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