Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.apache.maven.plugin.internal;
  
  /*
   * 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.io.Reader;
 import java.util.List;
 import java.util.Map;
 
Provides basic services to manage Maven plugins and their mojos. This component is kept general in its design such that the plugins/mojos can be used in arbitrary contexts. In particular, the mojos can be used for ordinary build plugins as well as special purpose plugins like reports.

Author(s):
Benjamin Bentmann
Since:
3.0
@Component( role = MavenPluginManager.class )
    implements MavenPluginManager
    private Logger logger;
    private LoggerManager loggerManager;
    private PlexusContainer container;
    public synchronized PluginDescriptor getPluginDescriptorPlugin pluginList<RemoteRepositoryrepositoriesRepositorySystemSession session )
    {
        PluginDescriptorCache.Key cacheKey = .createKeypluginrepositoriessession );
        PluginDescriptor pluginDescriptor = .getcacheKey );
        if ( pluginDescriptor == null )
        {
            org.eclipse.aether.artifact.Artifact artifact =
                .resolvepluginrepositoriessession );
            Artifact pluginArtifact = RepositoryUtils.toArtifactartifact );
            pluginDescriptor = extractPluginDescriptorpluginArtifactplugin );
            pluginDescriptor.setRequiredMavenVersionartifact.getProperty"requiredMavenVersion"null ) );
            .putcacheKeypluginDescriptor );
        }
        pluginDescriptor.setPluginplugin );
        return pluginDescriptor;
    }
    private PluginDescriptor extractPluginDescriptorArtifact pluginArtifactPlugin plugin )
    {
        PluginDescriptor pluginDescriptor = null;
        File pluginFile = pluginArtifact.getFile();
        try
        {
            if ( pluginFile.isFile() )
            {
                JarFile pluginJar = new JarFilepluginFilefalse );
                try
                {
                    ZipEntry pluginDescriptorEntry = pluginJar.getEntrygetPluginDescriptorLocation() );
                    if ( pluginDescriptorEntry != null )
                    {
                        InputStream is = pluginJar.getInputStreampluginDescriptorEntry );
                        pluginDescriptor = parsePluginDescriptorispluginpluginFile.getAbsolutePath() );
                    }
                }
                finally
                {
                    pluginJar.close();
                }
            }
            else
            {
                File pluginXml = new FilepluginFilegetPluginDescriptorLocation() );
                if ( pluginXml.isFile() )
                {
                    InputStream is = new BufferedInputStreamnew FileInputStreampluginXml ) );
                    try
                    {
                        pluginDescriptor = parsePluginDescriptorispluginpluginXml.getAbsolutePath() );
                    }
                    finally
                    {
                        IOUtil.closeis );
                    }
                }
            }
            if ( pluginDescriptor == null )
            {
                throw new IOException"No plugin descriptor found at " + getPluginDescriptorLocation() );
            }
        }
        catch ( IOException e )
        {
            throw new PluginDescriptorParsingExceptionpluginpluginFile.getAbsolutePath(), e );
        }
        MavenPluginValidator validator = new MavenPluginValidatorpluginArtifact );
        validator.validatepluginDescriptor );
        if ( validator.hasErrors() )
        {
            throw new InvalidPluginDescriptorException"Invalid plugin descriptor for " + plugin.getId() + " ("
                + pluginFile + ")"validator.getErrors() );
        }
        pluginDescriptor.setPluginArtifactpluginArtifact );
        return pluginDescriptor;
    }
    {
        return "META-INF/maven/plugin.xml";
    }
    private PluginDescriptor parsePluginDescriptorInputStream isPlugin pluginString descriptorLocation )
        throws PluginDescriptorParsingException
    {
        try
        {
            Reader reader = ReaderFactory.newXmlReaderis );
            PluginDescriptor pluginDescriptor = .buildreaderdescriptorLocation );
            return pluginDescriptor;
        }
        catch ( IOException e )
        {
            throw new PluginDescriptorParsingExceptionplugindescriptorLocatione );
        }
        catch ( PlexusConfigurationException e )
        {
            throw new PluginDescriptorParsingExceptionplugindescriptorLocatione );
        }
    }
    public MojoDescriptor getMojoDescriptorPlugin pluginString goalList<RemoteRepositoryrepositories,
                                             RepositorySystemSession session )
    {
        PluginDescriptor pluginDescriptor = getPluginDescriptorpluginrepositoriessession );
        MojoDescriptor mojoDescriptor = pluginDescriptor.getMojogoal );
        if ( mojoDescriptor == null )
        {
            throw new MojoNotFoundExceptiongoalpluginDescriptor );
        }
        return mojoDescriptor;
    }
    public void checkRequiredMavenVersionPluginDescriptor pluginDescriptor )
        throws PluginIncompatibleException
    {
        String requiredMavenVersion = pluginDescriptor.getRequiredMavenVersion();
        if ( StringUtils.isNotBlankrequiredMavenVersion ) )
        {
            try
            {
                if ( !.isMavenVersionrequiredMavenVersion ) )
                {
                    throw new PluginIncompatibleExceptionpluginDescriptor.getPlugin(), "The plugin "
                        + pluginDescriptor.getId() + " requires Maven version " + requiredMavenVersion );
                }
            }
            catch ( RuntimeException e )
            {
                .warn"Could not verify plugin's Maven prerequisite: " + e.getMessage() );
            }
        }
    }
    public synchronized void setupPluginRealmPluginDescriptor pluginDescriptorMavenSession session,
                                               ClassLoader parentList<StringimportsDependencyFilter filter )
    {
        Plugin plugin = pluginDescriptor.getPlugin();
        MavenProject project = session.getCurrentProject();
        Map<StringClassLoaderforeignImports = calcImportsprojectparentimports );
        PluginRealmCache.Key cacheKey =
            .createKeypluginparentforeignImportsfilterproject.getRemotePluginRepositories(),
                                        session.getRepositorySession() );
        PluginRealmCache.CacheRecord cacheRecord = .getcacheKey );
        if ( cacheRecord != null )
        {
            pluginDescriptor.setClassRealmcacheRecord.realm );
            pluginDescriptor.setArtifactsnew ArrayList<Artifact>( cacheRecord.artifacts ) );
            for ( ComponentDescriptor<?> componentDescriptor : pluginDescriptor.getComponents() )
            {
                componentDescriptor.setRealmcacheRecord.realm );
            }
        }
        else
        {
            createPluginRealmpluginDescriptorsessionparentforeignImportsfilter );
            cacheRecord =
                .putcacheKeypluginDescriptor.getClassRealm(), pluginDescriptor.getArtifacts() );
        }
        .registerprojectcacheRecord );
    }
    private void createPluginRealmPluginDescriptor pluginDescriptorMavenSession sessionClassLoader parent,
                                    Map<StringClassLoaderforeignImportsDependencyFilter filter )
    {
        Plugin plugin = pluginDescriptor.getPlugin();
        if ( plugin == null )
        {
            throw new IllegalArgumentException"incomplete plugin descriptor, plugin missing" );
        }
        Artifact pluginArtifact = pluginDescriptor.getPluginArtifact();
        if ( pluginArtifact == null )
        {
            throw new IllegalArgumentException"incomplete plugin descriptor, plugin artifact missing" );
        }
        MavenProject project = session.getCurrentProject();
        DependencyFilter dependencyFilter = project.getExtensionDependencyFilter();
        dependencyFilter = AndDependencyFilter.newInstancedependencyFilterfilter );
        DependencyNode root =
            .resolveplugin, RepositoryUtils.toArtifactpluginArtifact ), dependencyFilter,
                                                project.getRemotePluginRepositories(), session.getRepositorySession() );
        root.acceptnlg );
        List<ArtifactexposedPluginArtifacts = new ArrayList<Artifact>( nlg.getNodes().size() );
        RepositoryUtils.toArtifactsexposedPluginArtifacts, Collections.singletonroot ),
                                     Collections.<StringemptyList(), null );
        for ( Iterator<Artifactit = exposedPluginArtifacts.iterator(); it.hasNext(); )
        {
            Artifact artifact = it.next();
            if ( artifact.getFile() == null )
            {
                it.remove();
            }
        }
        List<org.eclipse.aether.artifact.ArtifactpluginArtifacts = nlg.getArtifactstrue );
        ClassRealm pluginRealm =
            .createPluginRealmpluginparentnullforeignImportspluginArtifacts );
        pluginDescriptor.setClassRealmpluginRealm );
        pluginDescriptor.setArtifactsexposedPluginArtifacts );
        try
        {
            for ( ComponentDescriptor<?> componentDescriptor : pluginDescriptor.getComponents() )
            {
                componentDescriptor.setRealmpluginRealm );
                .addComponentDescriptorcomponentDescriptor );
            }
            .discoverComponentspluginRealm );
        }
        catch ( PlexusConfigurationException e )
        {
            throw new PluginContainerExceptionpluginpluginRealm"Error in component graph of plugin "
                + plugin.getId() + ": " + e.getMessage(), e );
        }
        catch ( CycleDetectedInComponentGraphException e )
        {
            throw new PluginContainerExceptionpluginpluginRealm"Error in component graph of plugin "
                + plugin.getId() + ": " + e.getMessage(), e );
        }
    }
    private Map<StringClassLoadercalcImportsMavenProject projectClassLoader parentList<Stringimports )
    {
        Map<StringClassLoaderforeignImports = new HashMap<StringClassLoader>();
        ClassLoader projectRealm = project.getClassRealm();
        if ( projectRealm != null )
        {
            foreignImports.put""projectRealm );
        }
        else
        {
            foreignImports.put"".getMavenApiRealm() );
        }
        if ( parent != null && imports != null )
        {
            for ( String parentImport : imports )
            {
                foreignImports.putparentImportparent );
            }
        }
        return foreignImports;
    }
    public <T> T getConfiguredMojoClass<T> mojoInterfaceMavenSession sessionMojoExecution mojoExecution )
    {
        MojoDescriptor mojoDescriptor = mojoExecution.getMojoDescriptor();
        PluginDescriptor pluginDescriptor = mojoDescriptor.getPluginDescriptor();
        ClassRealm pluginRealm = pluginDescriptor.getClassRealm();
        if ( .isDebugEnabled() )
        {
            .debug"Configuring mojo " + mojoDescriptor.getId() + " from plugin realm " + pluginRealm );
        }
        // We are forcing the use of the plugin realm for all lookups that might occur during
        // the lifecycle that is part of the lookup. Here we are specifically trying to keep
        // lookups that occur in contextualize calls in line with the right realm.
        ClassRealm oldLookupRealm = .setLookupRealmpluginRealm );
        ClassLoader oldClassLoader = Thread.currentThread().getContextClassLoader();
        Thread.currentThread().setContextClassLoaderpluginRealm );
        try
        {
            T mojo;
            try
            {
                mojo = .lookupmojoInterfacemojoDescriptor.getRoleHint() );
            }
            catch ( ComponentLookupException e )
            {
                Throwable cause = e.getCause();
                while ( cause != null && !( cause instanceof LinkageError )
                    && !( cause instanceof ClassNotFoundException ) )
                {
                    cause = cause.getCause();
                }
                if ( ( cause instanceof NoClassDefFoundError ) || ( cause instanceof ClassNotFoundException ) )
                {
                    ByteArrayOutputStream os = new ByteArrayOutputStream( 1024 );
                    PrintStream ps = new PrintStreamos );
                    ps.println"Unable to load the mojo '" + mojoDescriptor.getGoal() + "' in the plugin '"
                        + pluginDescriptor.getId() + "'. A required class is missing: " + cause.getMessage() );
                    pluginRealm.displayps );
                    throw new PluginContainerExceptionmojoDescriptorpluginRealmos.toString(), cause );
                }
                else if ( cause instanceof LinkageError )
                {
                    ByteArrayOutputStream os = new ByteArrayOutputStream( 1024 );
                    PrintStream ps = new PrintStreamos );
                    ps.println"Unable to load the mojo '" + mojoDescriptor.getGoal() + "' in the plugin '"
                        + pluginDescriptor.getId() + "' due to an API incompatibility: " + e.getClass().getName()
                        + ": " + cause.getMessage() );
                    pluginRealm.displayps );
                    throw new PluginContainerExceptionmojoDescriptorpluginRealmos.toString(), cause );
                }
                throw new PluginContainerExceptionmojoDescriptorpluginRealm"Unable to load the mojo '"
                    + mojoDescriptor.getGoal() + "' (or one of its required components) from the plugin '"
                    + pluginDescriptor.getId() + "'"e );
            }
            if ( mojo instanceof ContextEnabled )
            {
                MavenProject project = session.getCurrentProject();
                Map<StringObjectpluginContext = session.getPluginContextpluginDescriptorproject );
                if ( pluginContext != null )
                {
                    pluginContext.put"project"project );
                    pluginContext.put"pluginDescriptor"pluginDescriptor );
                    ( (ContextEnabledmojo ).setPluginContextpluginContext );
                }
            }
            if ( mojo instanceof Mojo )
            {
                Logger mojoLogger = .getLoggerForComponentmojoDescriptor.getImplementation() );
                ( (Mojomojo ).setLognew DefaultLogmojoLogger ) );
            }
            Xpp3Dom dom = mojoExecution.getConfiguration();
            PlexusConfiguration pomConfiguration;
            if ( dom == null )
            {
                pomConfiguration = new XmlPlexusConfiguration"configuration" );
            }
            else
            {
                pomConfiguration = new XmlPlexusConfigurationdom );
            }
            ExpressionEvaluator expressionEvaluator = new PluginParameterExpressionEvaluatorsessionmojoExecution );
            populatePluginFieldsmojomojoDescriptorpluginRealmpomConfigurationexpressionEvaluator );
            return mojo;
        }
        finally
        {
            Thread.currentThread().setContextClassLoaderoldClassLoader );
            .setLookupRealmoldLookupRealm );
        }
    }
    private void populatePluginFieldsObject mojoMojoDescriptor mojoDescriptorClassRealm pluginRealm,
                                       PlexusConfiguration configurationExpressionEvaluator expressionEvaluator )
        throws PluginConfigurationException
    {
        ComponentConfigurator configurator = null;
        String configuratorId = mojoDescriptor.getComponentConfigurator();
        if ( StringUtils.isEmptyconfiguratorId ) )
        {
            configuratorId = "basic";
        }
        try
        {
            // TODO: could the configuration be passed to lookup and the configurator known to plexus via the descriptor
            // so that this method could entirely be handled by a plexus lookup?
            configurator = .lookupComponentConfigurator.classconfiguratorId );
            ConfigurationListener listener = new DebugConfigurationListener );
            ValidatingConfigurationListener validator =
                new ValidatingConfigurationListenermojomojoDescriptorlistener );
            .debug"Configuring mojo '" + mojoDescriptor.getId() + "' with " + configuratorId
                + " configurator -->" );
            configurator.configureComponentmojoconfigurationexpressionEvaluatorpluginRealmvalidator );
            .debug"-- end configuration --" );
            Collection<ParametermissingParameters = validator.getMissingParameters();
            if ( !missingParameters.isEmpty() )
            {
                if ( "basic".equalsconfiguratorId ) )
                {
                    throw new PluginParameterExceptionmojoDescriptornew ArrayList<Parameter>( missingParameters ) );
                }
                else
                {
                    /*
                     * NOTE: Other configurators like the map-oriented one don't call into the listener, so do it the
                     * hard way.
                     */
                    validateParametersmojoDescriptorconfigurationexpressionEvaluator );
                }
            }
        }
        catch ( ComponentConfigurationException e )
        {
            String message = "Unable to parse configuration of mojo " + mojoDescriptor.getId();
            if ( e.getFailedConfiguration() != null )
            {
                message += " for parameter " + e.getFailedConfiguration().getName();
            }
            message += ": " + e.getMessage();
            throw new PluginConfigurationExceptionmojoDescriptor.getPluginDescriptor(), messagee );
        }
        catch ( ComponentLookupException e )
        {
            throw new PluginConfigurationExceptionmojoDescriptor.getPluginDescriptor(),
                                                    "Unable to retrieve component configurator " + configuratorId
                                                        + " for configuration of mojo " + mojoDescriptor.getId(), e );
        }
        catch ( NoClassDefFoundError e )
        {
            ByteArrayOutputStream os = new ByteArrayOutputStream( 1024 );
            PrintStream ps = new PrintStreamos );
            ps.println"A required class was missing during configuration of mojo " + mojoDescriptor.getId() + ": "
                + e.getMessage() );
            pluginRealm.displayps );
            throw new PluginConfigurationExceptionmojoDescriptor.getPluginDescriptor(), os.toString(), e );
        }
        catch ( LinkageError e )
        {
            ByteArrayOutputStream os = new ByteArrayOutputStream( 1024 );
            PrintStream ps = new PrintStreamos );
            ps.println"An API incompatibility was encountered during configuration of mojo " + mojoDescriptor.getId()
                + ": " + e.getClass().getName() + ": " + e.getMessage() );
            pluginRealm.displayps );
            throw new PluginConfigurationExceptionmojoDescriptor.getPluginDescriptor(), os.toString(), e );
        }
        finally
        {
            if ( configurator != null )
            {
                try
                {
                    .releaseconfigurator );
                }
                catch ( ComponentLifecycleException e )
                {
                    .debug"Failed to release mojo configurator - ignoring." );
                }
            }
        }
    }
    private void validateParametersMojoDescriptor mojoDescriptorPlexusConfiguration configuration,
                                     ExpressionEvaluator expressionEvaluator )
    {
        if ( mojoDescriptor.getParameters() == null )
        {
            return;
        }
        List<ParameterinvalidParameters = new ArrayList<Parameter>();
        for ( Parameter parameter : mojoDescriptor.getParameters() )
        {
            if ( !parameter.isRequired() )
            {
                continue;
            }
            Object value = null;
            PlexusConfiguration config = configuration.getChildparameter.getName(), false );
            if ( config != null )
            {
                String expression = config.getValuenull );
                try
                {
                    value = expressionEvaluator.evaluateexpression );
                    if ( value == null )
                    {
                        value = config.getAttribute"default-value"null );
                    }
                }
                catch ( ExpressionEvaluationException e )
                {
                    String msg =
                        "Error evaluating the expression '" + expression + "' for configuration value '"
                            + configuration.getName() + "'";
                    throw new ComponentConfigurationExceptionconfigurationmsge );
                }
            }
            if ( value == null && ( config == null || config.getChildCount() <= 0 ) )
            {
                invalidParameters.addparameter );
            }
        }
        if ( !invalidParameters.isEmpty() )
        {
            throw new PluginParameterExceptionmojoDescriptorinvalidParameters );
        }
    }
    public void releaseMojoObject mojoMojoExecution mojoExecution )
    {
        if ( mojo != null )
        {
            try
            {
                .releasemojo );
            }
            catch ( ComponentLifecycleException e )
            {
                String goalExecId = mojoExecution.getGoal();
                if ( mojoExecution.getExecutionId() != null )
                {
                    goalExecId += " {execution: " + mojoExecution.getExecutionId() + "}";
                }
                .debug"Error releasing mojo for " + goalExecIde );
            }
        }
    }
New to GrepCode? Check out our FAQ X