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

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

Introduction

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

Prototype

ProjectBuildingRequest setRemoteRepositories(List<ArtifactRepository> remoteRepositories);

Source Link

Usage

From source file:com.github.veithen.phos.jacoco.AggregateReportMojo.java

License:Apache License

private File resolveArtifact(Artifact baseArtifact, String classifier, String type, boolean localOnly,
        boolean allowMissing) throws MojoExecutionException {
    ProjectBuildingRequest projectBuildingRequest = session.getProjectBuildingRequest();
    if (localOnly) {
        projectBuildingRequest = new DefaultProjectBuildingRequest(projectBuildingRequest);
        projectBuildingRequest.setRemoteRepositories(Collections.<ArtifactRepository>emptyList());
    }/*from   w w  w. ja  va2s .  com*/
    Dependency dependency = new Dependency();
    dependency.setGroupId(baseArtifact.getGroupId());
    dependency.setArtifactId(baseArtifact.getArtifactId());
    dependency.setVersion(baseArtifact.getVersion());
    dependency.setType(type);
    dependency.setClassifier(classifier);
    dependency.setScope(Artifact.SCOPE_COMPILE);
    Artifact artifact = repositorySystem.createDependencyArtifact(dependency);
    try {
        return resolver.resolveArtifact(projectBuildingRequest, artifact).getArtifact().getFile();
    } catch (ArtifactResolverException ex) {
        if (allowMissing) {
            return null;
        } else {
            throw new MojoExecutionException("Unable to resolve artifact", ex);
        }
    }
}

From source file:com.github.wcy123.maven.launcher.RunnerMojo.java

License:Apache License

