Example usage for org.apache.maven.project DefaultProjectBuildingRequest DefaultProjectBuildingRequest

List of usage examples for org.apache.maven.project DefaultProjectBuildingRequest DefaultProjectBuildingRequest

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

Introduction

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

Prototype

public DefaultProjectBuildingRequest()

Source Link

Usage

From source file:com.github.r351574nc3.maven.instrument.MavenLoader.java

License:Open Source License

public MavenLoader(final String m2Home) {
    setMavenHome(m2Home);//from w ww . j  a v a  2 s . c o m
    try {
        loadMaven();

        final ProjectBuilder projectBuilder = new DefaultProjectBuilder();

        for (final URL pomUrl : lookupPomFiles()) {
            info("URL: %s", pomUrl);
            setMavenProject(projectBuilder
                    .build(new File(pomUrl.getFile()), new DefaultProjectBuildingRequest()).getProject());
            // mavenProjectClass.getMethod("setPomFile", new Class[] { File.class }).invoke(mavenProject, new File(pomUrl.getFile()));
        }
    } catch (MalformedURLException mue) {
        mue.printStackTrace();
    } catch (Exception e) {
        e.printStackTrace();
    }

    setDependencyHandler(new MavenDependencyHandler(mavenProject));
}

From source file:com.liferay.maven.plugins.AbstractToolsLiferayMojo.java

License:Open Source License

protected MavenProject resolveProject(Artifact artifact) throws Exception {
    Artifact pomArtifact = artifact;//from   w w  w.  j  ava 2  s . co m

    String type = artifact.getType();

    if (!type.equals("pom")) {
        pomArtifact = artifactFactory.createArtifact(artifact.getGroupId(), artifact.getArtifactId(),
                artifact.getVersion(), "", "pom");
    }

    ProjectBuildingRequest projectBuildingRequest = new DefaultProjectBuildingRequest();

    projectBuildingRequest.setLocalRepository(localArtifactRepository);
    projectBuildingRequest.setRemoteRepositories(remoteArtifactRepositories);
    projectBuildingRequest.setRepositorySession(session.getRepositorySession());

    List<String> activeProfileIds = new ArrayList<String>();

    MavenExecutionRequest mavenExecutionRequest = session.getRequest();

    for (String activeProfile : mavenExecutionRequest.getActiveProfiles()) {
        activeProfileIds.add(activeProfile);
    }

    projectBuildingRequest.setActiveProfileIds(activeProfileIds);
    projectBuildingRequest.setProfiles(mavenExecutionRequest.getProfiles());

    ProjectBuildingResult projectBuildingResult = projectBuilder.build(pomArtifact, true,
            projectBuildingRequest);

    return projectBuildingResult.getProject();
}

From source file:com.monday_consulting.maven.plugins.fsm.util.resolver.MavenGetArtifactsResolver.java

License:Apache License

private MavenProject getMavenProjectViaRepository(final Module module, final ProjectBuilder projectBuilder)
        throws MojoFailureException {
    try {/*ww  w.j a v a  2s.co  m*/
        final ProjectBuildingRequest request = new DefaultProjectBuildingRequest();
        request.setResolveDependencies(true);
        request.setRemoteRepositories(mavenProject.getRemoteArtifactRepositories());
        request.setRepositorySession(repoSession);

        final LocalRepositoryManager localRepositoryManager = repoSession.getLocalRepositoryManager();
        final File repoBasedir = localRepositoryManager.getRepository().getBasedir();

        // the module type artifact (war, jar, pom ...)
        final DefaultArtifact moduleArtifact = new DefaultArtifact(module.getGroupId(), module.getArtifactId(),
                module.getClassifier(), module.getType(), module.getVersion());
        final String pathForLocalArtifact = localRepositoryManager.getPathForLocalArtifact(moduleArtifact);
        final File moduleArtifactFile = new File(repoBasedir, pathForLocalArtifact);

        // the module pom artifact to build maven project
        final DefaultArtifact pomArtifact = new DefaultArtifact(module.getGroupId(), module.getArtifactId(),
                module.getClassifier(), "pom", module.getVersion());
        final String localArtifactPath = localRepositoryManager.getPathForLocalArtifact(pomArtifact);

        final File projectFile = new File(repoBasedir, localArtifactPath);

        MavenProject result;
        try {
            log.info("try to build maven project for " + module.getArtifactId() + " from local repository...");
            result = projectBuilder.build(projectFile, request).getProject();

            if (!moduleArtifactFile.exists()) {
                resolveArtifact(module, moduleArtifact);
            }
        } catch (ProjectBuildingException e) {
            log.info("failed... try to resolve " + module.getArtifactId() + " from remote repository...");
            final Artifact mavenArtifact = new org.apache.maven.artifact.DefaultArtifact(module.getGroupId(),
                    module.getArtifactId(), module.getVersion(), null, module.getType(), module.getClassifier(),
                    new DefaultArtifactHandler());
            result = projectBuilder.build(mavenArtifact, request).getProject();

            resolveArtifact(module, moduleArtifact);
        }

        if (result != null) {
            log.info("Dependency resolved: " + module.getArtifactId());
            result.getArtifact().setFile(moduleArtifactFile);
            result.setParent(mavenProject);
        } else {
            throw new MojoFailureException(
                    "No dependency for " + module.getArtifactId() + " found in local or remote repository");
        }

        return result;
    } catch (ProjectBuildingException e) {
        throw new MojoFailureException(
                "No dependency for " + module.getArtifactId() + "found in local or remote repository", e);
    }
}

