Example usage for org.apache.maven.project ProjectBuildingRequest setProcessPlugins

List of usage examples for org.apache.maven.project ProjectBuildingRequest setProcessPlugins

  1. HOME
  2. Java
  3. org.apache.maven
  4. org.apache.maven.project.*
  5. ProjectBuildingRequest
  6. setProcessPlugins

Introduction

In this page you can find the example usage for org.apache.maven.project ProjectBuildingRequest setProcessPlugins.

Prototype

ProjectBuildingRequest setProcessPlugins(boolean processPlugins);

Source Link

Usage

From source file:hudson.maven.MavenEmbedder.java

License:Apache License

public List<ProjectBuildingResult> buildProjects(File mavenProject, boolean recursive)
        throws ProjectBuildingException, MavenEmbedderException {
    ClassLoader originalCl = Thread.currentThread().getContextClassLoader();
    try {// w  w w.  j  a va  2  s .  com
        Thread.currentThread().setContextClassLoader(this.plexusContainer.getContainerRealm());
        ProjectBuilder projectBuilder = lookup(ProjectBuilder.class);
        ProjectBuildingRequest projectBuildingRequest = this.mavenExecutionRequest.getProjectBuildingRequest();

        projectBuildingRequest.setValidationLevel(this.mavenRequest.getValidationLevel());

        RepositorySystemSession repositorySystemSession = buildRepositorySystemSession();

        projectBuildingRequest.setRepositorySession(repositorySystemSession);

        projectBuildingRequest.setProcessPlugins(this.mavenRequest.isProcessPlugins());

        projectBuildingRequest.setResolveDependencies(this.mavenRequest.isResolveDependencies());

        List<ProjectBuildingResult> results = projectBuilder.build(Arrays.asList(mavenProject), recursive,
                projectBuildingRequest);

        return results;
    } catch (ComponentLookupException e) {
        throw new MavenEmbedderException(e.getMessage(), e);
    } finally {
        Thread.currentThread().setContextClassLoader(originalCl);
    }

}

From source file:io.airlift.resolver.ArtifactResolver.java

License:Apache License

public List<Artifact> resolvePom(File pomFile) {
    if (pomFile == null) {
        throw new RuntimeException("pomFile is null");
    }//ww w. j  a  va  2  s .c o m

    MavenProject pom;
    try {
        PlexusContainer container = container();
        org.apache.maven.repository.RepositorySystem lrs = container
                .lookup(org.apache.maven.repository.RepositorySystem.class);
        ProjectBuilder projectBuilder = container.lookup(ProjectBuilder.class);
        ProjectBuildingRequest request = new DefaultProjectBuildingRequest();
        request.setSystemProperties(requiredSystemProperties());
        request.setRepositorySession(repositorySystemSession);
        request.setProcessPlugins(false);
        request.setLocalRepository(lrs.createDefaultLocalRepository());
        request.setRemoteRepositories(
                Arrays.asList(new ArtifactRepository[] { lrs.createDefaultRemoteRepository() }.clone()));
        ProjectBuildingResult result = projectBuilder.build(pomFile, request);
        pom = result.getProject();
    } catch (Exception e) {
        if (e instanceof RuntimeException) {
            throw (RuntimeException) e;
        }
        throw new RuntimeException("Error loading pom: " + pomFile.getAbsolutePath(), e);
    }

    Artifact rootArtifact = new DefaultArtifact(pom.getArtifact().getGroupId(),
            pom.getArtifact().getArtifactId(), pom.getArtifact().getClassifier(), pom.getArtifact().getType(),
            pom.getArtifact().getVersion(), null, new File(pom.getModel().getBuild().getOutputDirectory()));

    CollectRequest collectRequest = new CollectRequest();
    for (org.apache.maven.model.Dependency dependency : pom.getDependencies()) {
        collectRequest.addDependency(toAetherDependency(dependency));
    }
    for (RemoteRepository repository : pom.getRemoteProjectRepositories()) {
        collectRequest.addRepository(repository);
    }
    for (RemoteRepository repository : repositories) {
        collectRequest.addRepository(repository);
    }

    // Make sure we account for managed dependencies
    if (pom.getDependencyManagement() != null) {
        for (org.apache.maven.model.Dependency managedDependency : pom.getDependencyManagement()
                .getDependencies()) {
            collectRequest.addManagedDependency(toAetherDependency(managedDependency));
        }
    }

    DependencyRequest dependencyRequest = new DependencyRequest(collectRequest,
            DependencyFilterUtils.classpathFilter(JavaScopes.RUNTIME));
    List<Artifact> artifacts = resolveArtifacts(dependencyRequest);
    return ImmutableList.<Artifact>builder().add(rootArtifact).addAll(artifacts).build();
}

