package org.apache.maven.artifact.manager;

 /*

  * 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 java.io.File;

 import java.io.IOException;

 import java.net.MalformedURLException;

 import java.net.URL;

 import java.security.NoSuchAlgorithmException;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.HashMap;

 import java.util.Iterator;

 import java.util.LinkedHashMap;

 import java.util.List;

 import java.util.Map;

 import java.util.Set;

 import org.apache.maven.artifact.Artifact;

 import org.apache.maven.artifact.metadata.ArtifactMetadata;

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

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

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

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

 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.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.observers.ChecksumObserver;

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

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

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

 import org.codehaus.plexus.PlexusConstants;

 import org.codehaus.plexus.PlexusContainer;

 import org.codehaus.plexus.component.configurator.ComponentConfigurationException;

 import org.codehaus.plexus.component.configurator.ComponentConfigurator;

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

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

 import org.codehaus.plexus.configuration.PlexusConfiguration;

 import org.codehaus.plexus.configuration.xml.XmlPlexusConfiguration;

 import org.codehaus.plexus.context.Context;

 import org.codehaus.plexus.context.ContextException;

 import org.codehaus.plexus.logging.AbstractLogEnabled;

 import org.codehaus.plexus.personality.plexus.lifecycle.phase.Contextualizable;

 import org.codehaus.plexus.util.FileUtils;

 import org.codehaus.plexus.util.xml.Xpp3Dom;

 public class DefaultWagonManager

     extends AbstractLogEnabled

     implements WagonManager, Contextualizable

 {

     private static final String WILDCARD = "*";

     private static final String EXTERNAL_WILDCARD = "external:*";

     private PlexusContainer container;

     // TODO: proxies, authentication and mirrors are via settings, and should come in via an alternate method - perhaps

     // attached to ArtifactRepository before the method is called (so AR would be composed of WR, not inherit it)

     private Map proxies = new HashMap();

     private Map authenticationInfoMap = new HashMap();

     private Map serverPermissionsMap = new HashMap();

     //used LinkedMap to preserve the order.

     private Map mirrors = new LinkedHashMap();

     /** Map( String, XmlPlexusConfiguration ) with the repository id and the wagon configuration */

     private Map serverConfigurationMap = new HashMap();

     private TransferListener downloadMonitor;

     private boolean online = true;

     private ArtifactRepositoryFactory repositoryFactory;

     private boolean interactive = true;

     private Map availableWagons = new HashMap();

     private RepositoryPermissions defaultRepositoryPermissions;

     // TODO: this leaks the component in the public api - it is never released back to the container

     public Wagon getWagon( Repository repository )

         throws UnsupportedProtocolException, WagonConfigurationException

     {

         String protocol = repository.getProtocol();

         if ( protocol == null )

         {

             throw new UnsupportedProtocolException( "The repository " + repository + " does not specify a protocol" );

         }

         Wagon wagon = getWagon( protocol );

         configureWagon( wagon, repository.getId() );

         return wagon;

     }

     public Wagon getWagon( String protocol )

         throws UnsupportedProtocolException

     {

         PlexusContainer container = getWagonContainer( protocol );

         Wagon wagon;

         try

         {

             wagon = (Wagon) container.lookup( Wagon.ROLE, protocol );

         }

         catch ( ComponentLookupException e1 )

         {

             throw new UnsupportedProtocolException(

                 "Cannot find wagon which supports the requested protocol: " + protocol, e1 );

         }

         wagon.setInteractive( interactive );

         return wagon;

     }

     private PlexusContainer getWagonContainer( String protocol )

     {

         PlexusContainer container = this.container;

         if ( availableWagons.containsKey( protocol ) )

         {

             container = (PlexusContainer) availableWagons.get( protocol );

         }

         return container;

     }

     public void putArtifact( File source,

                              Artifact artifact,

                              ArtifactRepository deploymentRepository )

         throws TransferFailedException

     {

         putRemoteFile( deploymentRepository, source, deploymentRepository.pathOf( artifact ), downloadMonitor );

     }

     public void putArtifactMetadata( File source,

                                      ArtifactMetadata artifactMetadata,

                                      ArtifactRepository repository )

         throws TransferFailedException

     {

         getLogger().info( "Uploading " + artifactMetadata );

         putRemoteFile( repository, source, repository.pathOfRemoteRepositoryMetadata( artifactMetadata ), null );

     }

     private void putRemoteFile( ArtifactRepository repository,

                                 File source,

                                 String remotePath,

                                 TransferListener downloadMonitor )

         throws TransferFailedException

     {

         failIfNotOnline();

         String protocol = repository.getProtocol();

         Wagon wagon;

         try

         {

             wagon = getWagon( protocol );

             configureWagon( wagon, repository );

         }

         catch ( UnsupportedProtocolException e )

         {

             throw new TransferFailedException( "Unsupported Protocol: '" + protocol + "': " + e.getMessage(), e );

         }

         if ( downloadMonitor != null )

         {

             wagon.addTransferListener( downloadMonitor );

         }

         Map checksums = new HashMap( 2 );

         Map sums = new HashMap( 2 );

         // TODO: configure these on the repository

         try

         {

             ChecksumObserver checksumObserver = new ChecksumObserver( "MD5" );

             wagon.addTransferListener( checksumObserver );

             checksums.put( "md5", checksumObserver );

             checksumObserver = new ChecksumObserver( "SHA-1" );

             wagon.addTransferListener( checksumObserver );

             checksums.put( "sha1", checksumObserver );

         }

         catch ( NoSuchAlgorithmException e )

         {

             throw new TransferFailedException( "Unable to add checksum methods: " + e.getMessage(), e );

         }

         try

         {

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

             if ( serverPermissionsMap.containsKey( repository.getId() ) )

             {

                 RepositoryPermissions perms = (RepositoryPermissions) serverPermissionsMap.get( repository.getId() );

                 getLogger().debug(

                     "adding permissions to wagon connection: " + perms.getFileMode() + " " + perms.getDirectoryMode() );

                 artifactRepository.setPermissions( perms );

             }

             else

             {

                 if ( defaultRepositoryPermissions != null )

                 {

                     artifactRepository.setPermissions( defaultRepositoryPermissions );

                 }

                 else

                 {

                     getLogger().debug( "not adding permissions to wagon connection" );

                 }

             }

             wagon.connect( artifactRepository, getAuthenticationInfo( repository.getId() ), getProxy(protocol));

             wagon.put( source, remotePath );

             wagon.removeTransferListener( downloadMonitor );

             // Pre-store the checksums as any future puts will overwrite them

             for ( Iterator i = checksums.keySet().iterator(); i.hasNext(); )

             {

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

                 ChecksumObserver observer = (ChecksumObserver) checksums.get( extension );

                 sums.put( extension, observer.getActualChecksum() );

             }

             // We do this in here so we can checksum the artifact metadata too, otherwise it could be metadata itself

             for ( Iterator i = checksums.keySet().iterator(); i.hasNext(); )

             {

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

                 // TODO: shouldn't need a file intermediatary - improve wagon to take a stream

                 File temp = File.createTempFile( "maven-artifact", null );

                 temp.deleteOnExit();

                 FileUtils.fileWrite( temp.getAbsolutePath(), "UTF-8", (String) sums.get( extension ) );

                 wagon.put( temp, remotePath + "." + extension );

             }

         }

         catch ( ConnectionException e )

         {

             throw new TransferFailedException( "Connection failed: " + e.getMessage(), e );

         }

         catch ( AuthenticationException e )

         {

             throw new TransferFailedException( "Authentication failed: " + e.getMessage(), e );

         }

         catch ( AuthorizationException e )

         {

             throw new TransferFailedException( "Authorization failed: " + e.getMessage(), e );

         }

         catch ( ResourceDoesNotExistException e )

         {

             throw new TransferFailedException( "Resource to deploy not found: " + e.getMessage(), e );

         }

         catch ( IOException e )

         {

             throw new TransferFailedException( "Error creating temporary file for deployment: " + e.getMessage(), e );

         }

         finally

         {

             disconnectWagon( wagon );

             releaseWagon( protocol, wagon );

         }

     }

     public void getArtifact( Artifact artifact,

                              List remoteRepositories )

         throws TransferFailedException, ResourceDoesNotExistException

     {

         // TODO [BP]: The exception handling here needs some work

         boolean successful = false;

         for ( Iterator iter = remoteRepositories.iterator(); iter.hasNext() && !successful; )

         {

             ArtifactRepository repository = (ArtifactRepository) iter.next();

             try

             {

                 getArtifact( artifact, repository );

                 successful = artifact.isResolved();

             }

             catch ( ResourceDoesNotExistException e )

             {

                 // This one we will eat when looking through remote repositories

                 // because we want to cycle through them all before squawking.

                 getLogger().info( "Unable to find resource '" + artifact.getId() + "' in repository " +

                     repository.getId() + " (" + repository.getUrl() + ")" );

             }

             catch ( TransferFailedException e )

             {

                 getLogger().warn( "Unable to get resource '" + artifact.getId() + "' from repository " +

                     repository.getId() + " (" + repository.getUrl() + "): " + e.getMessage() );

             }

         }

         // if it already exists locally we were just trying to force it - ignore the update

         if ( !successful && !artifact.getFile().exists() )

         {

             throw new ResourceDoesNotExistException( "Unable to download the artifact from any repository" );

         }

     }

     public void getArtifact( Artifact artifact,

                              ArtifactRepository repository )

         throws TransferFailedException, ResourceDoesNotExistException

     {

         String remotePath = repository.pathOf( artifact );

         ArtifactRepositoryPolicy policy = artifact.isSnapshot() ? repository.getSnapshots() : repository.getReleases();

         if ( !policy.isEnabled() )

         {

             getLogger().debug( "Skipping disabled repository " + repository.getId() );

         }

         else if ( repository.isBlacklisted() )

         {

             getLogger().debug( "Skipping blacklisted repository " + repository.getId() );

         }

         else

         {

             getLogger().debug( "Trying repository " + repository.getId() );

             getRemoteFile( getMirrorRepository( repository ), artifact.getFile(), remotePath, downloadMonitor,

                                    policy.getChecksumPolicy(), false );

             getLogger().debug( "  Artifact resolved" );

             artifact.setResolved( true );

         }

     }

     public void getArtifactMetadata( ArtifactMetadata metadata,

                                      ArtifactRepository repository,

                                      File destination,

                                      String checksumPolicy )

         throws TransferFailedException, ResourceDoesNotExistException

     {

         String remotePath = repository.pathOfRemoteRepositoryMetadata( metadata );

         getRemoteFile( getMirrorRepository( repository ), destination, remotePath, null, checksumPolicy, true );

     }

     public void getArtifactMetadataFromDeploymentRepository( ArtifactMetadata metadata, ArtifactRepository repository,

                                                              File destination, String checksumPolicy )

         throws TransferFailedException, ResourceDoesNotExistException

     {

         String remotePath = repository.pathOfRemoteRepositoryMetadata( metadata );

         getRemoteFile( repository, destination, remotePath, null, checksumPolicy, true );

     }

     private void getRemoteFile( ArtifactRepository repository,

                                 File destination,

                                 String remotePath,

                                 TransferListener downloadMonitor,

                                 String checksumPolicy,

                                 boolean force )

         throws TransferFailedException, ResourceDoesNotExistException

     {

         // TODO: better excetpions - transfer failed is not enough?

         failIfNotOnline();

         String protocol = repository.getProtocol();

         Wagon wagon;

         try

         {

             wagon = getWagon( protocol );

             configureWagon( wagon, repository );

         }

         catch ( UnsupportedProtocolException e )

         {

             throw new TransferFailedException( "Unsupported Protocol: '" + protocol + "': " + e.getMessage(), e );

         }

         if ( downloadMonitor != null )

         {

             wagon.addTransferListener( downloadMonitor );

         }

         // TODO: configure on repository

         ChecksumObserver md5ChecksumObserver;

         ChecksumObserver sha1ChecksumObserver;

         List checksumObservers = new ArrayList( 2 );

         try

         {

             md5ChecksumObserver = new ChecksumObserver( "MD5" );

             wagon.addTransferListener( md5ChecksumObserver );

             checksumObservers.add( md5ChecksumObserver );

             sha1ChecksumObserver = new ChecksumObserver( "SHA-1" );

             wagon.addTransferListener( sha1ChecksumObserver );

             checksumObservers.add( sha1ChecksumObserver );

         }

         catch ( NoSuchAlgorithmException e )

         {

             throw new TransferFailedException( "Unable to add checksum methods: " + e.getMessage(), e );

         }

         File temp = new File( destination + ".tmp" );

         temp.deleteOnExit();

         boolean downloaded = false;

         try

         {

             wagon.connect( new Repository( repository.getId(), repository.getUrl() ),

                            getAuthenticationInfo( repository.getId() ),getProxy(protocol));

             boolean firstRun = true;

             boolean retry = true;

             // this will run at most twice. The first time, the firstRun flag is turned off, and if the retry flag

             // is set on the first run, it will be turned off and not re-set on the second try. This is because the

             // only way the retry flag can be set is if ( firstRun == true ).

             while ( firstRun || retry )

             {

                 // reset the retry flag.

                 retry = false;

                 // This should take care of creating destination directory now on

                 if ( destination.exists() && !force )

                 {

                     try

                     {

                         downloaded = wagon.getIfNewer( remotePath, temp, destination.lastModified() );

                         if ( !downloaded )

                         {

                             // prevent additional checks of this artifact until it expires again

                             destination.setLastModified( System.currentTimeMillis() );

                         }

                     }

                     catch ( UnsupportedOperationException e )

                     {

                         // older wagons throw this. Just get() instead

                         wagon.get( remotePath, temp );

                         downloaded = true;

                     }

                 }

                 else

                 {

                     wagon.get( remotePath, temp );

                     downloaded = true;

                 }

                 if ( downloaded )

                 {

                     // keep the checksum files from showing up on the download monitor...

                     if ( downloadMonitor != null )

                     {

                         wagon.removeTransferListener( downloadMonitor );

                     }

                     // try to verify the SHA-1 checksum for this file.

                     try

                     {

                         verifyChecksum( sha1ChecksumObserver, destination, temp, remotePath, ".sha1", wagon, checksumObservers );

                     }

                     catch ( ChecksumFailedException e )

                     {

                         // if we catch a ChecksumFailedException, it means the transfer/read succeeded, but the checksum

                         // doesn't match. This could be a problem with the server (ibiblio HTTP-200 error page), so we'll

                         // try this up to two times. On the second try, we'll handle it as a bona-fide error, based on the

                         // repository's checksum checking policy.

                         if ( firstRun )

                         {

                             getLogger().warn( "*** CHECKSUM FAILED - " + e.getMessage() + " - RETRYING" );

                             retry = true;

                         }

                         else

                         {

                             handleChecksumFailure( checksumPolicy, e.getMessage(), e.getCause() );

                         }

                     }

                     catch ( ResourceDoesNotExistException sha1TryException )

                     {

                         getLogger().debug( "SHA1 not found, trying MD5", sha1TryException );

                         // if this IS NOT a ChecksumFailedException, it was a problem with transfer/read of the checksum

                         // file...we'll try again with the MD5 checksum.

                         try

                         {

                             verifyChecksum( md5ChecksumObserver, destination, temp, remotePath, ".md5", wagon, checksumObservers );

                         }

                         catch ( ChecksumFailedException e )

                         {

                             // if we also fail to verify based on the MD5 checksum, and the checksum transfer/read

                             // succeeded, then we need to determine whether to retry or handle it as a failure.

                             if ( firstRun )

                             {

                                 retry = true;

                             }

                             else

                             {

                                 handleChecksumFailure( checksumPolicy, e.getMessage(), e.getCause() );

                             }

                         }

                         catch ( ResourceDoesNotExistException md5TryException )

                         {

                             // this was a failed transfer, and we don't want to retry.

                             handleChecksumFailure( checksumPolicy, "Error retrieving checksum file for " + remotePath,

                                                    md5TryException );

                         }

                     }

                     // reinstate the download monitor...

                     if ( downloadMonitor != null )

                     {

                         wagon.addTransferListener( downloadMonitor );

                     }

                 }

                 // unset the firstRun flag, so we don't get caught in an infinite loop...

                 firstRun = false;

             }

         }

         catch ( ConnectionException e )

         {

             throw new TransferFailedException( "Connection failed: " + e.getMessage(), e );

         }

         catch ( AuthenticationException e )

         {

             throw new TransferFailedException( "Authentication failed: " + e.getMessage(), e );

         }

         catch ( AuthorizationException e )

         {

             throw new TransferFailedException( "Authorization failed: " + e.getMessage(), e );

         }

         finally

         {

             disconnectWagon( wagon );

             releaseWagon( protocol, wagon );

         }

         if ( downloaded )

         {

             if ( !temp.exists() )

             {

                 throw new ResourceDoesNotExistException( "Downloaded file does not exist: " + temp );

             }

             // The temporary file is named destination + ".tmp" and is done this way to ensure

             // that the temporary file is in the same file system as the destination because the

             // File.renameTo operation doesn't really work across file systems.

             // So we will attempt to do a File.renameTo for efficiency and atomicity, if this fails

             // then we will use a brute force copy and delete the temporary file.

             if ( !temp.renameTo( destination ) )

             {

                 try

                 {

                     FileUtils.copyFile( temp, destination );

                     temp.delete();

                 }

                 catch ( IOException e )

                 {

                     throw new TransferFailedException(

                         "Error copying temporary file to the final destination: " + e.getMessage(), e );

                 }

             }

         }

     }

     public ArtifactRepository getMirrorRepository( ArtifactRepository repository )

     {

         ArtifactRepository mirror = getMirror( repository );

         if ( mirror != null )

         {

             String id = mirror.getId();

             if ( id == null )

             {

                 // TODO: this should be illegal in settings.xml

                 id = repository.getId();

             }

             repository = repositoryFactory.createArtifactRepository( id, mirror.getUrl(),

                                                                      repository.getLayout(), repository.getSnapshots(),

                                                                      repository.getReleases() );

         }

         return repository;

     }

     private void failIfNotOnline()

         throws TransferFailedException

     {

         if ( !isOnline() )

         {

             throw new TransferFailedException( "System is offline." );

         }

     }

     private void handleChecksumFailure( String checksumPolicy,

                                         String message,

                                         Throwable cause )

         throws ChecksumFailedException

     {

         if ( ArtifactRepositoryPolicy.CHECKSUM_POLICY_FAIL.equals( checksumPolicy ) )

         {

             throw new ChecksumFailedException( message, cause );

         }

         else if ( !ArtifactRepositoryPolicy.CHECKSUM_POLICY_IGNORE.equals( checksumPolicy ) )

         {

             // warn if it is set to anything other than ignore

             getLogger().warn( "*** CHECKSUM FAILED - " + message + " - IGNORING" );

         }

         // otherwise it is ignore

     }

     private void verifyChecksum( ChecksumObserver checksumObserver,

                                  File destination,

                                  File tempDestination,

                                  String remotePath,

                                  String checksumFileExtension,

                                  Wagon wagon, 

                                  List checksumObservers )

         throws ResourceDoesNotExistException, TransferFailedException, AuthorizationException

     {

         // FIXME: We need to be able to disable/retrieve/manipulate existing checksum observers on wagon instances.

         // Otherwise, each time a checksum GET throws ResourceNotFoundException, all other checksum data in other

         // observers for the main artifact have their actual checksums destroyed.

         for ( Iterator it = checksumObservers.iterator(); it.hasNext(); )

         {

             ChecksumObserver observer = (ChecksumObserver) it.next();

             wagon.removeTransferListener( observer );

         }

         try

         {

             // grab it first, because it's about to change...

             String actualChecksum = checksumObserver.getActualChecksum();

             File tempChecksumFile = new File( tempDestination + checksumFileExtension + ".tmp" );

             tempChecksumFile.deleteOnExit();

             wagon.get( remotePath + checksumFileExtension, tempChecksumFile );

             String expectedChecksum = FileUtils.fileRead( tempChecksumFile, "UTF-8" );

             // remove whitespaces at the end

             expectedChecksum = expectedChecksum.trim();

             // check for 'ALGO (name) = CHECKSUM' like used by openssl

             if ( expectedChecksum.regionMatches( true, 0, "MD", 0, 2 )

                 || expectedChecksum.regionMatches( true, 0, "SHA", 0, 3 ) )

             {

                 int lastSpacePos = expectedChecksum.lastIndexOf( ' ' );

                 expectedChecksum = expectedChecksum.substring( lastSpacePos + 1 );

             }

             else

             {

                 // remove everything after the first space (if available)

                 int spacePos = expectedChecksum.indexOf( ' ' );

                 if ( spacePos != -1 )

                 {

                     expectedChecksum = expectedChecksum.substring( 0, spacePos );

                 }

             }

             if ( expectedChecksum.equalsIgnoreCase( actualChecksum ) )

             {

                 File checksumFile = new File( destination + checksumFileExtension );

                 if ( checksumFile.exists() )

                 {

                     checksumFile.delete();

                 }

                 FileUtils.copyFile( tempChecksumFile, checksumFile );

             }

             else

             {

                 throw new ChecksumFailedException( "Checksum failed on download: local = '" + actualChecksum +

                     "'; remote = '" + expectedChecksum + "'" );

             }

         }

         catch ( IOException e )

         {

             throw new ChecksumFailedException( "Invalid checksum file", e );

         }

         finally

         {

             for ( Iterator it = checksumObservers.iterator(); it.hasNext(); )

             {

                 ChecksumObserver observer = (ChecksumObserver) it.next();

                 wagon.addTransferListener( observer );

             }

         }

     }

     private void disconnectWagon( Wagon wagon )

     {

         try

         {

             wagon.disconnect();

         }

         catch ( ConnectionException e )

         {

             getLogger().error( "Problem disconnecting from wagon - ignoring: " + e.getMessage() );

         }

     }

     private void releaseWagon( String protocol,

                                Wagon wagon )

     {

         PlexusContainer container = getWagonContainer( protocol );

         try

         {

             container.release( wagon );

         }

         catch ( ComponentLifecycleException e )

         {

             getLogger().error( "Problem releasing wagon - ignoring: " + e.getMessage() );

         }

     }

     public ProxyInfo getProxy( String protocol )

     {

         return (ProxyInfo) proxies.get( protocol );

     }

     public AuthenticationInfo getAuthenticationInfo( String id )

     {

         return (AuthenticationInfo) authenticationInfoMap.get( id );

     }

     /**

      * This method finds a matching mirror for the selected repository. If there is an exact match, this will be used.

      * If there is no exact match, then the list of mirrors is examined to see if a pattern applies.

      * 

      * @param originalRepository See if there is a mirror for this repository.

      * @return the selected mirror or null if none are found.

      */

     public ArtifactRepository getMirror( ArtifactRepository originalRepository )

     {

         ArtifactRepository selectedMirror = (ArtifactRepository) mirrors.get( originalRepository.getId() );

         if ( null == selectedMirror )

         {

             // Process the patterns in order. First one that matches wins.

             Set keySet = mirrors.keySet();

             if ( keySet != null )

             {

                 Iterator iter = keySet.iterator();

                 while ( iter.hasNext() )

                 {

                     String pattern = (String) iter.next();

                     if ( matchPattern( originalRepository, pattern ) )

                     {

                         selectedMirror = (ArtifactRepository) mirrors.get( pattern );

                         break;

                     }

                 }

             }

         }

         return selectedMirror;

     }

     /**

      * This method checks if the pattern matches the originalRepository. 

      * Valid patterns: 

      * * = everything

      * external:* = everything not on the localhost and not file based.

      * repo,repo1 = repo or repo1

      * *,!repo1 = everything except repo1

      * 

      * @param originalRepository to compare for a match.

      * @param pattern used for match. Currently only '*' is supported.

      * @return true if the repository is a match to this pattern.

      */

     public boolean matchPattern( ArtifactRepository originalRepository, String pattern )

     {

         boolean result = false;

         String originalId = originalRepository.getId();

         // simple checks first to short circuit processing below.

         if ( WILDCARD.equals( pattern ) || pattern.equals( originalId ) )

         {

             result = true;

         }

         else

         {

             // process the list

             String[] repos = pattern.split( "," );

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

             {

                 String repo = repos[i];

                 // see if this is a negative match

                 if ( repo.length() > 1 && repo.startsWith( "!" ) )

                 {

                     if ( originalId.equals( repo.substring( 1 ) ) )

                     {

                         // explicitly exclude. Set result and stop processing.

                         result = false;

                         break;

                     }

                 }

                 // check for exact match

                 else if ( originalId.equals( repo ) )

                 {

                     result = true;

                     break;

                 }

                 // check for external:*

                 else if ( EXTERNAL_WILDCARD.equals( repo ) && isExternalRepo( originalRepository ) )

                 {

                     result = true;

                     // don't stop processing in case a future segment explicitly excludes this repo

                 }

                 else if ( WILDCARD.equals( repo ) )

                 {

                     result = true;

                     // don't stop processing in case a future segment explicitly excludes this repo

                 }

             }

         }

         return result;

     }

     /**

      * Checks the URL to see if this repository refers to an external repository

      * 

      * @param originalRepository

      * @return true if external.

      */

     public boolean isExternalRepo( ArtifactRepository originalRepository )

     {

         try

         {

             URL url = new URL( originalRepository.getUrl() );

             return !( url.getHost().equals( "localhost" ) || url.getHost().equals( "127.0.0.1" ) || url.getProtocol().equals(

                                                                                                                               "file" ) );

         }

         catch ( MalformedURLException e )

         {

             // bad url just skip it here. It should have been validated already, but the wagon lookup will deal with it

             return false;

         }

     }

     /**

      * Set the proxy used for a particular protocol.

      * 

      * @param protocol the protocol (required)

      * @param host the proxy host name (required)

      * @param port the proxy port (required)

      * @param username the username for the proxy, or null if there is none

      * @param password the password for the proxy, or null if there is none

      * @param nonProxyHosts the set of hosts not to use the proxy for. Follows Java system property format:

      *            <code>*.foo.com|localhost</code>.

      * @todo [BP] would be nice to configure this via plexus in some way

      */

     public void addProxy( String protocol,

                           String host,

                           int port,

                           String username,

                           String password,

                           String nonProxyHosts )

     {

         ProxyInfo proxyInfo = new ProxyInfo();

         proxyInfo.setHost( host );

         proxyInfo.setType( protocol );

         proxyInfo.setPort( port );

         proxyInfo.setNonProxyHosts( nonProxyHosts );

         proxyInfo.setUserName( username );

         proxyInfo.setPassword( password );

         proxies.put( protocol, proxyInfo );

     }

     public void contextualize( Context context )

         throws ContextException

     {

         container = (PlexusContainer) context.get( PlexusConstants.PLEXUS_KEY );

     }

     /** @todo I'd rather not be setting this explicitly. */

     public void setDownloadMonitor( TransferListener downloadMonitor )

     {

         this.downloadMonitor = downloadMonitor;

     }

     public void addAuthenticationInfo( String repositoryId,

                                        String username,

                                        String password,

                                        String privateKey,

                                        String passphrase )

     {

         AuthenticationInfo authInfo = new AuthenticationInfo();

         authInfo.setUserName( username );

         authInfo.setPassword( password );

         authInfo.setPrivateKey( privateKey );

         authInfo.setPassphrase( passphrase );

         authenticationInfoMap.put( repositoryId, authInfo );

     }

     public void addPermissionInfo( String repositoryId,

                                    String filePermissions,

                                    String directoryPermissions )

     {

         RepositoryPermissions permissions = new RepositoryPermissions();

         boolean addPermissions = false;

         if ( filePermissions != null )

         {

             permissions.setFileMode( filePermissions );

             addPermissions = true;

         }

         if ( directoryPermissions != null )

         {

             permissions.setDirectoryMode( directoryPermissions );

             addPermissions = true;

         }

         if ( addPermissions )

         {

             serverPermissionsMap.put( repositoryId, permissions );

         }

     }

     public void addMirror( String id,

                            String mirrorOf,

                            String url )

     {

         ArtifactRepository mirror = new DefaultArtifactRepository( id, url, null );

         //to preserve first wins, don't add repeated mirrors.

         if (!mirrors.containsKey( mirrorOf ))

         {

             mirrors.put( mirrorOf, mirror );

         }

     }

     public void setOnline( boolean online )

     {

         this.online = online;

     }

     public boolean isOnline()

     {

         return online;

     }

     public void setInteractive( boolean interactive )

     {

         this.interactive = interactive;

     }

     public void registerWagons( Collection wagons,

                                 PlexusContainer extensionContainer )

     {

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

         {

             availableWagons.put( i.next(), extensionContainer );

         }

     }

     /**

      * Applies the server configuration to the wagon

      *

      * @param wagon      the wagon to configure

      * @param repository the repository that has the configuration

      * @throws WagonConfigurationException wraps any error given during configuration of the wagon instance

      */

     private void configureWagon( Wagon wagon,

                                  ArtifactRepository repository )

         throws WagonConfigurationException

     {

         configureWagon( wagon, repository.getId() );

     }

     private void configureWagon( Wagon wagon,

                                  String repositoryId )

         throws WagonConfigurationException

     {

         if ( serverConfigurationMap.containsKey( repositoryId ) )

         {

             ComponentConfigurator componentConfigurator = null;

             try

             {

                 componentConfigurator = (ComponentConfigurator) container.lookup( ComponentConfigurator.ROLE );

                 componentConfigurator.configureComponent( wagon, (PlexusConfiguration) serverConfigurationMap

                     .get( repositoryId ), container.getContainerRealm() );

             }

             catch ( final ComponentLookupException e )

             {

                 throw new WagonConfigurationException( repositoryId,

                                                        "Unable to lookup wagon configurator. Wagon configuration cannot be applied.",

                                                        e );

             }

             catch ( ComponentConfigurationException e )

             {

                 throw new WagonConfigurationException( repositoryId, "Unable to apply wagon configuration.", e );

             }

             finally

             {

                 if ( componentConfigurator != null )

                 {

                     try

                     {

                         container.release( componentConfigurator );

                     }

                     catch ( ComponentLifecycleException e )

                     {

                         getLogger().error( "Problem releasing configurator - ignoring: " + e.getMessage() );

                     }

                 }

             }

         }

     }

     public void addConfiguration( String repositoryId,

                                   Xpp3Dom configuration )

     {

         if ( repositoryId == null || configuration == null )

         {

             throw new IllegalArgumentException( "arguments can't be null" );

         }

         final XmlPlexusConfiguration xmlConf = new XmlPlexusConfiguration( configuration );

         serverConfigurationMap.put( repositoryId, xmlConf );

     }

     public void setDefaultRepositoryPermissions( RepositoryPermissions defaultRepositoryPermissions )

     {

         this.defaultRepositoryPermissions = defaultRepositoryPermissions;

     }

 }