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() + remotePath;
 482         requestProperties.setProperty( "url", url );
 483
 484         // Is a whitelist defined?
 485         if ( CollectionUtils.isNotEmpty( connector.getWhitelist() ) )
 486         {
 487             // Path must belong to whitelist.
 488             if ( !matchesPattern( remotePath, connector.getWhitelist() ) )
 489             {
 490                 getLogger().debug( "Path [" + remotePath + "] is not part of defined whitelist (skipping transfer)." );
 491                 return null;
 492             }
 493         }
 494
 495         // Is target path part of blacklist?
 496         if ( matchesPattern( remotePath, connector.getBlacklist() ) )
 497         {
 498             getLogger().debug( "Path [" + remotePath + "] is part of blacklist (skipping transfer)." );
 499             return null;
 500         }
 501
 502         // Handle pre-download policy
 503         try
 504         {
 505             validatePolicies( this.preDownloadPolicies, connector.getPolicies(), requestProperties, localFile );
 506         }
 507         catch ( PolicyViolationException e )
 508         {
 509             String emsg = "Transfer not attempted on " + url + " : " + e.getMessage();
 510             if ( fileExists( localFile ) )
 511             {
 512                 getLogger().info( emsg + ": using already present local file." );
 513                 return localFile;
 514             }
 515
 516             getLogger().info( emsg );
 517             return null;
 518         }
 519
 520         Wagon wagon = null;
 521         try
 522         {
 523             RepositoryURL repoUrl = remoteRepository.getURL();
 524             String protocol = repoUrl.getProtocol();
 525             wagon = (Wagon) wagons.get( protocol );
 526             if ( wagon == null )
 527             {
 528                 throw new ProxyException( "Unsupported target repository protocol: " + protocol );
 529             }
 530
 531             boolean connected = connectToRepository( connector, wagon, remoteRepository );
 532             if ( connected )
 533             {
 534                 localFile = transferSimpleFile( wagon, remoteRepository, remotePath, localFile );
 535
 536                 transferChecksum( wagon, remoteRepository, remotePath, localFile, ".sha1" );
 537                 transferChecksum( wagon, remoteRepository, remotePath, localFile, ".md5" );
 538             }
 539         }
 540         catch ( NotFoundException e )
 541         {
 542             // Do not cache url here.
 543             throw e;
 544         }
 545         catch ( NotModifiedException e )
 546         {
 547             // Do not cache url here.
 548             throw e;
 549         }
 550         catch ( ProxyException e )
 551         {
 552             urlFailureCache.cacheFailure( url );
 553             throw e;
 554         }
 555         finally
 556         {
 557             if ( wagon != null )
 558             {
 559                 try
 560                 {
 561                     wagon.disconnect();
 562                 }
 563                 catch ( ConnectionException e )
 564                 {
 565                     getLogger().warn( "Unable to disconnect wagon.", e );
 566                 }
 567             }
 568         }
 569
 570         // Handle post-download policies.
 571         try
 572         {
 573             validatePolicies( this.postDownloadPolicies, connector.getPolicies(), requestProperties, localFile );
 574         }
 575         catch ( PolicyViolationException e )
 576         {
 577             getLogger().info( "Transfer invalidated from " + url + " : " + e.getMessage() );
 578             if ( fileExists( localFile ) )
 579             {
 580                 return localFile;
 581             }
 582
 583             return null;
 584         }
 585
 586         // Just-in-time update of the index and database by executing the consumers for this artifact
 587         consumers.executeConsumers( connector.getSourceRepository().getRepository(), localFile );
 588
 589         // Everything passes.
 590         return localFile;
 591     }
 592
 593     /**
 594      * <p>
 595      * Quietly transfer the checksum file from the remote repository to the local file.
 596      * </p>
 597      *
 598      * @param wagon            the wagon instance (should already be connected) to use.
 599      * @param remoteRepository the remote repository to transfer from.
 600      * @param remotePath       the remote path to the resource to get.
 601      * @param localFile        the local file that should contain the downloaded contents
 602      * @param type             the type of checksum to transfer (example: ".md5" or ".sha1")
 603      * @throws ProxyException if copying the downloaded file into place did not succeed.
 604      */
 605     private void transferChecksum( Wagon wagon, RemoteRepositoryContent remoteRepository, String remotePath,
 606                                    File localFile, String type )
 607         throws ProxyException
 608     {
 609         String url = remoteRepository.getURL().getUrl() + remotePath;
 610
 611         // Transfer checksum does not use the policy.
 612         if ( urlFailureCache.hasFailedBefore( url + type ) )
 613         {
 614             return;
 615         }
 616
 617         try
 618         {
 619             File hashFile = new File( localFile.getAbsolutePath() + type );
 620             transferSimpleFile( wagon, remoteRepository, remotePath + type, hashFile );
 621             getLogger().debug( "Checksum" + type + " Downloaded: " + hashFile );
 622         }
 623         catch ( NotFoundException e )
 624         {
 625             getLogger().debug( "Transfer failed, checksum not found: " + url );
 626             // Consume it, do not pass this on.
 627         }
 628         catch ( NotModifiedException e )
 629         {
 630             getLogger().debug( "Transfer skipped, checksum not modified: " + url );
 631             // Consume it, do not pass this on.
 632         }
 633         catch ( ProxyException e )
 634         {
 635             urlFailureCache.cacheFailure( url + type );
 636             getLogger().warn( "Transfer failed on checksum: " + url + " : " + e.getMessage(), e );
 637             // Critical issue, pass it on.
 638             throw e;
 639         }
 640     }
 641
 642     /**
 643      * Perform the transfer of the remote file to the local file specified.
 644      *
 645      * @param wagon            the wagon instance to use.
 646      * @param remoteRepository the remote repository to use
 647      * @param remotePath       the remote path to attempt to get
 648      * @param localFile        the local file to save to
 649      * @return The local file that was transfered.
 650      * @throws ProxyException if there was a problem moving the downloaded file into place.
 651      * @throws WagonException if there was a problem tranfering the file.
 652      */
 653     private File transferSimpleFile( Wagon wagon, RemoteRepositoryContent remoteRepository, String remotePath,
 654                                      File localFile )
 655         throws ProxyException
 656     {
 657         assert ( remotePath != null );
 658
 659         // Transfer the file.
 660         File temp = null;
 661
 662         try
 663         {
 664             temp = new File( localFile.getAbsolutePath() + ".tmp" );
 665
 666             boolean success = false;
 667
 668             if ( !localFile.exists() )
 669             {
 670                 getLogger().debug( "Retrieving " + remotePath + " from " + remoteRepository.getRepository().getName() );
 671                 wagon.get( remotePath, temp );
 672                 success = true;
 673
 674                 if ( temp.exists() )
 675                 {
 676                     moveTempToTarget( temp, localFile );
 677                 }
 678
 679                 // You wouldn't get here on failure, a WagonException would have been thrown.
 680                 getLogger().debug( "Downloaded successfully." );
 681             }
 682             else
 683             {
 684                 getLogger().debug( "Retrieving " + remotePath + " from " + remoteRepository.getRepository().getName()
 685                                        + " if updated" );
 686                 success = wagon.getIfNewer( remotePath, temp, localFile.lastModified() );
 687                 if ( !success )
 688                 {
 689                     throw new NotModifiedException( "Not downloaded, as local file is newer than remote side: "
 690                                                     + localFile.getAbsolutePath() );
 691                 }
 692
 693                 if ( temp.exists() )
 694                 {
 695                     getLogger().debug( "Downloaded successfully." );
 696                     moveTempToTarget( temp, localFile );
 697                 }
 698             }
 699
 700             return localFile;
 701         }
 702         catch ( ResourceDoesNotExistException e )
 703         {
 704             throw new NotFoundException( "Resource [" + remoteRepository.getURL() + "/" + remotePath
 705                 + "] does not exist: " + e.getMessage(), e );
 706         }
 707         catch ( WagonException e )
 708         {
 709             throw new ProxyException( "Download failure on resource [" + remoteRepository.getURL() + "/" + remotePath + "]:"
 710                                   + e.getMessage(), e );
 711         }
 712         finally
 713         {
 714             if ( temp != null )
 715             {
 716                 temp.delete();
 717             }
 718         }
 719     }
 720
 721     /**
 722      * Apply the policies.
 723      *
 724      * @param policies  the map of policies to execute. (Map of String policy keys, to {@link DownloadPolicy} objects)
 725      * @param settings  the map of settings for the policies to execute. (Map of String policy keys, to String policy setting)
 726      * @param request   the request properties (utilized by the {@link DownloadPolicy#applyPolicy(String,Properties,File)})
 727      * @param localFile the local file (utilized by the {@link DownloadPolicy#applyPolicy(String,Properties,File)})
 728      */
 729     private void validatePolicies( Map<String, ? extends DownloadPolicy> policies, Map<String, String> settings,
 730                                    Properties request, File localFile )
 731         throws PolicyViolationException
 732     {
 733         for ( Entry<String, ? extends DownloadPolicy> entry : policies.entrySet() )
 734         {
 735             String key = (String) entry.getKey();
 736             DownloadPolicy policy = entry.getValue();
 737             String defaultSetting = policy.getDefaultOption();
 738             String setting = StringUtils.defaultString( (String) settings.get( key ), defaultSetting );
 739
 740             getLogger().debug( "Applying [" + key + "] policy with [" + setting + "]" );
 741             try
 742             {
 743                 policy.applyPolicy( setting, request, localFile );
 744             }
 745             catch ( PolicyConfigurationException e )
 746             {
 747                 getLogger().error( e.getMessage(), e );
 748             }
 749         }
 750     }
 751
 752     /**
 753      * Used to move the temporary file to its real destination.  This is patterned from the way WagonManager handles
 754      * its downloaded files.
 755      *
 756      * @param temp   The completed download file
 757      * @param target The final location of the downloaded file
 758      * @throws ProxyException when the temp file cannot replace the target file
 759      */
 760     private void moveTempToTarget( File temp, File target )
 761         throws ProxyException
 762     {
 763         if ( target.exists() && !target.delete() )
 764         {
 765             throw new ProxyException( "Unable to overwrite existing target file: " + target.getAbsolutePath() );
 766         }
 767
 768         if ( !temp.renameTo( target ) )
 769         {
 770             getLogger().warn( "Unable to rename tmp file to its final name... resorting to copy command." );
 771
 772             try
 773             {
 774                 FileUtils.copyFile( temp, target );
 775             }
 776             catch ( IOException e )
 777             {
 778                 throw new ProxyException( "Cannot copy tmp file to its final location", e );
 779             }
 780             finally
 781             {
 782                 temp.delete();
 783             }
 784         }
 785     }
 786
 787     /**
 788      * Using wagon, connect to the remote repository.
 789      *
 790      * @param connector        the connector configuration to utilize (for obtaining network proxy configuration from)
 791      * @param wagon            the wagon instance to establish the connection on.
 792      * @param remoteRepository the remote repository to connect to.
 793      * @return true if the connection was successful. false if not connected.
 794      */
 795     private boolean connectToRepository( ProxyConnector connector, Wagon wagon, RemoteRepositoryContent remoteRepository )
 796     {
 797         boolean connected = false;
 798
 799         ProxyInfo networkProxy = null;
 800         synchronized ( this.networkProxyMap )
 801         {
 802             networkProxy = (ProxyInfo) this.networkProxyMap.get( connector.getProxyId() );
 803         }
 804
 805         try
 806         {
 807             AuthenticationInfo authInfo = null;
 808             String username = remoteRepository.getRepository().getUsername();
 809             String password = remoteRepository.getRepository().getPassword();
 810
 811             if ( StringUtils.isNotBlank( username ) && StringUtils.isNotBlank( password ) )
 812             {
 813                 getLogger().debug( "Using username " + username + " to connect to remote repository "
 814                                        + remoteRepository.getURL() );
 815                 authInfo = new AuthenticationInfo();
 816                 authInfo.setUserName( username );
 817                 authInfo.setPassword( password );
 818             }
 819             else
 820             {
 821                 getLogger().debug( "No authentication for remote repository needed" );
 822             }
 823
 824             Repository wagonRepository = new Repository( remoteRepository.getId(), remoteRepository.getURL().toString() );
 825             if ( networkProxy != null )
 826             {
 827                 wagon.connect( wagonRepository, authInfo, networkProxy );
 828             }
 829             else
 830             {
 831                 wagon.connect( wagonRepository, authInfo );
 832             }
 833             connected = true;
 834         }
 835         catch ( ConnectionException e )
 836         {
 837             getLogger().warn(
 838                               "Could not connect to " + remoteRepository.getRepository().getName() + ": "
 839                                   + e.getMessage() );
 840             connected = false;
 841         }
 842         catch ( AuthenticationException e )
 843         {
 844             getLogger().warn(
 845                               "Could not connect to " + remoteRepository.getRepository().getName() + ": "
 846                                   + e.getMessage() );
 847             connected = false;
 848         }
 849
 850         return connected;
 851     }
 852
 853     /**
 854      * Tests whitelist and blacklist patterns against path.
 855      *
 856      * @param path     the path to test.
 857      * @param patterns the list of patterns to check.
 858      * @return true if the path matches at least 1 pattern in the provided patterns list.
 859      */
 860     private boolean matchesPattern( String path, List<String> patterns )
 861     {
 862         if ( CollectionUtils.isEmpty( patterns ) )
 863         {
 864             return false;
 865         }
 866
 867         for ( String pattern : patterns )
 868         {
 869             if ( SelectorUtils.matchPath( pattern, path, false ) )
 870             {
 871                 return true;
 872             }
 873         }
 874
 875         return false;
 876     }
 877
 878     /**
 879      * TODO: Ensure that list is correctly ordered based on configuration. See MRM-477
 880      */
 881     public List<ProxyConnector> getProxyConnectors( ManagedRepositoryContent repository )
 882     {
 883         synchronized ( this.proxyConnectorMap )
 884         {
 885             List<ProxyConnector> ret = (List<ProxyConnector>) this.proxyConnectorMap.get( repository.getId() );
 886             if ( ret == null )
 887             {
 888                 return Collections.EMPTY_LIST;
 889             }
 890
 891             Collections.sort( ret, ProxyConnectorOrderComparator.getInstance() );
 892             return ret;
 893         }
 894     }
 895
 896     public void afterConfigurationChange( Registry registry, String propertyName, Object propertyValue )
 897     {
 898         if ( ConfigurationNames.isNetworkProxy( propertyName )
 899             || ConfigurationNames.isManagedRepositories( propertyName )
 900             || ConfigurationNames.isRemoteRepositories( propertyName )
 901             || ConfigurationNames.isProxyConnector( propertyName ) )
 902         {
 903             initConnectorsAndNetworkProxies();
 904         }
 905     }
 906
 907     public void beforeConfigurationChange( Registry registry, String propertyName, Object propertyValue )
 908     {
 909         /* do nothing */
 910     }
 911
 912     private void initConnectorsAndNetworkProxies()
 913     {
 914         synchronized ( this.proxyConnectorMap )
 915         {
 916             ProxyConnectorOrderComparator proxyOrderSorter = new ProxyConnectorOrderComparator();
 917             this.proxyConnectorMap.clear();
 918
 919             List<ProxyConnectorConfiguration> proxyConfigs = archivaConfiguration.getConfiguration()
 920                 .getProxyConnectors();
 921             for ( ProxyConnectorConfiguration proxyConfig : proxyConfigs )
 922             {
 923                 String key = proxyConfig.getSourceRepoId();
 924
 925                 try
 926                 {
 927                     // Create connector object.
 928                     ProxyConnector connector = new ProxyConnector();
 929
 930                     connector.setSourceRepository( repositoryFactory.getManagedRepositoryContent( proxyConfig
 931                         .getSourceRepoId() ) );
 932                     connector.setTargetRepository( repositoryFactory.getRemoteRepositoryContent( proxyConfig
 933                         .getTargetRepoId() ) );
 934
 935                     connector.setProxyId( proxyConfig.getProxyId() );
 936                     connector.setPolicies( proxyConfig.getPolicies() );
 937                     connector.setOrder( proxyConfig.getOrder() );
 938
 939                     // Copy any blacklist patterns.
 940                     List<String> blacklist = new ArrayList<String>();
 941                     if ( CollectionUtils.isNotEmpty( proxyConfig.getBlackListPatterns() ) )
 942                     {
 943                         blacklist.addAll( proxyConfig.getBlackListPatterns() );
 944                     }
 945                     connector.setBlacklist( blacklist );
 946
 947                     // Copy any whitelist patterns.
 948                     List<String> whitelist = new ArrayList<String>();
 949                     if ( CollectionUtils.isNotEmpty( proxyConfig.getWhiteListPatterns() ) )
 950                     {
 951                         whitelist.addAll( proxyConfig.getWhiteListPatterns() );
 952                     }
 953                     connector.setWhitelist( whitelist );
 954
 955                     // Get other connectors
 956                     List<ProxyConnector> connectors = this.proxyConnectorMap.get( key );
 957                     if ( connectors == null )
 958                     {
 959                         // Create if we are the first.
 960                         connectors = new ArrayList<ProxyConnector>();
 961                     }
 962
 963                     // Add the connector.
 964                     connectors.add( connector );
 965
 966                     // Ensure the list is sorted.
 967                     Collections.sort( connectors, proxyOrderSorter );
 968
 969                     // Set the key to the list of connectors.
 970                     this.proxyConnectorMap.put( key, connectors );
 971                 }
 972                 catch ( RepositoryNotFoundException e )
 973                 {
 974                     getLogger().warn( "Unable to use proxy connector: " + e.getMessage(), e );
 975                 }
 976                 catch ( RepositoryException e )
 977                 {
 978                     getLogger().warn( "Unable to use proxy connector: " + e.getMessage(), e );
 979                 }
 980             }
 981
 982         }
 983
 984         synchronized ( this.networkProxyMap )
 985         {
 986             this.networkProxyMap.clear();
 987
 988             List<NetworkProxyConfiguration> networkProxies = archivaConfiguration.getConfiguration()
 989                 .getNetworkProxies();
 990             for ( NetworkProxyConfiguration networkProxyConfig : networkProxies )
 991             {
 992                 String key = networkProxyConfig.getId();
 993
 994                 ProxyInfo proxy = new ProxyInfo();
 995
 996                 proxy.setType( networkProxyConfig.getProtocol() );
 997                 proxy.setHost( networkProxyConfig.getHost() );
 998                 proxy.setPort( networkProxyConfig.getPort() );
 999                 proxy.setUserName( networkProxyConfig.getUsername() );
1000                 proxy.setPassword( networkProxyConfig.getPassword() );
1001
1002                 this.networkProxyMap.put( key, proxy );
1003             }
1004         }
1005     }
1006
1007     public void initialize()
1008         throws InitializationException
1009     {
1010         initConnectorsAndNetworkProxies();
1011         archivaConfiguration.addChangeListener( this );
1012     }
1013 }