1
2 package org.apache.maven.plugin;
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23 import java.io.File;
24 import java.net.URL;
25 import java.util.ArrayList;
26 import java.util.Collection;
27 import java.util.Collections;
28 import java.util.HashMap;
29 import java.util.HashSet;
30 import java.util.Iterator;
31 import java.util.LinkedHashMap;
32 import java.util.LinkedHashSet;
33 import java.util.List;
34 import java.util.Map;
35 import java.util.Set;
36
37 import org.apache.maven.MavenArtifactFilterManager;
38 import org.apache.maven.artifact.Artifact;
39 import org.apache.maven.artifact.factory.ArtifactFactory;
40 import org.apache.maven.artifact.metadata.ArtifactMetadataRetrievalException;
41 import org.apache.maven.artifact.metadata.ArtifactMetadataSource;
42 import org.apache.maven.artifact.metadata.ResolutionGroup;
43 import org.apache.maven.artifact.repository.ArtifactRepository;
44 import org.apache.maven.artifact.resolver.ArtifactNotFoundException;
45 import org.apache.maven.artifact.resolver.ArtifactResolutionException;
46 import org.apache.maven.artifact.resolver.ArtifactResolutionResult;
47 import org.apache.maven.artifact.resolver.ArtifactResolver;
48 import org.apache.maven.artifact.resolver.MultipleArtifactsNotFoundException;
49 import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
50 import org.apache.maven.artifact.resolver.filter.ScopeArtifactFilter;
51 import org.apache.maven.artifact.versioning.DefaultArtifactVersion;
52 import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException;
53 import org.apache.maven.artifact.versioning.VersionRange;
54 import org.apache.maven.execution.MavenSession;
55 import org.apache.maven.execution.RuntimeInformation;
56 import org.apache.maven.model.Plugin;
57 import org.apache.maven.model.ReportPlugin;
58 import org.apache.maven.monitor.event.EventDispatcher;
59 import org.apache.maven.monitor.event.MavenEvents;
60 import org.apache.maven.monitor.logging.DefaultLog;
61 import org.apache.maven.plugin.descriptor.MojoDescriptor;
62 import org.apache.maven.plugin.descriptor.Parameter;
63 import org.apache.maven.plugin.descriptor.PluginDescriptor;
64 import org.apache.maven.plugin.descriptor.PluginDescriptorBuilder;
65 import org.apache.maven.plugin.logging.Log;
66 import org.apache.maven.plugin.version.PluginVersionManager;
67 import org.apache.maven.plugin.version.PluginVersionNotFoundException;
68 import org.apache.maven.plugin.version.PluginVersionResolutionException;
69 import org.apache.maven.project.MavenProject;
70 import org.apache.maven.project.MavenProjectBuilder;
71 import org.apache.maven.project.ProjectBuildingException;
72 import org.apache.maven.project.artifact.InvalidDependencyVersionException;
73 import org.apache.maven.project.artifact.MavenMetadataSource;
74 import org.apache.maven.project.path.PathTranslator;
75 import org.apache.maven.reporting.MavenReport;
76 import org.apache.maven.settings.Settings;
77 import org.codehaus.classworlds.ClassRealm;
78 import org.codehaus.classworlds.NoSuchRealmException;
79 import org.codehaus.plexus.PlexusConstants;
80 import org.codehaus.plexus.PlexusContainer;
81 import org.codehaus.plexus.PlexusContainerException;
82 import org.codehaus.plexus.component.configurator.ComponentConfigurationException;
83 import org.codehaus.plexus.component.configurator.ComponentConfigurator;
84 import org.codehaus.plexus.component.configurator.ConfigurationListener;
85 import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluationException;
86 import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluator;
87 import org.codehaus.plexus.component.repository.exception.ComponentLifecycleException;
88 import org.codehaus.plexus.component.repository.exception.ComponentLookupException;
89 import org.codehaus.plexus.configuration.PlexusConfiguration;
90 import org.codehaus.plexus.configuration.xml.XmlPlexusConfiguration;
91 import org.codehaus.plexus.context.Context;
92 import org.codehaus.plexus.context.ContextException;
93 import org.codehaus.plexus.logging.AbstractLogEnabled;
94 import org.codehaus.plexus.personality.plexus.lifecycle.phase.Contextualizable;
95 import org.codehaus.plexus.personality.plexus.lifecycle.phase.Initializable;
96 import org.codehaus.plexus.util.StringUtils;
97 import org.codehaus.plexus.util.xml.Xpp3Dom;
98
99 public class DefaultPluginManager
100 extends AbstractLogEnabled
101 implements PluginManager, Initializable, Contextualizable
102 {
103 protected PlexusContainer container;
104
105 protected PluginDescriptorBuilder pluginDescriptorBuilder;
106
107 protected ArtifactFilter artifactFilter;
108
109 private Log mojoLogger;
110
111 private Map resolvedCoreArtifactFiles = new HashMap();
112
113
114 protected PathTranslator pathTranslator;
115
116 protected MavenPluginCollector pluginCollector;
117
118 protected PluginVersionManager pluginVersionManager;
119
120 protected ArtifactFactory artifactFactory;
121
122 protected ArtifactResolver artifactResolver;
123
124 protected ArtifactMetadataSource artifactMetadataSource;
125
126 protected RuntimeInformation runtimeInformation;
127
128 protected MavenProjectBuilder mavenProjectBuilder;
129
130 protected PluginMappingManager pluginMappingManager;
131
132
133
134 public DefaultPluginManager()
135 {
136 pluginDescriptorBuilder = new PluginDescriptorBuilder();
137 }
138
139
140
141
142
143 public PluginDescriptor getPluginDescriptorForPrefix( String prefix )
144 {
145 return pluginCollector.getPluginDescriptorForPrefix( prefix );
146 }
147
148 public Plugin getPluginDefinitionForPrefix( String prefix,
149 MavenSession session,
150 MavenProject project )
151 {
152
153
154 return pluginMappingManager.getByPrefix( prefix, session.getSettings().getPluginGroups(),
155 project.getPluginArtifactRepositories(),
156 session.getLocalRepository() );
157 }
158
159 public PluginDescriptor verifyPlugin( Plugin plugin,
160 MavenProject project,
161 Settings settings,
162 ArtifactRepository localRepository )
163 throws ArtifactResolutionException, PluginVersionResolutionException, ArtifactNotFoundException,
164 InvalidVersionSpecificationException, InvalidPluginException, PluginManagerException, PluginNotFoundException,
165 PluginVersionNotFoundException
166 {
167
168
169 if ( plugin.getVersion() == null )
170 {
171 String version = pluginVersionManager.resolvePluginVersion( plugin.getGroupId(), plugin.getArtifactId(),
172 project, settings, localRepository );
173 plugin.setVersion( version );
174 }
175
176 return verifyVersionedPlugin( plugin, project, localRepository );
177 }
178
179 private PluginDescriptor verifyVersionedPlugin( Plugin plugin,
180 MavenProject project,
181 ArtifactRepository localRepository )
182 throws PluginVersionResolutionException, ArtifactNotFoundException, ArtifactResolutionException,
183 InvalidVersionSpecificationException, InvalidPluginException, PluginManagerException, PluginNotFoundException
184 {
185
186
187
188
189 try
190 {
191 VersionRange versionRange = VersionRange.createFromVersionSpec( plugin.getVersion() );
192
193 List remoteRepositories = new ArrayList();
194 remoteRepositories.addAll( project.getPluginArtifactRepositories() );
195 remoteRepositories.addAll( project.getRemoteArtifactRepositories() );
196
197 checkRequiredMavenVersion( plugin, localRepository, remoteRepositories );
198
199 Artifact pluginArtifact =
200 artifactFactory.createPluginArtifact( plugin.getGroupId(), plugin.getArtifactId(), versionRange );
201
202 pluginArtifact = project.replaceWithActiveArtifact( pluginArtifact );
203
204 artifactResolver.resolve( pluginArtifact, project.getPluginArtifactRepositories(), localRepository );
205
206 PlexusContainer pluginContainer = container.getChildContainer( plugin.getKey() );
207
208 File pluginFile = pluginArtifact.getFile();
209
210 if ( !pluginCollector.isPluginInstalled( plugin ) || ( pluginContainer == null ) )
211 {
212 addPlugin( plugin, pluginArtifact, project, localRepository );
213 }
214 else if ( pluginFile.lastModified() > pluginContainer.getCreationDate().getTime() )
215 {
216 getLogger().info(
217 "Reloading plugin container for: " + plugin.getKey() + ". The plugin artifact has changed." );
218
219 pluginContainer.dispose();
220
221 pluginCollector.flushPluginDescriptor( plugin );
222
223 addPlugin( plugin, pluginArtifact, project, localRepository );
224 }
225
226 project.addPlugin( plugin );
227 }
228 catch ( ArtifactNotFoundException e )
229 {
230 String groupId = plugin.getGroupId();
231 String artifactId = plugin.getArtifactId();
232 String version = plugin.getVersion();
233
234 if ( ( groupId == null ) || ( artifactId == null ) || ( version == null ) )
235 {
236 throw new PluginNotFoundException( e );
237 }
238 else if ( groupId.equals( e.getGroupId() ) && artifactId.equals( e.getArtifactId() ) &&
239 version.equals( e.getVersion() ) && "maven-plugin".equals( e.getType() ) )
240 {
241 throw new PluginNotFoundException( e );
242 }
243 else
244 {
245 throw e;
246 }
247 }
248
249 return pluginCollector.getPluginDescriptor( plugin );
250 }
251
252
253
254
255
256 private void checkRequiredMavenVersion( Plugin plugin,
257 ArtifactRepository localRepository,
258 List remoteRepositories )
259 throws PluginVersionResolutionException, InvalidPluginException
260 {
261 try
262 {
263 Artifact artifact = artifactFactory.createProjectArtifact( plugin.getGroupId(), plugin.getArtifactId(),
264 plugin.getVersion() );
265 MavenProject project =
266 mavenProjectBuilder.buildFromRepository( artifact, remoteRepositories, localRepository, false );
267
268 if ( ( project.getPrerequisites() != null ) && ( project.getPrerequisites().getMaven() != null ) )
269 {
270 DefaultArtifactVersion requiredVersion =
271 new DefaultArtifactVersion( project.getPrerequisites().getMaven() );
272 if ( runtimeInformation.getApplicationVersion().compareTo( requiredVersion ) < 0 )
273 {
274 throw new PluginVersionResolutionException( plugin.getGroupId(), plugin.getArtifactId(),
275 "Plugin requires Maven version " + requiredVersion );
276 }
277 }
278 }
279 catch ( ProjectBuildingException e )
280 {
281 throw new InvalidPluginException(
282 "Unable to build project for plugin '" + plugin.getKey() + "': " + e.getMessage(), e );
283 }
284 }
285
286 protected void addPlugin( Plugin plugin,
287 Artifact pluginArtifact,
288 MavenProject project,
289 ArtifactRepository localRepository )
290 throws PluginManagerException, InvalidPluginException
291 {
292 PlexusContainer child;
293
294 try
295 {
296 child = container.createChildContainer( plugin.getKey(),
297 Collections.singletonList( pluginArtifact.getFile() ),
298 Collections.EMPTY_MAP,
299 Collections.singletonList( pluginCollector ) );
300 try
301 {
302 child.getContainerRealm().importFrom( "plexus.core", "org.codehaus.plexus.util.xml.Xpp3Dom" );
303 child.getContainerRealm().importFrom( "plexus.core", "org.codehaus.plexus.util.xml.pull" );
304
305
306 child.getContainerRealm().importFrom( "plexus.core", "/default-report.xml" );
307 }
308 catch ( NoSuchRealmException e )
309 {
310
311 }
312 }
313 catch ( PlexusContainerException e )
314 {
315 throw new PluginManagerException(
316 "Failed to create plugin container for plugin '" + plugin + "': " + e.getMessage(), e );
317 }
318
319
320
321 PluginDescriptor addedPlugin = pluginCollector.getPluginDescriptor( plugin );
322
323 if ( addedPlugin == null )
324 {
325 throw new IllegalStateException( "The PluginDescriptor for the plugin " + plugin + " was not found." );
326 }
327
328 addedPlugin.setClassRealm( child.getContainerRealm() );
329
330
331
332
333 addedPlugin.setArtifacts( Collections.singletonList( pluginArtifact ) );
334
335 try
336 {
337
338
339
340 Plugin projectPlugin = (Plugin) project.getBuild().getPluginsAsMap().get( plugin.getKey() );
341
342 if ( projectPlugin == null )
343 {
344 projectPlugin = plugin;
345 }
346
347 Set artifacts = MavenMetadataSource.createArtifacts( artifactFactory, projectPlugin.getDependencies(), null,
348 null, project );
349
350
351
352
353 addedPlugin.setIntroducedDependencyArtifacts( artifacts );
354 }
355 catch ( InvalidDependencyVersionException e )
356 {
357 throw new InvalidPluginException( "Plugin '" + plugin + "' is invalid: " + e.getMessage(), e );
358 }
359 }
360
361
362
363
364
365 public void executeMojo( MavenProject project,
366 MojoExecution mojoExecution,
367 MavenSession session )
368 throws ArtifactResolutionException, MojoExecutionException, MojoFailureException, ArtifactNotFoundException,
369 InvalidDependencyVersionException, PluginManagerException, PluginConfigurationException
370 {
371 MojoDescriptor mojoDescriptor = mojoExecution.getMojoDescriptor();
372
373
374
375 if ( mojoDescriptor.isProjectRequired() && !session.isUsingPOMsFromFilesystem() )
376 {
377 throw new MojoExecutionException( "Cannot execute mojo: " + mojoDescriptor.getGoal() +
378 ". It requires a project with an existing pom.xml, but the build is not using one." );
379 }
380
381 if ( mojoDescriptor.isOnlineRequired() && session.getSettings().isOffline() )
382 {
383
384 throw new MojoExecutionException( "Mojo: " + mojoDescriptor.getGoal() +
385 " requires online mode for execution. Maven is currently offline." );
386 }
387
388 if ( mojoDescriptor.isDependencyResolutionRequired() != null )
389 {
390 Collection projects;
391
392 if ( mojoDescriptor.isAggregator() )
393 {
394 projects = session.getSortedProjects();
395 }
396 else
397 {
398 projects = Collections.singleton( project );
399 }
400
401 for ( Iterator i = projects.iterator(); i.hasNext(); )
402 {
403 MavenProject p = (MavenProject) i.next();
404
405 resolveTransitiveDependencies( session, artifactResolver,
406 mojoDescriptor.isDependencyResolutionRequired(), artifactFactory, p, mojoDescriptor.isAggregator() );
407 }
408
409 downloadDependencies( project, session, artifactResolver );
410 }
411
412 String goalName = mojoDescriptor.getFullGoalName();
413
414 Mojo plugin;
415
416 PluginDescriptor pluginDescriptor = mojoDescriptor.getPluginDescriptor();
417 String goalId = mojoDescriptor.getGoal();
418 String groupId = pluginDescriptor.getGroupId();
419 String artifactId = pluginDescriptor.getArtifactId();
420 String executionId = mojoExecution.getExecutionId();
421 Xpp3Dom dom = project.getGoalConfiguration( groupId, artifactId, executionId, goalId );
422 Xpp3Dom reportDom = project.getReportConfiguration( groupId, artifactId, executionId );
423 dom = Xpp3Dom.mergeXpp3Dom( dom, reportDom );
424 if ( mojoExecution.getConfiguration() != null )
425 {
426 dom = Xpp3Dom.mergeXpp3Dom( dom, mojoExecution.getConfiguration() );
427 }
428
429 plugin = getConfiguredMojo( session, dom, project, false, mojoExecution );
430
431
432 String event = MavenEvents.MOJO_EXECUTION;
433 EventDispatcher dispatcher = session.getEventDispatcher();
434
435 String goalExecId = goalName;
436
437 if ( mojoExecution.getExecutionId() != null )
438 {
439 goalExecId += " {execution: " + mojoExecution.getExecutionId() + "}";
440 }
441
442 dispatcher.dispatchStart( event, goalExecId );
443
444 ClassLoader oldClassLoader = Thread.currentThread().getContextClassLoader();
445
446 try
447 {
448 Thread.currentThread().setContextClassLoader(
449 mojoDescriptor.getPluginDescriptor().getClassRealm().getClassLoader() );
450
451 plugin.execute();
452
453 dispatcher.dispatchEnd( event, goalExecId );
454 }
455 catch ( MojoExecutionException e )
456 {
457 session.getEventDispatcher().dispatchError( event, goalExecId, e );
458
459 throw e;
460 }
461 catch ( MojoFailureException e )
462 {
463 session.getEventDispatcher().dispatchError( event, goalExecId, e );
464
465 throw e;
466 }
467 catch ( LinkageError e )
468 {
469 if ( getLogger().isFatalErrorEnabled() )
470 {
471 getLogger().fatalError(
472 plugin.getClass().getName() + "#execute() caused a linkage error ("
473 + e.getClass().getName() + ") and may be out-of-date. Check the realms:" );
474
475 ClassRealm pluginRealm = mojoDescriptor.getPluginDescriptor().getClassRealm();
476 StringBuffer sb = new StringBuffer();
477 sb.append( "Plugin realm = " + pluginRealm.getId() ).append( '\n' );
478 for ( int i = 0; i < pluginRealm.getConstituents().length; i++ )
479 {
480 sb.append( "urls[" + i + "] = " + pluginRealm.getConstituents()[i] );
481 if ( i != ( pluginRealm.getConstituents().length - 1 ) )
482 {
483 sb.append( '\n' );
484 }
485 }
486 getLogger().fatalError( sb.toString() );
487
488 ClassRealm containerRealm = container.getContainerRealm();
489 sb = new StringBuffer();
490 sb.append( "Container realm = " + containerRealm.getId() ).append( '\n' );
491 for ( int i = 0; i < containerRealm.getConstituents().length; i++ )
492 {
493 sb.append( "urls[" + i + "] = " + containerRealm.getConstituents()[i] );
494 if ( i != ( containerRealm.getConstituents().length - 1 ) )
495 {
496 sb.append( '\n' );
497 }
498 }
499 getLogger().fatalError( sb.toString() );
500 }
501
502 session.getEventDispatcher().dispatchError( event, goalExecId, e );
503
504 throw e;
505 }
506 finally
507 {
508
509 Thread.currentThread().setContextClassLoader( oldClassLoader );
510
511 try
512 {
513 PlexusContainer pluginContainer = getPluginContainer( mojoDescriptor.getPluginDescriptor() );
514
515 pluginContainer.release( plugin );
516 }
517 catch ( ComponentLifecycleException e )
518 {
519 if ( getLogger().isErrorEnabled() )
520 {
521 getLogger().error( "Error releasing plugin - ignoring.", e );
522 }
523 }
524 }
525 }
526
527 public MavenReport getReport( MavenProject project,
528 MojoExecution mojoExecution,
529 MavenSession session )
530 throws ArtifactNotFoundException, PluginConfigurationException, PluginManagerException,
531 ArtifactResolutionException
532 {
533 MojoDescriptor mojoDescriptor = mojoExecution.getMojoDescriptor();
534 PluginDescriptor descriptor = mojoDescriptor.getPluginDescriptor();
535 Xpp3Dom dom = project.getReportConfiguration( descriptor.getGroupId(), descriptor.getArtifactId(),
536 mojoExecution.getExecutionId() );
537 if ( mojoExecution.getConfiguration() != null )
538 {
539 dom = Xpp3Dom.mergeXpp3Dom( dom, mojoExecution.getConfiguration() );
540 }
541
542 return (MavenReport) getConfiguredMojo( session, dom, project, true, mojoExecution );
543 }
544
545 public PluginDescriptor verifyReportPlugin( ReportPlugin reportPlugin,
546 MavenProject project,
547 MavenSession session )
548 throws PluginVersionResolutionException, ArtifactResolutionException, ArtifactNotFoundException,
549 InvalidVersionSpecificationException, InvalidPluginException, PluginManagerException, PluginNotFoundException,
550 PluginVersionNotFoundException
551 {
552 String version = reportPlugin.getVersion();
553
554 if ( version == null )
555 {
556 version = pluginVersionManager.resolveReportPluginVersion( reportPlugin.getGroupId(),
557 reportPlugin.getArtifactId(), project,
558 session.getSettings(),
559 session.getLocalRepository() );
560 reportPlugin.setVersion( version );
561 }
562
563 Plugin forLookup = new Plugin();
564
565 forLookup.setGroupId( reportPlugin.getGroupId() );
566 forLookup.setArtifactId( reportPlugin.getArtifactId() );
567 forLookup.setVersion( version );
568
569 return verifyVersionedPlugin( forLookup, project, session.getLocalRepository() );
570 }
571
572 private PlexusContainer getPluginContainer( PluginDescriptor pluginDescriptor )
573 throws PluginManagerException
574 {
575 String pluginKey = pluginDescriptor.getPluginLookupKey();
576
577 PlexusContainer pluginContainer = container.getChildContainer( pluginKey );
578
579 if ( pluginContainer == null )
580 {
581 throw new PluginManagerException( "Cannot find Plexus container for plugin: " + pluginKey );
582 }
583
584 return pluginContainer;
585 }
586
587 private Mojo getConfiguredMojo( MavenSession session,
588 Xpp3Dom dom,
589 MavenProject project,
590 boolean report,
591 MojoExecution mojoExecution )
592 throws PluginConfigurationException, ArtifactNotFoundException, PluginManagerException,
593 ArtifactResolutionException
594 {
595 MojoDescriptor mojoDescriptor = mojoExecution.getMojoDescriptor();
596
597 PluginDescriptor pluginDescriptor = mojoDescriptor.getPluginDescriptor();
598
599 PlexusContainer pluginContainer = getPluginContainer( pluginDescriptor );
600
601
602
603
604 ensurePluginContainerIsComplete( pluginDescriptor, pluginContainer, project, session );
605
606 Mojo plugin;
607 try
608 {
609 plugin = (Mojo) pluginContainer.lookup( Mojo.ROLE, mojoDescriptor.getRoleHint() );
610 if ( report && !( plugin instanceof MavenReport ) )
611 {
612
613 return null;
614 }
615 }
616 catch ( ComponentLookupException e )
617 {
618 throw new PluginManagerException( "Unable to find the mojo '" + mojoDescriptor.getRoleHint() +
619 "' in the plugin '" + pluginDescriptor.getPluginLookupKey() + "'", e );
620 }
621
622 if ( plugin instanceof ContextEnabled )
623 {
624 Map pluginContext = session.getPluginContext( pluginDescriptor, project );
625
626 ( (ContextEnabled) plugin ).setPluginContext( pluginContext );
627 }
628
629 plugin.setLog( mojoLogger );
630
631 XmlPlexusConfiguration pomConfiguration;
632 if ( dom == null )
633 {
634 pomConfiguration = new XmlPlexusConfiguration( "configuration" );
635 }
636 else
637 {
638 pomConfiguration = new XmlPlexusConfiguration( dom );
639 }
640
641
642
643 validatePomConfiguration( mojoDescriptor, pomConfiguration );
644
645 PlexusConfiguration mergedConfiguration = mergeMojoConfiguration( pomConfiguration, mojoDescriptor );
646
647
648
649
650
651 ExpressionEvaluator expressionEvaluator = new PluginParameterExpressionEvaluator( session, mojoExecution,
652 pathTranslator, getLogger(),
653 project,
654 session.getExecutionProperties() );
655
656 PlexusConfiguration extractedMojoConfiguration =
657 extractMojoConfiguration( mergedConfiguration, mojoDescriptor );
658
659 checkRequiredParameters( mojoDescriptor, extractedMojoConfiguration, expressionEvaluator );
660
661 populatePluginFields( plugin, mojoDescriptor, extractedMojoConfiguration, pluginContainer,
662 expressionEvaluator );
663 return plugin;
664 }
665
666 private void ensurePluginContainerIsComplete( PluginDescriptor pluginDescriptor,
667 PlexusContainer pluginContainer,
668 MavenProject project,
669 MavenSession session )
670 throws ArtifactNotFoundException, PluginManagerException, ArtifactResolutionException
671 {
672
673
674 if ( ( pluginDescriptor.getArtifacts() != null ) && ( pluginDescriptor.getArtifacts().size() == 1 ) )
675 {
676 Artifact pluginArtifact = (Artifact) pluginDescriptor.getArtifacts().get( 0 );
677
678 ArtifactRepository localRepository = session.getLocalRepository();
679
680 ResolutionGroup resolutionGroup;
681 try
682 {
683 resolutionGroup = artifactMetadataSource.retrieve( pluginArtifact, localRepository,
684 project.getPluginArtifactRepositories() );
685 }
686 catch ( ArtifactMetadataRetrievalException e )
687 {
688 throw new ArtifactResolutionException( "Unable to download metadata from repository for plugin '" +
689 pluginArtifact.getId() + "': " + e.getMessage(), pluginArtifact, e );
690 }
691
692 checkPlexusUtils( resolutionGroup, artifactFactory );
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711 Map dependencyMap = new LinkedHashMap();
712
713
714
715 List all = new ArrayList();
716
717
718
719 all.addAll( pluginDescriptor.getIntroducedDependencyArtifacts() );
720
721
722 all.addAll( resolutionGroup.getArtifacts() );
723
724 for ( Iterator it = all.iterator(); it.hasNext(); )
725 {
726 Artifact artifact = (Artifact) it.next();
727 String conflictId = artifact.getDependencyConflictId();
728
729
730
731
732 if ( !dependencyMap.containsKey( conflictId ) )
733 {
734 dependencyMap.put( conflictId, artifact );
735 }
736 }
737
738
739 Set dependencies = new LinkedHashSet( dependencyMap.values() );
740
741 if ( getLogger().isDebugEnabled() )
742 {
743
744 getLogger().debug( "Plugin dependencies for:\n\n" + pluginDescriptor.getId()
745 + "\n\nare:\n\n"
746 + StringUtils.join( dependencies.iterator(), "\n" ) + "\n\n" );
747 }
748
749 List repositories = new ArrayList();
750 repositories.addAll( resolutionGroup.getResolutionRepositories() );
751 repositories.addAll( project.getRemoteArtifactRepositories() );
752
753
754 Map pluginManagedDependencies = new HashMap();
755 try
756 {
757 MavenProject pluginProject =
758 mavenProjectBuilder.buildFromRepository( pluginArtifact, project.getRemoteArtifactRepositories(),
759 localRepository );
760 if ( pluginProject != null )
761 {
762 pluginManagedDependencies = pluginProject.getManagedVersionMap();
763 }
764 }
765 catch ( ProjectBuildingException e )
766 {
767
768 }
769
770 ArtifactResolutionResult result = artifactResolver.resolveTransitively( dependencies, pluginArtifact,
771 pluginManagedDependencies,
772 localRepository, repositories,
773 artifactMetadataSource,
774 artifactFilter );
775
776 Set resolved = result.getArtifacts();
777
778 for ( Iterator it = resolved.iterator(); it.hasNext(); )
779 {
780 Artifact artifact = (Artifact) it.next();
781
782 if ( !artifact.equals( pluginArtifact ) )
783 {
784 artifact = project.replaceWithActiveArtifact( artifact );
785
786 try
787 {
788 pluginContainer.addJarResource( artifact.getFile() );
789 }
790 catch ( PlexusContainerException e )
791 {
792 throw new PluginManagerException( "Error adding plugin dependency '" +
793 artifact.getDependencyConflictId() + "' into plugin manager: " + e.getMessage(), e );
794 }
795 }
796 }
797
798 pluginDescriptor.setClassRealm( pluginContainer.getContainerRealm() );
799
800 List unresolved = new ArrayList( dependencies );
801
802 unresolved.removeAll( resolved );
803
804 if ( getLogger().isDebugEnabled() )
805 {
806
807
808 getLogger().debug( " The following artifacts were filtered out for plugin: "
809 + pluginDescriptor.getId()
810 + " because they're already in the core of Maven:\n\n"
811 + StringUtils.join( unresolved.iterator(), "\n" )
812 + "\n\nThese will use the artifact files already in the core ClassRealm instead, to allow them to be included in PluginDescriptor.getArtifacts().\n\n" );
813 }
814
815
816
817
818 resolveCoreArtifacts( unresolved, localRepository, resolutionGroup.getResolutionRepositories() );
819
820
821
822
823
824
825 List allResolved = new ArrayList( resolved.size() + unresolved.size() );
826
827 allResolved.addAll( resolved );
828 allResolved.addAll( unresolved );
829
830 pluginDescriptor.setArtifacts( allResolved );
831 }
832 }
833
834 public static void checkPlexusUtils( ResolutionGroup resolutionGroup, ArtifactFactory artifactFactory )
835 {
836
837
838
839
840
841
842
843
844
845
846 VersionRange vr = null;
847
848 try
849 {
850 vr = VersionRange.createFromVersionSpec( "[1.1,)" );
851 }
852 catch ( InvalidVersionSpecificationException e )
853 {
854
855 }
856
857 boolean plexusUtilsPresent = false;
858
859 for ( Iterator i = resolutionGroup.getArtifacts().iterator(); i.hasNext(); )
860 {
861 Artifact a = (Artifact) i.next();
862
863 if ( a.getArtifactId().equals( "plexus-utils" ) &&
864 vr.containsVersion( new DefaultArtifactVersion( a.getVersion() ) ) )
865 {
866 plexusUtilsPresent = true;
867
868 break;
869 }
870 }
871
872 if ( !plexusUtilsPresent )
873 {
874
875
876
877
878 resolutionGroup.getArtifacts().add( artifactFactory.createArtifact( "org.codehaus.plexus",
879 "plexus-utils", "1.1",
880 Artifact.SCOPE_RUNTIME, "jar" ) );
881 }
882 }
883
884 private void resolveCoreArtifacts( List unresolved,
885 ArtifactRepository localRepository,
886 List resolutionRepositories )
887 throws ArtifactResolutionException, ArtifactNotFoundException
888 {
889 for ( Iterator it = unresolved.iterator(); it.hasNext(); )
890 {
891 Artifact artifact = (Artifact) it.next();
892
893 File artifactFile = (File) resolvedCoreArtifactFiles.get( artifact.getId() );
894
895 if ( artifactFile == null )
896 {
897 String resource =
898 "/META-INF/maven/" + artifact.getGroupId() + "/" + artifact.getArtifactId() + "/pom.xml";
899
900 URL resourceUrl = container.getContainerRealm().getResource( resource );
901
902 if ( resourceUrl == null )
903 {
904 artifactResolver.resolve( artifact, resolutionRepositories, localRepository );
905
906 artifactFile = artifact.getFile();
907 }
908 else
909 {
910 String artifactPath = resourceUrl.getPath();
911
912 if ( artifactPath.startsWith( "file:" ) )
913 {
914 artifactPath = artifactPath.substring( "file:".length() );
915 }
916
917 artifactPath = artifactPath.substring( 0, artifactPath.length() - resource.length() );
918
919 if ( artifactPath.endsWith( "/" ) )
920 {
921 artifactPath = artifactPath.substring( 0, artifactPath.length() - 1 );
922 }
923
924 if ( artifactPath.endsWith( "!" ) )
925 {
926 artifactPath = artifactPath.substring( 0, artifactPath.length() - 1 );
927 }
928
929 artifactFile = new File( artifactPath ).getAbsoluteFile();
930 }
931
932 resolvedCoreArtifactFiles.put( artifact.getId(), artifactFile );
933 }
934
935 artifact.setFile( artifactFile );
936 }
937 }
938
939 private PlexusConfiguration extractMojoConfiguration( PlexusConfiguration mergedConfiguration,
940 MojoDescriptor mojoDescriptor )
941 {
942 Map parameterMap = mojoDescriptor.getParameterMap();
943
944 PlexusConfiguration[] mergedChildren = mergedConfiguration.getChildren();
945
946 XmlPlexusConfiguration extractedConfiguration = new XmlPlexusConfiguration( "configuration" );
947
948 for ( int i = 0; i < mergedChildren.length; i++ )
949 {
950 PlexusConfiguration child = mergedChildren[i];
951
952 if ( parameterMap.containsKey( child.getName() ) )
953 {
954 extractedConfiguration.addChild( copyConfiguration( child ) );
955 }
956 else
957 {
958
959
960
961
962 getLogger().debug( "*** WARNING: Configuration \'" + child.getName() + "\' is not used in goal \'" +
963 mojoDescriptor.getFullGoalName() + "; this may indicate a typo... ***" );
964 }
965 }
966
967 return extractedConfiguration;
968 }
969
970 private void checkRequiredParameters( MojoDescriptor goal,
971 PlexusConfiguration configuration,
972 ExpressionEvaluator expressionEvaluator )
973 throws PluginConfigurationException
974 {
975
976
977 List parameters = goal.getParameters();
978
979 if ( parameters == null )
980 {
981 return;
982 }
983
984 List invalidParameters = new ArrayList();
985
986 for ( int i = 0; i < parameters.size(); i++ )
987 {
988 Parameter parameter = (Parameter) parameters.get( i );
989
990 if ( parameter.isRequired() )
991 {
992
993 String key = parameter.getName();
994
995 Object fieldValue = null;
996 String expression = null;
997 PlexusConfiguration value = configuration.getChild( key, false );
998 try
999 {
1000 if ( value != null )
1001 {
1002 expression = value.getValue( null );
1003
1004 fieldValue = expressionEvaluator.evaluate( expression );
1005
1006 if ( fieldValue == null )
1007 {
1008 fieldValue = value.getAttribute( "default-value", null );
1009 }
1010 }
1011
1012 if ( ( fieldValue == null ) && StringUtils.isNotEmpty( parameter.getAlias() ) )
1013 {
1014 value = configuration.getChild( parameter.getAlias(), false );
1015 if ( value != null )
1016 {
1017 expression = value.getValue( null );
1018 fieldValue = expressionEvaluator.evaluate( expression );
1019 if ( fieldValue == null )
1020 {
1021 fieldValue = value.getAttribute( "default-value", null );
1022 }
1023 }
1024 }
1025 }
1026 catch ( ExpressionEvaluationException e )
1027 {
1028 throw new PluginConfigurationException( goal.getPluginDescriptor(), e.getMessage(), e );
1029 }
1030
1031
1032 if ( ( fieldValue == null ) && ( ( value == null ) || ( value.getChildCount() == 0 ) ) )
1033 {
1034 parameter.setExpression( expression );
1035 invalidParameters.add( parameter );
1036 }
1037 }
1038 }
1039
1040 if ( !invalidParameters.isEmpty() )
1041 {
1042 throw new PluginParameterException( goal, invalidParameters );
1043 }
1044 }
1045
1046 private void validatePomConfiguration( MojoDescriptor goal,
1047 PlexusConfiguration pomConfiguration )
1048 throws PluginConfigurationException
1049 {
1050 List parameters = goal.getParameters();
1051
1052 if ( parameters == null )
1053 {
1054 return;
1055 }
1056
1057 for ( int i = 0; i < parameters.size(); i++ )
1058 {
1059 Parameter parameter = (Parameter) parameters.get( i );
1060
1061
1062 String key = parameter.getName();
1063
1064 PlexusConfiguration value = pomConfiguration.getChild( key, false );
1065
1066 if ( ( value == null ) && StringUtils.isNotEmpty( parameter.getAlias() ) )
1067 {
1068 key = parameter.getAlias();
1069 value = pomConfiguration.getChild( key, false );
1070 }
1071
1072 if ( value != null )
1073 {
1074
1075 if ( !parameter.isEditable() )
1076 {
1077 StringBuffer errorMessage = new StringBuffer()
1078 .append( "ERROR: Cannot override read-only parameter: " );
1079 errorMessage.append( key );
1080 errorMessage.append( " in goal: " ).append( goal.getFullGoalName() );
1081
1082 throw new PluginConfigurationException( goal.getPluginDescriptor(), errorMessage.toString() );
1083 }
1084
1085 String deprecated = parameter.getDeprecated();
1086 if ( StringUtils.isNotEmpty( deprecated ) )
1087 {
1088 getLogger().warn( "DEPRECATED [" + parameter.getName() + "]: " + deprecated );
1089 }
1090 }
1091 }
1092 }
1093
1094 private PlexusConfiguration mergeMojoConfiguration( XmlPlexusConfiguration fromPom,
1095 MojoDescriptor mojoDescriptor )
1096 {
1097 XmlPlexusConfiguration result = new XmlPlexusConfiguration( fromPom.getName() );
1098 result.setValue( fromPom.getValue( null ) );
1099
1100 if ( mojoDescriptor.getParameters() != null )
1101 {
1102 PlexusConfiguration fromMojo = mojoDescriptor.getMojoConfiguration();
1103
1104 for ( Iterator it = mojoDescriptor.getParameters().iterator(); it.hasNext(); )
1105 {
1106 Parameter parameter = (Parameter) it.next();
1107
1108 String paramName = parameter.getName();
1109 String alias = parameter.getAlias();
1110 String implementation = parameter.getImplementation();
1111
1112 PlexusConfiguration pomConfig = fromPom.getChild( paramName );
1113 PlexusConfiguration aliased = null;
1114
1115 if ( alias != null )
1116 {
1117 aliased = fromPom.getChild( alias );
1118 }
1119
1120 PlexusConfiguration mojoConfig = fromMojo.getChild( paramName, false );
1121
1122
1123
1124 if ( aliased != null )
1125 {
1126 if ( pomConfig == null )
1127 {
1128 pomConfig = new XmlPlexusConfiguration( paramName );
1129 }
1130
1131 pomConfig = buildTopDownMergedConfiguration( pomConfig, aliased );
1132 }
1133
1134 PlexusConfiguration toAdd = null;
1135
1136 if ( pomConfig != null )
1137 {
1138 pomConfig = buildTopDownMergedConfiguration( pomConfig, mojoConfig );
1139
1140 if ( StringUtils.isNotEmpty( pomConfig.getValue( null ) ) || ( pomConfig.getChildCount() > 0 ) )
1141 {
1142 toAdd = pomConfig;
1143 }
1144 }
1145
1146 if ( ( toAdd == null ) && ( mojoConfig != null ) )
1147 {
1148 toAdd = copyConfiguration( mojoConfig );
1149 }
1150
1151 if ( toAdd != null )
1152 {
1153 if ( ( implementation != null ) && ( toAdd.getAttribute( "implementation", null ) == null ) )
1154 {
1155
1156 XmlPlexusConfiguration implementationConf = new XmlPlexusConfiguration( paramName );
1157
1158 implementationConf.setAttribute( "implementation", parameter.getImplementation() );
1159
1160 toAdd = buildTopDownMergedConfiguration( toAdd, implementationConf );
1161 }
1162
1163 result.addChild( toAdd );
1164 }
1165 }
1166 }
1167 return result;
1168 }
1169
1170 private XmlPlexusConfiguration buildTopDownMergedConfiguration( PlexusConfiguration dominant,
1171 PlexusConfiguration recessive )
1172 {
1173 XmlPlexusConfiguration result = new XmlPlexusConfiguration( dominant.getName() );
1174
1175 String value = dominant.getValue( null );
1176
1177 if ( StringUtils.isEmpty( value ) && ( recessive != null ) )
1178 {
1179 value = recessive.getValue( null );
1180 }
1181
1182 if ( StringUtils.isNotEmpty( value ) )
1183 {
1184 result.setValue( value );
1185 }
1186
1187 String[] attributeNames = dominant.getAttributeNames();
1188
1189 for ( int i = 0; i < attributeNames.length; i++ )
1190 {
1191 String attributeValue = dominant.getAttribute( attributeNames[i], null );
1192
1193 result.setAttribute( attributeNames[i], attributeValue );
1194 }
1195
1196 if ( recessive != null )
1197 {
1198 attributeNames = recessive.getAttributeNames();
1199
1200 for ( int i = 0; i < attributeNames.length; i++ )
1201 {
1202 String attributeValue = recessive.getAttribute( attributeNames[i], null );
1203
1204 result.setAttribute( attributeNames[i], attributeValue );
1205 }
1206 }
1207
1208 PlexusConfiguration[] children = dominant.getChildren();
1209
1210 for ( int i = 0; i < children.length; i++ )
1211 {
1212 PlexusConfiguration childDom = children[i];
1213 PlexusConfiguration childRec = recessive == null ? null : recessive.getChild( childDom.getName(), false );
1214
1215 if ( childRec != null )
1216 {
1217 result.addChild( buildTopDownMergedConfiguration( childDom, childRec ) );
1218 }
1219 else
1220 {
1221 result.addChild( copyConfiguration( childDom ) );
1222 }
1223 }
1224
1225 return result;
1226 }
1227
1228 public static PlexusConfiguration copyConfiguration( PlexusConfiguration src )
1229 {
1230
1231 XmlPlexusConfiguration dom = new XmlPlexusConfiguration( src.getName() );
1232 dom.setValue( src.getValue( null ) );
1233
1234 String[] attributeNames = src.getAttributeNames();
1235 for ( int i = 0; i < attributeNames.length; i++ )
1236 {
1237 String attributeName = attributeNames[i];
1238 dom.setAttribute( attributeName, src.getAttribute( attributeName, null ) );
1239 }
1240
1241 PlexusConfiguration[] children = src.getChildren();
1242 for ( int i = 0; i < children.length; i++ )
1243 {
1244 dom.addChild( copyConfiguration( children[i] ) );
1245 }
1246
1247 return dom;
1248 }
1249
1250
1251
1252
1253
1254 private void populatePluginFields( Mojo plugin,
1255 MojoDescriptor mojoDescriptor,
1256 PlexusConfiguration configuration,
1257 PlexusContainer pluginContainer,
1258 ExpressionEvaluator expressionEvaluator )
1259 throws PluginConfigurationException
1260 {
1261 ComponentConfigurator configurator = null;
1262
1263 try
1264 {
1265 String configuratorId = mojoDescriptor.getComponentConfigurator();
1266
1267
1268
1269 if ( StringUtils.isNotEmpty( configuratorId ) )
1270 {
1271 configurator =
1272 (ComponentConfigurator) pluginContainer.lookup( ComponentConfigurator.ROLE, configuratorId );
1273 }
1274 else
1275 {
1276 configurator = (ComponentConfigurator) pluginContainer.lookup( ComponentConfigurator.ROLE );
1277 }
1278
1279 ConfigurationListener listener = new DebugConfigurationListener( getLogger() );
1280
1281 getLogger().debug( "Configuring mojo '" + mojoDescriptor.getId() + "' -->" );
1282 configurator.configureComponent( plugin, configuration, expressionEvaluator,
1283 pluginContainer.getContainerRealm(), listener );
1284 getLogger().debug( "-- end configuration --" );
1285 }
1286 catch ( ComponentConfigurationException e )
1287 {
1288 throw new PluginConfigurationException( mojoDescriptor.getPluginDescriptor(),
1289 "Unable to parse the created DOM for plugin configuration", e );
1290 }
1291 catch ( ComponentLookupException e )
1292 {
1293 throw new PluginConfigurationException( mojoDescriptor.getPluginDescriptor(),
1294 "Unable to retrieve component configurator for plugin configuration",
1295 e );
1296 }
1297 catch ( LinkageError e )
1298 {
1299 if ( getLogger().isFatalErrorEnabled() )
1300 {
1301 getLogger().fatalError(
1302 configurator.getClass().getName() + "#configureComponent(...) caused a linkage error ("
1303 + e.getClass().getName() + ") and may be out-of-date. Check the realms:" );
1304
1305 ClassRealm pluginRealm = mojoDescriptor.getPluginDescriptor().getClassRealm();
1306 StringBuffer sb = new StringBuffer();
1307 sb.append( "Plugin realm = " + pluginRealm.getId() ).append( '\n' );
1308 for ( int i = 0; i < pluginRealm.getConstituents().length; i++ )
1309 {
1310 sb.append( "urls[" + i + "] = " + pluginRealm.getConstituents()[i] );
1311 if ( i != ( pluginRealm.getConstituents().length - 1 ) )
1312 {
1313 sb.append( '\n' );
1314 }
1315 }
1316 getLogger().fatalError( sb.toString() );
1317
1318 ClassRealm containerRealm = container.getContainerRealm();
1319 sb = new StringBuffer();
1320 sb.append( "Container realm = " + containerRealm.getId() ).append( '\n' );
1321 for ( int i = 0; i < containerRealm.getConstituents().length; i++ )
1322 {
1323 sb.append( "urls[" + i + "] = " + containerRealm.getConstituents()[i] );
1324 if ( i != ( containerRealm.getConstituents().length - 1 ) )
1325 {
1326 sb.append( '\n' );
1327 }
1328 }
1329 getLogger().fatalError( sb.toString() );
1330 }
1331
1332 throw new PluginConfigurationException( mojoDescriptor.getPluginDescriptor(),
1333 e.getClass().getName() + ": " + e.getMessage(), e );
1334 }
1335 finally
1336 {
1337 if ( configurator != null )
1338 {
1339 try
1340 {
1341 pluginContainer.release( configurator );
1342 }
1343 catch ( ComponentLifecycleException e )
1344 {
1345 getLogger().debug( "Failed to release plugin container - ignoring." );
1346 }
1347 }
1348 }
1349 }
1350
1351 public static String createPluginParameterRequiredMessage( MojoDescriptor mojo,
1352 Parameter parameter,
1353 String expression )
1354 {
1355 StringBuffer message = new StringBuffer();
1356
1357 message.append( "The '" );
1358 message.append( parameter.getName() );
1359 message.append( "' parameter is required for the execution of the " );
1360 message.append( mojo.getFullGoalName() );
1361 message.append( " mojo and cannot be null." );
1362 if ( expression != null )
1363 {
1364 message.append( " The retrieval expression was: " ).append( expression );
1365 }
1366
1367 return message.toString();
1368 }
1369
1370
1371
1372
1373
1374 public void contextualize( Context context )
1375 throws ContextException
1376 {
1377 container = (PlexusContainer) context.get( PlexusConstants.PLEXUS_KEY );
1378
1379 mojoLogger = new DefaultLog( container.getLoggerManager().getLoggerForComponent( Mojo.ROLE ) );
1380 }
1381
1382 public void initialize()
1383 {
1384 artifactFilter = MavenArtifactFilterManager.createStandardFilter();
1385 }
1386
1387
1388
1389
1390
1391 private void resolveTransitiveDependencies( MavenSession context,
1392 ArtifactResolver artifactResolver,
1393 String scope,
1394 ArtifactFactory artifactFactory,
1395 MavenProject project, boolean isAggregator )
1396 throws ArtifactResolutionException, ArtifactNotFoundException, InvalidDependencyVersionException
1397 {
1398 ArtifactFilter filter = new ScopeArtifactFilter( scope );
1399
1400
1401 Artifact artifact = artifactFactory.createBuildArtifact( project.getGroupId(), project.getArtifactId(),
1402 project.getVersion(), project.getPackaging() );
1403
1404
1405
1406
1407 if ( project.getDependencyArtifacts() == null )
1408 {
1409 project.setDependencyArtifacts( project.createArtifacts( artifactFactory, null, null ) );
1410 }
1411
1412 Set resolvedArtifacts;
1413 try
1414 {
1415 ArtifactResolutionResult result = artifactResolver.resolveTransitively( project.getDependencyArtifacts(),
1416 artifact,
1417 project.getManagedVersionMap(),
1418 context.getLocalRepository(),
1419 project.getRemoteArtifactRepositories(),
1420 artifactMetadataSource, filter );
1421 resolvedArtifacts = result.getArtifacts();
1422 }
1423 catch (MultipleArtifactsNotFoundException me)
1424 {
1425
1426
1427
1428 if (isAggregator && checkMissingArtifactsInReactor( context.getSortedProjects(), me.getMissingArtifacts() ))
1429 {
1430 resolvedArtifacts = new HashSet(me.getResolvedArtifacts());
1431 }
1432 else
1433 {
1434
1435 throw me;
1436 }
1437 }
1438 project.setArtifacts( resolvedArtifacts );
1439 }
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450 private boolean checkMissingArtifactsInReactor(Collection projects, Collection missing)
1451 {
1452 Collection foundInReactor = new HashSet();
1453 Iterator iter = missing.iterator();
1454 while (iter.hasNext())
1455 {
1456 Artifact mArtifact = (Artifact) iter.next();
1457 Iterator pIter = projects.iterator();
1458 while (pIter.hasNext())
1459 {
1460 MavenProject p = (MavenProject) pIter.next();
1461 if (p.getArtifactId().equals( mArtifact.getArtifactId()) &&
1462 p.getGroupId().equals( mArtifact.getGroupId()) &&
1463 p.getVersion().equals( mArtifact.getVersion()))
1464 {
1465
1466
1467
1468 getLogger().warn( "The dependency: "+ p.getId()+" can't be resolved but has been found in the reactor.\nThis dependency has been excluded from the plugin execution. You should rerun this mojo after executing mvn install.\n" );
1469
1470
1471 foundInReactor.add( p );
1472 break;
1473 }
1474 }
1475 }
1476
1477
1478 return foundInReactor.size() == missing.size();
1479 }
1480
1481
1482
1483
1484
1485
1486 private void downloadDependencies( MavenProject project,
1487 MavenSession context,
1488 ArtifactResolver artifactResolver )
1489 throws ArtifactResolutionException, ArtifactNotFoundException
1490 {
1491 ArtifactRepository localRepository = context.getLocalRepository();
1492 List remoteArtifactRepositories = project.getRemoteArtifactRepositories();
1493
1494 for ( Iterator it = project.getArtifacts().iterator(); it.hasNext(); )
1495 {
1496 Artifact artifact = (Artifact) it.next();
1497
1498 artifactResolver.resolve( artifact, remoteArtifactRepositories, localRepository );
1499 }
1500 }
1501
1502 public Object getPluginComponent( Plugin plugin,
1503 String role,
1504 String roleHint )
1505 throws PluginManagerException, ComponentLookupException
1506 {
1507 PluginDescriptor pluginDescriptor = pluginCollector.getPluginDescriptor( plugin );
1508
1509 PlexusContainer pluginContainer = getPluginContainer( pluginDescriptor );
1510
1511 return pluginContainer.lookup( role, roleHint );
1512 }
1513
1514 public Map getPluginComponents( Plugin plugin,
1515 String role )
1516 throws ComponentLookupException, PluginManagerException
1517 {
1518 PluginDescriptor pluginDescriptor = pluginCollector.getPluginDescriptor( plugin );
1519
1520 PlexusContainer pluginContainer = getPluginContainer( pluginDescriptor );
1521
1522 return pluginContainer.lookupMap( role );
1523 }
1524 }