Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   
   package org.apache.maven.plugin;
   
   /*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you under the Apache License, Version 2.0 (the
   * "License"); you may not use this file except in compliance
   * with the License.  You may obtain a copy of the License at
   *
   *  http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * KIND, either express or implied.  See the License for the
   * specific language governing permissions and limitations
   * under the License.
   */
  
  import java.io.File;
  import java.net.URL;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
  
  public class DefaultPluginManager
     extends AbstractLogEnabled
 {
     protected PlexusContainer container;
 
 
     protected ArtifactFilter artifactFilter;
 
     private Log mojoLogger;
 
     private Map resolvedCoreArtifactFiles = new HashMap();
 
     // component requirements
     protected PathTranslator pathTranslator;
 
 
 
     protected ArtifactFactory artifactFactory;
 
     protected ArtifactResolver artifactResolver;
 
 
 
 
 
     // END component requirements
 
     public DefaultPluginManager()
     {
     }
 
     // ----------------------------------------------------------------------
     //
     // ----------------------------------------------------------------------
 
     {
         return .getPluginDescriptorForPrefixprefix );
     }
 
     public Plugin getPluginDefinitionForPrefixString prefix,
                                                 MavenSession session,
                                                 MavenProject project )
     {
         // TODO: since this is only used in the lifecycle executor, maybe it should be moved there? There is no other
         // use for the mapping manager in here
         return .getByPrefixprefixsession.getSettings().getPluginGroups(),
                                                  project.getPluginArtifactRepositories(),
                                                  session.getLocalRepository() );
     }
 
     public PluginDescriptor verifyPluginPlugin plugin,
                                           MavenProject project,
                                           Settings settings,
                                           ArtifactRepository localRepository )
     {
         // TODO: this should be possibly outside
         // All version-resolution logic has been moved to DefaultPluginVersionManager.
         if ( plugin.getVersion() == null )
         {
             String version = .resolvePluginVersionplugin.getGroupId(), plugin.getArtifactId(),
                                                                         projectsettingslocalRepository );
             plugin.setVersionversion );
         }
 
         return verifyVersionedPluginpluginprojectlocalRepository );
     }
 
     private PluginDescriptor verifyVersionedPluginPlugin plugin,
                                                     MavenProject project,
                                                     ArtifactRepository localRepository )
     {
         // TODO: this might result in an artifact "RELEASE" being resolved continuously
         // FIXME: need to find out how a plugin gets marked as 'installed'
         // and no ChildContainer exists. The check for that below fixes
         // the 'Can't find plexus container for plugin: xxx' error.
         try
         {
             VersionRange versionRange = VersionRange.createFromVersionSpecplugin.getVersion() );
 
             List remoteRepositories = new ArrayList();
             remoteRepositories.addAllproject.getPluginArtifactRepositories() );
             remoteRepositories.addAllproject.getRemoteArtifactRepositories() );
 
             checkRequiredMavenVersionpluginlocalRepositoryremoteRepositories );
 
             Artifact pluginArtifact =
                 .createPluginArtifactplugin.getGroupId(), plugin.getArtifactId(), versionRange );
 
             pluginArtifact = project.replaceWithActiveArtifactpluginArtifact );
 
             .resolvepluginArtifactproject.getPluginArtifactRepositories(), localRepository );
 
             PlexusContainer pluginContainer = .getChildContainerplugin.getKey() );
 
             File pluginFile = pluginArtifact.getFile();
 
             if ( !.isPluginInstalledplugin ) || ( pluginContainer == null ) )
             {
                 addPluginpluginpluginArtifactprojectlocalRepository );
             }
             else if ( pluginFile.lastModified() > pluginContainer.getCreationDate().getTime() )
             {
                 getLogger().info(
                     "Reloading plugin container for: " + plugin.getKey() + ". The plugin artifact has changed." );
 
                 pluginContainer.dispose();
 
                 .flushPluginDescriptorplugin );
 
                 addPluginpluginpluginArtifactprojectlocalRepository );
             }
 
             project.addPluginplugin );
         }
         catch ( ArtifactNotFoundException e )
         {
             String groupId = plugin.getGroupId();
             String artifactId = plugin.getArtifactId();
             String version = plugin.getVersion();
 
             if ( ( groupId == null ) || ( artifactId == null ) || ( version == null ) )
             {
                 throw new PluginNotFoundExceptione );
             }
             else if ( groupId.equalse.getGroupId() ) && artifactId.equalse.getArtifactId() ) &&
                 version.equalse.getVersion() ) && "maven-plugin".equalse.getType() ) )
             {
                 throw new PluginNotFoundExceptione );
             }
             else
             {
                 throw e;
             }
         }
 
         return .getPluginDescriptorplugin );
     }

    

