package org.apache.maven.plugins.stage;

 /*

  * Licensed to the Apache Software Foundation (ASF) under one

  * or more contributor license agreements.  See the NOTICE file

  * distributed with this work for additional information

  * regarding copyright ownership.  The ASF licenses this file

  * to you under the Apache License, Version 2.0 (the

  * "License"); you may not use this file except in compliance

  * with the License.  You may obtain a copy of the License at

  *

  *   http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing,

  * software distributed under the License is distributed on an

  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

  * KIND, either express or implied.  See the License for the

  * specific language governing permissions and limitations

  * under the License.

  */

 import org.apache.maven.artifact.manager.WagonManager;

 import org.apache.maven.artifact.repository.ArtifactRepository;

 import org.apache.maven.artifact.repository.metadata.Metadata;

 import org.apache.maven.artifact.repository.metadata.io.xpp3.MetadataXpp3Reader;

 import org.apache.maven.artifact.repository.metadata.io.xpp3.MetadataXpp3Writer;

 import org.apache.maven.wagon.CommandExecutor;

 import org.apache.maven.wagon.CommandExecutionException;

 import org.apache.maven.wagon.ConnectionException;

 import org.apache.maven.wagon.ResourceDoesNotExistException;

 import org.apache.maven.wagon.TransferFailedException;

 import org.apache.maven.wagon.UnsupportedProtocolException;

 import org.apache.maven.wagon.Wagon;

 import org.apache.maven.wagon.WagonException;

 import org.apache.maven.wagon.authentication.AuthenticationException;

 import org.apache.maven.wagon.authentication.AuthenticationInfo;

 import org.apache.maven.wagon.authorization.AuthorizationException;

 import org.apache.maven.wagon.repository.Repository;

 import org.codehaus.plexus.logging.LogEnabled;

 import org.codehaus.plexus.logging.Logger;

 import org.codehaus.plexus.util.FileUtils;

 import org.codehaus.plexus.util.IOUtil;

 import org.codehaus.plexus.util.StringUtils;

 import org.codehaus.plexus.util.xml.pull.XmlPullParserException;

 import java.io.File;

 import java.io.FileInputStream;

 import java.io.FileOutputStream;

 import java.io.FileReader;

 import java.io.FileWriter;

 import java.io.IOException;

 import java.io.InputStream;

 import java.io.OutputStream;

 import java.io.PrintWriter;

 import java.io.Reader;

 import java.io.Writer;

 import java.security.MessageDigest;

 import java.security.NoSuchAlgorithmException;

 import java.util.ArrayList;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Set;

 import java.util.TreeSet;

 import java.util.zip.ZipEntry;

 import java.util.zip.ZipOutputStream;

 /**

  * @author Jason van Zyl

  * @plexus.component

  */

 public class DefaultRepositoryCopier

     implements LogEnabled, RepositoryCopier

 {

     private MetadataXpp3Reader reader = new MetadataXpp3Reader();

     private MetadataXpp3Writer writer = new MetadataXpp3Writer();

     /** @plexus.requirement */

     private WagonManager wagonManager;

     private Logger logger;

     public void copy( Repository sourceRepository, Repository targetRepository, String version )

         throws WagonException, IOException

     {

         String prefix = "staging-plugin";

         String fileName = prefix + "-" + version + ".zip";

         String tempdir = System.getProperty( "java.io.tmpdir" );

         logger.debug( "Writing all output to " + tempdir );

         // Create the renameScript script

         String renameScriptName = prefix + "-" + version + "-rename.sh";

         File renameScript = new File( tempdir, renameScriptName );

         // Work directory

         File basedir = new File( tempdir, prefix + "-" + version );

         FileUtils.deleteDirectory( basedir );

         basedir.mkdirs();

         String protocol = sourceRepository.getProtocol();

         Wagon sourceWagon = wagonManager.getWagon( sourceRepository );

         AuthenticationInfo sourceAuth = wagonManager.getAuthenticationInfo( sourceRepository.getId() );

         sourceWagon.connect( sourceRepository, sourceAuth );

         logger.info( "Looking for files in the source repository." );

         List files = new ArrayList();

         scan( sourceWagon, "", files );

         logger.info( "Downloading files from the source repository to: " + basedir );

         for ( Iterator i = files.iterator(); i.hasNext(); )

         {

             String s = (String) i.next();

             if ( s.indexOf( ".svn" ) >= 0 )

             {

                 continue;

             }

             File f = new File( basedir, s );

             FileUtils.mkdir( f.getParentFile().getAbsolutePath() );

             logger.info( "Downloading file from the source repository: " + s );

             sourceWagon.get( s, f );

         }

         // ----------------------------------------------------------------------------

         // Now all the files are present locally and now we are going to grab the

         // metadata files from the targetRepositoryUrl and pull those down locally

         // so that we can merge the metadata.

         // ----------------------------------------------------------------------------

         logger.info( "Downloading metadata from the target repository." );

         Wagon targetWagon = wagonManager.getWagon( targetRepository );

         if ( ! ( targetWagon instanceof CommandExecutor ) )

         {

             throw new CommandExecutionException( "Wagon class '" + targetWagon.getClass().getName() +

                 "' in use for target repository is not a CommandExecutor" );

         }

         AuthenticationInfo targetAuth = wagonManager.getAuthenticationInfo( targetRepository.getId() );

         targetWagon.connect( targetRepository, targetAuth );

         PrintWriter rw = new PrintWriter( new FileWriter( renameScript ) );

         File archive = new File( tempdir, fileName );

         for ( Iterator i = files.iterator(); i.hasNext(); )

         {

             String s = (String) i.next();

             if ( s.startsWith( "/" ) )

             {

                 s = s.substring( 1 );

             }

             if ( s.endsWith( MAVEN_METADATA ) )

             {

                 File emf = new File( basedir, s + IN_PROCESS_MARKER );

                 try

                 {

                     targetWagon.get( s, emf );

                 }

                 catch ( ResourceDoesNotExistException e )

                 {

                     // We don't have an equivalent on the targetRepositoryUrl side because we have something

                     // new on the sourceRepositoryUrl side so just skip the metadata merging.

                     continue;

                 }

                 try

                 {

                     mergeMetadata( emf );

                 }

                 catch ( XmlPullParserException e )

                 {

                     throw new IOException( "Metadata file is corrupt " + s + " Reason: " + e.getMessage() );

                 }

             }

         }

         Set moveCommands = new TreeSet();

         // ----------------------------------------------------------------------------

         // Create the Zip file that we will deploy to the targetRepositoryUrl stage

         // ----------------------------------------------------------------------------

         logger.info( "Creating zip file." );

         OutputStream os = new FileOutputStream( archive );

         ZipOutputStream zos = new ZipOutputStream( os );

         scanDirectory( basedir, basedir, zos, version, moveCommands );

         // ----------------------------------------------------------------------------

         // Create the renameScript script. This is as atomic as we can

         // ----------------------------------------------------------------------------

         logger.info( "Creating rename script." );

         for ( Iterator i = moveCommands.iterator(); i.hasNext(); )

         {

             String s = (String) i.next();

             // We use an explicit unix '\n' line-ending here instead of using the println() method.

             // Using println() will cause files and folders to have a '\r' at the end if the plugin is run on Windows.

             rw.print( s + "\n" );

         }

         IOUtil.close( rw );

         ZipEntry e = new ZipEntry( renameScript.getName() );

         zos.putNextEntry( e );

         InputStream is = new FileInputStream( renameScript );

         IOUtil.copy( is, zos );

         IOUtil.close( is );

         IOUtil.close( zos );

         sourceWagon.disconnect();

         // Push the Zip to the target system

         logger.info( "Uploading zip file to the target repository." );

         targetWagon.put( archive, fileName );

         logger.info( "Unpacking zip file on the target machine." );

         String targetRepoBaseDirectory = targetRepository.getBasedir();

         // We use the super quiet option here as all the noise seems to kill/stall the connection

         String command = "unzip -o -qq -d " + targetRepoBaseDirectory + " " + targetRepoBaseDirectory + "/" + fileName;

         ( (CommandExecutor) targetWagon ).executeCommand( command );

         logger.info( "Deleting zip file from the target repository." );

         command = "rm -f " + targetRepoBaseDirectory + "/" + fileName;

         ( (CommandExecutor) targetWagon ).executeCommand( command );

         logger.info( "Running rename script on the target machine." );

         command = "cd " + targetRepoBaseDirectory + "; sh " + renameScriptName;

         ( (CommandExecutor) targetWagon ).executeCommand( command );

         logger.info( "Deleting rename script from the target repository." );

         command = "rm -f " + targetRepoBaseDirectory + "/" + renameScriptName;

         ( (CommandExecutor) targetWagon ).executeCommand( command );

         targetWagon.disconnect();

     }

     private void scanDirectory( File basedir, File dir, ZipOutputStream zos, String version, Set moveCommands )

         throws IOException

     {

         if ( dir == null )

         {

             return;

         }

         File[] files = dir.listFiles();

         for ( int i = 0; i < files.length; i++ )

         {

             File f = files[i];

             if ( f.isDirectory() )

             {

                 if ( f.getName().equals( ".svn" ) )

                 {

                     continue;

                 }

                 if ( f.getName().endsWith( version ) )

                 {

                     String s = f.getAbsolutePath().substring( basedir.getAbsolutePath().length() + 1 );

                     s = StringUtils.replace( s, "\\", "/" );

                     moveCommands.add( "mv " + s + IN_PROCESS_MARKER + " " + s );

                 }

                 scanDirectory( basedir, f, zos, version, moveCommands );

             }

             else

             {

                 InputStream is = new FileInputStream( f );

                 String s = f.getAbsolutePath().substring( basedir.getAbsolutePath().length() + 1 );                

                 s = StringUtils.replace( s, "\\", "/" );

                 // We are marking any version directories with the in-process flag so that

                 // anything being unpacked on the target side will not be recogized by Maven

                 // and so users cannot download partially uploaded files.

                 String vtag = "/" + version;

                 s = StringUtils.replace( s, vtag + "/", vtag + IN_PROCESS_MARKER + "/" );

                 ZipEntry e = new ZipEntry( s );

                 zos.putNextEntry( e );

                 IOUtil.copy( is, zos );

                 IOUtil.close( is );

                 int idx = s.indexOf( IN_PROCESS_MARKER );

                 if ( idx > 0 )

                 {

                     String d = s.substring( 0, idx );

                     moveCommands.add( "mv " + d + IN_PROCESS_MARKER + " " + d );

                 }

             }

         }

     }

     private void mergeMetadata( File existingMetadata )

         throws IOException, XmlPullParserException

     {

         // Existing Metadata in target stage

         Reader existingMetadataReader = new FileReader( existingMetadata );

         Metadata existing = reader.read( existingMetadataReader );

         // Staged Metadata

         File stagedMetadataFile = new File( existingMetadata.getParentFile(), MAVEN_METADATA );

         Reader stagedMetadataReader = new FileReader( stagedMetadataFile );

         Metadata staged = reader.read( stagedMetadataReader );

         // Merge

         existing.merge( staged );

         Writer writer = new FileWriter( existingMetadata );

         this.writer.write( writer, existing );

         IOUtil.close( writer );

         IOUtil.close( stagedMetadataReader );

         IOUtil.close( existingMetadataReader );

         // Mark all metadata as in-process and regenerate the checksums as they will be different

         // after the merger

         try

         {

             File newMd5 = new File( existingMetadata.getParentFile(), MAVEN_METADATA + ".md5" + IN_PROCESS_MARKER );

             FileUtils.fileWrite( newMd5.getAbsolutePath(), checksum( existingMetadata, MD5 ) );

             File oldMd5 = new File( existingMetadata.getParentFile(), MAVEN_METADATA + ".md5" );

             oldMd5.delete();

             File newSha1 = new File( existingMetadata.getParentFile(), MAVEN_METADATA + ".sha1" + IN_PROCESS_MARKER );

             FileUtils.fileWrite( newSha1.getAbsolutePath(), checksum( existingMetadata, SHA1 ) );

             File oldSha1 = new File( existingMetadata.getParentFile(), MAVEN_METADATA + ".sha1" );

             oldSha1.delete();

         }

         catch ( NoSuchAlgorithmException e )

         {

             throw new RuntimeException( e );

         }

         // We have the new merged copy so we're good

         stagedMetadataFile.delete();

     }

     private String checksum( File file,

                              String type )

         throws IOException, NoSuchAlgorithmException

     {

         MessageDigest md5 = MessageDigest.getInstance( type );

         InputStream is = new FileInputStream( file );

         byte[] buf = new byte[8192];

         int i;

         while ( ( i = is.read( buf ) ) > 0 )

         {

             md5.update( buf, 0, i );

         }

         IOUtil.close( is );

         return encode( md5.digest() );

     }

     protected String encode( byte[] binaryData )

     {

         if ( binaryData.length != 16 && binaryData.length != 20 )

         {

             int bitLength = binaryData.length * 8;

             throw new IllegalArgumentException( "Unrecognised length for binary data: " + bitLength + " bits" );

         }

         String retValue = "";

         for ( int i = 0; i < binaryData.length; i++ )

         {

             String t = Integer.toHexString( binaryData[i] & 0xff );

             if ( t.length() == 1 )

             {

                 retValue += ( "0" + t );

             }

             else

             {

                 retValue += t;

             }

         }

         return retValue.trim();

     }

     private void scan( Wagon wagon,

                        String basePath,

                        List collected )

     {

         try

         {

             List files = wagon.getFileList( basePath );

             if ( files.isEmpty() )

             {

                 collected.add( basePath );

             }

             else

             {

                 basePath = basePath + "/";

                 for ( Iterator iterator = files.iterator(); iterator.hasNext(); )

                 {

                     String file = (String) iterator.next();

                     logger.info( "Found file in the source repository: " + file );

                     scan( wagon, basePath + file, collected );

                 }

             }

         }

         catch ( TransferFailedException e )

         {

             throw new RuntimeException( e );

         }

         catch ( ResourceDoesNotExistException e )

         {

             // is thrown when calling getFileList on a file

             collected.add( basePath );

         }

         catch ( AuthorizationException e )

         {

             throw new RuntimeException( e );

         }

     }

     protected List scanForArtifactPaths( ArtifactRepository repository )

     {

         List collected;

         try

         {

             Wagon wagon = wagonManager.getWagon( repository.getProtocol() );

             Repository artifactRepository = new Repository( repository.getId(), repository.getUrl() );

             wagon.connect( artifactRepository );

             collected = new ArrayList();

             scan( wagon, "/", collected );

             wagon.disconnect();

             return collected;

         }

         catch ( UnsupportedProtocolException e )

         {

             throw new RuntimeException( e );

         }

         catch ( ConnectionException e )

         {

             throw new RuntimeException( e );

         }

         catch ( AuthenticationException e )

         {

             throw new RuntimeException( e );

         }

     }

     public void enableLogging( Logger logger )

     {

         this.logger = logger;

     }

 }