indexer-core/src/main/java/org/apache/maven/index/updater/WagonHelper.java

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() );
            }
        }
    }
}