Todo:
would be better to store this in the plugin descriptor, but then it won't be available to the version manager which executes before the plugin is instantiated
 
     private void checkRequiredMavenVersionPlugin plugin,
                                             ArtifactRepository localRepository,
                                             List remoteRepositories )
     {
         try
         {
             Artifact artifact = .createProjectArtifactplugin.getGroupId(), plugin.getArtifactId(),
                                                                        plugin.getVersion() );
             MavenProject project =
                 .buildFromRepositoryartifactremoteRepositorieslocalRepositoryfalse );
             // if we don't have the required Maven version, then ignore an update
             if ( ( project.getPrerequisites() != null ) && ( project.getPrerequisites().getMaven() != null ) )
             {
                 DefaultArtifactVersion requiredVersion =
                     new DefaultArtifactVersionproject.getPrerequisites().getMaven() );
                 if ( .getApplicationVersion().compareTorequiredVersion ) < 0 )
                 {
                     throw new PluginVersionResolutionExceptionplugin.getGroupId(), plugin.getArtifactId(),
                                                                 "Plugin requires Maven version " + requiredVersion );
                 }
             }
         }
         catch ( ProjectBuildingException e )
         {
             throw new InvalidPluginException(
                 "Unable to build project for plugin '" + plugin.getKey() + "': " + e.getMessage(), e );
         }
     }
 
     protected void addPluginPlugin plugin,
                               Artifact pluginArtifact,
                               MavenProject project,
                               ArtifactRepository localRepository )
     {
         PlexusContainer child;
 
         try
         {
             child = .createChildContainerplugin.getKey(),
                                                     Collections.singletonListpluginArtifact.getFile() ),
                                                     .,
                                                     Collections.singletonList ) );
             try
             {
                 child.getContainerRealm().importFrom"plexus.core""org.codehaus.plexus.util.xml.Xpp3Dom" );
                 child.getContainerRealm().importFrom"plexus.core""org.codehaus.plexus.util.xml.pull.XmlPullParser" );
                 child.getContainerRealm().importFrom"plexus.core""org.codehaus.plexus.util.xml.pull.XmlPullParserException" );
                 child.getContainerRealm().importFrom"plexus.core""org.codehaus.plexus.util.xml.pull.XmlSerializer" );
 
                 // MNG-2878
                 child.getContainerRealm().importFrom"plexus.core""/default-report.xml" );
             }
             catch ( NoSuchRealmException e )
             {
                 // won't happen
             }
         }
         catch ( PlexusContainerException e )
         {
             throw new PluginManagerException(
                 "Failed to create plugin container for plugin '" + plugin + "': " + e.getMessage(), e );
         }
 
         // this plugin's descriptor should have been discovered in the child creation, so we should be able to
         // circle around and set the artifacts and class realm
         PluginDescriptor addedPlugin = .getPluginDescriptorplugin );
 
         if ( addedPlugin == null )
         {
             throw new IllegalStateException"The plugin descriptor for the plugin " + plugin + " was not found."
                 + " Please verify that the plugin JAR " + pluginArtifact.getFile() + " is intact." );
         }
 
         addedPlugin.setClassRealmchild.getContainerRealm() );
 
         // we're only setting the plugin's artifact itself as the artifact list, to allow it to be retrieved
         // later when the plugin is first invoked. Retrieving this artifact will in turn allow us to
         // transitively resolve its dependencies, and add them to the plugin container...
         addedPlugin.setArtifacts( Collections.singletonListpluginArtifact ) );
 
         try
         {
             // the only Plugin instance which will have dependencies is the one specified in the project.
             // We need to look for a Plugin instance there, in case the instance we're using didn't come from
             // the project.
             Plugin projectPlugin = (Pluginproject.getBuild().getPluginsAsMap().getplugin.getKey() );
 
             if ( projectPlugin == null )
             {
                 projectPlugin = plugin;
             }
 
             Set artifacts = MavenMetadataSource.createArtifactsprojectPlugin.getDependencies(), null,
                                                                  nullproject );
 
 //            Set artifacts =
 //                MavenMetadataSource.createArtifacts( artifactFactory, plugin.getDependencies(), null, null, project );
 
             addedPlugin.setIntroducedDependencyArtifactsartifacts );
         }
         catch ( InvalidDependencyVersionException e )
         {
             throw new InvalidPluginException"Plugin '" + plugin + "' is invalid: " + e.getMessage(), e );
         }
     }
 
     // ----------------------------------------------------------------------
     // Mojo execution
     // ----------------------------------------------------------------------
 
     public void executeMojoMavenProject project,
                              MojoExecution mojoExecution,
                              MavenSession session )
     {
         MojoDescriptor mojoDescriptor = mojoExecution.getMojoDescriptor();
 
         // NOTE: I'm putting these checks in here, since this is the central point of access for
         // anything that wants to execute a mojo.
         if ( mojoDescriptor.isProjectRequired() && !session.isUsingPOMsFromFilesystem() )
         {
             throw new MojoExecutionException"Cannot execute mojo: " + mojoDescriptor.getGoal() +
                 ". It requires a project with an existing pom.xml, but the build is not using one." );
         }
 
         if ( mojoDescriptor.isOnlineRequired() && session.getSettings().isOffline() )
         {
             // TODO: Should we error out, or simply warn and skip??
             throw new MojoExecutionException"Mojo: " + mojoDescriptor.getGoal() +
                 " requires online mode for execution. Maven is currently offline." );
         }
 
         if ( mojoDescriptor.isDependencyResolutionRequired() != null )
         {
             Collection projects;
 
             if ( mojoDescriptor.isAggregator() )
             {
                 projects = session.getSortedProjects();
             }
             else
             {
                 projects = Collections.singletonproject );
             }
 
             for ( Iterator i = projects.iterator(); i.hasNext(); )
             {
                 MavenProject p = (MavenProjecti.next();
 
                 resolveTransitiveDependenciessession,
                                                mojoDescriptor.isDependencyResolutionRequired(), pmojoDescriptor.isAggregator() );
             }
 
             downloadDependenciesprojectsession );
         }
 
         String goalName = mojoDescriptor.getFullGoalName();
 
         Mojo plugin;
 
         PluginDescriptor pluginDescriptor = mojoDescriptor.getPluginDescriptor();
         String goalId = mojoDescriptor.getGoal();
         String groupId = pluginDescriptor.getGroupId();
         String artifactId = pluginDescriptor.getArtifactId();
         String executionId = mojoExecution.getExecutionId();
         Xpp3Dom dom = project.getGoalConfigurationgroupIdartifactIdexecutionIdgoalId );
         Xpp3Dom reportDom = project.getReportConfigurationgroupIdartifactIdexecutionId );
         dom = Xpp3Dom.mergeXpp3DomdomreportDom );
         if ( mojoExecution.getConfiguration() != null )
         {
             dom = Xpp3Dom.mergeXpp3DomdommojoExecution.getConfiguration() );
         }
 
         plugin = getConfiguredMojosessiondomprojectfalsemojoExecution );
 
         // Event monitoring.
         String event = .;
         EventDispatcher dispatcher = session.getEventDispatcher();
 
         String goalExecId = goalName;
 
         if ( mojoExecution.getExecutionId() != null )
         {
             goalExecId += " {execution: " + mojoExecution.getExecutionId() + "}";
         }
 
         dispatcher.dispatchStarteventgoalExecId );
 
         ClassLoader oldClassLoader = Thread.currentThread().getContextClassLoader();
 
         try
         {
             Thread.currentThread().setContextClassLoader(
                 mojoDescriptor.getPluginDescriptor().getClassRealm().getClassLoader() );
 
             plugin.execute();
 
             dispatcher.dispatchEndeventgoalExecId );
         }
         catch ( MojoExecutionException e )
         {
             session.getEventDispatcher().dispatchErroreventgoalExecIde );
 
             throw e;
         }
         catch ( MojoFailureException e )
         {
             session.getEventDispatcher().dispatchErroreventgoalExecIde );
 
             throw e;
         }
         catch ( LinkageError e )
         {
             if ( getLogger().isFatalErrorEnabled() )
             {
                 getLogger().fatalError(
                                         plugin.getClass().getName() + "#execute() caused a linkage error ("
                                             + e.getClass().getName() + ") and may be out-of-date. Check the realms:" );
 
                 ClassRealm pluginRealm = mojoDescriptor.getPluginDescriptor().getClassRealm();
                 StringBuffer sb = new StringBuffer();
                 sb.append"Plugin realm = " + pluginRealm.getId() ).append'\n' );
                 for ( int i = 0; i < pluginRealm.getConstituents().lengthi++ )
                 {
                     sb.append"urls[" + i + "] = " + pluginRealm.getConstituents()[i] );
                     if ( i != ( pluginRealm.getConstituents().length - 1 ) )
                     {
                         sb.append'\n' );
                     }
                 }
                 getLogger().fatalErrorsb.toString() );
 
                 ClassRealm containerRealm = .getContainerRealm();
                 sb = new StringBuffer();
                 sb.append"Container realm = " + containerRealm.getId() ).append'\n' );
                 for ( int i = 0; i < containerRealm.getConstituents().lengthi++ )
                 {
                     sb.append"urls[" + i + "] = " + containerRealm.getConstituents()[i] );
                     if ( i != ( containerRealm.getConstituents().length - 1 ) )
                     {
                         sb.append'\n' );
                     }
                 }
                 getLogger().fatalErrorsb.toString() );
             }
 
             session.getEventDispatcher().dispatchErroreventgoalExecIde );
 
             throw e;
         }
         finally
         {
 
             Thread.currentThread().setContextClassLoaderoldClassLoader );
 
             try
             {
                 PlexusContainer pluginContainer = getPluginContainermojoDescriptor.getPluginDescriptor() );
 
                 pluginContainer.releaseplugin );
             }
             catch ( ComponentLifecycleException e )
             {
                 if ( getLogger().isErrorEnabled() )
                 {
                     getLogger().error"Error releasing plugin - ignoring."e );
                 }
             }
         }
     }
 
     public MavenReport getReportMavenProject project,
                                   MojoExecution mojoExecution,
                                   MavenSession session )
     {
         MojoDescriptor mojoDescriptor = mojoExecution.getMojoDescriptor();
         PluginDescriptor descriptor = mojoDescriptor.getPluginDescriptor();
         Xpp3Dom dom = project.getReportConfigurationdescriptor.getGroupId(), descriptor.getArtifactId(),
                                                       mojoExecution.getExecutionId() );
         if ( mojoExecution.getConfiguration() != null )
         {
             dom = Xpp3Dom.mergeXpp3DomdommojoExecution.getConfiguration() );
         }
 
         return (MavenReportgetConfiguredMojosessiondomprojecttruemojoExecution );
     }
 
     public PluginDescriptor verifyReportPluginReportPlugin reportPlugin,
                                                 MavenProject project,
                                                 MavenSession session )
     {
         String version = reportPlugin.getVersion();
 
         if ( version == null )
         {
             version = .resolveReportPluginVersionreportPlugin.getGroupId(),
                                                                        reportPlugin.getArtifactId(), project,
                                                                        session.getSettings(),
                                                                        session.getLocalRepository() );
             reportPlugin.setVersionversion );
         }
 
         Plugin forLookup = new Plugin();
 
         forLookup.setGroupIdreportPlugin.getGroupId() );
         forLookup.setArtifactIdreportPlugin.getArtifactId() );
         forLookup.setVersionversion );
 
         return verifyVersionedPluginforLookupprojectsession.getLocalRepository() );
     }
 
     private PlexusContainer getPluginContainerPluginDescriptor pluginDescriptor )
         throws PluginManagerException
     {
         String pluginKey = pluginDescriptor.getPluginLookupKey();
 
         PlexusContainer pluginContainer = .getChildContainerpluginKey );
 
         if ( pluginContainer == null )
         {
             throw new PluginManagerException"Cannot find Plexus container for plugin: " + pluginKey );
         }
 
         return pluginContainer;
     }
 
     private Mojo getConfiguredMojoMavenSession session,
                                     Xpp3Dom dom,
                                     MavenProject project,
                                     boolean report,
                                     MojoExecution mojoExecution )
     {
         MojoDescriptor mojoDescriptor = mojoExecution.getMojoDescriptor();
 
         PluginDescriptor pluginDescriptor = mojoDescriptor.getPluginDescriptor();
 
         PlexusContainer pluginContainer = getPluginContainerpluginDescriptor );
 
         // if this is the first time this plugin has been used, the plugin's container will only
         // contain the plugin's artifact in isolation; we need to finish resolving the plugin's
         // dependencies, and add them to the container.
         ensurePluginContainerIsCompletepluginDescriptorpluginContainerprojectsession );
 
         Mojo plugin;
         try
         {
             plugin = (MojopluginContainer.lookup.mojoDescriptor.getRoleHint() );
             if ( report && !( plugin instanceof MavenReport ) )
             {
                 // TODO: the mojoDescriptor should actually capture this information so we don't get this far
                 return null;
             }
         }
         catch ( ComponentLookupException e )
         {
             throw new PluginManagerException"Unable to find the mojo '" + mojoDescriptor.getRoleHint() +
                 "' in the plugin '" + pluginDescriptor.getPluginLookupKey() + "'"e );
         }
 
         if ( plugin instanceof ContextEnabled )
         {
             Map pluginContext = session.getPluginContextpluginDescriptorproject );
 
             ( (ContextEnabledplugin ).setPluginContextpluginContext );
         }
 
         plugin.setLog );
 
         XmlPlexusConfiguration pomConfiguration;
         if ( dom == null )
         {
             pomConfiguration = new XmlPlexusConfiguration"configuration" );
         }
         else
         {
             pomConfiguration = new XmlPlexusConfigurationdom );
         }
 
         // Validate against non-editable (@readonly) parameters, to make sure users aren't trying to
         // override in the POM.
         validatePomConfigurationmojoDescriptorpomConfiguration );
 
         PlexusConfiguration mergedConfiguration = mergeMojoConfigurationpomConfigurationmojoDescriptor );
 
         // TODO: plexus changes to make this more like the component descriptor so this can be used instead
         //            PlexusConfiguration mergedConfiguration = mergeConfiguration( pomConfiguration,
         //                                                                          mojoDescriptor.getConfiguration() );
 
         ExpressionEvaluator expressionEvaluator = new PluginParameterExpressionEvaluatorsessionmojoExecution,
                                                                                           getLogger(),
                                                                                           project,
                                                                                           session.getExecutionProperties() );
 
         PlexusConfiguration extractedMojoConfiguration =
             extractMojoConfigurationmergedConfigurationmojoDescriptor );
 
         checkRequiredParametersmojoDescriptorextractedMojoConfigurationexpressionEvaluator );
 
         populatePluginFieldspluginmojoDescriptorextractedMojoConfigurationpluginContainer,
                               expressionEvaluator );
         return plugin;
     }
 
     private void ensurePluginContainerIsCompletePluginDescriptor pluginDescriptor,
                                                   PlexusContainer pluginContainer,
                                                   MavenProject project,
                                                   MavenSession session )
     {
         // if the plugin's already been used once, don't re-do this step...
         // otherwise, we have to finish resolving the plugin's classpath and start the container.
         if ( ( pluginDescriptor.getArtifacts() != null ) && ( pluginDescriptor.getArtifacts().size() == 1 ) )
         {
             Artifact pluginArtifact = (ArtifactpluginDescriptor.getArtifacts().get( 0 );
 
             ArtifactRepository localRepository = session.getLocalRepository();
 
             ResolutionGroup resolutionGroup;
             try
             {
                 resolutionGroup = .retrievepluginArtifactlocalRepository,
                                                                    project.getPluginArtifactRepositories() );
             }
             catch ( ArtifactMetadataRetrievalException e )
             {
                 throw new ArtifactResolutionException"Unable to download metadata from repository for plugin '" +
                     pluginArtifact.getId() + "': " + e.getMessage(), pluginArtifacte );
             }
 
             checkPlexusUtilsresolutionGroup );
 
             // [jdcasey; 20-March-2008]:
             // This is meant to eliminate the introduction of duplicated artifacts.
             // Since much of the reasoning for reversing the order of introduction of
             // plugin dependencies rests on the notion that we need to be able to
             // introduce upgraded versions of plugin dependencies on a case-by-case
             // basis, we need to remove the original version prior to artifact
             // resolution. This is consistent with recent thinking on duplicated
             // dependency specifications within a POM, where that case should
             // throw a model validation exception.
             //
             // Here, we just want to remove any chance that the ArtifactCollector
             // could make a bad choice, and use the old version in spite of our
             // explicit preference otherwise.
 
             // First, we're going to accumulate plugin dependencies in an ordered map,
             // keyed by dependencyConflictId (the ordered map is meant to preserve relative
             // ordering of the dependencies that do make the cut).
             Map dependencyMap = new LinkedHashMap();
 
             // Next, we need to accumulate all dependencies in a List, to make it
             // simpler to iterate through them all and add them to the map.
             List all = new ArrayList();
 
             // plugin-level dependencies from the consuming POM override dependencies
             // from the plugin's own POM.
             all.addAllpluginDescriptor.getIntroducedDependencyArtifacts() );
 
             // add in the deps from the plugin POM now.
             all.addAllresolutionGroup.getArtifacts() );
 
             for ( Iterator it = all.iterator(); it.hasNext(); )
             {
                 Artifact artifact = (Artifactit.next();
                 String conflictId = artifact.getDependencyConflictId();
 
                 // if the map already contains this dependencyConflictId, it constitutes an
                 // overridden dependency. Don't use the old one (we know it's old from the
                 // order in which dependencies were added to this list).
                 if ( !dependencyMap.containsKeyconflictId ) )
                 {
                     dependencyMap.putconflictIdartifact );
                 }
             }
 
             // Create an ordered set of dependencies from the ordered map we used above, to feed into the resolver.
             Set dependencies = new LinkedHashSetdependencyMap.values() );
 
             if ( getLogger().isDebugEnabled() )
             {
                 // list all dependencies to be used by this plugin (first-level deps, not transitive ones).
                 getLogger().debug"Plugin dependencies for:\n\n" + pluginDescriptor.getId()
                                    + "\n\nare:\n\n"
                                    + StringUtils.joindependencies.iterator(), "\n" ) + "\n\n" );
             }
 
             List repositories = new ArrayList();
             repositories.addAllresolutionGroup.getResolutionRepositories() );
             repositories.addAllproject.getRemoteArtifactRepositories() );
 
             /* get plugin managed versions */
             Map pluginManagedDependencies = new HashMap();
             try
             {
                 MavenProject pluginProject =
                     .buildFromRepositorypluginArtifactproject.getRemoteArtifactRepositories(),
                                                              localRepository );
                 if ( pluginProject != null )
                 {
                     pluginManagedDependencies = pluginProject.getManagedVersionMap();
                 }
             }
             catch ( ProjectBuildingException e )
             {
                 // this can't happen, it would have blowed up at artifactMetadataSource.retrieve()
             }
 
             ArtifactResolutionResult result = .resolveTransitivelydependenciespluginArtifact,
                                                                                     pluginManagedDependencies,
                                                                                     localRepositoryrepositories,
                                                                                     ,
                                                                                      );
 
             Set resolved = result.getArtifacts();
 
             for ( Iterator it = resolved.iterator(); it.hasNext(); )
             {
                 Artifact artifact = (Artifactit.next();
 
                 if ( !artifact.equalspluginArtifact ) )
                 {
                     artifact = project.replaceWithActiveArtifactartifact );
 
                     try
                     {
                         pluginContainer.addJarResourceartifact.getFile() );
                     }
                     catch ( PlexusContainerException e )
                     {
                         throw new PluginManagerException"Error adding plugin dependency '" +
                             artifact.getDependencyConflictId() + "' into plugin manager: " + e.getMessage(), e );
                     }
                 }
             }
 
             pluginDescriptor.setClassRealmpluginContainer.getContainerRealm() );
 
             List unresolved = new ArrayListdependencies );
 
             unresolved.removeAllresolved );
 
             if ( getLogger().isDebugEnabled() )
             {
                 // list all artifacts that were filtered out during the resolution process.
                 // these are already present in the core container.
                 getLogger().debug" The following artifacts were filtered out for plugin: "
                                    + pluginDescriptor.getId()
                                    + " because they're already in the core of Maven:\n\n"
                                    + StringUtils.joinunresolved.iterator(), "\n" )
                                    + "\n\nThese will use the artifact files already in the core ClassRealm instead, to allow them to be included in PluginDescriptor.getArtifacts().\n\n" );
             }
 
             // Grab a file for all filtered artifacts, even if it means resolving them. This
             // is necessary in order to present a full complement of a plugin's transitive
             // dependencies to anyone who calls PluginDescriptor.getArtifacts().
             resolveCoreArtifactsunresolvedlocalRepositoryresolutionGroup.getResolutionRepositories() );
 
             // Re-join resolved and filtered-but-now-resolved artifacts.
             // NOTE: The process of filtering then re-adding some artifacts will
             // result in different ordering within the PluginDescriptor.getArtifacts()
             // List than should have happened if none had been filtered. All filtered
             // artifacts will be listed last...
             List allResolved = new ArrayListresolved.size() + unresolved.size() );
 
             allResolved.addAllresolved );
             allResolved.addAllunresolved );
 
             pluginDescriptor.setArtifactsallResolved );
         }
     }
 
     public static void checkPlexusUtilsResolutionGroup resolutionGroupArtifactFactory artifactFactory )
     {
         // ----------------------------------------------------------------------------
         // If the plugin already declares a dependency on plexus-utils then we're all
         // set as the plugin author is aware of its use. If we don't have a dependency
         // on plexus-utils then we must protect users from stupid plugin authors who
         // did not declare a direct dependency on plexus-utils because the version
         // Maven uses is hidden from downstream use. We will also bump up any
         // anything below 1.1 to 1.1 as this mimics the behaviour in 2.0.5 where
         // plexus-utils 1.1 was being forced into use.
         // ----------------------------------------------------------------------------
 
         VersionRange vr = null;
 
         try
         {
             vr = VersionRange.createFromVersionSpec"[1.1,)" );
         }
         catch ( InvalidVersionSpecificationException e )
         {
             // Won't happen
         }
 
         boolean plexusUtilsPresent = false;
 
         for ( Iterator i = resolutionGroup.getArtifacts().iterator(); i.hasNext(); )
         {
             Artifact a = (Artifacti.next();
 
             if ( a.getArtifactId().equals"plexus-utils" ) &&
                 vr.containsVersionnew DefaultArtifactVersiona.getVersion() ) ) )
             {
                 plexusUtilsPresent = true;
 
                 break;
             }
         }
 
         if ( !plexusUtilsPresent )
         {
             // We will add plexus-utils as every plugin was getting this anyway from Maven itself. We will set the
             // version to the latest version we know that works as of the 2.0.6 release. We set the scope to runtime
             // as this is what's implicitly happening in 2.0.6.
 
             resolutionGroup.getArtifacts().addartifactFactory.createArtifact"org.codehaus.plexus",
                                                                                 "plexus-utils""1.1",
                                                                                 ."jar" ) );
         }
     }
 
     private void resolveCoreArtifactsList unresolved,
                                        ArtifactRepository localRepository,
                                        List resolutionRepositories )
     {
         for ( Iterator it = unresolved.iterator(); it.hasNext(); )
         {
             Artifact artifact = (Artifactit.next();
 
             File artifactFile = (File.getartifact.getId() );
 
             if ( artifactFile == null )
             {
                 String resource =
                     "/META-INF/maven/" + artifact.getGroupId() + "/" + artifact.getArtifactId() + "/pom.xml";
 
                 URL resourceUrl = .getContainerRealm().getResourceresource );
 
                 if ( resourceUrl == null )
                 {
                     .resolveartifactresolutionRepositorieslocalRepository );
 
                     artifactFile = artifact.getFile();
                 }
                 else
                 {
                     String artifactPath = resourceUrl.getPath();
 
                     if ( artifactPath.startsWith"file:" ) )
                     {
                         artifactPath = artifactPath.substring"file:".length() );
                     }
 
                     artifactPath = artifactPath.substring( 0, artifactPath.length() - resource.length() );
 
                     if ( artifactPath.endsWith"/" ) )
                     {
                         artifactPath = artifactPath.substring( 0, artifactPath.length() - 1 );
                     }
 
                     if ( artifactPath.endsWith"!" ) )
                     {
                         artifactPath = artifactPath.substring( 0, artifactPath.length() - 1 );
                     }
 
                     artifactFile = new FileartifactPath ).getAbsoluteFile();
                 }
 
                 .putartifact.getId(), artifactFile );
             }
 
             artifact.setFileartifactFile );
         }
     }
 
     private PlexusConfiguration extractMojoConfigurationPlexusConfiguration mergedConfiguration,
                                                           MojoDescriptor mojoDescriptor )
     {
         Map parameterMap = mojoDescriptor.getParameterMap();
 
         PlexusConfiguration[] mergedChildren = mergedConfiguration.getChildren();
 
         XmlPlexusConfiguration extractedConfiguration = new XmlPlexusConfiguration"configuration" );
 
         for ( int i = 0; i < mergedChildren.lengthi++ )
         {
             PlexusConfiguration child = mergedChildren[i];
 
             if ( parameterMap.containsKeychild.getName() ) )
             {
                 extractedConfiguration.addChildcopyConfigurationchild ) );
             }
             else
             {
                 // TODO: I defy anyone to find these messages in the '-X' output! Do we need a new log level?
                 // ideally, this would be elevated above the true debug output, but below the default INFO level...
                 // [BP] (2004-07-18): need to understand the context more but would prefer this could be either WARN or
                 // removed - shouldn't need DEBUG to diagnose a problem most of the time.
                 getLogger().debug"*** WARNING: Configuration \'" + child.getName() + "\' is not used in goal \'" +
                     mojoDescriptor.getFullGoalName() + "; this may indicate a typo... ***" );
             }
         }
 
         return extractedConfiguration;
     }
 
     private void checkRequiredParametersMojoDescriptor goal,
                                           PlexusConfiguration configuration,
                                           ExpressionEvaluator expressionEvaluator )
         throws PluginConfigurationException
     {
         // TODO: this should be built in to the configurator, as we presently double process the expressions
 
         List parameters = goal.getParameters();
 
         if ( parameters == null )
         {
             return;
         }
 
         List invalidParameters = new ArrayList();
 
         for ( int i = 0; i < parameters.size(); i++ )
         {
             Parameter parameter = (Parameterparameters.geti );
 
             if ( parameter.isRequired() )
             {
                 // the key for the configuration map we're building.
                 String key = parameter.getName();
 
                 Object fieldValue = null;
                 String expression = null;
                PlexusConfiguration value = configuration.getChildkeyfalse );
                try
                {
                    if ( value != null )
                    {
                        expression = value.getValuenull );
                        fieldValue = expressionEvaluator.evaluateexpression );
                        if ( fieldValue == null )
                        {
                            fieldValue = value.getAttribute"default-value"null );
                        }
                    }
                    if ( ( fieldValue == null ) && StringUtils.isNotEmptyparameter.getAlias() ) )
                    {
                        value = configuration.getChildparameter.getAlias(), false );
                        if ( value != null )
                        {
                            expression = value.getValuenull );
                            fieldValue = expressionEvaluator.evaluateexpression );
                            if ( fieldValue == null )
                            {
                                fieldValue = value.getAttribute"default-value"null );
                            }
                        }
                    }
                }
                catch ( ExpressionEvaluationException e )
                {
                    throw new PluginConfigurationExceptiongoal.getPluginDescriptor(), e.getMessage(), e );
                }
                // only mark as invalid if there are no child nodes
                if ( ( fieldValue == null ) && ( ( value == null ) || ( value.getChildCount() == 0 ) ) )
                {
                    parameter.setExpressionexpression );
                    invalidParameters.addparameter );
                }
            }
        }