Example usage for org.apache.maven.artifact.resolver ArtifactResolutionRequest setArtifactDependencies

List of usage examples for org.apache.maven.artifact.resolver ArtifactResolutionRequest setArtifactDependencies

Introduction

In this page you can find the example usage for org.apache.maven.artifact.resolver ArtifactResolutionRequest setArtifactDependencies.

Prototype

public ArtifactResolutionRequest setArtifactDependencies(Set<Artifact> artifactDependencies) 

Source Link

Usage

From source file:io.sundr.maven.GenerateBomMojo.java

License:Apache License

private Set<Artifact> resolve(final Set<Artifact> dependencies) {
    ArtifactResolutionRequest request = new ArtifactResolutionRequest();
    request.setArtifact(getProject().getArtifact());
    request.setArtifactDependencies(dependencies);
    request.setLocalRepository(localRepository);
    request.setRemoteRepositories(remoteRepositories);
    request.setManagedVersionMap(getProject().getManagedVersionMap());
    request.setResolveTransitively(true);
    ArtifactResolutionResult result = artifactResolver.resolve(request);
    return result.getArtifacts();
}

From source file:org.eclipse.che.maven.server.MavenServerImpl.java

License:Open Source License

private MavenResult internalResolveProject(File pom, List<String> activeProfiles, List<String> inactiveProfiles,
        List<ResolutionListener> dependencyTreeResolutionListeners) {

    MavenExecutionRequest request = newMavenRequest(pom, activeProfiles, inactiveProfiles,
            Collections.emptyList());
    request.setUpdateSnapshots(updateSnapshots);

    AtomicReference<MavenResult> reference = new AtomicReference<>();
    runMavenRequest(request, () -> {/* w ww . j a v a  2 s  .c o  m*/
        try {
            ProjectBuilder builder = getMavenComponent(ProjectBuilder.class);

            List<ProjectBuildingResult> resultList = builder.build(Collections.singletonList(pom), false,
                    request.getProjectBuildingRequest());
            ProjectBuildingResult result = resultList.get(0);
            MavenProject mavenProject = result.getProject();
            RepositorySystemSession repositorySession = getMavenComponent(LegacySupport.class)
                    .getRepositorySession();
            if (repositorySession instanceof DefaultRepositorySystemSession) {
                ((DefaultRepositorySystemSession) repositorySession)
                        .setTransferListener(new ArtifactTransferListener(mavenProgressNotifier));
                if (workspaceCache != null) {
                    ((DefaultRepositorySystemSession) repositorySession)
                            .setWorkspaceReader(new MavenWorkspaceReader(workspaceCache));
                }

            }

            List<Exception> exceptions = new ArrayList<>();

            loadExtensions(mavenProject, exceptions);
            mavenProject.setDependencyArtifacts(
                    mavenProject.createArtifacts(getMavenComponent(ArtifactFactory.class), null, null));

            ArtifactResolutionRequest resolutionRequest = new ArtifactResolutionRequest();
            resolutionRequest.setArtifact(mavenProject.getArtifact());
            resolutionRequest.setRemoteRepositories(mavenProject.getRemoteArtifactRepositories());
            resolutionRequest.setArtifactDependencies(mavenProject.getDependencyArtifacts());
            resolutionRequest.setListeners(dependencyTreeResolutionListeners);
            resolutionRequest.setLocalRepository(localRepo);
            resolutionRequest.setManagedVersionMap(mavenProject.getManagedVersionMap());
            resolutionRequest.setResolveTransitively(true);
            resolutionRequest.setResolveRoot(false);
            ArtifactResolver resolver = getMavenComponent(ArtifactResolver.class);
            ArtifactResolutionResult resolve = resolver.resolve(resolutionRequest);
            mavenProject.setArtifacts(resolve.getArtifacts());
            reference.set(new MavenResult(mavenProject, exceptions));

        } catch (Exception e) {
            reference.set(new MavenResult(null, null, Collections.singletonList(e)));
        }
    });
    return reference.get();
}

From source file:org.jetbrains.idea.maven.server.Maven30ServerEmbedderImpl.java

License:Apache License

