Example usage for org.apache.maven.project ProjectBuilder build

List of usage examples for org.apache.maven.project ProjectBuilder build

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

Introduction

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

Prototype

ProjectBuildingResult build(ModelSource modelSource, ProjectBuildingRequest request)
        throws ProjectBuildingException;

Source Link

Document

Builds a project descriptor for the specified model source.

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. ja  va  2s. 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.monday_consulting.maven.plugins.fsm.util.resolver.MavenGetArtifactsResolver.java

License:Apache License

private MavenProject getMavenProjectViaRepository(final Module module, final ProjectBuilder projectBuilder)
        throws MojoFailureException {
    try {/*from   www .  j  a  v a2  s . c  o 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.ruleoftech.markdown.page.generator.plugin.BetterAbstractMojoTestCase.java

/** As {@link #lookupConfiguredMojo(MavenProject, String)} but taking the pom file 
 * and creating the {@link MavenProject}. */
protected Mojo lookupConfiguredMojo(File pom, String goal) throws Exception {
    assertNotNull(pom);/*from   w  ww.j av  a2 s.c  om*/
    assertTrue(pom.exists());

    ProjectBuildingRequest buildingRequest = newMavenSession().getProjectBuildingRequest();
    ProjectBuilder projectBuilder = lookup(ProjectBuilder.class);
    MavenProject project = projectBuilder.build(pom, buildingRequest).getProject();

    return lookupConfiguredMojo(project, goal);
}

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  .  j  a  v a  2 s.com*/
    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:info.debatty.sparkpackages.maven.plugin.MojoTestCase.java

License:Open Source License

/**
 * Create an instance of Mojo corresponding to the provided goal.
 * The Mojo will be configured according to values provided in the pom.
 * @param pom/*from  w  w w . j  a v  a 2s . co m*/
 * @param goal
 * @return
 * @throws Exception if something went wrong...
 */
public final Mojo lookupConfiguredMojo(final File pom, final String goal) throws Exception {

    MavenExecutionRequest request = new DefaultMavenExecutionRequest();
    MavenExecutionResult result = new DefaultMavenExecutionResult();

    // populate default values for (a.o.) repository basedir and
    // remote repos
    MavenExecutionRequestPopulator populator = getContainer().lookup(MavenExecutionRequestPopulator.class);
    populator.populateDefaults(request);

    // this is needed to allow java profiles to get resolved;
    // i.e. avoid during project builds:
    // [ERROR] Failed to determine Java version for profile
    // java-1.5-detected
    request.setSystemProperties(System.getProperties());

    // and this is needed so that the repo session in the maven session
    // has a repo manager, and it points at the local repo
    // (cf MavenRepositorySystemUtils.newSession() which is what is
    // otherwise done)
    DefaultMaven maven = (DefaultMaven) getContainer().lookup(Maven.class);
    DefaultRepositorySystemSession repo_session = (DefaultRepositorySystemSession) maven
            .newRepositorySession(request);
    repo_session.setLocalRepositoryManager(new SimpleLocalRepositoryManagerFactory().newInstance(repo_session,
            new LocalRepository(request.getLocalRepository().getBasedir())));

    @SuppressWarnings("deprecation")
    MavenSession session = new MavenSession(getContainer(), repo_session, request, result);

    ProjectBuildingRequest building_request = session.getProjectBuildingRequest();
    ProjectBuilder project_builder = lookup(ProjectBuilder.class);
    MavenProject project = project_builder.build(pom, building_request).getProject();

    return super.lookupConfiguredMojo(project, goal);

}

From source file:info.ronjenkins.maven.rtr.steps.release.RebuildReleaseReactor.java

License:Apache License

@Override
protected void releaseExecute(final MavenSession session, final RTRComponents components)
        throws MavenExecutionException {
    final List<MavenProject> reactor = session.getProjects();
    final List<MavenProject> newReactor = new ArrayList<>(reactor.size());
    final ProjectBuilder projectBuilder = components.getProjectBuilder();
    File pomFile;/*from  ww  w. j av a 2s. c  o m*/
    ProjectBuildingResult result;
    MavenProject newProject;
    for (final MavenProject project : reactor) {
        pomFile = project.getFile();
        try {
            result = projectBuilder.build(pomFile, session.getProjectBuildingRequest());
        } catch (final ProjectBuildingException e) {
            this.logger.error("");
            throw new SmartReactorReleaseException(e);
        }
        newProject = result.getProject();
        if (project.isExecutionRoot()) {
            newProject.setExecutionRoot(true);
        }
        newReactor.add(newProject);
    }
    // Set the new list of projects, but don't replace the actual list
    // object.
    session.getProjects().clear();
    session.getProjects().addAll(newReactor);
}

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 v a 2s  .  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.swagger.v3.plugin.maven.BetterAbstractMojoTestCase.java

/**
 * As {@link #lookupConfiguredMojo(MavenProject, String)} but taking the pom file
 * and creating the {@link MavenProject}.
 *//*from  ww  w. ja  v a 2  s .  com*/
protected Mojo lookupConfiguredMojo(File pom, String goal) throws Exception {
    assertNotNull(pom);
    assertTrue(pom.exists());
    this.getContainer().addComponent(new IncludeProjectDependenciesComponentConfigurator(),
            org.codehaus.plexus.component.configurator.ComponentConfigurator.class,
            "include-project-dependencies");
    ProjectBuildingRequest buildingRequest = newMavenSession().getProjectBuildingRequest();
    ProjectBuilder projectBuilder = lookup(ProjectBuilder.class);
    MavenProject project = projectBuilder.build(pom, buildingRequest).getProject();

    return lookupConfiguredMojo(project, goal);
}

From source file:net.adamcin.oakpal.maven.mojo.OakpalMojoTestCaseBase.java

License:Apache License

protected SessionAndProject buildProject(final File pom) throws Exception {
    assertNotNull(pom);/*from www.j  a va 2  s.c om*/
    assertTrue(pom.exists());
    SessionAndProject sessionAndProject = new SessionAndProject();
    sessionAndProject.setSession(newMavenSession());

    ProjectBuildingRequest buildingRequest = sessionAndProject.getSession().getProjectBuildingRequest();
    buildingRequest.setResolveDependencies(true);
    ProjectBuilder projectBuilder = lookup(ProjectBuilder.class);
    MavenProject project = projectBuilder.build(pom, buildingRequest).getProject();
    sessionAndProject.setProject(project);
    return sessionAndProject;
}