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.model.facets.RepositoryProblemFacet;
  39 import org.apache.archiva.metadata.repository.filter.Filter;
  40 import org.apache.archiva.metadata.repository.storage.ReadMetadataRequest;
  41 import org.apache.archiva.metadata.repository.storage.RelocationException;
  42 import org.apache.archiva.metadata.repository.storage.RepositoryPathTranslator;
  43 import org.apache.archiva.metadata.repository.storage.RepositoryStorage;
  44 import org.apache.archiva.metadata.repository.storage.RepositoryStorageMetadataInvalidException;
  45 import org.apache.archiva.metadata.repository.storage.RepositoryStorageMetadataNotFoundException;
  46 import org.apache.archiva.metadata.repository.storage.RepositoryStorageRuntimeException;
  47 import org.apache.archiva.model.ArchivaRepositoryMetadata;
  48 import org.apache.archiva.model.ArtifactReference;
  49 import org.apache.archiva.model.SnapshotVersion;
  50 import org.apache.archiva.policies.ProxyDownloadException;
  51 import org.apache.archiva.proxy.common.WagonFactory;
  52 import org.apache.archiva.proxy.model.RepositoryProxyConnectors;
  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             metadata.setProperties( model.getProperties() );
 376
 377             MavenProjectFacet facet = new MavenProjectFacet();
 378             facet.setGroupId( model.getGroupId() != null ? model.getGroupId() : model.getParent().getGroupId() );
 379             facet.setArtifactId( model.getArtifactId() );
 380             facet.setPackaging( model.getPackaging() );
 381             if ( model.getParent() != null )
 382             {
 383                 MavenProjectParent parent = new MavenProjectParent();
 384                 parent.setGroupId( model.getParent().getGroupId() );
 385                 parent.setArtifactId( model.getParent().getArtifactId() );
 386                 parent.setVersion( model.getParent().getVersion() );
 387                 facet.setParent( parent );
 388             }
 389             metadata.addFacet( facet );
 390
 391             return metadata;
 392         }
 393         catch ( RepositoryAdminException e )
 394         {
 395             throw new RepositoryStorageRuntimeException( "repo-admin", e.getMessage(), e );
 396         }
 397     }
 398
 399     public void setWagonFactory( WagonFactory wagonFactory )
 400     {
 401         this.wagonFactory = wagonFactory;
 402     }
 403
 404     private List<org.apache.archiva.metadata.model.Dependency> convertDependencies( List<Dependency> dependencies )
 405     {
 406         List<org.apache.archiva.metadata.model.Dependency> l = 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 = new ArrayList<>();
 465         for ( MailingList mailingList : mailingLists )
 466         {
 467             org.apache.archiva.metadata.model.MailingList newMailingList =
 468                 new org.apache.archiva.metadata.model.MailingList();
 469             newMailingList.setName( mailingList.getName() );
 470             newMailingList.setMainArchiveUrl( mailingList.getArchive() );
 471             newMailingList.setPostAddress( mailingList.getPost() );
 472             newMailingList.setSubscribeAddress( mailingList.getSubscribe() );
 473             newMailingList.setUnsubscribeAddress( mailingList.getUnsubscribe() );
 474             newMailingList.setOtherArchives( mailingList.getOtherArchives() );
 475             l.add( newMailingList );
 476         }
 477         return l;
 478     }
 479
 480     private org.apache.archiva.metadata.model.IssueManagement convertIssueManagement( IssueManagement issueManagement )
 481     {
 482         org.apache.archiva.metadata.model.IssueManagement im = null;
 483         if ( issueManagement != null )
 484         {
 485             im = new org.apache.archiva.metadata.model.IssueManagement();
 486             im.setSystem( issueManagement.getSystem() );
 487             im.setUrl( issueManagement.getUrl() );
 488         }
 489         return im;
 490     }
 491
 492     private org.apache.archiva.metadata.model.CiManagement convertCiManagement( CiManagement ciManagement )
 493     {
 494         org.apache.archiva.metadata.model.CiManagement ci = null;
 495         if ( ciManagement != null )
 496         {
 497             ci = new org.apache.archiva.metadata.model.CiManagement();
 498             ci.setSystem( ciManagement.getSystem() );
 499             ci.setUrl( ciManagement.getUrl() );
 500         }
 501         return ci;
 502     }
 503
 504     @Override
 505     public Collection<String> listRootNamespaces( String repoId, Filter<String> filter )
 506         throws RepositoryStorageRuntimeException
 507     {
 508         File dir = getRepositoryBasedir( repoId );
 509
 510         return getSortedFiles( dir, filter );
 511     }
 512
 513     private static Collection<String> getSortedFiles( File dir, Filter<String> filter )
 514     {
 515         List<String> fileNames;
 516         String[] files = dir.list( new DirectoryFilter( filter ) );
 517         if ( files != null )
 518         {
 519             fileNames = new ArrayList<>( Arrays.asList( files ) );
 520             Collections.sort( fileNames );
 521         }
 522         else
 523         {
 524             fileNames = Collections.emptyList();
 525         }
 526         return fileNames;
 527     }
 528
 529     private File getRepositoryBasedir( String repoId )
 530         throws RepositoryStorageRuntimeException
 531     {
 532         try
 533         {
 534             ManagedRepository repositoryConfiguration = managedRepositoryAdmin.getManagedRepository( repoId );
 535
 536             return new File( repositoryConfiguration.getLocation() );
 537         }
 538         catch ( RepositoryAdminException e )
 539         {
 540             throw new RepositoryStorageRuntimeException( "repo-admin", e.getMessage(), e );
 541         }
 542     }
 543
 544     @Override
 545     public Collection<String> listNamespaces( String repoId, String namespace, Filter<String> filter )
 546         throws RepositoryStorageRuntimeException
 547     {
 548         File dir = pathTranslator.toFile( getRepositoryBasedir( repoId ), namespace );
 549
 550         // scan all the directories which are potential namespaces. Any directories known to be projects are excluded
 551         List<String> namespaces = new ArrayList<>();
 552         File[] files = dir.listFiles( new DirectoryFilter( filter ) );
 553         if ( files != null )
 554         {
 555             for ( File file : files )
 556             {
 557                 if ( !isProject( file, filter ) )
 558                 {
 559                     namespaces.add( file.getName() );
 560                 }
 561             }
 562         }
 563         Collections.sort( namespaces );
 564         return namespaces;
 565     }
 566
 567     @Override
 568     public Collection<String> listProjects( String repoId, String namespace, Filter<String> filter )
 569         throws RepositoryStorageRuntimeException
 570     {
 571         File dir = pathTranslator.toFile( getRepositoryBasedir( repoId ), namespace );
 572
 573         // scan all directories in the namespace, and only include those that are known to be projects
 574         List<String> projects = new ArrayList<>();
 575
 576         File[] files = dir.listFiles( new DirectoryFilter( filter ) );
 577         if ( files != null )
 578         {
 579             for ( File file : files )
 580             {
 581                 if ( isProject( file, filter ) )
 582                 {
 583                     projects.add( file.getName() );
 584                 }
 585             }
 586         }
 587         Collections.sort( projects );
 588         return projects;
 589     }
 590
 591     @Override
 592     public Collection<String> listProjectVersions( String repoId, String namespace, String projectId,
 593                                                    Filter<String> filter )
 594         throws RepositoryStorageRuntimeException
 595     {
 596         File dir = pathTranslator.toFile( getRepositoryBasedir( repoId ), namespace, projectId );
 597
 598         // all directories in a project directory can be considered a version
 599         return getSortedFiles( dir, filter );
 600     }
 601
 602     @Override
 603     public Collection<ArtifactMetadata> readArtifactsMetadata( ReadMetadataRequest readMetadataRequest )
 604         throws RepositoryStorageRuntimeException
 605     {
 606         File dir = pathTranslator.toFile( getRepositoryBasedir( readMetadataRequest.getRepositoryId() ),
 607                                           readMetadataRequest.getNamespace(), readMetadataRequest.getProjectId(),
 608                                           readMetadataRequest.getProjectVersion() );
 609
 610         // all files that are not metadata and not a checksum / signature are considered artifacts
 611         File[] files = dir.listFiles( new ArtifactDirectoryFilter( readMetadataRequest.getFilter() ) );
 612
 613         List<ArtifactMetadata> artifacts = new ArrayList<>();
 614         if ( files != null )
 615         {
 616             for ( File file : files )
 617             {
 618                 ArtifactMetadata metadata =
 619                     getArtifactFromFile( readMetadataRequest.getRepositoryId(), readMetadataRequest.getNamespace(),
 620                                          readMetadataRequest.getProjectId(), readMetadataRequest.getProjectVersion(),
 621                                          file );
 622                 artifacts.add( metadata );
 623             }
 624         }
 625         return artifacts;
 626     }
 627
 628     @Override
 629     public ArtifactMetadata readArtifactMetadataFromPath( String repoId, String path )
 630         throws RepositoryStorageRuntimeException
 631     {
 632         ArtifactMetadata metadata = pathTranslator.getArtifactForPath( repoId, path );
 633
 634         populateArtifactMetadataFromFile( metadata, new File( getRepositoryBasedir( repoId ), path ) );
 635
 636         return metadata;
 637     }
 638
 639     private ArtifactMetadata getArtifactFromFile( String repoId, String namespace, String projectId,
 640                                                   String projectVersion, File file )
 641     {
 642         ArtifactMetadata metadata =
 643             pathTranslator.getArtifactFromId( repoId, namespace, projectId, projectVersion, file.getName() );
 644
 645         populateArtifactMetadataFromFile( metadata, file );
 646
 647         return metadata;
 648     }
 649
 650     @Override
 651     public void applyServerSideRelocation( ManagedRepositoryContent managedRepository, ArtifactReference artifact )
 652         throws ProxyDownloadException
 653     {
 654         if ( "pom".equals( artifact.getType() ) )
 655         {
 656             return;
 657         }
 658
 659         // Build the artifact POM reference
 660         ArtifactReference pomReference = new ArtifactReference();
 661         pomReference.setGroupId( artifact.getGroupId() );
 662         pomReference.setArtifactId( artifact.getArtifactId() );
 663         pomReference.setVersion( artifact.getVersion() );
 664         pomReference.setType( "pom" );
 665
 666         RepositoryProxyConnectors connectors =
 667             applicationContext.getBean( "repositoryProxyConnectors#default", RepositoryProxyConnectors.class );
 668
 669         // Get the artifact POM from proxied repositories if needed
 670         connectors.fetchFromProxies( managedRepository, pomReference );
 671
 672         // Open and read the POM from the managed repo
 673         File pom = managedRepository.toFile( pomReference );
 674
 675         if ( !pom.exists() )
 676         {
 677             return;
 678         }
 679
 680         try
 681         {
 682             // MavenXpp3Reader leaves the file open, so we need to close it ourselves.
 683
 684             Model model = null;
 685             try (Reader reader = Files.newBufferedReader( pom.toPath(), Charset.defaultCharset() ))
 686             {
 687                 model = MAVEN_XPP_3_READER.read( reader );
 688             }
 689
 690             DistributionManagement dist = model.getDistributionManagement();
 691             if ( dist != null )
 692             {
 693                 Relocation relocation = dist.getRelocation();
 694                 if ( relocation != null )
 695                 {
 696                     // artifact is relocated : update the repositoryPath
 697                     if ( relocation.getGroupId() != null )
 698                     {
 699                         artifact.setGroupId( relocation.getGroupId() );
 700                     }
 701                     if ( relocation.getArtifactId() != null )
 702                     {
 703                         artifact.setArtifactId( relocation.getArtifactId() );
 704                     }
 705                     if ( relocation.getVersion() != null )
 706                     {
 707                         artifact.setVersion( relocation.getVersion() );
 708                     }
 709                 }
 710             }
 711         }
 712         catch ( IOException e )
 713         {
 714             // Unable to read POM : ignore.
 715         }
 716         catch ( XmlPullParserException e )
 717         {
 718             // Invalid POM : ignore
 719         }
 720     }
 721
 722
 723     @Override
 724     public String getFilePath( String requestPath, ManagedRepository managedRepository )
 725     {
 726         // managedRepository can be null
 727         // extract artifact reference from url
 728         // groupId:artifactId:version:packaging:classifier
 729         //org/apache/archiva/archiva-checksum/1.4-M4-SNAPSHOT/archiva-checksum-1.4-M4-SNAPSHOT.jar
 730         String logicalResource = null;
 731         String requestPathInfo = StringUtils.defaultString( requestPath );
 732
 733         //remove prefix ie /repository/blah becomes /blah
 734         requestPathInfo = removePrefix( requestPathInfo );
 735
 736         // Remove prefixing slash as the repository id doesn't contain it;
 737         if ( requestPathInfo.startsWith( "/" ) )
 738         {
 739             requestPathInfo = requestPathInfo.substring( 1 );
 740         }
 741
 742         int slash = requestPathInfo.indexOf( '/' );
 743         if ( slash > 0 )
 744         {
 745             logicalResource = requestPathInfo.substring( slash );
 746
 747             if ( logicalResource.endsWith( "/.." ) )
 748             {
 749                 logicalResource += "/";
 750             }
 751
 752             if ( logicalResource != null && logicalResource.startsWith( "//" ) )
 753             {
 754                 logicalResource = logicalResource.substring( 1 );
 755             }
 756
 757             if ( logicalResource == null )
 758             {
 759                 logicalResource = "/";
 760             }
 761         }
 762         else
 763         {
 764             logicalResource = "/";
 765         }
 766         return logicalResource;
 767
 768     }
 769
 770     @Override
 771     public String getFilePathWithVersion( final String requestPath, ManagedRepositoryContent managedRepositoryContent )
 772         throws XMLException, RelocationException
 773     {
 774
 775         if ( StringUtils.endsWith( requestPath, METADATA_FILENAME ) )
 776         {
 777             return getFilePath( requestPath, managedRepositoryContent.getRepository() );
 778         }
 779
 780         String filePath = getFilePath( requestPath, managedRepositoryContent.getRepository() );
 781
 782         ArtifactReference artifactReference = null;
 783         try
 784         {
 785             artifactReference = pathParser.toArtifactReference( filePath );
 786         }
 787         catch ( LayoutException e )
 788         {
 789             return filePath;
 790         }
 791
 792         if ( StringUtils.endsWith( artifactReference.getVersion(), VersionUtil.SNAPSHOT ) )
 793         {
 794             // read maven metadata to get last timestamp
 795             File metadataDir = new File( managedRepositoryContent.getRepoRoot(), filePath ).getParentFile();
 796             if ( !metadataDir.exists() )
 797             {
 798                 return filePath;
 799             }
 800             File metadataFile = new File( metadataDir, METADATA_FILENAME );
 801             if ( !metadataFile.exists() )
 802             {
 803                 return filePath;
 804             }
 805             ArchivaRepositoryMetadata archivaRepositoryMetadata = MavenMetadataReader.read( metadataFile );
 806             int buildNumber = archivaRepositoryMetadata.getSnapshotVersion().getBuildNumber();
 807             String timestamp = archivaRepositoryMetadata.getSnapshotVersion().getTimestamp();
 808
 809             // MRM-1846
 810             if ( buildNumber < 1 && timestamp == null )
 811             {
 812                 return filePath;
 813             }
 814
 815             // org/apache/archiva/archiva-checksum/1.4-M4-SNAPSHOT/archiva-checksum-1.4-M4-SNAPSHOT.jar
 816             // ->  archiva-checksum-1.4-M4-20130425.081822-1.jar
 817
 818             filePath = StringUtils.replace( filePath, //
 819                                             artifactReference.getArtifactId() //
 820                                                 + "-" + artifactReference.getVersion(), //
 821                                             artifactReference.getArtifactId() //
 822                                                 + "-" + StringUtils.remove( artifactReference.getVersion(),
 823                                                                             "-" + VersionUtil.SNAPSHOT ) //
 824                                                 + "-" + timestamp //
 825                                                 + "-" + buildNumber );
 826
 827             throw new RelocationException( "/repository/" + managedRepositoryContent.getRepository().getId() +
 828                                                ( StringUtils.startsWith( filePath, "/" ) ? "" : "/" ) + filePath,
 829                                            RelocationException.RelocationType.TEMPORARY );
 830
 831         }
 832
 833         return filePath;
 834     }
 835
 836     //-----------------------------
 837     // internal
 838     //-----------------------------
 839
 840     /**
 841      * FIXME remove
 842      *
 843      * @param href
 844      * @return
 845      */
 846     private static String removePrefix( final String href )
 847     {
 848         String[] parts = StringUtils.split( href, '/' );
 849         parts = (String[]) ArrayUtils.subarray( parts, 1, parts.length );
 850         if ( parts == null || parts.length == 0 )
 851         {
 852             return "/";
 853         }
 854
 855         String joinedString = StringUtils.join( parts, '/' );
 856         if ( href.endsWith( "/" ) )
 857         {
 858             joinedString = joinedString + "/";
 859         }
 860
 861         return joinedString;
 862     }
 863
 864     private static void populateArtifactMetadataFromFile( ArtifactMetadata metadata, File file )
 865     {
 866         metadata.setWhenGathered( new Date() );
 867         metadata.setFileLastModified( file.lastModified() );
 868         ChecksummedFile checksummedFile = new ChecksummedFile( file );
 869         try
 870         {
 871             metadata.setMd5( checksummedFile.calculateChecksum( ChecksumAlgorithm.MD5 ) );
 872         }
 873         catch ( IOException e )
 874         {
 875             LOGGER.error( "Unable to checksum file {}: {},MD5", file, e.getMessage() );
 876         }
 877         try
 878         {
 879             metadata.setSha1( checksummedFile.calculateChecksum( ChecksumAlgorithm.SHA1 ) );
 880         }
 881         catch ( IOException e )
 882         {
 883             LOGGER.error( "Unable to checksum file {}: {},SHA1", file, e.getMessage() );
 884         }
 885         metadata.setSize( file.length() );
 886     }
 887
 888     private boolean isProject( File dir, Filter<String> filter )
 889     {
 890         // scan directories for a valid project version subdirectory, meaning this must be a project directory
 891         File[] files = dir.listFiles( new DirectoryFilter( filter ) );
 892         if ( files != null )
 893         {
 894             for ( File file : files )
 895             {
 896                 if ( isProjectVersion( file ) )
 897                 {
 898                     return true;
 899                 }
 900             }
 901         }
 902
 903         // if a metadata file is present, check if this is the "artifactId" directory, marking it as a project
 904         ArchivaRepositoryMetadata metadata = readMetadata( dir );
 905         if ( metadata != null && dir.getName().equals( metadata.getArtifactId() ) )
 906         {
 907             return true;
 908         }
 909
 910         return false;
 911     }
 912
 913     private boolean isProjectVersion( File dir )
 914     {
 915         final String artifactId = dir.getParentFile().getName();
 916         final String projectVersion = dir.getName();
 917
 918         // check if there is a POM artifact file to ensure it is a version directory
 919         File[] files;
 920         if ( VersionUtil.isSnapshot( projectVersion ) )
 921         {
 922             files = dir.listFiles( new PomFilenameFilter( artifactId, projectVersion ) );
 923         }
 924         else
 925         {
 926             final String pomFile = artifactId + "-" + projectVersion + ".pom";
 927             files = dir.listFiles( new PomFileFilter( pomFile ) );
 928         }
 929         if ( files != null && files.length > 0 )
 930         {
 931             return true;
 932         }
 933
 934         // if a metadata file is present, check if this is the "version" directory, marking it as a project version
 935         ArchivaRepositoryMetadata metadata = readMetadata( dir );
 936         if ( metadata != null && projectVersion.equals( metadata.getVersion() ) )
 937         {
 938             return true;
 939         }
 940
 941         return false;
 942     }
 943
 944     private ArchivaRepositoryMetadata readMetadata( File directory )
 945     {
 946         ArchivaRepositoryMetadata metadata = null;
 947         File metadataFile = new File( directory, METADATA_FILENAME );
 948         if ( metadataFile.exists() )
 949         {
 950             try
 951             {
 952                 metadata = MavenMetadataReader.read( metadataFile );
 953             }
 954             catch ( XMLException e )
 955             {
 956                 // ignore missing or invalid metadata
 957             }
 958         }
 959         return metadata;
 960     }
 961
 962     private static class DirectoryFilter
 963         implements FilenameFilter
 964     {
 965         private final Filter<String> filter;
 966
 967         public DirectoryFilter( Filter<String> filter )
 968         {
 969             this.filter = filter;
 970         }
 971
 972         @Override
 973         public boolean accept( File dir, String name )
 974         {
 975             if ( !filter.accept( name ) )
 976             {
 977                 return false;
 978             }
 979             else if ( name.startsWith( "." ) )
 980             {
 981                 return false;
 982             }
 983             else if ( !new File( dir, name ).isDirectory() )
 984             {
 985                 return false;
 986             }
 987             return true;
 988         }
 989     }
 990
 991     private static class ArtifactDirectoryFilter
 992         implements FilenameFilter
 993     {
 994         private final Filter<String> filter;
 995
 996         private ArtifactDirectoryFilter( Filter<String> filter )
 997         {
 998             this.filter = filter;
 999         }
1000
1001         @Override
1002         public boolean accept( File dir, String name )
1003         {
1004             // TODO compare to logic in maven-repository-layer
1005             if ( !filter.accept( name ) )
1006             {
1007                 return false;
1008             }
1009             else if ( name.startsWith( "." ) )
1010             {
1011                 return false;
1012             }
1013             else if ( name.endsWith( ".md5" ) || name.endsWith( ".sha1" ) || name.endsWith( ".asc" ) )
1014             {
1015                 return false;
1016             }
1017             else if ( name.equals( METADATA_FILENAME ) )
1018             {
1019                 return false;
1020             }
1021             else if ( new File( dir, name ).isDirectory() )
1022             {
1023                 return false;
1024             }
1025             // some files from remote repositories can have name like maven-metadata-archiva-vm-all-public.xml
1026             else if ( StringUtils.startsWith( name, METADATA_FILENAME_START ) && StringUtils.endsWith( name, ".xml" ) )
1027             {
1028                 return false;
1029             }
1030
1031             return true;
1032
1033         }
1034     }
1035
1036
1037     private static final class PomFilenameFilter
1038         implements FilenameFilter
1039     {
1040
1041         private final String artifactId, projectVersion;
1042
1043         private PomFilenameFilter( String artifactId, String projectVersion )
1044         {
1045             this.artifactId = artifactId;
1046             this.projectVersion = projectVersion;
1047         }
1048
1049         @Override
1050         public boolean accept( File dir, String name )
1051         {
1052             if ( name.startsWith( artifactId + "-" ) && name.endsWith( ".pom" ) )
1053             {
1054                 String v = name.substring( artifactId.length() + 1, name.length() - 4 );
1055                 v = VersionUtil.getBaseVersion( v );
1056                 if ( v.equals( projectVersion ) )
1057                 {
1058                     return true;
1059                 }
1060             }
1061             return false;
1062         }
1063     }
1064
1065     private static class PomFileFilter
1066         implements FilenameFilter
1067     {
1068         private final String pomFile;
1069
1070         private PomFileFilter( String pomFile )
1071         {
1072             this.pomFile = pomFile;
1073         }
1074
1075         @Override
1076         public boolean accept( File dir, String name )
1077         {
1078             return pomFile.equals( name );
1079         }
1080     }
1081
1082
1083     public PathParser getPathParser()
1084     {
1085         return pathParser;
1086     }
1087
1088     public void setPathParser( PathParser pathParser )
1089     {
1090         this.pathParser = pathParser;
1091     }
1092 }