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