View Javadoc

1   package org.apache.maven.repository.legacy;
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 java.io.File;
23  import java.io.IOException;
24  import java.util.ArrayList;
25  import java.util.Collection;
26  import java.util.Collections;
27  import java.util.HashMap;
28  import java.util.LinkedHashMap;
29  import java.util.List;
30  import java.util.Map;
31  
32  import org.apache.maven.RepositoryUtils;
33  import org.apache.maven.artifact.Artifact;
34  import org.apache.maven.artifact.InvalidRepositoryException;
35  import org.apache.maven.artifact.factory.ArtifactFactory;
36  import org.apache.maven.artifact.metadata.ArtifactMetadata;
37  import org.apache.maven.artifact.repository.ArtifactRepository;
38  import org.apache.maven.repository.legacy.repository.ArtifactRepositoryFactory;
39  import org.apache.maven.artifact.repository.ArtifactRepositoryPolicy;
40  import org.apache.maven.artifact.repository.Authentication;
41  import org.apache.maven.artifact.repository.layout.ArtifactRepositoryLayout;
42  import org.apache.maven.artifact.resolver.ArtifactResolutionRequest;
43  import org.apache.maven.artifact.resolver.ArtifactResolutionResult;
44  import org.apache.maven.artifact.resolver.ArtifactResolver;
45  import org.apache.maven.artifact.resolver.filter.ExcludesArtifactFilter;
46  import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException;
47  import org.apache.maven.artifact.versioning.VersionRange;
48  import org.apache.maven.model.Dependency;
49  import org.apache.maven.model.Exclusion;
50  import org.apache.maven.model.Plugin;
51  import org.apache.maven.model.Repository;
52  import org.apache.maven.model.RepositoryPolicy;
53  import org.apache.maven.repository.DelegatingLocalArtifactRepository;
54  import org.apache.maven.repository.LocalArtifactRepository;
55  import org.apache.maven.repository.ArtifactTransferListener;
56  import org.apache.maven.repository.MirrorSelector;
57  import org.apache.maven.repository.Proxy;
58  import org.apache.maven.repository.RepositorySystem;
59  import org.apache.maven.repository.ArtifactDoesNotExistException;
60  import org.apache.maven.repository.ArtifactTransferFailedException;
61  import org.apache.maven.settings.Mirror;
62  import org.apache.maven.settings.Server;
63  import org.apache.maven.settings.building.SettingsProblem;
64  import org.apache.maven.settings.crypto.DefaultSettingsDecryptionRequest;
65  import org.apache.maven.settings.crypto.SettingsDecrypter;
66  import org.apache.maven.settings.crypto.SettingsDecryptionRequest;
67  import org.apache.maven.settings.crypto.SettingsDecryptionResult;
68  import org.apache.maven.wagon.proxy.ProxyInfo;
69  import org.apache.maven.wagon.proxy.ProxyUtils;
70  import org.codehaus.plexus.PlexusContainer;
71  import org.codehaus.plexus.component.annotations.Component;
72  import org.codehaus.plexus.component.annotations.Requirement;
73  import org.codehaus.plexus.component.repository.exception.ComponentLookupException;
74  import org.codehaus.plexus.logging.Logger;
75  import org.codehaus.plexus.util.StringUtils;
76  import org.sonatype.aether.RepositorySystemSession;
77  import org.sonatype.aether.repository.AuthenticationSelector;
78  import org.sonatype.aether.repository.ProxySelector;
79  import org.sonatype.aether.repository.RemoteRepository;
80  
81  /**
82   * @author Jason van Zyl
83   */
84  @Component( role = RepositorySystem.class, hint = "default" )
85  public class LegacyRepositorySystem
86      implements RepositorySystem
87  {
88  
89      @Requirement
90      private Logger logger;
91  
92      @Requirement
93      private ArtifactFactory artifactFactory;
94  
95      @Requirement
96      private ArtifactResolver artifactResolver;
97  
98      @Requirement
99      private ArtifactRepositoryFactory artifactRepositoryFactory;
100 
101     @Requirement( role = ArtifactRepositoryLayout.class )
102     private Map<String, ArtifactRepositoryLayout> layouts;
103 
104     @Requirement
105     private WagonManager wagonManager;
106 
107     @Requirement
108     private PlexusContainer plexus;
109 
110     @Requirement
111     private MirrorSelector mirrorSelector;
112 
113     @Requirement
114     private SettingsDecrypter settingsDecrypter;
115 
116     public Artifact createArtifact( String groupId, String artifactId, String version, String scope, String type )
117     {
118         return artifactFactory.createArtifact( groupId, artifactId, version, scope, type );
119     }
120 
121     public Artifact createArtifact( String groupId, String artifactId, String version, String packaging )
122     {
123         return artifactFactory.createBuildArtifact( groupId, artifactId, version, packaging );
124     }
125 
126     public Artifact createArtifactWithClassifier( String groupId, String artifactId, String version, String type,
127                                                   String classifier )
128     {
129         return artifactFactory.createArtifactWithClassifier( groupId, artifactId, version, type, classifier );
130     }
131 
132     public Artifact createProjectArtifact( String groupId, String artifactId, String metaVersionId )
133     {
134         return artifactFactory.createProjectArtifact( groupId, artifactId, metaVersionId );
135     }
136 
137     public Artifact createDependencyArtifact( Dependency d )
138     {
139         VersionRange versionRange;
140         try
141         {
142             versionRange = VersionRange.createFromVersionSpec( d.getVersion() );
143         }
144         catch ( InvalidVersionSpecificationException e )
145         {
146             return null;
147         }
148 
149         Artifact artifact =
150             artifactFactory.createDependencyArtifact( d.getGroupId(), d.getArtifactId(), versionRange, d.getType(),
151                                                       d.getClassifier(), d.getScope(), d.isOptional() );
152 
153         if ( Artifact.SCOPE_SYSTEM.equals( d.getScope() ) && d.getSystemPath() != null )
154         {
155             artifact.setFile( new File( d.getSystemPath() ) );
156         }
157 
158         if ( !d.getExclusions().isEmpty() )
159         {
160             List<String> exclusions = new ArrayList<String>();
161 
162             for ( Exclusion exclusion : d.getExclusions() )
163             {
164                 exclusions.add( exclusion.getGroupId() + ':' + exclusion.getArtifactId() );
165             }
166 
167             artifact.setDependencyFilter( new ExcludesArtifactFilter( exclusions ) );
168         }
169 
170         return artifact;
171     }
172 
173     public Artifact createExtensionArtifact( String groupId, String artifactId, String version )
174     {
175         VersionRange versionRange;
176         try
177         {
178             versionRange = VersionRange.createFromVersionSpec( version );
179         }
180         catch ( InvalidVersionSpecificationException e )
181         {
182             return null;
183         }
184 
185         return artifactFactory.createExtensionArtifact( groupId, artifactId, versionRange );
186     }
187 
188     public Artifact createParentArtifact( String groupId, String artifactId, String version )
189     {
190         return artifactFactory.createParentArtifact( groupId, artifactId, version );
191     }
192 
193     public Artifact createPluginArtifact( Plugin plugin )
194     {
195         VersionRange versionRange;
196         try
197         {
198             String version = plugin.getVersion();
199             if ( StringUtils.isEmpty( version ) )
200             {
201                 version = "RELEASE";
202             }
203             versionRange = VersionRange.createFromVersionSpec( version );
204         }
205         catch ( InvalidVersionSpecificationException e )
206         {
207             return null;
208         }
209 
210         return artifactFactory.createPluginArtifact( plugin.getGroupId(), plugin.getArtifactId(), versionRange );
211     }
212 
213     public ArtifactRepositoryPolicy buildArtifactRepositoryPolicy( RepositoryPolicy policy )
214     {
215         boolean enabled = true;
216 
217         String updatePolicy = null;
218 
219         String checksumPolicy = null;
220 
221         if ( policy != null )
222         {
223             enabled = policy.isEnabled();
224 
225             if ( policy.getUpdatePolicy() != null )
226             {
227                 updatePolicy = policy.getUpdatePolicy();
228             }
229             if ( policy.getChecksumPolicy() != null )
230             {
231                 checksumPolicy = policy.getChecksumPolicy();
232             }
233         }
234 
235         return new ArtifactRepositoryPolicy( enabled, updatePolicy, checksumPolicy );
236     }
237 
238     public ArtifactRepository createDefaultLocalRepository()
239         throws InvalidRepositoryException
240     {
241         return createLocalRepository( RepositorySystem.defaultUserLocalRepository );
242     }
243 
244     public ArtifactRepository createLocalRepository( File localRepository )
245         throws InvalidRepositoryException
246     {
247         return createRepository( "file://" + localRepository.toURI().getRawPath(),
248                                  RepositorySystem.DEFAULT_LOCAL_REPO_ID, true,
249                                  ArtifactRepositoryPolicy.UPDATE_POLICY_ALWAYS, true,
250                                  ArtifactRepositoryPolicy.UPDATE_POLICY_ALWAYS,
251                                  ArtifactRepositoryPolicy.CHECKSUM_POLICY_IGNORE );
252     }
253 
254     public ArtifactRepository createDefaultRemoteRepository()
255         throws InvalidRepositoryException
256     {
257         return createRepository( RepositorySystem.DEFAULT_REMOTE_REPO_URL, RepositorySystem.DEFAULT_REMOTE_REPO_ID,
258                                  true, ArtifactRepositoryPolicy.UPDATE_POLICY_DAILY, false,
259                                  ArtifactRepositoryPolicy.UPDATE_POLICY_DAILY,
260                                  ArtifactRepositoryPolicy.CHECKSUM_POLICY_WARN );
261     }
262 
263     public ArtifactRepository createLocalRepository( String url, String repositoryId )
264         throws IOException
265     {
266         return createRepository( canonicalFileUrl( url ), repositoryId, true,
267                                  ArtifactRepositoryPolicy.UPDATE_POLICY_ALWAYS, true,
268                                  ArtifactRepositoryPolicy.UPDATE_POLICY_ALWAYS,
269                                  ArtifactRepositoryPolicy.CHECKSUM_POLICY_IGNORE );
270     }
271 
272     private String canonicalFileUrl( String url )
273         throws IOException
274     {
275         if ( !url.startsWith( "file:" ) )
276         {
277             url = "file://" + url;
278         }
279         else if ( url.startsWith( "file:" ) && !url.startsWith( "file://" ) )
280         {
281             url = "file://" + url.substring( "file:".length() );
282         }
283 
284         // So now we have an url of the form file://<path>
285 
286         // We want to eliminate any relative path nonsense and lock down the path so we
287         // need to fully resolve it before any sub-modules use the path. This can happen
288         // when you are using a custom settings.xml that contains a relative path entry
289         // for the local repository setting.
290 
291         File localRepository = new File( url.substring( "file://".length() ) );
292 
293         if ( !localRepository.isAbsolute() )
294         {
295             url = "file://" + localRepository.getCanonicalPath();
296         }
297 
298         return url;
299     }
300 
301     public ArtifactResolutionResult resolve( ArtifactResolutionRequest request )
302     {
303         /*
304          * Probably is not worth it, but here I make sure I restore request
305          * to its original state.
306          */
307         try
308         {
309             LocalArtifactRepository ideWorkspace =
310                 plexus.lookup( LocalArtifactRepository.class, LocalArtifactRepository.IDE_WORKSPACE );
311 
312             if ( request.getLocalRepository() instanceof DelegatingLocalArtifactRepository )
313             {
314                 DelegatingLocalArtifactRepository delegatingLocalRepository =
315                     (DelegatingLocalArtifactRepository) request.getLocalRepository();
316 
317                 LocalArtifactRepository orig = delegatingLocalRepository.getIdeWorspace();
318 
319                 delegatingLocalRepository.setIdeWorkspace( ideWorkspace );
320 
321                 try
322                 {
323                     return artifactResolver.resolve( request );
324                 }
325                 finally
326                 {
327                     delegatingLocalRepository.setIdeWorkspace( orig );
328                 }
329             }
330             else
331             {
332                 ArtifactRepository localRepository = request.getLocalRepository();
333                 DelegatingLocalArtifactRepository delegatingLocalRepository =
334                     new DelegatingLocalArtifactRepository( localRepository );
335                 delegatingLocalRepository.setIdeWorkspace( ideWorkspace );
336                 request.setLocalRepository( delegatingLocalRepository );
337                 try
338                 {
339                     return artifactResolver.resolve( request );
340                 }
341                 finally
342                 {
343                     request.setLocalRepository( localRepository );
344                 }
345             }
346         }
347         catch ( ComponentLookupException e )
348         {
349             // no ide workspace artifact resolution
350         }
351 
352         return artifactResolver.resolve( request );
353     }
354 
355     /*
356     public void addProxy( String protocol, String host, int port, String username, String password, String nonProxyHosts )
357     {
358         ProxyInfo proxyInfo = new ProxyInfo();
359         proxyInfo.setHost( host );
360         proxyInfo.setType( protocol );
361         proxyInfo.setPort( port );
362         proxyInfo.setNonProxyHosts( nonProxyHosts );
363         proxyInfo.setUserName( username );
364         proxyInfo.setPassword( password );
365 
366         proxies.put( protocol, proxyInfo );
367 
368         wagonManager.addProxy( protocol, host, port, username, password, nonProxyHosts );
369     }
370     */
371 
372     public List<ArtifactRepository> getEffectiveRepositories( List<ArtifactRepository> repositories )
373     {
374         if ( repositories == null )
375         {
376             return null;
377         }
378 
379         Map<String, List<ArtifactRepository>> reposByKey = new LinkedHashMap<String, List<ArtifactRepository>>();
380 
381         for ( ArtifactRepository repository : repositories )
382         {
383             String key = repository.getId();
384 
385             List<ArtifactRepository> aliasedRepos = reposByKey.get( key );
386 
387             if ( aliasedRepos == null )
388             {
389                 aliasedRepos = new ArrayList<ArtifactRepository>();
390                 reposByKey.put( key, aliasedRepos );
391             }
392 
393             aliasedRepos.add( repository );
394         }
395 
396         List<ArtifactRepository> effectiveRepositories = new ArrayList<ArtifactRepository>();
397 
398         for ( List<ArtifactRepository> aliasedRepos : reposByKey.values() )
399         {
400             List<ArtifactRepository> mirroredRepos = new ArrayList<ArtifactRepository>();
401 
402             List<ArtifactRepositoryPolicy> releasePolicies =
403                 new ArrayList<ArtifactRepositoryPolicy>( aliasedRepos.size() );
404 
405             for ( ArtifactRepository aliasedRepo : aliasedRepos )
406             {
407                 releasePolicies.add( aliasedRepo.getReleases() );
408                 mirroredRepos.addAll( aliasedRepo.getMirroredRepositories() );
409             }
410 
411             ArtifactRepositoryPolicy releasePolicy = getEffectivePolicy( releasePolicies );
412 
413             List<ArtifactRepositoryPolicy> snapshotPolicies =
414                 new ArrayList<ArtifactRepositoryPolicy>( aliasedRepos.size() );
415 
416             for ( ArtifactRepository aliasedRepo : aliasedRepos )
417             {
418                 snapshotPolicies.add( aliasedRepo.getSnapshots() );
419             }
420 
421             ArtifactRepositoryPolicy snapshotPolicy = getEffectivePolicy( snapshotPolicies );
422 
423             ArtifactRepository aliasedRepo = aliasedRepos.get( 0 );
424 
425             ArtifactRepository effectiveRepository =
426                 createArtifactRepository( aliasedRepo.getId(), aliasedRepo.getUrl(), aliasedRepo.getLayout(),
427                                           snapshotPolicy, releasePolicy );
428 
429             effectiveRepository.setAuthentication( aliasedRepo.getAuthentication() );
430 
431             effectiveRepository.setProxy( aliasedRepo.getProxy() );
432 
433             effectiveRepository.setMirroredRepositories( mirroredRepos );
434 
435             effectiveRepositories.add( effectiveRepository );
436         }
437 
438         return effectiveRepositories;
439     }
440 
441     private ArtifactRepositoryPolicy getEffectivePolicy( Collection<ArtifactRepositoryPolicy> policies )
442     {
443         ArtifactRepositoryPolicy effectivePolicy = null;
444 
445         for ( ArtifactRepositoryPolicy policy : policies )
446         {
447             if ( effectivePolicy == null )
448             {
449                 effectivePolicy = new ArtifactRepositoryPolicy( policy );
450             }
451             else
452             {
453                 effectivePolicy.merge( policy );
454             }
455         }
456 
457         return effectivePolicy;
458     }
459 
460     public Mirror getMirror( ArtifactRepository repository, List<Mirror> mirrors )
461     {
462         return mirrorSelector.getMirror( repository, mirrors );
463     }
464 
465     public void injectMirror( List<ArtifactRepository> repositories, List<Mirror> mirrors )
466     {
467         if ( repositories != null && mirrors != null )
468         {
469             for ( ArtifactRepository repository : repositories )
470             {
471                 Mirror mirror = getMirror( repository, mirrors );
472                 injectMirror( repository, mirror );
473             }
474         }
475     }
476 
477     private Mirror getMirror( RepositorySystemSession session, ArtifactRepository repository )
478     {
479         if ( session != null )
480         {
481             org.sonatype.aether.repository.MirrorSelector selector = session.getMirrorSelector();
482             if ( selector != null )
483             {
484                 RemoteRepository repo = selector.getMirror( RepositoryUtils.toRepo( repository ) );
485                 if ( repo != null )
486                 {
487                     Mirror mirror = new Mirror();
488                     mirror.setId( repo.getId() );
489                     mirror.setUrl( repo.getUrl() );
490                     mirror.setLayout( repo.getContentType() );
491                     return mirror;
492                 }
493             }
494         }
495         return null;
496     }
497 
498     public void injectMirror( RepositorySystemSession session, List<ArtifactRepository> repositories )
499     {
500         if ( repositories != null && session != null )
501         {
502             for ( ArtifactRepository repository : repositories )
503             {
504                 Mirror mirror = getMirror( session, repository );
505                 injectMirror( repository, mirror );
506             }
507         }
508     }
509 
510     private void injectMirror( ArtifactRepository repository, Mirror mirror )
511     {
512         if ( mirror != null )
513         {
514             ArtifactRepository original =
515                 createArtifactRepository( repository.getId(), repository.getUrl(), repository.getLayout(),
516                                           repository.getSnapshots(), repository.getReleases() );
517 
518             repository.setMirroredRepositories( Collections.singletonList( original ) );
519 
520             repository.setId( mirror.getId() );
521             repository.setUrl( mirror.getUrl() );
522 
523             if ( StringUtils.isNotEmpty( mirror.getLayout() ) )
524             {
525                 repository.setLayout( getLayout( mirror.getLayout() ) );
526             }
527         }
528     }
529 
530     public void injectAuthentication( List<ArtifactRepository> repositories, List<Server> servers )
531     {
532         if ( repositories != null )
533         {
534             Map<String, Server> serversById = new HashMap<String, Server>();
535 
536             if ( servers != null )
537             {
538                 for ( Server server : servers )
539                 {
540                     if ( !serversById.containsKey( server.getId() ) )
541                     {
542                         serversById.put( server.getId(), server );
543                     }
544                 }
545             }
546 
547             for ( ArtifactRepository repository : repositories )
548             {
549                 Server server = serversById.get( repository.getId() );
550 
551                 if ( server != null )
552                 {
553                     SettingsDecryptionRequest request = new DefaultSettingsDecryptionRequest( server );
554                     SettingsDecryptionResult result = settingsDecrypter.decrypt( request );
555                     server = result.getServer();
556 
557                     if ( logger.isDebugEnabled() )
558                     {
559                         for ( SettingsProblem problem : result.getProblems() )
560                         {
561                             logger.debug( problem.getMessage(), problem.getException() );
562                         }
563                     }
564 
565                     Authentication authentication = new Authentication( server.getUsername(), server.getPassword() );
566                     authentication.setPrivateKey( server.getPrivateKey() );
567                     authentication.setPassphrase( server.getPassphrase() );
568 
569                     repository.setAuthentication( authentication );
570                 }
571                 else
572                 {
573                     repository.setAuthentication( null );
574                 }
575             }
576         }
577     }
578 
579     private Authentication getAuthentication( RepositorySystemSession session, ArtifactRepository repository )
580     {
581         if ( session != null )
582         {
583             AuthenticationSelector selector = session.getAuthenticationSelector();
584             if ( selector != null )
585             {
586                 org.sonatype.aether.repository.Authentication auth =
587                     selector.getAuthentication( RepositoryUtils.toRepo( repository ) );
588                 if ( auth != null )
589                 {
590                     Authentication result = new Authentication( auth.getUsername(), auth.getPassword() );
591                     result.setPrivateKey( auth.getPrivateKeyFile() );
592                     result.setPassphrase( auth.getPassphrase() );
593                     return result;
594                 }
595             }
596         }
597         return null;
598     }
599 
600     public void injectAuthentication( RepositorySystemSession session, List<ArtifactRepository> repositories )
601     {
602         if ( repositories != null && session != null )
603         {
604             for ( ArtifactRepository repository : repositories )
605             {
606                 repository.setAuthentication( getAuthentication( session, repository ) );
607             }
608         }
609     }
610 
611     private org.apache.maven.settings.Proxy getProxy( ArtifactRepository repository,
612                                                       List<org.apache.maven.settings.Proxy> proxies )
613     {
614         if ( proxies != null && repository.getProtocol() != null )
615         {
616             for ( org.apache.maven.settings.Proxy proxy : proxies )
617             {
618                 if ( proxy.isActive() && repository.getProtocol().equalsIgnoreCase( proxy.getProtocol() ) )
619                 {
620                     if ( StringUtils.isNotEmpty( proxy.getNonProxyHosts() ) )
621                     {
622                         ProxyInfo pi = new ProxyInfo();
623                         pi.setNonProxyHosts( proxy.getNonProxyHosts() );
624 
625                         org.apache.maven.wagon.repository.Repository repo =
626                             new org.apache.maven.wagon.repository.Repository( repository.getId(), repository.getUrl() );
627 
628                         if ( !ProxyUtils.validateNonProxyHosts( pi, repo.getHost() ) )
629                         {
630                             return proxy;
631                         }
632                     }
633                     else
634                     {
635                         return proxy;
636                     }
637                 }
638             }
639         }
640 
641         return null;
642     }
643 
644     public void injectProxy( List<ArtifactRepository> repositories, List<org.apache.maven.settings.Proxy> proxies )
645     {
646         if ( repositories != null )
647         {
648             for ( ArtifactRepository repository : repositories )
649             {
650                 org.apache.maven.settings.Proxy proxy = getProxy( repository, proxies );
651 
652                 if ( proxy != null )
653                 {
654                     SettingsDecryptionRequest request = new DefaultSettingsDecryptionRequest( proxy );
655                     SettingsDecryptionResult result = settingsDecrypter.decrypt( request );
656                     proxy = result.getProxy();
657 
658                     if ( logger.isDebugEnabled() )
659                     {
660                         for ( SettingsProblem problem : result.getProblems() )
661                         {
662                             logger.debug( problem.getMessage(), problem.getException() );
663                         }
664                     }
665 
666                     Proxy p = new Proxy();
667                     p.setHost( proxy.getHost() );
668                     p.setProtocol( proxy.getProtocol() );
669                     p.setPort( proxy.getPort() );
670                     p.setNonProxyHosts( proxy.getNonProxyHosts() );
671                     p.setUserName( proxy.getUsername() );
672                     p.setPassword( proxy.getPassword() );
673 
674                     repository.setProxy( p );
675                 }
676                 else
677                 {
678                     repository.setProxy( null );
679                 }
680             }
681         }
682     }
683 
684     private Proxy getProxy( RepositorySystemSession session, ArtifactRepository repository )
685     {
686         if ( session != null )
687         {
688             ProxySelector selector = session.getProxySelector();
689             if ( selector != null )
690             {
691                 org.sonatype.aether.repository.Proxy proxy = selector.getProxy( RepositoryUtils.toRepo( repository ) );
692                 if ( proxy != null )
693                 {
694                     Proxy p = new Proxy();
695                     p.setHost( proxy.getHost() );
696                     p.setProtocol( proxy.getType() );
697                     p.setPort( proxy.getPort() );
698                     if ( proxy.getAuthentication() != null )
699                     {
700                         p.setUserName( proxy.getAuthentication().getUsername() );
701                         p.setPassword( proxy.getAuthentication().getPassword() );
702                     }
703                     return p;
704                 }
705             }
706         }
707         return null;
708     }
709 
710     public void injectProxy( RepositorySystemSession session, List<ArtifactRepository> repositories )
711     {
712         if ( repositories != null && session != null )
713         {
714             for ( ArtifactRepository repository : repositories )
715             {
716                 repository.setProxy( getProxy( session, repository ) );
717             }
718         }
719     }
720 
721     public void retrieve( ArtifactRepository repository, File destination, String remotePath,
722                           ArtifactTransferListener transferListener )
723         throws ArtifactTransferFailedException, ArtifactDoesNotExistException
724     {
725         try
726         {
727             wagonManager.getRemoteFile( repository, destination, remotePath,
728                                         TransferListenerAdapter.newAdapter( transferListener ),
729                                         ArtifactRepositoryPolicy.CHECKSUM_POLICY_WARN, true );
730         }
731         catch ( org.apache.maven.wagon.TransferFailedException e )
732         {
733             throw new ArtifactTransferFailedException( getMessage( e, "Error transferring artifact." ), e );
734         }
735         catch ( org.apache.maven.wagon.ResourceDoesNotExistException e )
736         {
737             throw new ArtifactDoesNotExistException( getMessage( e, "Requested artifact does not exist." ), e );
738         }
739     }
740 
741     public void publish( ArtifactRepository repository, File source, String remotePath,
742                          ArtifactTransferListener transferListener )
743         throws ArtifactTransferFailedException
744     {
745         try
746         {
747             wagonManager.putRemoteFile( repository, source, remotePath,
748                                         TransferListenerAdapter.newAdapter( transferListener ) );
749         }
750         catch ( org.apache.maven.wagon.TransferFailedException e )
751         {
752             throw new ArtifactTransferFailedException( getMessage( e, "Error transferring artifact." ), e );
753         }
754     }
755 
756     //
757     // Artifact Repository Creation
758     //
759     public ArtifactRepository buildArtifactRepository( Repository repo )
760         throws InvalidRepositoryException
761     {
762         if ( repo != null )
763         {
764             String id = repo.getId();
765 
766             if ( StringUtils.isEmpty( id ) )
767             {
768                 throw new InvalidRepositoryException( "Repository identifier missing", "" );
769             }
770 
771             String url = repo.getUrl();
772 
773             if ( StringUtils.isEmpty( url ) )
774             {
775                 throw new InvalidRepositoryException( "URL missing for repository " + id, id );
776             }
777 
778             ArtifactRepositoryPolicy snapshots = buildArtifactRepositoryPolicy( repo.getSnapshots() );
779 
780             ArtifactRepositoryPolicy releases = buildArtifactRepositoryPolicy( repo.getReleases() );
781 
782             return createArtifactRepository( id, url, getLayout( repo.getLayout() ), snapshots, releases );
783         }
784         else
785         {
786             return null;
787         }
788     }
789 
790     private ArtifactRepository createRepository( String url, String repositoryId, boolean releases,
791                                                  String releaseUpdates, boolean snapshots, String snapshotUpdates,
792                                                  String checksumPolicy )
793     {
794         ArtifactRepositoryPolicy snapshotsPolicy =
795             new ArtifactRepositoryPolicy( snapshots, snapshotUpdates, checksumPolicy );
796 
797         ArtifactRepositoryPolicy releasesPolicy =
798             new ArtifactRepositoryPolicy( releases, releaseUpdates, checksumPolicy );
799 
800         return createArtifactRepository( repositoryId, url, null, snapshotsPolicy, releasesPolicy );
801     }
802 
803     public ArtifactRepository createArtifactRepository( String repositoryId, String url,
804                                                         ArtifactRepositoryLayout repositoryLayout,
805                                                         ArtifactRepositoryPolicy snapshots,
806                                                         ArtifactRepositoryPolicy releases )
807     {
808         if ( repositoryLayout == null )
809         {
810             repositoryLayout = layouts.get( "default" );
811         }
812 
813         ArtifactRepository artifactRepository =
814             artifactRepositoryFactory.createArtifactRepository( repositoryId, url, repositoryLayout, snapshots,
815                                                                 releases );
816 
817         return artifactRepository;
818     }
819 
820     private static String getMessage( Throwable error, String def )
821     {
822         if ( error == null )
823         {
824             return def;
825         }
826         String msg = error.getMessage();
827         if ( StringUtils.isNotEmpty( msg ) )
828         {
829             return msg;
830         }
831         return getMessage( error.getCause(), def );
832     }
833 
834     private ArtifactRepositoryLayout getLayout( String id )
835     {
836         ArtifactRepositoryLayout layout = layouts.get( id );
837 
838         if ( layout == null )
839         {
840             layout = new UnknownRepositoryLayout( id, layouts.get( "default" ) );
841         }
842 
843         return layout;
844     }
845 
846     /**
847      * In the future, the legacy system might encounter repository types for which no layout components exists because
848      * the actual communication with the repository happens via a repository connector. As a minimum, the legacy system
849      * needs to retain the id of this layout so that the content type of the remote repository can still be accurately
850      * described.
851      */
852     static class UnknownRepositoryLayout
853         implements ArtifactRepositoryLayout
854     {
855 
856         private final String id;
857 
858         private final ArtifactRepositoryLayout fallback;
859 
860         public UnknownRepositoryLayout( String id, ArtifactRepositoryLayout fallback )
861         {
862             this.id = id;
863             this.fallback = fallback;
864         }
865 
866         public String getId()
867         {
868             return id;
869         }
870 
871         public String pathOf( Artifact artifact )
872         {
873             return fallback.pathOf( artifact );
874         }
875 
876         public String pathOfLocalRepositoryMetadata( ArtifactMetadata metadata, ArtifactRepository repository )
877         {
878             return fallback.pathOfLocalRepositoryMetadata( metadata, repository );
879         }
880 
881         public String pathOfRemoteRepositoryMetadata( ArtifactMetadata metadata )
882         {
883             return fallback.pathOfRemoteRepositoryMetadata( metadata );
884         }
885 
886         @Override
887         public String toString()
888         {
889             return getId();
890         }
891 
892     }
893 
894 }