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

   1 package org.apache.archiva.metadata.repository.storage.maven2;
   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.admin.model.RepositoryAdminException;
  23 import org.apache.archiva.admin.model.beans.ManagedRepository;
  24 import org.apache.archiva.admin.model.beans.NetworkProxy;
  25 import org.apache.archiva.admin.model.beans.ProxyConnector;
  26 import org.apache.archiva.admin.model.beans.RemoteRepository;
  27 import org.apache.archiva.admin.model.managed.ManagedRepositoryAdmin;
  28 import org.apache.archiva.admin.model.networkproxy.NetworkProxyAdmin;
  29 import org.apache.archiva.admin.model.proxyconnector.ProxyConnectorAdmin;
  30 import org.apache.archiva.admin.model.remote.RemoteRepositoryAdmin;
  31 import org.apache.archiva.checksum.ChecksumAlgorithm;
  32 import org.apache.archiva.checksum.ChecksummedFile;
  33 import org.apache.archiva.common.utils.VersionUtil;
  34 import org.apache.archiva.maven2.metadata.MavenMetadataReader;
  35 import org.apache.archiva.metadata.model.ArtifactMetadata;
  36 import org.apache.archiva.metadata.model.ProjectMetadata;
  37 import org.apache.archiva.metadata.model.ProjectVersionMetadata;
  38 import org.apache.archiva.metadata.repository.filter.Filter;
  39 import org.apache.archiva.metadata.repository.storage.ReadMetadataRequest;
  40 import org.apache.archiva.metadata.repository.storage.RelocationException;
  41 import org.apache.archiva.metadata.repository.storage.RepositoryPathTranslator;
  42 import org.apache.archiva.metadata.repository.storage.RepositoryStorage;
  43 import org.apache.archiva.metadata.repository.storage.RepositoryStorageMetadataInvalidException;
  44 import org.apache.archiva.metadata.repository.storage.RepositoryStorageMetadataNotFoundException;
  45 import org.apache.archiva.metadata.repository.storage.RepositoryStorageRuntimeException;
  46 import org.apache.archiva.model.ArchivaRepositoryMetadata;
  47 import org.apache.archiva.model.ArtifactReference;
  48 import org.apache.archiva.model.SnapshotVersion;
  49 import org.apache.archiva.policies.ProxyDownloadException;
  50 import org.apache.archiva.proxy.common.WagonFactory;
  51 import org.apache.archiva.proxy.model.RepositoryProxyConnectors;
  52 import org.apache.archiva.reports.RepositoryProblemFacet;
  53 import org.apache.archiva.repository.ManagedRepositoryContent;
  54 import org.apache.archiva.repository.content.PathParser;
  55 import org.apache.archiva.repository.layout.LayoutException;
  56 import org.apache.archiva.xml.XMLException;
  57 import org.apache.commons.lang.ArrayUtils;
  58 import org.apache.commons.lang.StringUtils;
  59 import org.apache.maven.model.CiManagement;
  60 import org.apache.maven.model.Dependency;
  61 import org.apache.maven.model.DistributionManagement;
  62 import org.apache.maven.model.IssueManagement;
  63 import org.apache.maven.model.License;
  64 import org.apache.maven.model.MailingList;
  65 import org.apache.maven.model.Model;
  66 import org.apache.maven.model.Organization;
  67 import org.apache.maven.model.Relocation;
  68 import org.apache.maven.model.Scm;
  69 import org.apache.maven.model.building.DefaultModelBuilderFactory;
  70 import org.apache.maven.model.building.DefaultModelBuildingRequest;
  71 import org.apache.maven.model.building.ModelBuilder;
  72 import org.apache.maven.model.building.ModelBuildingException;
  73 import org.apache.maven.model.building.ModelBuildingRequest;
  74 import org.apache.maven.model.building.ModelProblem;
  75 import org.apache.maven.model.io.xpp3.MavenXpp3Reader;
  76 import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
  77 import org.slf4j.Logger;
  78 import org.slf4j.LoggerFactory;
  79 import org.springframework.context.ApplicationContext;
  80 import org.springframework.stereotype.Service;
  81
  82 import javax.annotation.PostConstruct;
  83 import javax.inject.Inject;
  84 import javax.inject.Named;
  85 import java.io.File;
  86 import java.io.FileNotFoundException;
  87 import java.io.FilenameFilter;
  88 import java.io.IOException;
  89 import java.io.Reader;
  90 import java.nio.charset.Charset;
  91 import java.nio.file.Files;
  92 import java.util.ArrayList;
  93 import java.util.Arrays;
  94 import java.util.Collection;
  95 import java.util.Collections;
  96 import java.util.Date;
  97 import java.util.HashMap;
  98 import java.util.List;
  99 import java.util.Map;
 100
 101 /**
 102  * Maven 2 repository format storage implementation. This class currently takes parameters to indicate the repository to
 103  * deal with rather than being instantiated per-repository.
 104  * FIXME: instantiate one per repository and allocate permanently from a factory (which can be obtained within the session).
 105  * <p>
 106  * The session is passed in as an argument to obtain any necessary resources, rather than the class being instantiated
 107  * within the session in the context of a single managed repository's resolution needs.
 108  * <p>
 109  */
 110 @Service( "repositoryStorage#maven2" )
 111 public class Maven2RepositoryStorage
 112     implements RepositoryStorage
 113 {
 114
 115     private static final Logger LOGGER = LoggerFactory.getLogger( Maven2RepositoryStorage.class );
 116
 117     private ModelBuilder builder;
 118
 119     @Inject
 120     private RemoteRepositoryAdmin remoteRepositoryAdmin;
 121
 122     @Inject
 123     private ManagedRepositoryAdmin managedRepositoryAdmin;
 124
 125     @Inject
 126     private ProxyConnectorAdmin proxyConnectorAdmin;
 127
 128     @Inject
 129     private NetworkProxyAdmin networkProxyAdmin;
 130
 131     @Inject
 132     @Named( "repositoryPathTranslator#maven2" )
 133     private RepositoryPathTranslator pathTranslator;
 134
 135     @Inject
 136     private WagonFactory wagonFactory;
 137
 138     @Inject
 139     private ApplicationContext applicationContext;
 140
 141     @Inject
 142     @Named( "pathParser#default" )
 143     private PathParser pathParser;
 144
 145     private static final String METADATA_FILENAME_START = "maven-metadata";
 146
 147     private static final String METADATA_FILENAME = METADATA_FILENAME_START + ".xml";
 148
 149     private static final MavenXpp3Reader MAVEN_XPP_3_READER = new MavenXpp3Reader();
 150
 151
 152     @PostConstruct
 153     public void initialize()
 154     {
 155         builder = new DefaultModelBuilderFactory().newInstance();
 156
 157     }
 158
 159     @Override
 160     public ProjectMetadata readProjectMetadata( String repoId, String namespace, String projectId )
 161     {
 162         // TODO: could natively implement the "shared model" concept from the browse action to avoid needing it there?
 163         return null;
 164     }
 165
 166     @Override
 167     public ProjectVersionMetadata readProjectVersionMetadata( ReadMetadataRequest readMetadataRequest )
 168         throws RepositoryStorageMetadataNotFoundException, RepositoryStorageMetadataInvalidException,
 169         RepositoryStorageRuntimeException
 170     {
 171         try
 172         {
 173             ManagedRepository managedRepository =
 174                 managedRepositoryAdmin.getManagedRepository( readMetadataRequest.getRepositoryId() );
 175             String artifactVersion = readMetadataRequest.getProjectVersion();
 176             // olamy: in case of browsing via the ui we can mix repos (parent of a SNAPSHOT can come from release repo)
 177             if ( !readMetadataRequest.isBrowsingRequest() )
 178             {
 179                 if ( VersionUtil.isSnapshot( artifactVersion ) )
 180                 {
 181                     // skygo trying to improve speed by honoring managed configuration MRM-1658
 182                     if ( managedRepository.isReleases() && !managedRepository.isSnapshots() )
 183                     {
 184                         throw new RepositoryStorageRuntimeException( "lookforsnaponreleaseonly",
 185                                                                      "managed repo is configured for release only" );
 186                     }
 187                 }
 188                 else
 189                 {
 190                     if ( !managedRepository.isReleases() && managedRepository.isSnapshots() )
 191                     {
 192                         throw new RepositoryStorageRuntimeException( "lookforsreleaseonsneponly",
 193                                                                      "managed repo is configured for snapshot only" );
 194                     }
 195                 }
 196             }
 197             File basedir = new File( managedRepository.getLocation() );
 198             if ( VersionUtil.isSnapshot( artifactVersion ) )
 199             {
 200                 File metadataFile = pathTranslator.toFile( basedir, readMetadataRequest.getNamespace(),
 201                                                            readMetadataRequest.getProjectId(), artifactVersion,
 202                                                            METADATA_FILENAME );
 203                 try
 204                 {
 205                     ArchivaRepositoryMetadata metadata = MavenMetadataReader.read( metadataFile );
 206
 207                     // re-adjust to timestamp if present, otherwise retain the original -SNAPSHOT filename
 208                     SnapshotVersion snapshotVersion = metadata.getSnapshotVersion();
 209                     if ( snapshotVersion != null )
 210                     {
 211                         artifactVersion =
 212                             artifactVersion.substring( 0, artifactVersion.length() - 8 ); // remove SNAPSHOT from end
 213                         artifactVersion =
 214                             artifactVersion + snapshotVersion.getTimestamp() + "-" + snapshotVersion.getBuildNumber();
 215                     }
 216                 }
 217                 catch ( XMLException e )
 218                 {
 219                     // unable to parse metadata - LOGGER it, and continue with the version as the original SNAPSHOT version
 220                     LOGGER.warn( "Invalid metadata: {} - {}", metadataFile, e.getMessage() );
 221                 }
 222             }
 223
 224             // TODO: won't work well with some other layouts, might need to convert artifact parts to ID by path translator
 225             String id = readMetadataRequest.getProjectId() + "-" + artifactVersion + ".pom";
 226             File file =
 227                 pathTranslator.toFile( basedir, readMetadataRequest.getNamespace(), readMetadataRequest.getProjectId(),
 228                                        readMetadataRequest.getProjectVersion(), id );
 229
 230             if ( !file.exists() )
 231             {
 232                 // metadata could not be resolved
 233                 throw new RepositoryStorageMetadataNotFoundException(
 234                     "The artifact's POM file '" + file.getAbsolutePath() + "' was missing" );
 235             }
 236
 237             // TODO: this is a workaround until we can properly resolve using proxies as well - this doesn't cache
 238             //       anything locally!
 239             List<RemoteRepository> remoteRepositories = new ArrayList<>();
 240             Map<String, NetworkProxy> networkProxies = new HashMap<>();
 241
 242             Map<String, List<ProxyConnector>> proxyConnectorsMap = proxyConnectorAdmin.getProxyConnectorAsMap();
 243             List<ProxyConnector> proxyConnectors = proxyConnectorsMap.get( readMetadataRequest.getRepositoryId() );
 244             if ( proxyConnectors != null )
 245             {
 246                 for ( ProxyConnector proxyConnector : proxyConnectors )
 247                 {
 248                     RemoteRepository remoteRepoConfig =
 249                         remoteRepositoryAdmin.getRemoteRepository( proxyConnector.getTargetRepoId() );
 250
 251                     if ( remoteRepoConfig != null )
 252                     {
 253                         remoteRepositories.add( remoteRepoConfig );
 254
 255                         NetworkProxy networkProxyConfig =
 256                             networkProxyAdmin.getNetworkProxy( proxyConnector.getProxyId() );
 257
 258                         if ( networkProxyConfig != null )
 259                         {
 260                             // key/value: remote repo ID/proxy info
 261                             networkProxies.put( proxyConnector.getTargetRepoId(), networkProxyConfig );
 262                         }
 263                     }
 264                 }
 265             }
 266
 267             // That's a browsing request so we can a mix of SNAPSHOT and release artifacts (especially with snapshots which
 268             // can have released parent pom
 269             if ( readMetadataRequest.isBrowsingRequest() )
 270             {
 271                 remoteRepositories.addAll( remoteRepositoryAdmin.getRemoteRepositories() );
 272             }
 273
 274             ModelBuildingRequest req =
 275                 new DefaultModelBuildingRequest().setProcessPlugins( false ).setPomFile( file ).setTwoPhaseBuilding(
 276                     false ).setValidationLevel( ModelBuildingRequest.VALIDATION_LEVEL_MINIMAL );
 277
 278             //MRM-1607. olamy this will resolve jdk profiles on the current running archiva jvm
 279             req.setSystemProperties( System.getProperties() );
 280
 281             // MRM-1411
 282             req.setModelResolver(
 283                 new RepositoryModelResolver( managedRepository, pathTranslator, wagonFactory, remoteRepositories,
 284                                              networkProxies, managedRepository ) );
 285
 286             Model model;
 287             try
 288             {
 289                 model = builder.build( req ).getEffectiveModel();
 290             }
 291             catch ( ModelBuildingException e )
 292             {
 293                 String msg = "The artifact's POM file '" + file + "' was invalid: " + e.getMessage();
 294
 295                 List<ModelProblem> modelProblems = e.getProblems();
 296                 for ( ModelProblem problem : modelProblems )
 297                 {
 298                     // MRM-1411, related to MRM-1335
 299                     // this means that the problem was that the parent wasn't resolved!
 300                     // olamy really hackhish but fail with java profile so use error message
 301                     // || ( StringUtils.startsWith( problem.getMessage(), "Failed to determine Java version for profile" ) )
 302                     // but setTwoPhaseBuilding(true) fix that
 303                     if ( ( problem.getException() instanceof FileNotFoundException && e.getModelId() != null &&
 304                         !e.getModelId().equals( problem.getModelId() ) ) )
 305                     {
 306                         LOGGER.warn( "The artifact's parent POM file '{}' cannot be resolved. "
 307                                          + "Using defaults for project version metadata..", file );
 308
 309                         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 310                         metadata.setId( readMetadataRequest.getProjectVersion() );
 311
 312                         MavenProjectFacet facet = new MavenProjectFacet();
 313                         facet.setGroupId( readMetadataRequest.getNamespace() );
 314                         facet.setArtifactId( readMetadataRequest.getProjectId() );
 315                         facet.setPackaging( "jar" );
 316                         metadata.addFacet( facet );
 317
 318                         String errMsg =
 319                             "Error in resolving artifact's parent POM file. " + ( problem.getException() == null
 320                                 ? problem.getMessage()
 321                                 : problem.getException().getMessage() );
 322                         RepositoryProblemFacet repoProblemFacet = new RepositoryProblemFacet();
 323                         repoProblemFacet.setRepositoryId( readMetadataRequest.getRepositoryId() );
 324                         repoProblemFacet.setId( readMetadataRequest.getRepositoryId() );
 325                         repoProblemFacet.setMessage( errMsg );
 326                         repoProblemFacet.setProblem( errMsg );
 327                         repoProblemFacet.setProject( readMetadataRequest.getProjectId() );
 328                         repoProblemFacet.setVersion( readMetadataRequest.getProjectVersion() );
 329                         repoProblemFacet.setNamespace( readMetadataRequest.getNamespace() );
 330
 331                         metadata.addFacet( repoProblemFacet );
 332
 333                         return metadata;
 334                     }
 335                 }
 336
 337                 throw new RepositoryStorageMetadataInvalidException( "invalid-pom", msg, e );
 338             }
 339
 340             // Check if the POM is in the correct location
 341             boolean correctGroupId = readMetadataRequest.getNamespace().equals( model.getGroupId() );
 342             boolean correctArtifactId = readMetadataRequest.getProjectId().equals( model.getArtifactId() );
 343             boolean correctVersion = readMetadataRequest.getProjectVersion().equals( model.getVersion() );
 344             if ( !correctGroupId || !correctArtifactId || !correctVersion )
 345             {
 346                 StringBuilder message = new StringBuilder( "Incorrect POM coordinates in '" + file + "':" );
 347                 if ( !correctGroupId )
 348                 {
 349                     message.append( "\nIncorrect group ID: " ).append( model.getGroupId() );
 350                 }
 351                 if ( !correctArtifactId )
 352                 {
 353                     message.append( "\nIncorrect artifact ID: " ).append( model.getArtifactId() );
 354                 }
 355                 if ( !correctVersion )
 356                 {
 357                     message.append( "\nIncorrect version: " ).append( model.getVersion() );
 358                 }
 359
 360                 throw new RepositoryStorageMetadataInvalidException( "mislocated-pom", message.toString() );
 361             }
 362
 363             ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 364             metadata.setCiManagement( convertCiManagement( model.getCiManagement() ) );
 365             metadata.setDescription( model.getDescription() );
 366             metadata.setId( readMetadataRequest.getProjectVersion() );
 367             metadata.setIssueManagement( convertIssueManagement( model.getIssueManagement() ) );
 368             metadata.setLicenses( convertLicenses( model.getLicenses() ) );
 369             metadata.setMailingLists( convertMailingLists( model.getMailingLists() ) );
 370             metadata.setDependencies( convertDependencies( model.getDependencies() ) );
 371             metadata.setName( model.getName() );
 372             metadata.setOrganization( convertOrganization( model.getOrganization() ) );
 373             metadata.setScm( convertScm( model.getScm() ) );
 374             metadata.setUrl( model.getUrl() );
 375
 376             MavenProjectFacet facet = new MavenProjectFacet();
 377             facet.setGroupId( model.getGroupId() != null ? model.getGroupId() : model.getParent().getGroupId() );
 378             facet.setArtifactId( model.getArtifactId() );
 379             facet.setPackaging( model.getPackaging() );
 380             if ( model.getParent() != null )
 381             {
 382                 MavenProjectParent parent = new MavenProjectParent();
 383                 parent.setGroupId( model.getParent().getGroupId() );
 384                 parent.setArtifactId( model.getParent().getArtifactId() );
 385                 parent.setVersion( model.getParent().getVersion() );
 386                 facet.setParent( parent );
 387             }
 388             metadata.addFacet( facet );
 389
 390             return metadata;
 391         }
 392         catch ( RepositoryAdminException e )
 393         {
 394             throw new RepositoryStorageRuntimeException( "repo-admin", e.getMessage(), e );
 395         }
 396     }
 397
 398     public void setWagonFactory( WagonFactory wagonFactory )
 399     {
 400         this.wagonFactory = wagonFactory;
 401     }
 402
 403     private List<org.apache.archiva.metadata.model.Dependency> convertDependencies( List<Dependency> dependencies )
 404     {
 405         List<org.apache.archiva.metadata.model.Dependency> l =
 406             new ArrayList<>();
 407         for ( Dependency dependency : dependencies )
 408         {
 409             org.apache.archiva.metadata.model.Dependency newDependency =
 410                 new org.apache.archiva.metadata.model.Dependency();
 411             newDependency.setArtifactId( dependency.getArtifactId() );
 412             newDependency.setClassifier( dependency.getClassifier() );
 413             newDependency.setGroupId( dependency.getGroupId() );
 414             newDependency.setOptional( dependency.isOptional() );
 415             newDependency.setScope( dependency.getScope() );
 416             newDependency.setSystemPath( dependency.getSystemPath() );
 417             newDependency.setType( dependency.getType() );
 418             newDependency.setVersion( dependency.getVersion() );
 419             l.add( newDependency );
 420         }
 421         return l;
 422     }
 423
 424     private org.apache.archiva.metadata.model.Scm convertScm( Scm scm )
 425     {
 426         org.apache.archiva.metadata.model.Scm newScm = null;
 427         if ( scm != null )
 428         {
 429             newScm = new org.apache.archiva.metadata.model.Scm();
 430             newScm.setConnection( scm.getConnection() );
 431             newScm.setDeveloperConnection( scm.getDeveloperConnection() );
 432             newScm.setUrl( scm.getUrl() );
 433         }
 434         return newScm;
 435     }
 436
 437     private org.apache.archiva.metadata.model.Organization convertOrganization( Organization organization )
 438     {
 439         org.apache.archiva.metadata.model.Organization org = null;
 440         if ( organization != null )
 441         {
 442             org = new org.apache.archiva.metadata.model.Organization();
 443             org.setName( organization.getName() );
 444             org.setUrl( organization.getUrl() );
 445         }
 446         return org;
 447     }
 448
 449     private List<org.apache.archiva.metadata.model.License> convertLicenses( List<License> licenses )
 450     {
 451         List<org.apache.archiva.metadata.model.License> l = new ArrayList<>();
 452         for ( License license : licenses )
 453         {
 454             org.apache.archiva.metadata.model.License newLicense = new org.apache.archiva.metadata.model.License();
 455             newLicense.setName( license.getName() );
 456             newLicense.setUrl( license.getUrl() );
 457             l.add( newLicense );
 458         }
 459         return l;
 460     }
 461
 462     private List<org.apache.archiva.metadata.model.MailingList> convertMailingLists( List<MailingList> mailingLists )
 463     {
 464         List<org.apache.archiva.metadata.model.MailingList> l =
 465             new ArrayList<>();
 466         for ( MailingList mailingList : mailingLists )
 467         {
 468             org.apache.archiva.metadata.model.MailingList newMailingList =
 469                 new org.apache.archiva.metadata.model.MailingList();
 470             newMailingList.setName( mailingList.getName() );
 471             newMailingList.setMainArchiveUrl( mailingList.getArchive() );
 472             newMailingList.setPostAddress( mailingList.getPost() );
 473             newMailingList.setSubscribeAddress( mailingList.getSubscribe() );
 474             newMailingList.setUnsubscribeAddress( mailingList.getUnsubscribe() );
 475             newMailingList.setOtherArchives( mailingList.getOtherArchives() );
 476             l.add( newMailingList );
 477         }
 478         return l;
 479     }
 480
 481     private org.apache.archiva.metadata.model.IssueManagement convertIssueManagement( IssueManagement issueManagement )
 482     {
 483         org.apache.archiva.metadata.model.IssueManagement im = null;
 484         if ( issueManagement != null )
 485         {
 486             im = new org.apache.archiva.metadata.model.IssueManagement();
 487             im.setSystem( issueManagement.getSystem() );
 488             im.setUrl( issueManagement.getUrl() );
 489         }
 490         return im;
 491     }
 492
 493     private org.apache.archiva.metadata.model.CiManagement convertCiManagement( CiManagement ciManagement )
 494     {
 495         org.apache.archiva.metadata.model.CiManagement ci = null;
 496         if ( ciManagement != null )
 497         {
 498             ci = new org.apache.archiva.metadata.model.CiManagement();
 499             ci.setSystem( ciManagement.getSystem() );
 500             ci.setUrl( ciManagement.getUrl() );
 501         }
 502         return ci;
 503     }
 504
 505     @Override
 506     public Collection<String> listRootNamespaces( String repoId, Filter<String> filter )
 507         throws RepositoryStorageRuntimeException
 508     {
 509         File dir = getRepositoryBasedir( repoId );
 510
 511         return getSortedFiles( dir, filter );
 512     }
 513
 514     private static Collection<String> getSortedFiles( File dir, Filter<String> filter )
 515     {
 516         List<String> fileNames;
 517         String[] files = dir.list( new DirectoryFilter( filter ) );
 518         if ( files != null )
 519         {
 520             fileNames = new ArrayList<>( Arrays.asList( files ) );
 521             Collections.sort( fileNames );
 522         }
 523         else
 524         {
 525             fileNames = Collections.emptyList();
 526         }
 527         return fileNames;
 528     }
 529
 530     private File getRepositoryBasedir( String repoId )
 531         throws RepositoryStorageRuntimeException
 532     {
 533         try
 534         {
 535             ManagedRepository repositoryConfiguration = managedRepositoryAdmin.getManagedRepository( repoId );
 536
 537             return new File( repositoryConfiguration.getLocation() );
 538         }
 539         catch ( RepositoryAdminException e )
 540         {
 541             throw new RepositoryStorageRuntimeException( "repo-admin", e.getMessage(), e );
 542         }
 543     }
 544
 545     @Override
 546     public Collection<String> listNamespaces( String repoId, String namespace, Filter<String> filter )
 547         throws RepositoryStorageRuntimeException
 548     {
 549         File dir = pathTranslator.toFile( getRepositoryBasedir( repoId ), namespace );
 550
 551         // scan all the directories which are potential namespaces. Any directories known to be projects are excluded
 552         List<String> namespaces = new ArrayList<>();
 553         File[] files = dir.listFiles( new DirectoryFilter( filter ) );
 554         if ( files != null )
 555         {
 556             for ( File file : files )
 557             {
 558                 if ( !isProject( file, filter ) )
 559                 {
 560                     namespaces.add( file.getName() );
 561                 }
 562             }
 563         }
 564         Collections.sort( namespaces );
 565         return namespaces;
 566     }
 567
 568     @Override
 569     public Collection<String> listProjects( String repoId, String namespace, Filter<String> filter )
 570         throws RepositoryStorageRuntimeException
 571     {
 572         File dir = pathTranslator.toFile( getRepositoryBasedir( repoId ), namespace );
 573
 574         // scan all directories in the namespace, and only include those that are known to be projects
 575         List<String> projects = new ArrayList<>();
 576
 577         File[] files = dir.listFiles( new DirectoryFilter( filter ) );
 578         if ( files != null )
 579         {
 580             for ( File file : files )
 581             {
 582                 if ( isProject( file, filter ) )
 583                 {
 584                     projects.add( file.getName() );
 585                 }
 586             }
 587         }
 588         Collections.sort( projects );
 589         return projects;
 590     }
 591
 592     @Override
 593     public Collection<String> listProjectVersions( String repoId, String namespace, String projectId,
 594                                                    Filter<String> filter )
 595         throws RepositoryStorageRuntimeException
 596     {
 597         File dir = pathTranslator.toFile( getRepositoryBasedir( repoId ), namespace, projectId );
 598
 599         // all directories in a project directory can be considered a version
 600         return getSortedFiles( dir, filter );
 601     }
 602
 603     @Override
 604     public Collection<ArtifactMetadata> readArtifactsMetadata( ReadMetadataRequest readMetadataRequest )
 605         throws RepositoryStorageRuntimeException
 606     {
 607         File dir = pathTranslator.toFile( getRepositoryBasedir( readMetadataRequest.getRepositoryId() ),
 608                                           readMetadataRequest.getNamespace(), readMetadataRequest.getProjectId(),
 609                                           readMetadataRequest.getProjectVersion() );
 610
 611         // all files that are not metadata and not a checksum / signature are considered artifacts
 612         File[] files = dir.listFiles( new ArtifactDirectoryFilter( readMetadataRequest.getFilter() ) );
 613
 614         List<ArtifactMetadata> artifacts = new ArrayList<>();
 615         if ( files != null )
 616         {
 617             for ( File file : files )
 618             {
 619                 ArtifactMetadata metadata =
 620                     getArtifactFromFile( readMetadataRequest.getRepositoryId(), readMetadataRequest.getNamespace(),
 621                                          readMetadataRequest.getProjectId(), readMetadataRequest.getProjectVersion(),
 622                                          file );
 623                 artifacts.add( metadata );
 624             }
 625         }
 626         return artifacts;
 627     }
 628
 629     @Override
 630     public ArtifactMetadata readArtifactMetadataFromPath( String repoId, String path )
 631         throws RepositoryStorageRuntimeException
 632     {
 633         ArtifactMetadata metadata = pathTranslator.getArtifactForPath( repoId, path );
 634
 635         populateArtifactMetadataFromFile( metadata, new File( getRepositoryBasedir( repoId ), path ) );
 636
 637         return metadata;
 638     }
 639
 640     private ArtifactMetadata getArtifactFromFile( String repoId, String namespace, String projectId,
 641                                                   String projectVersion, File file )
 642     {
 643         ArtifactMetadata metadata =
 644             pathTranslator.getArtifactFromId( repoId, namespace, projectId, projectVersion, file.getName() );
 645
 646         populateArtifactMetadataFromFile( metadata, file );
 647
 648         return metadata;
 649     }
 650
 651     @Override
 652     public void applyServerSideRelocation( ManagedRepositoryContent managedRepository, ArtifactReference artifact )
 653         throws ProxyDownloadException
 654     {
 655         if ( "pom".equals( artifact.getType() ) )
 656         {
 657             return;
 658         }
 659
 660         // Build the artifact POM reference
 661         ArtifactReference pomReference = new ArtifactReference();
 662         pomReference.setGroupId( artifact.getGroupId() );
 663         pomReference.setArtifactId( artifact.getArtifactId() );
 664         pomReference.setVersion( artifact.getVersion() );
 665         pomReference.setType( "pom" );
 666
 667         RepositoryProxyConnectors connectors =
 668             applicationContext.getBean( "repositoryProxyConnectors#default", RepositoryProxyConnectors.class );
 669
 670         // Get the artifact POM from proxied repositories if needed
 671         connectors.fetchFromProxies( managedRepository, pomReference );
 672
 673         // Open and read the POM from the managed repo
 674         File pom = managedRepository.toFile( pomReference );
 675
 676         if ( !pom.exists() )
 677         {
 678             return;
 679         }
 680
 681         try
 682         {
 683             // MavenXpp3Reader leaves the file open, so we need to close it ourselves.
 684
 685             Model model = null;
 686             try (Reader reader = Files.newBufferedReader( pom.toPath(), Charset.defaultCharset() ))
 687             {
 688                 model = MAVEN_XPP_3_READER.read( reader );
 689             }
 690
 691             DistributionManagement dist = model.getDistributionManagement();
 692             if ( dist != null )
 693             {
 694                 Relocation relocation = dist.getRelocation();
 695                 if ( relocation != null )
 696                 {
 697                     // artifact is relocated : update the repositoryPath
 698                     if ( relocation.getGroupId() != null )
 699                     {
 700                         artifact.setGroupId( relocation.getGroupId() );
 701                     }
 702                     if ( relocation.getArtifactId() != null )
 703                     {
 704                         artifact.setArtifactId( relocation.getArtifactId() );
 705                     }
 706                     if ( relocation.getVersion() != null )
 707                     {
 708                         artifact.setVersion( relocation.getVersion() );
 709                     }
 710                 }
 711             }
 712         }
 713         catch ( IOException e )
 714         {
 715             // Unable to read POM : ignore.
 716         }
 717         catch ( XmlPullParserException e )
 718         {
 719             // Invalid POM : ignore
 720         }
 721     }
 722
 723
 724     @Override
 725     public String getFilePath( String requestPath, ManagedRepository managedRepository )
 726     {
 727         // managedRepository can be null
 728         // extract artifact reference from url
 729         // groupId:artifactId:version:packaging:classifier
 730         //org/apache/archiva/archiva-checksum/1.4-M4-SNAPSHOT/archiva-checksum-1.4-M4-SNAPSHOT.jar
 731         String logicalResource = null;
 732         String requestPathInfo = StringUtils.defaultString( requestPath );
 733
 734         //remove prefix ie /repository/blah becomes /blah
 735         requestPathInfo = removePrefix( requestPathInfo );
 736
 737         // Remove prefixing slash as the repository id doesn't contain it;
 738         if ( requestPathInfo.startsWith( "/" ) )
 739         {
 740             requestPathInfo = requestPathInfo.substring( 1 );
 741         }
 742
 743         int slash = requestPathInfo.indexOf( '/' );
 744         if ( slash > 0 )
 745         {
 746             logicalResource = requestPathInfo.substring( slash );
 747
 748             if ( logicalResource.endsWith( "/.." ) )
 749             {
 750                 logicalResource += "/";
 751             }
 752
 753             if ( logicalResource != null && logicalResource.startsWith( "//" ) )
 754             {
 755                 logicalResource = logicalResource.substring( 1 );
 756             }
 757
 758             if ( logicalResource == null )
 759             {
 760                 logicalResource = "/";
 761             }
 762         }
 763         else
 764         {
 765             logicalResource = "/";
 766         }
 767         return logicalResource;
 768
 769     }
 770
 771     @Override
 772     public String getFilePathWithVersion( final String requestPath, ManagedRepositoryContent managedRepositoryContent )
 773         throws XMLException, RelocationException
 774     {
 775
 776         if ( StringUtils.endsWith( requestPath, METADATA_FILENAME ) )
 777         {
 778             return getFilePath( requestPath, managedRepositoryContent.getRepository() );
 779         }
 780
 781         String filePath = getFilePath( requestPath, managedRepositoryContent.getRepository() );
 782
 783         ArtifactReference artifactReference = null;
 784         try
 785         {
 786             artifactReference = pathParser.toArtifactReference( filePath );
 787         }
 788         catch ( LayoutException e )
 789         {
 790             return filePath;
 791         }
 792
 793         if ( StringUtils.endsWith( artifactReference.getVersion(), VersionUtil.SNAPSHOT ) )
 794         {
 795             // read maven metadata to get last timestamp
 796             File metadataDir = new File( managedRepositoryContent.getRepoRoot(), filePath ).getParentFile();
 797             if ( !metadataDir.exists() )
 798             {
 799                 return filePath;
 800             }
 801             File metadataFile = new File( metadataDir, METADATA_FILENAME );
 802             if ( !metadataFile.exists() )
 803             {
 804                 return filePath;
 805             }
 806             ArchivaRepositoryMetadata archivaRepositoryMetadata = MavenMetadataReader.read( metadataFile );
 807             int buildNumber = archivaRepositoryMetadata.getSnapshotVersion().getBuildNumber();
 808             String timestamp = archivaRepositoryMetadata.getSnapshotVersion().getTimestamp();
 809
 810             // org/apache/archiva/archiva-checksum/1.4-M4-SNAPSHOT/archiva-checksum-1.4-M4-SNAPSHOT.jar
 811             // ->  archiva-checksum-1.4-M4-20130425.081822-1.jar
 812
 813             filePath =
 814                 StringUtils.replace( filePath, artifactReference.getArtifactId() + "-" + artifactReference.getVersion(),
 815                                      artifactReference.getArtifactId() + "-" + StringUtils.remove(
 816                                          artifactReference.getVersion(), "-" + VersionUtil.SNAPSHOT ) + "-" + timestamp
 817                                          + "-" + buildNumber );
 818
 819             throw new RelocationException( "/repository/" + managedRepositoryContent.getRepository().getId() +
 820                                                ( StringUtils.startsWith( filePath, "/" ) ? "" : "/" ) + filePath,
 821                                            RelocationException.RelocationType.TEMPORARY );
 822
 823         }
 824
 825         return filePath;
 826     }
 827
 828     //-----------------------------
 829     // internal
 830     //-----------------------------
 831
 832     /**
 833      * FIXME remove
 834      *
 835      * @param href
 836      * @return
 837      */
 838     private static String removePrefix( final String href )
 839     {
 840         String[] parts = StringUtils.split( href, '/' );
 841         parts = (String[]) ArrayUtils.subarray( parts, 1, parts.length );
 842         if ( parts == null || parts.length == 0 )
 843         {
 844             return "/";
 845         }
 846
 847         String joinedString = StringUtils.join( parts, '/' );
 848         if ( href.endsWith( "/" ) )
 849         {
 850             joinedString = joinedString + "/";
 851         }
 852
 853         return joinedString;
 854     }
 855
 856     private static void populateArtifactMetadataFromFile( ArtifactMetadata metadata, File file )
 857     {
 858         metadata.setWhenGathered( new Date() );
 859         metadata.setFileLastModified( file.lastModified() );
 860         ChecksummedFile checksummedFile = new ChecksummedFile( file );
 861         try
 862         {
 863             metadata.setMd5( checksummedFile.calculateChecksum( ChecksumAlgorithm.MD5 ) );
 864         }
 865         catch ( IOException e )
 866         {
 867             LOGGER.error( "Unable to checksum file {}: {},MD5", file, e.getMessage() );
 868         }
 869         try
 870         {
 871             metadata.setSha1( checksummedFile.calculateChecksum( ChecksumAlgorithm.SHA1 ) );
 872         }
 873         catch ( IOException e )
 874         {
 875             LOGGER.error( "Unable to checksum file {}: {},SHA1", file, e.getMessage() );
 876         }
 877         metadata.setSize( file.length() );
 878     }
 879
 880     private boolean isProject( File dir, Filter<String> filter )
 881     {
 882         // scan directories for a valid project version subdirectory, meaning this must be a project directory
 883         File[] files = dir.listFiles( new DirectoryFilter( filter ) );
 884         if ( files != null )
 885         {
 886             for ( File file : files )
 887             {
 888                 if ( isProjectVersion( file ) )
 889                 {
 890                     return true;
 891                 }
 892             }
 893         }
 894
 895         // if a metadata file is present, check if this is the "artifactId" directory, marking it as a project
 896         ArchivaRepositoryMetadata metadata = readMetadata( dir );
 897         if ( metadata != null && dir.getName().equals( metadata.getArtifactId() ) )
 898         {
 899             return true;
 900         }
 901
 902         return false;
 903     }
 904
 905     private boolean isProjectVersion( File dir )
 906     {
 907         final String artifactId = dir.getParentFile().getName();
 908         final String projectVersion = dir.getName();
 909
 910         // check if there is a POM artifact file to ensure it is a version directory
 911         File[] files;
 912         if ( VersionUtil.isSnapshot( projectVersion ) )
 913         {
 914             files = dir.listFiles( new PomFilenameFilter( artifactId, projectVersion ) );
 915         }
 916         else
 917         {
 918             final String pomFile = artifactId + "-" + projectVersion + ".pom";
 919             files = dir.listFiles( new PomFileFilter( pomFile ) );
 920         }
 921         if ( files != null && files.length > 0 )
 922         {
 923             return true;
 924         }
 925
 926         // if a metadata file is present, check if this is the "version" directory, marking it as a project version
 927         ArchivaRepositoryMetadata metadata = readMetadata( dir );
 928         if ( metadata != null && projectVersion.equals( metadata.getVersion() ) )
 929         {
 930             return true;
 931         }
 932
 933         return false;
 934     }
 935
 936     private ArchivaRepositoryMetadata readMetadata( File directory )
 937     {
 938         ArchivaRepositoryMetadata metadata = null;
 939         File metadataFile = new File( directory, METADATA_FILENAME );
 940         if ( metadataFile.exists() )
 941         {
 942             try
 943             {
 944                 metadata = MavenMetadataReader.read( metadataFile );
 945             }
 946             catch ( XMLException e )
 947             {
 948                 // ignore missing or invalid metadata
 949             }
 950         }
 951         return metadata;
 952     }
 953
 954     private static class DirectoryFilter
 955         implements FilenameFilter
 956     {
 957         private final Filter<String> filter;
 958
 959         public DirectoryFilter( Filter<String> filter )
 960         {
 961             this.filter = filter;
 962         }
 963
 964         @Override
 965         public boolean accept( File dir, String name )
 966         {
 967             if ( !filter.accept( name ) )
 968             {
 969                 return false;
 970             }
 971             else if ( name.startsWith( "." ) )
 972             {
 973                 return false;
 974             }
 975             else if ( !new File( dir, name ).isDirectory() )
 976             {
 977                 return false;
 978             }
 979             return true;
 980         }
 981     }
 982
 983     private static class ArtifactDirectoryFilter
 984         implements FilenameFilter
 985     {
 986         private final Filter<String> filter;
 987
 988         private ArtifactDirectoryFilter( Filter<String> filter )
 989         {
 990             this.filter = filter;
 991         }
 992
 993         @Override
 994         public boolean accept( File dir, String name )
 995         {
 996             // TODO compare to logic in maven-repository-layer
 997             if ( !filter.accept( name ) )
 998             {
 999                 return false;
1000             }
1001             else if ( name.startsWith( "." ) )
1002             {
1003                 return false;
1004             }
1005             else if ( name.endsWith( ".md5" ) || name.endsWith( ".sha1" ) || name.endsWith( ".asc" ) )
1006             {
1007                 return false;
1008             }
1009             else if ( name.equals( METADATA_FILENAME ) )
1010             {
1011                 return false;
1012             }
1013             else if ( new File( dir, name ).isDirectory() )
1014             {
1015                 return false;
1016             }
1017             // some files from remote repositories can have name like maven-metadata-archiva-vm-all-public.xml
1018             else if ( StringUtils.startsWith( name, METADATA_FILENAME_START ) && StringUtils.endsWith( name, ".xml" ) )
1019             {
1020                 return false;
1021             }
1022
1023             return true;
1024
1025         }
1026     }
1027
1028
1029     private static final class PomFilenameFilter
1030         implements FilenameFilter
1031     {
1032
1033         private final String artifactId, projectVersion;
1034
1035         private PomFilenameFilter( String artifactId, String projectVersion )
1036         {
1037             this.artifactId = artifactId;
1038             this.projectVersion = projectVersion;
1039         }
1040
1041         @Override
1042         public boolean accept( File dir, String name )
1043         {
1044             if ( name.startsWith( artifactId + "-" ) && name.endsWith( ".pom" ) )
1045             {
1046                 String v = name.substring( artifactId.length() + 1, name.length() - 4 );
1047                 v = VersionUtil.getBaseVersion( v );
1048                 if ( v.equals( projectVersion ) )
1049                 {
1050                     return true;
1051                 }
1052             }
1053             return false;
1054         }
1055     }
1056
1057     private static class PomFileFilter
1058         implements FilenameFilter
1059     {
1060         private final String pomFile;
1061
1062         private PomFileFilter( String pomFile )
1063         {
1064             this.pomFile = pomFile;
1065         }
1066
1067         @Override
1068         public boolean accept( File dir, String name )
1069         {
1070             return pomFile.equals( name );
1071         }
1072     }
1073
1074
1075     public PathParser getPathParser()
1076     {
1077         return pathParser;
1078     }
1079
1080     public void setPathParser( PathParser pathParser )
1081     {
1082         this.pathParser = pathParser;
1083     }
1084 }