1 package org.apache.maven.resolver.internal.ant;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import java.io.BufferedReader;
23 import java.io.File;
24 import java.io.FileInputStream;
25 import java.io.IOException;
26 import java.io.InputStreamReader;
27 import java.util.ArrayList;
28 import java.util.Collection;
29 import java.util.Collections;
30 import java.util.HashMap;
31 import java.util.HashSet;
32 import java.util.LinkedHashMap;
33 import java.util.List;
34 import java.util.Locale;
35 import java.util.Map;
36 import java.util.Properties;
37 import java.util.concurrent.CopyOnWriteArrayList;
38
39 import org.apache.maven.model.Model;
40 import org.apache.maven.model.building.DefaultModelBuilderFactory;
41 import org.apache.maven.model.building.DefaultModelBuildingRequest;
42 import org.apache.maven.model.building.FileModelSource;
43 import org.apache.maven.model.building.ModelBuilder;
44 import org.apache.maven.model.building.ModelBuildingException;
45 import org.apache.maven.model.building.ModelBuildingRequest;
46 import org.apache.maven.model.resolution.ModelResolver;
47 import org.apache.maven.repository.internal.MavenRepositorySystemUtils;
48 import org.apache.maven.resolver.internal.ant.types.Artifact;
49 import org.apache.maven.resolver.internal.ant.types.Artifacts;
50 import org.apache.maven.resolver.internal.ant.types.Authentication;
51 import org.apache.maven.resolver.internal.ant.types.Dependencies;
52 import org.apache.maven.resolver.internal.ant.types.Dependency;
53 import org.apache.maven.resolver.internal.ant.types.DependencyContainer;
54 import org.apache.maven.resolver.internal.ant.types.Exclusion;
55 import org.apache.maven.resolver.internal.ant.types.LocalRepository;
56 import org.apache.maven.resolver.internal.ant.types.Mirror;
57 import org.apache.maven.resolver.internal.ant.types.Pom;
58 import org.apache.maven.resolver.internal.ant.types.Proxy;
59 import org.apache.maven.resolver.internal.ant.types.RemoteRepositories;
60 import org.apache.maven.resolver.internal.ant.types.RemoteRepository;
61 import org.apache.maven.settings.Server;
62 import org.apache.maven.settings.Settings;
63 import org.apache.maven.settings.building.DefaultSettingsBuilderFactory;
64 import org.apache.maven.settings.building.DefaultSettingsBuildingRequest;
65 import org.apache.maven.settings.building.SettingsBuilder;
66 import org.apache.maven.settings.building.SettingsBuildingException;
67 import org.apache.maven.settings.crypto.DefaultSettingsDecryptionRequest;
68 import org.apache.maven.settings.crypto.SettingsDecrypter;
69 import org.apache.maven.settings.crypto.SettingsDecryptionResult;
70 import org.apache.tools.ant.BuildException;
71 import org.apache.tools.ant.Project;
72 import org.apache.tools.ant.Task;
73 import org.apache.tools.ant.taskdefs.condition.Os;
74 import org.apache.tools.ant.types.Reference;
75 import org.codehaus.plexus.util.xml.Xpp3Dom;
76 import org.eclipse.aether.ConfigurationProperties;
77 import org.eclipse.aether.DefaultRepositoryCache;
78 import org.eclipse.aether.DefaultRepositorySystemSession;
79 import org.eclipse.aether.RepositorySystem;
80 import org.eclipse.aether.RepositorySystemSession;
81 import org.eclipse.aether.artifact.DefaultArtifact;
82 import org.eclipse.aether.collection.CollectRequest;
83 import org.eclipse.aether.collection.CollectResult;
84 import org.eclipse.aether.collection.DependencyCollectionException;
85 import org.eclipse.aether.connector.basic.BasicRepositoryConnectorFactory;
86 import org.eclipse.aether.deployment.DeployRequest;
87 import org.eclipse.aether.deployment.DeploymentException;
88 import org.eclipse.aether.impl.DefaultServiceLocator;
89 import org.eclipse.aether.impl.RemoteRepositoryManager;
90 import org.eclipse.aether.installation.InstallRequest;
91 import org.eclipse.aether.installation.InstallationException;
92 import org.eclipse.aether.repository.AuthenticationSelector;
93 import org.eclipse.aether.repository.LocalRepositoryManager;
94 import org.eclipse.aether.repository.MirrorSelector;
95 import org.eclipse.aether.repository.ProxySelector;
96 import org.eclipse.aether.spi.connector.RepositoryConnectorFactory;
97 import org.eclipse.aether.spi.connector.transport.TransporterFactory;
98 import org.eclipse.aether.spi.log.Logger;
99 import org.eclipse.aether.transport.classpath.ClasspathTransporterFactory;
100 import org.eclipse.aether.transport.file.FileTransporterFactory;
101 import org.eclipse.aether.transport.http.HttpTransporterFactory;
102 import org.eclipse.aether.util.repository.AuthenticationBuilder;
103 import org.eclipse.aether.util.repository.ConservativeAuthenticationSelector;
104 import org.eclipse.aether.util.repository.DefaultAuthenticationSelector;
105 import org.eclipse.aether.util.repository.DefaultMirrorSelector;
106 import org.eclipse.aether.util.repository.DefaultProxySelector;
107
108
109
110 public class AntRepoSys
111 {
112
113 private static final boolean OS_WINDOWS = Os.isFamily( "windows" );
114
115 private static final ModelBuilder MODEL_BUILDER = new DefaultModelBuilderFactory().newInstance();
116
117 private static final SettingsBuilder SETTINGS_BUILDER = new DefaultSettingsBuilderFactory().newInstance();
118
119 private static final SettingsDecrypter SETTINGS_DECRYPTER = new AntSettingsDecryptorFactory().newInstance();
120
121 private final Project project;
122
123 private final DefaultServiceLocator locator;
124
125 private RepositorySystem repoSys;
126
127 private RemoteRepositoryManager remoteRepoMan;
128
129 private File userSettings;
130
131 private File globalSettings;
132
133 private Settings settings;
134
135 private final List<Mirror> mirrors = new CopyOnWriteArrayList<Mirror>();
136
137 private final List<Proxy> proxies = new CopyOnWriteArrayList<Proxy>();
138
139 private final List<Authentication> authentications = new CopyOnWriteArrayList<Authentication>();
140
141 private LocalRepository localRepository;
142
143 private Pom defaultPom;
144
145 private static <T> boolean eq( T o1, T o2 )
146 {
147 return ( o1 == null ) ? o2 == null : o1.equals( o2 );
148 }
149
150 public static synchronized AntRepoSys getInstance( Project project )
151 {
152 Object obj = project.getReference( Names.ID );
153 if ( obj instanceof AntRepoSys )
154 {
155 return (AntRepoSys) obj;
156 }
157 AntRepoSys instance = new AntRepoSys( project );
158 project.addReference( Names.ID, instance );
159 instance.initDefaults();
160 return instance;
161 }
162
163 private AntRepoSys( Project project )
164 {
165 this.project = project;
166
167 locator = MavenRepositorySystemUtils.newServiceLocator();
168 locator.setErrorHandler( new AntServiceLocatorErrorHandler( project ) );
169 locator.setServices( Logger.class, new AntLogger( project ) );
170 locator.setServices( ModelBuilder.class, MODEL_BUILDER );
171 locator.addService( RepositoryConnectorFactory.class, BasicRepositoryConnectorFactory.class );
172 locator.addService( TransporterFactory.class, FileTransporterFactory.class );
173 locator.addService( TransporterFactory.class, HttpTransporterFactory.class );
174 locator.addService( TransporterFactory.class, ClasspathTransporterFactory.class );
175 }
176
177 private void initDefaults()
178 {
179 RemoteRepository repo = new RemoteRepository();
180 repo.setProject( project );
181 repo.setId( "central" );
182 repo.setUrl( "https://repo1.maven.org/maven2/" );
183 project.addReference( Names.ID_CENTRAL, repo );
184
185 repo = new RemoteRepository();
186 repo.setProject( project );
187 repo.setRefid( new Reference( project, Names.ID_CENTRAL ) );
188 RemoteRepositories repos = new RemoteRepositories();
189 repos.setProject( project );
190 repos.addRemoterepo( repo );
191 project.addReference( Names.ID_DEFAULT_REPOS, repos );
192 }
193
194 public synchronized RepositorySystem getSystem()
195 {
196 if ( repoSys == null )
197 {
198 repoSys = locator.getService( RepositorySystem.class );
199 if ( repoSys == null )
200 {
201 throw new BuildException( "The repository system could not be initialized" );
202 }
203 }
204 return repoSys;
205 }
206
207 private synchronized RemoteRepositoryManager getRemoteRepoMan()
208 {
209 if ( remoteRepoMan == null )
210 {
211 remoteRepoMan = locator.getService( RemoteRepositoryManager.class );
212 if ( remoteRepoMan == null )
213 {
214 throw new BuildException( "The repository system could not be initialized" );
215 }
216 }
217 return remoteRepoMan;
218 }
219
220 public RepositorySystemSession getSession( Task task, LocalRepository localRepo )
221 {
222 DefaultRepositorySystemSession session = MavenRepositorySystemUtils.newSession();
223
224 Map<Object, Object> configProps = new LinkedHashMap<Object, Object>();
225 configProps.put( ConfigurationProperties.USER_AGENT, getUserAgent() );
226 configProps.putAll( (Map<?, ?>) project.getProperties() );
227 processServerConfiguration( configProps );
228 session.setConfigProperties( configProps );
229
230 session.setOffline( isOffline() );
231 session.setUserProperties( project.getUserProperties() );
232
233 session.setProxySelector( getProxySelector() );
234 session.setMirrorSelector( getMirrorSelector() );
235 session.setAuthenticationSelector( getAuthSelector() );
236
237 session.setCache( new DefaultRepositoryCache() );
238
239 session.setRepositoryListener( new AntRepositoryListener( task ) );
240 session.setTransferListener( new AntTransferListener( task ) );
241
242 session.setLocalRepositoryManager( getLocalRepoMan( session, localRepo ) );
243
244 session.setWorkspaceReader( ProjectWorkspaceReader.getInstance() );
245
246 return session;
247 }
248
249 private String getUserAgent()
250 {
251 StringBuilder buffer = new StringBuilder( 128 );
252
253 buffer.append( "Apache-Ant/" ).append( project.getProperty( "ant.version" ) );
254 buffer.append( " (" );
255 buffer.append( "Java " ).append( System.getProperty( "java.version" ) );
256 buffer.append( "; " );
257 buffer.append( System.getProperty( "os.name" ) ).append( " " ).append( System.getProperty( "os.version" ) );
258 buffer.append( ")" );
259 buffer.append( " Aether" );
260
261 return buffer.toString();
262 }
263
264 private boolean isOffline()
265 {
266 String prop = project.getProperty( Names.PROPERTY_OFFLINE );
267 if ( prop != null )
268 {
269 return Boolean.parseBoolean( prop );
270 }
271 return getSettings().isOffline();
272 }
273
274 private void processServerConfiguration( Map<Object, Object> configProps )
275 {
276 Settings settings = getSettings();
277 for ( Server server : settings.getServers() )
278 {
279 if ( server.getConfiguration() != null )
280 {
281 Xpp3Dom dom = (Xpp3Dom) server.getConfiguration();
282 for ( int i = dom.getChildCount() - 1; i >= 0; i-- )
283 {
284 Xpp3Dom child = dom.getChild( i );
285 if ( "wagonProvider".equals( child.getName() ) )
286 {
287 dom.removeChild( i );
288 }
289 else if ( "httpHeaders".equals( child.getName() ) )
290 {
291 configProps.put( ConfigurationProperties.HTTP_HEADERS + "." + server.getId(),
292 getHttpHeaders( child ) );
293 }
294 }
295
296 configProps.put( "aether.connector.wagon.config." + server.getId(), dom );
297 }
298
299 configProps.put( "aether.connector.perms.fileMode." + server.getId(), server.getFilePermissions() );
300 configProps.put( "aether.connector.perms.dirMode." + server.getId(), server.getDirectoryPermissions() );
301 }
302 }
303
304 private Map<String, String> getHttpHeaders( Xpp3Dom dom )
305 {
306 Map<String, String> headers = new HashMap<String, String>();
307 for ( int i = 0; i < dom.getChildCount(); i++ )
308 {
309 Xpp3Dom child = dom.getChild( i );
310 Xpp3Dom name = child.getChild( "name" );
311 Xpp3Dom value = child.getChild( "value" );
312 if ( name != null && name.getValue() != null )
313 {
314 headers.put( name.getValue(), ( value != null ) ? value.getValue() : null );
315 }
316 }
317 return Collections.unmodifiableMap( headers );
318 }
319
320 private File getDefaultLocalRepoDir()
321 {
322 String dir = project.getProperty( "maven.repo.local" );
323 if ( dir != null )
324 {
325 return project.resolveFile( dir );
326 }
327
328 Settings settings = getSettings();
329 if ( settings.getLocalRepository() != null )
330 {
331 return new File( settings.getLocalRepository() );
332 }
333
334 return new File( new File( project.getProperty( "user.home" ), ".m2" ), "repository" );
335 }
336
337 private LocalRepositoryManager getLocalRepoMan( RepositorySystemSession session, LocalRepository localRepo )
338 {
339 if ( localRepo == null )
340 {
341 localRepo = localRepository;
342 }
343
344 File repoDir;
345 if ( localRepo != null && localRepo.getDir() != null )
346 {
347 repoDir = localRepo.getDir();
348 }
349 else
350 {
351 repoDir = getDefaultLocalRepoDir();
352 }
353
354 org.eclipse.aether.repository.LocalRepository repo =
355 new org.eclipse.aether.repository.LocalRepository( repoDir );
356
357 return getSystem().newLocalRepositoryManager( session, repo );
358 }
359
360 private synchronized Settings getSettings()
361 {
362 if ( settings == null )
363 {
364 DefaultSettingsBuildingRequest request = new DefaultSettingsBuildingRequest();
365 request.setUserSettingsFile( getUserSettings() );
366 request.setGlobalSettingsFile( getGlobalSettings() );
367 request.setSystemProperties( getSystemProperties() );
368 request.setUserProperties( getUserProperties() );
369
370 try
371 {
372 settings = SETTINGS_BUILDER.build( request ).getEffectiveSettings();
373 }
374 catch ( SettingsBuildingException e )
375 {
376 project.log( "Could not process settings.xml: " + e.getMessage(), e, Project.MSG_WARN );
377 }
378
379 SettingsDecryptionResult result =
380 SETTINGS_DECRYPTER.decrypt( new DefaultSettingsDecryptionRequest( settings ) );
381 settings.setServers( result.getServers() );
382 settings.setProxies( result.getProxies() );
383 }
384 return settings;
385 }
386
387 private ProxySelector getProxySelector()
388 {
389 DefaultProxySelector selector = new DefaultProxySelector();
390
391 for ( Proxy proxy : proxies )
392 {
393 selector.add( ConverterUtils.toProxy( proxy ), proxy.getNonProxyHosts() );
394 }
395
396 Settings settings = getSettings();
397 for ( org.apache.maven.settings.Proxy proxy : settings.getProxies() )
398 {
399 AuthenticationBuilder auth = new AuthenticationBuilder();
400 auth.addUsername( proxy.getUsername() ).addPassword( proxy.getPassword() );
401 selector.add( new org.eclipse.aether.repository.Proxy( proxy.getProtocol(), proxy.getHost(),
402 proxy.getPort(), auth.build() ),
403 proxy.getNonProxyHosts() );
404 }
405
406 return selector;
407 }
408
409 private MirrorSelector getMirrorSelector()
410 {
411 DefaultMirrorSelector selector = new DefaultMirrorSelector();
412
413 for ( Mirror mirror : mirrors )
414 {
415 selector.add( mirror.getId(), mirror.getUrl(), mirror.getType(), false, mirror.getMirrorOf(), null );
416 }
417
418 Settings settings = getSettings();
419 for ( org.apache.maven.settings.Mirror mirror : settings.getMirrors() )
420 {
421 selector.add( String.valueOf( mirror.getId() ), mirror.getUrl(), mirror.getLayout(), false,
422 mirror.getMirrorOf(), mirror.getMirrorOfLayouts() );
423 }
424
425 return selector;
426 }
427
428 private AuthenticationSelector getAuthSelector()
429 {
430 DefaultAuthenticationSelector selector = new DefaultAuthenticationSelector();
431
432 Collection<String> ids = new HashSet<String>();
433 for ( Authentication auth : authentications )
434 {
435 List<String> servers = auth.getServers();
436 if ( !servers.isEmpty() )
437 {
438 org.eclipse.aether.repository.Authentication a = ConverterUtils.toAuthentication( auth );
439 for ( String server : servers )
440 {
441 if ( ids.add( server ) )
442 {
443 selector.add( server, a );
444 }
445 }
446 }
447 }
448
449 Settings settings = getSettings();
450 for ( Server server : settings.getServers() )
451 {
452 AuthenticationBuilder auth = new AuthenticationBuilder();
453 auth.addUsername( server.getUsername() ).addPassword( server.getPassword() );
454 auth.addPrivateKey( server.getPrivateKey(), server.getPassphrase() );
455 selector.add( server.getId(), auth.build() );
456 }
457
458 return new ConservativeAuthenticationSelector( selector );
459 }
460
461 public synchronized void setUserSettings( File file )
462 {
463 if ( !eq( this.userSettings, file ) )
464 {
465 settings = null;
466 }
467 this.userSettings = file;
468 }
469
470 File getUserSettings()
471 {
472 if ( userSettings == null )
473 {
474 userSettings = AetherUtils.findUserSettings( project );
475 }
476 return userSettings;
477 }
478
479 public void setGlobalSettings( File file )
480 {
481 if ( !eq( this.globalSettings, file ) )
482 {
483 settings = null;
484 }
485 this.globalSettings = file;
486 }
487
488 File getGlobalSettings()
489 {
490 if ( globalSettings == null )
491 {
492 globalSettings = AetherUtils.findGlobalSettings( project );
493 }
494 return globalSettings;
495 }
496
497 public void addProxy( Proxy proxy )
498 {
499 proxies.add( proxy );
500 }
501
502 public void addMirror( Mirror mirror )
503 {
504 mirrors.add( mirror );
505 }
506
507 public void addAuthentication( Authentication authentication )
508 {
509 authentications.add( authentication );
510 }
511
512 public void setLocalRepository( LocalRepository localRepository )
513 {
514 this.localRepository = localRepository;
515 }
516
517 public Model loadModel( Task task, File pomFile, boolean local, RemoteRepositories remoteRepositories )
518 {
519 RepositorySystemSession session = getSession( task, null );
520
521 remoteRepositories =
522 remoteRepositories == null ? AetherUtils.getDefaultRepositories( project ) : remoteRepositories;
523
524 List<org.eclipse.aether.repository.RemoteRepository> repositories =
525 ConverterUtils.toRepositories( task.getProject(), session, remoteRepositories, getRemoteRepoMan() );
526
527 ModelResolver modelResolver =
528 new AntModelResolver( session, "project", getSystem(), getRemoteRepoMan(), repositories );
529
530 Settings settings = getSettings();
531
532 try
533 {
534 DefaultModelBuildingRequest request = new DefaultModelBuildingRequest();
535 request.setLocationTracking( true );
536 request.setProcessPlugins( false );
537 if ( local )
538 {
539 request.setPomFile( pomFile );
540 request.setValidationLevel( ModelBuildingRequest.VALIDATION_LEVEL_STRICT );
541 }
542 else
543 {
544 request.setModelSource( new FileModelSource( pomFile ) );
545 request.setValidationLevel( ModelBuildingRequest.VALIDATION_LEVEL_MINIMAL );
546 }
547 request.setSystemProperties( getSystemProperties() );
548 request.setUserProperties( getUserProperties() );
549 request.setProfiles( SettingsUtils.convert( settings.getProfiles() ) );
550 request.setActiveProfileIds( settings.getActiveProfiles() );
551 request.setModelResolver( modelResolver );
552 return MODEL_BUILDER.build( request ).getEffectiveModel();
553 }
554 catch ( ModelBuildingException e )
555 {
556 throw new BuildException( "Could not load POM " + pomFile + ": " + e.getMessage(), e );
557 }
558 }
559
560 private Properties getSystemProperties()
561 {
562 Properties props = new Properties();
563 getEnvProperties( props );
564 props.putAll( System.getProperties() );
565 ConverterUtils.addProperties( props, project.getProperties() );
566 return props;
567 }
568
569 private Properties getEnvProperties( Properties props )
570 {
571 if ( props == null )
572 {
573 props = new Properties();
574 }
575 boolean envCaseInsensitive = OS_WINDOWS;
576 for ( Map.Entry<String, String> entry : System.getenv().entrySet() )
577 {
578 String key = entry.getKey();
579 if ( envCaseInsensitive )
580 {
581 key = key.toUpperCase( Locale.ENGLISH );
582 }
583 key = "env." + key;
584 props.put( key, entry.getValue() );
585 }
586 return props;
587 }
588
589 private Properties getUserProperties()
590 {
591 return ConverterUtils.addProperties( null, project.getUserProperties() );
592 }
593
594
595
596
597 public void setDefaultPom( Pom pom )
598 {
599 this.defaultPom = pom;
600 }
601
602
603
604
605 public Pom getDefaultPom()
606 {
607 return defaultPom;
608 }
609
610 public CollectResult collectDependencies( Task task, Dependencies dependencies, LocalRepository localRepository,
611 RemoteRepositories remoteRepositories )
612 {
613 RepositorySystemSession session = getSession( task, localRepository );
614
615 remoteRepositories =
616 remoteRepositories == null ? AetherUtils.getDefaultRepositories( project ) : remoteRepositories;
617
618 List<org.eclipse.aether.repository.RemoteRepository> repos =
619 ConverterUtils.toRepositories( project, session, remoteRepositories, getRemoteRepoMan() );
620
621 CollectRequest collectRequest = new CollectRequest();
622 collectRequest.setRequestContext( "project" );
623
624 for ( org.eclipse.aether.repository.RemoteRepository repo : repos )
625 {
626 task.getProject().log( "Using remote repository " + repo, Project.MSG_VERBOSE );
627 collectRequest.addRepository( repo );
628 }
629
630 if ( dependencies != null )
631 {
632 populateCollectRequest( collectRequest, task, session, dependencies, Collections.<Exclusion>emptyList() );
633 }
634
635 task.getProject().log( "Collecting dependencies", Project.MSG_VERBOSE );
636
637 CollectResult result;
638 try
639 {
640 result = getSystem().collectDependencies( session, collectRequest );
641 }
642 catch ( DependencyCollectionException e )
643 {
644 throw new BuildException( "Could not collect dependencies: " + e.getMessage(), e );
645 }
646
647 return result;
648 }
649
650 private void populateCollectRequest( CollectRequest collectRequest, Task task, RepositorySystemSession session,
651 Dependencies dependencies, List<Exclusion> exclusions )
652 {
653 List<Exclusion> globalExclusions = exclusions;
654 if ( !dependencies.getExclusions().isEmpty() )
655 {
656 globalExclusions = new ArrayList<Exclusion>( exclusions );
657 globalExclusions.addAll( dependencies.getExclusions() );
658 }
659
660 Collection<String> ids = new HashSet<String>();
661
662 for ( DependencyContainer container : dependencies.getDependencyContainers() )
663 {
664 if ( container instanceof Dependency )
665 {
666 Dependency dep = (Dependency) container;
667 ids.add( dep.getVersionlessKey() );
668 collectRequest.addDependency( ConverterUtils.toDependency( dep, globalExclusions, session ) );
669 }
670 else
671 {
672 populateCollectRequest( collectRequest, task, session, (Dependencies) container, globalExclusions );
673 }
674 }
675
676 if ( dependencies.getPom() != null )
677 {
678 Model model = dependencies.getPom().getModel( task );
679 for ( org.apache.maven.model.Dependency dep : model.getDependencies() )
680 {
681 Dependency dependency = new Dependency();
682 dependency.setArtifactId( dep.getArtifactId() );
683 dependency.setClassifier( dep.getClassifier() );
684 dependency.setGroupId( dep.getGroupId() );
685 dependency.setScope( dep.getScope() );
686 dependency.setType( dep.getType() );
687 dependency.setVersion( dep.getVersion() );
688 if ( ids.contains( dependency.getVersionlessKey() ) )
689 {
690 project.log( "Ignoring dependency " + dependency.getVersionlessKey() + " from " + model.getId()
691 + ", already declared locally", Project.MSG_VERBOSE );
692 continue;
693 }
694 if ( dep.getSystemPath() != null && dep.getSystemPath().length() > 0 )
695 {
696 dependency.setSystemPath( task.getProject().resolveFile( dep.getSystemPath() ) );
697 }
698 for ( org.apache.maven.model.Exclusion exc : dep.getExclusions() )
699 {
700 Exclusion exclusion = new Exclusion();
701 exclusion.setGroupId( exc.getGroupId() );
702 exclusion.setArtifactId( exc.getArtifactId() );
703 exclusion.setClassifier( "*" );
704 exclusion.setExtension( "*" );
705 dependency.addExclusion( exclusion );
706 }
707 collectRequest.addDependency( ConverterUtils.toDependency( dependency, globalExclusions, session ) );
708 }
709 }
710
711 if ( dependencies.getFile() != null )
712 {
713 List<Dependency> deps = readDependencies( dependencies.getFile() );
714 for ( Dependency dependency : deps )
715 {
716 if ( ids.contains( dependency.getVersionlessKey() ) )
717 {
718 project.log( "Ignoring dependency " + dependency.getVersionlessKey() + " from "
719 + dependencies.getFile() + ", already declared locally", Project.MSG_VERBOSE );
720 continue;
721 }
722 collectRequest.addDependency( ConverterUtils.toDependency( dependency, globalExclusions, session ) );
723 }
724 }
725 }
726
727 private List<Dependency> readDependencies( File file )
728 {
729 List<Dependency> dependencies = new ArrayList<Dependency>();
730 try
731 {
732 BufferedReader reader = new BufferedReader( new InputStreamReader( new FileInputStream( file ), "UTF-8" ) );
733 try
734 {
735 for ( String line = reader.readLine(); line != null; line = reader.readLine() )
736 {
737 int comment = line.indexOf( '#' );
738 if ( comment >= 0 )
739 {
740 line = line.substring( 0, comment );
741 }
742 line = line.trim();
743 if ( line.length() <= 0 )
744 {
745 continue;
746 }
747 Dependency dependency = new Dependency();
748 dependency.setCoords( line );
749 dependencies.add( dependency );
750 }
751 }
752 finally
753 {
754 reader.close();
755 }
756 }
757 catch ( IOException e )
758 {
759 throw new BuildException( "Cannot read " + file, e );
760 }
761 return dependencies;
762 }
763
764 public void install( Task task, Pom pom, Artifacts artifacts )
765 {
766 RepositorySystemSession session = getSession( task, null );
767
768 InstallRequest request = new InstallRequest();
769 request.setArtifacts( toArtifacts( task, session, pom, artifacts ) );
770
771 try
772 {
773 getSystem().install( session, request );
774 }
775 catch ( InstallationException e )
776 {
777 throw new BuildException( "Could not install artifacts: " + e.getMessage(), e );
778 }
779 }
780
781 public void deploy( Task task, Pom pom, Artifacts artifacts, RemoteRepository releaseRepository,
782 RemoteRepository snapshotRepository )
783 {
784 RepositorySystemSession session = getSession( task, null );
785
786 DeployRequest request = new DeployRequest();
787 request.setArtifacts( toArtifacts( task, session, pom, artifacts ) );
788 boolean snapshot = request.getArtifacts().iterator().next().isSnapshot();
789 RemoteRepository distRepo = ( snapshot && snapshotRepository != null ) ? snapshotRepository : releaseRepository;
790 request.setRepository( ConverterUtils.toDistRepository( distRepo, session ) );
791
792 try
793 {
794 getSystem().deploy( session, request );
795 }
796 catch ( DeploymentException e )
797 {
798 throw new BuildException( "Could not deploy artifacts: " + e.getMessage(), e );
799 }
800 }
801
802 private List<org.eclipse.aether.artifact.Artifact> toArtifacts( Task task, RepositorySystemSession session,
803 Pom pom, Artifacts artifacts )
804 {
805 Model model = pom.getModel( task );
806 File pomFile = pom.getFile();
807
808 List<org.eclipse.aether.artifact.Artifact> results = new ArrayList<org.eclipse.aether.artifact.Artifact>();
809
810 org.eclipse.aether.artifact.Artifact pomArtifact =
811 new DefaultArtifact( model.getGroupId(), model.getArtifactId(), "pom", model.getVersion() ).setFile( pomFile );
812 results.add( pomArtifact );
813
814 for ( Artifact artifact : artifacts.getArtifacts() )
815 {
816 org.eclipse.aether.artifact.Artifact buildArtifact =
817 new DefaultArtifact( model.getGroupId(), model.getArtifactId(), artifact.getClassifier(),
818 artifact.getType(), model.getVersion() ).setFile( artifact.getFile() );
819 results.add( buildArtifact );
820 }
821
822 return results;
823 }
824
825 }