RepositoryUtils.java
/*
* 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;
import java.io.File;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.stream.Collectors;
import org.apache.maven.artifact.handler.ArtifactHandler;
import org.apache.maven.artifact.handler.DefaultArtifactHandler;
import org.apache.maven.artifact.handler.manager.ArtifactHandlerManager;
import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.artifact.repository.ArtifactRepositoryPolicy;
import org.apache.maven.impl.resolver.artifact.MavenArtifactProperties;
import org.eclipse.aether.DefaultRepositorySystemSession;
import org.eclipse.aether.RepositorySystem;
import org.eclipse.aether.RepositorySystemSession;
import org.eclipse.aether.artifact.Artifact;
import org.eclipse.aether.artifact.ArtifactProperties;
import org.eclipse.aether.artifact.ArtifactType;
import org.eclipse.aether.artifact.ArtifactTypeRegistry;
import org.eclipse.aether.artifact.DefaultArtifact;
import org.eclipse.aether.artifact.DefaultArtifactType;
import org.eclipse.aether.graph.Dependency;
import org.eclipse.aether.graph.DependencyFilter;
import org.eclipse.aether.graph.DependencyNode;
import org.eclipse.aether.graph.Exclusion;
import org.eclipse.aether.repository.Authentication;
import org.eclipse.aether.repository.LocalRepository;
import org.eclipse.aether.repository.LocalRepositoryManager;
import org.eclipse.aether.repository.Proxy;
import org.eclipse.aether.repository.RemoteRepository;
import org.eclipse.aether.repository.RepositoryPolicy;
import org.eclipse.aether.repository.WorkspaceReader;
import org.eclipse.aether.repository.WorkspaceRepository;
import org.eclipse.aether.util.repository.AuthenticationBuilder;
/**
* <strong>Warning:</strong> This is an internal utility class that is only public for technical reasons, it is not part
* of the public API. In particular, this class can be changed or deleted without prior notice.
*
*/
public class RepositoryUtils {
private static String nullify(String string) {
return (string == null || string.isEmpty()) ? null : string;
}
public static org.apache.maven.artifact.Artifact toArtifact(Dependency dependency) {
if (dependency == null) {
return null;
}
org.apache.maven.artifact.Artifact result = toArtifact(dependency.getArtifact());
result.setScope(dependency.getScope());
result.setOptional(dependency.isOptional());
return result;
}
public static org.apache.maven.artifact.Artifact toArtifact(Artifact artifact) {
if (artifact == null) {
return null;
}
ArtifactHandler handler = newHandler(artifact);
/*
* NOTE: From Artifact.hasClassifier(), an empty string and a null both denote "no classifier". However, some
* plugins only check for null, so be sure to nullify an empty classifier.
*/
org.apache.maven.artifact.Artifact result = new org.apache.maven.artifact.DefaultArtifact(
artifact.getGroupId(),
artifact.getArtifactId(),
artifact.getVersion(),
null,
artifact.getProperty(ArtifactProperties.TYPE, artifact.getExtension()),
nullify(artifact.getClassifier()),
handler);
result.setFile(artifact.getFile());
result.setResolved(artifact.getFile() != null);
List<String> trail = new ArrayList<>(1);
trail.add(result.getId());
result.setDependencyTrail(trail);
return result;
}
public static void toArtifacts(
Collection<org.apache.maven.artifact.Artifact> artifacts,
Collection<? extends DependencyNode> nodes,
List<String> trail,
DependencyFilter filter) {
for (DependencyNode node : nodes) {
org.apache.maven.artifact.Artifact artifact = toArtifact(node.getDependency());
List<String> nodeTrail = new ArrayList<>(trail.size() + 1);
nodeTrail.addAll(trail);
nodeTrail.add(artifact.getId());
if (filter == null || filter.accept(node, Collections.emptyList())) {
artifact.setDependencyTrail(nodeTrail);
artifacts.add(artifact);
}
toArtifacts(artifacts, node.getChildren(), nodeTrail, filter);
}
}
public static Artifact toArtifact(org.apache.maven.artifact.Artifact artifact) {
if (artifact == null) {
return null;
}
String version = artifact.getVersion();
if (version == null && artifact.getVersionRange() != null) {
version = artifact.getVersionRange().toString();
}
Map<String, String> props = null;
if (org.apache.maven.artifact.Artifact.SCOPE_SYSTEM.equals(artifact.getScope())) {
String localPath = (artifact.getFile() != null) ? artifact.getFile().getPath() : "";
props = Collections.singletonMap(MavenArtifactProperties.LOCAL_PATH, localPath);
}
Artifact result = new DefaultArtifact(
artifact.getGroupId(),
artifact.getArtifactId(),
artifact.getClassifier(),
artifact.getArtifactHandler().getExtension(),
version,
props,
newArtifactType(artifact.getType(), artifact.getArtifactHandler()));
result = result.setFile(artifact.getFile());
return result;
}
public static Dependency toDependency(
org.apache.maven.artifact.Artifact artifact, Collection<org.apache.maven.model.Exclusion> exclusions) {
if (artifact == null) {
return null;
}
Artifact result = toArtifact(artifact);
List<Exclusion> excl = Optional.ofNullable(exclusions).orElse(Collections.emptyList()).stream()
.map(RepositoryUtils::toExclusion)
.collect(Collectors.toList());
return new Dependency(result, artifact.getScope(), artifact.isOptional(), excl);
}
public static List<RemoteRepository> toRepos(List<ArtifactRepository> repos) {
return Optional.ofNullable(repos).orElse(Collections.emptyList()).stream()
.map(RepositoryUtils::toRepo)
.collect(Collectors.toList());
}
public static RemoteRepository toRepo(ArtifactRepository repo) {
RemoteRepository result = null;
if (repo != null) {
RemoteRepository.Builder builder =
new RemoteRepository.Builder(repo.getId(), getLayout(repo), repo.getUrl());
builder.setSnapshotPolicy(toPolicy(repo.getSnapshots()));
builder.setReleasePolicy(toPolicy(repo.getReleases()));
builder.setAuthentication(toAuthentication(repo.getAuthentication()));
builder.setProxy(toProxy(repo.getProxy()));
builder.setMirroredRepositories(toRepos(repo.getMirroredRepositories()));
builder.setBlocked(repo.isBlocked());
result = builder.build();
}
return result;
}
public static String getLayout(ArtifactRepository repo) {
try {
return repo.getLayout().getId();
} catch (LinkageError e) {
/*
* NOTE: getId() was added in 3.x and is as such not implemented by plugins compiled against 2.x APIs.
*/
String className = repo.getLayout().getClass().getSimpleName();
if (className.endsWith("RepositoryLayout")) {
String layout = className.substring(0, className.length() - "RepositoryLayout".length());
if (!layout.isEmpty()) {
layout = Character.toLowerCase(layout.charAt(0)) + layout.substring(1);
return layout;
}
}
return "";
}
}
private static RepositoryPolicy toPolicy(ArtifactRepositoryPolicy policy) {
RepositoryPolicy result = null;
if (policy != null) {
result = new RepositoryPolicy(policy.isEnabled(), policy.getUpdatePolicy(), policy.getChecksumPolicy());
}
return result;
}
private static Authentication toAuthentication(org.apache.maven.artifact.repository.Authentication auth) {
Authentication result = null;
if (auth != null) {
AuthenticationBuilder authBuilder = new AuthenticationBuilder();
authBuilder.addUsername(auth.getUsername()).addPassword(auth.getPassword());
authBuilder.addPrivateKey(auth.getPrivateKey(), auth.getPassphrase());
result = authBuilder.build();
}
return result;
}
private static Proxy toProxy(org.apache.maven.repository.Proxy proxy) {
Proxy result = null;
if (proxy != null) {
AuthenticationBuilder authBuilder = new AuthenticationBuilder();
authBuilder.addUsername(proxy.getUserName()).addPassword(proxy.getPassword());
result = new Proxy(proxy.getProtocol(), proxy.getHost(), proxy.getPort(), authBuilder.build());
}
return result;
}
public static ArtifactHandler newHandler(Artifact artifact) {
String type = artifact.getProperty(ArtifactProperties.TYPE, artifact.getExtension());
return new DefaultArtifactHandler(
type,
artifact.getExtension(),
null,
null,
null,
Boolean.parseBoolean(artifact.getProperty(MavenArtifactProperties.INCLUDES_DEPENDENCIES, "")),
artifact.getProperty(ArtifactProperties.LANGUAGE, null),
Boolean.parseBoolean(artifact.getProperty(MavenArtifactProperties.CONSTITUTES_BUILD_PATH, "")));
}
public static ArtifactType newArtifactType(String id, ArtifactHandler handler) {
return handler != null
? new DefaultArtifactType(
id,
handler.getExtension(),
handler.getClassifier(),
handler.getLanguage(),
handler.isAddedToClasspath(),
handler.isIncludesDependencies())
: null;
}
public static Dependency toDependency(
org.apache.maven.model.Dependency dependency, ArtifactTypeRegistry stereotypes) {
ArtifactType stereotype = stereotypes.get(dependency.getType());
if (stereotype == null) {
stereotype = new DefaultArtifactType(dependency.getType());
}
boolean system = dependency.getSystemPath() != null
&& !dependency.getSystemPath().isEmpty();
Map<String, String> props = null;
if (system) {
props = Collections.singletonMap(MavenArtifactProperties.LOCAL_PATH, dependency.getSystemPath());
}
Artifact artifact = new DefaultArtifact(
dependency.getGroupId(),
dependency.getArtifactId(),
dependency.getClassifier(),
null,
dependency.getVersion(),
props,
stereotype);
List<Exclusion> exclusions = dependency.getExclusions().stream()
.map(RepositoryUtils::toExclusion)
.collect(Collectors.toList());
return new Dependency(
artifact,
dependency.getScope(),
dependency.getOptional() != null ? dependency.isOptional() : null,
exclusions);
}
private static Exclusion toExclusion(org.apache.maven.model.Exclusion exclusion) {
return new Exclusion(exclusion.getGroupId(), exclusion.getArtifactId(), "*", "*");
}
/**
* @deprecated Use by maven-artifact-transfer.
*/
@Deprecated
public static ArtifactTypeRegistry newArtifactTypeRegistry(ArtifactHandlerManager handlerManager) {
return typeId -> newArtifactType(typeId, handlerManager.getArtifactHandler(typeId));
}
public static Collection<Artifact> toArtifacts(Collection<org.apache.maven.artifact.Artifact> artifactsToConvert) {
return artifactsToConvert.stream().map(RepositoryUtils::toArtifact).collect(Collectors.toList());
}
public static WorkspaceRepository getWorkspace(RepositorySystemSession session) {
WorkspaceReader reader = session.getWorkspaceReader();
return (reader != null) ? reader.getRepository() : null;
}
public static boolean repositoriesEquals(List<RemoteRepository> r1, List<RemoteRepository> r2) {
if (r1.size() != r2.size()) {
return false;
}
for (Iterator<RemoteRepository> it1 = r1.iterator(), it2 = r2.iterator(); it1.hasNext(); ) {
if (!repositoryEquals(it1.next(), it2.next())) {
return false;
}
}
return true;
}
public static int repositoriesHashCode(List<RemoteRepository> repositories) {
int result = 17;
for (RemoteRepository repository : repositories) {
result = 31 * result + repositoryHashCode(repository);
}
return result;
}
public static RepositorySystemSession overlay(
ArtifactRepository repository, RepositorySystemSession session, RepositorySystem system) {
if (repository == null || repository.getBasedir() == null) {
return session;
}
DefaultRepositorySystemSession newSession;
if (session != null) {
LocalRepositoryManager lrm = session.getLocalRepositoryManager();
if (lrm != null && lrm.getRepository().getBasedir().equals(new File(repository.getBasedir()))) {
return session;
}
newSession = new DefaultRepositorySystemSession(session);
} else {
newSession = new DefaultRepositorySystemSession(h -> false); // no close handle used
}
final LocalRepositoryManager llrm =
system.newLocalRepositoryManager(newSession, new LocalRepository(repository.getBasedir()));
newSession.setLocalRepositoryManager(llrm);
return newSession;
}
private static int repositoryHashCode(RemoteRepository repository) {
int result = 17;
Object obj = repository.getUrl();
result = 31 * result + (obj != null ? obj.hashCode() : 0);
return result;
}
private static boolean policyEquals(RepositoryPolicy p1, RepositoryPolicy p2) {
if (p1 == p2) {
return true;
}
// update policy doesn't affect contents
return p1.isEnabled() == p2.isEnabled() && Objects.equals(p1.getChecksumPolicy(), p2.getChecksumPolicy());
}
private static boolean repositoryEquals(RemoteRepository r1, RemoteRepository r2) {
if (r1 == r2) {
return true;
}
return Objects.equals(r1.getId(), r2.getId())
&& Objects.equals(r1.getUrl(), r2.getUrl())
&& policyEquals(r1.getPolicy(false), r2.getPolicy(false))
&& policyEquals(r1.getPolicy(true), r2.getPolicy(true));
}
}