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.io.File;
  23 import java.io.IOException;
  24 import java.util.ArrayList;
  25 import java.util.Enumeration;
  26 import java.util.HashMap;
  27 import java.util.List;
  28 import java.util.Map;
  29 import java.util.jar.JarEntry;
  30 import java.util.jar.JarFile;
  31
  32 import org.apache.commons.lang.StringUtils;
  33 import org.apache.maven.archiva.configuration.ArchivaConfiguration;
  34 import org.apache.maven.archiva.configuration.ConfigurationNames;
  35 import org.apache.maven.archiva.configuration.FileTypes;
  36 import org.apache.maven.archiva.configuration.ManagedRepositoryConfiguration;
  37 import org.apache.maven.archiva.consumers.AbstractMonitoredConsumer;
  38 import org.apache.maven.archiva.consumers.ConsumerException;
  39 import org.apache.maven.archiva.database.ArchivaDAO;
  40 import org.apache.maven.archiva.database.ArchivaDatabaseException;
  41 import org.apache.maven.archiva.database.updater.ArchivaArtifactConsumer;
  42 import org.apache.maven.archiva.model.ArchivaArtifact;
  43 import org.apache.maven.archiva.model.ArchivaProjectModel;
  44 import org.apache.maven.archiva.model.RepositoryProblem;
  45 import org.apache.maven.archiva.repository.ManagedRepositoryContent;
  46 import org.apache.maven.archiva.repository.RepositoryContentFactory;
  47 import org.apache.maven.archiva.repository.RepositoryException;
  48 import org.codehaus.plexus.personality.plexus.lifecycle.phase.Initializable;
  49 import org.codehaus.plexus.personality.plexus.lifecycle.phase.InitializationException;
  50 import org.codehaus.plexus.registry.Registry;
  51 import org.codehaus.plexus.registry.RegistryListener;
  52 import org.codehaus.plexus.util.SelectorUtils;
  53 import org.slf4j.Logger;
  54 import org.slf4j.LoggerFactory;
  55
  56 /**
  57  * Validate the location of the artifact based on the values indicated
  58  * in its pom (both the pom packaged with the artifact & the pom in the
  59  * file system).
  60  *
  61  * @version $Id$
  62  * @plexus.component role="org.apache.maven.archiva.database.updater.ArchivaArtifactConsumer"
  63  * role-hint="validate-artifacts-location"
  64  */
  65 public class LocationArtifactsConsumer
  66     extends AbstractMonitoredConsumer
  67     implements ArchivaArtifactConsumer, RegistryListener, Initializable
  68 {
  69     private Logger log = LoggerFactory.getLogger( LocationArtifactsConsumer.class );
  70
  71     /**
  72      * @plexus.configuration default-value="duplicate-artifacts"
  73      */
  74     private String id;
  75
  76     /**
  77      * @plexus.configuration default-value="Check for Duplicate Artifacts via SHA1 Checksums"
  78      */
  79     private String description;
  80
  81     /**
  82      * @plexus.requirement
  83      */
  84     private ArchivaConfiguration configuration;
  85
  86     /**
  87      * @plexus.requirement
  88      */
  89     private FileTypes filetypes;
  90
  91     /**
  92      * @plexus.requirement role-hint="jdo"
  93      */
  94     private ArchivaDAO dao;
  95
  96     /**
  97      * @plexus.requirement
  98      */
  99     private RepositoryContentFactory repositoryFactory;
 100
 101     private Map<String, ManagedRepositoryConfiguration> repositoryMap =
 102         new HashMap<String, ManagedRepositoryConfiguration>();
 103
 104     // TODO: why is this not used? If it should be, what about excludes?
 105     private List<String> includes = new ArrayList<String>();
 106
 107     public String getId()
 108     {
 109         return id;
 110     }
 111
 112     public String getDescription()
 113     {
 114         return description;
 115     }
 116
 117     public boolean isPermanent()
 118     {
 119         return false;
 120     }
 121
 122     public void beginScan()
 123     {
 124         /* do nothing */
 125     }
 126
 127     public void completeScan()
 128     {
 129         /* do nothing */
 130     }
 131
 132     public List<String> getIncludedTypes()
 133     {
 134         return null;
 135     }
 136
 137     /**
 138      * Check whether the artifact is in its proper location. The location of the artifact
 139      * is validated first against the groupId, artifactId and versionId in the specified model
 140      * object (pom in the file system). Then unpack the artifact (jar file) and get the model (pom)
 141      * included in the package. If a model exists inside the package, then check if the artifact's
 142      * location is valid based on the location specified in the pom. Check if the both the location
 143      * specified in the file system pom and in the pom included in the package is the same.
 144      */
 145     public void processArchivaArtifact( ArchivaArtifact artifact )
 146         throws ConsumerException
 147     {
 148         ManagedRepositoryConfiguration repository = findRepository( artifact );
 149
 150         File artifactFile = new File( repository.getLocation(), toPath( artifact ) );
 151         ArchivaProjectModel fsModel = readFilesystemModel( artifactFile );
 152         ArchivaProjectModel embeddedModel = readEmbeddedModel( artifact, artifactFile );
 153
 154         validateAppropriateModel( "Filesystem", artifact, fsModel );
 155         validateAppropriateModel( "Embedded", artifact, embeddedModel );
 156     }
 157
 158     private void validateAppropriateModel( String location, ArchivaArtifact artifact, ArchivaProjectModel model )
 159         throws ConsumerException
 160     {
 161         if ( model != null )
 162         {
 163             if ( !StringUtils.equals( model.getGroupId(), artifact.getGroupId() ) )
 164             {
 165                 addProblem( artifact, "The groupId of the " + location +
 166                     " project model doesn't match with the artifact, expected <" + artifact.getGroupId() +
 167                     ">, but was actually <" + model.getGroupId() + ">" );
 168             }
 169
 170             if ( !StringUtils.equals( model.getArtifactId(), artifact.getArtifactId() ) )
 171             {
 172                 addProblem( artifact, "The artifactId of the " + location +
 173                     " project model doesn't match with the artifact, expected <" + artifact.getArtifactId() +
 174                     ">, but was actually <" + model.getArtifactId() + ">" );
 175             }
 176
 177             if ( !StringUtils.equals( model.getVersion(), artifact.getVersion() ) )
 178             {
 179                 addProblem( artifact, "The version of the " + location +
 180                     " project model doesn't match with the artifact, expected <" + artifact.getVersion() +
 181                     ">, but was actually <" + model.getVersion() + ">" );
 182             }
 183         }
 184     }
 185
 186     private ArchivaProjectModel readEmbeddedModel( ArchivaArtifact artifact, File artifactFile )
 187         throws ConsumerException
 188     {
 189         try
 190         {
 191             JarFile jar = new JarFile( artifactFile );
 192
 193             // Get the entry and its input stream.
 194             JarEntry expectedEntry = jar.getJarEntry(
 195                 "META-INF/maven/" + artifact.getGroupId() + "/" + artifact.getArtifactId() + "/pom.xml" );
 196
 197             if ( expectedEntry != null )
 198             {
 199                 // TODO: read and resolve model here.
 200                 return null;
 201             }
 202
 203             /* Expected Entry not found, look for alternate that might
 204             * indicate that the artifact is, indeed located in the wrong place.
 205             */
 206
 207             List<JarEntry> actualPomXmls = findJarEntryPattern( jar, "META-INF/maven/**/pom.xml" );
 208             if ( actualPomXmls.isEmpty() )
 209             {
 210                 // No check needed.
 211
 212             }
 213
 214             // TODO: test for invalid actual pom.xml
 215             // TODO: test
 216         }
 217         catch ( IOException e )
 218         {
 219             // Not able to read from the file.
 220             String emsg = "Unable to read file contents: " + e.getMessage();
 221             addProblem( artifact, emsg );
 222         }
 223
 224         return null;
 225     }
 226
 227     private List<JarEntry> findJarEntryPattern( JarFile jar, String pattern )
 228     {
 229         List<JarEntry> hits = new ArrayList<JarEntry>();
 230
 231         Enumeration<JarEntry> entries = jar.entries();
 232         while ( entries.hasMoreElements() )
 233         {
 234             JarEntry entry = entries.nextElement();
 235             if ( SelectorUtils.match( pattern, entry.getName() ) )
 236             {
 237                 hits.add( entry );
 238             }
 239         }
 240
 241         return hits;
 242     }
 243
 244     private void addProblem( ArchivaArtifact artifact, String msg )
 245         throws ConsumerException
 246     {
 247         RepositoryProblem problem = new RepositoryProblem();
 248         problem.setRepositoryId( artifact.getModel().getRepositoryId() );
 249         problem.setPath( toPath( artifact ) );
 250         problem.setGroupId( artifact.getGroupId() );
 251         problem.setArtifactId( artifact.getArtifactId() );
 252         problem.setVersion( artifact.getVersion() );
 253         problem.setType( LocationArtifactsReport.PROBLEM_TYPE_BAD_ARTIFACT_LOCATION );
 254         problem.setOrigin( getId() );
 255         problem.setMessage( msg );
 256
 257         try
 258         {
 259             dao.getRepositoryProblemDAO().saveRepositoryProblem( problem );
 260         }
 261         catch ( ArchivaDatabaseException e )
 262         {
 263             String emsg = "Unable to save problem with artifact location to DB: " + e.getMessage();
 264             log.warn( emsg, e );
 265             throw new ConsumerException( emsg, e );
 266         }
 267     }
 268
 269     private ArchivaProjectModel readFilesystemModel( File artifactFile )
 270     {
 271 //        File pomFile = createPomFileReference( artifactFile );
 272
 273         // TODO: read and resolve model here.
 274
 275         return null;
 276     }
 277
 278 //    private File createPomFileReference( File artifactFile )
 279 //    {
 280 //        String pomFilename = artifactFile.getAbsolutePath();
 281 //
 282 //        int pos = pomFilename.lastIndexOf( '.' );
 283 //        if ( pos <= 0 )
 284 //        {
 285 //            // Invalid filename.
 286 //            return null;
 287 //        }
 288 //
 289 //        pomFilename = pomFilename.substring( 0, pos ) + ".pom";
 290 //        return new File( pomFilename );
 291 //    }
 292
 293     private ManagedRepositoryConfiguration findRepository( ArchivaArtifact artifact )
 294     {
 295         return (ManagedRepositoryConfiguration) this.repositoryMap.get( artifact.getModel().getRepositoryId() );
 296     }
 297
 298     private String toPath( ArchivaArtifact artifact )
 299     {
 300         try
 301         {
 302             String repoId = artifact.getModel().getRepositoryId();
 303             ManagedRepositoryContent repo = repositoryFactory.getManagedRepositoryContent( repoId );
 304             return repo.toPath( artifact );
 305         }
 306         catch ( RepositoryException e )
 307         {
 308             log.warn( "Unable to calculate path for artifact: " + artifact );
 309             return "";
 310         }
 311     }
 312
 313     public void afterConfigurationChange( Registry registry, String propertyName, Object propertyValue )
 314     {
 315         if ( ConfigurationNames.isManagedRepositories( propertyName ) )
 316         {
 317             initRepositoryMap();
 318         }
 319
 320         if ( ConfigurationNames.isRepositoryScanning( propertyName ) )
 321         {
 322             initIncludes();
 323         }
 324     }
 325
 326     public void beforeConfigurationChange( Registry registry, String propertyName, Object propertyValue )
 327     {
 328         /* do nothing */
 329     }
 330
 331     private void initIncludes()
 332     {
 333         includes.clear();
 334
 335         includes.addAll( filetypes.getFileTypePatterns( FileTypes.ARTIFACTS ) );
 336     }
 337
 338     private void initRepositoryMap()
 339     {
 340         synchronized ( this.repositoryMap )
 341         {
 342             this.repositoryMap.clear();
 343
 344             Map<String, ManagedRepositoryConfiguration> map =
 345                 configuration.getConfiguration().getManagedRepositoriesAsMap();
 346
 347             for ( Map.Entry<String, ManagedRepositoryConfiguration> entry : map.entrySet() )
 348             {
 349                 this.repositoryMap.put( entry.getKey(), entry.getValue() );
 350             }
 351         }
 352     }
 353
 354     public void initialize()
 355         throws InitializationException
 356     {
 357         initRepositoryMap();
 358         initIncludes();
 359         configuration.addChangeListener( this );
 360     }
 361 }