maven-compat/src/main/java/org/apache/maven/project/artifact/DefaultMavenMetadataCache.java - maven - Git at Google

 /*
  * 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<CacheKey, CacheRecord> cache = new ConcurrentHashMap<>();

     /**
      * CacheKey
      */
     public static class CacheKey {
         private final Artifact artifact;
         private final long pomHash;
         private final boolean resolveManagedVersions;
         private final List<ArtifactRepository> repositories = new ArrayList<>();
         private final int hashCode;

         public CacheKey(
                 Artifact artifact,
                 boolean resolveManagedVersions,
                 ArtifactRepository localRepository,
                 List<ArtifactRepository> 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<ArtifactRepository> 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<ArtifactRepository> r1, List<ArtifactRepository> r2) {
         if (r1.size() != r2.size()) {
             return false;
         }

         for (Iterator<ArtifactRepository> 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<Artifact> artifacts;
         private Map<String, Artifact> managedVersions;
         private List<ArtifactRepository> remoteRepositories;

         private long length;
         private long timestamp;

         CacheRecord(
                 Artifact pomArtifact,
                 Artifact relocatedArtifact,
                 Set<Artifact> artifacts,
                 Map<String, Artifact> managedVersions,
                 List<ArtifactRepository> 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<Artifact> getArtifacts() {
             return artifacts;
         }

         public Map<String, Artifact> getManagedVersions() {
             return managedVersions;
         }

         public List<ArtifactRepository> 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<ArtifactRepository> 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<Artifact> artifacts = ArtifactUtils.copyArtifacts(cacheRecord.getArtifacts(), new LinkedHashSet<>());
             Map<String, Artifact> 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<ArtifactRepository> remoteRepositories,
             ResolutionGroup result) {
         put(newCacheKey(artifact, resolveManagedVersions, localRepository, remoteRepositories), result);
     }

     protected CacheKey newCacheKey(
             Artifact artifact,
             boolean resolveManagedVersions,
             ArtifactRepository localRepository,
             List<ArtifactRepository> 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();
     }
 }
	/*
	* 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<CacheKey, CacheRecord> cache = new ConcurrentHashMap<>();

	/**
	* CacheKey
	*/
	public static class CacheKey {
	private final Artifact artifact;
	private final long pomHash;
	private final boolean resolveManagedVersions;
	private final List<ArtifactRepository> repositories = new ArrayList<>();
	private final int hashCode;

	public CacheKey(
	Artifact artifact,
	boolean resolveManagedVersions,
	ArtifactRepository localRepository,
	List<ArtifactRepository> 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<ArtifactRepository> 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<ArtifactRepository> r1, List<ArtifactRepository> r2) {
	if (r1.size() != r2.size()) {
	return false;
	}

	for (Iterator<ArtifactRepository> 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<Artifact> artifacts;
	private Map<String, Artifact> managedVersions;
	private List<ArtifactRepository> remoteRepositories;

	private long length;
	private long timestamp;

	CacheRecord(
	Artifact pomArtifact,
	Artifact relocatedArtifact,
	Set<Artifact> artifacts,
	Map<String, Artifact> managedVersions,
	List<ArtifactRepository> 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<Artifact> getArtifacts() {
	return artifacts;
	}

	public Map<String, Artifact> getManagedVersions() {
	return managedVersions;
	}

	public List<ArtifactRepository> 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<ArtifactRepository> 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<Artifact> artifacts = ArtifactUtils.copyArtifacts(cacheRecord.getArtifacts(), new LinkedHashSet<>());
	Map<String, Artifact> 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<ArtifactRepository> remoteRepositories,
	ResolutionGroup result) {
	put(newCacheKey(artifact, resolveManagedVersions, localRepository, remoteRepositories), result);
	}

	protected CacheKey newCacheKey(
	Artifact artifact,
	boolean resolveManagedVersions,
	ArtifactRepository localRepository,
	List<ArtifactRepository> 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();
	}
	}