* @param key
* @param value
*/
- public void addPolicy( Object key, String value )
+ public void addPolicy( String key, String value )
{
getPolicies().put( key, value );
} //-- void addPolicy( Object, String )
* @param key
* @param value
*/
- public void addProperty( Object key, String value )
+ public void addProperty( String key, String value )
{
getProperties().put( key, value );
} //-- void addProperty( Object, String )
*
* @return Map
*/
- public java.util.Map getPolicies()
+ public java.util.Map<String, String> getPolicies()
{
if ( this.policies == null )
{
*
* @return Map
*/
- public java.util.Map getProperties()
+ public java.util.Map<String, String> getProperties()
{
if ( this.properties == null )
{
* Returns the list of all proxy connectors.
* @return
*/
- public List<org.apache.archiva.proxy.model.ProxyConnector> getProxyConnectors();
+ List<org.apache.archiva.proxy.model.ProxyConnector> getProxyConnectors( );
/**
* Returns a map of connector lists with the source repository id as key
* @return A map with source repository ids as key and list of corresponding proxy connector objects as value.
*/
- public Map<String, List<ProxyConnector>> getProxyConnectorAsMap();
+ Map<String, List<ProxyConnector>> getProxyConnectorAsMap( );
+
+ /**
+ * Reloads the proxies from the configuration.
+ */
+ void reload();
}
* under the License.
*/
+import org.apache.archiva.policies.Policy;
+import org.apache.archiva.policies.PolicyOption;
import org.apache.archiva.repository.ManagedRepository;
-import org.apache.archiva.repository.ManagedRepositoryContent;
import org.apache.archiva.repository.RemoteRepository;
-import org.apache.archiva.repository.RemoteRepositoryContent;
import org.apache.archiva.repository.connector.RepositoryConnector;
import java.util.Iterator;
import java.util.Map;
/**
- * This represents a connector for a repository to repository proxy.
+ * This represents a connector for a repository to a remote repository that is proxied.
*/
public class ProxyConnector
implements RepositoryConnector
private int order;
- private Map<String, String> policies;
+ private Map<Policy, PolicyOption> policies;
- private boolean disabled;
+ private boolean enabled;
private Map<String, String> properties;
// no op
}
+ /**
+ * @see RepositoryConnector#isEnabled()
+ */
@Override
- public boolean isDisabled()
+ public boolean isEnabled()
{
- return disabled;
+ return enabled;
}
+
+ /**
+ * @see RepositoryConnector#enable()
+ */
+ @Override
+ public void enable()
+ {
+ this.enabled = true;
+ }
+
+ /**
+ * @see RepositoryConnector#disable()
+ */
@Override
- public void setDisabled( boolean disabled )
+ public void disable( )
{
- this.disabled = disabled;
+ this.enabled = false;
}
+ /**
+ * @see RepositoryConnector#getBlacklist()
+ */
@Override
public List<String> getBlacklist()
{
return blacklist;
}
+ /**
+ * Sets the blacklist. The list is a string of paths.
+ *
+ * @param blacklist List of paths.
+ */
public void setBlacklist( List<String> blacklist )
{
this.blacklist = blacklist;
}
+ /**
+ * @see RepositoryConnector#getSourceRepository()
+ */
@Override
public ManagedRepository getSourceRepository()
{
return sourceRepository;
}
+ /**
+ * Sets the source repository.
+ * @param sourceRepository The managed repository which is the local representation of the proxy.
+ */
public void setSourceRepository( ManagedRepository sourceRepository )
{
this.sourceRepository = sourceRepository;
}
+ /**
+ * @see ProxyConnector#getTargetRepository()
+ */
@Override
public RemoteRepository getTargetRepository()
{
return targetRepository;
}
+ /**
+ * Sets the target repository.
+ * @param targetRepository The remote repository, where the artifacts are downloaded from.
+ */
public void setTargetRepository( RemoteRepository targetRepository )
{
this.targetRepository = targetRepository;
}
+ /**
+ * @see ProxyConnector#getWhitelist()
+ */
@Override
public List<String> getWhitelist()
{
return whitelist;
}
+ /**
+ * Sets the list of paths that are proxied.
+ * @param whitelist List of paths.
+ */
public void setWhitelist( List<String> whitelist )
{
this.whitelist = whitelist;
}
- public Map<String, String> getPolicies()
+ /**
+ * Returns the policies that are defined
+ * @return
+ */
+ public Map<Policy, PolicyOption> getPolicies()
{
return policies;
}
- public void setPolicies( Map<String, String> policies )
+ /**
+ * Sets policies that set the behaviour of this proxy connector.
+ * @param policies A map of policies with each option.
+ */
+ public void setPolicies( Map<Policy, PolicyOption> policies )
{
this.policies = policies;
}
+ /**
+ * Adds a new policy.
+ * @param policy The policy to add.
+ * @param option The option for the policy.
+ */
+ public void addPolicy( Policy policy, PolicyOption option )
+ {
+ this.policies.put( policy, option );
+ }
+
+ /**
+ * Returns the id of this proxy connector.
+ * @return The id string.
+ */
public String getProxyId()
{
return proxyId;
}
+ /**
+ * Sets the id of this proxy connector.
+ * @param proxyId A id string.
+ */
public void setProxyId( String proxyId )
{
this.proxyId = proxyId;
sb.append( " target: [remote] " ).append( this.targetRepository.getId() ).append( "\n" );
sb.append( " proxyId:" ).append( this.proxyId ).append( "\n" );
- Iterator<String> keys = this.policies.keySet().iterator();
+ Iterator<Policy> keys = this.policies.keySet().iterator();
while ( keys.hasNext() )
{
- String name = keys.next();
+ String name = keys.next().getId();
sb.append( " policy[" ).append( name ).append( "]:" );
sb.append( this.policies.get( name ) ).append( "\n" );
}
return sb.toString();
}
- public void setPolicy( String policyId, String policySetting )
- {
- this.policies.put( policyId, policySetting );
- }
-
+ /**
+ * Returns a number that orders the proxy connectors numerically.
+ * @return The order number of this connector.
+ */
public int getOrder()
{
return order;
}
+ /**
+ * Set the order number of this proxy connector.
+ *
+ * @param order The order number.
+ */
public void setOrder( int order )
{
this.order = order;
}
-
+ /**
+ * Returns additional properties defined for this connector.
+ * @return Map of key, value pairs.
+ */
public Map<String, String> getProperties() {
return properties;
}
+ /**
+ * Sets additional properties for this connector.
+ * @param properties Map of key, value pairs.
+ */
public void setProperties(Map<String, String> properties) {
this.properties = properties;
}
*/
import org.apache.archiva.model.ArtifactReference;
+import org.apache.archiva.policies.Policy;
import org.apache.archiva.policies.ProxyDownloadException;
-import org.apache.archiva.repository.ManagedRepositoryContent;
+import org.apache.archiva.repository.ManagedRepository;
import org.apache.archiva.repository.RepositoryType;
import org.apache.archiva.repository.storage.StorageAsset;
import java.util.Map;
/**
- * Handler for potential repository proxy connectors.
+ * A repository proxy handler is used to fetch remote artifacts from different remote repositories.
+ * A proxy handler is connected to one managed repository and a list of remote repositories.
*
+ * Repository proxies should not be confused with network proxies. Network are proxies for specific network protocols,
+ * like HTTP. A repository proxy delegates the repository requests to remote repositories and caches artifacts.
+ *
+ * If a artifact is requested for the managed repository and the artifact is not cached locally, the handler goes through
+ * the list of remotes and tries to download the artifact. If a download was successful the artifact is cached locally.
+ *
+ * The connection between managed and remote repositories is defined by list of {@link ProxyConnector} each defines a one-to-one relationship.
+ *
+ * A proxy connector defines specifics about the download behaviour:
+ * <ul>
+ * <li>Policies {@link org.apache.archiva.policies.Policy} define the behaviour for different cases (errors, not available, caching lifetime).</li>
+ * <li>Black- and Whitelists are used to ban or allow certain paths on the remote repositories.
+ * </ul>
+ *
+ * The policies and black- and whitelist are set on the {@link ProxyConnector}
+ *
+ * There may be network proxies needed to connect the remote repositories.
*
*/
public interface RepositoryProxyHandler
{
- List<RepositoryType> supports();
+ List<RepositoryType> supports( );
/**
* Performs the artifact fetch operation against the target repositories
* of the provided source repository.
- *
+ * <p>
* If the artifact is found, it is downloaded and placed into the source repository
* filesystem.
- *
+ *
* @param repository the source repository to use. (must be a managed repository)
- * @param artifact the artifact to fetch.
+ * @param artifact the artifact to fetch.
* @return the file that was obtained, or null if no content was obtained
* @throws ProxyDownloadException if there was a problem fetching the content from the target repositories.
*/
- StorageAsset fetchFromProxies( ManagedRepositoryContent repository, ArtifactReference artifact )
+ StorageAsset fetchFromProxies( ManagedRepository repository, ArtifactReference artifact )
throws ProxyDownloadException;
-
+
/**
* Performs the metadata fetch operation against the target repositories
* of the provided source repository.
- *
+ * <p>
* If the metadata is found, it is downloaded and placed into the source repository
* filesystem.
- *
- * @param repository the source repository to use. (must be a managed repository)
+ *
+ * @param repository the source repository to use. (must be a managed repository)
* @param logicalPath the metadata to fetch.
* @return the file that was obtained, or null if no content was obtained
*/
- ProxyFetchResult fetchMetadataFromProxies( ManagedRepositoryContent repository, String logicalPath );
+ ProxyFetchResult fetchMetadataFromProxies( ManagedRepository repository, String logicalPath );
/**
* Performs the fetch operation against the target repositories
- * of the provided source repository.
- *
+ * of the provided source repository by a specific path.
+ *
* @param managedRepository the source repository to use. (must be a managed repository)
- * @param path the path of the resource to fetch
+ * @param path the path of the resource to fetch
* @return the file that was obtained, or null if no content was obtained
*/
- StorageAsset fetchFromProxies( ManagedRepositoryContent managedRepository, String path );
+ StorageAsset fetchFromProxies( ManagedRepository managedRepository, String path );
/**
* Get the List of {@link ProxyConnector} objects of the source repository.
- *
+ *
* @param repository the source repository to look for.
* @return the List of {@link ProxyConnector} objects.
*/
- List<ProxyConnector> getProxyConnectors( ManagedRepositoryContent repository );
+ List<ProxyConnector> getProxyConnectors( ManagedRepository repository );
/**
* Tests to see if the provided repository is a source repository for
* any {@link ProxyConnector} objects.
- *
+ *
* @param repository the source repository to look for.
- * @return true if there are proxy connectors that use the provided
- * repository as a source repository.
+ * @return true if there are proxy connectors that use the provided
+ * repository as a source repository.
*/
- boolean hasProxies( ManagedRepositoryContent repository );
+ boolean hasProxies( ManagedRepository repository );
- void setNetworkProxies(Map<String, NetworkProxy> proxies);
+ /**
+ * Sets network proxies (normally HTTP proxies) to access the remote repositories.
+ *
+ * @param networkProxies A map of (repository id, network proxy) where the repository id must be the id of an
+ * existing remote repository.
+ */
+ void setNetworkProxies( Map<String, NetworkProxy> networkProxies );
- Map<String, NetworkProxy> getNetworkProxies();
+ /**
+ * Adds a network proxy that is used to access the remote repository.
+ *
+ * @param id The repository id
+ * @param networkProxy The network proxy to use
+ */
+ void addNetworkproxy( String id, NetworkProxy networkProxy);
+
+ /**
+ * Returns a map of the defined network proxies, or a empty map, if no proxy is defined.
+ *
+ * @return A map (repository id, network proxy). If none is defined, a empty map is returned.
+ */
+ Map<String, NetworkProxy> getNetworkProxies( );
- NetworkProxy getNetworkProxy(String id);
+ /**
+ * Returns the network proxy that is defined for the given repository id.
+ * @param id The remote repository id
+ * @return A network proxy or <code>null</code> if no one is defined for this id.
+ */
+ NetworkProxy getNetworkProxy( String id );
+
+ /**
+ * Returns the proxy handler implementation. This can be used, if the underlying implementation for a specific
+ * repository type is needed.
+ *
+ * @param clazz The class to convert to
+ * @param <T> The type
+ * @return The handler
+ */
+ <T extends RepositoryProxyHandler> T getHandler( Class<T> clazz ) throws IllegalArgumentException;
+
+ /**
+ * Sets the policies that this handler should validate.
+ * @param policyList
+ */
+ void setPolicies(List<Policy> policyList);
+
+ /**
+ * Adds a policy
+ * @param policy
+ */
+ void addPolicy( Policy policy );
+
+ /**
+ * Removes a policy
+ * @param policy
+ */
+ void removePolicy( Policy policy );
+ void addProxyConnector(ProxyConnector connector);
+ void setProxyConnectors( List<ProxyConnector> proxyConnectors );
}
*/
import org.apache.archiva.configuration.*;
+import org.apache.archiva.policies.Policy;
+import org.apache.archiva.policies.PolicyOption;
+import org.apache.archiva.policies.PolicyUtil;
import org.apache.archiva.proxy.model.NetworkProxy;
import org.apache.archiva.proxy.model.ProxyConnector;
import org.apache.archiva.proxy.model.RepositoryProxyHandler;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import java.util.*;
+import java.util.function.Function;
import java.util.stream.Collectors;
/**
* proxy information.
*
*/
+@SuppressWarnings( "SpringJavaInjectionPointsAutowiringInspection" )
@Service("proxyRegistry#default")
public class ArchivaProxyRegistry implements ProxyRegistry, ConfigurationListener {
@Inject
List<RepositoryProxyHandler> repositoryProxyHandlers;
+ @Inject
+ List<Policy> policies;
+
@Inject
RepositoryRegistry repositoryRegistry;
private Map<String, List<ProxyConnector>> connectorMap = new HashMap<>();
private List<ProxyConnector> connectorList = new ArrayList<>();
+ private Map<Policy, PolicyOption> policyMap = new HashMap<>( );
@PostConstruct
if (repositoryProxyHandlers == null) {
repositoryProxyHandlers = new ArrayList<>();
}
+ archivaConfiguration.addListener( this );
updateHandler();
+ updateConnectors();
updateNetworkProxies();
}
proxy.setHost(networkProxyConfig.getHost());
proxy.setPort(networkProxyConfig.getPort());
proxy.setUsername(networkProxyConfig.getUsername());
- proxy.setPassword(networkProxyConfig.getPassword().toCharArray());
+ proxy.setPassword(networkProxyConfig.getPassword()==null? new char[0] : networkProxyConfig.getPassword().toCharArray());
proxy.setUseNtlm(networkProxyConfig.isUseNtlm());
this.networkProxyMap.put(key, proxy);
}
- for (RepositoryProxyHandler connectors : repositoryProxyHandlers) {
- connectors.setNetworkProxies(this.networkProxyMap);
+ for (RepositoryProxyHandler proxyHandler : repositoryProxyHandlers) {
+ proxyHandler.setNetworkProxies(this.networkProxyMap);
}
}
- private void updateHandler() {
+ private void updateHandler( ) {
+
for (RepositoryProxyHandler handler : repositoryProxyHandlers) {
List<RepositoryType> types = handler.supports();
for (RepositoryType type : types) {
}
handlerMap.get(type).add(handler);
}
+ handler.setPolicies( policies );
}
}
private void updateConnectors() {
List<ProxyConnectorConfiguration> proxyConnectorConfigurations =
- getArchivaConfiguration().getConfiguration().getProxyConnectors();
+ getArchivaConfiguration().getConfiguration().getProxyConnectors();
+
connectorList = proxyConnectorConfigurations.stream()
.map(configuration -> buildProxyConnector(configuration))
.sorted(comparator).collect(Collectors.toList());
connectorMap = connectorList.stream().collect(Collectors.groupingBy(a -> a.getSourceRepository().getId()));
+ for (RepositoryProxyHandler handler : repositoryProxyHandlers) {
+ handler.setProxyConnectors( connectorList );
+ }
+ }
+
+
+ private Map<Policy, PolicyOption> getPolicyMap(ProxyConnectorConfiguration configuration) {
+ Map<String, String> policyConfig = configuration.getPolicies( );
+ return policies.stream().collect( Collectors.toMap( Function.identity(), p -> PolicyUtil.findOption( policyConfig.get(p.getId()), p ) ) );
}
private ProxyConnector buildProxyConnector(ProxyConnectorConfiguration configuration) {
proxyConnector.setOrder(configuration.getOrder());
proxyConnector.setBlacklist(configuration.getBlackListPatterns());
proxyConnector.setWhitelist(configuration.getWhiteListPatterns());
- proxyConnector.setDisabled(configuration.isDisabled());
- proxyConnector.setPolicies(configuration.getPolicies());
+ if (configuration.isDisabled()) {
+ proxyConnector.disable();
+ } else {
+ proxyConnector.enable();
+ }
+ proxyConnector.setPolicies(getPolicyMap( configuration ));
proxyConnector.setProperties(configuration.getProperties());
proxyConnector.setProxyId(configuration.getProxyId());
ManagedRepository srcRepo = repositoryRegistry.getManagedRepository(configuration.getSourceRepoId());
@Override
public void configurationEvent(ConfigurationEvent event) {
log.debug("Config changed updating proxy list");
- updateNetworkProxies();
- updateConnectors();
+ init( );
}
@Override
public Map<String, List<ProxyConnector>> getProxyConnectorAsMap() {
return connectorMap;
}
+
+ @Override
+ public void reload( )
+ {
+ init();
+ }
}
import org.apache.archiva.checksum.ChecksumAlgorithm;
import org.apache.archiva.checksum.ChecksumUtil;
-import org.apache.archiva.proxy.model.ProxyConnectorRuleType;
import org.apache.archiva.common.filelock.FileLockManager;
-import org.apache.archiva.configuration.*;
+import org.apache.archiva.configuration.ArchivaConfiguration;
+import org.apache.archiva.configuration.ProxyConnectorConfiguration;
+import org.apache.archiva.configuration.ProxyConnectorRuleConfiguration;
import org.apache.archiva.model.ArtifactReference;
import org.apache.archiva.model.Keys;
-import org.apache.archiva.policies.*;
+import org.apache.archiva.policies.DownloadErrorPolicy;
+import org.apache.archiva.policies.DownloadPolicy;
+import org.apache.archiva.policies.Policy;
+import org.apache.archiva.policies.PolicyConfigurationException;
+import org.apache.archiva.policies.PolicyOption;
+import org.apache.archiva.policies.PolicyViolationException;
+import org.apache.archiva.policies.PostDownloadPolicy;
+import org.apache.archiva.policies.PreDownloadPolicy;
+import org.apache.archiva.policies.ProxyDownloadException;
import org.apache.archiva.policies.urlcache.UrlFailureCache;
import org.apache.archiva.proxy.model.NetworkProxy;
import org.apache.archiva.proxy.model.ProxyConnector;
import org.apache.archiva.proxy.model.ProxyFetchResult;
import org.apache.archiva.proxy.model.RepositoryProxyHandler;
-import org.apache.archiva.redback.components.registry.Registry;
-import org.apache.archiva.redback.components.registry.RegistryListener;
import org.apache.archiva.redback.components.taskqueue.TaskQueueException;
-import org.apache.archiva.repository.*;
+import org.apache.archiva.repository.ManagedRepository;
+import org.apache.archiva.repository.RemoteRepository;
+import org.apache.archiva.repository.RemoteRepositoryContent;
+import org.apache.archiva.repository.RepositoryType;
+import org.apache.archiva.repository.metadata.MetadataTools;
+import org.apache.archiva.repository.metadata.RepositoryMetadataException;
import org.apache.archiva.repository.storage.FilesystemStorage;
import org.apache.archiva.repository.storage.StorageAsset;
import org.apache.archiva.repository.storage.StorageUtil;
-import org.apache.archiva.repository.metadata.MetadataTools;
-import org.apache.archiva.repository.metadata.RepositoryMetadataException;
import org.apache.archiva.scheduler.ArchivaTaskScheduler;
import org.apache.archiva.scheduler.repository.model.RepositoryTask;
import org.apache.commons.collections4.CollectionUtils;
import javax.inject.Inject;
import javax.inject.Named;
import java.io.IOException;
+import java.net.MalformedURLException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
-import java.util.stream.Collectors;
-public abstract class DefaultRepositoryProxyHandler implements RepositoryProxyHandler, RegistryListener {
+public abstract class DefaultRepositoryProxyHandler implements RepositoryProxyHandler {
protected Logger log = LoggerFactory.getLogger( DefaultRepositoryProxyHandler.class );
@Inject
protected UrlFailureCache urlFailureCache;
- @Inject
- @Named(value = "archivaConfiguration#default")
- private ArchivaConfiguration archivaConfiguration;
-
@Inject
@Named(value = "metadataTools#default")
private MetadataTools metadataTools;
- @Inject
- private Map<String, PreDownloadPolicy> preDownloadPolicies;
- @Inject
- private Map<String, PostDownloadPolicy> postDownloadPolicies;
- @Inject
- private Map<String, DownloadErrorPolicy> downloadErrorPolicies;
+ private Map<String, PreDownloadPolicy> preDownloadPolicies = new HashMap<>( );
+ private Map<String, PostDownloadPolicy> postDownloadPolicies = new HashMap<>( );
+ private Map<String, DownloadErrorPolicy> downloadErrorPolicies = new HashMap<>( );
private ConcurrentMap<String, List<ProxyConnector>> proxyConnectorMap = new ConcurrentHashMap<>();
@Inject
@Named(value = "archivaTaskScheduler#repository")
private ArchivaTaskScheduler<RepositoryTask> scheduler;
+
@Inject
- private RepositoryRegistry repositoryRegistry;
+ private ArchivaConfiguration archivaConfiguration;
@Inject
@Named(value = "fileLockManager#default")
@PostConstruct
public void initialize()
{
- initConnectors();
- archivaConfiguration.addChangeListener( this );
checksumAlgorithms = ChecksumUtil.getAlgorithms(archivaConfiguration.getConfiguration().getArchivaRuntimeConfiguration().getChecksumTypes());
-
- }
-
- @SuppressWarnings("unchecked")
- private void initConnectors()
- {
-
- ProxyConnectorOrderComparator proxyOrderSorter = new ProxyConnectorOrderComparator();
- this.proxyConnectorMap.clear();
-
- Configuration configuration = archivaConfiguration.getConfiguration();
-
- List<ProxyConnectorRuleConfiguration> allProxyConnectorRuleConfigurations =
- configuration.getProxyConnectorRuleConfigurations();
-
- List<ProxyConnectorConfiguration> proxyConfigs = configuration.getProxyConnectors();
- for ( ProxyConnectorConfiguration proxyConfig : proxyConfigs )
- {
- String key = proxyConfig.getSourceRepoId();
-
- // Create connector object.
- ProxyConnector connector = new ProxyConnector();
-
- ManagedRepository repo = repositoryRegistry.getManagedRepository( proxyConfig.getSourceRepoId( ) );
- if (repo==null) {
- log.error("Cannot find source repository after config change "+proxyConfig.getSourceRepoId());
- continue;
- }
- connector.setSourceRepository(repo);
- RemoteRepository rRepo = repositoryRegistry.getRemoteRepository( proxyConfig.getTargetRepoId() );
- if (rRepo==null) {
- log.error("Cannot find target repository after config change "+proxyConfig.getSourceRepoId());
- continue;
- }
- connector.setTargetRepository(rRepo);
-
- connector.setProxyId( proxyConfig.getProxyId() );
- connector.setPolicies( proxyConfig.getPolicies() );
- connector.setOrder( proxyConfig.getOrder() );
- connector.setDisabled( proxyConfig.isDisabled() );
-
- // Copy any blacklist patterns.
- List<String> blacklist = new ArrayList<>( 0 );
- if ( CollectionUtils.isNotEmpty( proxyConfig.getBlackListPatterns() ) )
- {
- blacklist.addAll( proxyConfig.getBlackListPatterns() );
- }
- connector.setBlacklist( blacklist );
-
- // Copy any whitelist patterns.
- List<String> whitelist = new ArrayList<>( 0 );
- if ( CollectionUtils.isNotEmpty( proxyConfig.getWhiteListPatterns() ) )
- {
- whitelist.addAll( proxyConfig.getWhiteListPatterns() );
- }
- connector.setWhitelist( whitelist );
-
- List<ProxyConnectorRuleConfiguration> proxyConnectorRuleConfigurations =
- findProxyConnectorRules( connector.getSourceRepository().getId(),
- connector.getTargetRepository().getId(),
- allProxyConnectorRuleConfigurations );
-
- if ( !proxyConnectorRuleConfigurations.isEmpty() )
- {
- for ( ProxyConnectorRuleConfiguration proxyConnectorRuleConfiguration : proxyConnectorRuleConfigurations )
- {
- if ( StringUtils.equals( proxyConnectorRuleConfiguration.getRuleType(),
- ProxyConnectorRuleType.BLACK_LIST.getRuleType() ) )
- {
- connector.getBlacklist().add( proxyConnectorRuleConfiguration.getPattern() );
- }
-
- if ( StringUtils.equals( proxyConnectorRuleConfiguration.getRuleType(),
- ProxyConnectorRuleType.WHITE_LIST.getRuleType() ) )
- {
- connector.getWhitelist().add( proxyConnectorRuleConfiguration.getPattern() );
- }
- }
- }
-
- // Get other connectors
- List<ProxyConnector> connectors = this.proxyConnectorMap.get( key );
- if ( connectors == null )
- {
- // Create if we are the first.
- connectors = new ArrayList<>( 1 );
- }
-
- // Add the connector.
- connectors.add( connector );
-
- // Ensure the list is sorted.
- Collections.sort( connectors, proxyOrderSorter );
-
- // Set the key to the list of connectors.
- this.proxyConnectorMap.put( key, connectors );
-
-
- }
-
-
-
-
-
}
private List<ProxyConnectorRuleConfiguration> findProxyConnectorRules(String sourceRepository,
return proxyConnectorRuleConfigurations;
}
- private void updateNetworkProxies() {
- Map<String, NetworkProxy> proxies = archivaConfiguration.getConfiguration().getNetworkProxies().stream().map(p -> {
- NetworkProxy np = new NetworkProxy();
- np.setId(p.getId());
- np.setUseNtlm(p.isUseNtlm());
- np.setUsername(p.getUsername());
- np.setPassword(p.getPassword() == null ? new char[0] : p.getPassword().toCharArray());
- np.setProtocol(p.getProtocol());
- np.setHost(p.getHost());
- np.setPort(p.getPort());
- return np;
- }).collect(Collectors.toMap(p -> p.getId(), p -> p));
- setNetworkProxies(proxies);
- }
-
@Override
- public StorageAsset fetchFromProxies( ManagedRepositoryContent repository, ArtifactReference artifact )
+ public StorageAsset fetchFromProxies( ManagedRepository repository, ArtifactReference artifact )
throws ProxyDownloadException
{
StorageAsset localFile = toLocalFile( repository, artifact );
Map<String, Exception> previousExceptions = new LinkedHashMap<>();
for ( ProxyConnector connector : connectors )
{
- if ( connector.isDisabled() )
+ if ( !connector.isEnabled() )
{
continue;
}
try
{
StorageAsset downloadedFile =
- transferFile( connector, targetRepository.getContent(), targetPath, repository, localFile, requestProperties,
+ transferFile( connector, targetRepository, targetPath, repository, localFile, requestProperties,
true );
if ( fileExists(downloadedFile) )
}
@Override
- public StorageAsset fetchFromProxies( ManagedRepositoryContent repository, String path )
+ public StorageAsset fetchFromProxies( ManagedRepository repository, String path )
{
- StorageAsset localFile = repository.getRepository().getAsset( path );
+ StorageAsset localFile = repository.getAsset( path );
// no update policies for these paths
if ( localFile.exists() )
List<ProxyConnector> connectors = getProxyConnectors( repository );
for ( ProxyConnector connector : connectors )
{
- if ( connector.isDisabled() )
+ if ( !connector.isEnabled() )
{
continue;
}
try
{
StorageAsset downloadedFile =
- transferFile( connector, targetRepository.getContent(), targetPath, repository, localFile, requestProperties,
+ transferFile( connector, targetRepository, targetPath, repository, localFile, requestProperties,
false );
if ( fileExists( downloadedFile ) )
}
@Override
- public ProxyFetchResult fetchMetadataFromProxies(ManagedRepositoryContent repository, String logicalPath )
+ public ProxyFetchResult fetchMetadataFromProxies( ManagedRepository repository, String logicalPath )
{
- StorageAsset localFile = repository.getRepository().getAsset( logicalPath );
+ StorageAsset localFile = repository.getAsset( logicalPath );
Properties requestProperties = new Properties();
requestProperties.setProperty( "filetype", "metadata" );
List<ProxyConnector> connectors = new ArrayList<>( getProxyConnectors( repository ) );
for ( ProxyConnector connector : connectors )
{
- if ( connector.isDisabled() )
+ if ( !connector.isEnabled() )
{
continue;
}
try
{
- transferFile( connector, targetRepository.getContent(), logicalPath, repository, localRepoFile, requestProperties,
+ transferFile( connector, targetRepository, logicalPath, repository, localRepoFile, requestProperties,
true );
if ( hasBeenUpdated( localRepoFile, originalMetadataTimestamp ) )
{
try
{
- metadataTools.updateMetadata( repository, logicalPath );
+ metadataTools.updateMetadata( repository.getContent(), logicalPath );
}
catch ( RepositoryMetadataException e )
{
return ( currentLastModified > originalLastModified );
}
- private StorageAsset toLocalRepoFile( ManagedRepositoryContent repository, RemoteRepositoryContent targetRepository,
+ private StorageAsset toLocalRepoFile( ManagedRepository repository, RemoteRepositoryContent targetRepository,
String targetPath )
{
String repoPath = metadataTools.getRepositorySpecificName( targetRepository, targetPath );
- return repository.getRepository().getAsset( repoPath );
+ return repository.getAsset( repoPath );
}
/**
* Test if the provided ManagedRepositoryContent has any proxies configured for it.
+ * @param repository
*/
@Override
- public boolean hasProxies( ManagedRepositoryContent repository )
+ public boolean hasProxies( ManagedRepository repository )
{
synchronized ( this.proxyConnectorMap )
{
}
}
- private StorageAsset toLocalFile(ManagedRepositoryContent repository, ArtifactReference artifact )
+ private StorageAsset toLocalFile(ManagedRepository repository, ArtifactReference artifact )
{
- return repository.toFile( artifact );
+ return repository.getContent().toFile( artifact );
}
/**
* the remote resource is not newer than the local File.
* @throws ProxyException if transfer was unsuccessful.
*/
- protected StorageAsset transferFile( ProxyConnector connector, RemoteRepositoryContent remoteRepository, String remotePath,
- ManagedRepositoryContent repository, StorageAsset resource, Properties requestProperties,
+ protected StorageAsset transferFile( ProxyConnector connector, RemoteRepository remoteRepository, String remotePath,
+ ManagedRepository repository, StorageAsset resource, Properties requestProperties,
boolean executeConsumers )
throws ProxyException, NotModifiedException
{
- String url = remoteRepository.getURL().getUrl();
+ String url = null;
+ try
+ {
+ url = remoteRepository.getLocation().toURL().toString();
+ }
+ catch ( MalformedURLException e )
+ {
+ throw new ProxyException( e.getMessage(), e );
+ }
if ( !url.endsWith( "/" ) )
{
url = url + "/";
if ( !matchesPattern( remotePath, connector.getWhitelist() ) )
{
log.debug( "Path [{}] is not part of defined whitelist (skipping transfer from repository [{}]).",
- remotePath, remoteRepository.getRepository().getName() );
+ remotePath, remoteRepository.getId() );
return null;
}
}
if ( matchesPattern( remotePath, connector.getBlacklist() ) )
{
log.debug( "Path [{}] is part of blacklist (skipping transfer from repository [{}]).", remotePath,
- remoteRepository.getRepository().getName() );
+ remoteRepository.getId() );
return null;
}
return resource;
}
- protected abstract void transferResources( ProxyConnector connector, RemoteRepositoryContent remoteRepository,
+ protected abstract void transferResources( ProxyConnector connector, RemoteRepository remoteRepository,
StorageAsset tmpResource, StorageAsset[] checksumFiles, String url, String remotePath, StorageAsset resource, Path workingDirectory,
- ManagedRepositoryContent repository ) throws ProxyException;
+ ManagedRepository repository ) throws ProxyException;
private void queueRepositoryTask(String repositoryId, StorageAsset localFile )
{
* @param localFile the local file (utilized by the {@link DownloadPolicy#applyPolicy(PolicyOption, Properties, StorageAsset)})
* @throws PolicyViolationException
*/
- private void validatePolicies( Map<String, ? extends DownloadPolicy> policies, Map<String, String> settings,
+ private void validatePolicies( Map<String, ? extends DownloadPolicy> policies, Map<Policy, PolicyOption> settings,
Properties request, StorageAsset localFile )
throws PolicyViolationException
{
{
// olamy with spring rolehint is now downloadPolicy#hint
// so substring after last # to get the hint as with plexus
- String key = StringUtils.substringAfterLast( entry.getKey(), "#" );
+ String key = entry.getValue( ).getId( );
DownloadPolicy policy = entry.getValue();
- PolicyOption option = PolicyUtil.findOption(settings.get(key), policy);
+ PolicyOption option = settings.containsKey(policy ) ? settings.get(policy) : policy.getDefaultOption();
log.debug( "Applying [{}] policy with [{}]", key, option );
try
}
}
- private void validatePolicies( Map<String, DownloadErrorPolicy> policies, Map<String, String> settings,
+ private void validatePolicies( Map<String, DownloadErrorPolicy> policies, Map<Policy, PolicyOption> settings,
Properties request, ArtifactReference artifact, RemoteRepositoryContent content,
StorageAsset localFile, Exception exception, Map<String, Exception> previousExceptions )
throws ProxyDownloadException
// olamy with spring rolehint is now downloadPolicy#hint
// so substring after last # to get the hint as with plexus
- String key = StringUtils.substringAfterLast( entry.getKey(), "#" );
+ String key = entry.getValue( ).getId( );
DownloadErrorPolicy policy = entry.getValue();
- PolicyOption option = PolicyUtil.findOption(settings.get(key), policy);
+ PolicyOption option = settings.containsKey( policy ) ? settings.get(policy) : policy.getDefaultOption();
log.debug( "Applying [{}] policy with [{}]", key, option );
try
* @param repository
* @return file location of working directory
*/
- private Path createWorkingDirectory( ManagedRepositoryContent repository )
+ private Path createWorkingDirectory( ManagedRepository repository )
{
try
{
/**
* TODO: Ensure that list is correctly ordered based on configuration. See MRM-477
+ * @param repository
*/
@Override
- public List<ProxyConnector> getProxyConnectors( ManagedRepositoryContent repository )
+ public List<ProxyConnector> getProxyConnectors( ManagedRepository repository )
{
if ( !this.proxyConnectorMap.containsKey( repository.getId() ) )
}
- @Override
- public void afterConfigurationChange(Registry registry, String propertyName, Object propertyValue )
- {
- if ( ConfigurationNames.isManagedRepositories( propertyName ) //
- || ConfigurationNames.isRemoteRepositories( propertyName ) //
- || ConfigurationNames.isProxyConnector( propertyName ) ) //
- {
- initConnectors();
- } else if (ConfigurationNames.isNetworkProxy(propertyName)) {
- updateNetworkProxies();
- }
- }
protected String addParameters(String path, RemoteRepository remoteRepository )
{
return res.toString();
}
- @Override
- public void beforeConfigurationChange( Registry registry, String propertyName, Object propertyValue )
- {
- /* do nothing */
- }
-
- public ArchivaConfiguration getArchivaConfiguration()
- {
- return archivaConfiguration;
- }
-
public void setArchivaConfiguration(ArchivaConfiguration archivaConfiguration )
{
this.archivaConfiguration = archivaConfiguration;
}
@Override
- public void setNetworkProxies(Map<String, NetworkProxy> proxies) {
+ public void setNetworkProxies(Map<String, NetworkProxy> networkProxies ) {
this.networkProxyMap.clear();
- this.networkProxyMap.putAll(proxies);
+ this.networkProxyMap.putAll( networkProxies );
}
@Override
@Override
public abstract List<RepositoryType> supports();
+
+ @Override
+ public void setPolicies( List<Policy> policyList )
+ {
+ preDownloadPolicies.clear();
+ postDownloadPolicies.clear();
+ downloadErrorPolicies.clear();
+ for (Policy policy : policyList) {
+ addPolicy( policy );
+ }
+ }
+
+ void addPolicy(PreDownloadPolicy policy) {
+ preDownloadPolicies.put( policy.getId( ), policy );
+ }
+
+ void addPolicy(PostDownloadPolicy policy) {
+ postDownloadPolicies.put( policy.getId( ), policy );
+ }
+ void addPolicy(DownloadErrorPolicy policy) {
+ downloadErrorPolicies.put( policy.getId( ), policy );
+ }
+
+ @Override
+ public void addPolicy( Policy policy )
+ {
+ if (policy instanceof PreDownloadPolicy) {
+ addPolicy( (PreDownloadPolicy)policy );
+ } else if (policy instanceof PostDownloadPolicy) {
+ addPolicy( (PostDownloadPolicy) policy );
+ } else if (policy instanceof DownloadErrorPolicy) {
+ addPolicy( (DownloadErrorPolicy) policy );
+ } else {
+ log.warn( "Policy not known: {}, {}", policy.getId( ), policy.getClass( ).getName( ) );
+ }
+ }
+
+ @Override
+ public void removePolicy( Policy policy )
+ {
+ final String id = policy.getId();
+ if (preDownloadPolicies.containsKey( id )) {
+ preDownloadPolicies.remove( id );
+ } else if (postDownloadPolicies.containsKey( id )) {
+ postDownloadPolicies.remove( id );
+ } else if (downloadErrorPolicies.containsKey( id )) {
+ downloadErrorPolicies.remove( id );
+ }
+ }
+
+ @Override
+ public void addProxyConnector( ProxyConnector connector )
+ {
+ final String sourceId = connector.getSourceRepository( ).getId( );
+ List<ProxyConnector> connectors;
+ if (proxyConnectorMap.containsKey( sourceId )) {
+ connectors = proxyConnectorMap.get( sourceId );
+ } else {
+ connectors = new ArrayList<>( );
+ proxyConnectorMap.put( sourceId, connectors );
+ }
+ connectors.add( connector );
+ }
+
+ @Override
+ public void setProxyConnectors( List<ProxyConnector> proxyConnectors )
+ {
+ proxyConnectorMap.clear();
+ for ( ProxyConnector connector : proxyConnectors )
+ {
+ addProxyConnector( connector );
+ }
+ }
}
*/
public interface RepositoryConnector
{
+ /**
+ * Returns the local repository that is connected to the remote.
+ * @return The local managed repository.
+ */
ManagedRepository getSourceRepository();
+ /**
+ * Returns the remote repository that is connected to the local.
+ * @return The remote repository.
+ */
RemoteRepository getTargetRepository();
+ /**
+ * Returns a list of paths that are not fetched from the remote repository.
+ * @return A list of paths.
+ */
List<String> getBlacklist();
-
+
+ /**
+ * Returns a list of paths that are fetched from the remote repository, even if a
+ * parent path is in the blacklist.
+ *
+ * @return The list of paths.
+ */
List<String> getWhitelist();
-
- boolean isDisabled();
-
- void setDisabled(boolean disabled);
+
+ /**
+ * Returns true, if this connector is enabled, otherwise false.
+ * @return True, if enabled.
+ */
+ boolean isEnabled();
+
+ /**
+ * Enables this connector, if it was disabled before, otherwise does nothing.
+ */
+ void enable();
+
+ /**
+ * Disables this connector, if it was enabled before, otherwise does nothing.
+ */
+ void disable();
+
}
import org.apache.archiva.proxy.ProxyException;
import org.apache.archiva.proxy.model.NetworkProxy;
import org.apache.archiva.proxy.model.ProxyConnector;
+import org.apache.archiva.proxy.model.RepositoryProxyHandler;
import org.apache.archiva.repository.*;
import org.apache.archiva.repository.storage.StorageAsset;
import org.apache.commons.lang3.StringUtils;
* TODO exception handling needs work - "not modified" is not really an exceptional case, and it has more layers than
* your average brown onion
*/
-@Service("repositoryProxyConnectors#maven")
+@Service( "repositoryProxyHandler#maven" )
public class MavenRepositoryProxyHandler extends DefaultRepositoryProxyHandler {
private static final List<RepositoryType> REPOSITORY_TYPES = new ArrayList<>();
private void updateWagonProxyInfo(Map<String, NetworkProxy> proxyList) {
this.networkProxyMap.clear();
- List<NetworkProxyConfiguration> networkProxies = getArchivaConfiguration().getConfiguration().getNetworkProxies();
for (Map.Entry<String, NetworkProxy> proxyEntry : proxyList.entrySet()) {
String key = proxyEntry.getKey();
NetworkProxy networkProxyDef = proxyEntry.getValue();
}
@Override
- public void setNetworkProxies(Map<String, NetworkProxy> proxies) {
- super.setNetworkProxies(proxies);
- updateWagonProxyInfo(proxies);
+ public void setNetworkProxies(Map<String, NetworkProxy> networkProxies ) {
+ super.setNetworkProxies( networkProxies );
+ updateWagonProxyInfo( networkProxies );
}
/**
* @throws ProxyException
* @throws NotModifiedException
*/
- protected void transferResources( ProxyConnector connector, RemoteRepositoryContent remoteRepository,
+ protected void transferResources( ProxyConnector connector, RemoteRepository remoteRepository,
StorageAsset tmpResource, StorageAsset[] checksumFiles, String url, String remotePath, StorageAsset resource,
- Path workingDirectory, ManagedRepositoryContent repository )
+ Path workingDirectory, ManagedRepository repository )
throws ProxyException, NotModifiedException {
Wagon wagon = null;
try {
- RepositoryURL repoUrl = remoteRepository.getURL();
+ RepositoryURL repoUrl = remoteRepository.getContent().getURL();
String protocol = repoUrl.getProtocol();
NetworkProxy networkProxy = null;
String proxyId = connector.getProxyId();
networkProxy = getNetworkProxy(proxyId);
}
WagonFactoryRequest wagonFactoryRequest = new WagonFactoryRequest("wagon#" + protocol,
- remoteRepository.getRepository().getExtraHeaders());
+ remoteRepository.getExtraHeaders());
if (networkProxy == null) {
log.warn("No network proxy with id {} found for connector {}->{}", proxyId,
}
}
- protected void transferArtifact(Wagon wagon, RemoteRepositoryContent remoteRepository, String remotePath,
- ManagedRepositoryContent repository, Path resource, Path tmpDirectory,
+ protected void transferArtifact(Wagon wagon, RemoteRepository remoteRepository, String remotePath,
+ ManagedRepository repository, Path resource, Path tmpDirectory,
StorageAsset destFile)
throws ProxyException {
transferSimpleFile(wagon, remoteRepository, remotePath, repository, resource, destFile.getFilePath());
* @param ext the type of checksum to transfer (example: ".md5" or ".sha1")
* @throws ProxyException if copying the downloaded file into place did not succeed.
*/
- protected void transferChecksum( Wagon wagon, RemoteRepositoryContent remoteRepository, String remotePath,
- ManagedRepositoryContent repository, Path resource, String ext,
+ protected void transferChecksum( Wagon wagon, RemoteRepository remoteRepository, String remotePath,
+ ManagedRepository repository, Path resource, String ext,
Path destFile )
throws ProxyException {
- String url = remoteRepository.getURL().getUrl() + remotePath + ext;
+ String url = remoteRepository.getLocation().toString() + remotePath + ext;
// Transfer checksum does not use the policy.
if (urlFailureCache.hasFailedBefore(url)) {
* @param origFile the local file to save to
* @throws ProxyException if there was a problem moving the downloaded file into place.
*/
- protected void transferSimpleFile(Wagon wagon, RemoteRepositoryContent remoteRepository, String remotePath,
- ManagedRepositoryContent repository, Path origFile, Path destFile)
+ protected void transferSimpleFile(Wagon wagon, RemoteRepository remoteRepository, String remotePath,
+ ManagedRepository repository, Path origFile, Path destFile)
throws ProxyException {
assert (remotePath != null);
boolean success = false;
if (!Files.exists(origFile)) {
- log.debug("Retrieving {} from {}", remotePath, remoteRepository.getRepository().getName());
- wagon.get(addParameters(remotePath, remoteRepository.getRepository()), destFile.toFile());
+ log.debug("Retrieving {} from {}", remotePath, remoteRepository.getId());
+ wagon.get(addParameters(remotePath, remoteRepository), destFile.toFile());
success = true;
// You wouldn't get here on failure, a WagonException would have been thrown.
log.debug("Downloaded successfully.");
} else {
- log.debug("Retrieving {} from {} if updated", remotePath, remoteRepository.getRepository().getName());
+ log.debug("Retrieving {} from {} if updated", remotePath, remoteRepository.getId());
try {
- success = wagon.getIfNewer(addParameters(remotePath, remoteRepository.getRepository()), destFile.toFile(),
+ success = wagon.getIfNewer(addParameters(remotePath, remoteRepository), destFile.toFile(),
Files.getLastModifiedTime(origFile).toMillis());
} catch (IOException e) {
throw new ProxyException("Failed to the modification time of " + origFile.toAbsolutePath());
}
} catch (ResourceDoesNotExistException e) {
throw new NotFoundException(
- "Resource [" + remoteRepository.getURL() + "/" + remotePath + "] does not exist: " + e.getMessage(),
+ "Resource [" + remoteRepository.getLocation() + "/" + remotePath + "] does not exist: " + e.getMessage(),
e);
} catch (WagonException e) {
// TODO: shouldn't have to drill into the cause, but TransferFailedException is often not descriptive enough
String msg =
- "Download failure on resource [" + remoteRepository.getURL() + "/" + remotePath + "]:" + e.getMessage();
+ "Download failure on resource [" + remoteRepository.getLocation() + "/" + remotePath + "]:" + e.getMessage();
if (e.getCause() != null) {
msg += " (cause: " + e.getCause() + ")";
}
* @return true if the connection was successful. false if not connected.
*/
protected boolean connectToRepository(ProxyConnector connector, Wagon wagon,
- RemoteRepositoryContent remoteRepository) {
+ RemoteRepository remoteRepository) {
boolean connected = false;
final ProxyInfo networkProxy =
if (networkProxy != null) {
// TODO: move to proxyInfo.toString()
String msg = "Using network proxy " + networkProxy.getHost() + ":" + networkProxy.getPort()
- + " to connect to remote repository " + remoteRepository.getURL();
+ + " to connect to remote repository " + remoteRepository.getLocation();
if (networkProxy.getNonProxyHosts() != null) {
msg += "; excluding hosts: " + networkProxy.getNonProxyHosts();
}
AuthenticationInfo authInfo = null;
String username = "";
String password = "";
- RepositoryCredentials repCred = remoteRepository.getRepository().getLoginCredentials();
+ RepositoryCredentials repCred = remoteRepository.getLoginCredentials();
if (repCred != null && repCred instanceof PasswordCredentials) {
PasswordCredentials pwdCred = (PasswordCredentials) repCred;
username = pwdCred.getUsername();
}
if (StringUtils.isNotBlank(username) && StringUtils.isNotBlank(password)) {
- log.debug("Using username {} to connect to remote repository {}", username, remoteRepository.getURL());
+ log.debug("Using username {} to connect to remote repository {}", username, remoteRepository.getLocation());
authInfo = new AuthenticationInfo();
authInfo.setUserName(username);
authInfo.setPassword(password);
// Convert seconds to milliseconds
- long timeoutInMilliseconds = remoteRepository.getRepository().getTimeout().toMillis();
+ long timeoutInMilliseconds = remoteRepository.getTimeout().toMillis();
// Set timeout read and connect
// FIXME olamy having 2 config values
try {
Repository wagonRepository =
- new Repository(remoteRepository.getId(), remoteRepository.getURL().toString());
+ new Repository(remoteRepository.getId(), remoteRepository.getLocation().toString());
wagon.connect(wagonRepository, authInfo, networkProxy);
connected = true;
} catch (ConnectionException | AuthenticationException e) {
- log.warn("Could not connect to {}: {}", remoteRepository.getRepository().getName(), e.getMessage());
+ log.warn("Could not connect to {}: {}", remoteRepository.getId(), e.getMessage());
connected = false;
}
public List<RepositoryType> supports() {
return REPOSITORY_TYPES;
}
+
+ @Override
+ public void addNetworkproxy( String id, NetworkProxy networkProxy )
+ {
+
+ }
+
+ @Override
+ public <T extends RepositoryProxyHandler> T getHandler( Class<T> clazz ) throws IllegalArgumentException
+ {
+ if (clazz.isAssignableFrom( this.getClass() )) {
+ return (T)this;
+ } else {
+ throw new IllegalArgumentException( "This Proxy Handler is no subclass of " + clazz );
+ }
+ }
}
@Inject
protected ApplicationContext applicationContext;
+ @Inject
+ private ProxyRegistry proxyRegistry;
+
@Inject
RepositoryRegistry repositoryRegistry;
// Setup the proxy handler.
//proxyHandler = applicationContext.getBean (RepositoryProxyHandler) lookup( RepositoryProxyHandler.class.getName() );
- proxyHandler = applicationContext.getBean( "repositoryProxyConnectors#test", RepositoryProxyHandler.class );
+ proxyHandler = applicationContext.getBean( "repositoryProxyHandler#test", RepositoryProxyHandler.class );
+ assertNotNull( proxyRegistry );
+ assertTrue(proxyRegistry.getAllHandler( ).get( RepositoryType.MAVEN).contains( proxyHandler ));
// Setup the wagon mock.
wagonMockControl = EasyMock.createNiceControl();
wagonMock = wagonMockControl.createMock( Wagon.class );
- delegate = (WagonDelegate) applicationContext.getBean( "wagon#test", Wagon.class );
+ delegate = (WagonDelegate) applicationContext.getBean( "wagon#http", Wagon.class );
delegate.setDelegate( wagonMock );
ArtifactReference artifact = managedDefaultRepository.toArtifactReference( path );
// Configure Repository (usually done within archiva.xml configuration)
- saveRemoteRepositoryConfig( "badproxied1", "Bad Proxied 1", "test://bad.machine.com/repo/", "default" );
- saveRemoteRepositoryConfig( "badproxied2", "Bad Proxied 2", "test://bad.machine.com/anotherrepo/", "default" );
+ saveRemoteRepositoryConfig( "badproxied1", "Bad Proxied 1", "http://bad.machine.com/repo/", "default" );
+ saveRemoteRepositoryConfig( "badproxied2", "Bad Proxied 2", "http://bad.machine.com/anotherrepo/", "default" );
// Configure Connector (usually done within archiva.xml configuration)
saveConnector( ID_DEFAULT_MANAGED, "badproxied1", ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
wagonMockControl.replay();
//noinspection UnusedAssignment
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
wagonMockControl.verify();
// Second attempt to download same artifact use cache
wagonMockControl.reset();
wagonMockControl.replay();
- downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
wagonMockControl.verify();
assertNotDownloaded( downloadedFile);
ArtifactReference artifact = managedDefaultRepository.toArtifactReference( path );
// Configure Repository (usually done within archiva.xml configuration)
- saveRemoteRepositoryConfig( "badproxied1", "Bad Proxied 1", "test://bad.machine.com/repo/", "default" );
- saveRemoteRepositoryConfig( "badproxied2", "Bad Proxied 2", "test://bad.machine.com/anotherrepo/", "default" );
+ saveRemoteRepositoryConfig( "badproxied1", "Bad Proxied 1", "http://bad.machine.com/repo/", "default" );
+ saveRemoteRepositoryConfig( "badproxied2", "Bad Proxied 2", "http://bad.machine.com/anotherrepo/", "default" );
// Configure Connector (usually done within archiva.xml configuration)
wagonMockControl.replay();
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
wagonMockControl.verify();
wagonMockControl.replay();
- downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
wagonMockControl.verify();
saveConnector( ID_DEFAULT_MANAGED, "proxied2", ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.YES, false );
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
// Validate that file actually came from proxied2 (as intended).
Path proxied2File = Paths.get( REPOPATH_PROXIED2, path );
saveConnector( ID_DEFAULT_MANAGED, "proxied1", ChecksumPolicy.IGNORE, ReleasesPolicy.ALWAYS,
SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO, true );
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
assertNull( downloadedFile );
}
saveConnector( ID_DEFAULT_MANAGED, "proxied1", ChecksumPolicy.IGNORE, ReleasesPolicy.ALWAYS,
SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO, false );
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
Path proxied1File = Paths.get( REPOPATH_PROXIED1, path );
assertFileEquals( expectedFile, downloadedFile.getFilePath(), proxied1File );
saveConnector( ID_DEFAULT_MANAGED, "proxied1", ChecksumPolicy.IGNORE, ReleasesPolicy.ALWAYS,
SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO, false );
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
Path proxied1File = Paths.get( REPOPATH_PROXIED1, path );
assertFileEquals( expectedFile, downloadedFile.getFilePath(), proxied1File );
saveConnector( ID_DEFAULT_MANAGED, "proxied1", ChecksumPolicy.IGNORE, ReleasesPolicy.ALWAYS,
SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO, false );
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
Path proxied1File = Paths.get( REPOPATH_PROXIED1, path );
assertFileEquals( expectedFile, downloadedFile.getFilePath(), proxied1File );
saveConnector( ID_DEFAULT_MANAGED, "proxied1", ChecksumPolicy.IGNORE, ReleasesPolicy.ALWAYS,
SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO, false );
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
Path proxied1File = Paths.get( REPOPATH_PROXIED1, path );
assertFileEquals( expectedFile, downloadedFile.getFilePath(), proxied1File );
saveConnector( ID_DEFAULT_MANAGED, "proxied1", ChecksumPolicy.IGNORE, ReleasesPolicy.ALWAYS,
SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO, false );
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
Path proxied1File = Paths.get( REPOPATH_PROXIED1, path );
assertFileEquals( expectedFile, downloadedFile.getFilePath(), proxied1File );
saveConnector( ID_DEFAULT_MANAGED, "proxied1", ChecksumPolicy.FAIL, ReleasesPolicy.ALWAYS,
SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO, false );
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
assertNotDownloaded( downloadedFile );
assertChecksums( expectedFile, null, null );
saveConnector( ID_DEFAULT_MANAGED, "proxied1", ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO, false );
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
Path proxied1File = Paths.get( REPOPATH_PROXIED1, path );
assertFileEquals( expectedFile, downloadedFile.getFilePath(), proxied1File );
saveConnector( ID_DEFAULT_MANAGED, "proxied1", ChecksumPolicy.FAIL, ReleasesPolicy.ALWAYS,
SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO, false );
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
assertNotDownloaded( downloadedFile );
assertChecksums( expectedFile, null, null );
saveConnector( ID_DEFAULT_MANAGED, "proxied1", ChecksumPolicy.FAIL, ReleasesPolicy.ALWAYS,
SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO, false );
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
// This is a success situation. No SHA1 with a Good MD5.
Path proxied1File = Paths.get(REPOPATH_PROXIED1, path);
saveConnector( ID_DEFAULT_MANAGED, "proxied1", ChecksumPolicy.FAIL, ReleasesPolicy.ALWAYS,
SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO, false );
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
assertNotDownloaded( downloadedFile );
assertChecksums( expectedFile, null, null );
saveConnector( ID_DEFAULT_MANAGED, "proxied1", ChecksumPolicy.IGNORE, ReleasesPolicy.ALWAYS,
SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO, false );
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
Path proxied1File = Paths.get(REPOPATH_PROXIED1, path);
assertFileEquals( expectedFile, downloadedFile.getFilePath(), proxied1File );
SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO, false );
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
Path proxied1File = Paths.get(REPOPATH_PROXIED1, path);
assertFileEquals( expectedFile, downloadedFile.getFilePath(), proxied1File );
saveConnector( ID_DEFAULT_MANAGED, "proxied1", ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO, false );
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
Path proxied1File = Paths.get(REPOPATH_PROXIED1, path);
assertFileEquals( expectedFile, downloadedFile.getFilePath(), proxied1File );
saveConnector( ID_DEFAULT_MANAGED, "proxied1", ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO, false );
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
Path proxied1File = Paths.get(REPOPATH_PROXIED1, path);
assertFileEquals( expectedFile, downloadedFile.getFilePath(), proxied1File );
assertFalse( Files.exists(expectedFile.getParent()) );
assertFalse( Files.exists(expectedFile) );
- saveRemoteRepositoryConfig( "badproxied", "Bad Proxied", "test://bad.machine.com/repo/", "default" );
+ saveRemoteRepositoryConfig( "badproxied", "Bad Proxied", "http://bad.machine.com/repo/", "default" );
// Configure Connector (usually done within archiva.xml configuration)
saveConnector( ID_DEFAULT_MANAGED, "badproxied", ChecksumPolicy.IGNORE, ReleasesPolicy.ALWAYS,
wagonMockControl.replay();
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
wagonMockControl.verify();
saveConnector( ID_DEFAULT_MANAGED, "proxied1", ChecksumPolicy.IGNORE, ReleasesPolicy.ALWAYS,
SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO, false );
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
Path proxied1File = Paths.get( REPOPATH_PROXIED1, path );
assertFileEquals( expectedFile, downloadedFile.getFilePath(), proxied1File );
saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED1, ChecksumPolicy.FAIL, ReleasesPolicy.ALWAYS,
SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO, false );
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
assertNotDownloaded( downloadedFile );
assertNoTempFiles( expectedFile );
saveConnector( ID_DEFAULT_MANAGED, "proxied1", ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO, false );
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
Path proxied1File = Paths.get(REPOPATH_PROXIED1, path);
assertFileEquals( expectedFile, downloadedFile.getFilePath(), proxied1File );
private void createMockedProxyConnector( String id, String name, PolicyOption errorPolicy )
{
- saveRemoteRepositoryConfig( id, name, "test://bad.machine.com/repo/", "default" );
+ saveRemoteRepositoryConfig( id, name, "http://bad.machine.com/repo/", "default" );
saveConnector( ID_DEFAULT_MANAGED, id, ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS, SnapshotsPolicy.ALWAYS,
CachedFailuresPolicy.NO, errorPolicy, false );
}
private void createMockedProxyConnector( String id, String name, PolicyOption errorPolicy, PolicyOption errorOnUpdatePolicy )
{
- saveRemoteRepositoryConfig( id, name, "test://bad.machine.com/repo/", "default" );
+ saveRemoteRepositoryConfig( id, name, "http://bad.machine.com/repo/", "default" );
saveConnector( ID_DEFAULT_MANAGED, id, ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS, SnapshotsPolicy.ALWAYS,
CachedFailuresPolicy.NO, errorPolicy, errorOnUpdatePolicy, false );
}
StorageAsset downloadedFile = null;
try
{
- downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository,
+ downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(),
managedDefaultRepository.toArtifactReference( path ) );
fail( "Proxy should not have succeeded" );
}
wagonMockControl.replay();
// Attempt the proxy fetch.
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository,
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(),
managedDefaultRepository.toArtifactReference( path ) );
wagonMockControl.verify();
import org.apache.archiva.policies.PropagateErrorsOnUpdateDownloadPolicy;
import org.apache.archiva.policies.ReleasesPolicy;
import org.apache.archiva.policies.SnapshotsPolicy;
+import org.apache.archiva.proxy.maven.DefaultWagonFactory;
+import org.apache.archiva.proxy.maven.WagonFactory;
+import org.apache.archiva.proxy.maven.WagonFactoryRequest;
import org.apache.archiva.proxy.model.RepositoryProxyHandler;
import org.apache.archiva.repository.*;
import org.apache.archiva.repository.storage.StorageAsset;
import org.apache.archiva.test.utils.ArchivaSpringJUnit4ClassRunner;
import org.apache.commons.io.FileUtils;
+import org.apache.maven.wagon.Wagon;
+import org.apache.maven.wagon.providers.http.HttpWagon;
import org.assertj.core.api.Assertions;
import org.eclipse.jetty.server.Handler;
import org.eclipse.jetty.server.HttpConnectionFactory;
private RepositoryProxyHandler proxyHandler;
- private ArchivaConfiguration config;
-
private ManagedRepositoryContent managedDefaultRepository;
@Inject
@Inject
private RepositoryRegistry repositoryRegistry;
+ @Inject
+ private ArchivaConfiguration config;
+
+ @Inject
+ private ProxyRegistry proxyRegistry;
+
private Server server;
protected ManagedRepositoryContent createRepository( String id, String name, String path, String layout )
public void setUp()
throws Exception
{
- proxyHandler = applicationContext.getBean( "repositoryProxyConnectors#test", RepositoryProxyHandler.class );
-
- config = applicationContext.getBean( "archivaConfiguration#mock", ArchivaConfiguration.class );
+ proxyHandler = applicationContext.getBean( "repositoryProxyHandler#test", RepositoryProxyHandler.class );
// clear from previous tests - TODO the spring context should be initialised per test instead, or the config
// made a complete mock
config.getConfiguration().addRemoteRepository( repoConfig );
+ Wagon wagon = new HttpWagon( );
+ WagonDelegate delegate = (WagonDelegate) applicationContext.getBean( "wagon#http", Wagon.class );
+ delegate.setDelegate( wagon );
+
+ proxyRegistry.reload();
repositoryRegistry.reload();
managedDefaultRepository = createRepository(MANAGED_ID, "Default Managed Repository", repoPath, "default");
addConnector();
Path expectedFile = Paths.get( managedDefaultRepository.getRepoRoot() ).resolve( path );
+ Files.deleteIfExists( expectedFile );
ArtifactReference artifact = managedDefaultRepository.toArtifactReference( path );
// Attempt the proxy fetch.
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
Path sourceFile = Paths.get( PROXIED_BASEDIR, path );
assertNotNull( "Expected File should not be null.", expectedFile );
CachedFailuresPolicy.NO, true );
// Attempt the proxy fetch.
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
assertNull( "File should not have been downloaded", downloadedFile );
}
CachedFailuresPolicy.NO, false );
// Attempt the proxy fetch.
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
Path sourceFile = Paths.get(REPOPATH_PROXIED1, path);
assertFileEquals( expectedFile, downloadedFile.getFilePath(), sourceFile );
CachedFailuresPolicy.NO, false );
// Attempt the proxy fetch.
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, path );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), path );
Path sourceFile = Paths.get(REPOPATH_PROXIED1, path);
assertNotNull(downloadedFile);
CachedFailuresPolicy.NO, false );
// Attempt the proxy fetch.
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
assertFileEquals( expectedFile, downloadedFile.getFilePath(), expectedFile );
assertNoTempFiles( expectedFile );
CachedFailuresPolicy.NO, false );
// Attempt the proxy fetch.
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, path );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), path );
assertNotDownloaded( downloadedFile );
assertNotModified( expectedFile, originalModificationTime );
SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO, false );
// Attempt the proxy fetch.
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
assertNotDownloaded( downloadedFile );
assertNotModified( expectedFile, originalModificationTime );
SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO, false );
// Attempt the proxy fetch.
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
Path proxiedFile = Paths.get(REPOPATH_PROXIED1, path);
assertFileEquals( expectedFile, downloadedFile.getFilePath(), proxiedFile );
CachedFailuresPolicy.NO, false );
// Attempt the proxy fetch.
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
Path proxiedFile = Paths.get(REPOPATH_PROXIED1, path);
assertFileEquals( expectedFile, downloadedFile.getFilePath(), proxiedFile );
saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED2, false );
// Attempt the proxy fetch.
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
Path proxied1File = Paths.get(REPOPATH_PROXIED1, path);
Path proxied2File = Paths.get(REPOPATH_PROXIED2, path);
saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED2, false );
// Attempt the proxy fetch.
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
Path proxied2File = Paths.get(REPOPATH_PROXIED2, path);
assertFileEquals( expectedFile, downloadedFile.getFilePath(), proxied2File );
saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED2, false );
// Attempt the proxy fetch.
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
assertNull( "File returned was: " + downloadedFile + "; should have got a not found exception",
downloadedFile );
assertNotExistsInManagedDefaultRepo( expectedFile );
// Configure Repository (usually done within archiva.xml configuration)
- saveRemoteRepositoryConfig( "badproxied", "Bad Proxied", "test://bad.machine.com/repo/", "default" );
+ saveRemoteRepositoryConfig( "badproxied", "Bad Proxied", "" +
+ "http://bad.machine.com/repo/", "default" );
wagonMock.get( EasyMock.eq( path), EasyMock.anyObject( File.class ) );
EasyMock.expectLastCall().andThrow( new ResourceDoesNotExistException( "transfer failed" ) );
saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED2, false );
// Attempt the proxy fetch.
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
wagonMockControl.verify();
assertNotExistsInManagedDefaultRepo( expectedFile );
// Configure Repository (usually done within archiva.xml configuration)
- saveRemoteRepositoryConfig( "badproxied1", "Bad Proxied 1", "test://bad.machine.com/repo/", "default" );
- saveRemoteRepositoryConfig( "badproxied2", "Bad Proxied 2", "test://dead.machine.com/repo/", "default" );
+ saveRemoteRepositoryConfig( "badproxied1", "Bad Proxied 1", "http://bad.machine.com/repo/", "default" );
+ saveRemoteRepositoryConfig( "badproxied2", "Bad Proxied 2", "http://dead.machine.com/repo/", "default" );
// Configure Connector (usually done within archiva.xml configuration)
saveConnector( ID_DEFAULT_MANAGED, "badproxied1", false );
wagonMockControl.replay();
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
assertNotDownloaded( downloadedFile );
ProjectReference metadata = createProjectReference( requestedResource );
- StorageAsset downloadedFile = proxyHandler.fetchMetadataFromProxies( managedDefaultRepository,
+ StorageAsset downloadedFile = proxyHandler.fetchMetadataFromProxies( managedDefaultRepository.getRepository(),
managedDefaultRepository.toMetadataPath(
metadata ) ).getFile();
String requestedResource = "org/apache/maven/test/get-default-layout/maven-metadata.xml";
setupTestableManagedRepository( requestedResource );
- saveRemoteRepositoryConfig( "badproxied1", "Bad Proxied 1", "test://bad.machine.com/repo/", "default" );
+ saveRemoteRepositoryConfig( "badproxied1", "Bad Proxied 1", "http://bad.machine.com/repo/", "default" );
// Configure Connector (usually done within archiva.xml configuration)
saveConnector( ID_DEFAULT_MANAGED, "badproxied1", ChecksumPolicy.FIX, ReleasesPolicy.ALWAYS,
ProjectReference metadata = createProjectReference( requestedResource );
- StorageAsset downloadedFile = proxyHandler.fetchMetadataFromProxies( managedDefaultRepository,
+ StorageAsset downloadedFile = proxyHandler.fetchMetadataFromProxies( managedDefaultRepository.getRepository(),
managedDefaultRepository.toMetadataPath(
metadata ) ).getFile();
Path expectedFile = managedDefaultDir.resolve(requestedResource);
ProjectReference metadata = createProjectReference( requestedResource );
- StorageAsset downloadedFile = proxyHandler.fetchMetadataFromProxies( managedDefaultRepository,
+ StorageAsset downloadedFile = proxyHandler.fetchMetadataFromProxies( managedDefaultRepository.getRepository(),
managedDefaultRepository.toMetadataPath(
metadata ) ).getFile();
VersionedReference metadata = createVersionedReference( requestedResource );
- StorageAsset downloadedFile = proxyHandler.fetchMetadataFromProxies( managedDefaultRepository,
+ StorageAsset downloadedFile = proxyHandler.fetchMetadataFromProxies( managedDefaultRepository.getRepository(),
managedDefaultRepository.toMetadataPath(
metadata ) ).getFile();
Path expectedFile = managedDefaultDir.resolve(requestedResource);
VersionedReference metadata = createVersionedReference( requestedResource );
- StorageAsset downloadedFile = proxyHandler.fetchMetadataFromProxies( managedDefaultRepository,
+ StorageAsset downloadedFile = proxyHandler.fetchMetadataFromProxies( managedDefaultRepository.getRepository(),
managedDefaultRepository.toMetadataPath(
metadata ) ).getFile();
registryListeners.add( listener );
}
+
@Override
public void removeChangeListener( RegistryListener listener )
{
e.printStackTrace();
}
}
+
+ for (ConfigurationListener listener : configListeners) {
+ listener.configurationEvent( new ConfigurationEvent( ConfigurationEvent.CHANGED ) );
+ }
}
@Override
// Configure Connector (usually done within archiva.xml configuration)
saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED1, false);
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
assertNotDownloaded( downloadedFile );
assertNoTempFiles( expectedFile );
}
// Configure Connector (usually done within archiva.xml configuration)
saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED1, false);
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
Path proxiedFile = Paths.get(REPOPATH_PROXIED1, path);
assertFileEquals( expectedFile, downloadedFile.getFilePath(), proxiedFile );
// Configure Connector (usually done within archiva.xml configuration)
saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED1, false);
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
Path proxiedFile = Paths.get(REPOPATH_PROXIED1, path);
assertFileEquals( expectedFile, downloadedFile.getFilePath(), proxiedFile );
saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED1, false );
// Attempt to download.
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
// Should not have downloaded as managed is newer than remote.
assertNotDownloaded( downloadedFile );
// Configure Connector (usually done within archiva.xml configuration)
saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED1, false);
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
assertFileEquals( expectedFile, downloadedFile.getFilePath(), proxiedFile );
assertNoTempFiles( expectedFile );
// Configure Connector (usually done within archiva.xml configuration)
saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED1, false);
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
assertNotDownloaded( downloadedFile );
assertNotModified( expectedFile, expectedTimestamp );
saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED2, ChecksumPolicy.IGNORE, ReleasesPolicy.ALWAYS,
SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.YES , false);
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
Path proxiedFile = Paths.get(REPOPATH_PROXIED1, path);
assertFileEquals( expectedFile, downloadedFile.getFilePath(), proxiedFile );
// Configure Connector (usually done within archiva.xml configuration)
saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED1, false);
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
Path proxiedFile = Paths.get(REPOPATH_PROXIED1, path);
assertFileEquals( expectedFile, downloadedFile.getFilePath(), proxiedFile );
// Configure Connector (usually done within archiva.xml configuration)
saveConnector( ID_DEFAULT_MANAGED, ID_PROXIED1, false);
- StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository, artifact );
+ StorageAsset downloadedFile = proxyHandler.fetchFromProxies( managedDefaultRepository.getRepository(), artifact );
Path proxiedFile = Paths.get(REPOPATH_PROXIED1, path);
assertFileEquals( expectedFile, downloadedFile.getFilePath(), proxiedFile );
try
{
Files.createDirectories(destination.getParent());
- if ( contentToGet == null )
+ if ( contentToGet == null && !Files.exists(destination))
{
Files.createFile(destination);
}
- else
+ else if (contentToGet != null)
{
org.apache.archiva.common.utils.FileUtils.writeStringToFile(destination, Charset.defaultCharset(), contentToGet);
}
throw new RuntimeException( e.getMessage(), e );
}
}
+
+ public void cleanup() {
+
+ }
}
<bean name="repositoryContentProvider#mocked" class="org.apache.archiva.repository.mock.RepositoryContentProviderMock" />
- <bean name="repositoryProxyConnectors#test" class="org.apache.archiva.proxy.maven.MavenRepositoryProxyHandler">
+ <bean name="repositoryProxyHandler#test" class="org.apache.archiva.proxy.maven.MavenRepositoryProxyHandler">
<property name="archivaConfiguration" ref="archivaConfiguration#mock"/>
<property name="metadataTools" ref="metadataTools#mocked"/>
</bean>
+ <alias name="repositoryProxyHandler#test" alias="repositoryProxyHandler#maven"/>
+
<bean name="metadataTools#default" class="org.apache.archiva.repository.metadata.MetadataTools">
<property name="configuration" ref="archivaConfiguration#mock"/>
</bean>
<property name="timeToLiveSeconds" value="1800"/>
</bean>
- <bean name="wagon#test" class="org.apache.archiva.proxy.WagonDelegate" scope="singleton"/>
+ <bean name="wagon#http" class="org.apache.archiva.proxy.WagonDelegate" scope="singleton"/>
<bean name="wagon#file" scope="prototype" class="org.apache.maven.wagon.providers.file.FileWagon"/>
<alias name="userConfiguration#redback" alias="userConfiguration#default"/>
}
@Override
- public void applyServerSideRelocation(ManagedRepositoryContent managedRepository, ArtifactReference artifact)
+ public void applyServerSideRelocation(ManagedRepository managedRepository, ArtifactReference artifact)
throws ProxyDownloadException {
if ("pom".equals(artifact.getType())) {
return;
pomReference.setVersion(artifact.getVersion());
pomReference.setType("pom");
- RepositoryType repositoryType = managedRepository.getRepository().getType();
+ RepositoryType repositoryType = managedRepository.getType();
if (!proxyRegistry.hasHandler(repositoryType)) {
throw new ProxyDownloadException("No proxy handler found for repository type " + repositoryType, new HashMap<>());
}
proxyHandler.fetchFromProxies(managedRepository, pomReference);
// Open and read the POM from the managed repo
- StorageAsset pom = managedRepository.toFile(pomReference);
+ StorageAsset pom = managedRepository.getContent().toFile(pomReference);
if (!pom.exists()) {
return;
String path = managedRepositoryContent.toPath( archivaArtifact );
- file = proxyHandler.fetchFromProxies( managedRepositoryContent, path );
+ file = proxyHandler.fetchFromProxies( managedRepositoryContent.getRepository(), path );
if ( file != null && file.exists() )
{
// download pom now
String pomPath = StringUtils.substringBeforeLast( path, ".jar" ) + ".pom";
- proxyHandler.fetchFromProxies( managedRepositoryContent, pomPath );
+ proxyHandler.fetchFromProxies( managedRepositoryContent.getRepository(), pomPath );
return true;
}
}
import org.apache.archiva.model.ArtifactReference;
import org.apache.archiva.policies.ProxyDownloadException;
import org.apache.archiva.redback.components.taskqueue.TaskQueueException;
+import org.apache.archiva.repository.ManagedRepository;
import org.apache.archiva.repository.ManagedRepositoryContent;
import org.apache.archiva.repository.events.RepositoryListener;
import org.apache.archiva.scheduler.repository.model.RepositoryArchivaTaskScheduler;
}
@Override
- public void applyServerSideRelocation( ManagedRepositoryContent managedRepository, ArtifactReference artifact )
+ public void applyServerSideRelocation( ManagedRepository managedRepository, ArtifactReference artifact )
throws ProxyDownloadException
{
{
boolean previouslyExisted = repoAsset.exists();
- boolean fromProxy = fetchContentFromProxies( managedRepositoryContent, request, logicalResource );
+ boolean fromProxy = fetchContentFromProxies( managedRepository, request, logicalResource );
StorageAsset resourceAsset=null;
// At this point the incoming request can either be in default or
return resource;
}
- private boolean fetchContentFromProxies( ManagedRepositoryContent managedRepository, DavServletRequest request,
+ private boolean fetchContentFromProxies( ManagedRepository managedRepository, DavServletRequest request,
LogicalResource resource )
throws DavException
{
String path = resource.getPath();
- if (!proxyRegistry.hasHandler(managedRepository.getRepository().getType())) {
- throw new DavException(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "No proxy handler found for repository type "+managedRepository.getRepository().getType());
+ if (!proxyRegistry.hasHandler(managedRepository.getType())) {
+ throw new DavException(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "No proxy handler found for repository type "+managedRepository.getType());
}
- RepositoryRequestInfo repositoryRequestInfo = managedRepository.getRepository().getRequestInfo();
- RepositoryProxyHandler proxyHandler = proxyRegistry.getHandler(managedRepository.getRepository().getType()).get(0);
+ RepositoryRequestInfo repositoryRequestInfo = managedRepository.getRequestInfo();
+ RepositoryProxyHandler proxyHandler = proxyRegistry.getHandler(managedRepository.getType()).get(0);
if ( repositoryRequestInfo.isSupportFile( path ) )
{
StorageAsset proxiedFile = proxyHandler.fetchFromProxies( managedRepository, path );
if ( artifact != null )
{
- String repositoryLayout = managedRepository.getRepository().getLayout();
+ String repositoryLayout = managedRepository.getLayout();
RepositoryStorage repositoryStorage =
this.applicationContext.getBean( "repositoryStorage#" + repositoryLayout, RepositoryStorage.class );
StorageAsset proxiedFile = proxyHandler.fetchFromProxies( managedRepository, artifact );
- resource.setPath( managedRepository.toPath( artifact ) );
+ resource.setPath( managedRepository.getContent().toPath( artifact ) );
log.debug( "Proxied artifact '{}:{}:{}'", artifact.getGroupId(), artifact.getArtifactId(),
artifact.getVersion() );
import org.apache.archiva.proxy.maven.MavenRepositoryProxyHandler;
import org.apache.archiva.proxy.model.ProxyFetchResult;
-import org.apache.archiva.repository.ManagedRepositoryContent;
+import org.apache.archiva.repository.ManagedRepository;
import org.apache.archiva.repository.storage.StorageAsset;
import org.apache.commons.io.FileUtils;
import java.io.IOException;
-import java.nio.file.Path;
-import java.nio.file.Paths;
class OverridingRepositoryProxyHandler
extends MavenRepositoryProxyHandler
}
@Override
- public ProxyFetchResult fetchMetadataFromProxies(ManagedRepositoryContent repository, String logicalPath )
+ public ProxyFetchResult fetchMetadataFromProxies( ManagedRepository repository, String logicalPath )
{
- StorageAsset target = repository.getRepository().getAsset( logicalPath );
+ StorageAsset target = repository.getAsset( logicalPath );
try
{
FileUtils.copyFile( archivaDavResourceFactoryTest.getProjectBase().resolve( "target/test-classes/maven-metadata.xml" ).toFile(), target.getFilePath().toFile() );
import org.apache.archiva.filter.Filter;
import org.apache.archiva.model.ArtifactReference;
import org.apache.archiva.policies.ProxyDownloadException;
+import org.apache.archiva.repository.ManagedRepository;
import org.apache.archiva.repository.ManagedRepositoryContent;
import org.apache.archiva.xml.XMLException;
* @param artifact the artifact reference
* @throws org.apache.archiva.policies.ProxyDownloadException
*/
- void applyServerSideRelocation( ManagedRepositoryContent managedRepository, ArtifactReference artifact )
+ void applyServerSideRelocation( ManagedRepository managedRepository, ArtifactReference artifact )
throws ProxyDownloadException;
/**
import org.apache.archiva.metadata.repository.storage.RepositoryStorageRuntimeException;
import org.apache.archiva.model.ArtifactReference;
import org.apache.archiva.policies.ProxyDownloadException;
+import org.apache.archiva.repository.ManagedRepository;
import org.apache.archiva.repository.ManagedRepositoryContent;
import org.apache.archiva.repository.events.RepositoryListener;
import org.apache.archiva.xml.XMLException;
}
@Override
- public void applyServerSideRelocation( ManagedRepositoryContent managedRepository, ArtifactReference artifact )
+ public void applyServerSideRelocation( ManagedRepository managedRepository, ArtifactReference artifact )
throws ProxyDownloadException
{
projects / archiva.git / commitdiff