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