From source file:net.oneandone.maven.embedded.Maven.java

License:Apache License

public MavenProject loadPom(FileNode file, boolean resolve, Properties userProperties, List<String> profiles,
        List<Dependency> dependencies) throws RepositoryException, ProjectBuildingException {
    ProjectBuildingRequest request;
    ProjectBuildingResult result;/* ww w .  ja v a  2  s  .co  m*/
    List<Exception> problems;

    request = new DefaultProjectBuildingRequest();
    request.setRepositorySession(repositorySession);
    request.setRemoteRepositories(remoteLegacy);
    request.setProcessPlugins(false);
    request.setValidationLevel(ModelBuildingRequest.VALIDATION_LEVEL_MINIMAL);
    request.setSystemProperties(System.getProperties());
    if (userProperties != null) {
        request.setUserProperties(userProperties);
    }
    // If you don't turn this into RepositoryMerging.REQUEST_DOMINANT the dependencies will be resolved against Maven Central
    // and not against the configured repositories. The default of the DefaultProjectBuildingRequest is
    // RepositoryMerging.POM_DOMINANT.
    request.setRepositoryMerging(ProjectBuildingRequest.RepositoryMerging.REQUEST_DOMINANT);
    request.setResolveDependencies(resolve);
    if (profiles != null) {
        request.setActiveProfileIds(profiles);
    }
    result = builder.build(file.toPath().toFile(), request);

    // TODO: i've seen these collection errors for a dependency with ranges. Why does Aether NOT throw an exception in this case?
    if (result.getDependencyResolutionResult() != null) {
        problems = result.getDependencyResolutionResult().getCollectionErrors();
        if (problems != null && !problems.isEmpty()) {
            throw new RepositoryException("collection errors: " + problems.toString(), problems.get(0));
        }
    }

    if (dependencies != null) {
        if (!resolve) {
            throw new IllegalArgumentException();
        }
        dependencies.addAll(result.getDependencyResolutionResult().getDependencies());
    }
    return result.getProject();
}

From source file:net.oneandone.maven.plugins.prerelease.util.Maven.java

License:Apache License

public MavenProject loadPom(FileNode file) throws ProjectBuildingException {
    ProjectBuildingRequest request;
    ProjectBuildingResult result;//from w w  w  . j  a  va  2 s .  com

    // session initializes the repository session in the build request
    request = new DefaultProjectBuildingRequest(parentSession.getProjectBuildingRequest());
    request.setRemoteRepositories(remoteRepositories);
    request.setProcessPlugins(false);
    request.setValidationLevel(ModelBuildingRequest.VALIDATION_LEVEL_MINIMAL);
    request.setSystemProperties(System.getProperties());
    //If you don't turn this into RepositoryMerging.REQUEST_DOMINANT the dependencies will be resolved against Maven Central
    //and not against the configured repositories. The default of the DefaultProjectBuildingRequest is
    // RepositoryMerging.POM_DOMINANT.
    request.setRepositoryMerging(ProjectBuildingRequest.RepositoryMerging.REQUEST_DOMINANT);
    request.setResolveDependencies(false);
    result = builder.build(file.toPath().toFile(), request);
    return result.getProject();
}

From source file:org.appformer.maven.integration.embedder.MavenEmbedder.java

License:Apache License

