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

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

Introduction

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

Prototype

public ArtifactResolutionRequest setManagedVersionMap(Map<String, Artifact> managedVersionMap) 

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 w w.  j  av a  2s. c om
        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  v a 2s  .com*/
        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//  w  ww.j ava 2 s  . com
        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.maven.bootstrap.core.AbstractBootstrapper.java

License:Apache License

private ArtifactResolutionResult resolve(MavenSession session, MavenProject project, Dependency dependency) {
    final ArtifactResolutionRequest request = new ArtifactResolutionRequest();
    request.setResolveRoot(true);/*from  w  ww. ja  va2s .c o m*/
    request.setResolveTransitively(true);

    final AndArtifactFilter artifactFilter = new AndArtifactFilter();
    artifactFilter.add(new ScopeArtifactFilter(org.apache.maven.artifact.Artifact.SCOPE_RUNTIME_PLUS_SYSTEM));
    artifactFilter.add(new ExclusionSetFilter(artifactFilterManager.getCoreArtifactExcludes()));

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

    final MavenExecutionRequest executionRequest = session.getRequest();
    request.setForceUpdate(executionRequest.isUpdateSnapshots());
    request.setServers(executionRequest.getServers());
    request.setMirrors(executionRequest.getMirrors());
    request.setProxies(executionRequest.getProxies());

    request.setOffline(session.isOffline());
    request.setLocalRepository(session.getLocalRepository());

    // project specific
    request.setRemoteRepositories(project.getRemoteArtifactRepositories());

    // important to NOT apply dep management here, leeds to unexpected side effects, e.g. when osgifier is managed in
    // project which is build. So separate deps from project which is build and build system is a good thing.
    // Note: we must explicitly set an empty map to prevent managed version resolution via maven session
    request.setManagedVersionMap(new HashMap<String, Artifact>());

    request.setArtifact(repositorySystem.createDependencyArtifact(dependency));

    final ArtifactResolutionResult result = repositorySystem.resolve(request);
    try {
        resolutionErrorHandler.throwErrors(request, result);
    } catch (ArtifactResolutionException e) {
        throw new IllegalStateException(e);
    }
    return result;
}

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);//  w ww .  j  ava  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();
}

From source file:org.sourcepit.tpmp.LocalizeTargetPlatformMojo.java

License:Apache License

private void download(MavenSession session, MavenProject project, File parentDir) {
    final Artifact platformArtifact = createPlatformArtifact(project);

    final ArtifactResolutionRequest request = new ArtifactResolutionRequest();
    request.setArtifact(platformArtifact);
    request.setResolveRoot(true);//from  w w w  .j a  v a2  s  .c  o m
    request.setResolveTransitively(false);
    request.setLocalRepository(session.getLocalRepository());
    request.setRemoteRepositories(project.getRemoteArtifactRepositories());
    request.setManagedVersionMap(project.getManagedVersionMap());
    request.setOffline(session.isOffline());

    repositorySystem.resolve(request);

    if (platformArtifact.getFile().exists()) {
        final ZipProcessingRequest unzipRequest = ZipProcessingRequest
                .newUnzipRequest(platformArtifact.getFile(), parentDir);
        try {
            new ZipProcessor().process(unzipRequest);
        } catch (IOException e) {
            throw Exceptions.pipe(e);
        }
    }
}