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

   1 package org.apache.maven.archiva.scheduled.executors;
   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.util.ArrayList;
  24 import java.util.List;
  25
  26 import org.apache.commons.collections.CollectionUtils;
  27 import org.apache.commons.io.FileUtils;
  28 import org.apache.commons.lang.StringUtils;
  29 import org.apache.maven.archiva.configuration.ArchivaConfiguration;
  30 import org.apache.maven.archiva.configuration.ManagedRepositoryConfiguration;
  31 import org.apache.maven.archiva.database.ArchivaDAO;
  32 import org.apache.maven.archiva.database.ArchivaDatabaseException;
  33 import org.apache.maven.archiva.database.ObjectNotFoundException;
  34 import org.apache.maven.archiva.database.constraints.ArtifactsByRepositoryConstraint;
  35 import org.apache.maven.archiva.database.constraints.MostRecentRepositoryScanStatistics;
  36 import org.apache.maven.archiva.database.constraints.UniqueArtifactIdConstraint;
  37 import org.apache.maven.archiva.database.constraints.UniqueGroupIdConstraint;
  38 import org.apache.maven.archiva.model.ArchivaArtifact;
  39 import org.apache.maven.archiva.model.RepositoryContentStatistics;
  40 import org.apache.maven.archiva.repository.RepositoryException;
  41 import org.apache.maven.archiva.repository.scanner.RepositoryContentConsumers;
  42 import org.apache.maven.archiva.repository.scanner.RepositoryScanStatistics;
  43 import org.apache.maven.archiva.repository.scanner.RepositoryScanner;
  44 import org.apache.maven.archiva.scheduled.tasks.RepositoryTask;
  45 import org.codehaus.plexus.personality.plexus.lifecycle.phase.Initializable;
  46 import org.codehaus.plexus.personality.plexus.lifecycle.phase.InitializationException;
  47 import org.codehaus.plexus.taskqueue.Task;
  48 import org.codehaus.plexus.taskqueue.execution.TaskExecutionException;
  49 import org.codehaus.plexus.taskqueue.execution.TaskExecutor;
  50 import org.slf4j.Logger;
  51 import org.slf4j.LoggerFactory;
  52
  53 /**
  54  * ArchivaRepositoryScanningTaskExecutor
  55  *
  56  * @version $Id$
  57  * @plexus.component role="org.codehaus.plexus.taskqueue.execution.TaskExecutor"
  58  * role-hint="repository-scanning"
  59  */
  60 public class ArchivaRepositoryScanningTaskExecutor
  61     implements TaskExecutor, Initializable
  62 {
  63     private Logger log = LoggerFactory.getLogger( ArchivaRepositoryScanningTaskExecutor.class );
  64
  65     /**
  66      * @plexus.requirement role-hint="jdo"
  67      */
  68     private ArchivaDAO dao;
  69
  70     /**
  71      * @plexus.requirement
  72      */
  73     private ArchivaConfiguration archivaConfiguration;
  74
  75     /**
  76      * The repository scanner component.
  77      *
  78      * @plexus.requirement
  79      */
  80     private RepositoryScanner repoScanner;
  81
  82     /**
  83      * @plexus.requirement
  84      */
  85     private RepositoryContentConsumers consumers;
  86
  87     private Task task;
  88
  89     public void initialize()
  90         throws InitializationException
  91     {
  92         log.info( "Initialized " + this.getClass().getName() );
  93     }
  94
  95     @SuppressWarnings("unchecked")
  96     public void executeTask( Task task )
  97         throws TaskExecutionException
  98     {
  99         this.task = task;
 100
 101         RepositoryTask repoTask = (RepositoryTask) task;
 102
 103         if ( StringUtils.isBlank( repoTask.getRepositoryId() ) )
 104         {
 105             throw new TaskExecutionException( "Unable to execute RepositoryTask with blank repository Id." );
 106         }
 107
 108         ManagedRepositoryConfiguration arepo =
 109             archivaConfiguration.getConfiguration().findManagedRepositoryById( repoTask.getRepositoryId() );
 110
 111         // execute consumers on resource file if set
 112         if ( repoTask.getResourceFile() != null )
 113         {
 114             log.debug( "Executing task from queue with job name: " + repoTask );
 115             consumers.executeConsumers( arepo, repoTask.getResourceFile(), repoTask.isUpdateRelatedArtifacts() );
 116         }
 117         else
 118         {
 119             log.info( "Executing task from queue with job name: " + repoTask );
 120
 121             // otherwise, execute consumers on whole repository
 122             try
 123             {
 124                 if ( arepo == null )
 125                 {
 126                     throw new TaskExecutionException(
 127                         "Unable to execute RepositoryTask with invalid repository id: " + repoTask.getRepositoryId() );
 128                 }
 129
 130                 long sinceWhen = RepositoryScanner.FRESH_SCAN;
 131
 132                 List<RepositoryContentStatistics> results = (List<RepositoryContentStatistics>) dao.query(
 133                     new MostRecentRepositoryScanStatistics( arepo.getId() ) );
 134
 135                 if ( CollectionUtils.isNotEmpty( results ) )
 136                 {
 137                     RepositoryContentStatistics lastStats = results.get( 0 );
 138                     if ( !repoTask.isScanAll() )
 139                     {
 140                         sinceWhen = lastStats.getWhenGathered().getTime() - lastStats.getDuration();
 141                     }
 142                 }
 143
 144                 RepositoryScanStatistics stats = repoScanner.scan( arepo, sinceWhen );
 145
 146                 log.info( "Finished repository task: " + stats.toDump( arepo ) );
 147
 148                 RepositoryContentStatistics dbstats = constructRepositoryStatistics( arepo, stats );
 149
 150                 dao.getRepositoryContentStatisticsDAO().saveRepositoryContentStatistics( dbstats );
 151
 152                 this.task = null;
 153             }
 154             catch ( RepositoryException e )
 155             {
 156                 throw new TaskExecutionException( "Repository error when executing repository job.", e );
 157             }
 158         }
 159     }
 160
 161     @SuppressWarnings("unchecked")
 162     private RepositoryContentStatistics constructRepositoryStatistics( ManagedRepositoryConfiguration arepo,
 163                                                                        RepositoryScanStatistics stats )
 164     {
 165         // I hate jpox and modello <-- and so do I
 166         RepositoryContentStatistics dbstats = new RepositoryContentStatistics();
 167         dbstats.setDuration( stats.getDuration() );
 168         dbstats.setNewFileCount( stats.getNewFileCount() );
 169         dbstats.setRepositoryId( stats.getRepositoryId() );
 170         dbstats.setTotalFileCount( stats.getTotalFileCount() );
 171         dbstats.setWhenGathered( stats.getWhenGathered() );
 172
 173         // total artifact count
 174         try
 175         {
 176             // note that when gathered is the end of the scan, so we look for all those before that time
 177             List<ArchivaArtifact> artifacts = dao.getArtifactDAO().queryArtifacts(
 178                 new ArtifactsByRepositoryConstraint( arepo.getId(), stats.getWhenGathered(), "groupId", true ) );
 179             dbstats.setTotalArtifactCount( artifacts.size() );
 180         }
 181         catch ( ObjectNotFoundException oe )
 182         {
 183             log.error( "Object not found in the database : " + oe.getMessage() );
 184         }
 185         catch ( ArchivaDatabaseException ae )
 186         {
 187             log.error( "Error occurred while querying artifacts for artifact count : " + ae.getMessage() );
 188         }
 189
 190         // total repo size -- TODO: needs to exclude ignored files (eg .svn)
 191         long size = FileUtils.sizeOfDirectory( new File( arepo.getLocation() ) );
 192         dbstats.setTotalSize( size );
 193
 194         // total unique groups
 195         List<String> repos = new ArrayList<String>();
 196         repos.add( arepo.getId() );
 197
 198         List<String> groupIds = (List<String>) dao.query( new UniqueGroupIdConstraint( repos ) );
 199         dbstats.setTotalGroupCount( groupIds.size() );
 200
 201         List<Object[]> artifactIds =
 202             (List<Object[]>) dao.query( new UniqueArtifactIdConstraint( arepo.getId(), true ) );
 203         dbstats.setTotalProjectCount( artifactIds.size() );
 204
 205         return dbstats;
 206     }
 207
 208     public Task getCurrentTaskInExecution()
 209     {
 210         return task;
 211     }
 212 }