@Nonnull
public MavenExecutionResult doResolveProject(@Nonnull final File file,
        @Nonnull final List<String> activeProfiles, @Nonnull final List<String> inactiveProfiles,
        final List<ResolutionListener> listeners) throws RemoteException {
    final MavenExecutionRequest request = createRequest(file, activeProfiles, inactiveProfiles,
            Collections.<String>emptyList());

    request.setUpdateSnapshots(myAlwaysUpdateSnapshots);

    final AtomicReference<MavenExecutionResult> ref = new AtomicReference<MavenExecutionResult>();

    executeWithMavenSession(request, new Runnable() {
        @Override/*  w  w w. j  a  va2 s .  c  o m*/
        public void run() {
            try {
                // copied from DefaultMavenProjectBuilder.buildWithDependencies
                ProjectBuilder builder = getComponent(ProjectBuilder.class);

                CustomMaven3ModelInterpolator2 modelInterpolator = (CustomMaven3ModelInterpolator2) getComponent(
                        ModelInterpolator.class);

                String savedLocalRepository = modelInterpolator.getLocalRepository();
                modelInterpolator.setLocalRepository(request.getLocalRepositoryPath().getAbsolutePath());
                List<ProjectBuildingResult> results;

                try {
                    // Don't use build(File projectFile, ProjectBuildingRequest request) , because it don't use cache !!!!!!!! (see http://devnet.jetbrains.com/message/5500218)
                    results = builder.build(Collections.singletonList(new File(file.getPath())), false,
                            request.getProjectBuildingRequest());
                } finally {
                    modelInterpolator.setLocalRepository(savedLocalRepository);
                }

                ProjectBuildingResult buildingResult = results.get(0);

                MavenProject project = buildingResult.getProject();

                RepositorySystemSession repositorySession = getComponent(LegacySupport.class)
                        .getRepositorySession();
                if (repositorySession instanceof DefaultRepositorySystemSession) {
                    ((DefaultRepositorySystemSession) repositorySession)
                            .setTransferListener(new Maven30TransferListenerAdapter(myCurrentIndicator));

                    if (myWorkspaceMap != null) {
                        ((DefaultRepositorySystemSession) repositorySession)
                                .setWorkspaceReader(new Maven30WorkspaceReader(myWorkspaceMap));
                    }
                }

                List<Exception> exceptions = new ArrayList<Exception>();
                loadExtensions(project, exceptions);

                //Artifact projectArtifact = project.getArtifact();
                //Map managedVersions = project.getManagedVersionMap();
                //ArtifactMetadataSource metadataSource = getComponent(ArtifactMetadataSource.class);
                project.setDependencyArtifacts(
                        project.createArtifacts(getComponent(ArtifactFactory.class), null, null));
                //

                if (USE_MVN2_COMPATIBLE_DEPENDENCY_RESOLVING) {
                    ArtifactResolutionRequest resolutionRequest = new ArtifactResolutionRequest();
                    resolutionRequest.setArtifactDependencies(project.getDependencyArtifacts());
                    resolutionRequest.setArtifact(project.getArtifact());
                    resolutionRequest.setManagedVersionMap(project.getManagedVersionMap());
                    resolutionRequest.setLocalRepository(myLocalRepository);
                    resolutionRequest.setRemoteRepositories(project.getRemoteArtifactRepositories());
                    resolutionRequest.setListeners(listeners);

                    resolutionRequest.setResolveRoot(false);
                    resolutionRequest.setResolveTransitively(true);

                    ArtifactResolver resolver = getComponent(ArtifactResolver.class);
                    ArtifactResolutionResult result = resolver.resolve(resolutionRequest);

                    project.setArtifacts(result.getArtifacts());
                    // end copied from DefaultMavenProjectBuilder.buildWithDependencies
                    ref.set(new MavenExecutionResult(project, exceptions));
                } else {
                    final DependencyResolutionResult dependencyResolutionResult = resolveDependencies(project,
                            repositorySession);
                    final List<Dependency> dependencies = dependencyResolutionResult.getDependencies();

                    Set<Artifact> artifacts = new LinkedHashSet<Artifact>(dependencies.size());
                    for (Dependency dependency : dependencies) {
                        final Artifact artifact = RepositoryUtils.toArtifact(dependency.getArtifact());
                        artifact.setScope(dependency.getScope());
                        artifact.setOptional(dependency.isOptional());
                        artifacts.add(artifact);
                        resolveAsModule(artifact);
                    }

                    project.setArtifacts(artifacts);
                    ref.set(new MavenExecutionResult(project, dependencyResolutionResult, exceptions));
                }
            } catch (Exception e) {
                ref.set(handleException(e));
            }
        }
    });

    return ref.get();
}

