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

   1 package org.apache.maven.archiva.reporting.artifact;
   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.util.ArrayList;
  23 import java.util.List;
  24
  25 import org.apache.commons.collections.CollectionUtils;
  26 import org.apache.maven.archiva.configuration.ArchivaConfiguration;
  27 import org.apache.maven.archiva.configuration.ConfigurationNames;
  28 import org.apache.maven.archiva.configuration.FileTypes;
  29 import org.apache.maven.archiva.consumers.AbstractMonitoredConsumer;
  30 import org.apache.maven.archiva.consumers.ArchivaArtifactConsumer;
  31 import org.apache.maven.archiva.consumers.ConsumerException;
  32 import org.apache.maven.archiva.database.ArchivaDAO;
  33 import org.apache.maven.archiva.database.ArchivaDatabaseException;
  34 import org.apache.maven.archiva.database.ObjectNotFoundException;
  35 import org.apache.maven.archiva.database.constraints.ArtifactsByChecksumConstraint;
  36 import org.apache.maven.archiva.model.ArchivaArtifact;
  37 import org.apache.maven.archiva.model.RepositoryProblem;
  38 import org.apache.maven.archiva.repository.ManagedRepositoryContent;
  39 import org.apache.maven.archiva.repository.RepositoryContentFactory;
  40 import org.apache.maven.archiva.repository.RepositoryException;
  41 import org.codehaus.plexus.personality.plexus.lifecycle.phase.Initializable;
  42 import org.codehaus.plexus.personality.plexus.lifecycle.phase.InitializationException;
  43 import org.codehaus.plexus.registry.Registry;
  44 import org.codehaus.plexus.registry.RegistryListener;
  45 import org.slf4j.Logger;
  46 import org.slf4j.LoggerFactory;
  47
  48 /**
  49  * Search the database of known SHA1 Checksums for potential duplicate artifacts.
  50  *
  51  * @version $Id$
  52  *
  53  * @plexus.component role="org.apache.maven.archiva.consumers.ArchivaArtifactConsumer"
  54  *                   role-hint="duplicate-artifacts"
  55  */
  56 public class DuplicateArtifactsConsumer
  57     extends AbstractMonitoredConsumer
  58     implements ArchivaArtifactConsumer, RegistryListener, Initializable
  59 {
  60     private Logger log = LoggerFactory.getLogger( DuplicateArtifactsConsumer.class );
  61
  62     /**
  63      * @plexus.configuration default-value="duplicate-artifacts"
  64      */
  65     private String id;
  66
  67     /**
  68      * @plexus.configuration default-value="Check for Duplicate Artifacts via SHA1 Checksums"
  69      */
  70     private String description;
  71
  72     /**
  73      * @plexus.requirement
  74      */
  75     private ArchivaConfiguration configuration;
  76
  77     /**
  78      * @plexus.requirement
  79      */
  80     private FileTypes filetypes;
  81
  82     /**
  83      * @plexus.requirement role-hint="jdo"
  84      */
  85     private ArchivaDAO dao;
  86
  87     /**
  88      * @plexus.requirement
  89      */
  90     private RepositoryContentFactory repositoryFactory;
  91
  92     // TODO: why is this not used? If it should be, what about excludes?
  93     private List<String> includes = new ArrayList<String>();
  94
  95     public String getId()
  96     {
  97         return id;
  98     }
  99
 100     public String getDescription()
 101     {
 102         return description;
 103     }
 104
 105     public boolean isPermanent()
 106     {
 107         return false;
 108     }
 109
 110     public void beginScan()
 111     {
 112         /* do nothing */
 113     }
 114
 115     public void completeScan()
 116     {
 117         /* do nothing */
 118     }
 119
 120     public List<String> getIncludedTypes()
 121     {
 122         return null;
 123     }
 124
 125     public void processArchivaArtifact( ArchivaArtifact artifact )
 126         throws ConsumerException
 127     {
 128         String checksumSha1 = artifact.getModel().getChecksumSHA1();
 129
 130         List<ArchivaArtifact> results = null;
 131         try
 132         {
 133             results = dao.getArtifactDAO().queryArtifacts( new ArtifactsByChecksumConstraint(
 134                 checksumSha1, ArtifactsByChecksumConstraint.SHA1 ) );
 135         }
 136         catch ( ObjectNotFoundException e )
 137         {
 138             log.debug( "No duplicates for artifact: " + artifact );
 139             return;
 140         }
 141         catch ( ArchivaDatabaseException e )
 142         {
 143             log.warn( "Unable to query DB for potential duplicates with : " + artifact );
 144             return;
 145         }
 146
 147         if ( CollectionUtils.isNotEmpty( results ) )
 148         {
 149             if ( results.size() <= 1 )
 150             {
 151                 // No duplicates detected.
 152                 log.debug( "Found no duplicate artifact results on: " + artifact );
 153                 return;
 154             }
 155
 156             for ( ArchivaArtifact dupArtifact : results )
 157             {
 158                 if ( dupArtifact.equals( artifact ) )
 159                 {
 160                     // Skip reference to itself.
 161                     continue;
 162                 }
 163
 164                 RepositoryProblem problem = new RepositoryProblem();
 165                 problem.setRepositoryId( dupArtifact.getModel().getRepositoryId() );
 166                 problem.setPath( toPath( dupArtifact ) );
 167                 problem.setGroupId( artifact.getGroupId() );
 168                 problem.setArtifactId( artifact.getArtifactId() );
 169                 problem.setVersion( artifact.getVersion() );
 170                 problem.setType( DuplicateArtifactReport.PROBLEM_TYPE_DUPLICATE_ARTIFACTS );
 171                 problem.setOrigin( getId() );
 172                 problem.setMessage( "Duplicate Artifact Detected: " + artifact + " <--> " + dupArtifact );
 173
 174                 try
 175                 {
 176                     log.debug( "Found duplicate artifact: " + problem );
 177                     dao.getRepositoryProblemDAO().saveRepositoryProblem( problem );
 178                 }
 179                 catch ( ArchivaDatabaseException e )
 180                 {
 181                     String emsg = "Unable to save problem with duplicate artifact to DB: " + e.getMessage();
 182                     log.warn( emsg, e );
 183                     throw new ConsumerException( emsg, e );
 184                 }
 185             }
 186         }
 187     }
 188
 189     private String toPath( ArchivaArtifact artifact )
 190     {
 191         try
 192         {
 193             String repoId = artifact.getModel().getRepositoryId();
 194             ManagedRepositoryContent repo = repositoryFactory.getManagedRepositoryContent( repoId );
 195             return repo.toPath( artifact );
 196         }
 197         catch ( RepositoryException e )
 198         {
 199             log.warn( "Unable to calculate path for artifact: " + artifact );
 200             return "";
 201         }
 202     }
 203
 204     public void afterConfigurationChange( Registry registry, String propertyName, Object propertyValue )
 205     {
 206         if ( ConfigurationNames.isRepositoryScanning( propertyName ) )
 207         {
 208             initIncludes();
 209         }
 210     }
 211
 212     public void beforeConfigurationChange( Registry registry, String propertyName, Object propertyValue )
 213     {
 214         /* do nothing */
 215     }
 216
 217     private void initIncludes()
 218     {
 219         includes.clear();
 220
 221         includes.addAll( filetypes.getFileTypePatterns( FileTypes.ARTIFACTS ) );
 222     }
 223
 224     public void initialize()
 225         throws InitializationException
 226     {
 227         initIncludes();
 228         configuration.addChangeListener( this );
 229     }
 230 }