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

   1 package org.apache.maven.archiva.consumers.core.repository;
   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.archiva.metadata.repository.RepositorySession;
  23 import org.apache.archiva.metadata.repository.RepositorySessionFactory;
  24 import org.apache.archiva.repository.events.RepositoryListener;
  25 import org.apache.maven.archiva.configuration.ArchivaConfiguration;
  26 import org.apache.maven.archiva.configuration.ConfigurationNames;
  27 import org.apache.maven.archiva.configuration.FileTypes;
  28 import org.apache.maven.archiva.configuration.ManagedRepositoryConfiguration;
  29 import org.apache.maven.archiva.consumers.AbstractMonitoredConsumer;
  30 import org.apache.maven.archiva.consumers.ConsumerException;
  31 import org.apache.maven.archiva.consumers.KnownRepositoryContentConsumer;
  32 import org.apache.maven.archiva.repository.ManagedRepositoryContent;
  33 import org.apache.maven.archiva.repository.RepositoryContentFactory;
  34 import org.apache.maven.archiva.repository.RepositoryException;
  35 import org.apache.maven.archiva.repository.RepositoryNotFoundException;
  36 import org.apache.maven.archiva.repository.metadata.MetadataTools;
  37 import org.codehaus.plexus.registry.Registry;
  38 import org.codehaus.plexus.registry.RegistryListener;
  39 import org.springframework.context.ApplicationContext;
  40 import org.springframework.context.annotation.Scope;
  41 import org.springframework.stereotype.Service;
  42
  43 import javax.annotation.PostConstruct;
  44 import javax.inject.Inject;
  45 import javax.inject.Named;
  46 import java.util.ArrayList;
  47 import java.util.Collections;
  48 import java.util.Date;
  49 import java.util.List;
  50
  51 /**
  52  * Consumer for removing old snapshots in the repository based on the criteria
  53  * specified by the user.
  54  * <p/>
  55  * plexus.component role="org.apache.maven.archiva.consumers.KnownRepositoryContentConsumer"
  56  * role-hint="repository-purge"
  57  * instantiation-strategy="per-lookup"
  58  */
  59 @Service( "knownRepositoryContentConsumer#repository-purge" )
  60 @Scope( "prototype" )
  61 public class RepositoryPurgeConsumer
  62     extends AbstractMonitoredConsumer
  63     implements KnownRepositoryContentConsumer, RegistryListener
  64 {
  65     /**
  66      * plexus.configuration default-value="repository-purge"
  67      */
  68     private String id = "repository-purge";
  69
  70     /**
  71      * plexus.configuration default-value="Purge repository of old snapshots"
  72      */
  73     private String description = "Purge repository of old snapshots";
  74
  75     /**
  76      * plexus.requirement
  77      */
  78     @Inject
  79     @Named( value = "archivaConfiguration#default" )
  80     private ArchivaConfiguration configuration;
  81
  82     /**
  83      * plexus.requirement
  84      */
  85     @Inject
  86     @Named(value = "repositoryContentFactory#default")
  87     private RepositoryContentFactory repositoryContentFactory;
  88
  89     /**
  90      * plexus.requirement
  91      */
  92     @Inject
  93     private MetadataTools metadataTools;
  94
  95     /**
  96      * plexus.requirement
  97      */
  98     @Inject
  99     @Named(value = "fileTypes")
 100     private FileTypes filetypes;
 101
 102     private List<String> includes = new ArrayList<String>();
 103
 104     private RepositoryPurge repoPurge;
 105
 106     private RepositoryPurge cleanUp;
 107
 108     private boolean deleteReleasedSnapshots;
 109
 110     //@Inject
 111     //private ApplicationContext applicationContext;
 112
 113     /**
 114      * plexus.requirement role="org.apache.archiva.repository.events.RepositoryListener"
 115      */
 116     @Inject
 117     private List<RepositoryListener> listeners = Collections.emptyList();
 118
 119     /**
 120      * TODO: this could be multiple implementations and needs to be configured.
 121      * <p/>
 122      * plexus.requirement
 123      */
 124     @Inject
 125     private RepositorySessionFactory repositorySessionFactory;
 126
 127     private RepositorySession repositorySession;
 128
 129     public String getId()
 130     {
 131         return this.id;
 132     }
 133
 134     public String getDescription()
 135     {
 136         return this.description;
 137     }
 138
 139     public boolean isPermanent()
 140     {
 141         return false;
 142     }
 143
 144     public List<String> getExcludes()
 145     {
 146         return getDefaultArtifactExclusions();
 147     }
 148
 149     public List<String> getIncludes()
 150     {
 151         return this.includes;
 152     }
 153
 154     public void beginScan( ManagedRepositoryConfiguration repository, Date whenGathered )
 155         throws ConsumerException
 156     {
 157         ManagedRepositoryContent repositoryContent;
 158         try
 159         {
 160             repositoryContent = repositoryContentFactory.getManagedRepositoryContent( repository.getId() );
 161         }
 162         catch ( RepositoryNotFoundException e )
 163         {
 164             throw new ConsumerException( "Can't run repository purge: " + e.getMessage(), e );
 165         }
 166         catch ( RepositoryException e )
 167         {
 168             throw new ConsumerException( "Can't run repository purge: " + e.getMessage(), e );
 169         }
 170
 171         repositorySession = repositorySessionFactory.createSession();
 172
 173         if ( repository.getDaysOlder() != 0 )
 174         {
 175             repoPurge = new DaysOldRepositoryPurge( repositoryContent, repository.getDaysOlder(),
 176                                                     repository.getRetentionCount(), repositorySession, listeners );
 177         }
 178         else
 179         {
 180             repoPurge =
 181                 new RetentionCountRepositoryPurge( repositoryContent, repository.getRetentionCount(), repositorySession,
 182                                                    listeners );
 183         }
 184
 185         cleanUp = new CleanupReleasedSnapshotsRepositoryPurge( repositoryContent, metadataTools, configuration,
 186                                                                repositoryContentFactory, repositorySession, listeners );
 187
 188         deleteReleasedSnapshots = repository.isDeleteReleasedSnapshots();
 189     }
 190
 191     public void beginScan( ManagedRepositoryConfiguration repository, Date whenGathered, boolean executeOnEntireRepo )
 192         throws ConsumerException
 193     {
 194         beginScan( repository, whenGathered );
 195     }
 196
 197     public void processFile( String path )
 198         throws ConsumerException
 199     {
 200         try
 201         {
 202             if ( deleteReleasedSnapshots )
 203             {
 204                 cleanUp.process( path );
 205             }
 206
 207             repoPurge.process( path );
 208         }
 209         catch ( RepositoryPurgeException rpe )
 210         {
 211             throw new ConsumerException( rpe.getMessage(), rpe );
 212         }
 213     }
 214
 215     public void processFile( String path, boolean executeOnEntireRepo )
 216         throws Exception
 217     {
 218         processFile( path );
 219     }
 220
 221     public void completeScan()
 222     {
 223         repositorySession.close();
 224     }
 225
 226     public void completeScan( boolean executeOnEntireRepo )
 227     {
 228         completeScan();
 229     }
 230
 231     public void afterConfigurationChange( Registry registry, String propertyName, Object propertyValue )
 232     {
 233         if ( ConfigurationNames.isRepositoryScanning( propertyName ) )
 234         {
 235             initIncludes();
 236         }
 237     }
 238
 239     public void beforeConfigurationChange( Registry registry, String propertyName, Object propertyValue )
 240     {
 241         /* do nothing */
 242     }
 243
 244     private void initIncludes()
 245     {
 246         includes.clear();
 247
 248         includes.addAll( filetypes.getFileTypePatterns( FileTypes.ARTIFACTS ) );
 249     }
 250
 251     @PostConstruct
 252     public void initialize()
 253     {
 254         //this.listeners =
 255         //    new ArrayList<RepositoryListener>( applicationContext.getBeansOfType( RepositoryListener.class ).values() );
 256         configuration.addChangeListener( this );
 257
 258         initIncludes();
 259     }
 260
 261     public boolean isProcessUnmodified()
 262     {
 263         // we need to check all files for deletion, especially if not modified
 264         return true;
 265     }
 266
 267     public ArchivaConfiguration getConfiguration()
 268     {
 269         return configuration;
 270     }
 271
 272     public void setConfiguration( ArchivaConfiguration configuration )
 273     {
 274         this.configuration = configuration;
 275     }
 276
 277     public RepositoryContentFactory getRepositoryContentFactory()
 278     {
 279         return repositoryContentFactory;
 280     }
 281
 282     public void setRepositoryContentFactory( RepositoryContentFactory repositoryContentFactory )
 283     {
 284         this.repositoryContentFactory = repositoryContentFactory;
 285     }
 286
 287     public MetadataTools getMetadataTools()
 288     {
 289         return metadataTools;
 290     }
 291
 292     public void setMetadataTools( MetadataTools metadataTools )
 293     {
 294         this.metadataTools = metadataTools;
 295     }
 296
 297     public FileTypes getFiletypes()
 298     {
 299         return filetypes;
 300     }
 301
 302     public void setFiletypes( FileTypes filetypes )
 303     {
 304         this.filetypes = filetypes;
 305     }
 306
 307     public RepositoryPurge getRepoPurge()
 308     {
 309         return repoPurge;
 310     }
 311
 312     public void setRepoPurge( RepositoryPurge repoPurge )
 313     {
 314         this.repoPurge = repoPurge;
 315     }
 316
 317     public RepositoryPurge getCleanUp()
 318     {
 319         return cleanUp;
 320     }
 321
 322     public void setCleanUp( RepositoryPurge cleanUp )
 323     {
 324         this.cleanUp = cleanUp;
 325     }
 326
 327     public boolean isDeleteReleasedSnapshots()
 328     {
 329         return deleteReleasedSnapshots;
 330     }
 331
 332     public void setDeleteReleasedSnapshots( boolean deleteReleasedSnapshots )
 333     {
 334         this.deleteReleasedSnapshots = deleteReleasedSnapshots;
 335     }
 336
 337     public RepositorySessionFactory getRepositorySessionFactory()
 338     {
 339         return repositorySessionFactory;
 340     }
 341
 342     public void setRepositorySessionFactory( RepositorySessionFactory repositorySessionFactory )
 343     {
 344         this.repositorySessionFactory = repositorySessionFactory;
 345     }
 346
 347     public RepositorySession getRepositorySession()
 348     {
 349         return repositorySession;
 350     }
 351
 352     public void setRepositorySession( RepositorySession repositorySession )
 353     {
 354         this.repositorySession = repositorySession;
 355     }
 356 }