From source file:com.xwikisas.xcs.tools.dependenciespackager.PackageExtensionsMojo.java

License:Open Source License

private Collection<Artifact> getMainWikiArtifacts() throws DependencyGraphBuilderException {
    // Get main UI
    Artifact mainWikiUI = mavenProject.getArtifactMap().get(extensionOnMainWiki);
    // If no artifact was configured for main wiki, return an empty list of artifacts to mark as installed
    if (mainWikiUI == null) {
        return Collections.<Artifact>emptyList();
    }//  w  w w .j a va  2 s. co  m

    ProjectBuildingRequest request = new DefaultProjectBuildingRequest();
    request.setRepositorySession(session.getRepositorySession());
    request.setProject(mavenProject);

    DependencyNode rootNode = graphBuilder.buildDependencyGraph(request, null);

    Collection<Artifact> artifactsToInstall = new ArrayList<>();
    walk(rootNode, mainWikiUI, false, artifactsToInstall);

    return artifactsToInstall;
}

From source file:de.fct.companian.analyze.mvn.helper.MvnProjectBuilder.java

License:Apache License

public static MavenProject buildMavenProject(File pomFile) {
    if (logger.isDebugEnabled()) {
        logger.debug("buildMavenProject() start, pomFile=" + pomFile);
    }/*from   w  w w.ja  v a2s .  c  om*/
    MavenProject mvnProject = null;

    ClassWorld classWorld = new ClassWorld("plexus.core", Thread.currentThread().getContextClassLoader());

    ContainerConfiguration cc = new DefaultContainerConfiguration().setClassWorld(classWorld)
            .setName("embedder");

    DefaultPlexusContainer container;
    org.codehaus.plexus.logging.Logger mvnLogger;
    try {
        mvnLogger = new ConsoleLogger(org.codehaus.plexus.logging.Logger.LEVEL_DEBUG, "Console");
        container = new DefaultPlexusContainer(cc);
        container.setLoggerManager(new MavenLoggerManager(mvnLogger));
        container.getLoggerManager().setThresholds(org.codehaus.plexus.logging.Logger.LEVEL_DEBUG);

        ProjectBuilder builder;
        try {
            builder = container.lookup(ProjectBuilder.class);
            logger.info("buildMavenProject() project builder = " + builder);

            try {

                ArtifactRepositoryFactory repoFactory = new DefaultArtifactRepositoryFactory();

                ArtifactRepository localRepo = repoFactory.createArtifactRepository("mylocal",
                        "file://h:/maven/repository", new DefaultRepositoryLayout(),
                        new ArtifactRepositoryPolicy(), new ArtifactRepositoryPolicy());

                List<ArtifactRepository> remoteRepos = new ArrayList<ArtifactRepository>();
                ArtifactRepository mvnCentral = repoFactory.createArtifactRepository("mvnCentral",
                        "http://repo1.maven.org/maven2/", new DefaultRepositoryLayout(),
                        new ArtifactRepositoryPolicy(), new ArtifactRepositoryPolicy());
                remoteRepos.add(mvnCentral);

                ProjectBuildingRequest buildRequest = new DefaultProjectBuildingRequest();
                buildRequest.setLocalRepository(localRepo);
                buildRequest.setRemoteRepositories(remoteRepos);
                buildRequest.setResolveDependencies(true);
                buildRequest.setOffline(false);

                ProjectBuildingResult buildResult = builder.build(pomFile, buildRequest);
                if (buildResult != null) {
                    logger.info("buildMavenProject() got a build result");

                    mvnProject = buildResult.getProject();
                }
            } catch (ProjectBuildingException e) {
                logger.error("buildMavenProject() error building project", e);
            }

        } catch (ComponentLookupException e) {
            logger.error("buildMavenProject() error looking up ArtifactResolver", e);
        }
    } catch (PlexusContainerException e) {
        logger.error("buildMavenProject() error from Plexus container", e);
    }

    if (logger.isDebugEnabled()) {
        logger.debug("buildMavenProject() finished, mvnProject=" + mvnProject);
    }
    return mvnProject;
}