From source file:org.jetbrains.idea.maven.server.Maven32ServerEmbedderImpl.java

License:Apache License

@Nonnull
public MavenExecutionResult doResolveProject(@Nonnull final File file,
        @Nonnull final List<String> activeProfiles, @Nonnull final List<String> inactiveProfiles,
        final List<ResolutionListener> listeners) throws RemoteException {
    final MavenExecutionRequest request = createRequest(file, activeProfiles, inactiveProfiles,
            Collections.<String>emptyList());

    request.setUpdateSnapshots(myAlwaysUpdateSnapshots);

    final AtomicReference<MavenExecutionResult> ref = new AtomicReference<MavenExecutionResult>();

    executeWithMavenSession(request, new Runnable() {
        @Override/* ww w. ja v  a2  s .c o  m*/
        public void run() {
            try {
                // copied from DefaultMavenProjectBuilder.buildWithDependencies
                ProjectBuilder builder = getComponent(ProjectBuilder.class);

                CustomMaven3ModelInterpolator2 modelInterpolator = (CustomMaven3ModelInterpolator2) getComponent(
                        ModelInterpolator.class);

                String savedLocalRepository = modelInterpolator.getLocalRepository();
                modelInterpolator.setLocalRepository(request.getLocalRepositoryPath().getAbsolutePath());
                List<ProjectBuildingResult> results;

                try {
                    // Don't use build(File projectFile, ProjectBuildingRequest request) , because it don't use cache !!!!!!!! (see http://devnet.jetbrains.com/message/5500218)
                    results = builder.build(Collections.singletonList(new File(file.getPath())), false,
                            request.getProjectBuildingRequest());
                } finally {
                    modelInterpolator.setLocalRepository(savedLocalRepository);
                }

                ProjectBuildingResult buildingResult = results.get(0);

                MavenProject project = buildingResult.getProject();

                RepositorySystemSession repositorySession = getComponent(LegacySupport.class)
                        .getRepositorySession();
                if (repositorySession instanceof DefaultRepositorySystemSession) {
                    ((DefaultRepositorySystemSession) repositorySession)
                            .setTransferListener(new TransferListenerAdapter(myCurrentIndicator));

                    if (myWorkspaceMap != null) {
                        ((DefaultRepositorySystemSession) repositorySession)
                                .setWorkspaceReader(new Maven32WorkspaceReader(myWorkspaceMap));
                    }
                }

                List<Exception> exceptions = new ArrayList<Exception>();
                loadExtensions(project, exceptions);

                //Artifact projectArtifact = project.getArtifact();
                //Map managedVersions = project.getManagedVersionMap();
                //ArtifactMetadataSource metadataSource = getComponent(ArtifactMetadataSource.class);
                project.setDependencyArtifacts(
                        project.createArtifacts(getComponent(ArtifactFactory.class), null, null));
                //

                if (USE_MVN2_COMPATIBLE_DEPENDENCY_RESOLVING) {
                    ArtifactResolutionRequest resolutionRequest = new ArtifactResolutionRequest();
                    resolutionRequest.setArtifactDependencies(project.getDependencyArtifacts());
                    resolutionRequest.setArtifact(project.getArtifact());
                    resolutionRequest.setManagedVersionMap(project.getManagedVersionMap());
                    resolutionRequest.setLocalRepository(myLocalRepository);
                    resolutionRequest.setRemoteRepositories(project.getRemoteArtifactRepositories());
                    resolutionRequest.setListeners(listeners);

                    resolutionRequest.setResolveRoot(false);
                    resolutionRequest.setResolveTransitively(true);

                    ArtifactResolver resolver = getComponent(ArtifactResolver.class);
                    ArtifactResolutionResult result = resolver.resolve(resolutionRequest);

                    project.setArtifacts(result.getArtifacts());
                    // end copied from DefaultMavenProjectBuilder.buildWithDependencies
                    ref.set(new MavenExecutionResult(project, exceptions));
                } else {
                    final DependencyResolutionResult dependencyResolutionResult = resolveDependencies(project,
                            repositorySession);
                    final List<Dependency> dependencies = dependencyResolutionResult.getDependencies();

                    Set<Artifact> artifacts = new LinkedHashSet<Artifact>(dependencies.size());
                    for (Dependency dependency : dependencies) {
                        final Artifact artifact = RepositoryUtils.toArtifact(dependency.getArtifact());
                        artifact.setScope(dependency.getScope());
                        artifact.setOptional(dependency.isOptional());
                        artifacts.add(artifact);
                        resolveAsModule(artifact);
                    }

                    project.setArtifacts(artifacts);
                    ref.set(new MavenExecutionResult(project, dependencyResolutionResult, exceptions));
                }
            } catch (Exception e) {
                ref.set(handleException(e));
            }
        }
    });

    return ref.get();
}