private ProjectBuildingRequest getProjectBuildingRequest() throws ComponentLookupException {
    ProjectBuildingRequest projectBuildingRequest = this.mavenExecutionRequest.getProjectBuildingRequest();
    projectBuildingRequest.setValidationLevel(this.mavenRequest.getValidationLevel());
    RepositorySystemSession repositorySystemSession = componentProvider
            .getRepositorySystemSession(mavenExecutionRequest);
    projectBuildingRequest.setRepositorySession(repositorySystemSession);
    projectBuildingRequest.setProcessPlugins(this.mavenRequest.isProcessPlugins());
    projectBuildingRequest.setResolveDependencies(this.mavenRequest.isResolveDependencies());
    return projectBuildingRequest;
}

From source file:org.commonjava.emb.project.ProjectToolsSessionInjector.java

License:Apache License

public synchronized ProjectBuildingRequest getProjectBuildingRequest(final ProjectToolsSession session)
        throws ProjectToolsException {
    ProjectBuildingRequest pbr = session.getProjectBuildingRequest();
    try {/* w w w.j av  a  2 s .c o  m*/
        if (pbr == null) {
            pbr = emb.serviceManager().createProjectBuildingRequest();

            pbr.setProcessPlugins(false);
            pbr.setResolveDependencies(false);
            pbr.setSystemProperties(System.getProperties());
            pbr.setInactiveProfileIds(new ArrayList<String>());
            pbr.setRepositoryMerging(ProjectBuildingRequest.RepositoryMerging.REQUEST_DOMINANT);

            final RepositorySystemSession rss = getRepositorySystemSession(session);
            pbr.setRepositorySession(rss);
            pbr.setLocalRepository(
                    mavenRepositorySystem.createLocalRepository(rss.getLocalRepository().getBasedir()));
            pbr.setRemoteRepositories(getArtifactRepositories(session));

            session.setProjectBuildingRequest(pbr);
        } else {
            pbr = new DefaultProjectBuildingRequest(pbr);
            pbr.setRepositorySession(getRepositorySystemSession(session));
        }
    } catch (final EMBException e) {
        throw new ProjectToolsException("Failed to create project-building request: %s", e, e.getMessage());
    } catch (final InvalidRepositoryException e) {
        throw new ProjectToolsException("Failed to create local-repository instance. Reason: %s", e,
                e.getMessage());
    }

    return pbr;
}

From source file:org.jboss.forge.addon.maven.projects.MavenBuildManager.java

License:Open Source License

@SuppressWarnings("deprecation")
private ProjectBuildingRequest getProjectBuildingRequest(final boolean offline) {
    ClassLoader cl = Thread.currentThread().getContextClassLoader();
    try {//from   w  w w  .ja v  a  2  s .  c  om
        Settings settings = container.getSettings();
        // TODO this needs to be configurable via .forge
        // TODO this reference to the M2_REPO should probably be centralized

        MavenExecutionRequest executionRequest = new DefaultMavenExecutionRequest();
        MavenExecutionRequestPopulator populator = getPlexus().lookup(MavenExecutionRequestPopulator.class);
        populator.populateFromSettings(executionRequest, container.getSettings());
        populator.populateDefaults(executionRequest);
        RepositorySystem system = getPlexus().lookup(RepositorySystem.class);
        ProjectBuildingRequest request = executionRequest.getProjectBuildingRequest();

        ArtifactRepository localRepository = RepositoryUtils.toArtifactRepository("local",
                new File(settings.getLocalRepository()).toURI().toURL().toString(), null, true, true);
        request.setLocalRepository(localRepository);

        List<ArtifactRepository> settingsRepos = new ArrayList<>(request.getRemoteRepositories());
        List<String> activeProfiles = settings.getActiveProfiles();

        Map<String, Profile> profiles = settings.getProfilesAsMap();

        for (String id : activeProfiles) {
            Profile profile = profiles.get(id);
            if (profile != null) {
                List<Repository> repositories = profile.getRepositories();
                for (Repository repository : repositories) {
                    settingsRepos.add(RepositoryUtils.convertFromMavenSettingsRepository(repository));
                }
            }
        }
        request.setRemoteRepositories(settingsRepos);
        request.setSystemProperties(System.getProperties());

        DefaultRepositorySystemSession repositorySession = MavenRepositorySystemUtils.newSession();
        Proxy activeProxy = settings.getActiveProxy();
        if (activeProxy != null) {
            DefaultProxySelector dps = new DefaultProxySelector();
            dps.add(RepositoryUtils.convertFromMavenProxy(activeProxy), activeProxy.getNonProxyHosts());
            repositorySession.setProxySelector(dps);
        }
        LocalRepository localRepo = new LocalRepository(settings.getLocalRepository());
        repositorySession
                .setLocalRepositoryManager(system.newLocalRepositoryManager(repositorySession, localRepo));
        repositorySession.setOffline(offline);
        List<Mirror> mirrors = executionRequest.getMirrors();
        if (mirrors != null) {
            DefaultMirrorSelector mirrorSelector = new DefaultMirrorSelector();
            for (Mirror mirror : mirrors) {
                mirrorSelector.add(mirror.getId(), mirror.getUrl(), mirror.getLayout(), false,
                        mirror.getMirrorOf(), mirror.getMirrorOfLayouts());
            }
            repositorySession.setMirrorSelector(mirrorSelector);
        }

        request.setRepositorySession(repositorySession);
        request.setProcessPlugins(false);
        request.setResolveDependencies(false);
        return request;
    } catch (RuntimeException e) {
        throw e;
    } catch (Exception e) {
        throw new RuntimeException("Could not create Maven project building request", e);
    } finally {
        /*
         * We reset the classloader to prevent potential modules bugs if Classwords container changes classloaders on
         * us
         */
        Thread.currentThread().setContextClassLoader(cl);
    }
}

