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.codehaus.plexus.util.FileUtils;
  20
  21 import java.io.BufferedOutputStream;
  22 import java.io.BufferedReader;
  23 import java.io.File;
  24 import java.io.FileInputStream;
  25 import java.io.FileNotFoundException;
  26 import java.io.FileOutputStream;
  27 import java.io.FileReader;
  28 import java.io.IOException;
  29 import java.io.InputStream;
  30 import java.io.OutputStream;
  31 import java.io.OutputStreamWriter;
  32 import java.security.MessageDigest;
  33 import java.security.NoSuchAlgorithmException;
  34 import java.util.jar.JarEntry;
  35 import java.util.jar.JarOutputStream;
  36
  37 /**
  38  * This class creates the artifact and metadata files used for testing the ChecksumArtifactReporter.
  39  * It is extended by ChecksumArtifactReporterTest class.
  40  */
  41 public abstract class AbstractChecksumArtifactReporterTest
  42     extends AbstractRepositoryReportsTestCase
  43 {
  44     protected static final String[] validArtifactChecksumJars = {"validArtifact-1.0"};
  45
  46     protected static final String[] invalidArtifactChecksumJars = {"invalidArtifact-1.0"};
  47
  48     protected static final String metadataChecksumFilename = "maven-metadata-repository";
  49
  50     public AbstractChecksumArtifactReporterTest()
  51     {
  52     }
  53
  54     public void setUp()
  55         throws Exception
  56     {
  57         super.setUp();
  58     }
  59
  60     public void tearDown()
  61         throws Exception
  62     {
  63         super.tearDown();
  64     }
  65
  66     /**
  67      * Create checksum files.
  68      *
  69      * @param type The type of checksum file to be created.
  70      * @return
  71      */
  72     protected boolean createChecksumFile( String type )
  73     {
  74         boolean written = true;
  75
  76         //loop through the valid artifact names..
  77         if ( "VALID".equals( type ) )
  78         {
  79             for ( int i = 0; i < validArtifactChecksumJars.length; i++ )
  80             {
  81                 written = writeChecksumFile( "checksumTest/", validArtifactChecksumJars[i], "jar", true );
  82                 if ( written == false )
  83                 {
  84                     i = validArtifactChecksumJars.length;
  85                 }
  86             }
  87         }
  88         else if ( "INVALID".equals( type ) )
  89         {
  90             for ( int i = 0; i < invalidArtifactChecksumJars.length; i++ )
  91             {
  92                 written = writeChecksumFile( "checksumTest/", invalidArtifactChecksumJars[i], "jar", false );
  93                 if ( written == false )
  94                 {
  95                     i = invalidArtifactChecksumJars.length;
  96                 }
  97             }
  98         }
  99
 100         return written;
 101     }
 102
 103     /**
 104      * Create checksum files for metadata.
 105      *
 106      * @param type The type of checksum to be created. (Valid or invalid)
 107      * @return
 108      */
 109     protected boolean createMetadataFile( String type )
 110     {
 111         boolean written = true;
 112
 113         //loop through the valid artifact names..
 114         if ( "VALID".equals( type ) )
 115         {
 116             writeMetadataFile( "checksumTest/validArtifact/1.0/", metadataChecksumFilename, "xml", true );
 117             writeMetadataFile( "checksumTest/validArtifact/", metadataChecksumFilename, "xml", true );
 118             writeMetadataFile( "checksumTest/", metadataChecksumFilename, "xml", true );
 119
 120         }
 121         else if ( "INVALID".equals( type ) )
 122         {
 123             writeMetadataFile( "checksumTest/invalidArtifact/1.0/", metadataChecksumFilename, "xml", false );
 124         }
 125
 126         return written;
 127     }
 128
 129     /**
 130      * Create artifact together with its checksums.
 131      *
 132      * @param relativePath The groupId
 133      * @param filename     The filename of the artifact to be created.
 134      * @param type         The file type (JAR)
 135      * @param isValid      Indicates whether the checksum to be created is valid or not.
 136      * @return
 137      */
 138     private boolean writeChecksumFile( String relativePath, String filename, String type, boolean isValid )
 139     {
 140         //System.out.println( " " );
 141         //System.out.println( "========================= ARTIFACT CHECKSUM ==================================" );
 142
 143         //Initialize variables for creating jar files
 144         FileOutputStream f = null;
 145         JarOutputStream out = null;
 146         String repoUrl = super.repository.getBasedir();
 147         try
 148         {
 149             String dirs = filename.replace( '-', '/' );
 150             //create the group level directory of the artifact
 151             File dirFiles = new File( repoUrl + relativePath + dirs );
 152
 153             if ( dirFiles.mkdirs() )
 154             {
 155
 156                 // create a jar file
 157                 f = new FileOutputStream( repoUrl + relativePath + dirs + "/" + filename + "." + type );
 158                 out = new JarOutputStream( new BufferedOutputStream( f ) );
 159
 160                 // jar sample.txt
 161                 String filename1 = repoUrl + relativePath + dirs + "/sample.txt";
 162                 boolean bool = createSampleFile( filename1 );
 163
 164                 BufferedReader in = new BufferedReader( new FileReader( filename1 ) );
 165                 out.putNextEntry( new JarEntry( filename1 ) );
 166                 int c;
 167                 while ( ( c = in.read() ) != -1 )
 168                 {
 169                     out.write( c );
 170                 }
 171                 in.close();
 172                 out.close();
 173
 174                 //Create md5 and sha-1 checksum files..
 175                 byte[] md5chk = createChecksum( repoUrl + relativePath + dirs + "/" + filename + "." + type, "MD5" );
 176                 byte[] sha1chk = createChecksum( repoUrl + relativePath + dirs + "/" + filename + "." + type, "SHA-1" );
 177                 //System.out.println( "----- CREATED MD5 checksum ::: " + byteArrayToHexStr( md5chk ) );
 178                 //System.out.println( "----- CREATED SHA-1 checksum ::: " + byteArrayToHexStr( sha1chk ) );
 179
 180                 File file = null;
 181
 182                 if ( md5chk != null )
 183                 {
 184                     file = new File( repoUrl + relativePath + dirs + "/" + filename + "." + type + ".md5" );
 185                     OutputStream os = new FileOutputStream( file );
 186                     OutputStreamWriter osw = new OutputStreamWriter( os );
 187                     if ( !isValid )
 188                     {
 189                         osw.write( byteArrayToHexStr( md5chk ) + "1" );
 190                     }
 191                     else
 192                     {
 193                         osw.write( byteArrayToHexStr( md5chk ) );
 194                     }
 195                     osw.close();
 196                 }
 197
 198                 if ( sha1chk != null )
 199                 {
 200                     file = new File( repoUrl + relativePath + dirs + "/" + filename + "." + type + ".sha1" );
 201                     OutputStream os = new FileOutputStream( file );
 202                     OutputStreamWriter osw = new OutputStreamWriter( os );
 203                     if ( !isValid )
 204                     {
 205                         osw.write( byteArrayToHexStr( sha1chk ) + "2" );
 206                     }
 207                     else
 208                     {
 209                         osw.write( byteArrayToHexStr( sha1chk ) );
 210                     }
 211                     osw.close();
 212                 }
 213             }
 214         }
 215         catch ( Exception e )
 216         {
 217             return false;
 218         }
 219         return true;
 220     }
 221
 222     /**
 223      * Create metadata file together with its checksums.
 224      *
 225      * @param relativePath The groupId
 226      * @param filename     The filename of the artifact to be created.
 227      * @param type         The file type (JAR)
 228      * @param isValid      Indicates whether the checksum to be created is valid or not.
 229      * @return
 230      */
 231     private boolean writeMetadataFile( String relativePath, String filename, String type, boolean isValid )
 232     {
 233         // System.out.println( " " );
 234         // System.out.println( "========================= METADATA CHECKSUM ==================================" );
 235         try
 236         {
 237             //create checksum for the metadata file..
 238             String repoUrl = repository.getBasedir();
 239             String url = repository.getBasedir() + "/" + filename + "." + type;
 240
 241             FileUtils.copyFile( new File( url ), new File( repoUrl + relativePath + filename + "." + type ) );
 242
 243             //Create md5 and sha-1 checksum files..
 244             byte[] md5chk = createChecksum( repoUrl + relativePath + filename + "." + type, "MD5" );
 245             byte[] sha1chk = createChecksum( repoUrl + relativePath + filename + "." + type, "SHA-1" );
 246             //System.out.println( "----- CREATED MD5 checksum ::: " + byteArrayToHexStr( md5chk ) );
 247             //System.out.println( "----- CREATED SHA-1 checksum ::: " + byteArrayToHexStr( sha1chk ) );
 248
 249             File file = null;
 250
 251             if ( md5chk != null )
 252             {
 253                 file = new File( repoUrl + relativePath + filename + "." + type + ".md5" );
 254                 OutputStream os = new FileOutputStream( file );
 255                 OutputStreamWriter osw = new OutputStreamWriter( os );
 256                 if ( !isValid )
 257                 {
 258                     osw.write( byteArrayToHexStr( md5chk ) + "1" );
 259                 }
 260                 else
 261                 {
 262                     osw.write( byteArrayToHexStr( md5chk ) );
 263                 }
 264                 osw.close();
 265             }
 266
 267             if ( sha1chk != null )
 268             {
 269                 file = new File( repoUrl + relativePath + filename + "." + type + ".sha1" );
 270                 OutputStream os = new FileOutputStream( file );
 271                 OutputStreamWriter osw = new OutputStreamWriter( os );
 272                 if ( !isValid )
 273                 {
 274                     osw.write( byteArrayToHexStr( sha1chk ) + "2" );
 275                 }
 276                 else
 277                 {
 278                     osw.write( byteArrayToHexStr( sha1chk ) );
 279                 }
 280                 osw.close();
 281             }
 282         }
 283         catch ( Exception e )
 284         {
 285             e.printStackTrace();
 286             return false;
 287         }
 288
 289         return true;
 290     }
 291
 292     /**
 293      * Create the sample file that will be included in the jar.
 294      *
 295      * @param filename
 296      * @return
 297      */
 298     private boolean createSampleFile( String filename )
 299     {
 300         try
 301         {
 302             File file = new File( filename );
 303             OutputStream os = new FileOutputStream( file );
 304             OutputStreamWriter osw = new OutputStreamWriter( os );
 305             osw.write( "This is the content of the sample file that will be included in the jar file." );
 306             osw.close();
 307         }
 308         catch ( Exception e )
 309         {
 310             return false;
 311         }
 312         return true;
 313     }
 314
 315     /**
 316      * Create a checksum from the specified metadata file.
 317      *
 318      * @param metadataUrl
 319      * @return
 320      * @throws FileNotFoundException
 321      * @throws NoSuchAlgorithmException
 322      * @throws IOException
 323      */
 324     private byte[] createChecksum( String filename, String algo )
 325         throws FileNotFoundException, NoSuchAlgorithmException, IOException
 326     {
 327
 328         InputStream fis = new FileInputStream( filename );
 329         byte[] buffer = new byte[1024];
 330
 331         MessageDigest complete = MessageDigest.getInstance( algo );
 332         int numRead;
 333         do
 334         {
 335             numRead = fis.read( buffer );
 336             if ( numRead > 0 )
 337             {
 338                 complete.update( buffer, 0, numRead );
 339             }
 340         }
 341         while ( numRead != -1 );
 342         fis.close();
 343
 344         return complete.digest();
 345     }
 346
 347     /**
 348      * Convert an incoming array of bytes into a string that represents each of
 349      * the bytes as two hex characters.
 350      *
 351      * @param data
 352      * @return
 353      */
 354     private String byteArrayToHexStr( byte[] data )
 355     {
 356         String output = "";
 357         String tempStr = "";
 358         int tempInt = 0;
 359
 360         for ( int cnt = 0; cnt < data.length; cnt++ )
 361         {
 362             tempInt = data[cnt] & 0xFF;
 363             tempStr = Integer.toHexString( tempInt );
 364
 365             if ( tempStr.length() == 1 )
 366             {
 367                 tempStr = "0" + tempStr;
 368             }
 369             output = output + tempStr;
 370         }
 371
 372         return output.toUpperCase();
 373     }
 374
 375     /**
 376      * Delete the test directory created in the repository.
 377      *
 378      * @param dirname The directory to be deleted.
 379      * @return
 380      */
 381     protected boolean deleteTestDirectory( File dir )
 382     {
 383         boolean b = false;
 384
 385         try
 386         {
 387             FileUtils.deleteDirectory( dir );
 388             b = true;
 389         }
 390         catch ( IOException ioe )
 391         {
 392             ioe.printStackTrace();
 393         }
 394
 395         return b;
 396     }
 397
 398     private boolean deleteFile( String filename )
 399     {
 400         File f = new File( filename );
 401         return f.delete();
 402     }
 403
 404     /**
 405      * @return
 406      */
 407     protected boolean deleteChecksumFiles( String type )
 408     {
 409
 410         boolean b = true;
 411
 412         //delete valid checksum files of artifacts created
 413         for ( int i = 0; i < validArtifactChecksumJars.length; i++ )
 414         {
 415             b = deleteFile( repository.getBasedir() + "checksumTest/" +
 416                 validArtifactChecksumJars[i].replace( '-', '/' ) + "/" + validArtifactChecksumJars[i] + "." + type +
 417                 ".md5" );
 418             if ( b == false )
 419             {
 420                 return b;
 421             }
 422
 423             b = deleteFile( repository.getBasedir() + "checksumTest/" +
 424                 validArtifactChecksumJars[i].replace( '-', '/' ) + "/" + validArtifactChecksumJars[i] + "." + type +
 425                 ".sha1" );
 426             if ( b == false )
 427             {
 428                 return b;
 429             }
 430         }
 431
 432         //delete valid checksum files of metadata file
 433         for ( int i = 0; i < validArtifactChecksumJars.length; i++ )
 434         {
 435             b = deleteFile( repository.getBasedir() + "checksumTest/" +
 436                 validArtifactChecksumJars[i].replace( '-', '/' ) + "/" + metadataChecksumFilename + ".xml.md5" );
 437             if ( b == false )
 438             {
 439                 return b;
 440             }
 441
 442             b = deleteFile( repository.getBasedir() + "checksumTest/" +
 443                 validArtifactChecksumJars[i].replace( '-', '/' ) + "/" + metadataChecksumFilename + ".xml.sha1" );
 444             if ( b == false )
 445             {
 446                 return b;
 447             }
 448         }
 449         return b;
 450     }
 451
 452 }