| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package org.apache.maven.plugins.dependency.utils; |
| |
| import javax.inject.Inject; |
| import javax.inject.Named; |
| import javax.inject.Provider; |
| import javax.inject.Singleton; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.List; |
| import java.util.Objects; |
| import java.util.stream.Collectors; |
| |
| import org.apache.maven.execution.MavenSession; |
| import org.eclipse.aether.RepositorySystem; |
| import org.eclipse.aether.RepositorySystemSession; |
| import org.eclipse.aether.artifact.Artifact; |
| import org.eclipse.aether.artifact.ArtifactType; |
| import org.eclipse.aether.artifact.ArtifactTypeRegistry; |
| import org.eclipse.aether.artifact.DefaultArtifact; |
| import org.eclipse.aether.collection.CollectRequest; |
| import org.eclipse.aether.collection.CollectResult; |
| import org.eclipse.aether.collection.DependencyCollectionException; |
| import org.eclipse.aether.graph.Dependency; |
| import org.eclipse.aether.repository.RemoteRepository; |
| import org.eclipse.aether.repository.RepositoryPolicy; |
| import org.eclipse.aether.resolution.ArtifactRequest; |
| import org.eclipse.aether.resolution.ArtifactResolutionException; |
| import org.eclipse.aether.resolution.ArtifactResult; |
| import org.eclipse.aether.resolution.DependencyRequest; |
| import org.eclipse.aether.resolution.DependencyResolutionException; |
| import org.eclipse.aether.resolution.DependencyResult; |
| import org.eclipse.aether.util.graph.visitor.PreorderNodeListGenerator; |
| |
| /** |
| * Helper class for using Resolver API. |
| */ |
| @Named |
| @Singleton |
| public class ResolverUtil { |
| |
| private final RepositorySystem repositorySystem; |
| |
| private final Provider<MavenSession> mavenSessionProvider; |
| |
| @Inject |
| public ResolverUtil(RepositorySystem repositorySystem, Provider<MavenSession> mavenSessionProvider) { |
| this.repositorySystem = repositorySystem; |
| this.mavenSessionProvider = mavenSessionProvider; |
| } |
| |
| /** |
| * Collects the transitive dependencies. |
| * |
| * @param root a root dependency for collections |
| * @return a resolved dependencies collections |
| */ |
| public Collection<Dependency> collectDependencies(Dependency root) throws DependencyCollectionException { |
| |
| MavenSession session = mavenSessionProvider.get(); |
| |
| CollectRequest request = |
| new CollectRequest(root, session.getCurrentProject().getRemoteProjectRepositories()); |
| CollectResult result = repositorySystem.collectDependencies(session.getRepositorySession(), request); |
| |
| PreorderNodeListGenerator nodeListGenerator = new PreorderNodeListGenerator(); |
| result.getRoot().accept(nodeListGenerator); |
| return nodeListGenerator.getDependencies(true); |
| } |
| |
| /** |
| * Resolve given artifact |
| * |
| * @param artifact an artifact to resolve |
| * @param repositories remote repositories list |
| * @return resolved artifact |
| * @throws ArtifactResolutionException If the artifact could not be resolved. |
| */ |
| public Artifact resolveArtifact(Artifact artifact, List<RemoteRepository> repositories) |
| throws ArtifactResolutionException { |
| MavenSession session = mavenSessionProvider.get(); |
| ArtifactRequest request = new ArtifactRequest(artifact, repositories, null); |
| ArtifactResult result = repositorySystem.resolveArtifact(session.getRepositorySession(), request); |
| return result.getArtifact(); |
| } |
| |
| /** |
| * Resolve transitive dependencies for artifact. |
| * |
| * @param artifact an artifact to resolve |
| * @param repositories remote repositories list |
| * @return list of transitive dependencies for artifact |
| * @throws DependencyResolutionException If the dependency tree could not be built or any dependency artifact could |
| * not be resolved. |
| */ |
| public List<Artifact> resolveDependencies(Artifact artifact, List<RemoteRepository> repositories) |
| throws DependencyResolutionException { |
| MavenSession session = mavenSessionProvider.get(); |
| |
| CollectRequest collectRequest = new CollectRequest(new Dependency(artifact, null), repositories); |
| DependencyRequest request = new DependencyRequest(collectRequest, null); |
| DependencyResult result = repositorySystem.resolveDependencies(session.getRepositorySession(), request); |
| return result.getArtifactResults().stream() |
| .map(ArtifactResult::getArtifact) |
| .collect(Collectors.toList()); |
| } |
| |
| /** |
| * Prepare a remote repositories list for given descriptions. |
| * |
| * @param repositories remote repositories descriptions |
| * @return a list of remote repositories |
| */ |
| public List<RemoteRepository> remoteRepositories(List<String> repositories) { |
| MavenSession mavenSession = mavenSessionProvider.get(); |
| List<RemoteRepository> projectRepositories = |
| mavenSession.getCurrentProject().getRemoteProjectRepositories(); |
| if (repositories == null || repositories.isEmpty()) { |
| return projectRepositories; |
| } |
| |
| List<RemoteRepository> repositoriesList = |
| repositories.stream().map(this::prepareRemoteRepository).collect(Collectors.toList()); |
| repositoriesList = |
| repositorySystem.newResolutionRepositories(mavenSession.getRepositorySession(), repositoriesList); |
| |
| List<RemoteRepository> result = new ArrayList<>(projectRepositories); |
| result.addAll(repositoriesList); |
| return result; |
| } |
| |
| // protected for testing purpose |
| protected RemoteRepository prepareRemoteRepository(String repository) { |
| String[] items = Objects.requireNonNull(repository, "repository must be not null") |
| .split("::"); |
| String id = "temp"; |
| String type = null; |
| String url; |
| switch (items.length) { |
| case 3: |
| id = items[0]; |
| type = items[1]; |
| url = items[2]; |
| break; |
| case 2: |
| id = items[0]; |
| url = items[1]; |
| break; |
| case 1: |
| url = items[0]; |
| break; |
| default: |
| throw new IllegalArgumentException("Invalid repository: " + repository); |
| } |
| |
| if (type == null || type.isEmpty()) { |
| type = "default"; |
| } |
| |
| MavenSession mavenSession = mavenSessionProvider.get(); |
| RepositorySystemSession repositorySession = mavenSession.getRepositorySession(); |
| |
| String checksumPolicy = repositorySession.getChecksumPolicy(); |
| if (checksumPolicy == null) { |
| checksumPolicy = RepositoryPolicy.CHECKSUM_POLICY_WARN; |
| } |
| String updatePolicy = |
| mavenSession.getRequest().isUpdateSnapshots() ? RepositoryPolicy.UPDATE_POLICY_ALWAYS : null; |
| RepositoryPolicy repositoryPolicy = new RepositoryPolicy(true, updatePolicy, checksumPolicy); |
| |
| RemoteRepository.Builder builder = new RemoteRepository.Builder(id, type, url); |
| builder.setReleasePolicy(repositoryPolicy); |
| builder.setSnapshotPolicy(repositoryPolicy); |
| |
| return builder.build(); |
| } |
| |
| /** |
| * Create an artifact based on configuration from Mojo. |
| * |
| * @param paramArtifact an artifact configuration |
| * @return new artifact |
| */ |
| public Artifact createArtifactFromParams(ParamArtifact paramArtifact) { |
| Objects.requireNonNull(paramArtifact); |
| if (paramArtifact.getArtifact() != null) { |
| return createArtifactFromString(paramArtifact.getArtifact()); |
| } else { |
| ArtifactType artifactType = getArtifactType(paramArtifact.getPackaging()); |
| return new DefaultArtifact( |
| paramArtifact.getGroupId(), |
| paramArtifact.getArtifactId(), |
| paramArtifact.getClassifier(), |
| artifactType.getExtension(), |
| paramArtifact.getVersion(), |
| artifactType); |
| } |
| } |
| |
| private Artifact createArtifactFromString(String artifact) { |
| // groupId:artifactId:version[:packaging[:classifier]]. |
| String[] items = artifact.split(":"); |
| if (items.length < 3) { |
| throw new IllegalArgumentException("Invalid artifact format: " + artifact); |
| } |
| |
| ArtifactType artifactType = getArtifactType(items.length > 3 ? items[3] : null); |
| String classifier = items.length > 4 ? items[4] : null; |
| |
| return new DefaultArtifact(items[0], items[1], classifier, artifactType.getExtension(), items[2], artifactType); |
| } |
| |
| private ArtifactType getArtifactType(String packaging) { |
| ArtifactTypeRegistry artifactTypeRegistry = |
| mavenSessionProvider.get().getRepositorySession().getArtifactTypeRegistry(); |
| return artifactTypeRegistry.get(packaging != null ? packaging : "jar"); |
| } |
| } |