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

   1 package org.apache.maven.repository.reporting;
   2
   3 /*
   4  * Copyright 2005-2006 The Apache Software Foundation.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19 import org.apache.maven.artifact.Artifact;
  20 import org.apache.maven.artifact.repository.ArtifactRepository;
  21 import org.apache.maven.model.Model;
  22 import org.apache.maven.model.io.xpp3.MavenXpp3Reader;
  23 import org.codehaus.plexus.util.FileUtils;
  24
  25 import java.io.File;
  26 import java.io.FileInputStream;
  27 import java.io.FileOutputStream;
  28 import java.io.IOException;
  29 import java.io.InputStream;
  30 import java.io.InputStreamReader;
  31 import java.io.Reader;
  32 import java.net.URL;
  33 import java.util.jar.JarEntry;
  34 import java.util.jar.JarFile;
  35
  36 /**
  37  * Validate the location of the artifact based on the values indicated
  38  * in its pom (both the pom packaged with the artifact & the pom in the
  39  * file system).
  40  */
  41 public class LocationArtifactReportProcessor
  42     implements ArtifactReportProcessor
  43 {
  44     private boolean isLocal = true;
  45
  46     private InputStream is;
  47
  48     /**
  49      * Check whether the artifact is in its proper location. The location of the artifact
  50      * is validated first against the groupId, artifactId and versionId in the specified model
  51      * object (pom in the file system). Then unpack the artifact (jar file) and get the model (pom)
  52      * included in the package. If a model exists inside the package, then check if the artifact's
  53      * location is valid based on the location specified in the pom. Check if the both the location
  54      * specified in the file system pom and in the pom included in the package is the same.
  55      *
  56      * @param model      Represents the pom in the file system.
  57      * @param artifact
  58      * @param reporter
  59      * @param repository
  60      */
  61     public void processArtifact( Model model, Artifact artifact, ArtifactReporter reporter,
  62                                  ArtifactRepository repository )
  63     {
  64         boolean fsPomLocation = false, pkgPomLocation = false;
  65         String repositoryUrl = "", modelArtifactLocation = "";
  66
  67         if ( !repository.getProtocol().equals( "file" ) )
  68         {
  69             isLocal = false;
  70             repositoryUrl = repository.getUrl();
  71         }
  72         else
  73         {
  74             repositoryUrl = repository.getBasedir();
  75         }
  76
  77         //check if the artifact is located in its proper location based on the info
  78         //specified in the model object/pom
  79         modelArtifactLocation = repositoryUrl + model.getGroupId() + "/" + model.getArtifactId() + "/" +
  80             model.getVersion() + "/" + model.getArtifactId() + "-" + model.getVersion() + "." + model.getPackaging();
  81         fsPomLocation = validateArtifactLocation( modelArtifactLocation );
  82
  83         //get the location of the artifact itself
  84         String artifactLocation = repositoryUrl + artifact.getGroupId() + "/" + artifact.getArtifactId() + "/" +
  85             artifact.getVersion() + "/" + artifact.getArtifactId() + "-" + artifact.getVersion() + "." +
  86             artifact.getType();
  87
  88         //unpack the artifact (using the groupId, artifactId & version specified in the artifact object itself
  89         //check if the pom is included in the package
  90         Model extractedModel =
  91             unpackArtifact( artifactLocation, artifact.getGroupId(), artifact.getArtifactId(), artifact.getVersion() );
  92
  93         if ( extractedModel != null )
  94         {
  95
  96             String pkgPomArtifactLocation = repositoryUrl + extractedModel.getGroupId() + "/" +
  97                 extractedModel.getArtifactId() + "/" + extractedModel.getVersion() + "/" +
  98                 extractedModel.getArtifactId() + "-" + extractedModel.getVersion() + "." +
  99                 extractedModel.getPackaging();
 100             pkgPomLocation = validateArtifactLocation( pkgPomArtifactLocation );
 101
 102             //check the conditions
 103             if ( fsPomLocation == true && pkgPomLocation == true )
 104             {
 105                 reporter.addSuccess( artifact );
 106
 107             }
 108             else if ( fsPomLocation == false && pkgPomLocation == true )
 109             {
 110                 reporter
 111                     .addFailure( artifact,
 112                                  "The artifact is out of place. It does not match the specified location in the file system pom." );
 113
 114             }
 115             else if ( fsPomLocation == true && pkgPomLocation == false )
 116             {
 117                 reporter
 118                     .addFailure( artifact,
 119                                  "The artifact is out of place. It does not match the specified location in the packaged pom." );
 120
 121             }
 122             else if ( fsPomLocation == false && pkgPomLocation == false )
 123             {
 124                 reporter.addFailure( artifact, "The artifact is out of place." );
 125             }
 126
 127         }
 128         else
 129         {
 130
 131             if ( fsPomLocation )
 132             {
 133                 reporter.addSuccess( artifact );
 134
 135             }
 136             else
 137             {
 138                 reporter.addFailure( artifact, "The artifact is out of place." );
 139             }
 140         }
 141     }
 142
 143     /**
 144      * Validate the if the artifact exists in the specified location.
 145      *
 146      * @param filename
 147      * @return
 148      */
 149     private boolean validateArtifactLocation( String filename )
 150     {
 151         try
 152         {
 153             if ( isLocal )
 154             {
 155                 is = new FileInputStream( filename );
 156             }
 157             else
 158             {
 159                 URL url = new URL( filename );
 160                 is = url.openStream();
 161             }
 162
 163             is.close();
 164         }
 165         catch ( Exception e )
 166         {
 167             return false;
 168         }
 169         return true;
 170     }
 171
 172     /**
 173      * Extract the contents of the artifact/jar file.
 174      *
 175      * @param filename
 176      * @param groupId
 177      * @param artifactId
 178      * @param version
 179      */
 180     private Model unpackArtifact( String filename, String groupId, String artifactId, String version )
 181     {
 182         String basedir = "";
 183         Model modelObj = null;
 184
 185         basedir = System.getProperty( "basedir" );
 186         File f = new File( basedir + "/" + "temp" );
 187         boolean b = f.mkdirs();
 188
 189         try
 190         {
 191             JarFile jar = new JarFile( filename );
 192
 193             try
 194             {
 195                 //Get the entry and its input stream.
 196                 JarEntry entry = jar.getJarEntry( "META-INF/maven/" + groupId + "/" + artifactId + "/pom.xml" );
 197
 198                 // If the entry is not null, extract it.
 199                 if ( entry != null )
 200                 {
 201                     InputStream entryStream = jar.getInputStream( entry );
 202
 203                     try
 204                     {
 205
 206                         //Create the output file (clobbering the file if it exists).
 207                         FileOutputStream file = new FileOutputStream( basedir + "/temp/pom.xml" );
 208
 209                         try
 210                         {
 211                             byte[] buffer = new byte[1024];
 212                             int bytesRead;
 213
 214                             while ( ( bytesRead = entryStream.read( buffer ) ) != -1 )
 215                             {
 216                                 file.write( buffer, 0, bytesRead );
 217                             }
 218
 219                         }
 220                         finally
 221                         {
 222                             file.close();
 223                         }
 224                         InputStream inputStream = new FileInputStream( basedir + "/temp/pom.xml" );
 225                         Reader isReader = new InputStreamReader( inputStream );
 226
 227                         try
 228                         {
 229                             MavenXpp3Reader pomReader = new MavenXpp3Reader();
 230                             modelObj = pomReader.read( isReader );
 231                         }
 232                         finally
 233                         {
 234                             isReader.close();
 235                             inputStream.close();
 236                         }
 237
 238                     }
 239                     finally
 240                     {
 241                         entryStream.close();
 242                     }
 243                 }
 244                 else
 245                 {
 246                     return modelObj;
 247                 }
 248
 249             }
 250             finally
 251             {
 252                 jar.close();
 253             }
 254
 255         }
 256         catch ( Exception e )
 257         {
 258             return modelObj;
 259
 260         }
 261         finally
 262         {
 263             try
 264             {
 265                 FileUtils.deleteDirectory( new File( basedir + "/temp" ) );
 266             }
 267             catch ( IOException ie )
 268             {
 269                 return modelObj;
 270             }
 271         }
 272         return modelObj;
 273     }
 274
 275 }