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