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         try
 164         {
 165             ArtifactReference artifact = repository.toArtifactReference( path );
 166             updateVersionMetadata( artifact, path );
 167             updateProjectMetadata( artifact, path );
 168         }
 169         catch ( LayoutException e )
 170         {
 171             throw new ConsumerException( "Unable to convert to artifact reference: " + path, e );
 172         }
 173     }
 174
 175     private void updateProjectMetadata( ArtifactReference artifact, String path )
 176     {
 177         ProjectReference projectRef = new ProjectReference();
 178         projectRef.setGroupId( artifact.getGroupId() );
 179         projectRef.setArtifactId( artifact.getArtifactId() );
 180
 181         try
 182         {
 183             String metadataPath = this.metadataTools.toPath( projectRef );
 184
 185             File projectMetadata = new File( this.repositoryDir, metadataPath );
 186
 187             if ( projectMetadata.exists() && ( projectMetadata.lastModified() >= this.scanStartTimestamp ) )
 188             {
 189                 // This metadata is up to date. skip it.
 190                 log.debug( "Skipping uptodate metadata: " + this.metadataTools.toPath( projectRef ) );
 191                 return;
 192             }
 193
 194             metadataTools.updateMetadata( this.repository, projectRef );
 195             log.debug( "Updated metadata: " + this.metadataTools.toPath( projectRef ) );
 196         }
 197         catch ( LayoutException e )
 198         {
 199             triggerConsumerWarning( TYPE_METADATA_BAD_INTERNAL_REF, "Unable to convert path [" + path
 200                 + "] to an internal project reference: " + e.getMessage() );
 201         }
 202         catch ( RepositoryMetadataException e )
 203         {
 204             triggerConsumerError( TYPE_METADATA_WRITE_FAILURE, "Unable to write project metadata for artifact [" + path
 205                 + "]: " + e.getMessage() );
 206         }
 207         catch ( IOException e )
 208         {
 209             triggerConsumerWarning( TYPE_METADATA_IO, "Project metadata not written due to IO warning: "
 210                 + e.getMessage() );
 211         }
 212         catch ( ContentNotFoundException e )
 213         {
 214             triggerConsumerWarning( TYPE_METADATA_IO,
 215                                     "Project metadata not written because no versions were found to update: "
 216                                         + e.getMessage() );
 217         }
 218     }
 219
 220     private void updateVersionMetadata( ArtifactReference artifact, String path )
 221     {
 222         VersionedReference versionRef = new VersionedReference();
 223         versionRef.setGroupId( artifact.getGroupId() );
 224         versionRef.setArtifactId( artifact.getArtifactId() );
 225         versionRef.setVersion( artifact.getVersion() );
 226
 227         try
 228         {
 229             String metadataPath = this.metadataTools.toPath( versionRef );
 230
 231             File projectMetadata = new File( this.repositoryDir, metadataPath );
 232
 233             if ( projectMetadata.exists() && ( projectMetadata.lastModified() >= this.scanStartTimestamp ) )
 234             {
 235                 // This metadata is up to date. skip it.
 236                 log.debug( "Skipping uptodate metadata: " + this.metadataTools.toPath( versionRef ) );
 237                 return;
 238             }
 239
 240             metadataTools.updateMetadata( this.repository, versionRef );
 241             log.debug( "Updated metadata: " + this.metadataTools.toPath( versionRef ) );
 242         }
 243         catch ( LayoutException e )
 244         {
 245             triggerConsumerWarning( TYPE_METADATA_BAD_INTERNAL_REF, "Unable to convert path [" + path
 246                 + "] to an internal version reference: " + e.getMessage() );
 247         }
 248         catch ( RepositoryMetadataException e )
 249         {
 250             triggerConsumerError( TYPE_METADATA_WRITE_FAILURE, "Unable to write version metadata for artifact [" + path
 251                 + "]: " + e.getMessage() );
 252         }
 253         catch ( IOException e )
 254         {
 255             triggerConsumerWarning( TYPE_METADATA_IO, "Version metadata not written due to IO warning: "
 256                 + e.getMessage() );
 257         }
 258         catch ( ContentNotFoundException e )
 259         {
 260             triggerConsumerWarning( TYPE_METADATA_IO,
 261                                     "Version metadata not written because no versions were found to update: "
 262                                         + e.getMessage() );
 263         }
 264     }
 265
 266     public boolean isPermanent()
 267     {
 268         return false;
 269     }
 270
 271     public void afterConfigurationChange( Registry registry, String propertyName, Object propertyValue )
 272     {
 273         if ( ConfigurationNames.isRepositoryScanning( propertyName ) )
 274         {
 275             initIncludes();
 276         }
 277     }
 278
 279     public void beforeConfigurationChange( Registry registry, String propertyName, Object propertyValue )
 280     {
 281         /* do nothing here */
 282     }
 283
 284     private void initIncludes()
 285     {
 286         includes.clear();
 287
 288         includes.addAll( filetypes.getFileTypePatterns( FileTypes.ARTIFACTS ) );
 289     }
 290
 291     public void initialize()
 292         throws InitializationException
 293     {
 294         configuration.addChangeListener( this );
 295
 296         initIncludes();
 297     }
 298 }