From source file:org.jboss.forge.arquillian.maven.ProjectHelper.java

License:Open Source License

private ProjectBuildingRequest getBuildingRequest(PlexusContainer plexus) {
    if (this.request == null) {
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        try {// ww  w .  ja v a 2 s.c om
            Settings settings = mavenContainer.getSettings();
            // TODO this needs to be configurable via .forge
            // TODO this reference to the M2_REPO should probably be centralized
            MavenExecutionRequest executionRequest = new DefaultMavenExecutionRequest();

            RepositorySystem repositorySystem = plexus.lookup(RepositorySystem.class);
            MavenExecutionRequestPopulator requestPopulator = plexus
                    .lookup(MavenExecutionRequestPopulator.class);

            requestPopulator.populateFromSettings(executionRequest, settings);
            requestPopulator.populateDefaults(executionRequest);

            ProjectBuildingRequest request = executionRequest.getProjectBuildingRequest();

            org.apache.maven.artifact.repository.ArtifactRepository localRepository = RepositoryUtils
                    .toArtifactRepository("local",
                            new File(settings.getLocalRepository()).toURI().toURL().toString(), null, true,
                            true);
            request.setLocalRepository(localRepository);

            List<org.apache.maven.artifact.repository.ArtifactRepository> settingsRepos = new ArrayList<org.apache.maven.artifact.repository.ArtifactRepository>(
                    request.getRemoteRepositories());
            List<String> activeProfiles = settings.getActiveProfiles();

            Map<String, Profile> profiles = settings.getProfilesAsMap();

            for (String id : activeProfiles) {
                Profile profile = profiles.get(id);
                if (profile != null) {
                    List<Repository> repositories = profile.getRepositories();
                    for (Repository repository : repositories) {
                        settingsRepos.add(RepositoryUtils.convertFromMavenSettingsRepository(repository));
                    }
                }
            }
            request.setRemoteRepositories(settingsRepos);
            request.setSystemProperties(System.getProperties());

            DefaultRepositorySystemSession repositorySession = MavenRepositorySystemUtils.newSession();
            Proxy activeProxy = settings.getActiveProxy();
            if (activeProxy != null) {
                DefaultProxySelector dps = new DefaultProxySelector();
                dps.add(RepositoryUtils.convertFromMavenProxy(activeProxy), activeProxy.getNonProxyHosts());
                repositorySession.setProxySelector(dps);
            }
            LocalRepository localRepo = new LocalRepository(settings.getLocalRepository());

            repositorySession.setLocalRepositoryManager(
                    repositorySystem.newLocalRepositoryManager(repositorySession, localRepo));
            repositorySession.setOffline(settings.isOffline());
            List<Mirror> mirrors = executionRequest.getMirrors();
            DefaultMirrorSelector mirrorSelector = new DefaultMirrorSelector();
            if (mirrors != null) {
                for (Mirror mirror : mirrors) {
                    mirrorSelector.add(mirror.getId(), mirror.getUrl(), mirror.getLayout(), false,
                            mirror.getMirrorOf(), mirror.getMirrorOfLayouts());
                }
            }
            repositorySession.setMirrorSelector(mirrorSelector);

            LazyAuthenticationSelector authSelector = new LazyAuthenticationSelector(mirrorSelector);
            for (Server server : settings.getServers()) {
                authSelector.add(server.getId(),
                        new AuthenticationBuilder().addUsername(server.getUsername())
                                .addPassword(server.getPassword())
                                .addPrivateKey(server.getPrivateKey(), server.getPassphrase()).build());
            }
            repositorySession.setAuthenticationSelector(authSelector);

            request.setRepositorySession(repositorySession);
            request.setProcessPlugins(false);
            request.setResolveDependencies(false);
            this.request = request;
        } catch (RuntimeException e) {
            throw e;
        } catch (Exception e) {
            throw new RuntimeException("Could not create Maven project building request", e);
        } finally {
            /*
             * We reset the classloader to prevent potential modules bugs if Classwords container changes classloaders
             * on us
             */
            Thread.currentThread().setContextClassLoader(cl);
        }
    }
    return request;
}

