001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: *
017: */
018: package org.apache.ivy.core.cache;
019:
020: import java.text.ParseException;
021:
022: import org.apache.ivy.core.module.descriptor.Artifact;
023: import org.apache.ivy.core.module.descriptor.DependencyDescriptor;
024: import org.apache.ivy.core.module.descriptor.ModuleDescriptor;
025: import org.apache.ivy.core.report.ArtifactDownloadReport;
026: import org.apache.ivy.core.resolve.ResolvedModuleRevision;
027: import org.apache.ivy.plugins.repository.ArtifactResourceResolver;
028: import org.apache.ivy.plugins.repository.ResourceDownloader;
029: import org.apache.ivy.plugins.resolver.DependencyResolver;
030: import org.apache.ivy.plugins.resolver.util.ResolvedResource;
031:
032: public interface RepositoryCacheManager {
033:
034: /**
035: * Returns the name of the repository cache manager.
036: * @return the name of the repository cache manager.
037: */
038: public abstract String getName();
039:
040: /**
041: * Saves the information of which resolvers were used to resolve a module (both for metadata and
042: * artifact), so that this info can be loaded later (even after a jvm restart) for the use of
043: * {@link #findModuleInCache(DependencyDescriptor, CacheMetadataOptions, String)}.
044: *
045: * @param md
046: * the module descriptor resolved
047: * @param metadataResolverName
048: * metadata resolver name
049: * @param artifactResolverName
050: * artifact resolver name
051: */
052: public abstract void saveResolvers(ModuleDescriptor descriptor,
053: String metadataResolverName, String artifactResolverName);
054:
055: /**
056: * Returns the artifact origin of the given artifact as saved in this cache, or
057: * {@link ArtifactOrigin#UNKNOWN} if the origin is unknown.
058: *
059: * @param artifact
060: * the artifact for which the saved artifact origin should be returned.
061: * @return the artifact origin of the given artifact as saved in this cache
062: */
063: public abstract ArtifactOrigin getSavedArtifactOrigin(
064: Artifact artifact);
065:
066: /**
067: * Search a module descriptor in cache for a mrid
068: *
069: * @param dd
070: * the dependency descriptor identifying the module to search
071: * @param options
072: * options on how caching should be handled
073: * @param expectedResolver
074: * the resolver with which the md in cache must have been resolved to be returned,
075: * null if this doesn't matter
076: * @return the ResolvedModuleRevision corresponding to the module found, null if none correct
077: * has been found in cache
078: */
079: public abstract ResolvedModuleRevision findModuleInCache(
080: DependencyDescriptor dd, CacheMetadataOptions options,
081: String expectedResolver);
082:
083: /**
084: * Downloads an artifact to this cache.
085: *
086: * @param artifact
087: * the artifact to download
088: * @param resourceResolver
089: * a resource resolver to use if the artifact needs to be resolved to a Resource for
090: * downloading
091: * @param resourceDownloader
092: * a resource downloader to use if actual download of the resource is needed
093: * @param options
094: * a set of options to adjust the download
095: * @return a report indicating how the download was performed
096: */
097: public abstract ArtifactDownloadReport download(Artifact artifact,
098: ArtifactResourceResolver resourceResolver,
099: ResourceDownloader resourceDownloader,
100: CacheDownloadOptions options);
101:
102: /**
103: * Caches an original module descriptor.
104: * <p>
105: * After this call, the original module descriptor file (with no modification nor conversion)
106: * should be available as a local file.
107: * </p>
108: *
109: * @param resolver
110: * the dependency resolver from which the cache request comes from
111: * @param orginalMetadataRef
112: * a resolved resource pointing to the remote original module descriptor
113: * @param dd
114: * the dependency descriptor for which the module descriptor should be cached
115: * @param requestedMetadataArtifact
116: * the module descriptor artifact as requested originally
117: * @param downloader
118: * a ResourceDownloader able to download the original module descriptor resource if
119: * required by this cache implementation
120: * @param options
121: * options to apply to cache this module descriptor
122: * @return a {@link ResolvedModuleRevision} representing the local cached module descriptor, or
123: * null if it failed
124: * @throws ParseException
125: * if an exception occured while parsing the module descriptor
126: */
127: public ResolvedModuleRevision cacheModuleDescriptor(
128: DependencyResolver resolver,
129: ResolvedResource orginalMetadataRef,
130: DependencyDescriptor dd,
131: Artifact requestedMetadataArtifact,
132: ResourceDownloader downloader, CacheMetadataOptions options)
133: throws ParseException;
134:
135: /**
136: * Stores a standardized version of an original module descriptor in the cache for later use.
137: *
138: * @param resolver
139: * the dependency resolver from which the cache request comes from
140: * @param orginalMetadataRef
141: * a resolved resource pointing to the remote original module descriptor
142: * @param requestedMetadataArtifact
143: * the module descriptor artifact as requested originally
144: * @param rmr
145: * the {@link ResolvedModuleRevision} representing the local cached module descriptor
146: * @param writer
147: * a {@link ModuleDescriptorWriter} able to write the module descriptor to a stream.
148: */
149: public void originalToCachedModuleDescriptor(
150: DependencyResolver resolver,
151: ResolvedResource orginalMetadataRef,
152: Artifact requestedMetadataArtifact,
153: ResolvedModuleRevision rmr, ModuleDescriptorWriter writer);
154:
155: /**
156: * Cleans the whole cache.
157: */
158: public void clean();
159:
160: }
|