package org.apache.maven.wagon.providers.ssh;

 /*

  * 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.wagon.CommandExecutionException;

 import org.apache.maven.wagon.CommandExecutor;

 import org.apache.maven.wagon.PathUtils;

 import org.apache.maven.wagon.PermissionModeUtils;

 import org.apache.maven.wagon.ResourceDoesNotExistException;

 import org.apache.maven.wagon.Streams;

 import org.apache.maven.wagon.TransferFailedException;

 import org.apache.maven.wagon.Wagon;

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

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

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

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

 import org.apache.maven.wagon.resource.Resource;

 import org.codehaus.plexus.util.FileUtils;

 import org.codehaus.plexus.util.IOUtil;

 import org.codehaus.plexus.util.StringUtils;

 import java.io.File;

 import java.io.FileInputStream;

 import java.io.FileNotFoundException;

 import java.io.FileOutputStream;

 import java.io.IOException;

 import java.util.List;

 import java.util.zip.ZipEntry;

 import java.util.zip.ZipOutputStream;

 public class ScpHelper

 {

     public static final char PATH_SEPARATOR = '/';

     public static final int DEFAULT_SSH_PORT = 22;

     private final CommandExecutor executor;

     public ScpHelper( CommandExecutor executor )

     {

         this.executor = executor;

     }

     public static String getResourceDirectory( String resourceName )

     {

         String dir = PathUtils.dirname( resourceName );

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

         return dir;

     }

     public static String getResourceFilename( String r )

     {

         String filename;

         if ( r.lastIndexOf( PATH_SEPARATOR ) > 0 )

         {

             filename = r.substring( r.lastIndexOf( PATH_SEPARATOR ) + 1 );

         }

         else

         {

             filename = r;

         }

         return filename;

     }

     public static Resource getResource( String resourceName )

     {

         String r = StringUtils.replace( resourceName, "\\", "/" );

         return new Resource( r );

     }

     public static File getPrivateKey( AuthenticationInfo authenticationInfo )

         throws FileNotFoundException

     {

         // If user don't define a password, he want to use a private key

         File privateKey = null;

         if ( authenticationInfo.getPassword() == null )

         {

             if ( authenticationInfo.getPrivateKey() != null )

             {

                 privateKey = new File( authenticationInfo.getPrivateKey() );

                 if ( !privateKey.exists() )

                 {

                     throw new FileNotFoundException( "Private key '" + privateKey + "' not found" );

                 }

             }

             else

             {

                 privateKey = findPrivateKey();

             }

             if ( privateKey != null && privateKey.exists() )

             {

                 if ( authenticationInfo.getPassphrase() == null )

                 {

                     authenticationInfo.setPassphrase( "" );

                 }

             }

         }

         return privateKey;

     }

     private static File findPrivateKey()

     {

         String privateKeyDirectory = System.getProperty( "wagon.privateKeyDirectory" );

         if ( privateKeyDirectory == null )

         {

             privateKeyDirectory = System.getProperty( "user.home" );

         }

         File privateKey = new File( privateKeyDirectory, ".ssh/id_dsa" );

         if ( !privateKey.exists() )

         {

             privateKey = new File( privateKeyDirectory, ".ssh/id_rsa" );

             if ( !privateKey.exists() )

             {

                 privateKey = null;

             }

         }

         return privateKey;

     }

     public static void createZip( List<String> files, File zipName, File basedir )

         throws IOException

     {

         ZipOutputStream zos = new ZipOutputStream( new FileOutputStream( zipName ) );

         try

         {

             for ( String file : files )

             {

                 file = file.replace( '\\', '/' );

                 writeZipEntry( zos, new File( basedir, file ), file );

             }

         }

         finally

         {

             IOUtil.close( zos );

         }

     }

     private static void writeZipEntry( ZipOutputStream jar, File source, String entryName )

         throws IOException

     {

         byte[] buffer = new byte[1024];

         int bytesRead;

         FileInputStream is = new FileInputStream( source );

         try

         {

             ZipEntry entry = new ZipEntry( entryName );

             jar.putNextEntry( entry );

             while ( ( bytesRead = is.read( buffer ) ) != -1 )

             {

                 jar.write( buffer, 0, bytesRead );

             }

         }

         finally

         {

             is.close();

         }

     }

     protected static String getPath( String basedir, String dir )

     {

         String path;

         path = basedir;

         if ( !basedir.endsWith( "/" ) && !dir.startsWith( "/" ) )

         {

             path += "/";

         }

         path += dir;

         return path;

     }

     public void putDirectory( Wagon wagon, File sourceDirectory, String destinationDirectory )

         throws TransferFailedException, ResourceDoesNotExistException, AuthorizationException

     {

         Repository repository = wagon.getRepository();

         String basedir = repository.getBasedir();

         String destDir = StringUtils.replace( destinationDirectory, "\\", "/" );

         String path = getPath( basedir, destDir );

         try

         {

             if ( repository.getPermissions() != null )

             {

                 String dirPerms = repository.getPermissions().getDirectoryMode();

                 if ( dirPerms != null )

                 {

                     String umaskCmd = "umask " + PermissionModeUtils.getUserMaskFor( dirPerms );

                     executor.executeCommand( umaskCmd );

                 }

             }

             //String mkdirCmd = "mkdir -p " + path;

             String mkdirCmd = "mkdir -p \"" + path + "\"";

             executor.executeCommand( mkdirCmd );

         }

         catch ( CommandExecutionException e )

         {

             throw new TransferFailedException( "Error performing commands for file transfer", e );

         }

         File zipFile;

         try

         {

             zipFile = File.createTempFile( "wagon", ".zip" );

             zipFile.deleteOnExit();

             List<String> files = FileUtils.getFileNames( sourceDirectory, "**/**", "", false );

             createZip( files, zipFile, sourceDirectory );

         }

         catch ( IOException e )

         {

             throw new TransferFailedException( "Unable to create ZIP archive of directory", e );

         }

         wagon.put( zipFile, getPath( destDir, zipFile.getName() ) );

         try

         {

             //executor.executeCommand(

             //    "cd " + path + "; unzip -q -o " + zipFile.getName() + "; rm -f " + zipFile.getName() );

             executor.executeCommand( "cd \"" + path + "\"; unzip -q -o \"" + zipFile.getName() + "\"; rm -f \"" + zipFile.getName() + "\"" );

             zipFile.delete();

             RepositoryPermissions permissions = repository.getPermissions();

             if ( permissions != null && permissions.getGroup() != null )

             {

                 //executor.executeCommand( "chgrp -Rf " + permissions.getGroup() + " " + path );

                 executor.executeCommand( "chgrp -Rf " + permissions.getGroup() + " \"" + path + "\"" );

             }

             if ( permissions != null && permissions.getFileMode() != null )

             {

                 //executor.executeCommand( "chmod -Rf " + permissions.getFileMode() + " " + path );

                 executor.executeCommand( "chmod -Rf " + permissions.getFileMode() + " \"" + path + "\"" );

             }

         }

         catch ( CommandExecutionException e )

         {

             throw new TransferFailedException( "Error performing commands for file transfer", e );

         }

     }

     public List<String> getFileList( String destinationDirectory, Repository repository )

         throws TransferFailedException, ResourceDoesNotExistException, AuthorizationException

     {

         try

         {

             String path = getPath( repository.getBasedir(), destinationDirectory );

             //Streams streams = executor.executeCommand( "ls -FlA " + path, false );

             Streams streams = executor.executeCommand( "ls -FlA \"" + path + "\"", false );

             List<String> ret = new LSParser().parseFiles( streams.getOut() );

             if ( ret == null || ret.isEmpty() )

             {

                 throw new ResourceDoesNotExistException( "No such file or directory" );

             }

             return ret;

         }

         catch ( CommandExecutionException e )

         {

             if ( e.getMessage().trim().endsWith( "No such file or directory" ) )

             {

                 throw new ResourceDoesNotExistException( e.getMessage().trim(), e );

             }

             else if ( e.getMessage().trim().endsWith( "Not a directory" ) )

             {

                 throw new ResourceDoesNotExistException( e.getMessage().trim(), e );

             }

             else

             {

                 throw new TransferFailedException( "Error performing file listing.", e );

             }

         }

     }

     public boolean resourceExists( String resourceName, Repository repository )

         throws TransferFailedException, AuthorizationException

     {

         try

         {

             String path = getPath( repository.getBasedir(), resourceName );

             //executor.executeCommand( "ls " + path, false );

             executor.executeCommand( "ls \"" + path + "\"" );

             // Parsing of output not really needed.  As a failed ls results in a

             // CommandExectionException on the 'ls' command.

             return true;

         }

         catch ( CommandExecutionException e )

         {

             // Error?  Then the 'ls' command failed.  No such file found.

             return false;

         }

     }

     public void createRemoteDirectories( String path, RepositoryPermissions permissions )

         throws CommandExecutionException

     {

         String umaskCmd = null;

         if ( permissions != null )

         {

             String dirPerms = permissions.getDirectoryMode();

             if ( dirPerms != null )

             {

                 umaskCmd = "umask " + PermissionModeUtils.getUserMaskFor( dirPerms );

             }

         }

         //String mkdirCmd = "mkdir -p " + path;

         String mkdirCmd = "mkdir -p \"" + path + "\"";

         if ( umaskCmd != null )

         {

             mkdirCmd = umaskCmd + "; " + mkdirCmd;

         }

         executor.executeCommand( mkdirCmd );

     }

 }