From source file:guru.nidi.maven.tools.MavenUtil.java

License:Apache License

public static MavenProject projectFromArtifact(MavenSession session, ProjectBuilder projectBuilder,
        Artifact artifact, boolean resolveDependencies) throws ProjectBuildingException {
    final ProjectBuildingRequest request = new DefaultProjectBuildingRequest()
            .setLocalRepository(session.getLocalRepository())
            .setRepositorySession(session.getRepositorySession()).setSystemProperties(System.getProperties())
            .setResolveDependencies(resolveDependencies);
    return projectBuilder.build(artifact, request).getProject();
}

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");
    }/*  w  ww .  j  a  v  a 2 s  . c  om*/

    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:io.github.patrickpilch.dependencylicensechecker.DependencyChecker.java

License:Open Source License

private MavenProject generateMavenProject(final Artifact artifact) throws ProjectBuildingException {
    Objects.requireNonNull(artifact);
    final Artifact projectArtifact = repositorySystem.createProjectArtifact(artifact.getGroupId(),
            artifact.getArtifactId(), artifact.getVersion());

    final ProjectBuildingRequest projectBuildingRequest = new DefaultProjectBuildingRequest();
    projectBuildingRequest.setRepositorySession(repositorySystemSession);
    projectBuildingRequest.setSystemProperties(System.getProperties());
    return projectBuilder.build(projectArtifact, projectBuildingRequest).getProject();
}

From source file:net.flexmojos.oss.plugin.war.CopyMojo.java

License:Open Source License

private MavenProject getProject(Artifact artifact) throws MojoExecutionException {
    try {/*  w w w .  j  a va 2s . c  o m*/
        ProjectBuildingRequest request = new DefaultProjectBuildingRequest();
        request.setLocalRepository(localRepository);
        request.setRemoteRepositories(remoteRepositories);
        request.setResolveDependencies(true);
        ArrayList<String> ids = new ArrayList<String>();
        for (Profile profile : project.getActiveProfiles()) {
            ids.add(profile.getId());
        }
        request.setActiveProfileIds(ids);
        request.setRepositorySession(session.getRepositorySession());
        return projectBuilder.build(artifact, request).getProject();
    } catch (ProjectBuildingException e) {
        getLog().warn("Failed to retrieve pom for " + artifact);
        return null;
    }
}

From source file:net.java.jpatch.maven.common.AbstractMavenMojo.java

License:Apache License

/**
 * Loads the list of projects.//ww w  .ja v a 2  s. c o m
 *
 * @param directories the list of project directories.
 *
 * @return the list of the MAVEN projects.
 *
 * @throws MojoExecutionException
 * @throws ProjectBuildingException
 */
protected List<MavenProject> loadMavenProjects() throws MojoExecutionException {
    List<File> files = new ArrayList<File>();
    for (String item : projects) {
        File file = new File(item, mavenFile);
        files.add(file);
    }

    DefaultRepositorySystemSession mavenSession = new DefaultRepositorySystemSession();
    mavenSession.setLocalRepositoryManager(new SimpleLocalRepositoryManager(localRepository.getBasedir()));

    DefaultProjectBuildingRequest config = new DefaultProjectBuildingRequest();
    config.setLocalRepository(localRepository);
    config.setRemoteRepositories(remoteRepositories);
    config.setRepositorySession(mavenSession);

    List<ProjectBuildingResult> results = null;
    try {
        results = projectBuilder.build(files, true, config);
    } catch (ProjectBuildingException ex) {
        throw new MojoExecutionException("Error create the maven project!", ex);
    }

    List<MavenProject> result = new ArrayList<MavenProject>();
    for (ProjectBuildingResult item : results) {
        result.add(item.getProject());
    }
    return result;
}