source.dussan.org Git - archiva.git/blob

   1 package org.apache.archiva.repository.metadata;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  *   http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22 import org.apache.archiva.checksum.ChecksumAlgorithm;
  23 import org.apache.archiva.checksum.ChecksummedFile;
  24 import org.apache.archiva.common.utils.FileUtils;
  25 import org.apache.archiva.common.utils.PathUtil;
  26 import org.apache.archiva.common.utils.VersionComparator;
  27 import org.apache.archiva.common.utils.VersionUtil;
  28 import org.apache.archiva.configuration.ArchivaConfiguration;
  29 import org.apache.archiva.configuration.ConfigurationNames;
  30 import org.apache.archiva.configuration.FileTypes;
  31 import org.apache.archiva.configuration.ProxyConnectorConfiguration;
  32 import org.apache.archiva.maven2.metadata.MavenMetadataReader;
  33 import org.apache.archiva.model.ArchivaRepositoryMetadata;
  34 import org.apache.archiva.model.ArtifactReference;
  35 import org.apache.archiva.model.Plugin;
  36 import org.apache.archiva.model.ProjectReference;
  37 import org.apache.archiva.model.SnapshotVersion;
  38 import org.apache.archiva.model.VersionedReference;
  39 import org.apache.archiva.redback.components.registry.Registry;
  40 import org.apache.archiva.redback.components.registry.RegistryListener;
  41 import org.apache.archiva.repository.ContentNotFoundException;
  42 import org.apache.archiva.repository.LayoutException;
  43 import org.apache.archiva.repository.ManagedRepositoryContent;
  44 import org.apache.archiva.repository.RemoteRepositoryContent;
  45 import org.apache.archiva.xml.XMLException;
  46 import org.apache.commons.collections.CollectionUtils;
  47 import org.apache.commons.lang.StringUtils;
  48 import org.apache.commons.lang.math.NumberUtils;
  49 import org.apache.commons.lang.time.DateUtils;
  50 import org.slf4j.Logger;
  51 import org.slf4j.LoggerFactory;
  52 import org.springframework.stereotype.Service;
  53
  54 import javax.annotation.PostConstruct;
  55 import javax.inject.Inject;
  56 import javax.inject.Named;
  57 import java.io.IOException;
  58 import java.nio.file.Files;
  59 import java.nio.file.Path;
  60 import java.nio.file.Paths;
  61 import java.text.ParseException;
  62 import java.text.SimpleDateFormat;
  63 import java.util.ArrayList;
  64 import java.util.Arrays;
  65 import java.util.Calendar;
  66 import java.util.Collection;
  67 import java.util.Collections;
  68 import java.util.Date;
  69 import java.util.HashMap;
  70 import java.util.HashSet;
  71 import java.util.Iterator;
  72 import java.util.LinkedHashSet;
  73 import java.util.List;
  74 import java.util.Map;
  75 import java.util.Set;
  76 import java.util.regex.Matcher;
  77 import java.util.stream.Stream;
  78
  79 /**
  80  * MetadataTools
  81  *
  82  *
  83  */
  84 @Service( "metadataTools#default" )
  85 public class MetadataTools
  86     implements RegistryListener
  87 {
  88     private Logger log = LoggerFactory.getLogger( getClass() );
  89
  90     public static final String MAVEN_METADATA = "maven-metadata.xml";
  91
  92     public static final String MAVEN_ARCHETYPE_CATALOG ="archetype-catalog.xml";
  93
  94     private static final char PATH_SEPARATOR = '/';
  95
  96     private static final char GROUP_SEPARATOR = '.';
  97
  98     /**
  99      *
 100      */
 101     @Inject
 102     @Named( value = "archivaConfiguration#default" )
 103     private ArchivaConfiguration configuration;
 104
 105     /**
 106      *
 107      */
 108     @Inject
 109     @Named( value = "fileTypes" )
 110     private FileTypes filetypes;
 111
 112     private List<ChecksumAlgorithm> algorithms = Arrays.asList(ChecksumAlgorithm.SHA256, ChecksumAlgorithm.SHA1, ChecksumAlgorithm.MD5 );
 113
 114     private List<String> artifactPatterns;
 115
 116     private Map<String, Set<String>> proxies;
 117
 118     private static final char NUMS[] = new char[]{ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
 119
 120     private SimpleDateFormat lastUpdatedFormat;
 121
 122     public MetadataTools()
 123     {
 124         lastUpdatedFormat = new SimpleDateFormat( "yyyyMMddHHmmss" );
 125         lastUpdatedFormat.setTimeZone( DateUtils.UTC_TIME_ZONE );
 126     }
 127
 128     @Override
 129     public void afterConfigurationChange( Registry registry, String propertyName, Object propertyValue )
 130     {
 131         if ( ConfigurationNames.isProxyConnector( propertyName ) )
 132         {
 133             initConfigVariables();
 134         }
 135     }
 136
 137     @Override
 138     public void beforeConfigurationChange( Registry registry, String propertyName, Object propertyValue )
 139     {
 140         /* nothing to do */
 141     }
 142
 143     /**
 144      * Gather the set of snapshot versions found in a particular versioned reference.
 145      *
 146      * @return the Set of snapshot artifact versions found.
 147      * @throws LayoutException
 148      * @throws ContentNotFoundException
 149      */
 150     public Set<String> gatherSnapshotVersions( ManagedRepositoryContent managedRepository,
 151                                                VersionedReference reference )
 152         throws LayoutException, IOException, ContentNotFoundException
 153     {
 154         Set<String> foundVersions = managedRepository.getVersions( reference );
 155
 156         // Next gather up the referenced 'latest' versions found in any proxied repositories
 157         // maven-metadata-${proxyId}.xml files that may be present.
 158
 159         // Does this repository have a set of remote proxied repositories?
 160         Set<String> proxiedRepoIds = this.proxies.get( managedRepository.getId() );
 161
 162         if ( CollectionUtils.isNotEmpty( proxiedRepoIds ) )
 163         {
 164             String baseVersion = VersionUtil.getBaseVersion( reference.getVersion() );
 165             baseVersion = baseVersion.substring( 0, baseVersion.indexOf( VersionUtil.SNAPSHOT ) - 1 );
 166
 167             // Add in the proxied repo version ids too.
 168             Iterator<String> it = proxiedRepoIds.iterator();
 169             while ( it.hasNext() )
 170             {
 171                 String proxyId = it.next();
 172
 173                 ArchivaRepositoryMetadata proxyMetadata = readProxyMetadata( managedRepository, reference, proxyId );
 174                 if ( proxyMetadata == null )
 175                 {
 176                     // There is no proxy metadata, skip it.
 177                     continue;
 178                 }
 179
 180                 // Is there some snapshot info?
 181                 SnapshotVersion snapshot = proxyMetadata.getSnapshotVersion();
 182                 if ( snapshot != null )
 183                 {
 184                     String timestamp = snapshot.getTimestamp();
 185                     int buildNumber = snapshot.getBuildNumber();
 186
 187                     // Only interested in the timestamp + buildnumber.
 188                     if ( StringUtils.isNotBlank( timestamp ) && ( buildNumber > 0 ) )
 189                     {
 190                         foundVersions.add( baseVersion + "-" + timestamp + "-" + buildNumber );
 191                     }
 192                 }
 193             }
 194         }
 195
 196         return foundVersions;
 197     }
 198
 199     /**
 200      * Take a path to a maven-metadata.xml, and attempt to translate it to a VersionedReference.
 201      *
 202      * @param path
 203      * @return
 204      */
 205     public VersionedReference toVersionedReference( String path )
 206         throws RepositoryMetadataException
 207     {
 208         if ( !path.endsWith( "/" + MAVEN_METADATA ) )
 209         {
 210             throw new RepositoryMetadataException( "Cannot convert to versioned reference, not a metadata file. " );
 211         }
 212
 213         VersionedReference reference = new VersionedReference();
 214
 215         String normalizedPath = StringUtils.replace( path, "\\", "/" );
 216         String pathParts[] = StringUtils.split( normalizedPath, '/' );
 217
 218         int versionOffset = pathParts.length - 2;
 219         int artifactIdOffset = versionOffset - 1;
 220         int groupIdEnd = artifactIdOffset - 1;
 221
 222         reference.setVersion( pathParts[versionOffset] );
 223
 224         if ( !hasNumberAnywhere( reference.getVersion() ) )
 225         {
 226             // Scary check, but without it, all paths are version references;
 227             throw new RepositoryMetadataException(
 228                 "Not a versioned reference, as version id on path has no number in it." );
 229         }
 230
 231         reference.setArtifactId( pathParts[artifactIdOffset] );
 232
 233         StringBuilder gid = new StringBuilder();
 234         for ( int i = 0; i <= groupIdEnd; i++ )
 235         {
 236             if ( i > 0 )
 237             {
 238                 gid.append( "." );
 239             }
 240             gid.append( pathParts[i] );
 241         }
 242
 243         reference.setGroupId( gid.toString() );
 244
 245         return reference;
 246     }
 247
 248     private boolean hasNumberAnywhere( String version )
 249     {
 250         return StringUtils.indexOfAny( version, NUMS ) != ( -1 );
 251     }
 252
 253     public ProjectReference toProjectReference( String path )
 254         throws RepositoryMetadataException
 255     {
 256         if ( !path.endsWith( "/" + MAVEN_METADATA ) )
 257         {
 258             throw new RepositoryMetadataException( "Cannot convert to versioned reference, not a metadata file. " );
 259         }
 260
 261         ProjectReference reference = new ProjectReference();
 262
 263         String normalizedPath = StringUtils.replace( path, "\\", "/" );
 264         String pathParts[] = StringUtils.split( normalizedPath, '/' );
 265
 266         // Assume last part of the path is the version.
 267
 268         int artifactIdOffset = pathParts.length - 2;
 269         int groupIdEnd = artifactIdOffset - 1;
 270
 271         reference.setArtifactId( pathParts[artifactIdOffset] );
 272
 273         StringBuilder gid = new StringBuilder();
 274         for ( int i = 0; i <= groupIdEnd; i++ )
 275         {
 276             if ( i > 0 )
 277             {
 278                 gid.append( "." );
 279             }
 280             gid.append( pathParts[i] );
 281         }
 282
 283         reference.setGroupId( gid.toString() );
 284
 285         return reference;
 286     }
 287
 288     public String toPath( ProjectReference reference )
 289     {
 290         StringBuilder path = new StringBuilder();
 291
 292         path.append( formatAsDirectory( reference.getGroupId() ) ).append( PATH_SEPARATOR );
 293         path.append( reference.getArtifactId() ).append( PATH_SEPARATOR );
 294         path.append( MAVEN_METADATA );
 295
 296         return path.toString();
 297     }
 298
 299     public String toPath( VersionedReference reference )
 300     {
 301         StringBuilder path = new StringBuilder();
 302
 303         path.append( formatAsDirectory( reference.getGroupId() ) ).append( PATH_SEPARATOR );
 304         path.append( reference.getArtifactId() ).append( PATH_SEPARATOR );
 305         if ( reference.getVersion() != null )
 306         {
 307             // add the version only if it is present
 308             path.append( VersionUtil.getBaseVersion( reference.getVersion() ) ).append( PATH_SEPARATOR );
 309         }
 310         path.append( MAVEN_METADATA );
 311
 312         return path.toString();
 313     }
 314
 315     private String formatAsDirectory( String directory )
 316     {
 317         return directory.replace( GROUP_SEPARATOR, PATH_SEPARATOR );
 318     }
 319
 320     /**
 321      * Adjusts a path for a metadata.xml file to its repository specific path.
 322      *
 323      * @param repository the repository to base new path off of.
 324      * @param path       the path to the metadata.xml file to adjust the name of.
 325      * @return the newly adjusted path reference to the repository specific metadata path.
 326      */
 327     public String getRepositorySpecificName( RemoteRepositoryContent repository, String path )
 328     {
 329         return getRepositorySpecificName( repository.getId(), path );
 330     }
 331
 332     /**
 333      * Adjusts a path for a metadata.xml file to its repository specific path.
 334      *
 335      * @param proxyId the repository id to base new path off of.
 336      * @param path    the path to the metadata.xml file to adjust the name of.
 337      * @return the newly adjusted path reference to the repository specific metadata path.
 338      */
 339     public String getRepositorySpecificName( String proxyId, String path )
 340     {
 341         StringBuilder ret = new StringBuilder();
 342
 343         int idx = path.lastIndexOf( '/' );
 344         if ( idx > 0 )
 345         {
 346             ret.append( path.substring( 0, idx + 1 ) );
 347         }
 348
 349         // TODO: need to filter out 'bad' characters from the proxy id.
 350         ret.append( "maven-metadata-" ).append( proxyId ).append( ".xml" );
 351
 352         return ret.toString();
 353     }
 354
 355     @PostConstruct
 356     public void initialize()
 357     {
 358         this.artifactPatterns = new ArrayList<>();
 359         this.proxies = new HashMap<>();
 360         initConfigVariables();
 361
 362         configuration.addChangeListener( this );
 363     }
 364
 365     public ArchivaRepositoryMetadata readProxyMetadata( ManagedRepositoryContent managedRepository,
 366                                                         ProjectReference reference, String proxyId )
 367     {
 368         String metadataPath = getRepositorySpecificName( proxyId, toPath( reference ) );
 369         Path metadataFile = Paths.get( managedRepository.getRepoRoot(), metadataPath );
 370
 371         if ( !Files.exists(metadataFile) || !Files.isRegularFile( metadataFile ))
 372         {
 373             // Nothing to do. return null.
 374             return null;
 375         }
 376
 377         try
 378         {
 379             return MavenMetadataReader.read( metadataFile );
 380         }
 381         catch ( XMLException e )
 382         {
 383             // TODO: [monitor] consider a monitor for this event.
 384             // TODO: consider a read-redo on monitor return code?
 385             log.warn( "Unable to read metadata: {}", metadataFile.toAbsolutePath(), e );
 386             return null;
 387         }
 388     }
 389
 390     public ArchivaRepositoryMetadata readProxyMetadata( ManagedRepositoryContent managedRepository,
 391                                                         String logicalResource, String proxyId )
 392     {
 393         String metadataPath = getRepositorySpecificName( proxyId, logicalResource );
 394         Path metadataFile = Paths.get( managedRepository.getRepoRoot(), metadataPath );
 395
 396         if ( !Files.exists(metadataFile) || !Files.isRegularFile( metadataFile))
 397         {
 398             // Nothing to do. return null.
 399             return null;
 400         }
 401
 402         try
 403         {
 404             return MavenMetadataReader.read( metadataFile );
 405         }
 406         catch ( XMLException e )
 407         {
 408             // TODO: [monitor] consider a monitor for this event.
 409             // TODO: consider a read-redo on monitor return code?
 410             log.warn( "Unable to read metadata: {}", metadataFile.toAbsolutePath(), e );
 411             return null;
 412         }
 413     }
 414
 415     public ArchivaRepositoryMetadata readProxyMetadata( ManagedRepositoryContent managedRepository,
 416                                                         VersionedReference reference, String proxyId )
 417     {
 418         String metadataPath = getRepositorySpecificName( proxyId, toPath( reference ) );
 419         Path metadataFile = Paths.get( managedRepository.getRepoRoot(), metadataPath );
 420
 421         if ( !Files.exists(metadataFile) || !Files.isRegularFile(metadataFile))
 422         {
 423             // Nothing to do. return null.
 424             return null;
 425         }
 426
 427         try
 428         {
 429             return MavenMetadataReader.read( metadataFile );
 430         }
 431         catch ( XMLException e )
 432         {
 433             // TODO: [monitor] consider a monitor for this event.
 434             // TODO: consider a read-redo on monitor return code?
 435             log.warn( "Unable to read metadata: {}", metadataFile.toAbsolutePath(), e );
 436             return null;
 437         }
 438     }
 439
 440     public void updateMetadata( ManagedRepositoryContent managedRepository, String logicalResource )
 441         throws RepositoryMetadataException
 442     {
 443         final Path metadataFile = Paths.get( managedRepository.getRepoRoot(), logicalResource );
 444         ArchivaRepositoryMetadata metadata = null;
 445
 446         //Gather and merge all metadata available
 447         List<ArchivaRepositoryMetadata> metadatas =
 448             getMetadatasForManagedRepository( managedRepository, logicalResource );
 449         for ( ArchivaRepositoryMetadata proxiedMetadata : metadatas )
 450         {
 451             if ( metadata == null )
 452             {
 453                 metadata = proxiedMetadata;
 454                 continue;
 455             }
 456             metadata = RepositoryMetadataMerge.merge( metadata, proxiedMetadata );
 457         }
 458
 459         if ( metadata == null )
 460         {
 461             log.debug( "No metadata to update for {}", logicalResource );
 462             return;
 463         }
 464
 465         Set<String> availableVersions = new HashSet<String>();
 466         List<String> metadataAvailableVersions = metadata.getAvailableVersions();
 467         if ( metadataAvailableVersions != null )
 468         {
 469             availableVersions.addAll( metadataAvailableVersions );
 470         }
 471         availableVersions = findPossibleVersions( availableVersions, metadataFile.getParent() );
 472
 473         if ( availableVersions.size() > 0 )
 474         {
 475             updateMetadataVersions( availableVersions, metadata );
 476         }
 477
 478         RepositoryMetadataWriter.write( metadata, metadataFile );
 479
 480         ChecksummedFile checksum = new ChecksummedFile( metadataFile );
 481         checksum.fixChecksums( algorithms );
 482     }
 483
 484     /**
 485      * Skims the parent directory of a metadata in vain hope of finding
 486      * subdirectories that contain poms.
 487      *
 488      * @param metadataParentDirectory
 489      * @return origional set plus newly found versions
 490      */
 491     private Set<String> findPossibleVersions( Set<String> versions, Path metadataParentDirectory )
 492     {
 493
 494         Set<String> result = new HashSet<String>( versions );
 495
 496         try (Stream<Path> stream = Files.list( metadataParentDirectory )) {
 497             stream.filter( Files::isDirectory ).filter(
 498                 p ->
 499                 {
 500                     try(Stream<Path> substream = Files.list(p))
 501                     {
 502                         return substream.anyMatch( f -> Files.isRegularFile( f ) && f.toString().endsWith( ".pom" ));
 503                     }
 504                     catch ( IOException e )
 505                     {
 506                         return false;
 507                     }
 508                 }
 509             ).forEach(
 510                 p -> result.add(p.getFileName().toString())
 511             );
 512         } catch (IOException e) {
 513             //
 514         }
 515         return result;
 516     }
 517
 518     private List<ArchivaRepositoryMetadata> getMetadatasForManagedRepository(
 519         ManagedRepositoryContent managedRepository, String logicalResource )
 520     {
 521         List<ArchivaRepositoryMetadata> metadatas = new ArrayList<>();
 522         Path file = Paths.get( managedRepository.getRepoRoot(), logicalResource );
 523         if ( Files.exists(file) )
 524         {
 525             try
 526             {
 527                 ArchivaRepositoryMetadata existingMetadata = MavenMetadataReader.read( file );
 528                 if ( existingMetadata != null )
 529                 {
 530                     metadatas.add( existingMetadata );
 531                 }
 532             }
 533             catch ( XMLException e )
 534             {
 535                 log.debug( "Could not read metadata at {}. Metadata will be removed.", file.toAbsolutePath() );
 536                 FileUtils.deleteQuietly( file );
 537             }
 538         }
 539
 540         Set<String> proxyIds = proxies.get( managedRepository.getId() );
 541         if ( proxyIds != null )
 542         {
 543             for ( String proxyId : proxyIds )
 544             {
 545                 ArchivaRepositoryMetadata proxyMetadata =
 546                     readProxyMetadata( managedRepository, logicalResource, proxyId );
 547                 if ( proxyMetadata != null )
 548                 {
 549                     metadatas.add( proxyMetadata );
 550                 }
 551             }
 552         }
 553
 554         return metadatas;
 555     }
 556
 557
 558     /**
 559      * Update the metadata to represent the all versions/plugins of
 560      * the provided groupId:artifactId project or group reference,
 561      * based off of information present in the repository,
 562      * the maven-metadata.xml files, and the proxy/repository specific
 563      * metadata file contents.
 564      * <p>
 565      * We must treat this as a group or a project metadata file as there is no way to know in advance
 566      *
 567      * @param managedRepository the managed repository where the metadata is kept.
 568      * @param reference         the reference to update.
 569      * @throws LayoutException
 570      * @throws RepositoryMetadataException
 571      * @throws IOException
 572      * @throws ContentNotFoundException
 573      * @deprecated
 574      */
 575     public void updateMetadata( ManagedRepositoryContent managedRepository, ProjectReference reference )
 576         throws LayoutException, RepositoryMetadataException, IOException, ContentNotFoundException
 577     {
 578         Path metadataFile = Paths.get( managedRepository.getRepoRoot(), toPath( reference ) );
 579
 580         long lastUpdated = getExistingLastUpdated( metadataFile );
 581
 582         ArchivaRepositoryMetadata metadata = new ArchivaRepositoryMetadata();
 583         metadata.setGroupId( reference.getGroupId() );
 584         metadata.setArtifactId( reference.getArtifactId() );
 585
 586         // Gather up all versions found in the managed repository.
 587         Set<String> allVersions = managedRepository.getVersions( reference );
 588
 589         // Gather up all plugins found in the managed repository.
 590         // TODO: do we know this information instead?
 591 //        Set<Plugin> allPlugins = managedRepository.getPlugins( reference );
 592         Set<Plugin> allPlugins;
 593         if ( Files.exists(metadataFile))
 594         {
 595             try
 596             {
 597                 allPlugins = new LinkedHashSet<Plugin>( MavenMetadataReader.read( metadataFile ).getPlugins() );
 598             }
 599             catch ( XMLException e )
 600             {
 601                 throw new RepositoryMetadataException( e.getMessage(), e );
 602             }
 603         }
 604         else
 605         {
 606             allPlugins = new LinkedHashSet<Plugin>();
 607         }
 608
 609         // Does this repository have a set of remote proxied repositories?
 610         Set<String> proxiedRepoIds = this.proxies.get( managedRepository.getId() );
 611
 612         if ( CollectionUtils.isNotEmpty( proxiedRepoIds ) )
 613         {
 614             // Add in the proxied repo version ids too.
 615             Iterator<String> it = proxiedRepoIds.iterator();
 616             while ( it.hasNext() )
 617             {
 618                 String proxyId = it.next();
 619
 620                 ArchivaRepositoryMetadata proxyMetadata = readProxyMetadata( managedRepository, reference, proxyId );
 621                 if ( proxyMetadata != null )
 622                 {
 623                     allVersions.addAll( proxyMetadata.getAvailableVersions() );
 624                     allPlugins.addAll( proxyMetadata.getPlugins() );
 625                     long proxyLastUpdated = getLastUpdated( proxyMetadata );
 626
 627                     lastUpdated = Math.max( lastUpdated, proxyLastUpdated );
 628                 }
 629             }
 630         }
 631
 632         if ( !allVersions.isEmpty() )
 633         {
 634             updateMetadataVersions( allVersions, metadata );
 635         }
 636         else
 637         {
 638             // Add the plugins to the metadata model.
 639             metadata.setPlugins( new ArrayList<>( allPlugins ) );
 640
 641             // artifact ID was actually the last part of the group
 642             metadata.setGroupId( metadata.getGroupId() + "." + metadata.getArtifactId() );
 643             metadata.setArtifactId( null );
 644         }
 645
 646         if ( lastUpdated > 0 )
 647         {
 648             metadata.setLastUpdatedTimestamp( toLastUpdatedDate( lastUpdated ) );
 649         }
 650
 651         // Save the metadata model to disk.
 652         RepositoryMetadataWriter.write( metadata, metadataFile );
 653         ChecksummedFile checksum = new ChecksummedFile( metadataFile );
 654         checksum.fixChecksums( algorithms );
 655     }
 656
 657     private void updateMetadataVersions( Collection<String> allVersions, ArchivaRepositoryMetadata metadata )
 658     {
 659         // Sort the versions
 660         List<String> sortedVersions = new ArrayList<>( allVersions );
 661         Collections.sort( sortedVersions, VersionComparator.getInstance() );
 662
 663         // Split the versions into released and snapshots.
 664         List<String> releasedVersions = new ArrayList<>();
 665         List<String> snapshotVersions = new ArrayList<>();
 666
 667         for ( String version : sortedVersions )
 668         {
 669             if ( VersionUtil.isSnapshot( version ) )
 670             {
 671                 snapshotVersions.add( version );
 672             }
 673             else
 674             {
 675                 releasedVersions.add( version );
 676             }
 677         }
 678
 679         Collections.sort( releasedVersions, VersionComparator.getInstance() );
 680         Collections.sort( snapshotVersions, VersionComparator.getInstance() );
 681
 682         String latestVersion = sortedVersions.get( sortedVersions.size() - 1 );
 683         String releaseVersion = null;
 684
 685         if ( CollectionUtils.isNotEmpty( releasedVersions ) )
 686         {
 687             releaseVersion = releasedVersions.get( releasedVersions.size() - 1 );
 688         }
 689
 690         // Add the versions to the metadata model.
 691         metadata.setAvailableVersions( sortedVersions );
 692
 693         metadata.setLatestVersion( latestVersion );
 694         metadata.setReleasedVersion( releaseVersion );
 695     }
 696
 697     private Date toLastUpdatedDate( long lastUpdated )
 698     {
 699         Calendar cal = Calendar.getInstance( DateUtils.UTC_TIME_ZONE );
 700         cal.setTimeInMillis( lastUpdated );
 701
 702         return cal.getTime();
 703     }
 704
 705     private long toLastUpdatedLong( String timestampString )
 706     {
 707         try
 708         {
 709             Date date = lastUpdatedFormat.parse( timestampString );
 710             Calendar cal = Calendar.getInstance( DateUtils.UTC_TIME_ZONE );
 711             cal.setTime( date );
 712
 713             return cal.getTimeInMillis();
 714         }
 715         catch ( ParseException e )
 716         {
 717             return 0;
 718         }
 719     }
 720
 721     private long getLastUpdated( ArchivaRepositoryMetadata metadata )
 722     {
 723         if ( metadata == null )
 724         {
 725             // Doesn't exist.
 726             return 0;
 727         }
 728
 729         try
 730         {
 731             String lastUpdated = metadata.getLastUpdated();
 732             if ( StringUtils.isBlank( lastUpdated ) )
 733             {
 734                 // Not set.
 735                 return 0;
 736             }
 737
 738             Date lastUpdatedDate = lastUpdatedFormat.parse( lastUpdated );
 739             return lastUpdatedDate.getTime();
 740         }
 741         catch ( ParseException e )
 742         {
 743             // Bad format on the last updated string.
 744             return 0;
 745         }
 746     }
 747
 748     private long getExistingLastUpdated( Path metadataFile )
 749     {
 750         if ( !Files.exists(metadataFile) )
 751         {
 752             // Doesn't exist.
 753             return 0;
 754         }
 755
 756         try
 757         {
 758             ArchivaRepositoryMetadata metadata = MavenMetadataReader.read( metadataFile );
 759
 760             return getLastUpdated( metadata );
 761         }
 762         catch ( XMLException e )
 763         {
 764             // Error.
 765             return 0;
 766         }
 767     }
 768
 769     /**
 770      * Update the metadata based on the following rules.
 771      * <p>
 772      * 1) If this is a SNAPSHOT reference, then utilize the proxy/repository specific
 773      * metadata files to represent the current / latest SNAPSHOT available.
 774      * 2) If this is a RELEASE reference, and the metadata file does not exist, then
 775      * create the metadata file with contents required of the VersionedReference
 776      *
 777      * @param managedRepository the managed repository where the metadata is kept.
 778      * @param reference         the versioned reference to update
 779      * @throws LayoutException
 780      * @throws RepositoryMetadataException
 781      * @throws IOException
 782      * @throws ContentNotFoundException
 783      * @deprecated
 784      */
 785     public void updateMetadata( ManagedRepositoryContent managedRepository, VersionedReference reference )
 786         throws LayoutException, RepositoryMetadataException, IOException, ContentNotFoundException
 787     {
 788         Path metadataFile = Paths.get( managedRepository.getRepoRoot(), toPath( reference ) );
 789
 790         long lastUpdated = getExistingLastUpdated( metadataFile );
 791
 792         ArchivaRepositoryMetadata metadata = new ArchivaRepositoryMetadata();
 793         metadata.setGroupId( reference.getGroupId() );
 794         metadata.setArtifactId( reference.getArtifactId() );
 795
 796         if ( VersionUtil.isSnapshot( reference.getVersion() ) )
 797         {
 798             // Do SNAPSHOT handling.
 799             metadata.setVersion( VersionUtil.getBaseVersion( reference.getVersion() ) );
 800
 801             // Gather up all of the versions found in the reference dir, and any
 802             // proxied maven-metadata.xml files.
 803             Set<String> snapshotVersions = gatherSnapshotVersions( managedRepository, reference );
 804
 805             if ( snapshotVersions.isEmpty() )
 806             {
 807                 throw new ContentNotFoundException(
 808                     "No snapshot versions found on reference [" + VersionedReference.toKey( reference ) + "]." );
 809             }
 810
 811             // sort the list to determine to aide in determining the Latest version.
 812             List<String> sortedVersions = new ArrayList<>();
 813             sortedVersions.addAll( snapshotVersions );
 814             Collections.sort( sortedVersions, new VersionComparator() );
 815
 816             String latestVersion = sortedVersions.get( sortedVersions.size() - 1 );
 817
 818             if ( VersionUtil.isUniqueSnapshot( latestVersion ) )
 819             {
 820                 // The latestVersion will contain the full version string "1.0-alpha-5-20070821.213044-8"
 821                 // This needs to be broken down into ${base}-${timestamp}-${build_number}
 822
 823                 Matcher m = VersionUtil.UNIQUE_SNAPSHOT_PATTERN.matcher( latestVersion );
 824                 if ( m.matches() )
 825                 {
 826                     metadata.setSnapshotVersion( new SnapshotVersion() );
 827                     int buildNumber = NumberUtils.toInt( m.group( 3 ), -1 );
 828                     metadata.getSnapshotVersion().setBuildNumber( buildNumber );
 829
 830                     Matcher mtimestamp = VersionUtil.TIMESTAMP_PATTERN.matcher( m.group( 2 ) );
 831                     if ( mtimestamp.matches() )
 832                     {
 833                         String tsDate = mtimestamp.group( 1 );
 834                         String tsTime = mtimestamp.group( 2 );
 835
 836                         long snapshotLastUpdated = toLastUpdatedLong( tsDate + tsTime );
 837
 838                         lastUpdated = Math.max( lastUpdated, snapshotLastUpdated );
 839
 840                         metadata.getSnapshotVersion().setTimestamp( m.group( 2 ) );
 841                     }
 842                 }
 843             }
 844             else if ( VersionUtil.isGenericSnapshot( latestVersion ) )
 845             {
 846                 // The latestVersion ends with the generic version string.
 847                 // Example: 1.0-alpha-5-SNAPSHOT
 848
 849                 metadata.setSnapshotVersion( new SnapshotVersion() );
 850
 851                 /* Disabled due to decision in [MRM-535].
 852                  * Do not set metadata.lastUpdated to file.lastModified.
 853                  *
 854                  * Should this be the last updated timestamp of the file, or in the case of an
 855                  * archive, the most recent timestamp in the archive?
 856                  *
 857                 ArtifactReference artifact = getFirstArtifact( managedRepository, reference );
 858
 859                 if ( artifact == null )
 860                 {
 861                     throw new IOException( "Not snapshot artifact found to reference in " + reference );
 862                 }
 863
 864                 File artifactFile = managedRepository.toFile( artifact );
 865
 866                 if ( artifactFile.exists() )
 867                 {
 868                     Date lastModified = new Date( artifactFile.lastModified() );
 869                     metadata.setLastUpdatedTimestamp( lastModified );
 870                 }
 871                 */
 872             }
 873             else
 874             {
 875                 throw new RepositoryMetadataException(
 876                     "Unable to process snapshot version <" + latestVersion + "> reference <" + reference + ">" );
 877             }
 878         }
 879         else
 880         {
 881             // Do RELEASE handling.
 882             metadata.setVersion( reference.getVersion() );
 883         }
 884
 885         // Set last updated
 886         if ( lastUpdated > 0 )
 887         {
 888             metadata.setLastUpdatedTimestamp( toLastUpdatedDate( lastUpdated ) );
 889         }
 890
 891         // Save the metadata model to disk.
 892         RepositoryMetadataWriter.write( metadata, metadataFile );
 893         ChecksummedFile checksum = new ChecksummedFile( metadataFile );
 894         checksum.fixChecksums( algorithms );
 895     }
 896
 897     private void initConfigVariables()
 898     {
 899         synchronized ( this.artifactPatterns )
 900         {
 901             this.artifactPatterns.clear();
 902
 903             this.artifactPatterns.addAll( filetypes.getFileTypePatterns( FileTypes.ARTIFACTS ) );
 904         }
 905
 906         synchronized ( proxies )
 907         {
 908             this.proxies.clear();
 909
 910             List<ProxyConnectorConfiguration> proxyConfigs = configuration.getConfiguration().getProxyConnectors();
 911             for ( ProxyConnectorConfiguration proxyConfig : proxyConfigs )
 912             {
 913                 String key = proxyConfig.getSourceRepoId();
 914
 915                 Set<String> remoteRepoIds = this.proxies.get( key );
 916
 917                 if ( remoteRepoIds == null )
 918                 {
 919                     remoteRepoIds = new HashSet<String>();
 920                 }
 921
 922                 remoteRepoIds.add( proxyConfig.getTargetRepoId() );
 923
 924                 this.proxies.put( key, remoteRepoIds );
 925             }
 926         }
 927     }
 928
 929     /**
 930      * Get the first Artifact found in the provided VersionedReference location.
 931      *
 932      * @param managedRepository the repository to search within.
 933      * @param reference         the reference to the versioned reference to search within
 934      * @return the ArtifactReference to the first artifact located within the versioned reference. or null if
 935      *         no artifact was found within the versioned reference.
 936      * @throws IOException     if the versioned reference is invalid (example: doesn't exist, or isn't a directory)
 937      * @throws LayoutException
 938      */
 939     public ArtifactReference getFirstArtifact( ManagedRepositoryContent managedRepository,
 940                                                VersionedReference reference )
 941         throws LayoutException, IOException
 942     {
 943         String path = toPath( reference );
 944
 945         int idx = path.lastIndexOf( '/' );
 946         if ( idx > 0 )
 947         {
 948             path = path.substring( 0, idx );
 949         }
 950
 951         Path repoDir = Paths.get( managedRepository.getRepoRoot(), path );
 952
 953         if ( !Files.exists(repoDir))
 954         {
 955             throw new IOException( "Unable to gather the list of snapshot versions on a non-existant directory: "
 956                                        + repoDir.toAbsolutePath() );
 957         }
 958
 959         if ( !Files.isDirectory( repoDir ))
 960         {
 961             throw new IOException(
 962                 "Unable to gather the list of snapshot versions on a non-directory: " + repoDir.toAbsolutePath() );
 963         }
 964
 965         try(Stream<Path> stream = Files.list(repoDir)) {
 966             String result = stream.filter(  Files::isRegularFile ).map( path1 ->
 967                 PathUtil.getRelative( managedRepository.getRepoRoot(), path1 )
 968             ).filter( filetypes::matchesArtifactPattern ).findFirst().orElse( null );
 969             if (result!=null) {
 970                 return managedRepository.toArtifactReference( result );
 971             }
 972         }
 973         // No artifact was found.
 974         return null;
 975     }
 976
 977     public ArchivaConfiguration getConfiguration()
 978     {
 979         return configuration;
 980     }
 981
 982     public void setConfiguration( ArchivaConfiguration configuration )
 983     {
 984         this.configuration = configuration;
 985     }
 986
 987     public FileTypes getFiletypes()
 988     {
 989         return filetypes;
 990     }
 991
 992     public void setFiletypes( FileTypes filetypes )
 993     {
 994         this.filetypes = filetypes;
 995     }
 996 }