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