From source file:org.jszip.maven.RunMojo.java

License:Apache License

private List<MavenProject> buildReactorProjects() throws Exception {

    List<MavenProject> projects = new ArrayList<MavenProject>();
    for (MavenProject p : reactorProjects) {
        ProjectBuildingRequest request = ProjectBuildingRequestCreator.create(session);

        request.setProcessPlugins(true);
        request.setProfiles(request.getProfiles());
        request.setActiveProfileIds(session.getRequest().getActiveProfiles());
        request.setInactiveProfileIds(session.getRequest().getInactiveProfiles());
        request.setRemoteRepositories(session.getRequest().getRemoteRepositories());
        request.setSystemProperties(session.getSystemProperties());
        request.setUserProperties(session.getUserProperties());
        request.setRemoteRepositories(session.getRequest().getRemoteRepositories());
        request.setPluginArtifactRepositories(session.getRequest().getPluginArtifactRepositories());
        request.setLocalRepository(localRepository);
        request.setBuildStartTime(session.getRequest().getStartTime());
        request.setResolveDependencies(true);
        request.setValidationLevel(ModelBuildingRequest.VALIDATION_LEVEL_STRICT);
        projects.add(projectBuilder.build(p.getFile(), request).getProject());
    }/*from   w  w w.j  av a2  s .c om*/
    return new ProjectSorter(projects).getSortedProjects();
}

From source file:org.jvnet.hudson.plugins.mavendepsupdate.MavenUpdateChecker.java

License:Apache License

