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

   1 package org.apache.maven.archiva.consumers.core;
   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.io.File;
  23 import java.io.IOException;
  24 import java.util.ArrayList;
  25 import java.util.Date;
  26 import java.util.List;
  27
  28 import org.apache.maven.archiva.configuration.ArchivaConfiguration;
  29 import org.apache.maven.archiva.configuration.ConfigurationNames;
  30 import org.apache.maven.archiva.configuration.FileTypes;
  31 import org.apache.maven.archiva.configuration.ManagedRepositoryConfiguration;
  32 import org.apache.maven.archiva.consumers.AbstractMonitoredConsumer;
  33 import org.apache.maven.archiva.consumers.ConsumerException;
  34 import org.apache.maven.archiva.consumers.KnownRepositoryContentConsumer;
  35 import org.apache.maven.archiva.model.ArtifactReference;
  36 import org.apache.maven.archiva.model.ProjectReference;
  37 import org.apache.maven.archiva.model.VersionedReference;
  38 import org.apache.maven.archiva.repository.ContentNotFoundException;
  39 import org.apache.maven.archiva.repository.ManagedRepositoryContent;
  40 import org.apache.maven.archiva.repository.RepositoryContentFactory;
  41 import org.apache.maven.archiva.repository.RepositoryException;
  42 import org.apache.maven.archiva.repository.RepositoryNotFoundException;
  43 import org.apache.maven.archiva.repository.layout.LayoutException;
  44 import org.apache.maven.archiva.repository.metadata.MetadataTools;
  45 import org.apache.maven.archiva.repository.metadata.RepositoryMetadataException;
  46 import org.codehaus.plexus.personality.plexus.lifecycle.phase.Initializable;
  47 import org.codehaus.plexus.personality.plexus.lifecycle.phase.InitializationException;
  48 import org.codehaus.plexus.registry.Registry;
  49 import org.codehaus.plexus.registry.RegistryListener;
  50 import org.slf4j.Logger;
  51 import org.slf4j.LoggerFactory;
  52
  53 /**
  54  * MetadataUpdaterConsumer will create and update the metadata present within the repository.
  55  *
  56  * @version $Id$
  57  * @plexus.component role="org.apache.maven.archiva.consumers.KnownRepositoryContentConsumer"
  58  * role-hint="metadata-updater"
  59  * instantiation-strategy="per-lookup"
  60  */
  61 public class MetadataUpdaterConsumer
  62     extends AbstractMonitoredConsumer
  63     implements KnownRepositoryContentConsumer, RegistryListener, Initializable
  64 {
  65     private Logger log = LoggerFactory.getLogger( MetadataUpdaterConsumer.class );
  66
  67     /**
  68      * @plexus.configuration default-value="metadata-updater"
  69      */
  70     private String id;
  71
  72     /**
  73      * @plexus.configuration default-value="Update / Create maven-metadata.xml files"
  74      */
  75     private String description;
  76
  77     /**
  78      * @plexus.requirement
  79      */
  80     private RepositoryContentFactory repositoryFactory;
  81
  82     /**
  83      * @plexus.requirement
  84      */
  85     private MetadataTools metadataTools;
  86
  87     /**
  88      * @plexus.requirement
  89      */
  90     private ArchivaConfiguration configuration;
  91
  92     /**
  93      * @plexus.requirement
  94      */
  95     private FileTypes filetypes;
  96
  97     private static final String TYPE_METADATA_BAD_INTERNAL_REF = "metadata-bad-internal-ref";
  98
  99     private static final String TYPE_METADATA_WRITE_FAILURE = "metadata-write-failure";
 100
 101     private static final String TYPE_METADATA_IO = "metadata-io-warning";
 102
 103     private ManagedRepositoryContent repository;
 104
 105     private File repositoryDir;
 106
 107     private List<String> includes = new ArrayList<String>();
 108
 109     private long scanStartTimestamp = 0;
 110
 111     public String getDescription()
 112     {
 113         return description;
 114     }
 115
 116     public String getId()
 117     {
 118         return id;
 119     }
 120
 121     public void setIncludes( List<String> includes )
 122     {
 123         this.includes = includes;
 124     }
 125
 126     public void beginScan( ManagedRepositoryConfiguration repoConfig, Date whenGathered )
 127         throws ConsumerException
 128     {
 129         try
 130         {
 131             this.repository = repositoryFactory.getManagedRepositoryContent( repoConfig.getId() );
 132             this.repositoryDir = new File( repository.getRepoRoot() );
 133             this.scanStartTimestamp = System.currentTimeMillis();
 134         }
 135         catch ( RepositoryNotFoundException e )
 136         {
 137             throw new ConsumerException( e.getMessage(), e );
 138         }
 139         catch ( RepositoryException e )
 140         {
 141             throw new ConsumerException( e.getMessage(), e );
 142         }
 143     }
 144
 145     public void completeScan()
 146     {
 147         /* do nothing here */
 148     }
 149
 150     public List<String> getExcludes()
 151     {
 152         return getDefaultArtifactExclusions();
 153     }
 154
 155     public List<String> getIncludes()
 156     {
 157         return this.includes;
 158     }
 159
 160     public void processFile( String path )
 161         throws ConsumerException
 162     {
 163         // Ignore paths like .indexer etc
 164         if ( !path.startsWith( "." ) )
 165         {
 166             try
 167             {
 168                 ArtifactReference artifact = repository.toArtifactReference( path );
 169                 updateVersionMetadata( artifact, path );
 170                 updateProjectMetadata( artifact, path );
 171             }
 172             catch ( LayoutException e )
 173             {
 174                 log.info( "Not processing path that is not an artifact: " + path + " (" + e.getMessage() + ")" );
 175             }
 176         }
 177     }
 178
 179     private void updateProjectMetadata( ArtifactReference artifact, String path )
 180     {
 181         ProjectReference projectRef = new ProjectReference();
 182         projectRef.setGroupId( artifact.getGroupId() );
 183         projectRef.setArtifactId( artifact.getArtifactId() );
 184
 185         try
 186         {
 187             String metadataPath = this.metadataTools.toPath( projectRef );
 188
 189             File projectMetadata = new File( this.repositoryDir, metadataPath );
 190
 191             if ( projectMetadata.exists() && ( projectMetadata.lastModified() >= this.scanStartTimestamp ) )
 192             {
 193                 // This metadata is up to date. skip it.
 194                 log.debug( "Skipping uptodate metadata: " + this.metadataTools.toPath( projectRef ) );
 195                 return;
 196             }
 197
 198             metadataTools.updateMetadata( this.repository, projectRef );
 199             log.debug( "Updated metadata: " + this.metadataTools.toPath( projectRef ) );
 200         }
 201         catch ( LayoutException e )
 202         {
 203             triggerConsumerWarning( TYPE_METADATA_BAD_INTERNAL_REF, "Unable to convert path [" + path
 204                 + "] to an internal project reference: " + e.getMessage() );
 205         }
 206         catch ( RepositoryMetadataException e )
 207         {
 208             triggerConsumerError( TYPE_METADATA_WRITE_FAILURE, "Unable to write project metadata for artifact [" + path
 209                 + "]: " + e.getMessage() );
 210         }
 211         catch ( IOException e )
 212         {
 213             triggerConsumerWarning( TYPE_METADATA_IO, "Project metadata not written due to IO warning: "
 214                 + e.getMessage() );
 215         }
 216         catch ( ContentNotFoundException e )
 217         {
 218             triggerConsumerWarning( TYPE_METADATA_IO,
 219                                     "Project metadata not written because no versions were found to update: "
 220                                         + e.getMessage() );
 221         }
 222     }
 223
 224     private void updateVersionMetadata( ArtifactReference artifact, String path )
 225     {
 226         VersionedReference versionRef = new VersionedReference();
 227         versionRef.setGroupId( artifact.getGroupId() );
 228         versionRef.setArtifactId( artifact.getArtifactId() );
 229         versionRef.setVersion( artifact.getVersion() );
 230
 231         try
 232         {
 233             String metadataPath = this.metadataTools.toPath( versionRef );
 234
 235             File projectMetadata = new File( this.repositoryDir, metadataPath );
 236
 237             if ( projectMetadata.exists() && ( projectMetadata.lastModified() >= this.scanStartTimestamp ) )
 238             {
 239                 // This metadata is up to date. skip it.
 240                 log.debug( "Skipping uptodate metadata: " + this.metadataTools.toPath( versionRef ) );
 241                 return;
 242             }
 243
 244             metadataTools.updateMetadata( this.repository, versionRef );
 245             log.debug( "Updated metadata: " + this.metadataTools.toPath( versionRef ) );
 246         }
 247         catch ( LayoutException e )
 248         {
 249             triggerConsumerWarning( TYPE_METADATA_BAD_INTERNAL_REF, "Unable to convert path [" + path
 250                 + "] to an internal version reference: " + e.getMessage() );
 251         }
 252         catch ( RepositoryMetadataException e )
 253         {
 254             triggerConsumerError( TYPE_METADATA_WRITE_FAILURE, "Unable to write version metadata for artifact [" + path
 255                 + "]: " + e.getMessage() );
 256         }
 257         catch ( IOException e )
 258         {
 259             triggerConsumerWarning( TYPE_METADATA_IO, "Version metadata not written due to IO warning: "
 260                 + e.getMessage() );
 261         }
 262         catch ( ContentNotFoundException e )
 263         {
 264             triggerConsumerWarning( TYPE_METADATA_IO,
 265                                     "Version metadata not written because no versions were found to update: "
 266                                         + e.getMessage() );
 267         }
 268     }
 269
 270     public boolean isPermanent()
 271     {
 272         return false;
 273     }
 274
 275     public void afterConfigurationChange( Registry registry, String propertyName, Object propertyValue )
 276     {
 277         if ( ConfigurationNames.isRepositoryScanning( propertyName ) )
 278         {
 279             initIncludes();
 280         }
 281     }
 282
 283     public void beforeConfigurationChange( Registry registry, String propertyName, Object propertyValue )
 284     {
 285         /* do nothing here */
 286     }
 287
 288     private void initIncludes()
 289     {
 290         includes.clear();
 291
 292         includes.addAll( filetypes.getFileTypePatterns( FileTypes.ARTIFACTS ) );
 293     }
 294
 295     public void initialize()
 296         throws InitializationException
 297     {
 298         configuration.addChangeListener( this );
 299
 300         initIncludes();
 301     }
 302 }