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

   1 package org.apache.maven.archiva.repositories;
   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.commons.lang.StringUtils;
  23 import org.apache.maven.archiva.artifact.ManagedArtifact;
  24 import org.apache.maven.archiva.artifact.ManagedArtifactTypes;
  25 import org.apache.maven.archiva.artifact.ManagedEjbArtifact;
  26 import org.apache.maven.archiva.artifact.ManagedJavaArtifact;
  27 import org.apache.maven.archiva.configuration.ArchivaConfiguration;
  28 import org.apache.maven.archiva.configuration.Configuration;
  29 import org.apache.maven.archiva.configuration.ConfiguredRepositoryFactory;
  30 import org.apache.maven.archiva.configuration.RepositoryConfiguration;
  31 import org.apache.maven.artifact.Artifact;
  32 import org.apache.maven.artifact.factory.ArtifactFactory;
  33 import org.apache.maven.artifact.repository.ArtifactRepository;
  34 import org.apache.maven.model.Model;
  35 import org.apache.maven.project.MavenProject;
  36 import org.apache.maven.project.MavenProjectBuilder;
  37 import org.apache.maven.project.ProjectBuildingException;
  38 import org.codehaus.plexus.cache.Cache;
  39 import org.codehaus.plexus.logging.AbstractLogEnabled;
  40 import org.codehaus.plexus.personality.plexus.lifecycle.phase.Initializable;
  41 import org.codehaus.plexus.personality.plexus.lifecycle.phase.InitializationException;
  42 import org.codehaus.plexus.registry.Registry;
  43 import org.codehaus.plexus.registry.RegistryListener;
  44
  45 import java.io.File;
  46 import java.util.Iterator;
  47 import java.util.List;
  48
  49 /**
  50  * DefaultActiveManagedRepositories
  51  *
  52  * @author <a href="mailto:joakim@erdfelt.com">Joakim Erdfelt</a>
  53  * @version $Id$
  54  * @plexus.component role="org.apache.maven.archiva.repositories.ActiveManagedRepositories"
  55  */
  56 public class DefaultActiveManagedRepositories
  57     extends AbstractLogEnabled
  58     implements ActiveManagedRepositories, Initializable, RegistryListener
  59 {
  60     /**
  61      * @plexus.requirement role-hint="artifactCache"
  62      */
  63     private Cache artifactCache;
  64
  65     /**
  66      * @plexus.requirement
  67      */
  68     private ArtifactFactory artifactFactory;
  69
  70     /**
  71      * @plexus.requirement
  72      */
  73     private ArchivaConfiguration archivaConfiguration;
  74
  75     /**
  76      * @plexus.requirement
  77      */
  78     private MavenProjectBuilder projectBuilder;
  79
  80     /**
  81      * @plexus.requirement role-hint="projectCache"
  82      */
  83     private Cache projectCache;
  84
  85     /**
  86      * @plexus.requirement
  87      */
  88     private ConfiguredRepositoryFactory repositoryFactory;
  89
  90     private Configuration configuration;
  91
  92     private ArtifactRepository localRepository;
  93
  94     private List repositories;
  95
  96     public Artifact createRelatedArtifact( Artifact artifact, String classifier, String type )
  97     {
  98         String groupId = artifact.getGroupId();
  99         String artifactId = artifact.getArtifactId();
 100         String version = artifact.getVersion();
 101         String reltype = StringUtils.defaultIfEmpty( type, artifact.getType() );
 102         return artifactFactory.createArtifactWithClassifier( groupId, artifactId, version, reltype, classifier );
 103     }
 104
 105     public ManagedArtifact findArtifact( Artifact artifact )
 106     {
 107         ManagedArtifact managedArtifact = (ManagedArtifact) artifactCache.get( toKey( artifact ) );
 108
 109         if ( managedArtifact != null )
 110         {
 111             return managedArtifact;
 112         }
 113
 114         boolean snapshot = artifact.isSnapshot();
 115
 116         for ( Iterator i = repositories.iterator(); i.hasNext(); )
 117         {
 118             ArtifactRepository repository = (ArtifactRepository) i.next();
 119             if ( snapshot && !repository.getSnapshots().isEnabled() )
 120             {
 121                 // skip repo.
 122                 continue;
 123             }
 124
 125             String path = repository.pathOf( artifact );
 126             File f = new File( repository.getBasedir(), path );
 127             if ( f.exists() )
 128             {
 129                 // Found it.
 130                 managedArtifact = createManagedArtifact( repository, artifact, f );
 131
 132                 artifactCache.put( toKey( artifact ), managedArtifact );
 133
 134                 return managedArtifact;
 135             }
 136         }
 137
 138         return null;
 139     }
 140
 141     public ManagedArtifact findArtifact( String groupId, String artifactId, String version )
 142         throws ProjectBuildingException
 143     {
 144         MavenProject project = findProject( groupId, artifactId, version );
 145         Model model = project.getModel();
 146
 147         return findArtifact( model.getGroupId(), model.getArtifactId(), model.getVersion(), model.getPackaging() );
 148     }
 149
 150     public ManagedArtifact findArtifact( String groupId, String artifactId, String version, String type )
 151     {
 152         Artifact artifact = artifactFactory.createBuildArtifact( groupId, artifactId, version, type );
 153         return findArtifact( artifact );
 154     }
 155
 156     public MavenProject findProject( String groupId, String artifactId, String version )
 157         throws ProjectBuildingException
 158     {
 159         MavenProject project = (MavenProject) projectCache.get( toKey( groupId, artifactId, version ) );
 160
 161         if ( project != null )
 162         {
 163             return project;
 164         }
 165
 166         Artifact projectArtifact = artifactFactory.createProjectArtifact( groupId, artifactId, version );
 167
 168         project = projectBuilder.buildFromRepository( projectArtifact, repositories, localRepository );
 169
 170         projectCache.put( toKey( groupId, artifactId, version ), project );
 171
 172         return project;
 173     }
 174
 175     public ArtifactRepository getArtifactRepository( String id )
 176     {
 177         RepositoryConfiguration repoConfig = getRepositoryConfiguration( id );
 178         if ( repoConfig == null )
 179         {
 180             return null;
 181         }
 182
 183         return repositoryFactory.createRepository( repoConfig );
 184     }
 185
 186     public List getAllArtifactRepositories()
 187     {
 188         return repositoryFactory.createRepositories( configuration );
 189     }
 190
 191     public RepositoryConfiguration getRepositoryConfiguration( String id )
 192     {
 193         return this.configuration.getRepositoryById( id );
 194     }
 195
 196     public void initialize()
 197         throws InitializationException
 198     {
 199         Configuration config = archivaConfiguration.getConfiguration();
 200         archivaConfiguration.addChangeListener( this );
 201         configureSelf( config );
 202     }
 203
 204     private String toKey( Artifact artifact )
 205     {
 206         if ( artifact == null )
 207         {
 208             return null;
 209         }
 210
 211         return toKey( artifact.getGroupId(), artifact.getArtifactId(), artifact.getVersion() );
 212     }
 213
 214     private String toKey( String groupId, String artifactId, String version )
 215     {
 216         return groupId + ":" + artifactId + ":" + version;
 217     }
 218
 219     private void configureSelf( Configuration config )
 220     {
 221         this.configuration = config;
 222         this.artifactCache.clear();
 223         this.projectCache.clear();
 224
 225         repositories = repositoryFactory.createRepositories( this.configuration );
 226         localRepository = repositoryFactory.createLocalRepository( this.configuration );
 227     }
 228
 229     private ManagedArtifact createManagedArtifact( ArtifactRepository repository, Artifact artifact, File f )
 230     {
 231         artifact.isSnapshot();
 232         String path = repository.pathOf( artifact );
 233
 234         switch ( ManagedArtifactTypes.whichType( artifact.getType() ) )
 235         {
 236             case ManagedArtifactTypes.EJB:
 237                 ManagedEjbArtifact managedEjbArtifact = new ManagedEjbArtifact( repository.getId(), artifact, path );
 238
 239                 managedEjbArtifact.setJavadocPath( pathToRelatedArtifact( repository, artifact, "javadoc", "jar" ) );
 240                 managedEjbArtifact.setSourcesPath( pathToRelatedArtifact( repository, artifact, "sources", "jar" ) );
 241                 managedEjbArtifact.setClientPath( pathToRelatedArtifact( repository, artifact, "client", "jar" ) );
 242
 243                 return managedEjbArtifact;
 244
 245             case ManagedArtifactTypes.JAVA:
 246                 ManagedJavaArtifact managedJavaArtifact = new ManagedJavaArtifact( repository.getId(), artifact, path );
 247
 248                 managedJavaArtifact.setJavadocPath( pathToRelatedArtifact( repository, artifact, "javadoc", "jar" ) );
 249                 managedJavaArtifact.setSourcesPath( pathToRelatedArtifact( repository, artifact, "sources", "jar" ) );
 250
 251                 return managedJavaArtifact;
 252
 253             case ManagedArtifactTypes.GENERIC:
 254             default:
 255                 return new ManagedArtifact( repository.getId(), artifact, path );
 256         }
 257     }
 258
 259     private String pathToRelatedArtifact( ArtifactRepository repository, Artifact artifact, String classifier,
 260                                           String type )
 261     {
 262         Artifact relatedArtifact = createRelatedArtifact( artifact, classifier, type );
 263
 264         relatedArtifact.isSnapshot();
 265         String path = repository.pathOf( relatedArtifact );
 266
 267         File relatedFile = new File( repository.getBasedir(), path );
 268         if ( !relatedFile.exists() )
 269         {
 270             // Return null to set the ManagedArtifact related path to empty.
 271             return null;
 272         }
 273
 274         return path;
 275     }
 276
 277     public void beforeConfigurationChange( Registry registry, String propertyName, Object propertyValue )
 278     {
 279         // nothing to do
 280     }
 281
 282     public void afterConfigurationChange( Registry registry, String propertyName, Object propertyValue )
 283     {
 284         if ( propertyName.startsWith( "repositories" ) || propertyName.startsWith( "localRepository" ) )
 285         {
 286             getLogger().debug( "Triggering managed repository configuration change with " + propertyName + " set to " +
 287                 propertyValue );
 288             configureSelf( archivaConfiguration.getConfiguration() );
 289         }
 290         else
 291         {
 292             getLogger().debug( "Not triggering managed repository configuration change with " + propertyName );
 293         }
 294     }
 295 }