public MavenUpdateCheckerResult call() throws IOException {
    ClassLoader originalClassLoader = Thread.currentThread().getContextClassLoader();

    try {/*from  w  ww  .  j  a  v a2  s  .  co m*/

        PluginFirstClassLoader pluginFirstClassLoader = getPluginFirstClassLoader();
        Thread.currentThread().setContextClassLoader(pluginFirstClassLoader);
        String classLoaderName = getClass().getClassLoader().toString();

        mavenUpdateCheckerResult.addDebugLine(classLoaderName);
        PlexusContainer plexusContainer = getPlexusContainer(pluginFirstClassLoader);

        Thread.currentThread().setContextClassLoader(plexusContainer.getContainerRealm());
        mavenUpdateCheckerResult.addDebugLine("ok for new DefaultPlexusContainer( conf ) ");
        mavenUpdateCheckerResult.addDebugLine("Thread.currentThread().getContextClassLoader() "
                + Thread.currentThread().getContextClassLoader());
        mavenUpdateCheckerResult.addDebugLine("Thread.currentThread().getContextClassLoader().parent "
                + (Thread.currentThread().getContextClassLoader().getParent() == null ? "null"
                        : Thread.currentThread().getContextClassLoader().getParent().toString()));
        mavenUpdateCheckerResult.addDebugLine(
                "classLoader  urls " + Arrays.asList(plexusContainer.getContainerRealm().getURLs()));
        ProjectBuilder projectBuilder = plexusContainer.lookup(ProjectBuilder.class);

        // FIXME load userProperties from the job
        Properties userProperties = this.userProperties == null ? new Properties() : this.userProperties;

        userProperties.put("java.home", jdkHome);

        ProjectBuildingRequest projectBuildingRequest = getProjectBuildingRequest(userProperties,
                plexusContainer);

        // check plugins too
        projectBuildingRequest.setProcessPlugins(true);
        // force snapshots update

        projectBuildingRequest.setResolveDependencies(true);

        List<ProjectBuildingResult> projectBuildingResults = projectBuilder
                .build(Arrays.asList(new File(rootPomPath)), true, projectBuildingRequest);

        ProjectDependenciesResolver projectDependenciesResolver = plexusContainer
                .lookup(ProjectDependenciesResolver.class);

        List<MavenProject> mavenProjects = new ArrayList<MavenProject>(projectBuildingResults.size());

        for (ProjectBuildingResult projectBuildingResult : projectBuildingResults) {
            mavenProjects.add(projectBuildingResult.getProject());
        }

        ProjectSorter projectSorter = new ProjectSorter(mavenProjects);

        // use the projects reactor model as a workspaceReader
        // if reactors are not available remotely dependencies resolve will failed
        // due to artifact not found

        final Map<String, MavenProject> projectMap = getProjectMap(mavenProjects);
        WorkspaceReader reactorRepository = new ReactorReader(projectMap);

        MavenRepositorySystemSession mavenRepositorySystemSession = (MavenRepositorySystemSession) projectBuildingRequest
                .getRepositorySession();

        mavenRepositorySystemSession.setUpdatePolicy(RepositoryPolicy.UPDATE_POLICY_ALWAYS);

        mavenRepositorySystemSession.setWorkspaceReader(reactorRepository);

        MavenPluginManager mavenPluginManager = plexusContainer.lookup(MavenPluginManager.class);

        for (MavenProject mavenProject : projectSorter.getSortedProjects()) {
            LOGGER.info("resolve dependencies for project " + mavenProject.getId());

            DefaultDependencyResolutionRequest dependencyResolutionRequest = new DefaultDependencyResolutionRequest(
                    mavenProject, mavenRepositorySystemSession);

            try {
                DependencyResolutionResult dependencyResolutionResult = projectDependenciesResolver
                        .resolve(dependencyResolutionRequest);
            } catch (DependencyResolutionException e) {
                mavenUpdateCheckerResult.addDebugLine(e.getMessage());
                StringWriter sw = new StringWriter();
                PrintWriter pw = new PrintWriter(sw);
                e.printStackTrace(pw);
                mavenUpdateCheckerResult.addDebugLine("skip:" + sw.toString());
            }
            if (checkPlugins) {
                for (Plugin plugin : mavenProject.getBuildPlugins()) {
                    // only for SNAPSHOT
                    if (StringUtils.endsWith(plugin.getVersion(), "SNAPSHOT")) {
                        mavenPluginManager.getPluginDescriptor(plugin,
                                mavenProject.getRemotePluginRepositories(), mavenRepositorySystemSession);
                    }
                }
            }

        }
        SnapshotTransfertListener snapshotTransfertListener = (SnapshotTransfertListener) projectBuildingRequest
                .getRepositorySession().getTransferListener();

        if (snapshotTransfertListener.isSnapshotDownloaded()) {
            mavenUpdateCheckerResult.addFilesUpdatedNames(snapshotTransfertListener.getSnapshots());
        }

    } catch (Exception e) {
        mavenUpdateCheckerResult.addDebugLine(e.getMessage());
        StringWriter sw = new StringWriter();
        PrintWriter pw = new PrintWriter(sw);
        e.printStackTrace(pw);
        mavenUpdateCheckerResult.addDebugLine("skip:" + sw.toString());
    } finally {
        Thread.currentThread().setContextClassLoader(originalClassLoader);
    }
    return mavenUpdateCheckerResult;
}