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

   1 package org.apache.archiva.metadata.repository;
   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 java.util.ArrayList;
  23 import java.util.Collection;
  24
  25 import org.apache.archiva.metadata.model.ArtifactMetadata;
  26 import org.apache.archiva.metadata.model.Dependency;
  27 import org.apache.archiva.metadata.model.ProjectMetadata;
  28 import org.apache.archiva.metadata.model.ProjectVersionMetadata;
  29 import org.apache.archiva.metadata.model.ProjectVersionReference;
  30 import org.apache.archiva.metadata.repository.filter.ExcludesFilter;
  31 import org.apache.archiva.metadata.repository.storage.StorageMetadataResolver;
  32
  33 /**
  34  * @plexus.component role="org.apache.archiva.metadata.repository.MetadataResolver"
  35  */
  36 public class DefaultMetadataResolver
  37     implements MetadataResolver
  38 {
  39     /**
  40      * @plexus.requirement
  41      */
  42     private MetadataRepository metadataRepository;
  43
  44     /**
  45      * FIXME: this needs to be configurable based on storage type, and availability of proxy module
  46      * ... could be a different type since we need methods to modify the storage metadata, which would also allow more
  47      * appropriate methods to pass in the already determined repository configuration, for example, instead of the ID
  48      *
  49      * @plexus.requirement role-hint="maven2"
  50      */
  51     private StorageMetadataResolver storageResolver;
  52
  53     public ProjectMetadata getProject( String repoId, String namespace, String projectId )
  54     {
  55         // TODO: intercept
  56         return metadataRepository.getProject( repoId, namespace, projectId );
  57     }
  58
  59     public ProjectVersionMetadata getProjectVersion( String repoId, String namespace, String projectId,
  60                                                      String projectVersion )
  61         throws MetadataResolverException
  62     {
  63         ProjectVersionMetadata metadata =
  64             metadataRepository.getProjectVersion( repoId, namespace, projectId, projectVersion );
  65         // TODO: do we want to detect changes as well by comparing timestamps? isProjectVersionNewerThan(updated)
  66         //       in such cases we might also remove/update stale metadata, including adjusting plugin-based facets
  67         if ( metadata == null )
  68         {
  69             metadata = storageResolver.getProjectVersion( repoId, namespace, projectId, projectVersion );
  70             if ( metadata != null )
  71             {
  72                 // FIXME: make this a more generic post-processing that plugins can take advantage of
  73                 //       eg. maven projects should be able to process parent here
  74                 if ( !metadata.getDependencies().isEmpty() )
  75                 {
  76                     ProjectVersionReference ref = new ProjectVersionReference();
  77                     ref.setNamespace( namespace );
  78                     ref.setProjectId( projectId );
  79                     ref.setProjectVersion( projectVersion );
  80                     ref.setReferenceType( ProjectVersionReference.ReferenceType.DEPENDENCY );
  81                     for ( Dependency dependency : metadata.getDependencies() )
  82                     {
  83                         metadataRepository.updateProjectReference( repoId, dependency.getGroupId(),
  84                                                                    dependency.getArtifactId(), dependency.getVersion(),
  85                                                                    ref );
  86                     }
  87                 }
  88                 metadataRepository.updateProjectVersion( repoId, namespace, projectId, metadata );
  89             }
  90         }
  91         return metadata;
  92     }
  93
  94     public Collection<String> getArtifactVersions( String repoId, String namespace, String projectId,
  95                                                    String projectVersion )
  96     {
  97         // TODO: intercept
  98         return metadataRepository.getArtifactVersions( repoId, namespace, projectId, projectVersion );
  99     }
 100
 101     public Collection<ProjectVersionReference> getProjectReferences( String repoId, String namespace, String projectId,
 102                                                                      String projectVersion )
 103     {
 104         // TODO: is this assumption correct? could a storage mech. actually know all references in a non-Maven scenario?
 105         // not passed to the storage mechanism as resolving references would require iterating all artifacts
 106         return metadataRepository.getProjectReferences( repoId, namespace, projectId, projectVersion );
 107     }
 108
 109     public Collection<String> getRootNamespaces( String repoId )
 110     {
 111         Collection<String> namespaces = metadataRepository.getRootNamespaces( repoId );
 112         Collection<String> storageNamespaces =
 113             storageResolver.getRootNamespaces( repoId, new ExcludesFilter<String>( namespaces ) );
 114         if ( storageNamespaces != null && !storageNamespaces.isEmpty() )
 115         {
 116             for ( String n : storageNamespaces )
 117             {
 118                 metadataRepository.updateNamespace( repoId, n );
 119             }
 120             namespaces = new ArrayList<String>( namespaces );
 121             namespaces.addAll( storageNamespaces );
 122         }
 123         return namespaces;
 124     }
 125
 126     public Collection<String> getNamespaces( String repoId, String namespace )
 127     {
 128         Collection<String> namespaces = metadataRepository.getNamespaces( repoId, namespace );
 129         Collection<String> exclusions = new ArrayList<String>( namespaces );
 130         exclusions.addAll( metadataRepository.getProjects( repoId, namespace ) );
 131         Collection<String> storageNamespaces =
 132             storageResolver.getNamespaces( repoId, namespace, new ExcludesFilter<String>( exclusions ) );
 133         if ( storageNamespaces != null && !storageNamespaces.isEmpty() )
 134         {
 135             for ( String n : storageNamespaces )
 136             {
 137                 metadataRepository.updateNamespace( repoId, namespace + "." + n );
 138             }
 139             namespaces = new ArrayList<String>( namespaces );
 140             namespaces.addAll( storageNamespaces );
 141         }
 142         return namespaces;
 143     }
 144
 145     public Collection<String> getProjects( String repoId, String namespace )
 146     {
 147         Collection<String> projects = metadataRepository.getProjects( repoId, namespace );
 148         Collection<String> exclusions = new ArrayList<String>( projects );
 149         exclusions.addAll( metadataRepository.getNamespaces( repoId, namespace ) );
 150         Collection<String> storageProjects =
 151             storageResolver.getProjects( repoId, namespace, new ExcludesFilter<String>( exclusions ) );
 152         if ( storageProjects != null && !storageProjects.isEmpty() )
 153         {
 154             for ( String projectId : storageProjects )
 155             {
 156                 ProjectMetadata projectMetadata = storageResolver.getProject( repoId, namespace, projectId );
 157                 if ( projectMetadata != null )
 158                 {
 159                     metadataRepository.updateProject( repoId, projectMetadata );
 160                 }
 161             }
 162             projects = new ArrayList<String>( projects );
 163             projects.addAll( storageProjects );
 164         }
 165         return projects;
 166     }
 167
 168     public Collection<String> getProjectVersions( String repoId, String namespace, String projectId )
 169         throws MetadataResolverException
 170     {
 171         Collection<String> projectVersions = metadataRepository.getProjectVersions( repoId, namespace, projectId );
 172         Collection<String> storageProjectVersions = storageResolver.getProjectVersions( repoId, namespace, projectId,
 173                                                                                         new ExcludesFilter<String>(
 174                                                                                             projectVersions ) );
 175         if ( storageProjectVersions != null && !storageProjectVersions.isEmpty() )
 176         {
 177             for ( String projectVersion : storageProjectVersions )
 178             {
 179                 ProjectVersionMetadata versionMetadata =
 180                     storageResolver.getProjectVersion( repoId, namespace, projectId, projectVersion );
 181                 if ( versionMetadata != null )
 182                 {
 183                     metadataRepository.updateProjectVersion( repoId, namespace, projectId, versionMetadata );
 184                 }
 185             }
 186             projectVersions = new ArrayList<String>( projectVersions );
 187             projectVersions.addAll( storageProjectVersions );
 188         }
 189         return projectVersions;
 190     }
 191
 192     public Collection<ArtifactMetadata> getArtifacts( String repoId, String namespace, String projectId,
 193                                                       String projectVersion )
 194     {
 195         Collection<ArtifactMetadata> artifacts =
 196             metadataRepository.getArtifacts( repoId, namespace, projectId, projectVersion );
 197         Collection<ArtifactMetadata> storageArtifacts =
 198             storageResolver.getArtifacts( repoId, namespace, projectId, projectVersion,
 199                                           new ExcludesFilter<String>( createArtifactIdList( artifacts ) ) );
 200         if ( storageArtifacts != null && !storageArtifacts.isEmpty() )
 201         {
 202             for ( ArtifactMetadata artifact : storageArtifacts )
 203             {
 204                 metadataRepository.updateArtifact( repoId, namespace, projectId, projectVersion, artifact );
 205             }
 206             artifacts = new ArrayList<ArtifactMetadata>( artifacts );
 207             artifacts.addAll( storageArtifacts );
 208         }
 209         return artifacts;
 210     }
 211
 212     private Collection<String> createArtifactIdList( Collection<ArtifactMetadata> artifacts )
 213     {
 214         Collection<String> artifactIds = new ArrayList<String>();
 215         for ( ArtifactMetadata artifact : artifacts )
 216         {
 217             artifactIds.add( artifact.getId() );
 218         }
 219         return artifactIds;
 220     }
 221 }