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

   1 package org.apache.maven.archiva.consumers.database;
   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.lang.StringUtils;
  27 import org.apache.maven.archiva.common.utils.VersionUtil;
  28 import org.apache.maven.archiva.consumers.AbstractMonitoredConsumer;
  29 import org.apache.maven.archiva.consumers.ConsumerException;
  30 import org.apache.maven.archiva.consumers.DatabaseUnprocessedArtifactConsumer;
  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.model.ArchivaArtifact;
  35 import org.apache.maven.archiva.model.ArchivaModelCloner;
  36 import org.apache.maven.archiva.model.ArchivaProjectModel;
  37 import org.apache.maven.archiva.model.Keys;
  38 import org.apache.maven.archiva.model.RepositoryProblem;
  39 import org.apache.maven.archiva.reporting.artifact.CorruptArtifactReport;
  40 import org.apache.maven.archiva.repository.ManagedRepositoryContent;
  41 import org.apache.maven.archiva.repository.RepositoryContentFactory;
  42 import org.apache.maven.archiva.repository.RepositoryException;
  43 import org.apache.maven.archiva.repository.content.ManagedLegacyRepositoryContent;
  44 import org.apache.maven.archiva.repository.project.ProjectModelException;
  45 import org.apache.maven.archiva.repository.project.ProjectModelReader;
  46 import org.apache.maven.archiva.repository.project.filters.EffectiveProjectModelFilter;
  47 import org.apache.maven.archiva.repository.project.readers.ProjectModel300Reader;
  48 import org.apache.maven.archiva.repository.project.readers.ProjectModel400Reader;
  49 import org.codehaus.plexus.cache.Cache;
  50 import org.slf4j.Logger;
  51 import org.slf4j.LoggerFactory;
  52
  53 /**
  54  * ProjectModelToDatabaseConsumer
  55  *
  56  * @version $Id$
  57  * @plexus.component role="org.apache.maven.archiva.consumers.DatabaseUnprocessedArtifactConsumer"
  58  * role-hint="update-db-project"
  59  * instantiation-strategy="per-lookup"
  60  */
  61 public class ProjectModelToDatabaseConsumer
  62     extends AbstractMonitoredConsumer
  63     implements DatabaseUnprocessedArtifactConsumer
  64 {
  65     private Logger log = LoggerFactory.getLogger( ProjectModelToDatabaseConsumer.class );
  66
  67     /**
  68      * @plexus.configuration default-value="update-db-project"
  69      */
  70     private String id;
  71
  72     /**
  73      * @plexus.configuration default-value="Update database with project model information."
  74      */
  75     private String description;
  76
  77     /**
  78      * @plexus.requirement role-hint="jdo"
  79      */
  80     private ArchivaDAO dao;
  81
  82     /**
  83      * @plexus.requirement
  84      */
  85     private RepositoryContentFactory repositoryFactory;
  86
  87     /**
  88      * @plexus.requirement role="org.apache.maven.archiva.repository.project.ProjectModelFilter"
  89      * role-hint="effective"
  90      */
  91     private EffectiveProjectModelFilter effectiveModelFilter;
  92
  93     private List<String> includes;
  94
  95     /**
  96      * @plexus.requirement role-hint="effective-project-cache"
  97      */
  98     private Cache effectiveProjectCache;
  99
 100     public ProjectModelToDatabaseConsumer()
 101     {
 102         includes = new ArrayList<String>();
 103         includes.add( "pom" );
 104     }
 105
 106     public void beginScan()
 107     {
 108         /* nothing to do here */
 109     }
 110
 111     public void completeScan()
 112     {
 113         /* nothing to do here */
 114     }
 115
 116     public List<String> getIncludedTypes()
 117     {
 118         return includes;
 119     }
 120
 121     public void processArchivaArtifact( ArchivaArtifact artifact )
 122         throws ConsumerException
 123     {
 124         if ( !StringUtils.equals( "pom", artifact.getType() ) )
 125         {
 126             // Not a pom.  Skip it.
 127             return;
 128         }
 129
 130         ArchivaProjectModel model = null;
 131
 132         // remove old project model if it already exists in the database
 133         if ( ( model =
 134             getProjectModelFromDatabase( artifact.getGroupId(), artifact.getArtifactId(), artifact.getVersion() ) ) != null )
 135         {
 136             removeOldProjectModel( model );
 137             model = null;
 138         }
 139
 140         ManagedRepositoryContent repo = getRepository( artifact );
 141         File artifactFile = repo.toFile( artifact );
 142
 143         ProjectModelReader reader;
 144         if ( repo instanceof ManagedLegacyRepositoryContent )
 145         {
 146             reader = new ProjectModel300Reader();
 147         }
 148         else
 149         {
 150             reader = new ProjectModel400Reader();
 151         }
 152
 153         try
 154         {
 155             model = reader.read( artifactFile );
 156
 157             // The version should be updated to the artifact/filename version if it is a unique snapshot
 158             if ( VersionUtil.isUniqueSnapshot( artifact.getVersion() ) )
 159             {
 160                 model.setVersion( artifact.getVersion() );
 161             }
 162
 163             // Resolve the project model (build effective model, resolve expressions)
 164             model = effectiveModelFilter.filter( model );
 165
 166             if ( isValidModel( model, repo, artifact ) )
 167             {
 168                 log.debug( "Adding project model to database - " + Keys.toKey( model ) );
 169
 170                 // Clone model, since DAO while detachingCopy resets its contents
 171                 // This changes contents of the cache in EffectiveProjectModelFilter
 172                 model = ArchivaModelCloner.clone( model );
 173                 dao.getProjectModelDAO().saveProjectModel( model );
 174             }
 175             else
 176             {
 177                 log.warn( "Invalid or corrupt pom. Project model not added to database - " + Keys.toKey( model ) );
 178             }
 179
 180         }
 181         catch ( ProjectModelException e )
 182         {
 183             log.warn( "Unable to read project model " + artifactFile + " : " + e.getMessage(), e );
 184
 185             addProblem( artifact, "Unable to read project model " + artifactFile + " : " + e.getMessage() );
 186         }
 187         catch ( ArchivaDatabaseException e )
 188         {
 189             log.warn( "Unable to save project model " + artifactFile + " to the database : " + e.getMessage(), e );
 190         }
 191         catch ( Throwable t )
 192         {
 193             // Catch the other errors in the process to allow the rest of the process to complete.
 194             log.error( "Unable to process model " + artifactFile + " due to : " + t.getClass().getName() + " : " +
 195                 t.getMessage(), t );
 196         }
 197     }
 198
 199     private ArchivaProjectModel getProjectModelFromDatabase( String groupId, String artifactId, String version )
 200     {
 201         try
 202         {
 203             ArchivaProjectModel model = dao.getProjectModelDAO().getProjectModel( groupId, artifactId, version );
 204             return model;
 205         }
 206         catch ( ObjectNotFoundException e )
 207         {
 208             return null;
 209         }
 210         catch ( ArchivaDatabaseException e )
 211         {
 212             return null;
 213         }
 214     }
 215
 216     private ManagedRepositoryContent getRepository( ArchivaArtifact artifact )
 217         throws ConsumerException
 218     {
 219         String repoId = artifact.getModel().getRepositoryId();
 220         try
 221         {
 222             return repositoryFactory.getManagedRepositoryContent( repoId );
 223         }
 224         catch ( RepositoryException e )
 225         {
 226             throw new ConsumerException( "Unable to process project model: " + e.getMessage(), e );
 227         }
 228     }
 229
 230     public String getDescription()
 231     {
 232         return description;
 233     }
 234
 235     public String getId()
 236     {
 237         return id;
 238     }
 239
 240     public boolean isPermanent()
 241     {
 242         // Tells the configuration that this consumer cannot be disabled.
 243         return true;
 244     }
 245
 246     private boolean isValidModel( ArchivaProjectModel model, ManagedRepositoryContent repo, ArchivaArtifact artifact )
 247         throws ConsumerException
 248     {
 249         File artifactFile = repo.toFile( artifact );
 250
 251         if ( !artifact.getArtifactId().equalsIgnoreCase( model.getArtifactId() ) )
 252         {
 253             StringBuffer emsg = new StringBuffer();
 254             emsg.append( "File " ).append( artifactFile.getName() );
 255             emsg.append( " has an invalid project model [" );
 256             appendModel( emsg, model );
 257             emsg.append( "]: The model artifactId [" ).append( model.getArtifactId() );
 258             emsg.append( "] does not match the artifactId portion of the filename: " ).append( artifact.getArtifactId() );
 259
 260             log.warn( emsg.toString() );
 261             addProblem( artifact, emsg.toString() );
 262
 263             return false;
 264         }
 265
 266         if ( !artifact.getVersion().equalsIgnoreCase( model.getVersion() ) &&
 267             !VersionUtil.getBaseVersion( artifact.getVersion() ).equalsIgnoreCase( model.getVersion() ) )
 268         {
 269             StringBuffer emsg = new StringBuffer();
 270             emsg.append( "File " ).append( artifactFile.getName() );
 271             emsg.append( " has an invalid project model [" );
 272             appendModel( emsg, model );
 273             emsg.append( "]; The model version [" ).append( model.getVersion() );
 274             emsg.append( "] does not match the version portion of the filename: " ).append( artifact.getVersion() );
 275
 276             log.warn( emsg.toString() );
 277             addProblem( artifact, emsg.toString() );
 278
 279             return false;
 280         }
 281
 282         return true;
 283     }
 284
 285     private void appendModel( StringBuffer buf, ArchivaProjectModel model )
 286     {
 287         buf.append( "groupId:" ).append( model.getGroupId() );
 288         buf.append( "|artifactId:" ).append( model.getArtifactId() );
 289         buf.append( "|version:" ).append( model.getVersion() );
 290         buf.append( "|packaging:" ).append( model.getPackaging() );
 291     }
 292
 293     private void addProblem( ArchivaArtifact artifact, String msg )
 294         throws ConsumerException
 295     {
 296         ManagedRepositoryContent repo = getRepository( artifact );
 297
 298         RepositoryProblem problem = new RepositoryProblem();
 299         problem.setRepositoryId( artifact.getModel().getRepositoryId() );
 300         problem.setPath( repo.toPath( artifact ) );
 301         problem.setGroupId( artifact.getGroupId() );
 302         problem.setArtifactId( artifact.getArtifactId() );
 303         problem.setVersion( artifact.getVersion() );
 304         problem.setType( CorruptArtifactReport.PROBLEM_TYPE_CORRUPT_ARTIFACT );
 305         problem.setOrigin( getId() );
 306         problem.setMessage( msg );
 307
 308         try
 309         {
 310             dao.getRepositoryProblemDAO().saveRepositoryProblem( problem );
 311         }
 312         catch ( ArchivaDatabaseException e )
 313         {
 314             String emsg = "Unable to save problem with artifact location to DB: " + e.getMessage();
 315             log.warn( emsg, e );
 316             throw new ConsumerException( emsg, e );
 317         }
 318     }
 319
 320     private String toProjectKey( ArchivaProjectModel project )
 321     {
 322         StringBuilder key = new StringBuilder();
 323
 324         key.append( project.getGroupId() ).append( ":" );
 325         key.append( project.getArtifactId() ).append( ":" );
 326         key.append( project.getVersion() );
 327
 328         return key.toString();
 329     }
 330
 331     private void removeOldProjectModel( ArchivaProjectModel model )
 332     {
 333         try
 334         {
 335             dao.getProjectModelDAO().deleteProjectModel( model );
 336         }
 337         catch ( ArchivaDatabaseException ae )
 338         {
 339             log.error( "Unable to delete existing project model." );
 340         }
 341
 342         // Force removal of project model from effective cache
 343         String projectKey = toProjectKey( model );
 344         synchronized ( effectiveProjectCache )
 345         {
 346             if ( effectiveProjectCache.hasKey( projectKey ) )
 347             {
 348                 effectiveProjectCache.remove( projectKey );
 349             }
 350         }
 351     }
 352 }