From source file:org.sourcepit.osgifier.maven.context.MavenDependencyWalker.java

License:Apache License

private Set<Artifact> resolve(Request walkerRequest, Artifact artifact, MavenProject resolutionContext,
        boolean resolveRoot, List<Dependency> dependencies) {
    final ArtifactResolutionRequest request = new ArtifactResolutionRequest();
    request.setArtifact(artifact);/*from w w  w .  j a  v a 2 s .  c  om*/
    request.setResolveRoot(resolveRoot);
    request.setResolveTransitively(!resolveRoot);

    if (dependencies != null) {
        final Set<Artifact> artifactDependencies = new LinkedHashSet<Artifact>();
        for (Dependency dependency : dependencies) {
            artifactDependencies.add(repositorySystem.createArtifactWithClassifier(dependency.getGroupId(),
                    dependency.getArtifactId(), dependency.getVersion(), dependency.getType(),
                    dependency.getClassifier()));
        }
        request.setArtifactDependencies(artifactDependencies);
    }

    request.setLocalRepository(walkerRequest.getLocalRepository());

    final List<ArtifactRepository> remoteRepositories = new ArrayList<ArtifactRepository>();
    final Set<String> repoIds = new HashSet<String>();
    final List<ArtifactRepository> requestRepos = walkerRequest.getRemoteRepositories();
    if (requestRepos != null) {
        for (ArtifactRepository artifactRepository : requestRepos) {
            repoIds.add(artifactRepository.getId());
            remoteRepositories.add(artifactRepository);
        }
    }

    if (resolutionContext != null) {
        for (ArtifactRepository artifactRepository : resolutionContext.getRemoteArtifactRepositories()) {
            if (repoIds.add(artifactRepository.getId())) {
                remoteRepositories.add(artifactRepository);
            }
        }
        request.setManagedVersionMap(resolutionContext.getManagedVersionMap());
    }

    request.setRemoteRepositories(remoteRepositories);

    final ArtifactFilter artifactFilter = walkerRequest.getArtifactFilter();

    request.setCollectionFilter(artifactFilter);
    request.setResolutionFilter(artifactFilter);

    ArtifactResolutionResult result = repositorySystem.resolve(request);

    final Exception ex;
    if (result.hasExceptions()) {
        ex = result.getExceptions().get(0);
    } else if (result.hasCircularDependencyExceptions()) {
        ex = result.getCircularDependencyException(0);
    } else if (result.hasErrorArtifactExceptions()) {
        ex = result.getErrorArtifactExceptions().get(0);
    } else if (result.hasMetadataResolutionExceptions()) {
        ex = result.getMetadataResolutionException(0);
    } else {
        ex = null;
    }
    if (ex != null) {
        throw new IllegalStateException(ex);
    }

    for (Artifact missingArtifact : result.getMissingArtifacts()) {
        throw Exceptions.pipe(new ArtifactNotFoundException("Unable to resolve artifact", missingArtifact));
    }

    return result.getArtifacts();
}