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

   1 package org.apache.maven.repository.manager.web.execution;
   2
   3 /*
   4  * Copyright 2006 The Apache Software Foundation.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19 import org.apache.lucene.index.IndexReader;
  20 import org.apache.maven.artifact.Artifact;
  21 import org.apache.maven.artifact.repository.ArtifactRepository;
  22 import org.apache.maven.artifact.repository.ArtifactRepositoryFactory;
  23 import org.apache.maven.artifact.repository.DefaultArtifactRepositoryFactory;
  24 import org.apache.maven.artifact.repository.layout.ArtifactRepositoryLayout;
  25 import org.apache.maven.artifact.repository.metadata.RepositoryMetadata;
  26 import org.apache.maven.model.Model;
  27 import org.apache.maven.repository.discovery.ArtifactDiscoverer;
  28 import org.apache.maven.repository.discovery.MetadataDiscoverer;
  29 import org.apache.maven.repository.indexing.ArtifactRepositoryIndex;
  30 import org.apache.maven.repository.indexing.MetadataRepositoryIndex;
  31 import org.apache.maven.repository.indexing.PomRepositoryIndex;
  32 import org.apache.maven.repository.indexing.RepositoryIndexException;
  33 import org.apache.maven.repository.indexing.RepositoryIndexingFactory;
  34 import org.apache.maven.repository.manager.web.job.Configuration;
  35 import org.codehaus.plexus.logging.AbstractLogEnabled;
  36
  37 import java.io.File;
  38 import java.net.MalformedURLException;
  39 import java.util.Iterator;
  40 import java.util.List;
  41 import java.util.Properties;
  42
  43 /**
  44  * This is the class that executes the discoverer and indexer.
  45  *
  46  * @plexus.component role="org.apache.maven.repository.manager.web.execution.DiscovererExecution"
  47  */
  48 public class DiscovererExecution
  49     extends AbstractLogEnabled
  50 {
  51     /**
  52      * @plexus.requirement
  53      */
  54     private Configuration config;
  55
  56     /**
  57      * @plexus.requirement role-hint="default"
  58      */
  59     private ArtifactDiscoverer defaultArtifactDiscoverer;
  60
  61     /**
  62      * @plexus.requirement role-hint="legacy"
  63      */
  64     private ArtifactDiscoverer legacyArtifactDiscoverer;
  65
  66     /**
  67      * @plexus.requirement role-hint="default"
  68      */
  69     private MetadataDiscoverer defaultMetadataDiscoverer;
  70
  71     /**
  72      * @plexus.requirement
  73      */
  74     private RepositoryIndexingFactory indexFactory;
  75
  76     /**
  77      * @plexus.requirement
  78      */
  79     private ArtifactRepositoryFactory repoFactory;
  80
  81     private ArtifactRepositoryLayout layout;
  82
  83     private String indexPath;
  84
  85     private String blacklistedPatterns;
  86
  87     private boolean includeSnapshots;
  88
  89     private boolean convertSnapshots;
  90
  91     private ArtifactRepository defaultRepository;
  92
  93     /**
  94      * Executes discoverer and indexer if an index does not exist yet
  95      *
  96      * @throws MalformedURLException
  97      * @throws RepositoryIndexException
  98      */
  99     public void executeDiscovererIfIndexDoesNotExist()
 100         throws MalformedURLException, RepositoryIndexException
 101     {
 102         Properties props = config.getProperties();
 103         indexPath = props.getProperty( "index.path" );
 104
 105         File indexDir = new File( indexPath );
 106         boolean isExisting = false;
 107
 108         if ( IndexReader.indexExists( indexDir ) )
 109         {
 110             isExisting = true;
 111         }
 112
 113         if ( !isExisting )
 114         {
 115             executeDiscoverer();
 116         }
 117     }
 118
 119     /**
 120      * Method that executes the discoverer and indexer
 121      */
 122     public void executeDiscoverer()
 123         throws MalformedURLException, RepositoryIndexException
 124     {
 125         Properties props = config.getProperties();
 126         indexPath = props.getProperty( "index.path" );
 127         layout = config.getLayout();
 128         blacklistedPatterns = props.getProperty( "blacklist.patterns" );
 129         includeSnapshots = Boolean.valueOf( props.getProperty( "include.snapshots" ) ).booleanValue();
 130         convertSnapshots = Boolean.valueOf( props.getProperty( "convert.snapshots" ) ).booleanValue();
 131
 132         try
 133         {
 134             defaultRepository = getDefaultRepository();
 135         }
 136         catch ( MalformedURLException me )
 137         {
 138             getLogger().error( me.getMessage() );
 139         }
 140
 141         getLogger().info( "[DiscovererExecution] Started discovery and indexing.." );
 142         if ( "default".equals( props.getProperty( "layout" ) ) )
 143         {
 144             executeDiscovererInDefaultRepo();
 145         }
 146         else if ( "legacy".equals( props.getProperty( "layout" ) ) )
 147         {
 148             executeDiscovererInLegacyRepo();
 149         }
 150         getLogger().info( "[DiscovererExecution] Finished discovery and indexing." );
 151     }
 152
 153     /**
 154      * Method that discovers and indexes artifacts, poms and metadata in a default
 155      * m2 repository structure.
 156      *
 157      * @throws MalformedURLException
 158      * @throws RepositoryIndexException
 159      * @todo why is this any different from legacy? [!]
 160      */
 161     protected void executeDiscovererInDefaultRepo()
 162         throws MalformedURLException, RepositoryIndexException
 163     {
 164         List artifacts =
 165             defaultArtifactDiscoverer.discoverArtifacts( defaultRepository, blacklistedPatterns, includeSnapshots );
 166         indexArtifact( artifacts, indexPath, defaultRepository );
 167
 168         List models = defaultArtifactDiscoverer.discoverStandalonePoms( defaultRepository, blacklistedPatterns,
 169                                                                         convertSnapshots );
 170         indexPom( models, indexPath, defaultRepository );
 171
 172         List metadataList = defaultMetadataDiscoverer.discoverMetadata( new File( defaultRepository
 173             .getBasedir() ), blacklistedPatterns );
 174         indexMetadata( metadataList, indexPath, new File( defaultRepository.getBasedir() ) );
 175     }
 176
 177     /**
 178      * Method that discovers and indexes artifacts in a legacy type repository
 179      *
 180      * @throws RepositoryIndexException
 181      */
 182     protected void executeDiscovererInLegacyRepo()
 183         throws RepositoryIndexException
 184     {
 185         List artifacts =
 186             legacyArtifactDiscoverer.discoverArtifacts( defaultRepository, blacklistedPatterns, includeSnapshots );
 187         indexArtifact( artifacts, indexPath, defaultRepository );
 188     }
 189
 190     /**
 191      * Index the artifacts in the list
 192      *
 193      * @param artifacts  the artifacts to be indexed
 194      * @param indexPath  the path to the index file
 195      * @param repository the repository where the artifacts are located
 196      */
 197     protected void indexArtifact( List artifacts, String indexPath, ArtifactRepository repository )
 198         throws RepositoryIndexException
 199     {
 200         ArtifactRepositoryIndex artifactIndex = indexFactory.createArtifactRepositoryIndex( indexPath, repository );
 201         for ( Iterator iter = artifacts.iterator(); iter.hasNext(); )
 202         {
 203             Artifact artifact = (Artifact) iter.next();
 204             artifactIndex.indexArtifact( artifact );
 205
 206             if ( artifactIndex.isOpen() )
 207             {
 208                 artifactIndex.optimize();
 209                 artifactIndex.close();
 210             }
 211         }
 212     }
 213
 214     /**
 215      * Index the metadata in the list
 216      *
 217      * @param metadataList   the metadata to be indexed
 218      * @param indexPath      the path to the index file
 219      * @param repositoryBase the repository where the metadata are located
 220      */
 221     protected void indexMetadata( List metadataList, String indexPath, File repositoryBase )
 222         throws RepositoryIndexException, MalformedURLException
 223     {
 224         String repoDir = repositoryBase.toURL().toString();
 225         ArtifactRepository repository = repoFactory
 226             .createArtifactRepository( "repository", repoDir, layout, null, null );
 227
 228         MetadataRepositoryIndex metadataIndex = indexFactory.createMetadataRepositoryIndex( indexPath, repository );
 229         for ( Iterator iter = metadataList.iterator(); iter.hasNext(); )
 230         {
 231             RepositoryMetadata repoMetadata = (RepositoryMetadata) iter.next();
 232             metadataIndex.index( repoMetadata );
 233
 234             if ( metadataIndex.isOpen() )
 235             {
 236                 metadataIndex.optimize();
 237                 metadataIndex.close();
 238             }
 239         }
 240     }
 241
 242     /**
 243      * Index the poms in the list
 244      *
 245      * @param models     list of poms that will be indexed
 246      * @param indexPath  the path to the index
 247      * @param repository the artifact repository where the poms were discovered
 248      */
 249     protected void indexPom( List models, String indexPath, ArtifactRepository repository )
 250         throws RepositoryIndexException
 251     {
 252         PomRepositoryIndex pomIndex = indexFactory.createPomRepositoryIndex( indexPath, repository );
 253         for ( Iterator iter = models.iterator(); iter.hasNext(); )
 254         {
 255             Model model = (Model) iter.next();
 256             pomIndex.indexPom( model );
 257
 258             if ( pomIndex.isOpen() )
 259             {
 260                 pomIndex.optimize();
 261                 pomIndex.close();
 262             }
 263         }
 264     }
 265
 266     /**
 267      * Method that creates the artifact repository
 268      *
 269      * @return an ArtifactRepository instance
 270      * @throws java.net.MalformedURLException
 271      */
 272     protected ArtifactRepository getDefaultRepository()
 273         throws MalformedURLException
 274     {
 275         File repositoryDirectory = new File( config.getRepositoryDirectory() );
 276         String repoDir = repositoryDirectory.toURL().toString();
 277         ArtifactRepositoryFactory repoFactory = new DefaultArtifactRepositoryFactory();
 278
 279         return repoFactory.createArtifactRepository( "test", repoDir, config.getLayout(), null, null );
 280     }
 281
 282     /**
 283      * Method that sets the configuration object
 284      *
 285      * @param config
 286      */
 287     public void setConfiguration( Configuration config )
 288     {
 289         this.config = config;
 290     }
 291
 292     /**
 293      * Returns the cofiguration
 294      *
 295      * @return a Configuration object that contains the configuration values
 296      */
 297     public Configuration getConfiguration()
 298     {
 299         return config;
 300     }
 301 }