@Override
public void execute() throws MojoExecutionException, MojoFailureException {
    if (isSkip()) {
        getLog().info("Skipping plugin execution");
        return;/*from   w w w  .  j av  a  2s .  c  om*/
    }

    if (coordinate.getArtifactId() == null && artifact == null) {
        throw new MojoFailureException("You must specify an artifact, "
                + "e.g. -Dartifact=org.apache.maven.plugins:maven-downloader-plugin:1.0");
    }
    if (artifact != null) {
        String[] tokens = StringUtils.split(artifact, ":");
        if (tokens.length < 3 || tokens.length > 5) {
            throw new MojoFailureException(
                    "Invalid artifact, you must specify groupId:artifactId:version[:packaging[:classifier]] "
                            + artifact);
        }
        coordinate.setGroupId(tokens[0]);
        coordinate.setArtifactId(tokens[1]);
        coordinate.setVersion(tokens[2]);
        if (tokens.length >= 4) {
            coordinate.setType(tokens[3]);
        }
        if (tokens.length == 5) {
            coordinate.setClassifier(tokens[4]);
        }
    }

    ArtifactRepositoryPolicy always = new ArtifactRepositoryPolicy(true,
            ArtifactRepositoryPolicy.UPDATE_POLICY_ALWAYS, ArtifactRepositoryPolicy.CHECKSUM_POLICY_WARN);

    List<ArtifactRepository> repoList = new ArrayList<ArtifactRepository>();

    if (pomRemoteRepositories != null) {
        repoList.addAll(pomRemoteRepositories);
    }

    if (remoteRepositories != null) {
        // Use the same format as in the deploy plugin id::layout::url
        List<String> repos = Arrays.asList(StringUtils.split(remoteRepositories, ","));
        for (String repo : repos) {
            repoList.add(parseRepository(repo, always));
        }
    }

    try {
        ProjectBuildingRequest buildingRequest = new DefaultProjectBuildingRequest(
                session.getProjectBuildingRequest());
        buildingRequest.setProject(session.getCurrentProject());
        buildingRequest.setRemoteRepositories(repoList);

        getLog().info("Resolving " + coordinate + " with transitive dependencies");

        // FIXME
        // artifactResolver.resolveArtifact( buildingRequest, coordinate );

        final Iterable<ArtifactResult> artifactResults = dependencyResolver.resolveDependencies(buildingRequest,
                coordinate, null);

        // start from here
        if (!artifactResults.iterator().hasNext()) {
            getLog().error("cannot find the first artifcat");
            return;
        }
        List<Artifact> listOfArtifacts = new ArrayList<>();
        for (ArtifactResult artifactResult : artifactResults) {
            getLog().info("artifacts " + artifactResult.getArtifact());
            listOfArtifacts.add(artifactResolver.resolveArtifact(buildingRequest, artifactResult.getArtifact())
                    .getArtifact());

        }
        URL[] urls = new URL[listOfArtifacts.size()];
        for (int i = 0; i < urls.length; ++i) {
            urls[i] = listOfArtifacts.get(i).getFile().toURI().toURL();
        }
        final SharedUrlClassLoader classLoader = SharedUrlClassLoader.create(urls);

        final JarFile jarFile = new JarFile(urls[0].getFile());
        final Manifest manifest = jarFile.getManifest();
        String value = manifest.getMainAttributes().getValue("Main-Class");
        // final String charSequence = "cannot find Main-Class: " +
        // manifest.getMainAttributes().entrySet().stream().map(e -> e.getKey() + ":" +
        // e.getValue()).collect(Collectors.joining("\n"));
        if (value == null) {
            throw new MojoFailureException("cannot find Main-Class " + classLoader.getURLs());
        }
        value = "com.wcy123.HelloWorldApplication";
        System.out.println("value is value " + value);
        final Class<?> aClass = Class.forName(value, true, classLoader);
        final Method main = aClass.getMethod("main", String[].class);
        Thread runnerThread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    main.invoke(null, new Object[] { new String[] { "hello", "world" } });
                } catch (IllegalAccessException | InvocationTargetException e) {
                    e.printStackTrace();
                }
            }
        });
        runnerThread.setContextClassLoader(classLoader);
        runnerThread.start();
        runnerThread.join();
    } catch (DependencyResolverException e) {
        throw new MojoExecutionException("Couldn't download artifact: " + e.getMessage(), e);
    } catch (IOException e) {
        getLog().error("cannot create class loader", e);
        throw new MojoFailureException("cannot create class loader");
    } catch (ArtifactResolverException e) {
        getLog().error("cannot resolve artifact", e);
        throw new MojoFailureException("cannot resolve artifact");
    } catch (ClassNotFoundException e) {
        getLog().error("cannot load Main-Class", e);
        throw new MojoFailureException("cannot load Main-Class");
    } catch (NoSuchMethodException e) {
        getLog().error("cannot get main method", e);
        throw new MojoFailureException("cannot get main method");
    } catch (InterruptedException e) {
        getLog().error("interrupted", e);
    }
}

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. ja  v  a 2  s. c o  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 {/*from  ww w .j av  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: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 ww  w.  j  a v a  2 s  . c o m*/
    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:io.airlift.resolver.ArtifactResolver.java

License:Apache License

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

    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.syndesis.maven.ExtractConnectorDescriptorsMojo.java

License:Apache License

@Override
@SuppressWarnings("PMD.EmptyCatchBlock")
public void execute() throws MojoExecutionException, MojoFailureException {

    ArrayNode root = new ArrayNode(JsonNodeFactory.instance);

    URLClassLoader classLoader = null;
    try {/*from ww w.j ava2  s.  c om*/
        PluginDescriptor desc = (PluginDescriptor) getPluginContext().get("pluginDescriptor");
        List<Artifact> artifacts = desc.getArtifacts();
        ProjectBuildingRequest buildingRequest = new DefaultProjectBuildingRequest(
                session.getProjectBuildingRequest());
        buildingRequest.setRemoteRepositories(remoteRepositories);
        for (Artifact artifact : artifacts) {
            ArtifactResult result = artifactResolver.resolveArtifact(buildingRequest, artifact);
            File jar = result.getArtifact().getFile();
            classLoader = createClassLoader(jar);
            if (classLoader == null) {
                throw new IOException("Can not create classloader for " + jar);
            }
            ObjectNode entry = new ObjectNode(JsonNodeFactory.instance);
            addConnectorMeta(entry, classLoader);
            addComponentMeta(entry, classLoader);
            if (entry.size() > 0) {
                addGav(entry, artifact);
                root.add(entry);
            }
        }
        if (root.size() > 0) {
            saveCamelMetaData(root);
        }
    } catch (ArtifactResolverException | IOException e) {
        throw new MojoExecutionException(e.getMessage(), e);
    } finally {
        if (classLoader != null) {
            try {
                classLoader.close();
            } catch (IOException ignored) {

            }
        }
    }
}

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 av a  2 s  .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.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;// www  . j  av  a2  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;/*w ww  . ja 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();
}