package org.apache.maven.index.updater;

 /*

  * 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.ConnectionException;

 import org.apache.maven.wagon.ResourceDoesNotExistException;

 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.events.TransferListener;

 import org.apache.maven.wagon.proxy.ProxyInfo;

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

 import org.codehaus.plexus.PlexusContainer;

 import org.codehaus.plexus.component.repository.exception.ComponentLookupException;

 import java.io.File;

 import java.io.FileInputStream;

 import java.io.FileNotFoundException;

 import java.io.IOException;

 import java.io.InputStream;

 /**

  * This is a helper for obtaining Wagon based ResourceFetchers. Some Indexer integrations does have access to Wagon

  * already, so this is here just to help them. Since Wagon (et al) is just optional dependency, looking up this

  * component in integrations where Wagon is not present, should be avoided. This helper is rather limited, as it offers

  * only "HTTP" wagons! This is not made a Plexus component since SISU would crack in CLI, while trying to load up this

  * class, because of lacking Wagon classes from classpath!

  *

  * @author cstamas

  */

 public class WagonHelper

 {

     private final PlexusContainer plexusContainer;

     public WagonHelper( final PlexusContainer plexusContainer )

     {

         this.plexusContainer = plexusContainer;

     }

     public WagonFetcher getWagonResourceFetcher( final TransferListener listener )

         throws ComponentLookupException

     {

         return getWagonResourceFetcher( listener, null, null );

     }

     /**

      * @param listener

      * @param authenticationInfo

      * @param proxyInfo

      * @return

      * @throws ComponentLookupException

      * @deprecated use getWagonResourceFetcher with protocol argument

      */

     public WagonFetcher getWagonResourceFetcher( final TransferListener listener,

                                                  final AuthenticationInfo authenticationInfo,

                                                  final ProxyInfo proxyInfo )

         throws ComponentLookupException

     {

         // we limit ourselves to HTTP only

         return new WagonFetcher( plexusContainer.lookup( Wagon.class, "http" ), listener, authenticationInfo,

                                  proxyInfo );

     }

     /**

      * @param listener

      * @param authenticationInfo

      * @param proxyInfo

      * @param protocol           protocol supported by wagon http/https

      * @return

      * @throws ComponentLookupException

      * @since 4.1.3

      */

     public WagonFetcher getWagonResourceFetcher( final TransferListener listener,

                                                  final AuthenticationInfo authenticationInfo, final ProxyInfo proxyInfo,

                                                  String protocol )

         throws ComponentLookupException

     {

         return new WagonFetcher( plexusContainer.lookup( Wagon.class, protocol ), listener, authenticationInfo,

                                  proxyInfo );

     }

     public static class WagonFetcher

         implements ResourceFetcher

     {

         private final TransferListener listener;

         private final AuthenticationInfo authenticationInfo;

         private final ProxyInfo proxyInfo;

         private final Wagon wagon;

         public WagonFetcher( final Wagon wagon, final TransferListener listener,

                              final AuthenticationInfo authenticationInfo, final ProxyInfo proxyInfo )

         {

             this.wagon = wagon;

             this.listener = listener;

             this.authenticationInfo = authenticationInfo;

             this.proxyInfo = proxyInfo;

         }

         public void connect( final String id, final String url )

             throws IOException

         {

             Repository repository = new Repository( id, url );

             try

             {

                 // wagon = wagonManager.getWagon( repository );

                 if ( listener != null )

                 {

                     wagon.addTransferListener( listener );

                 }

                 // when working in the context of Maven, the WagonManager is already

                 // populated with proxy information from the Maven environment

                 if ( authenticationInfo != null )

                 {

                     if ( proxyInfo != null )

                     {

                         wagon.connect( repository, authenticationInfo, proxyInfo );

                     }

                     else

                     {

                         wagon.connect( repository, authenticationInfo );

                     }

                 }

                 else

                 {

                     if ( proxyInfo != null )

                     {

                         wagon.connect( repository, proxyInfo );

                     }

                     else

                     {

                         wagon.connect( repository );

                     }

                 }

             }

             catch ( AuthenticationException ex )

             {

                 String msg = "Authentication exception connecting to " + repository;

                 logError( msg, ex );

                 IOException ioException = new IOException( msg );

                 ioException.initCause( ex );

                 throw ioException;

             }

             catch ( WagonException ex )

             {

                 String msg = "Wagon exception connecting to " + repository;

                 logError( msg, ex );

                 IOException ioException = new IOException( msg );

                 ioException.initCause( ex );

                 throw ioException;

             }

         }

         public void disconnect()

             throws IOException

         {

             if ( wagon != null )

             {

                 try

                 {

                     wagon.disconnect();

                 }

                 catch ( ConnectionException ex )

                 {

                     IOException ioe = new IOException( ex.toString() );

                     ioe.initCause( ex );

                     throw ioe;

                 }

             }

         }

         public InputStream retrieve( String name )

             throws IOException, FileNotFoundException

         {

             final File target = File.createTempFile( name, "" );

             retrieve( name, target );

             return new FileInputStream( target )

             {

                 @Override

                 public void close()

                     throws IOException

                 {

                     super.close();

                     target.delete();

                 }

             };

         }

         public void retrieve( final String name, final File targetFile )

             throws IOException, FileNotFoundException

         {

             try

             {

                 wagon.get( name, targetFile );

             }

             catch ( AuthorizationException e )

             {

                 String msg = "Authorization exception retrieving " + name;

                 logError( msg, e );

                 IOException ioException = new IOException( msg );

                 ioException.initCause( e );

                 throw ioException;

             }

             catch ( ResourceDoesNotExistException e )

             {

                 String msg = "Resource " + name + " does not exist";

                 logError( msg, e );

                 FileNotFoundException fileNotFoundException = new FileNotFoundException( msg );

                 fileNotFoundException.initCause( e );

                 throw fileNotFoundException;

             }

             catch ( WagonException e )

             {

                 String msg = "Transfer for " + name + " failed";

                 logError( msg, e );

                 IOException ioException = new IOException( msg + "; " + e.getMessage() );

                 ioException.initCause( e );

                 throw ioException;

             }

         }

         private void logError( final String msg, final Exception ex )

         {

             if ( listener != null )

             {

                 listener.debug( msg + "; " + ex.getMessage() );

             }

         }

     }

 }