source.dussan.org Git - archiva.git/blob

   1 package org.apache.archiva.proxy.model;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  *  http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22 import org.apache.archiva.model.ArtifactReference;
  23 import org.apache.archiva.policies.Policy;
  24 import org.apache.archiva.policies.ProxyDownloadException;
  25 import org.apache.archiva.repository.ManagedRepository;
  26 import org.apache.archiva.repository.RepositoryType;
  27 import org.apache.archiva.repository.storage.StorageAsset;
  28
  29 import java.util.List;
  30 import java.util.Map;
  31
  32 /**
  33  * A repository proxy handler is used to fetch remote artifacts from different remote repositories.
  34  * A proxy handler is connected to one managed repository and a list of remote repositories.
  35  *
  36  * Repository proxies should not be confused with network proxies. Network are proxies for specific network protocols,
  37  * like HTTP. A repository proxy delegates the repository requests to remote repositories and caches artifacts.
  38  *
  39  * If a artifact is requested for the managed repository and the artifact is not cached locally, the handler goes through
  40  * the list of remotes and tries to download the artifact. If a download was successful the artifact is cached locally.
  41  *
  42  * The connection between managed and remote repositories is defined by list of {@link ProxyConnector} each defines a one-to-one relationship.
  43  *
  44  * A proxy connector defines specifics about the download behaviour:
  45  * <ul>
  46  * <li>Policies {@link org.apache.archiva.policies.Policy} define the behaviour for different cases (errors, not available, caching lifetime).</li>
  47  * <li>Black- and Whitelists are used to ban or allow certain paths on the remote repositories.
  48  * </ul>
  49  *
  50  * The policies and black- and whitelist are set on the {@link ProxyConnector}
  51  *
  52  * There may be network proxies needed to connect the remote repositories.
  53  *
  54  */
  55 public interface RepositoryProxyHandler
  56 {
  57
  58     List<RepositoryType> supports( );
  59
  60     /**
  61      * Performs the artifact fetch operation against the target repositories
  62      * of the provided source repository.
  63      * <p>
  64      * If the artifact is found, it is downloaded and placed into the source repository
  65      * filesystem.
  66      *
  67      * @param repository the source repository to use. (must be a managed repository)
  68      * @param artifact   the artifact to fetch.
  69      * @return the file that was obtained, or null if no content was obtained
  70      * @throws ProxyDownloadException if there was a problem fetching the content from the target repositories.
  71      */
  72     StorageAsset fetchFromProxies( ManagedRepository repository, ArtifactReference artifact )
  73         throws ProxyDownloadException;
  74
  75     /**
  76      * Performs the metadata fetch operation against the target repositories
  77      * of the provided source repository.
  78      * <p>
  79      * If the metadata is found, it is downloaded and placed into the source repository
  80      * filesystem.
  81      *
  82      * @param repository  the source repository to use. (must be a managed repository)
  83      * @param logicalPath the metadata to fetch.
  84      * @return the file that was obtained, or null if no content was obtained
  85      */
  86     ProxyFetchResult fetchMetadataFromProxies( ManagedRepository repository, String logicalPath );
  87
  88     /**
  89      * Performs the fetch operation against the target repositories
  90      * of the provided source repository by a specific path.
  91      *
  92      * @param managedRepository the source repository to use. (must be a managed repository)
  93      * @param path              the path of the resource to fetch
  94      * @return the file that was obtained, or null if no content was obtained
  95      */
  96     StorageAsset fetchFromProxies( ManagedRepository managedRepository, String path );
  97
  98     /**
  99      * Get the List of {@link ProxyConnector} objects of the source repository.
 100      *
 101      * @param repository the source repository to look for.
 102      * @return the List of {@link ProxyConnector} objects.
 103      */
 104     List<ProxyConnector> getProxyConnectors( ManagedRepository repository );
 105
 106     /**
 107      * Tests to see if the provided repository is a source repository for
 108      * any {@link ProxyConnector} objects.
 109      *
 110      * @param repository the source repository to look for.
 111      * @return true if there are proxy connectors that use the provided
 112      * repository as a source repository.
 113      */
 114     boolean hasProxies( ManagedRepository repository );
 115
 116     /**
 117      * Sets network proxies (normally HTTP proxies) to access the remote repositories.
 118      *
 119      * @param networkProxies A map of (repository id, network proxy) where the repository id must be the id of an
 120      *                existing remote repository.
 121      */
 122     void setNetworkProxies( Map<String, NetworkProxy> networkProxies );
 123
 124     /**
 125      * Adds a network proxy that is used to access the remote repository.
 126      *
 127      * @param id The repository id
 128      * @param networkProxy The network proxy to use
 129      */
 130     void addNetworkproxy( String id, NetworkProxy networkProxy);
 131
 132     /**
 133      * Returns a map of the defined network proxies, or a empty map, if no proxy is defined.
 134      *
 135      * @return A map (repository id, network proxy). If none is defined, a empty map is returned.
 136      */
 137     Map<String, NetworkProxy> getNetworkProxies( );
 138
 139     /**
 140      * Returns the network proxy that is defined for the given repository id.
 141      * @param id The remote repository id
 142      * @return A network proxy or <code>null</code> if no one is defined for this id.
 143      */
 144     NetworkProxy getNetworkProxy( String id );
 145
 146     /**
 147      * Returns the proxy handler implementation. This can be used, if the underlying implementation for a specific
 148      * repository type is needed.
 149      *
 150      * @param clazz The class to convert to
 151      * @param <T>   The type
 152      * @return The handler
 153      */
 154     <T extends RepositoryProxyHandler> T getHandler( Class<T> clazz ) throws IllegalArgumentException;
 155
 156     /**
 157      * Sets the policies that this handler should validate.
 158      * @param policyList
 159      */
 160     void setPolicies(List<Policy> policyList);
 161
 162     /**
 163      * Adds a policy
 164      * @param policy
 165      */
 166     void addPolicy( Policy policy );
 167
 168     /**
 169      * Removes a policy
 170      * @param policy
 171      */
 172     void removePolicy( Policy policy );
 173
 174     void addProxyConnector(ProxyConnector connector);
 175
 176     void setProxyConnectors( List<ProxyConnector> proxyConnectors );
 177 }