public T getConfiguredMojo()

in maven-core/src/main/java/org/apache/maven/plugin/internal/DefaultMavenPluginManager.java [469:609]
112 lines of code
19 McCabe index (conditional complexity)

    public <T> T getConfiguredMojo(Class<T> mojoInterface, MavenSession session, MojoExecution mojoExecution)
            throws PluginConfigurationException, PluginContainerException {
        MojoDescriptor mojoDescriptor = mojoExecution.getMojoDescriptor();

        PluginDescriptor pluginDescriptor = mojoDescriptor.getPluginDescriptor();

        ClassRealm pluginRealm = pluginDescriptor.getClassRealm();

        if (pluginRealm == null) {
            try {
                setupPluginRealm(pluginDescriptor, session, null, null, null);
            } catch (PluginResolutionException e) {
                String msg = "Cannot setup plugin realm [mojoDescriptor=" + mojoDescriptor.getId()
                        + ", pluginDescriptor=" + pluginDescriptor.getId() + "]";
                throw new PluginConfigurationException(pluginDescriptor, msg, e);
            }
            pluginRealm = pluginDescriptor.getClassRealm();
        }

        if (logger.isDebugEnabled()) {
            logger.debug("Loading 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 = container.setLookupRealm(pluginRealm);

        ClassLoader oldClassLoader = Thread.currentThread().getContextClassLoader();
        Thread.currentThread().setContextClassLoader(pluginRealm);

        try {
            T mojo;

            try {
                mojo = container.lookup(mojoInterface, mojoDescriptor.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 PrintStream(os);
                    ps.println("Unable to load the mojo '" + mojoDescriptor.getGoal() + "' in the plugin '"
                            + pluginDescriptor.getId() + "'. A required class is missing: "
                            + cause.getMessage());
                    pluginRealm.display(ps);

                    throw new PluginContainerException(mojoDescriptor, pluginRealm, os.toString(), cause);
                } else if (cause instanceof LinkageError) {
                    ByteArrayOutputStream os = new ByteArrayOutputStream(1024);
                    PrintStream ps = new PrintStream(os);
                    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.display(ps);

                    throw new PluginContainerException(mojoDescriptor, pluginRealm, os.toString(), cause);
                }

                throw new PluginContainerException(
                        mojoDescriptor,
                        pluginRealm,
                        "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<String, Object> pluginContext = session.getPluginContext(pluginDescriptor, project);

                if (pluginContext != null) {
                    pluginContext.put("project", project);

                    pluginContext.put("pluginDescriptor", pluginDescriptor);

                    ((ContextEnabled) mojo).setPluginContext(pluginContext);
                }
            }

            if (mojo instanceof Mojo) {
                Logger mojoLogger = LoggerFactory.getLogger(mojoDescriptor.getImplementation());
                ((Mojo) mojo).setLog(new MojoLogWrapper(mojoLogger));
            }

            if (mojo instanceof Contextualizable) {
                pluginValidationManager.reportPluginMojoValidationIssue(
                        PluginValidationManager.IssueLocality.EXTERNAL,
                        session,
                        mojoDescriptor,
                        mojo.getClass(),
                        "Mojo implements `Contextualizable` interface from Plexus Container, which is EOL.");
            }

            XmlNode dom = mojoExecution.getConfiguration() != null
                    ? mojoExecution.getConfiguration().getDom()
                    : null;

            PlexusConfiguration pomConfiguration;

            if (dom == null) {
                pomConfiguration = new DefaultPlexusConfiguration("configuration");
            } else {
                pomConfiguration = XmlPlexusConfiguration.toPlexusConfiguration(dom);
            }

            ExpressionEvaluator expressionEvaluator;
            if (mojoDescriptor.isV4Api()) {
                expressionEvaluator = new PluginParameterExpressionEvaluatorV4(
                        session.getSession(),
                        ((DefaultSession) session.getSession()).getProject(session.getCurrentProject()),
                        mojoExecution);
            } else {
                expressionEvaluator = new PluginParameterExpressionEvaluator(session, mojoExecution);
            }

            for (MavenPluginConfigurationValidator validator : configurationValidators) {
                validator.validate(session, mojoDescriptor, mojo.getClass(), pomConfiguration, expressionEvaluator);
            }

            populateMojoExecutionFields(
                    mojo,
                    mojoExecution.getExecutionId(),
                    mojoDescriptor,
                    pluginRealm,
                    pomConfiguration,
                    expressionEvaluator);

            return mojo;
        } finally {
            Thread.currentThread().setContextClassLoader(oldClassLoader);
            container.setLookupRealm(oldLookupRealm);
        }
    }