source.dussan.org Git - archiva.git/blob

   1 package org.apache.maven.archiva.proxy;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  *  http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22 import org.apache.commons.collections.CollectionUtils;
  23 import org.apache.commons.io.FileUtils;
  24 import org.apache.commons.lang.StringUtils;
  25 import org.apache.maven.archiva.configuration.ArchivaConfiguration;
  26 import org.apache.maven.archiva.configuration.ConfigurationNames;
  27 import org.apache.maven.archiva.configuration.NetworkProxyConfiguration;
  28 import org.apache.maven.archiva.configuration.ProxyConnectorConfiguration;
  29 import org.apache.maven.archiva.model.ArtifactReference;
  30 import org.apache.maven.archiva.model.Keys;
  31 import org.apache.maven.archiva.model.ProjectReference;
  32 import org.apache.maven.archiva.model.RepositoryURL;
  33 import org.apache.maven.archiva.model.VersionedReference;
  34 import org.apache.maven.archiva.policies.DownloadPolicy;
  35 import org.apache.maven.archiva.policies.PolicyConfigurationException;
  36 import org.apache.maven.archiva.policies.PolicyViolationException;
  37 import org.apache.maven.archiva.policies.PostDownloadPolicy;
  38 import org.apache.maven.archiva.policies.PreDownloadPolicy;
  39 import org.apache.maven.archiva.policies.urlcache.UrlFailureCache;
  40 import org.apache.maven.archiva.repository.ContentNotFoundException;
  41 import org.apache.maven.archiva.repository.ManagedRepositoryContent;
  42 import org.apache.maven.archiva.repository.RemoteRepositoryContent;
  43 import org.apache.maven.archiva.repository.RepositoryContentFactory;
  44 import org.apache.maven.archiva.repository.RepositoryException;
  45 import org.apache.maven.archiva.repository.RepositoryNotFoundException;
  46 import org.apache.maven.archiva.repository.layout.LayoutException;
  47 import org.apache.maven.archiva.repository.metadata.MetadataTools;
  48 import org.apache.maven.archiva.repository.metadata.RepositoryMetadataException;
  49 import org.apache.maven.archiva.repository.scanner.RepositoryContentConsumers;
  50 import org.apache.maven.wagon.ConnectionException;
  51 import org.apache.maven.wagon.ResourceDoesNotExistException;
  52 import org.apache.maven.wagon.Wagon;
  53 import org.apache.maven.wagon.WagonException;
  54 import org.apache.maven.wagon.authentication.AuthenticationException;
  55 import org.apache.maven.wagon.authentication.AuthenticationInfo;
  56 import org.apache.maven.wagon.proxy.ProxyInfo;
  57 import org.apache.maven.wagon.repository.Repository;
  58 import org.codehaus.plexus.logging.AbstractLogEnabled;
  59 import org.codehaus.plexus.personality.plexus.lifecycle.phase.Initializable;
  60 import org.codehaus.plexus.personality.plexus.lifecycle.phase.InitializationException;
  61 import org.codehaus.plexus.registry.Registry;
  62 import org.codehaus.plexus.registry.RegistryListener;
  63 import org.codehaus.plexus.util.SelectorUtils;
  64
  65 import java.io.File;
  66 import java.io.IOException;
  67 import java.util.ArrayList;
  68 import java.util.Collections;
  69 import java.util.HashMap;
  70 import java.util.List;
  71 import java.util.Map;
  72 import java.util.Map.Entry;
  73 import java.util.Properties;
  74
  75 /**
  76  * DefaultRepositoryProxyConnectors
  77  *
  78  * @author <a href="mailto:joakime@apache.org">Joakim Erdfelt</a>
  79  * @version $Id$
  80  * @plexus.component role-hint="default"
  81  */
  82 public class DefaultRepositoryProxyConnectors
  83     extends AbstractLogEnabled
  84     implements RepositoryProxyConnectors, RegistryListener, Initializable
  85 {
  86     /**
  87      * @plexus.requirement
  88      */
  89     private ArchivaConfiguration archivaConfiguration;
  90
  91     /**
  92      * @plexus.requirement role="org.apache.maven.wagon.Wagon"
  93      */
  94     private Map<String, Wagon> wagons;
  95
  96     /**
  97      * @plexus.requirement
  98      */
  99     private RepositoryContentFactory repositoryFactory;
 100
 101     /**
 102      * @plexus.requirement
 103      */
 104     private MetadataTools metadataTools;
 105
 106     /**
 107      * @plexus.requirement role="org.apache.maven.archiva.policies.PreDownloadPolicy"
 108      */
 109     private Map<String, PreDownloadPolicy> preDownloadPolicies;
 110
 111     /**
 112      * @plexus.requirement role="org.apache.maven.archiva.policies.PostDownloadPolicy"
 113      */
 114     private Map<String, PostDownloadPolicy> postDownloadPolicies;
 115
 116     /**
 117      * @plexus.requirement role-hint="default"
 118      */
 119     private UrlFailureCache urlFailureCache;
 120
 121     private Map<String, List<ProxyConnector>> proxyConnectorMap = new HashMap<String, List<ProxyConnector>>();
 122
 123     private Map<String, ProxyInfo> networkProxyMap = new HashMap<String, ProxyInfo>();
 124
 125     /**
 126      * @plexus.requirement
 127      */
 128     private RepositoryContentConsumers consumers;
 129
 130     /**
 131      * Fetch an artifact from a remote repository.
 132      *
 133      * @param repository the managed repository to utilize for the request.
 134      * @param artifact   the artifact reference to fetch.
 135      * @return the local file in the managed repository that was fetched, or null if the artifact was not (or
 136      *         could not be) fetched.
 137      * @throws ProxyException if there was a problem fetching the artifact.
 138      */
 139     public File fetchFromProxies( ManagedRepositoryContent repository, ArtifactReference artifact )
 140     {
 141         File localFile = toLocalFile( repository, artifact );
 142
 143         Properties requestProperties = new Properties();
 144         requestProperties.setProperty( "filetype", "artifact" );
 145         requestProperties.setProperty( "version", artifact.getVersion() );
 146
 147         List<ProxyConnector> connectors = getProxyConnectors( repository );
 148         for ( ProxyConnector connector : connectors )
 149         {
 150             RemoteRepositoryContent targetRepository = connector.getTargetRepository();
 151             String targetPath = targetRepository.toPath( artifact );
 152
 153             try
 154             {
 155                 File downloadedFile = transferFile( connector, targetRepository, targetPath, localFile,
 156                                                     requestProperties );
 157
 158                 if ( fileExists( downloadedFile ) )
 159                 {
 160                     getLogger().debug( "Successfully transferred: " + downloadedFile.getAbsolutePath() );
 161                     return downloadedFile;
 162                 }
 163             }
 164             catch ( NotFoundException e )
 165             {
 166                 getLogger().debug( "Artifact " + Keys.toKey( artifact ) + " not found on repository \""
 167                                        + targetRepository.getRepository().getId() + "\"." );
 168             }
 169             catch ( NotModifiedException e )
 170             {
 171                 getLogger().debug( "Artifact " + Keys.toKey( artifact ) + " not updated on repository \""
 172                                        + targetRepository.getRepository().getId() + "\"." );
 173             }
 174             catch ( ProxyException e )
 175             {
 176                 getLogger().warn( "Transfer error from repository \"" + targetRepository.getRepository().getId() +
 177                     "\" for artifact " + Keys.toKey( artifact ) + ", continuing to next repository. Error message: " +
 178                     e.getMessage() );
 179                 getLogger().debug( "Full stack trace", e );
 180             }
 181         }
 182         getLogger().debug( "Exhausted all target repositories, artifact " + Keys.toKey( artifact ) + " not found." );
 183
 184         return null;
 185     }
 186
 187     /**
 188      * Fetch, from the proxies, a metadata.xml file for the groupId:artifactId:version metadata contents.
 189      *
 190      * @return the (local) metadata file that was fetched/merged/updated, or null if no metadata file exists.
 191      */
 192     public File fetchFromProxies( ManagedRepositoryContent repository, VersionedReference metadata )
 193     {
 194         File localFile = toLocalFile( repository, metadata );
 195
 196         Properties requestProperties = new Properties();
 197         requestProperties.setProperty( "filetype", "metadata" );
 198         boolean metadataNeedsUpdating = false;
 199         long originalTimestamp = getLastModified( localFile );
 200
 201         List<ProxyConnector> connectors = getProxyConnectors( repository );
 202         for ( ProxyConnector connector : connectors )
 203         {
 204             RemoteRepositoryContent targetRepository = connector.getTargetRepository();
 205             String targetPath = metadataTools.toPath( metadata );
 206
 207             File localRepoFile = toLocalRepoFile( repository, targetRepository, targetPath );
 208             long originalMetadataTimestamp = getLastModified( localRepoFile );
 209
 210             try
 211             {
 212                 transferFile( connector, targetRepository, targetPath, localRepoFile, requestProperties );
 213
 214                 if ( hasBeenUpdated( localRepoFile, originalMetadataTimestamp ) )
 215                 {
 216                     metadataNeedsUpdating = true;
 217                 }
 218             }
 219             catch ( NotFoundException e )
 220             {
 221                 getLogger().debug( "Versioned Metadata " + Keys.toKey( metadata )
 222                                        + " not found on remote repository \""
 223                                        + targetRepository.getRepository().getId() + "\"." );
 224             }
 225             catch ( NotModifiedException e )
 226             {
 227                 getLogger().debug( "Versioned Metadata " + Keys.toKey( metadata )
 228                                        + " not updated on remote repository \""
 229                                        + targetRepository.getRepository().getId() + "\"." );
 230             }
 231             catch ( ProxyException e )
 232             {
 233                 getLogger().warn( "Transfer error from repository \"" + targetRepository.getRepository().getId() +
 234                     "\" for versioned Metadata " + Keys.toKey( metadata ) +
 235                     ", continuing to next repository. Error message: " + e.getMessage() );
 236                 getLogger().debug( "Full stack trace", e );
 237             }
 238         }
 239
 240         if ( hasBeenUpdated( localFile, originalTimestamp ) )
 241         {
 242             metadataNeedsUpdating = true;
 243         }
 244
 245         if ( metadataNeedsUpdating )
 246         {
 247             try
 248             {
 249                 metadataTools.updateMetadata( repository, metadata );
 250             }
 251             catch ( LayoutException e )
 252             {
 253                 getLogger().warn( "Unable to update metadata " + localFile.getAbsolutePath() + ": " + e.getMessage() );
 254                 // TODO: add into repository report?
 255             }
 256             catch ( RepositoryMetadataException e )
 257             {
 258                 getLogger()
 259                     .warn( "Unable to update metadata " + localFile.getAbsolutePath() + ": " + e.getMessage(), e );
 260                 // TODO: add into repository report?
 261             }
 262             catch ( IOException e )
 263             {
 264                 getLogger()
 265                     .warn( "Unable to update metadata " + localFile.getAbsolutePath() + ": " + e.getMessage(), e );
 266                 // TODO: add into repository report?
 267             }
 268             catch ( ContentNotFoundException e )
 269             {
 270                 getLogger()
 271                     .warn( "Unable to update metadata " + localFile.getAbsolutePath() + ": " + e.getMessage(), e );
 272                 // TODO: add into repository report?
 273             }
 274         }
 275
 276         if ( fileExists( localFile ) )
 277         {
 278             return localFile;
 279         }
 280
 281         return null;
 282     }
 283
 284     private long getLastModified( File file )
 285     {
 286         if ( !file.exists() || !file.isFile() )
 287         {
 288             return 0;
 289         }
 290
 291         return file.lastModified();
 292     }
 293
 294     private boolean hasBeenUpdated( File file, long originalLastModified )
 295     {
 296         if ( !file.exists() || !file.isFile() )
 297         {
 298             return false;
 299         }
 300
 301         long currentLastModified = getLastModified( file );
 302         return ( currentLastModified > originalLastModified );
 303     }
 304
 305     /**
 306      * Fetch from the proxies a metadata.xml file for the groupId:artifactId metadata contents.
 307      *
 308      * @return the (local) metadata file that was fetched/merged/updated, or null if no metadata file exists.
 309      * @throws ProxyException if there was a problem fetching the metadata file.
 310      */
 311     public File fetchFromProxies( ManagedRepositoryContent repository, ProjectReference metadata )
 312     {
 313         File localFile = toLocalFile( repository, metadata );
 314
 315         Properties requestProperties = new Properties();
 316         requestProperties.setProperty( "filetype", "metadata" );
 317         boolean metadataNeedsUpdating = false;
 318         long originalTimestamp = getLastModified( localFile );
 319
 320         List<ProxyConnector> connectors = getProxyConnectors( repository );
 321         for ( ProxyConnector connector : connectors )
 322         {
 323             RemoteRepositoryContent targetRepository = connector.getTargetRepository();
 324             String targetPath = metadataTools.toPath( metadata );
 325
 326             File localRepoFile = toLocalRepoFile( repository, targetRepository, targetPath );
 327             long originalMetadataTimestamp = getLastModified( localRepoFile );
 328             try
 329             {
 330                 transferFile( connector, targetRepository, targetPath, localRepoFile, requestProperties );
 331
 332                 if ( hasBeenUpdated( localRepoFile, originalMetadataTimestamp ) )
 333                 {
 334                     metadataNeedsUpdating = true;
 335                 }
 336             }
 337             catch ( NotFoundException e )
 338             {
 339                 getLogger().debug( "Project Metadata " + Keys.toKey( metadata ) + " not found on remote repository \""
 340                                        + targetRepository.getRepository().getId() + "\"." );
 341             }
 342             catch ( NotModifiedException e )
 343             {
 344                 getLogger().debug( "Project Metadata " + Keys.toKey( metadata )
 345                                        + " not updated on remote repository \""
 346                                        + targetRepository.getRepository().getId() + "\"." );
 347             }
 348             catch ( ProxyException e )
 349             {
 350                 getLogger().warn( "Transfer error from repository \"" + targetRepository.getRepository().getId() +
 351                     "\" for project metadata " + Keys.toKey( metadata ) +
 352                     ", continuing to next repository. Error message: " + e.getMessage() );
 353                 getLogger().debug( "Full stack trace", e );
 354             }
 355
 356         }
 357
 358         if ( hasBeenUpdated( localFile, originalTimestamp ) )
 359         {
 360             metadataNeedsUpdating = true;
 361         }
 362
 363         if ( metadataNeedsUpdating )
 364         {
 365             try
 366             {
 367                 metadataTools.updateMetadata( repository, metadata );
 368             }
 369             catch ( LayoutException e )
 370             {
 371                 getLogger().warn( "Unable to update metadata " + localFile.getAbsolutePath() + ": " + e.getMessage() );
 372                 // TODO: add into repository report?
 373             }
 374             catch ( RepositoryMetadataException e )
 375             {
 376                 getLogger()
 377                     .warn( "Unable to update metadata " + localFile.getAbsolutePath() + ": " + e.getMessage(), e );
 378                 // TODO: add into repository report?
 379             }
 380             catch ( IOException e )
 381             {
 382                 getLogger()
 383                     .warn( "Unable to update metadata " + localFile.getAbsolutePath() + ": " + e.getMessage(), e );
 384                 // TODO: add into repository report?
 385             }
 386             catch ( ContentNotFoundException e )
 387             {
 388                 getLogger()
 389                     .warn( "Unable to update metadata " + localFile.getAbsolutePath() + ": " + e.getMessage(), e );
 390                 // TODO: add into repository report?
 391             }
 392         }
 393
 394         if ( fileExists( localFile ) )
 395         {
 396             return localFile;
 397         }
 398
 399         return null;
 400     }
 401
 402     private File toLocalRepoFile( ManagedRepositoryContent repository, RemoteRepositoryContent targetRepository,
 403                                   String targetPath )
 404     {
 405         String repoPath = metadataTools.getRepositorySpecificName( targetRepository, targetPath );
 406         return new File( repository.getRepoRoot(), repoPath );
 407     }
 408
 409     /**
 410      * Test if the provided ManagedRepositoryContent has any proxies configured for it.
 411      */
 412     public boolean hasProxies( ManagedRepositoryContent repository )
 413     {
 414         synchronized ( this.proxyConnectorMap )
 415         {
 416             return this.proxyConnectorMap.containsKey( repository.getId() );
 417         }
 418     }
 419
 420     private File toLocalFile( ManagedRepositoryContent repository, ArtifactReference artifact )
 421     {
 422         return repository.toFile( artifact );
 423     }
 424
 425     private File toLocalFile( ManagedRepositoryContent repository, ProjectReference metadata )
 426     {
 427         String sourcePath = metadataTools.toPath( metadata );
 428         return new File( repository.getRepoRoot(), sourcePath );
 429     }
 430
 431     private File toLocalFile( ManagedRepositoryContent repository, VersionedReference metadata )
 432     {
 433         String sourcePath = metadataTools.toPath( metadata );
 434         return new File( repository.getRepoRoot(), sourcePath );
 435     }
 436
 437     /**
 438      * Simple method to test if the file exists on the local disk.
 439      *
 440      * @param file the file to test. (may be null)
 441      * @return true if file exists. false if the file param is null, doesn't exist, or is not of type File.
 442      */
 443     private boolean fileExists( File file )
 444     {
 445         if ( file == null )
 446         {
 447             return false;
 448         }
 449
 450         if ( !file.exists() )
 451         {
 452             return false;
 453         }
 454
 455         if ( !file.isFile() )
 456         {
 457             return false;
 458         }
 459
 460         return true;
 461     }
 462
 463     /**
 464      * Perform the transfer of the file.
 465      *
 466      * @param connector         the connector configuration to use.
 467      * @param remoteRepository  the remote repository get the resource from.
 468      * @param remotePath        the path in the remote repository to the resource to get.
 469      * @param localFile         the local file to place the downloaded resource into
 470      * @param requestProperties the request properties to utilize for policy handling.
 471      * @return the local file that was downloaded, or null if not downloaded.
 472      * @throws NotFoundException if the file was not found on the remote repository.
 473      * @throws NotModifiedException if the localFile was present, and the resource was present on remote repository,
 474      *                              but the remote resource is not newer than the local File.
 475      * @throws ProxyException if transfer was unsuccessful.
 476      */
 477     private File transferFile( ProxyConnector connector, RemoteRepositoryContent remoteRepository, String remotePath,
 478                                File localFile, Properties requestProperties )
 479         throws ProxyException, NotModifiedException
 480     {
 481         String url = remoteRepository.getURL().getUrl();
 482         if ( !url.endsWith( "/" ) )
 483         {
 484             url = url + "/";
 485         }
 486         url = url + remotePath;
 487         requestProperties.setProperty( "url", url );
 488
 489         // Is a whitelist defined?
 490         if ( CollectionUtils.isNotEmpty( connector.getWhitelist() ) )
 491         {
 492             // Path must belong to whitelist.
 493             if ( !matchesPattern( remotePath, connector.getWhitelist() ) )
 494             {
 495                 getLogger().debug( "Path [" + remotePath + "] is not part of defined whitelist (skipping transfer)." );
 496                 return null;
 497             }
 498         }
 499
 500         // Is target path part of blacklist?
 501         if ( matchesPattern( remotePath, connector.getBlacklist() ) )
 502         {
 503             getLogger().debug( "Path [" + remotePath + "] is part of blacklist (skipping transfer)." );
 504             return null;
 505         }
 506
 507         // Handle pre-download policy
 508         try
 509         {
 510             validatePolicies( this.preDownloadPolicies, connector.getPolicies(), requestProperties, localFile );
 511         }
 512         catch ( PolicyViolationException e )
 513         {
 514             String emsg = "Transfer not attempted on " + url + " : " + e.getMessage();
 515             if ( fileExists( localFile ) )
 516             {
 517                 getLogger().info( emsg + ": using already present local file." );
 518                 return localFile;
 519             }
 520
 521             getLogger().info( emsg );
 522             return null;
 523         }
 524
 525         Wagon wagon = null;
 526         try
 527         {
 528             RepositoryURL repoUrl = remoteRepository.getURL();
 529             String protocol = repoUrl.getProtocol();
 530             wagon = (Wagon) wagons.get( protocol );
 531             if ( wagon == null )
 532             {
 533                 throw new ProxyException( "Unsupported target repository protocol: " + protocol );
 534             }
 535
 536             boolean connected = connectToRepository( connector, wagon, remoteRepository );
 537             if ( connected )
 538             {
 539                 localFile = transferSimpleFile( wagon, remoteRepository, remotePath, localFile );
 540
 541                 transferChecksum( wagon, remoteRepository, remotePath, localFile, ".sha1" );
 542                 transferChecksum( wagon, remoteRepository, remotePath, localFile, ".md5" );
 543             }
 544         }
 545         catch ( NotFoundException e )
 546         {
 547             // Do not cache url here.
 548             throw e;
 549         }
 550         catch ( NotModifiedException e )
 551         {
 552             // Do not cache url here.
 553             throw e;
 554         }
 555         catch ( ProxyException e )
 556         {
 557             urlFailureCache.cacheFailure( url );
 558             throw e;
 559         }
 560         finally
 561         {
 562             if ( wagon != null )
 563             {
 564                 try
 565                 {
 566                     wagon.disconnect();
 567                 }
 568                 catch ( ConnectionException e )
 569                 {
 570                     getLogger().warn( "Unable to disconnect wagon.", e );
 571                 }
 572             }
 573         }
 574
 575         // Handle post-download policies.
 576         try
 577         {
 578             validatePolicies( this.postDownloadPolicies, connector.getPolicies(), requestProperties, localFile );
 579         }
 580         catch ( PolicyViolationException e )
 581         {
 582             getLogger().info( "Transfer invalidated from " + url + " : " + e.getMessage() );
 583             if ( fileExists( localFile ) )
 584             {
 585                 return localFile;
 586             }
 587
 588             return null;
 589         }
 590
 591         // Just-in-time update of the index and database by executing the consumers for this artifact
 592         consumers.executeConsumers( connector.getSourceRepository().getRepository(), localFile );
 593
 594         // Everything passes.
 595         return localFile;
 596     }
 597
 598     /**
 599      * <p>
 600      * Quietly transfer the checksum file from the remote repository to the local file.
 601      * </p>
 602      *
 603      * @param wagon            the wagon instance (should already be connected) to use.
 604      * @param remoteRepository the remote repository to transfer from.
 605      * @param remotePath       the remote path to the resource to get.
 606      * @param localFile        the local file that should contain the downloaded contents
 607      * @param type             the type of checksum to transfer (example: ".md5" or ".sha1")
 608      * @throws ProxyException if copying the downloaded file into place did not succeed.
 609      */
 610     private void transferChecksum( Wagon wagon, RemoteRepositoryContent remoteRepository, String remotePath,
 611                                    File localFile, String type )
 612         throws ProxyException
 613     {
 614         String url = remoteRepository.getURL().getUrl() + remotePath;
 615
 616         // Transfer checksum does not use the policy.
 617         if ( urlFailureCache.hasFailedBefore( url + type ) )
 618         {
 619             return;
 620         }
 621
 622         try
 623         {
 624             File hashFile = new File( localFile.getAbsolutePath() + type );
 625             transferSimpleFile( wagon, remoteRepository, remotePath + type, hashFile );
 626             getLogger().debug( "Checksum" + type + " Downloaded: " + hashFile );
 627         }
 628         catch ( NotFoundException e )
 629         {
 630             getLogger().debug( "Transfer failed, checksum not found: " + url );
 631             // Consume it, do not pass this on.
 632         }
 633         catch ( NotModifiedException e )
 634         {
 635             getLogger().debug( "Transfer skipped, checksum not modified: " + url );
 636             // Consume it, do not pass this on.
 637         }
 638         catch ( ProxyException e )
 639         {
 640             urlFailureCache.cacheFailure( url + type );
 641             getLogger().warn( "Transfer failed on checksum: " + url + " : " + e.getMessage(), e );
 642             // Critical issue, pass it on.
 643             throw e;
 644         }
 645     }
 646
 647     /**
 648      * Perform the transfer of the remote file to the local file specified.
 649      *
 650      * @param wagon            the wagon instance to use.
 651      * @param remoteRepository the remote repository to use
 652      * @param remotePath       the remote path to attempt to get
 653      * @param localFile        the local file to save to
 654      * @return The local file that was transfered.
 655      * @throws ProxyException if there was a problem moving the downloaded file into place.
 656      * @throws WagonException if there was a problem tranfering the file.
 657      */
 658     private File transferSimpleFile( Wagon wagon, RemoteRepositoryContent remoteRepository, String remotePath,
 659                                      File localFile )
 660         throws ProxyException
 661     {
 662         assert ( remotePath != null );
 663
 664         // Transfer the file.
 665         File temp = null;
 666
 667         try
 668         {
 669             temp = new File( localFile.getAbsolutePath() + ".tmp" );
 670
 671             boolean success = false;
 672
 673             if ( !localFile.exists() )
 674             {
 675                 getLogger().debug( "Retrieving " + remotePath + " from " + remoteRepository.getRepository().getName() );
 676                 wagon.get( remotePath, temp );
 677                 success = true;
 678
 679                 if ( temp.exists() )
 680                 {
 681                     moveTempToTarget( temp, localFile );
 682                 }
 683
 684                 // You wouldn't get here on failure, a WagonException would have been thrown.
 685                 getLogger().debug( "Downloaded successfully." );
 686             }
 687             else
 688             {
 689                 getLogger().debug( "Retrieving " + remotePath + " from " + remoteRepository.getRepository().getName()
 690                                        + " if updated" );
 691                 success = wagon.getIfNewer( remotePath, temp, localFile.lastModified() );
 692                 if ( !success )
 693                 {
 694                     throw new NotModifiedException( "Not downloaded, as local file is newer than remote side: "
 695                                                     + localFile.getAbsolutePath() );
 696                 }
 697
 698                 if ( temp.exists() )
 699                 {
 700                     getLogger().debug( "Downloaded successfully." );
 701                     moveTempToTarget( temp, localFile );
 702                 }
 703             }
 704
 705             return localFile;
 706         }
 707         catch ( ResourceDoesNotExistException e )
 708         {
 709             throw new NotFoundException( "Resource [" + remoteRepository.getURL() + "/" + remotePath
 710                 + "] does not exist: " + e.getMessage(), e );
 711         }
 712         catch ( WagonException e )
 713         {
 714             throw new ProxyException( "Download failure on resource [" + remoteRepository.getURL() + "/" + remotePath + "]:"
 715                                   + e.getMessage(), e );
 716         }
 717         finally
 718         {
 719             if ( temp != null )
 720             {
 721                 temp.delete();
 722             }
 723         }
 724     }
 725
 726     /**
 727      * Apply the policies.
 728      *
 729      * @param policies  the map of policies to execute. (Map of String policy keys, to {@link DownloadPolicy} objects)
 730      * @param settings  the map of settings for the policies to execute. (Map of String policy keys, to String policy setting)
 731      * @param request   the request properties (utilized by the {@link DownloadPolicy#applyPolicy(String,Properties,File)})
 732      * @param localFile the local file (utilized by the {@link DownloadPolicy#applyPolicy(String,Properties,File)})
 733      */
 734     private void validatePolicies( Map<String, ? extends DownloadPolicy> policies, Map<String, String> settings,
 735                                    Properties request, File localFile )
 736         throws PolicyViolationException
 737     {
 738         for ( Entry<String, ? extends DownloadPolicy> entry : policies.entrySet() )
 739         {
 740             String key = (String) entry.getKey();
 741             DownloadPolicy policy = entry.getValue();
 742             String defaultSetting = policy.getDefaultOption();
 743             String setting = StringUtils.defaultString( (String) settings.get( key ), defaultSetting );
 744
 745             getLogger().debug( "Applying [" + key + "] policy with [" + setting + "]" );
 746             try
 747             {
 748                 policy.applyPolicy( setting, request, localFile );
 749             }
 750             catch ( PolicyConfigurationException e )
 751             {
 752                 getLogger().error( e.getMessage(), e );
 753             }
 754         }
 755     }
 756
 757     /**
 758      * Used to move the temporary file to its real destination.  This is patterned from the way WagonManager handles
 759      * its downloaded files.
 760      *
 761      * @param temp   The completed download file
 762      * @param target The final location of the downloaded file
 763      * @throws ProxyException when the temp file cannot replace the target file
 764      */
 765     private void moveTempToTarget( File temp, File target )
 766         throws ProxyException
 767     {
 768         if ( target.exists() && !target.delete() )
 769         {
 770             throw new ProxyException( "Unable to overwrite existing target file: " + target.getAbsolutePath() );
 771         }
 772
 773         if ( !temp.renameTo( target ) )
 774         {
 775             getLogger().warn( "Unable to rename tmp file to its final name... resorting to copy command." );
 776
 777             try
 778             {
 779                 FileUtils.copyFile( temp, target );
 780             }
 781             catch ( IOException e )
 782             {
 783                 throw new ProxyException( "Cannot copy tmp file to its final location", e );
 784             }
 785             finally
 786             {
 787                 temp.delete();
 788             }
 789         }
 790     }
 791
 792     /**
 793      * Using wagon, connect to the remote repository.
 794      *
 795      * @param connector        the connector configuration to utilize (for obtaining network proxy configuration from)
 796      * @param wagon            the wagon instance to establish the connection on.
 797      * @param remoteRepository the remote repository to connect to.
 798      * @return true if the connection was successful. false if not connected.
 799      */
 800     private boolean connectToRepository( ProxyConnector connector, Wagon wagon, RemoteRepositoryContent remoteRepository )
 801     {
 802         boolean connected = false;
 803
 804         ProxyInfo networkProxy = null;
 805         synchronized ( this.networkProxyMap )
 806         {
 807             networkProxy = (ProxyInfo) this.networkProxyMap.get( connector.getProxyId() );
 808         }
 809
 810         try
 811         {
 812             AuthenticationInfo authInfo = null;
 813             String username = remoteRepository.getRepository().getUsername();
 814             String password = remoteRepository.getRepository().getPassword();
 815
 816             if ( StringUtils.isNotBlank( username ) && StringUtils.isNotBlank( password ) )
 817             {
 818                 getLogger().debug( "Using username " + username + " to connect to remote repository "
 819                                        + remoteRepository.getURL() );
 820                 authInfo = new AuthenticationInfo();
 821                 authInfo.setUserName( username );
 822                 authInfo.setPassword( password );
 823             }
 824             else
 825             {
 826                 getLogger().debug( "No authentication for remote repository needed" );
 827             }
 828
 829             Repository wagonRepository = new Repository( remoteRepository.getId(), remoteRepository.getURL().toString() );
 830             if ( networkProxy != null )
 831             {
 832                 wagon.connect( wagonRepository, authInfo, networkProxy );
 833             }
 834             else
 835             {
 836                 wagon.connect( wagonRepository, authInfo );
 837             }
 838             connected = true;
 839         }
 840         catch ( ConnectionException e )
 841         {
 842             getLogger().warn(
 843                               "Could not connect to " + remoteRepository.getRepository().getName() + ": "
 844                                   + e.getMessage() );
 845             connected = false;
 846         }
 847         catch ( AuthenticationException e )
 848         {
 849             getLogger().warn(
 850                               "Could not connect to " + remoteRepository.getRepository().getName() + ": "
 851                                   + e.getMessage() );
 852             connected = false;
 853         }
 854
 855         return connected;
 856     }
 857
 858     /**
 859      * Tests whitelist and blacklist patterns against path.
 860      *
 861      * @param path     the path to test.
 862      * @param patterns the list of patterns to check.
 863      * @return true if the path matches at least 1 pattern in the provided patterns list.
 864      */
 865     private boolean matchesPattern( String path, List<String> patterns )
 866     {
 867         if ( CollectionUtils.isEmpty( patterns ) )
 868         {
 869             return false;
 870         }
 871
 872         for ( String pattern : patterns )
 873         {
 874             if ( SelectorUtils.matchPath( pattern, path, false ) )
 875             {
 876                 return true;
 877             }
 878         }
 879
 880         return false;
 881     }
 882
 883     /**
 884      * TODO: Ensure that list is correctly ordered based on configuration. See MRM-477
 885      */
 886     public List<ProxyConnector> getProxyConnectors( ManagedRepositoryContent repository )
 887     {
 888         synchronized ( this.proxyConnectorMap )
 889         {
 890             List<ProxyConnector> ret = (List<ProxyConnector>) this.proxyConnectorMap.get( repository.getId() );
 891             if ( ret == null )
 892             {
 893                 return Collections.EMPTY_LIST;
 894             }
 895
 896             Collections.sort( ret, ProxyConnectorOrderComparator.getInstance() );
 897             return ret;
 898         }
 899     }
 900
 901     public void afterConfigurationChange( Registry registry, String propertyName, Object propertyValue )
 902     {
 903         if ( ConfigurationNames.isNetworkProxy( propertyName )
 904             || ConfigurationNames.isManagedRepositories( propertyName )
 905             || ConfigurationNames.isRemoteRepositories( propertyName )
 906             || ConfigurationNames.isProxyConnector( propertyName ) )
 907         {
 908             initConnectorsAndNetworkProxies();
 909         }
 910     }
 911
 912     public void beforeConfigurationChange( Registry registry, String propertyName, Object propertyValue )
 913     {
 914         /* do nothing */
 915     }
 916
 917     private void initConnectorsAndNetworkProxies()
 918     {
 919         synchronized ( this.proxyConnectorMap )
 920         {
 921             ProxyConnectorOrderComparator proxyOrderSorter = new ProxyConnectorOrderComparator();
 922             this.proxyConnectorMap.clear();
 923
 924             List<ProxyConnectorConfiguration> proxyConfigs = archivaConfiguration.getConfiguration()
 925                 .getProxyConnectors();
 926             for ( ProxyConnectorConfiguration proxyConfig : proxyConfigs )
 927             {
 928                 String key = proxyConfig.getSourceRepoId();
 929
 930                 try
 931                 {
 932                     // Create connector object.
 933                     ProxyConnector connector = new ProxyConnector();
 934
 935                     connector.setSourceRepository( repositoryFactory.getManagedRepositoryContent( proxyConfig
 936                         .getSourceRepoId() ) );
 937                     connector.setTargetRepository( repositoryFactory.getRemoteRepositoryContent( proxyConfig
 938                         .getTargetRepoId() ) );
 939
 940                     connector.setProxyId( proxyConfig.getProxyId() );
 941                     connector.setPolicies( proxyConfig.getPolicies() );
 942                     connector.setOrder( proxyConfig.getOrder() );
 943
 944                     // Copy any blacklist patterns.
 945                     List<String> blacklist = new ArrayList<String>();
 946                     if ( CollectionUtils.isNotEmpty( proxyConfig.getBlackListPatterns() ) )
 947                     {
 948                         blacklist.addAll( proxyConfig.getBlackListPatterns() );
 949                     }
 950                     connector.setBlacklist( blacklist );
 951
 952                     // Copy any whitelist patterns.
 953                     List<String> whitelist = new ArrayList<String>();
 954                     if ( CollectionUtils.isNotEmpty( proxyConfig.getWhiteListPatterns() ) )
 955                     {
 956                         whitelist.addAll( proxyConfig.getWhiteListPatterns() );
 957                     }
 958                     connector.setWhitelist( whitelist );
 959
 960                     // Get other connectors
 961                     List<ProxyConnector> connectors = this.proxyConnectorMap.get( key );
 962                     if ( connectors == null )
 963                     {
 964                         // Create if we are the first.
 965                         connectors = new ArrayList<ProxyConnector>();
 966                     }
 967
 968                     // Add the connector.
 969                     connectors.add( connector );
 970
 971                     // Ensure the list is sorted.
 972                     Collections.sort( connectors, proxyOrderSorter );
 973
 974                     // Set the key to the list of connectors.
 975                     this.proxyConnectorMap.put( key, connectors );
 976                 }
 977                 catch ( RepositoryNotFoundException e )
 978                 {
 979                     getLogger().warn( "Unable to use proxy connector: " + e.getMessage(), e );
 980                 }
 981                 catch ( RepositoryException e )
 982                 {
 983                     getLogger().warn( "Unable to use proxy connector: " + e.getMessage(), e );
 984                 }
 985             }
 986
 987         }
 988
 989         synchronized ( this.networkProxyMap )
 990         {
 991             this.networkProxyMap.clear();
 992
 993             List<NetworkProxyConfiguration> networkProxies = archivaConfiguration.getConfiguration()
 994                 .getNetworkProxies();
 995             for ( NetworkProxyConfiguration networkProxyConfig : networkProxies )
 996             {
 997                 String key = networkProxyConfig.getId();
 998
 999                 ProxyInfo proxy = new ProxyInfo();
1000
1001                 proxy.setType( networkProxyConfig.getProtocol() );
1002                 proxy.setHost( networkProxyConfig.getHost() );
1003                 proxy.setPort( networkProxyConfig.getPort() );
1004                 proxy.setUserName( networkProxyConfig.getUsername() );
1005                 proxy.setPassword( networkProxyConfig.getPassword() );
1006
1007                 this.networkProxyMap.put( key, proxy );
1008             }
1009         }
1010     }
1011
1012     public void initialize()
1013         throws InitializationException
1014     {
1015         initConnectorsAndNetworkProxies();
1016         archivaConfiguration.addChangeListener( this );
1017     }
1018 }