org.apache.maven.project.artifact.DefaultMavenMetadataCache Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of maven-compat Show documentation
Show all versions of maven-compat Show documentation
Maven2 classes maintained as compatibility layer.
/*
* 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.project.artifact;
import javax.inject.Named;
import javax.inject.Singleton;
import java.io.File;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.ArtifactUtils;
import org.apache.maven.artifact.metadata.ResolutionGroup;
import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.artifact.repository.ArtifactRepositoryPolicy;
/**
* DefaultMavenMetadataCache
*/
@Named
@Singleton
@Deprecated
public class DefaultMavenMetadataCache implements MavenMetadataCache {
protected final Map cache = new ConcurrentHashMap<>();
/**
* CacheKey
*/
public static class CacheKey {
private final Artifact artifact;
private final long pomHash;
private final boolean resolveManagedVersions;
private final List repositories = new ArrayList<>();
private final int hashCode;
public CacheKey(
Artifact artifact,
boolean resolveManagedVersions,
ArtifactRepository localRepository,
List remoteRepositories) {
File file = artifact.getFile();
this.artifact = ArtifactUtils.copyArtifact(artifact);
if ("pom".equals(artifact.getType()) && file != null) {
pomHash = file.getPath().hashCode() + file.lastModified();
} else {
pomHash = 0;
}
this.resolveManagedVersions = resolveManagedVersions;
this.repositories.add(localRepository);
this.repositories.addAll(remoteRepositories);
int hash = 17;
hash = hash * 31 + artifactHashCode(artifact);
hash = hash * 31 + (resolveManagedVersions ? 1 : 2);
hash = hash * 31 + repositoriesHashCode(repositories);
this.hashCode = hash;
}
@Override
public int hashCode() {
return hashCode;
}
@Override
public boolean equals(Object o) {
if (o == this) {
return true;
}
if (!(o instanceof CacheKey)) {
return false;
}
CacheKey other = (CacheKey) o;
return pomHash == other.pomHash
&& artifactEquals(artifact, other.artifact)
&& resolveManagedVersions == other.resolveManagedVersions
&& repositoriesEquals(repositories, other.repositories);
}
}
private static int artifactHashCode(Artifact a) {
int result = 17;
result = 31 * result + a.getGroupId().hashCode();
result = 31 * result + a.getArtifactId().hashCode();
result = 31 * result + a.getType().hashCode();
if (a.getVersion() != null) {
result = 31 * result + a.getVersion().hashCode();
}
result = 31 * result + (a.getClassifier() != null ? a.getClassifier().hashCode() : 0);
result = 31 * result + (a.getScope() != null ? a.getScope().hashCode() : 0);
result = 31 * result
+ (a.getDependencyFilter() != null ? a.getDependencyFilter().hashCode() : 0);
result = 31 * result + (a.isOptional() ? 1 : 0);
return result;
}
private static boolean artifactEquals(Artifact a1, Artifact a2) {
if (a1 == a2) {
return true;
}
return Objects.equals(a1.getGroupId(), a2.getGroupId())
&& Objects.equals(a1.getArtifactId(), a2.getArtifactId())
&& Objects.equals(a1.getType(), a2.getType())
&& Objects.equals(a1.getVersion(), a2.getVersion())
&& Objects.equals(a1.getClassifier(), a2.getClassifier())
&& Objects.equals(a1.getScope(), a2.getScope())
&& Objects.equals(a1.getDependencyFilter(), a2.getDependencyFilter())
&& a1.isOptional() == a2.isOptional();
}
private static int repositoryHashCode(ArtifactRepository repository) {
int result = 17;
result = 31 * result + (repository.getId() != null ? repository.getId().hashCode() : 0);
return result;
}
private static int repositoriesHashCode(List repositories) {
int result = 17;
for (ArtifactRepository repository : repositories) {
result = 31 * result + repositoryHashCode(repository);
}
return result;
}
private static boolean repositoryEquals(ArtifactRepository r1, ArtifactRepository r2) {
if (r1 == r2) {
return true;
}
return Objects.equals(r1.getId(), r2.getId())
&& Objects.equals(r1.getUrl(), r2.getUrl())
&& repositoryPolicyEquals(r1.getReleases(), r2.getReleases())
&& repositoryPolicyEquals(r1.getSnapshots(), r2.getSnapshots());
}
private static boolean repositoryPolicyEquals(ArtifactRepositoryPolicy p1, ArtifactRepositoryPolicy p2) {
if (p1 == p2) {
return true;
}
return p1.isEnabled() == p2.isEnabled() && Objects.equals(p1.getUpdatePolicy(), p2.getUpdatePolicy());
}
private static boolean repositoriesEquals(List r1, List r2) {
if (r1.size() != r2.size()) {
return false;
}
for (Iterator it1 = r1.iterator(), it2 = r2.iterator(); it1.hasNext(); ) {
if (!repositoryEquals(it1.next(), it2.next())) {
return false;
}
}
return true;
}
/**
* CacheRecord
*/
public class CacheRecord {
private Artifact pomArtifact;
private Artifact relocatedArtifact;
private List artifacts;
private Map managedVersions;
private List remoteRepositories;
private long length;
private long timestamp;
CacheRecord(
Artifact pomArtifact,
Artifact relocatedArtifact,
Set artifacts,
Map managedVersions,
List remoteRepositories) {
this.pomArtifact = ArtifactUtils.copyArtifact(pomArtifact);
this.relocatedArtifact = ArtifactUtils.copyArtifactSafe(relocatedArtifact);
this.artifacts = ArtifactUtils.copyArtifacts(artifacts, new ArrayList<>());
this.remoteRepositories = new ArrayList<>(remoteRepositories);
this.managedVersions = managedVersions;
if (managedVersions != null) {
this.managedVersions = ArtifactUtils.copyArtifacts(managedVersions, new LinkedHashMap<>());
}
File pomFile = pomArtifact.getFile();
if (pomFile != null && pomFile.canRead()) {
this.length = pomFile.length();
this.timestamp = pomFile.lastModified();
} else {
this.length = -1;
this.timestamp = -1;
}
}
public Artifact getArtifact() {
return pomArtifact;
}
public Artifact getRelocatedArtifact() {
return relocatedArtifact;
}
public List getArtifacts() {
return artifacts;
}
public Map getManagedVersions() {
return managedVersions;
}
public List getRemoteRepositories() {
return remoteRepositories;
}
public boolean isStale() {
File pomFile = pomArtifact.getFile();
if (pomFile != null) {
if (pomFile.canRead()) {
return length != pomFile.length() || timestamp != pomFile.lastModified();
} else {
// if the POM didn't exist, retry if any repo is configured to always update
boolean snapshot = pomArtifact.isSnapshot();
for (ArtifactRepository repository : remoteRepositories) {
ArtifactRepositoryPolicy policy =
snapshot ? repository.getSnapshots() : repository.getReleases();
if (ArtifactRepositoryPolicy.UPDATE_POLICY_ALWAYS.equals(policy.getUpdatePolicy())) {
return true;
}
}
}
}
return length != -1 || timestamp != -1;
}
}
public ResolutionGroup get(
Artifact artifact,
boolean resolveManagedVersions,
ArtifactRepository localRepository,
List remoteRepositories) {
CacheKey cacheKey = newCacheKey(artifact, resolveManagedVersions, localRepository, remoteRepositories);
CacheRecord cacheRecord = cache.get(cacheKey);
if (cacheRecord != null && !cacheRecord.isStale()) {
Artifact pomArtifact = ArtifactUtils.copyArtifact(cacheRecord.getArtifact());
Artifact relocatedArtifact = ArtifactUtils.copyArtifactSafe(cacheRecord.getRelocatedArtifact());
Set artifacts = ArtifactUtils.copyArtifacts(cacheRecord.getArtifacts(), new LinkedHashSet<>());
Map managedVersions = cacheRecord.getManagedVersions();
if (managedVersions != null) {
managedVersions = ArtifactUtils.copyArtifacts(managedVersions, new LinkedHashMap<>());
}
return new ResolutionGroup(
pomArtifact, relocatedArtifact, artifacts, managedVersions, cacheRecord.getRemoteRepositories());
}
cache.remove(cacheKey);
return null;
}
public void put(
Artifact artifact,
boolean resolveManagedVersions,
ArtifactRepository localRepository,
List remoteRepositories,
ResolutionGroup result) {
put(newCacheKey(artifact, resolveManagedVersions, localRepository, remoteRepositories), result);
}
protected CacheKey newCacheKey(
Artifact artifact,
boolean resolveManagedVersions,
ArtifactRepository localRepository,
List remoteRepositories) {
return new CacheKey(artifact, resolveManagedVersions, localRepository, remoteRepositories);
}
protected void put(CacheKey cacheKey, ResolutionGroup result) {
CacheRecord cacheRecord = new CacheRecord(
result.getPomArtifact(),
result.getRelocatedArtifact(),
result.getArtifacts(),
result.getManagedVersions(),
result.getResolutionRepositories());
cache.put(cacheKey, cacheRecord);
}
public void flush() {
cache.clear();
}
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy