Apache
/
archiva
mirror of https://github.com/apache/archiva.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Refactoring repository registry

This commit is contained in:
Martin Stockhammer 2021-08-09 23:40:20 +02:00
parent 32cf204092
commit 3e959d5b07
45 changed files with 2107 additions and 846 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
archiva-modules/archiva-base/archiva-configuration/src/main/java/org/apache/archiva/configuration/DefaultArchivaConfiguration.java
View File

@ -430,7 +430,7 @@ public class DefaultArchivaConfiguration
if (section == null) {
section = baseSection;
if (section == null) {
section = createDefaultConfigurationFile();
section = createDefaultConfigurationFile(eventTag);
}
} else if (baseSection != null) {
Collection<String> keys = baseSection.getKeys();
@ -513,7 +513,7 @@ public class DefaultArchivaConfiguration
}
}
private Registry createDefaultConfigurationFile()
private Registry createDefaultConfigurationFile(String eventTag)
throws RegistryException {
// TODO: may not be needed under commons-configuration 1.4 - check
@ -543,7 +543,7 @@ public class DefaultArchivaConfiguration
addRegistryChangeListener(regListener);
}
triggerEvent(ConfigurationEvent.SAVED, "default-file");
triggerEvent(ConfigurationEvent.SAVED, eventTag==null?"default-file":eventTag);
Registry section = registry.getSection(KEY + ".user");
if (section == null) {

2
archiva-modules/archiva-base/archiva-configuration/src/main/java/org/apache/archiva/configuration/RepositoryGroupConfiguration.java
View File

@ -29,7 +29,7 @@ import java.util.List;
* @version $Revision$ $Date$
*/
@SuppressWarnings( "all" )
public class RepositoryGroupConfiguration
public class RepositoryGroupConfiguration extends AbstractRepositoryConfiguration
implements Serializable
{

24
archiva-modules/archiva-base/archiva-consumers/archiva-consumer-archetype/src/main/resources/archetype-resources/src/test/java/SimpleArtifactConsumerTest.java
View File

@ -21,10 +21,13 @@ package $package;
import org.apache.archiva.metadata.repository.MetadataRepository;
import org.apache.archiva.metadata.repository.RepositorySessionFactory;
import org.apache.archiva.repository.base.ArchivaRepositoryRegistry;
import org.apache.archiva.repository.base.managed.BasicManagedRepository;
import org.apache.archiva.repository.base.managed.ManagedRepositoryHandler;
import org.apache.archiva.repository.RepositoryException;
import org.apache.archiva.repository.RepositoryRegistry;
import org.junit.Before;
import org.junit.After;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
@ -52,7 +55,15 @@ public class SimpleArtifactConsumerTest
private SimpleArtifactConsumer consumer;
@Inject
private RepositoryRegistry repositoryRegistry;
private ArchivaRepositoryRegistry repositoryRegistry;
@SuppressWarnings( "unused" )
@Inject
private ManagedRepositoryHandler managedRepositoryHandler;
@SuppressWarnings( "unused" )
@Inject
private org.apache.archiva.repository.base.group.RepositoryGroupHandler repositoryGroupHandler;
@Inject
private RepositorySessionFactory repositorySessionFactory;
@ -70,9 +81,20 @@ public class SimpleArtifactConsumerTest
setUpMockRepository();
}
@After
public void tearDown() {
try
{
repositoryRegistry.removeRepository( "test-consumer-repository" );
} catch (Throwable ex) {
log.error( "Could not remove repository: {}", ex.getMessage( ) );
}
}
private void setUpMockRepository()
throws IOException, RepositoryException
{
((ArchivaRepositoryRegistry)repositoryRegistry).setIgnoreIndexing( true );
Path repoDir = Paths.get( "target/test-consumer-repo" );
Files.createDirectories( repoDir );
repoDir.toFile().deleteOnExit();

16
archiva-modules/archiva-base/archiva-consumers/archiva-core-consumers/src/test/java/org/apache/archiva/consumers/core/AbstractArtifactConsumerTest.java
View File

@ -25,7 +25,10 @@ import org.apache.archiva.configuration.FileType;
import org.apache.archiva.configuration.FileTypes;
import org.apache.archiva.consumers.KnownRepositoryContentConsumer;
import org.apache.archiva.consumers.functors.ConsumerWantsFilePredicate;
import org.apache.archiva.repository.RepositoryRegistry;
import org.apache.archiva.repository.base.ArchivaRepositoryRegistry;
import org.apache.archiva.repository.base.group.RepositoryGroupHandler;
import org.apache.archiva.repository.base.managed.ManagedRepositoryHandler;
import org.apache.archiva.test.utils.ArchivaSpringJUnit4ClassRunner;
import org.apache.commons.lang3.StringUtils;
import org.junit.After;
@ -56,6 +59,19 @@ public abstract class AbstractArtifactConsumerTest
@Inject
ArchivaConfiguration archivaConfiguration;
@SuppressWarnings( "unused" )
@Inject
RepositoryRegistry repositoryRegistry;
@SuppressWarnings( "unused" )
@Inject
RepositoryGroupHandler repositoryGroupHandler;
@SuppressWarnings( "unused" )
@Inject
ManagedRepositoryHandler managedRepositoryHandler;
@Before
public void setUp()
throws Exception

5
archiva-modules/archiva-base/archiva-consumers/archiva-core-consumers/src/test/java/org/apache/archiva/consumers/core/repository/AbstractRepositoryPurgeTest.java
View File

@ -25,6 +25,7 @@ import org.apache.archiva.metadata.repository.RepositorySession;
import org.apache.archiva.metadata.repository.RepositorySessionFactory;
import org.apache.archiva.repository.ManagedRepositoryContent;
import org.apache.archiva.repository.base.group.RepositoryGroupHandler;
import org.apache.archiva.repository.base.managed.ManagedRepositoryHandler;
import org.apache.archiva.repository.maven.metadata.storage.Maven2RepositoryPathTranslator;
import org.apache.archiva.repository.base.managed.BasicManagedRepository;
import org.apache.archiva.repository.ReleaseScheme;
@ -115,6 +116,10 @@ public abstract class AbstractRepositoryPurgeTest
@Inject
RepositoryGroupHandler repositoryGroupHandler;
@SuppressWarnings( "unused" )
@Inject
ManagedRepositoryHandler managedRepositoryHandler;
@Before
public void setUp()

5
archiva-modules/archiva-base/archiva-consumers/archiva-indexer-consumers/src/test/java/org/apache/archiva/consumers/lucene/NexusIndexerConsumerTest.java
View File

@ -28,6 +28,7 @@ import org.apache.archiva.repository.base.ArchivaRepositoryRegistry;
import org.apache.archiva.repository.base.managed.BasicManagedRepository;
import org.apache.archiva.repository.ReleaseScheme;
import org.apache.archiva.repository.base.group.RepositoryGroupHandler;
import org.apache.archiva.repository.base.managed.ManagedRepositoryHandler;
import org.apache.archiva.scheduler.ArchivaTaskScheduler;
import org.apache.archiva.scheduler.indexing.ArtifactIndexingTask;
import org.apache.archiva.test.utils.ArchivaSpringJUnit4ClassRunner;
@ -101,6 +102,10 @@ public class NexusIndexerConsumerTest
@Inject
RepositoryGroupHandler repositoryGroupHandler;
@SuppressWarnings( "unused" )
@Inject
ManagedRepositoryHandler managedRepositoryHandler;
@Override
@Before
public void setUp()

93
archiva-modules/archiva-base/archiva-repository-admin/archiva-repository-admin-default/src/main/java/org/apache/archiva/admin/repository/managed/DefaultManagedRepositoryAdmin.java
View File

@ -40,8 +40,11 @@ import org.apache.archiva.components.taskqueue.TaskQueueException;
import org.apache.archiva.redback.role.RoleManager;
import org.apache.archiva.redback.role.RoleManagerException;
import org.apache.archiva.repository.ReleaseScheme;
import org.apache.archiva.repository.Repository;
import org.apache.archiva.repository.RepositoryException;
import org.apache.archiva.repository.RepositoryRegistry;
import org.apache.archiva.repository.base.group.RepositoryGroupHandler;
import org.apache.archiva.repository.base.managed.ManagedRepositoryHandler;
import org.apache.archiva.repository.features.ArtifactCleanupFeature;
import org.apache.archiva.repository.features.IndexCreationFeature;
import org.apache.archiva.repository.features.StagingRepositoryFeature;
@ -85,6 +88,12 @@ public class DefaultManagedRepositoryAdmin
@Inject
private RepositoryRegistry repositoryRegistry;
@Inject
private ManagedRepositoryHandler managedRepositoryHandler;
@Inject
private RepositoryGroupHandler repositoryGroupHandler;
@Inject
@Named(value = "archivaTaskScheduler#repository")
private RepositoryArchivaTaskScheduler repositoryTaskScheduler;
@ -223,19 +232,9 @@ public class DefaultManagedRepositoryAdmin
Configuration configuration = getArchivaConfiguration().getConfiguration();
try
{
org.apache.archiva.repository.ManagedRepository newRepo = repositoryRegistry.putRepository( repoConfig, configuration );
org.apache.archiva.repository.ManagedRepository newRepo = repositoryRegistry.putRepository( repoConfig );
log.debug("Added new repository {}", newRepo.getId());
org.apache.archiva.repository.ManagedRepository stagingRepo = null;
addRepositoryRoles( newRepo.getId() );
if ( newRepo.supportsFeature( StagingRepositoryFeature.class )) {
StagingRepositoryFeature stf = newRepo.getFeature( StagingRepositoryFeature.class ).get();
stagingRepo = stf.getStagingRepository();
if (stf.isStageRepoNeeded() && stagingRepo != null) {
addRepositoryRoles( stagingRepo.getId() );
triggerAuditEvent( stagingRepo.getId(), null, AuditEvent.ADD_MANAGED_REPO, auditInformation );
}
}
saveConfiguration( configuration );
//MRM-1342 Repository statistics report doesn't appear to be working correctly
//scan repository when adding of repository is successful
try
@ -245,10 +244,14 @@ public class DefaultManagedRepositoryAdmin
scanRepository( newRepo.getId(), true );
}
if ( stagingRepo!=null && stagingRepo.isScanned() )
org.apache.archiva.repository.ManagedRepository stagingRepo = newRepo.getFeature( StagingRepositoryFeature.class ).get( ).getStagingRepository( );
if ( stagingRepo!=null)
{
if (stagingRepo.isScanned()) {
scanRepository( stagingRepo.getId(), true );
}
addRepositoryRoles( stagingRepo.getId( ) );
}
}
catch ( Exception e )
{
@ -285,15 +288,9 @@ public class DefaultManagedRepositoryAdmin
org.apache.archiva.repository.ManagedRepository repo = repositoryRegistry.getManagedRepository(repositoryId);
org.apache.archiva.repository.ManagedRepository stagingRepository = null;
if (repo != null) {
try {
if (repo.supportsFeature(StagingRepositoryFeature.class)) {
stagingRepository = repo.getFeature(StagingRepositoryFeature.class).get().getStagingRepository();
}
repositoryRegistry.removeRepository(repo, config);
} catch (RepositoryException e) {
log.error("Removal of repository {} failed: {}", repositoryId, e.getMessage(), e);
throw new RepositoryAdminException("Removal of repository " + repositoryId + " failed.");
}
} else {
throw new RepositoryAdminException("A repository with that id does not exist");
}
@ -308,14 +305,9 @@ public class DefaultManagedRepositoryAdmin
if (stagingRepository != null) {
// do not trigger event when deleting the staged one
ManagedRepositoryConfiguration stagingRepositoryConfig = config.findManagedRepositoryById(stagingRepository.getId());
try {
repositoryRegistry.removeRepository(stagingRepository);
if (stagingRepositoryConfig != null) {
deleteManagedRepository(stagingRepositoryConfig, deleteContent, config, true);
}
} catch (RepositoryException e) {
log.error("Removal of staging repository {} failed: {}", stagingRepository.getId(), e.getMessage(), e);
}
}
try {
@ -371,12 +363,6 @@ public class DefaultManagedRepositoryAdmin
}
if ( deleteContent )
{
// TODO could be async ? as directory can be huge
Path dir = Paths.get( repository.getLocation() );
org.apache.archiva.common.utils.FileUtils.deleteQuietly( dir );
}
// olamy: copy list for reading as a unit test in webapp fail with ConcurrentModificationException
List<ProxyConnectorConfiguration> proxyConnectors = new ArrayList<>( config.getProxyConnectors() );
@ -387,27 +373,6 @@ public class DefaultManagedRepositoryAdmin
config.removeProxyConnector( proxyConnector );
}
}
Map<String, List<String>> repoToGroupMap = config.getRepositoryToGroupMap();
if ( repoToGroupMap != null )
{
if ( repoToGroupMap.containsKey( repository.getId() ) )
{
List<String> repoGroups = repoToGroupMap.get( repository.getId() );
for ( String repoGroup : repoGroups )
{
// copy to prevent UnsupportedOperationException
RepositoryGroupConfiguration repositoryGroupConfiguration =
config.findRepositoryGroupById( repoGroup );
List<String> repos = new ArrayList<>( repositoryGroupConfiguration.getRepositories() );
config.removeRepositoryGroup( repositoryGroupConfiguration );
repos.remove( repository.getId() );
repositoryGroupConfiguration.setRepositories( repos );
config.addRepositoryGroup( repositoryGroupConfiguration );
}
}
}
try
{
removeRepositoryRoles( repository );
@ -419,9 +384,16 @@ public class DefaultManagedRepositoryAdmin
}
try {
final RepositoryRegistry reg = getRepositoryRegistry();
if (reg.getManagedRepository(repository.getId())!=null) {
reg.removeRepository(reg.getManagedRepository(repository.getId()));
org.apache.archiva.repository.ManagedRepository repo = repositoryRegistry.getManagedRepository( repository.getId( ) );
if (repo!=null)
{
repositoryRegistry.removeRepository( repo, config );
if ( deleteContent )
{
// TODO could be async ? as directory can be huge
Path dir = Paths.get( repository.getLocation( ) );
org.apache.archiva.common.utils.FileUtils.deleteQuietly( dir );
}
}
} catch (RepositoryException e) {
throw new RepositoryAdminException("Removal of repository "+repository.getId()+ " failed: "+e.getMessage());
@ -429,6 +401,7 @@ public class DefaultManagedRepositoryAdmin
saveConfiguration( config );
return Boolean.TRUE;
}
@ -452,8 +425,6 @@ public class DefaultManagedRepositoryAdmin
getRepositoryCommonValidator().validateManagedRepository( managedRepository );
Configuration configuration = getArchivaConfiguration().getConfiguration();
ManagedRepositoryConfiguration updatedRepoConfig = getRepositoryConfiguration( managedRepository );
updatedRepoConfig.setStageRepoNeeded( needStageRepo );
@ -467,7 +438,7 @@ public class DefaultManagedRepositoryAdmin
// TODO remove content from old if path has changed !!!!!
try
{
newRepo = repositoryRegistry.putRepository( updatedRepoConfig, configuration );
newRepo = repositoryRegistry.putRepository( updatedRepoConfig );
if (newRepo.supportsFeature( StagingRepositoryFeature.class )) {
org.apache.archiva.repository.ManagedRepository stagingRepo = newRepo.getFeature( StagingRepositoryFeature.class ).get( ).getStagingRepository( );
if (stagingRepo!=null && !stagingExists)
@ -490,16 +461,6 @@ public class DefaultManagedRepositoryAdmin
}
triggerAuditEvent( managedRepository.getId(), null, AuditEvent.MODIFY_MANAGED_REPO,
auditInformation );
try
{
getArchivaConfiguration().save(configuration);
}
catch ( RegistryException | IndeterminateConfigurationException e )
{
log.error("Could not save repository configuration: {}", e.getMessage(), e);
throw new RepositoryAdminException( "Could not save repository configuration: "+e.getMessage() );
}
// Save the repository configuration.
RepositorySession repositorySession = null;
try

10
archiva-modules/archiva-base/archiva-repository-admin/archiva-repository-admin-default/src/test/java/org/apache/archiva/admin/repository/AbstractRepositoryAdminTest.java
View File

@ -31,7 +31,9 @@ import org.apache.archiva.configuration.ArchivaConfiguration;
import org.apache.archiva.redback.role.RoleManager;
import org.apache.archiva.redback.users.User;
import org.apache.archiva.redback.users.memory.SimpleUser;
import org.apache.archiva.repository.RepositoryRegistry;
import org.apache.archiva.repository.base.group.RepositoryGroupHandler;
import org.apache.archiva.repository.base.managed.ManagedRepositoryHandler;
import org.apache.archiva.test.utils.ArchivaSpringJUnit4ClassRunner;
import org.apache.commons.lang3.StringUtils;
import org.junit.Before;
@ -84,10 +86,18 @@ public abstract class AbstractRepositoryAdminTest
@Inject
private ArchivaConfiguration archivaConfiguration;
@Inject
protected RepositoryRegistry repositoryRegistry;
@SuppressWarnings( "unused" )
@Inject
ManagedRepositoryHandler managedRepositoryHandler;
@SuppressWarnings( "unused" )
@Inject
RepositoryGroupHandler repositoryGroupHandler;
@Before
public void initialize() {
Path confFile = Paths.get(APPSERVER_BASE_PATH, "conf/archiva.xml");

6
archiva-modules/archiva-base/archiva-repository-admin/archiva-repository-admin-default/src/test/java/org/apache/archiva/admin/repository/group/RepositoryGroupAdminTest.java
View File

@ -27,6 +27,7 @@ import org.apache.archiva.metadata.model.facets.AuditEvent;
import org.apache.archiva.repository.Repository;
import org.apache.archiva.repository.RepositoryRegistry;
import org.apache.archiva.repository.base.group.RepositoryGroupHandler;
import org.apache.archiva.repository.base.managed.ManagedRepositoryHandler;
import org.junit.Test;
import javax.inject.Inject;
@ -42,11 +43,6 @@ public class RepositoryGroupAdminTest
@Inject
RepositoryGroupAdmin repositoryGroupAdmin;
@Inject
RepositoryRegistry repositoryRegistry;
@Inject
RepositoryGroupHandler repositoryGroupHandler;
@Test
public void addAndDeleteGroup()

35
archiva-modules/archiva-base/archiva-repository-api/src/main/java/org/apache/archiva/repository/RepositoryHandler.java
View File

@ -17,6 +17,7 @@ package org.apache.archiva.repository;
* under the License.
*/
import org.apache.archiva.configuration.AbstractRepositoryConfiguration;
import org.apache.archiva.configuration.Configuration;
import org.apache.archiva.repository.validation.CheckedResult;
import org.apache.archiva.repository.validation.RepositoryChecker;
@ -44,7 +45,7 @@ import java.util.Map;
*
* @author Martin Stockhammer <martin_s@apache.org>
*/
public interface RepositoryHandler<R extends Repository, C>
public interface RepositoryHandler<R extends Repository, C extends AbstractRepositoryConfiguration>
{
/**
@ -58,6 +59,12 @@ public interface RepositoryHandler<R extends Repository, C>
*/
void activateRepository( R repository );
/**
* Reset the repository. E.g. stops scheduling.
* @param repository
*/
void deactivateRepository( R repository );
/**
* Creates new instances from the archiva configuration. The instances are not registered in the registry.
*
@ -163,9 +170,10 @@ public interface RepositoryHandler<R extends Repository, C>
* Clones a given repository without registering.
*
* @param repo the repository that should be cloned
* @param newId the new identifier of the cloned instance
* @return a newly created instance with the same repository data
*/
R clone( R repo ) throws RepositoryException;
R clone( R repo, String newId ) throws RepositoryException;
/**
* Updates the references and stores updates in the given <code>configuration</code> instance.
@ -221,6 +229,13 @@ public interface RepositoryHandler<R extends Repository, C>
*/
boolean hasRepository( String id );
/**
* This is called, when another variant repository was removed. This is needed only for certain variants.
*
* @param repository
*/
void processOtherVariantRemoval( Repository repository );
/**
* Initializes the handler. This method must be called before using the repository handler.
*/
@ -231,4 +246,20 @@ public interface RepositoryHandler<R extends Repository, C>
*/
void close( );
/**
* Sets the repository provider list
* @param providers
*/
void setRepositoryProviders( List<RepositoryProvider> providers );
/**
* Sets the list of repository validators
* @param repositoryValidatorList
*/
void setRepositoryValidator( List<RepositoryValidator<? extends Repository>> repositoryValidatorList );
Class<R> getVariant();
Class<C> getConfigurationVariant();
}

35
archiva-modules/archiva-base/archiva-repository-api/src/main/java/org/apache/archiva/repository/RepositoryHandlerManager.java Normal file
View File

@ -0,0 +1,35 @@
package org.apache.archiva.repository;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
import org.apache.archiva.configuration.AbstractRepositoryConfiguration;
import org.apache.archiva.event.Event;
import org.apache.archiva.event.EventHandler;
/**
* @author Martin Stockhammer <martin_s@apache.org>
*/
public interface RepositoryHandlerManager extends EventHandler<Event>
{
<R extends Repository, C extends AbstractRepositoryConfiguration> RepositoryHandler<R,C> getHandler( Class<R> repositoryClazz, Class<C> configurationClazz);
void registerHandler( RepositoryHandler<?, ?> handler );
boolean isRegisteredId(String id);
}

2
archiva-modules/archiva-base/archiva-repository-api/src/main/java/org/apache/archiva/repository/RepositoryRegistry.java
View File

@ -50,7 +50,7 @@ import java.util.Map;
* @author Martin Stockhammer <martin_s@apache.org>
*/
@SuppressWarnings( "UnusedReturnValue" )
public interface RepositoryRegistry extends EventSource
public interface RepositoryRegistry extends EventSource, RepositoryHandlerManager
{
/**
* Set the configuration for the registry

2
archiva-modules/archiva-base/archiva-repository-api/src/main/java/org/apache/archiva/repository/RepositoryState.java
View File

@ -22,7 +22,7 @@ package org.apache.archiva.repository;
*/
public enum RepositoryState
{
CREATED(0),REFERENCES_SET(100),SAVED(200),INITIALIZED(300),REGISTERED(400),UNREGISTERED(500),CLOSED(600);
CREATED(0),REFERENCES_SET(100),SAVED(200),INITIALIZED(300),REGISTERED(400),DEACTIVATED(500), UNREGISTERED(600),CLOSED(700);
private final int orderNumber;

338
archiva-modules/archiva-base/archiva-repository-layer/src/main/java/org/apache/archiva/repository/base/AbstractRepositoryHandler.java
View File

@ -17,51 +17,367 @@ package org.apache.archiva.repository.base;
* under the License.
*/
import org.apache.archiva.components.registry.RegistryException;
import org.apache.archiva.configuration.AbstractRepositoryConfiguration;
import org.apache.archiva.configuration.Configuration;
import org.apache.archiva.configuration.IndeterminateConfigurationException;
import org.apache.archiva.event.Event;
import org.apache.archiva.event.EventManager;
import org.apache.archiva.event.EventType;
import org.apache.archiva.repository.EditableRepository;
import org.apache.archiva.repository.Repository;
import org.apache.archiva.repository.RepositoryException;
import org.apache.archiva.repository.RepositoryHandler;
import org.apache.archiva.repository.RepositoryProvider;
import org.apache.archiva.repository.RepositoryState;
import org.apache.archiva.repository.base.group.RepositoryGroupHandler;
import org.apache.archiva.repository.RepositoryType;
import org.apache.archiva.repository.event.LifecycleEvent;
import org.apache.archiva.repository.validation.CheckedResult;
import org.apache.archiva.repository.validation.CombinedValidator;
import org.apache.archiva.repository.validation.RepositoryChecker;
import org.apache.archiva.repository.validation.RepositoryValidator;
import org.apache.archiva.repository.validation.ValidationError;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* Base abstract class for repository handlers.
*
* @author Martin Stockhammer <martin_s@apache.org>
*/
public abstract class AbstractRepositoryHandler<R extends Repository, C> implements RepositoryHandler<R, C>
public abstract class AbstractRepositoryHandler<R extends Repository, C extends AbstractRepositoryConfiguration> implements RepositoryHandler<R, C>
{
private static final Logger log = LoggerFactory.getLogger( AbstractRepositoryHandler.class );
protected List<RepositoryValidator<R>> initValidators( Class<R> clazz, List<RepositoryValidator<? extends Repository>> repositoryGroupValidatorList) {
if (repositoryGroupValidatorList!=null && repositoryGroupValidatorList.size()>0) {
protected final Map<RepositoryType, RepositoryProvider> providerMap = new HashMap<>( );
private CombinedValidator<R> combinedValidator;
private final Class<R> repositoryClazz;
private final Class<C> configurationClazz;
private final EventManager eventManager;
private final Map<String, R> repositoryMap = new HashMap<>( );
private final ConfigurationHandler configurationHandler;
public AbstractRepositoryHandler(Class<R> repositoryClazz, Class<C> configurationClazz, ConfigurationHandler configurationHandler) {
this.repositoryClazz = repositoryClazz;
this.configurationClazz = configurationClazz;
this.eventManager = new EventManager( this );
this.configurationHandler = configurationHandler;
}
protected List<RepositoryValidator<R>> initValidators( Class<R> clazz, List<RepositoryValidator<? extends Repository>> repositoryGroupValidatorList )
{
if ( repositoryGroupValidatorList != null && repositoryGroupValidatorList.size( ) > 0 )
{
return repositoryGroupValidatorList.stream( ).filter(
v -> v.isFlavour( clazz )
).map( v -> v.narrowTo( clazz ) ).collect( Collectors.toList( ) );
} else {
}
else
{
return Collections.emptyList( );
}
}
protected CombinedValidator<R> getCombinedValidatdor(Class<R> clazz, List<RepositoryValidator<? extends Repository>> repositoryGroupValidatorList) {
protected CombinedValidator<R> getCombinedValidator( Class<R> clazz, List<RepositoryValidator<? extends Repository>> repositoryGroupValidatorList )
{
return new CombinedValidator<>( clazz, initValidators( clazz, repositoryGroupValidatorList ) );
}
protected void setLastState(Repository repo, RepositoryState state) {
if (repo instanceof EditableRepository ) {
if (state.getOrderNumber()>repo.getLastState().getOrderNumber())
protected void setLastState( R repo, RepositoryState state )
{
RepositoryState currentState = repo.getLastState( );
if ( repo instanceof EditableRepository )
{
if ( state.getOrderNumber( ) > repo.getLastState( ).getOrderNumber( ) )
{
( (EditableRepository) repo ).setLastState( state );
}
} else {
log.error( "Found a not editable repository instance: {}, {}", repo.getId( ), repo.getClass().getName() );
}
else
{
log.error( "Found a not editable repository instance: {}, {}", repo.getId( ), repo.getClass( ).getName( ) );
}
if (state == RepositoryState.REGISTERED && state != currentState ) {
pushEvent( LifecycleEvent.REGISTERED, repo );
} else if (state == RepositoryState.UNREGISTERED && state != currentState) {
pushEvent( LifecycleEvent.UNREGISTERED, repo );
}
}
@Override
public void setRepositoryProviders( List<RepositoryProvider> providers )
{
if ( providers != null )
{
for ( RepositoryProvider provider : providers )
{
for ( RepositoryType type : provider.provides( ) )
{
providerMap.put( type, provider );
}
}
}
}
protected RepositoryProvider getProvider(RepositoryType type) {
return providerMap.get( type );
}
@Override
public void setRepositoryValidator( List<RepositoryValidator<? extends Repository>> repositoryValidatorList )
{
this.combinedValidator = getCombinedValidator( repositoryClazz, repositoryValidatorList );
}
protected CombinedValidator<R> getCombinedValidator() {
return this.combinedValidator;
}
@Override
public Class<R> getVariant( )
{
return this.repositoryClazz;
}
@Override
public Class<C> getConfigurationVariant( )
{
return this.configurationClazz;
}
@Override
public void processOtherVariantRemoval( Repository repository )
{
// Default: do nothing
}
protected void pushEvent( Event event )
{
eventManager.fireEvent( event );
}
protected void pushEvent(EventType<? extends LifecycleEvent> event, R repo) {
pushEvent( new LifecycleEvent( event, this, repo ) );
}
protected Map<String, R> getRepositories() {
return repositoryMap;
}
protected ConfigurationHandler getConfigurationHandler() {
return configurationHandler;
}
@Override
public void activateRepository( R repository )
{
//
}
@Override
public void deactivateRepository( R repository )
{
}
@Override
public abstract R newInstance( C repositoryConfiguration ) throws RepositoryException;
@Override
public <D> CheckedResult<R, D> putWithCheck( C repositoryConfiguration, RepositoryChecker<R, D> checker ) throws RepositoryException
{
final String id = repositoryConfiguration.getId( );
R currentRepository = getRepositories().get( id );
R managedRepository = newInstance( repositoryConfiguration );
CheckedResult<R, D> result;
if ( currentRepository == null )
{
result = checker.apply( managedRepository );
}
else
{
result = checker.applyForUpdate( managedRepository );
}
if ( result.isValid( ) )
{
put( result.getRepository() );
}
return result;
}
protected abstract C findRepositoryConfiguration(Configuration configuration, String id);
protected abstract void removeRepositoryConfiguration(Configuration configuration, C repoConfiguration );
protected abstract void addRepositoryConfiguration( Configuration configuration, C repoConfiguration );
/**
* Removes a repository group from the registry and configuration, if it exists.
* The change is saved to the configuration immediately.
*
* @param id the id of the repository group to remove
* @throws RepositoryException if an error occurs during configuration save
*/
@Override
public void remove( String id ) throws RepositoryException
{
R repo = get( id );
if ( repo != null )
{
try
{
repo = getRepositories().remove( id );
if ( repo != null )
{
deactivateRepository( repo );
Configuration configuration = this.configurationHandler.getBaseConfiguration( );
C cfg = findRepositoryConfiguration( configuration, id );
if ( cfg != null )
{
removeRepositoryConfiguration( configuration, cfg );
}
this.configurationHandler.save( configuration, ConfigurationHandler.REGISTRY_EVENT_TAG );
setLastState( repo, RepositoryState.UNREGISTERED );
}
}
catch ( RegistryException | IndeterminateConfigurationException e )
{
// Rollback
log.error( "Could not save config after repository removal: {}", e.getMessage( ), e );
getRepositories().put( repo.getId( ), repo );
throw new RepositoryException( "Could not save configuration after repository removal: " + e.getMessage( ) );
}
}
}
@Override
public void remove( String id, Configuration configuration ) throws RepositoryException
{
R repo = getRepositories().get( id );
if ( repo != null )
{
repo = getRepositories().remove( id );
if ( repo != null )
{
deactivateRepository( repo );
}
setLastState( repo, RepositoryState.UNREGISTERED );
}
C cfg = findRepositoryConfiguration(configuration, id );
if ( cfg != null )
{
removeRepositoryConfiguration(configuration, cfg );
}
}
@Override
public R get( String groupId )
{
return getRepositories().get( groupId );
}
@Override
public Collection<R> getAll( )
{
return Collections.unmodifiableCollection( getRepositories( ).values( ) );
}
@Override
public RepositoryValidator<R> getValidator( )
{
return getCombinedValidator();
}
@Override
public CheckedResult<R, Map<String, List<ValidationError>>> validateRepository( R repository )
{
return getCombinedValidator( ).apply( repository );
}
@Override
public CheckedResult<R,Map<String, List<ValidationError>>> validateRepositoryForUpdate( R repository )
{
return getCombinedValidator().applyForUpdate( repository );
}
@Override
public boolean hasRepository( String id )
{
return getRepositories().containsKey( id );
}
@Override
public void close( )
{
for ( R repository : getRepositories().values( ) )
{
try
{
deactivateRepository( repository );
}
catch ( Throwable e )
{
log.error( "Could not close repository {}: {}", repository.getId( ), e.getMessage( ) );
}
}
getRepositories().clear( );
}
protected void registerNewRepository( C repositoryGroupConfiguration, R currentRepository, Configuration configuration, boolean updated ) throws IndeterminateConfigurationException, RegistryException, RepositoryException
{
final String id = repositoryGroupConfiguration.getId( );
getConfigurationHandler().save( configuration, ConfigurationHandler.REGISTRY_EVENT_TAG );
updateReferences( currentRepository, repositoryGroupConfiguration );
if (!updated )
{
setLastState( currentRepository, RepositoryState.REFERENCES_SET );
}
activateRepository( currentRepository );
getRepositories().put( id, currentRepository );
setLastState( currentRepository, RepositoryState.REGISTERED );
}
protected void rollback( Configuration configuration, R oldRepository, Exception e, C oldCfg ) throws RepositoryException
{
final String id = oldRepository.getId( );
replaceOrAddRepositoryConfig( oldCfg, configuration );
try
{
getConfigurationHandler().save( configuration, ConfigurationHandler.REGISTRY_EVENT_TAG );
}
catch ( IndeterminateConfigurationException | RegistryException indeterminateConfigurationException )
{
log.error( "Fatal error, config save during rollback failed: {}", e.getMessage( ), e );
}
updateReferences( oldRepository, oldCfg );
setLastState( oldRepository, RepositoryState.REFERENCES_SET );
activateRepository( oldRepository );
getRepositories().put( id, oldRepository );
setLastState( oldRepository, RepositoryState.REGISTERED );
}
protected void replaceOrAddRepositoryConfig( C repositoryGroupConfiguration, Configuration configuration )
{
C oldCfg = findRepositoryConfiguration( configuration, repositoryGroupConfiguration.getId( ) );
if ( oldCfg != null )
{
removeRepositoryConfiguration(configuration, oldCfg );
}
addRepositoryConfiguration( configuration, repositoryGroupConfiguration );
}
}

427
archiva-modules/archiva-base/archiva-repository-layer/src/main/java/org/apache/archiva/repository/base/ArchivaRepositoryRegistry.java
View File

@ -20,6 +20,7 @@ package org.apache.archiva.repository.base;
*/
import org.apache.archiva.components.registry.RegistryException;
import org.apache.archiva.configuration.AbstractRepositoryConfiguration;
import org.apache.archiva.configuration.ArchivaConfiguration;
import org.apache.archiva.configuration.Configuration;
import org.apache.archiva.configuration.ConfigurationEvent;
@ -38,8 +39,6 @@ import org.apache.archiva.indexer.ArchivaIndexingContext;
import org.apache.archiva.indexer.IndexCreationFailedException;
import org.apache.archiva.indexer.IndexManagerFactory;
import org.apache.archiva.indexer.IndexUpdateFailedException;
import org.apache.archiva.repository.base.group.RepositoryGroupHandler;
import org.apache.archiva.repository.validation.CheckedResult;
import org.apache.archiva.repository.EditableManagedRepository;
import org.apache.archiva.repository.EditableRemoteRepository;
import org.apache.archiva.repository.EditableRepository;
@ -49,6 +48,7 @@ import org.apache.archiva.repository.Repository;
import org.apache.archiva.repository.RepositoryContentFactory;
import org.apache.archiva.repository.RepositoryException;
import org.apache.archiva.repository.RepositoryGroup;
import org.apache.archiva.repository.RepositoryHandler;
import org.apache.archiva.repository.RepositoryProvider;
import org.apache.archiva.repository.RepositoryRegistry;
import org.apache.archiva.repository.RepositoryType;
@ -61,6 +61,7 @@ import org.apache.archiva.repository.features.IndexCreationFeature;
import org.apache.archiva.repository.features.StagingRepositoryFeature;
import org.apache.archiva.repository.metadata.MetadataReader;
import org.apache.archiva.repository.storage.StorageAsset;
import org.apache.archiva.repository.validation.CheckedResult;
import org.apache.archiva.repository.validation.RepositoryValidator;
import org.apache.archiva.repository.validation.ValidationError;
import org.apache.archiva.repository.validation.ValidationResponse;
@ -118,23 +119,26 @@ public class ArchivaRepositoryRegistry implements ConfigurationListener, EventHa
@Inject
List<MetadataReader> metadataReaderList;
@Inject
List<RepositoryValidator<? extends Repository>> repositoryValidatorList;
@Inject
@Named( "repositoryContentFactory#default" )
RepositoryContentFactory repositoryContentFactory;
private boolean ignoreIndexing = false;
private final EventManager eventManager;
private Map<String, ManagedRepository> managedRepositories = new HashMap<>( );
private Map<String, ManagedRepository> uManagedRepository = Collections.unmodifiableMap( managedRepositories );
private Map<String, RemoteRepository> remoteRepositories = new HashMap<>( );
private Map<String, RemoteRepository> uRemoteRepositories = Collections.unmodifiableMap( remoteRepositories );
private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock( );
private RepositoryGroupHandler groupHandler;
private RepositoryHandler<RepositoryGroup, RepositoryGroupConfiguration> groupHandler;
private RepositoryHandler<ManagedRepository, ManagedRepositoryConfiguration> managedRepositoryHandler;
private final Set<RepositoryValidator<? extends Repository>> validators;
private final ConfigurationHandler configurationHandler;
@ -155,7 +159,8 @@ public class ArchivaRepositoryRegistry implements ConfigurationListener, EventHa
private Set<RepositoryValidator<? extends Repository>> initValidatorList( List<RepositoryValidator<? extends Repository>> validators )
{
TreeSet<RepositoryValidator<? extends Repository>> val = new TreeSet<>( );
for (RepositoryValidator<? extends Repository> validator : validators) {
for ( RepositoryValidator<? extends Repository> validator : validators )
{
val.add( validator );
validator.setRepositoryRegistry( this );
}
@ -175,9 +180,7 @@ public class ArchivaRepositoryRegistry implements ConfigurationListener, EventHa
try
{
log.debug( "Initializing repository registry" );
updateManagedRepositoriesFromConfig( );
pushEvent( new RepositoryRegistryEvent( RepositoryRegistryEvent.MANAGED_REPOS_INITIALIZED, this ) );
managed_initialized.set( true );
initializeManagedRepositories();
updateRemoteRepositoriesFromConfig( );
pushEvent( new RepositoryRegistryEvent( RepositoryRegistryEvent.REMOTE_REPOS_INITIALIZED, this ) );
remote_initialized.set( true );
@ -211,9 +214,20 @@ public class ArchivaRepositoryRegistry implements ConfigurationListener, EventHa
}
}
public void registerGroupHandler( RepositoryGroupHandler groupHandler )
private void initializeManagedRepositories( )
{
if ( this.managedRepositoryHandler != null )
{
this.managedRepositoryHandler.initializeFromConfig( );
this.managed_initialized.set( true );
pushEvent( new RepositoryRegistryEvent( RepositoryRegistryEvent.MANAGED_REPOS_INITIALIZED, this ) );
}
}
public void registerGroupHandler( RepositoryHandler<RepositoryGroup, RepositoryGroupConfiguration> groupHandler )
{
this.groupHandler = groupHandler;
registerRepositoryHandler( groupHandler );
initializeRepositoryGroups( );
if ( managed_initialized.get( ) && remote_initialized.get( ) && groups_initalized.get( ) )
{
@ -221,15 +235,22 @@ public class ArchivaRepositoryRegistry implements ConfigurationListener, EventHa
}
}
public void registerManagedRepositoryHandler( RepositoryHandler<ManagedRepository, ManagedRepositoryConfiguration> managedRepositoryHandler )
{
this.managedRepositoryHandler = managedRepositoryHandler;
registerRepositoryHandler( managedRepositoryHandler );
initializeManagedRepositories();
if ( managed_initialized.get( ) && remote_initialized.get( ) && groups_initalized.get( ) )
{
pushEvent( new RepositoryRegistryEvent( RepositoryRegistryEvent.INITIALIZED, this ) );
}
}
@PreDestroy
public void destroy( )
{
for ( ManagedRepository rep : managedRepositories.values( ) )
{
rep.close( );
}
managedRepositories.clear( );
managedRepositoryHandler.close( );
for ( RemoteRepository repo : remoteRepositories.values( ) )
{
repo.close( );
@ -266,100 +287,15 @@ public class ArchivaRepositoryRegistry implements ConfigurationListener, EventHa
*/
private void updateManagedRepositoriesFromConfig( )
{
try
{
Set<String> configRepoIds = new HashSet<>( );
List<ManagedRepositoryConfiguration> managedRepoConfigs =
configurationHandler.getBaseConfiguration( ).getManagedRepositories( );
if ( managedRepoConfigs == null )
{
return;
managedRepositoryHandler.initializeFromConfig( );
}
for ( ManagedRepositoryConfiguration repoConfig : managedRepoConfigs )
{
ManagedRepository repo = putRepository( repoConfig, null );
configRepoIds.add( repoConfig.getId( ) );
if ( repo.supportsFeature( StagingRepositoryFeature.class ) )
{
StagingRepositoryFeature stagF = repo.getFeature( StagingRepositoryFeature.class ).get( );
if ( stagF.getStagingRepository( ) != null )
{
configRepoIds.add( stagF.getStagingRepository( ).getId( ) );
}
}
}
List<String> toRemove = managedRepositories.keySet( ).stream( ).filter( id -> !configRepoIds.contains( id ) ).collect( Collectors.toList( ) );
for ( String id : toRemove )
{
ManagedRepository removed = managedRepositories.remove( id );
removed.close( );
}
}
catch ( Throwable e )
{
log.error( "Could not initialize repositories from config: {}", e.getMessage( ), e );
return;
}
}
private ManagedRepository createNewManagedRepository( RepositoryProvider provider, ManagedRepositoryConfiguration cfg ) throws RepositoryException
{
log.debug( "Creating repo {}", cfg.getId( ) );
ManagedRepository repo = provider.createManagedInstance( cfg );
repo.registerEventHandler( RepositoryEvent.ANY, this );
updateRepositoryReferences( provider, repo, cfg, null );
return repo;
}
private String getStagingId( String repoId )
{
return repoId + StagingRepositoryFeature.STAGING_REPO_POSTFIX;
}
@SuppressWarnings( "unchecked" )
private void updateRepositoryReferences( RepositoryProvider provider, ManagedRepository repo, ManagedRepositoryConfiguration cfg, Configuration configuration ) throws RepositoryException
{
log.debug( "Updating references of repo {}", repo.getId( ) );
if ( repo.supportsFeature( StagingRepositoryFeature.class ) )
{
StagingRepositoryFeature feature = repo.getFeature( StagingRepositoryFeature.class ).get( );
if ( feature.isStageRepoNeeded( ) && feature.getStagingRepository( ) == null )
{
ManagedRepository stageRepo = getManagedRepository( getStagingId( repo.getId( ) ) );
if ( stageRepo == null )
{
stageRepo = getStagingRepository( provider, cfg, configuration );
managedRepositories.put( stageRepo.getId( ), stageRepo );
if ( configuration != null )
{
replaceOrAddRepositoryConfig( provider.getManagedConfiguration( stageRepo ), configuration );
}
pushEvent( new LifecycleEvent( LifecycleEvent.REGISTERED, this, stageRepo ) );
}
feature.setStagingRepository( stageRepo );
}
}
if ( repo instanceof EditableManagedRepository )
{
EditableManagedRepository editableRepo = (EditableManagedRepository) repo;
if ( repo.getContent( ) == null )
{
editableRepo.setContent( repositoryContentFactory.getManagedRepositoryContent( repo ) );
editableRepo.getContent( ).setRepository( editableRepo );
}
log.debug( "Index repo: " + repo.hasIndex( ) );
if ( repo.hasIndex( ) && ( repo.getIndexingContext( ) == null || !repo.getIndexingContext( ).isOpen( ) ) )
{
log.debug( "Creating indexing context for {}", repo.getId( ) );
createIndexingContext( editableRepo );
}
}
repo.registerEventHandler( RepositoryEvent.ANY, this );
}
@Override
public ArchivaIndexManager getIndexManager( RepositoryType type )
@ -397,22 +333,6 @@ public class ArchivaRepositoryRegistry implements ConfigurationListener, EventHa
}
}
private ManagedRepository getStagingRepository( RepositoryProvider provider, ManagedRepositoryConfiguration baseRepoCfg, Configuration configuration ) throws RepositoryException
{
ManagedRepository stageRepo = getManagedRepository( getStagingId( baseRepoCfg.getId( ) ) );
if ( stageRepo == null )
{
stageRepo = provider.createStagingInstance( baseRepoCfg );
if ( stageRepo.supportsFeature( StagingRepositoryFeature.class ) )
{
stageRepo.getFeature( StagingRepositoryFeature.class ).get( ).setStageRepoNeeded( false );
}
ManagedRepositoryConfiguration stageCfg = provider.getManagedConfiguration( stageRepo );
updateRepositoryReferences( provider, stageRepo, stageCfg, configuration );
}
return stageRepo;
}
private void updateRemoteRepositoriesFromConfig( )
{
@ -482,7 +402,7 @@ public class ArchivaRepositoryRegistry implements ConfigurationListener, EventHa
rwLock.readLock( ).lock( );
try
{
return Stream.concat( managedRepositories.values( ).stream( ), remoteRepositories.values( ).stream( ) ).collect( Collectors.toList( ) );
return Stream.concat( managedRepositoryHandler.getAll().stream( ), remoteRepositories.values( ).stream( ) ).collect( Collectors.toList( ) );
}
finally
{
@ -501,7 +421,7 @@ public class ArchivaRepositoryRegistry implements ConfigurationListener, EventHa
rwLock.readLock( ).lock( );
try
{
return uManagedRepository.values( );
return managed_initialized.get() ? managedRepositoryHandler.getAll( ) : Collections.emptyList();
}
finally
{
@ -556,10 +476,10 @@ public class ArchivaRepositoryRegistry implements ConfigurationListener, EventHa
try
{
log.debug( "getRepository {}", repoId );
if ( managedRepositories.containsKey( repoId ) )
if ( managedRepositoryHandler.hasRepository( repoId ) )
{
log.debug( "Managed repo" );
return managedRepositories.get( repoId );
return managedRepositoryHandler.get( repoId );
}
else if ( remoteRepositories.containsKey( repoId ) )
{
@ -594,7 +514,7 @@ public class ArchivaRepositoryRegistry implements ConfigurationListener, EventHa
rwLock.readLock( ).lock( );
try
{
return managedRepositories.get( repoId );
return managed_initialized.get() ? managedRepositoryHandler.get( repoId ) : null;
}
finally
{
@ -640,13 +560,15 @@ public class ArchivaRepositoryRegistry implements ConfigurationListener, EventHa
@Override
public boolean hasRepository( String repoId )
{
return this.managedRepositories.containsKey( repoId ) || this.remoteRepositories.containsKey( repoId ) || groupHandler.hasRepository( repoId );
return ( managedRepositoryHandler != null && managedRepositoryHandler.hasRepository( repoId ) )
|| ( this.remoteRepositories != null && this.remoteRepositories.containsKey( repoId ) )
|| ( this.groupHandler != null && groupHandler.hasRepository( repoId ) );
}
@Override
public boolean hasManagedRepository( String repoId )
{
return this.managedRepositories.containsKey( repoId );
return managedRepositoryHandler.hasRepository( repoId );
}
@Override
@ -658,7 +580,7 @@ public class ArchivaRepositoryRegistry implements ConfigurationListener, EventHa
@Override
public boolean hasRepositoryGroup( String groupId )
{
return groupHandler.hasRepository( groupId );
return this.groupHandler != null && groupHandler.hasRepository( groupId );
}
protected void saveConfiguration( Configuration configuration ) throws IndeterminateConfigurationException, RegistryException
@ -680,53 +602,7 @@ public class ArchivaRepositoryRegistry implements ConfigurationListener, EventHa
rwLock.writeLock( ).lock( );
try
{
final String id = managedRepository.getId( );
if ( remoteRepositories.containsKey( id ) )
{
throw new RepositoryException( "There exists a remote repository with id " + id + ". Could not update with managed repository." );
}
ManagedRepository originRepo = managedRepositories.put( id, managedRepository );
try
{
if ( originRepo != null && originRepo != managedRepository )
{
originRepo.close( );
}
RepositoryProvider provider = getProvider( managedRepository.getType( ) );
ManagedRepositoryConfiguration newCfg = provider.getManagedConfiguration( managedRepository );
Configuration configuration = configurationHandler.getBaseConfiguration( );
updateRepositoryReferences( provider, managedRepository, newCfg, configuration );
ManagedRepositoryConfiguration oldCfg = configuration.findManagedRepositoryById( id );
if ( oldCfg != null )
{
configuration.removeManagedRepository( oldCfg );
}
configuration.addManagedRepository( newCfg );
saveConfiguration( configuration );
if ( originRepo != managedRepository )
{
pushEvent( new LifecycleEvent( LifecycleEvent.REGISTERED, this, managedRepository ) );
}
else
{
pushEvent( new LifecycleEvent( LifecycleEvent.UPDATED, this, managedRepository ) );
}
return managedRepository;
}
catch ( Exception e )
{
// Rollback only partly, because repository is closed already
if ( originRepo != null )
{
managedRepositories.put( id, originRepo );
}
else
{
managedRepositories.remove( id );
}
log.error( "Exception during configuration update {}", e.getMessage( ), e );
throw new RepositoryException( "Could not save the configuration" + ( e.getMessage( ) == null ? "" : ": " + e.getMessage( ) ) );
}
return managed_initialized.get() ? managedRepositoryHandler.put( managedRepository ) : null;
}
finally
{
@ -748,26 +624,7 @@ public class ArchivaRepositoryRegistry implements ConfigurationListener, EventHa
rwLock.writeLock( ).lock( );
try
{
final String id = managedRepositoryConfiguration.getId( );
final RepositoryType repositoryType = RepositoryType.valueOf( managedRepositoryConfiguration.getType( ) );
Configuration configuration = configurationHandler.getBaseConfiguration( );
ManagedRepository repo = managedRepositories.get( id );
ManagedRepositoryConfiguration oldCfg = repo != null ? getProvider( repositoryType ).getManagedConfiguration( repo ) : null;
repo = putRepository( managedRepositoryConfiguration, configuration );
try
{
saveConfiguration( configuration );
}
catch ( IndeterminateConfigurationException | RegistryException e )
{
if ( oldCfg != null )
{
getProvider( repositoryType ).updateManagedInstance( (EditableManagedRepository) repo, oldCfg );
}
log.error( "Could not save the configuration for repository {}: {}", id, e.getMessage( ), e );
throw new RepositoryException( "Could not save the configuration for repository " + id + ": " + e.getMessage( ) );
}
return repo;
return managedRepositoryHandler.put( managedRepositoryConfiguration );
}
finally
{
@ -791,39 +648,7 @@ public class ArchivaRepositoryRegistry implements ConfigurationListener, EventHa
rwLock.writeLock( ).lock( );
try
{
final String id = managedRepositoryConfiguration.getId( );
final RepositoryType repoType = RepositoryType.valueOf( managedRepositoryConfiguration.getType( ) );
ManagedRepository repo;
boolean registeredNew = false;
repo = managedRepositories.get( id );
if ( repo != null && repo.isOpen( ) )
{
if ( repo instanceof EditableManagedRepository )
{
getProvider( repoType ).updateManagedInstance( (EditableManagedRepository) repo, managedRepositoryConfiguration );
}
else
{
throw new RepositoryException( "The repository is not editable " + id );
}
}
else
{
repo = getProvider( repoType ).createManagedInstance( managedRepositoryConfiguration );
managedRepositories.put( id, repo );
registeredNew = true;
}
updateRepositoryReferences( getProvider( repoType ), repo, managedRepositoryConfiguration, configuration );
replaceOrAddRepositoryConfig( managedRepositoryConfiguration, configuration );
if ( registeredNew )
{
pushEvent( new LifecycleEvent( LifecycleEvent.REGISTERED, this, repo ) );
}
else
{
pushEvent( new LifecycleEvent( LifecycleEvent.UPDATED, this, repo ) );
}
return repo;
return managedRepositoryHandler.put( managedRepositoryConfiguration, configuration );
}
finally
{
@ -888,7 +713,7 @@ public class ArchivaRepositoryRegistry implements ConfigurationListener, EventHa
rwLock.writeLock( ).lock( );
try
{
return groupHandler.putWithCheck( repositoryGroupConfiguration, groupHandler.getValidator() );
return groupHandler.putWithCheck( repositoryGroupConfiguration, groupHandler.getValidator( ) );
}
finally
{
@ -919,19 +744,6 @@ public class ArchivaRepositoryRegistry implements ConfigurationListener, EventHa
}
}
private void replaceOrAddRepositoryConfig( ManagedRepositoryConfiguration managedRepositoryConfiguration, Configuration configuration )
{
if ( configuration != null )
{
ManagedRepositoryConfiguration oldCfg = configuration.findManagedRepositoryById( managedRepositoryConfiguration.getId( ) );
if ( oldCfg != null )
{
configuration.removeManagedRepository( oldCfg );
}
configuration.addManagedRepository( managedRepositoryConfiguration );
}
}
private void replaceOrAddRepositoryConfig( RemoteRepositoryConfiguration remoteRepositoryConfiguration, Configuration configuration )
{
if ( configuration != null )
@ -945,16 +757,6 @@ public class ArchivaRepositoryRegistry implements ConfigurationListener, EventHa
}
}
private void replaceOrAddRepositoryConfig( RepositoryGroupConfiguration repositoryGroupConfiguration, Configuration configuration )
{
RepositoryGroupConfiguration oldCfg = configuration.findRepositoryGroupById( repositoryGroupConfiguration.getId( ) );
if ( oldCfg != null )
{
configuration.removeRepositoryGroup( oldCfg );
}
configuration.addRepositoryGroup( repositoryGroupConfiguration );
}
@Override
public RemoteRepository putRepository( RemoteRepository remoteRepository, Configuration configuration ) throws RepositoryException
{
@ -962,7 +764,7 @@ public class ArchivaRepositoryRegistry implements ConfigurationListener, EventHa
try
{
final String id = remoteRepository.getId( );
if ( managedRepositories.containsKey( id ) )
if ( managedRepositoryHandler.hasRepository( id ) )
{
throw new RepositoryException( "There exists a managed repository with id " + id + ". Could not update with remote repository." );
}
@ -1206,41 +1008,16 @@ public class ArchivaRepositoryRegistry implements ConfigurationListener, EventHa
{
return;
}
final String id = managedRepository.getId( );
ManagedRepository repo = getManagedRepository( id );
if ( repo != null )
{
rwLock.writeLock( ).lock( );
try
{
repo = managedRepositories.remove( id );
if ( repo != null )
{
repo.close( );
this.groupHandler.removeRepositoryFromGroups( repo );
Configuration configuration = configurationHandler.getBaseConfiguration( );
ManagedRepositoryConfiguration cfg = configuration.findManagedRepositoryById( id );
if ( cfg != null )
{
configuration.removeManagedRepository( cfg );
}
saveConfiguration( configuration );
}
pushEvent( new LifecycleEvent( LifecycleEvent.UNREGISTERED, this, repo ) );
}
catch ( RegistryException | IndeterminateConfigurationException e )
{
// Rollback
log.error( "Could not save config after repository removal: {}", e.getMessage( ), e );
managedRepositories.put( repo.getId( ), repo );
throw new RepositoryException( "Could not save configuration after repository removal: " + e.getMessage( ) );
if (managed_initialized.get() ) managedRepositoryHandler.remove( managedRepository.getId( ) );
}
finally
{
rwLock.writeLock( ).unlock( );
}
}
}
@Override
@ -1250,31 +1027,15 @@ public class ArchivaRepositoryRegistry implements ConfigurationListener, EventHa
{
return;
}
final String id = managedRepository.getId( );
ManagedRepository repo = getManagedRepository( id );
if ( repo != null )
{
rwLock.writeLock( ).lock( );
try
{
repo = managedRepositories.remove( id );
if ( repo != null )
{
repo.close( );
this.groupHandler.removeRepositoryFromGroups( repo );
ManagedRepositoryConfiguration cfg = configuration.findManagedRepositoryById( id );
if ( cfg != null )
{
configuration.removeManagedRepository( cfg );
}
}
pushEvent( new LifecycleEvent( LifecycleEvent.UNREGISTERED, this, repo ) );
if (managed_initialized.get()) managedRepositoryHandler.remove( managedRepository.getId( ), configuration );
}
finally
{
rwLock.writeLock( ).unlock( );
}
}
}
@ -1457,16 +1218,11 @@ public class ArchivaRepositoryRegistry implements ConfigurationListener, EventHa
*/
public ManagedRepository clone( ManagedRepository repo, String newId ) throws RepositoryException
{
if ( managedRepositories.containsKey( newId ) || remoteRepositories.containsKey( newId ) )
{
throw new RepositoryException( "The given id exists already " + newId );
if (isRegisteredId( newId )) {
throw new RepositoryException( "The new id exists already: " + newId );
}
RepositoryProvider provider = getProvider( repo.getType( ) );
ManagedRepositoryConfiguration cfg = provider.getManagedConfiguration( repo );
cfg.setId( newId );
ManagedRepository cloned = provider.createManagedInstance( cfg );
cloned.registerEventHandler( RepositoryEvent.ANY, this );
return cloned;
EditableManagedRepository newRepo = (EditableManagedRepository) managedRepositoryHandler.clone( repo, newId );
return newRepo;
}
@Override
@ -1495,7 +1251,7 @@ public class ArchivaRepositoryRegistry implements ConfigurationListener, EventHa
*/
public RemoteRepository clone( RemoteRepository repo, String newId ) throws RepositoryException
{
if ( managedRepositories.containsKey( newId ) || remoteRepositories.containsKey( newId ) )
if ( isRegisteredId( newId ) )
{
throw new RepositoryException( "The given id exists already " + newId );
}
@ -1526,8 +1282,8 @@ public class ArchivaRepositoryRegistry implements ConfigurationListener, EventHa
{
Map<String, List<ValidationError>> errorMap = this.validators.stream( )
.filter( ( validator ) -> validator.getType( ).equals( RepositoryType.ALL ) || repository.getType( ).equals( validator.getType( ) ) )
.filter( val -> val.isFlavour( repository.getClass() ))
.flatMap( validator -> ((RepositoryValidator<R>)validator).apply( repository ).getResult().entrySet( ).stream( ) )
.filter( val -> val.isFlavour( repository.getClass( ) ) )
.flatMap( validator -> ( (RepositoryValidator<R>) validator ).apply( repository ).getResult( ).entrySet( ).stream( ) )
.collect( Collectors.toMap(
entry -> entry.getKey( ),
entry -> entry.getValue( ),
@ -1541,8 +1297,8 @@ public class ArchivaRepositoryRegistry implements ConfigurationListener, EventHa
{
Map<String, List<ValidationError>> errorMap = this.validators.stream( )
.filter( ( validator ) -> validator.getType( ).equals( RepositoryType.ALL ) || repository.getType( ).equals( validator.getType( ) ) )
.filter( val -> val.isFlavour( repository.getClass() ))
.flatMap( validator -> ((RepositoryValidator<R>)validator).applyForUpdate( repository ).getResult().entrySet( ).stream( ) )
.filter( val -> val.isFlavour( repository.getClass( ) ) )
.flatMap( validator -> ( (RepositoryValidator<R>) validator ).applyForUpdate( repository ).getResult( ).entrySet( ).stream( ) )
.collect( Collectors.toMap(
entry -> entry.getKey( ),
entry -> entry.getValue( ),
@ -1593,6 +1349,8 @@ public class ArchivaRepositoryRegistry implements ConfigurationListener, EventHa
}
private void handleIndexCreationEvent( RepositoryIndexEvent event )
{
if (!ignoreIndexing && !( event.getRepository() instanceof ManagedRepository ))
{
RepositoryIndexEvent idxEvent = event;
EditableRepository repo = (EditableRepository) idxEvent.getRepository( );
@ -1628,6 +1386,7 @@ public class ArchivaRepositoryRegistry implements ConfigurationListener, EventHa
}
}
}
}
private boolean sameOriginator( Event event )
{
@ -1650,5 +1409,57 @@ public class ArchivaRepositoryRegistry implements ConfigurationListener, EventHa
eventManager.fireEvent( event );
}
private <R extends Repository, C extends AbstractRepositoryConfiguration> void registerRepositoryHandler( RepositoryHandler<R, C> repositoryHandler )
{
repositoryHandler.setRepositoryProviders( this.repositoryProviders );
repositoryHandler.setRepositoryValidator( this.repositoryValidatorList );
}
@Override
public void registerHandler( RepositoryHandler<?, ?> handler )
{
if ( handler.getVariant( ).isAssignableFrom( RepositoryGroup.class ) )
{
registerGroupHandler( (RepositoryHandler<RepositoryGroup, RepositoryGroupConfiguration>) handler );
}
else if ( handler.getVariant( ).isAssignableFrom( ManagedRepository.class ) )
{
registerManagedRepositoryHandler( (RepositoryHandler<ManagedRepository, ManagedRepositoryConfiguration>) handler );
}
}
@Override
public boolean isRegisteredId( String id )
{
return hasRepository( id );
}
@Override
public <R extends Repository, C extends AbstractRepositoryConfiguration> RepositoryHandler<R, C> getHandler( Class<R> repositoryClazz, Class<C> configurationClazz )
{
if ( repositoryClazz.isAssignableFrom( RepositoryGroup.class ) )
{
return (RepositoryHandler<R, C>) this.groupHandler;
}
else if ( repositoryClazz.isAssignableFrom( ManagedRepository.class ) )
{
return (RepositoryHandler<R, C>) this.managedRepositoryHandler;
}
else
{
return null;
}
}
public boolean isIgnoreIndexing( )
{
return ignoreIndexing;
}
public void setIgnoreIndexing( boolean ignoreIndexing )
{
this.ignoreIndexing = ignoreIndexing;
}
}

311
archiva-modules/archiva-base/archiva-repository-layer/src/main/java/org/apache/archiva/repository/base/group/RepositoryGroupHandler.java
View File

@ -20,13 +20,9 @@ package org.apache.archiva.repository.base.group;
import org.apache.archiva.components.registry.RegistryException;
import org.apache.archiva.configuration.Configuration;
import org.apache.archiva.configuration.IndeterminateConfigurationException;
import org.apache.archiva.configuration.ManagedRepositoryConfiguration;
import org.apache.archiva.configuration.RepositoryGroupConfiguration;
import org.apache.archiva.indexer.merger.MergedRemoteIndexesScheduler;
import org.apache.archiva.repository.RepositoryState;
import org.apache.archiva.repository.base.AbstractRepositoryHandler;
import org.apache.archiva.repository.base.ArchivaRepositoryRegistry;
import org.apache.archiva.repository.base.ConfigurationHandler;
import org.apache.archiva.repository.validation.CheckedResult;
import org.apache.archiva.repository.EditableRepository;
import org.apache.archiva.repository.EditableRepositoryGroup;
import org.apache.archiva.repository.ManagedRepository;
@ -34,14 +30,17 @@ import org.apache.archiva.repository.Repository;
import org.apache.archiva.repository.RepositoryException;
import org.apache.archiva.repository.RepositoryGroup;
import org.apache.archiva.repository.RepositoryHandler;
import org.apache.archiva.repository.RepositoryHandlerManager;
import org.apache.archiva.repository.RepositoryProvider;
import org.apache.archiva.repository.RepositoryState;
import org.apache.archiva.repository.RepositoryType;
import org.apache.archiva.repository.base.AbstractRepositoryHandler;
import org.apache.archiva.repository.base.ArchivaRepositoryRegistry;
import org.apache.archiva.repository.base.ConfigurationHandler;
import org.apache.archiva.repository.event.LifecycleEvent;
import org.apache.archiva.repository.event.RepositoryEvent;
import org.apache.archiva.repository.features.IndexCreationFeature;
import org.apache.archiva.repository.storage.StorageAsset;
import org.apache.archiva.repository.validation.RepositoryChecker;
import org.apache.archiva.repository.validation.RepositoryValidator;
import org.apache.archiva.repository.validation.ValidationError;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -53,14 +52,10 @@ import javax.inject.Named;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.stream.Collectors;
@ -79,13 +74,9 @@ public class RepositoryGroupHandler
{
private static final Logger log = LoggerFactory.getLogger( RepositoryGroupHandler.class );
private final ArchivaRepositoryRegistry repositoryRegistry;
private final ConfigurationHandler configurationHandler;
private final RepositoryHandlerManager repositoryRegistry;
private final MergedRemoteIndexesScheduler mergedRemoteIndexesScheduler;
private final Map<String, RepositoryGroup> repositoryGroups = new HashMap<>( );
private final RepositoryValidator<RepositoryGroup> validator;
private Path groupsDirectory;
@ -95,18 +86,15 @@ public class RepositoryGroupHandler
* @param repositoryRegistry the registry. To avoid circular dependencies via DI, this class registers itself on the registry.
* @param configurationHandler the configuration handler is used to retrieve and save configuration.
* @param mergedRemoteIndexesScheduler the index scheduler is used for merging the indexes from all group members
* @param repositoryValidatorList the list of validators that are registered
*/
public RepositoryGroupHandler( ArchivaRepositoryRegistry repositoryRegistry,
public RepositoryGroupHandler( RepositoryHandlerManager repositoryRegistry,
ConfigurationHandler configurationHandler,
@Named( "mergedRemoteIndexesScheduler#default" ) MergedRemoteIndexesScheduler mergedRemoteIndexesScheduler,
List<RepositoryValidator<? extends Repository>> repositoryValidatorList
@Named( "mergedRemoteIndexesScheduler#default" ) MergedRemoteIndexesScheduler mergedRemoteIndexesScheduler
)
{
this.configurationHandler = configurationHandler;
super( RepositoryGroup.class, RepositoryGroupConfiguration.class, configurationHandler );
this.mergedRemoteIndexesScheduler = mergedRemoteIndexesScheduler;
this.repositoryRegistry = repositoryRegistry;
this.validator = getCombinedValidatdor( RepositoryGroup.class, repositoryValidatorList );
}
@Override
@ -116,15 +104,15 @@ public class RepositoryGroupHandler
log.debug( "Initializing repository group handler " + repositoryRegistry.toString( ) );
initializeStorage( );
// We are registering this class on the registry. This is necessary to avoid circular dependencies via injection.
this.repositoryRegistry.registerGroupHandler( this );
this.repositoryRegistry.registerHandler( this );
}
@Override
public void initializeFromConfig( )
{
this.repositoryGroups.clear( );
this.repositoryGroups.putAll( newInstancesFromConfig( ) );
for ( RepositoryGroup group : this.repositoryGroups.values( ) )
getRepositories().clear( );
getRepositories().putAll( newInstancesFromConfig( ) );
for ( RepositoryGroup group : getRepositories().values( ) )
{
activateRepository( group );
}
@ -132,7 +120,7 @@ public class RepositoryGroupHandler
private void initializeStorage( )
{
Path baseDir = this.configurationHandler.getArchivaConfiguration( ).getRepositoryGroupBaseDir( );
Path baseDir = this.getConfigurationHandler().getArchivaConfiguration( ).getRepositoryGroupBaseDir( );
if ( !Files.exists( baseDir ) )
{
try
@ -179,6 +167,14 @@ public class RepositoryGroupHandler
setLastState( repositoryGroup, RepositoryState.INITIALIZED );
}
@Override
public void deactivateRepository( RepositoryGroup repository )
{
mergedRemoteIndexesScheduler.unschedule( repository );
repository.close();
setLastState( repository, RepositoryState.DEACTIVATED );
}
public StorageAsset getMergedIndexDirectory( RepositoryGroup group )
{
if ( group != null )
@ -198,7 +194,7 @@ public class RepositoryGroupHandler
try
{
List<RepositoryGroupConfiguration> repositoryGroupConfigurations =
this.configurationHandler.getBaseConfiguration( ).getRepositoryGroups( );
this.getConfigurationHandler().getBaseConfiguration( ).getRepositoryGroups( );
if ( repositoryGroupConfigurations == null )
{
@ -207,11 +203,10 @@ public class RepositoryGroupHandler
Map<String, RepositoryGroup> repositoryGroupMap = new LinkedHashMap<>( repositoryGroupConfigurations.size( ) );
Map<RepositoryType, RepositoryProvider> providerMap = repositoryRegistry.getRepositoryProviderMap( );
for ( RepositoryGroupConfiguration repoConfig : repositoryGroupConfigurations )
{
RepositoryType repositoryType = RepositoryType.valueOf( repoConfig.getType( ) );
if ( providerMap.containsKey( repositoryType ) )
if ( super.providerMap.containsKey( repositoryType ) )
{
try
{
@ -236,7 +231,7 @@ public class RepositoryGroupHandler
@Override
public RepositoryGroup newInstance( final RepositoryType type, String id ) throws RepositoryException
{
RepositoryProvider provider = repositoryRegistry.getProvider( type );
RepositoryProvider provider = getProvider( type );
RepositoryGroupConfiguration config = new RepositoryGroupConfiguration( );
config.setId( id );
return createNewRepositoryGroup( provider, config );
@ -246,7 +241,7 @@ public class RepositoryGroupHandler
public RepositoryGroup newInstance( final RepositoryGroupConfiguration repositoryConfiguration ) throws RepositoryException
{
RepositoryType type = RepositoryType.valueOf( repositoryConfiguration.getType( ) );
RepositoryProvider provider = repositoryRegistry.getProvider( type );
RepositoryProvider provider = getProvider( type );
return createNewRepositoryGroup( provider, repositoryConfiguration );
}
@ -258,6 +253,7 @@ public class RepositoryGroupHandler
{
( (EditableRepository) repositoryGroup ).setLastState( RepositoryState.REFERENCES_SET );
}
repositoryGroup.registerEventHandler( RepositoryEvent.ANY, repositoryRegistry );
return repositoryGroup;
}
@ -273,21 +269,21 @@ public class RepositoryGroupHandler
public RepositoryGroup put( final RepositoryGroup repositoryGroup ) throws RepositoryException
{
final String id = repositoryGroup.getId( );
RepositoryGroup originRepoGroup = repositoryGroups.remove( id );
RepositoryGroup originRepoGroup = getRepositories().remove( id );
try
{
if ( originRepoGroup != null && originRepoGroup != repositoryGroup )
{
this.mergedRemoteIndexesScheduler.unschedule( originRepoGroup );
originRepoGroup.close( );
deactivateRepository( originRepoGroup );
pushEvent( new LifecycleEvent( LifecycleEvent.UNREGISTERED, this, originRepoGroup ) );
}
RepositoryProvider provider = repositoryRegistry.getProvider( repositoryGroup.getType( ) );
RepositoryProvider provider = getProvider( repositoryGroup.getType( ) );
RepositoryGroupConfiguration newCfg = provider.getRepositoryGroupConfiguration( repositoryGroup );
ReentrantReadWriteLock.WriteLock configLock = this.configurationHandler.getLock( ).writeLock( );
ReentrantReadWriteLock.WriteLock configLock = this.getConfigurationHandler().getLock( ).writeLock( );
configLock.lock( );
try
{
Configuration configuration = this.configurationHandler.getBaseConfiguration( );
Configuration configuration = this.getConfigurationHandler().getBaseConfiguration( );
updateReferences( repositoryGroup, newCfg );
RepositoryGroupConfiguration oldCfg = configuration.findRepositoryGroupById( id );
if ( oldCfg != null )
@ -295,7 +291,7 @@ public class RepositoryGroupHandler
configuration.removeRepositoryGroup( oldCfg );
}
configuration.addRepositoryGroup( newCfg );
configurationHandler.save( configuration, ConfigurationHandler.REGISTRY_EVENT_TAG );
getConfigurationHandler().save( configuration, ConfigurationHandler.REGISTRY_EVENT_TAG );
setLastState( repositoryGroup, RepositoryState.SAVED );
activateRepository( repositoryGroup );
}
@ -303,7 +299,7 @@ public class RepositoryGroupHandler
{
configLock.unlock( );
}
repositoryGroups.put( id, repositoryGroup );
getRepositories().put( id, repositoryGroup );
setLastState( repositoryGroup, RepositoryState.REGISTERED );
return repositoryGroup;
}
@ -312,11 +308,11 @@ public class RepositoryGroupHandler
// Rollback
if ( originRepoGroup != null )
{
repositoryGroups.put( id, originRepoGroup );
getRepositories().put( id, originRepoGroup );
}
else
{
repositoryGroups.remove( id );
getRepositories().remove( id );
}
log.error( "Exception during configuration update {}", e.getMessage( ), e );
throw new RepositoryException( "Could not save the configuration" + ( e.getMessage( ) == null ? "" : ": " + e.getMessage( ) ), e);
@ -336,31 +332,28 @@ public class RepositoryGroupHandler
{
final String id = repositoryGroupConfiguration.getId( );
final RepositoryType repositoryType = RepositoryType.valueOf( repositoryGroupConfiguration.getType( ) );
final RepositoryProvider provider = repositoryRegistry.getProvider( repositoryType );
final RepositoryProvider provider = getProvider( repositoryType );
RepositoryGroup currentRepository;
ReentrantReadWriteLock.WriteLock configLock = this.configurationHandler.getLock( ).writeLock( );
ReentrantReadWriteLock.WriteLock configLock = this.getConfigurationHandler().getLock( ).writeLock( );
configLock.lock( );
try
{
Configuration configuration = this.configurationHandler.getBaseConfiguration( );
currentRepository = repositoryRegistry.getRepositoryGroup( id );
RepositoryGroup oldRepository = currentRepository == null ? null : clone( currentRepository );
Configuration configuration = this.getConfigurationHandler().getBaseConfiguration( );
currentRepository = getRepositories().get( id );
RepositoryGroup oldRepository = currentRepository == null ? null : clone( currentRepository, id );
try
{
boolean updated = false;
if (currentRepository==null) {
currentRepository = put( repositoryGroupConfiguration, configuration );
} else
{
setRepositoryGroupDefaults( repositoryGroupConfiguration );
provider.updateRepositoryGroupInstance( (EditableRepositoryGroup) currentRepository, repositoryGroupConfiguration );
updated = true;
pushEvent( LifecycleEvent.UPDATED, currentRepository );
}
configurationHandler.save( configuration, ConfigurationHandler.REGISTRY_EVENT_TAG );
updateReferences( currentRepository, repositoryGroupConfiguration );
setLastState( currentRepository, RepositoryState.REFERENCES_SET );
activateRepository( currentRepository );
this.repositoryGroups.put( id, currentRepository );
setLastState( currentRepository, RepositoryState.REGISTERED );
registerNewRepository( repositoryGroupConfiguration, currentRepository, configuration, updated );
}
catch ( IndeterminateConfigurationException | RegistryException | RepositoryException e )
{
@ -368,23 +361,10 @@ public class RepositoryGroupHandler
if ( oldRepository != null )
{
RepositoryGroupConfiguration oldCfg = provider.getRepositoryGroupConfiguration( oldRepository );
provider.updateRepositoryGroupInstance( (EditableRepositoryGroup) currentRepository, oldCfg);
replaceOrAddRepositoryConfig( oldCfg, configuration );
try
{
configurationHandler.save( configuration, ConfigurationHandler.REGISTRY_EVENT_TAG );
}
catch ( IndeterminateConfigurationException | RegistryException indeterminateConfigurationException )
{
log.error( "Fatal error, config save during rollback failed: {}", e.getMessage( ), e );
}
updateReferences( oldRepository, oldCfg );
setLastState( oldRepository, RepositoryState.REFERENCES_SET );
activateRepository( oldRepository );
repositoryGroups.put( id, oldRepository );
setLastState( oldRepository, RepositoryState.REGISTERED );
provider.updateRepositoryGroupInstance( (EditableRepositoryGroup) currentRepository, oldCfg );
rollback( configuration, oldRepository, e, oldCfg );
} else {
repositoryGroups.remove( id );
getRepositories().remove( id );
}
log.error( "Could not save the configuration for repository group {}: {}", id, e.getMessage( ), e );
if (e instanceof RepositoryException) {
@ -409,12 +389,12 @@ public class RepositoryGroupHandler
final RepositoryType repoType = RepositoryType.valueOf( repositoryGroupConfiguration.getType( ) );
RepositoryGroup repo;
setRepositoryGroupDefaults( repositoryGroupConfiguration );
if ( repositoryGroups.containsKey( id ) )
if ( getRepositories().containsKey( id ) )
{
repo = clone( repositoryGroups.get( id ) );
repo = clone( getRepositories().get( id ), id );
if ( repo instanceof EditableRepositoryGroup )
{
repositoryRegistry.getProvider( repoType ).updateRepositoryGroupInstance( (EditableRepositoryGroup) repo, repositoryGroupConfiguration );
getProvider( repoType ).updateRepositoryGroupInstance( (EditableRepositoryGroup) repo, repositoryGroupConfiguration );
}
else
{
@ -423,7 +403,7 @@ public class RepositoryGroupHandler
}
else
{
repo = repositoryRegistry.getProvider( repoType ).createRepositoryGroup( repositoryGroupConfiguration );
repo = getProvider( repoType ).createRepositoryGroup( repositoryGroupConfiguration );
setLastState( repo, RepositoryState.CREATED );
}
replaceOrAddRepositoryConfig( repositoryGroupConfiguration, configuration );
@ -432,29 +412,6 @@ public class RepositoryGroupHandler
return repo;
}
@Override
public <D> CheckedResult<RepositoryGroup, D> putWithCheck( RepositoryGroupConfiguration repositoryConfiguration, RepositoryChecker<RepositoryGroup, D> checker ) throws RepositoryException
{
final String id = repositoryConfiguration.getId( );
RepositoryGroup currentGroup = repositoryGroups.get( id );
RepositoryGroup repositoryGroup = newInstance( repositoryConfiguration );
CheckedResult<RepositoryGroup, D> result;
if ( currentGroup == null )
{
result = checker.apply( repositoryGroup );
}
else
{
result = checker.applyForUpdate( repositoryGroup );
}
if ( result.isValid( ) )
{
put( result.getRepository() );
}
return result;
}
private void setRepositoryGroupDefaults( RepositoryGroupConfiguration repositoryGroupConfiguration )
{
if ( StringUtils.isEmpty( repositoryGroupConfiguration.getMergedIndexPath( ) ) )
@ -471,106 +428,23 @@ public class RepositoryGroupHandler
}
}
private void replaceOrAddRepositoryConfig( RepositoryGroupConfiguration repositoryGroupConfiguration, Configuration configuration )
{
RepositoryGroupConfiguration oldCfg = configuration.findRepositoryGroupById( repositoryGroupConfiguration.getId( ) );
if ( oldCfg != null )
{
configuration.removeRepositoryGroup( oldCfg );
}
configuration.addRepositoryGroup( repositoryGroupConfiguration );
}
public void removeRepositoryFromGroups( ManagedRepository repo )
{
if ( repo != null )
{
repositoryGroups.values( ).stream( ).filter( repoGroup -> repoGroup instanceof EditableRepository ).
map( repoGroup -> (EditableRepositoryGroup) repoGroup ).forEach( repoGroup -> repoGroup.removeRepository( repo ) );
}
}
/**
* Removes a repository group from the registry and configuration, if it exists.
* The change is saved to the configuration immediately.
*
* @param id the id of the repository group to remove
* @throws RepositoryException if a error occurs during configuration save
*/
@Override
public void remove( final String id ) throws RepositoryException
public void processOtherVariantRemoval( Repository repo )
{
RepositoryGroup repo = get( id );
if ( repo != null )
if ( repo instanceof ManagedRepository )
{
try
{
repo = repositoryGroups.remove( id );
if ( repo != null )
{
this.mergedRemoteIndexesScheduler.unschedule( repo );
repo.close( );
Configuration configuration = this.configurationHandler.getBaseConfiguration( );
RepositoryGroupConfiguration cfg = configuration.findRepositoryGroupById( id );
if ( cfg != null )
{
configuration.removeRepositoryGroup( cfg );
getRepositories().values( ).stream( ).filter( repoGroup -> repoGroup instanceof EditableRepository ).
map( repoGroup -> (EditableRepositoryGroup) repoGroup ).forEach( repoGroup -> repoGroup.removeRepository( (ManagedRepository) repo ) );
}
this.configurationHandler.save( configuration, ConfigurationHandler.REGISTRY_EVENT_TAG );
setLastState( repo, RepositoryState.UNREGISTERED );
}
}
catch ( RegistryException | IndeterminateConfigurationException e )
{
// Rollback
log.error( "Could not save config after repository removal: {}", e.getMessage( ), e );
repositoryGroups.put( repo.getId( ), repo );
throw new RepositoryException( "Could not save configuration after repository removal: " + e.getMessage( ) );
}
}
}
@Override
public void remove( String id, Configuration configuration ) throws RepositoryException
public RepositoryGroup clone( RepositoryGroup repo, String newId ) throws RepositoryException
{
RepositoryGroup repo = repositoryGroups.get( id );
if ( repo != null )
{
repo = repositoryGroups.remove( id );
if ( repo != null )
{
this.mergedRemoteIndexesScheduler.unschedule( repo );
repo.close( );
RepositoryGroupConfiguration cfg = configuration.findRepositoryGroupById( id );
if ( cfg != null )
{
configuration.removeRepositoryGroup( cfg );
}
setLastState( repo, RepositoryState.UNREGISTERED );
}
}
Iterator<RepositoryGroupConfiguration> cfgIter = configuration.getRepositoryGroups( ).iterator( );
while(cfgIter.hasNext()) {
RepositoryGroupConfiguration el = cfgIter.next( );
if (id.equals( el.getId() )) {
cfgIter.remove( );
break;
}
}
}
@Override
public RepositoryGroup get( String groupId )
{
return repositoryGroups.get( groupId );
}
@Override
public RepositoryGroup clone( RepositoryGroup repo ) throws RepositoryException
{
RepositoryProvider provider = repositoryRegistry.getProvider( repo.getType( ) );
RepositoryProvider provider = getProvider( repo.getType( ) );
RepositoryGroupConfiguration cfg = provider.getRepositoryGroupConfiguration( repo );
cfg.setId( newId );
RepositoryGroup cloned = provider.createRepositoryGroup( cfg );
cloned.registerEventHandler( RepositoryEvent.ANY, repositoryRegistry );
setLastState( cloned, RepositoryState.CREATED );
@ -578,46 +452,18 @@ public class RepositoryGroupHandler
}
@Override
public void updateReferences( RepositoryGroup repo, RepositoryGroupConfiguration repositoryConfiguration ) throws RepositoryException
public void updateReferences( RepositoryGroup repo, RepositoryGroupConfiguration repositoryConfiguration )
{
if ( repo instanceof EditableRepositoryGroup && repositoryConfiguration!=null)
{
EditableRepositoryGroup eGroup = (EditableRepositoryGroup) repo;
RepositoryHandler<ManagedRepository, ManagedRepositoryConfiguration> managedHandler = repositoryRegistry.getHandler( ManagedRepository.class, ManagedRepositoryConfiguration.class );
eGroup.setRepositories( repositoryConfiguration.getRepositories( ).stream( )
.map( repositoryRegistry::getManagedRepository ).collect( Collectors.toList( ) ) );
.map( managedHandler::get ).collect( Collectors.toList( ) ) );
}
}
@Override
public Collection<RepositoryGroup> getAll( )
{
return Collections.unmodifiableCollection( repositoryGroups.values( ) );
}
@Override
public RepositoryValidator<RepositoryGroup> getValidator( )
{
return this.validator;
}
@Override
public CheckedResult<RepositoryGroup, Map<String, List<ValidationError>>> validateRepository( RepositoryGroup repository )
{
return this.validator.apply( repository );
}
@Override
public CheckedResult<RepositoryGroup,Map<String, List<ValidationError>>> validateRepositoryForUpdate( RepositoryGroup repository )
{
return this.validator.applyForUpdate( repository );
}
@Override
public boolean hasRepository( String id )
{
return repositoryGroups.containsKey( id );
}
@PreDestroy
private void destroy( )
@ -626,21 +472,20 @@ public class RepositoryGroupHandler
}
@Override
public void close( )
protected RepositoryGroupConfiguration findRepositoryConfiguration( Configuration configuration, String id )
{
for ( RepositoryGroup group : repositoryGroups.values( ) )
{
try
{
mergedRemoteIndexesScheduler.unschedule( group );
group.close( );
}
catch ( Throwable e )
{
log.error( "Could not close repository group {}: {}", group.getId( ), e.getMessage( ) );
}
}
this.repositoryGroups.clear( );
return configuration.findRepositoryGroupById( id );
}
@Override
protected void removeRepositoryConfiguration( Configuration configuration, RepositoryGroupConfiguration cfg )
{
configuration.removeRepositoryGroup( cfg );
}
@Override
protected void addRepositoryConfiguration( Configuration configuration, RepositoryGroupConfiguration repoConfiguration )
{
configuration.addRepositoryGroup( repoConfiguration );
}
}

529
archiva-modules/archiva-base/archiva-repository-layer/src/main/java/org/apache/archiva/repository/base/managed/ManagedRepositoryHandler.java
View File

@ -17,75 +17,103 @@ package org.apache.archiva.repository.base.managed;
* under the License.
*/
import org.apache.archiva.components.registry.RegistryException;
import org.apache.archiva.configuration.Configuration;
import org.apache.archiva.configuration.IndeterminateConfigurationException;
import org.apache.archiva.configuration.ManagedRepositoryConfiguration;
import org.apache.archiva.indexer.ArchivaIndexManager;
import org.apache.archiva.indexer.IndexCreationFailedException;
import org.apache.archiva.indexer.IndexManagerFactory;
import org.apache.archiva.repository.EditableManagedRepository;
import org.apache.archiva.repository.EditableRepository;
import org.apache.archiva.repository.ManagedRepository;
import org.apache.archiva.repository.Repository;
import org.apache.archiva.repository.RepositoryContentFactory;
import org.apache.archiva.repository.RepositoryException;
import org.apache.archiva.repository.RepositoryHandler;
import org.apache.archiva.repository.RepositoryHandlerManager;
import org.apache.archiva.repository.RepositoryProvider;
import org.apache.archiva.repository.RepositoryRegistry;
import org.apache.archiva.repository.RepositoryState;
import org.apache.archiva.repository.RepositoryType;
import org.apache.archiva.repository.base.AbstractRepositoryHandler;
import org.apache.archiva.repository.base.ArchivaRepositoryRegistry;
import org.apache.archiva.repository.base.ConfigurationHandler;
import org.apache.archiva.repository.event.LifecycleEvent;
import org.apache.archiva.repository.event.RepositoryEvent;
import org.apache.archiva.repository.features.IndexCreationFeature;
import org.apache.archiva.repository.features.StagingRepositoryFeature;
import org.apache.archiva.repository.validation.CheckedResult;
import org.apache.archiva.repository.validation.RepositoryChecker;
import org.apache.archiva.repository.validation.RepositoryValidator;
import org.apache.archiva.repository.validation.ValidationResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import java.util.Collection;
import javax.annotation.PostConstruct;
import javax.inject.Named;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* Handler implementation for managed repositories.
*
* @author Martin Stockhammer <martin_s@apache.org>
*/
@Service( "managedRepositoryHandler#default" )
public class ManagedRepositoryHandler
extends AbstractRepositoryHandler<ManagedRepository, ManagedRepositoryConfiguration>
implements RepositoryHandler<ManagedRepository, ManagedRepositoryConfiguration>
implements RepositoryHandler<ManagedRepository, ManagedRepositoryConfiguration>
{
private static final Logger log = LoggerFactory.getLogger( ManagedRepositoryHandler.class );
private final ConfigurationHandler configurationHandler;
private final ArchivaRepositoryRegistry repositoryRegistry;
private final RepositoryValidator<ManagedRepository> validator;
private Map<String, ManagedRepository> managedRepositories = new HashMap<>( );
private Map<String, ManagedRepository> uManagedRepositories = Collections.unmodifiableMap( managedRepositories );
private final RepositoryHandlerManager repositoryRegistry;
private final RepositoryContentFactory repositoryContentFactory;
public ManagedRepositoryHandler( ArchivaRepositoryRegistry repositoryRegistry,
ConfigurationHandler configurationHandler,
List<RepositoryValidator<? extends Repository>> repositoryValidatorList )
IndexManagerFactory indexManagerFactory;
public ManagedRepositoryHandler( RepositoryHandlerManager repositoryRegistry,
ConfigurationHandler configurationHandler, IndexManagerFactory indexManagerFactory,
@Named( "repositoryContentFactory#default" )
RepositoryContentFactory repositoryContentFactory
)
{
this.configurationHandler = configurationHandler;
super( ManagedRepository.class, ManagedRepositoryConfiguration.class, configurationHandler );
this.repositoryRegistry = repositoryRegistry;
this.validator = getCombinedValidatdor( ManagedRepository.class, repositoryValidatorList );
this.indexManagerFactory = indexManagerFactory;
this.repositoryContentFactory = repositoryContentFactory;
}
@Override
@PostConstruct
public void init( )
{
log.debug( "Initializing managed repository handler " + repositoryRegistry.toString( ) );
initializeStorage( );
// We are registering this class on the registry. This is necessary to avoid circular dependencies via injection.
this.repositoryRegistry.registerHandler( this );
}
private void initializeStorage( )
{
}
@Override
public void initializeFromConfig( )
{
this.managedRepositories.clear( );
this.managedRepositories.putAll( newInstancesFromConfig( ) );
for ( ManagedRepository managedRepository : this.managedRepositories.values( ) )
Map<String, ManagedRepository> currentInstances = new HashMap<>( getRepositories( ) );
getRepositories().clear();
getRepositories( ).putAll( newOrUpdateInstancesFromConfig( currentInstances ) );
for ( ManagedRepository managedRepository : getRepositories( ).values( ) )
{
activateRepository( managedRepository );
}
for (ManagedRepository managedRepository : currentInstances.values()) {
deactivateRepository( managedRepository );
}
@Override
public void activateRepository( ManagedRepository repository )
{
}
@Override
@ -93,148 +121,437 @@ implements RepositoryHandler<ManagedRepository, ManagedRepositoryConfiguration>
{
try
{
Set<String> configRepoIds = new HashSet<>( );
List<ManagedRepositoryConfiguration> managedRepoConfigs =
configurationHandler.getBaseConfiguration( ).getManagedRepositories( );
new ArrayList<>(
getConfigurationHandler( ).getBaseConfiguration( ).getManagedRepositories( ) );
if ( managedRepoConfigs == null )
{
return managedRepositories;
return Collections.emptyMap( );
}
Map<String, ManagedRepository> result = new HashMap<>( );
for ( ManagedRepositoryConfiguration repoConfig : managedRepoConfigs )
{
ManagedRepository repo = put( repoConfig, null );
configRepoIds.add( repoConfig.getId( ) );
ManagedRepository repo = newInstance( repoConfig );
result.put( repo.getId( ), repo );
if ( repo.supportsFeature( StagingRepositoryFeature.class ) )
{
StagingRepositoryFeature stagF = repo.getFeature( StagingRepositoryFeature.class ).get( );
if ( stagF.getStagingRepository( ) != null )
{
configRepoIds.add( stagF.getStagingRepository( ).getId( ) );
}
}
}
List<String> toRemove = managedRepositories.keySet( ).stream( ).filter( id -> !configRepoIds.contains( id ) ).collect( Collectors.toList( ) );
for ( String id : toRemove )
ManagedRepository stagingRepo = getStagingRepository( repo );
if ( stagingRepo != null )
{
ManagedRepository removed = managedRepositories.remove( id );
removed.close( );
result.put( stagingRepo.getId( ), stagingRepo );
}
}
}
}
return result;
}
catch ( Throwable e )
{
log.error( "Could not initialize repositories from config: {}", e.getMessage( ), e );
return managedRepositories;
return new HashMap<>( );
}
return managedRepositories;
}
public Map<String, ManagedRepository> newOrUpdateInstancesFromConfig( Map<String, ManagedRepository> currentInstances)
{
try
{
List<ManagedRepositoryConfiguration> managedRepoConfigs =
new ArrayList<>(
getConfigurationHandler( ).getBaseConfiguration( ).getManagedRepositories( ) );
if ( managedRepoConfigs == null )
{
return Collections.emptyMap( );
}
Map<String, ManagedRepository> result = new HashMap<>( );
for ( ManagedRepositoryConfiguration repoConfig : managedRepoConfigs )
{
String id = repoConfig.getId( );
ManagedRepository repo;
if ( currentInstances.containsKey( id ) )
{
repo = currentInstances.remove( id );
getProvider( repo.getType() ).updateManagedInstance( (EditableManagedRepository) repo, repoConfig );
updateReferences( repo, repoConfig );
}
else
{
repo = newInstance( repoConfig );
}
result.put( id, repo );
if ( repo.supportsFeature( StagingRepositoryFeature.class ) )
{
StagingRepositoryFeature stagF = repo.getFeature( StagingRepositoryFeature.class ).get( );
if ( stagF.getStagingRepository( ) != null )
{
String stagingId = getStagingId( id );
ManagedRepository stagingRepo;
if ( currentInstances.containsKey( stagingId ) )
{
stagingRepo = currentInstances.remove( stagingId );
managedRepoConfigs.stream( ).filter( cfg -> stagingId.equals( cfg.getId( ) ) ).findFirst( ).ifPresent(
stagingRepoConfig ->
{
try
{
getProvider( stagingRepo.getType() ).updateManagedInstance( (EditableManagedRepository) stagingRepo, stagingRepoConfig );
updateReferences( stagingRepo, stagingRepoConfig );
}
catch ( RepositoryException e )
{
log.error( "Could not update staging repo {}: {}", stagingId, e.getMessage( ) );
}
}
);
}
else
{
stagingRepo = getStagingRepository( repo );
}
if ( stagingRepo != null )
{
result.put( stagingRepo.getId( ), stagingRepo );
}
}
}
}
return result;
}
catch ( Throwable e )
{
log.error( "Could not initialize repositories from config: {}", e.getMessage( ), e );
return new HashMap<>( );
}
}
@Override
public ManagedRepository newInstance( RepositoryType type, String id ) throws RepositoryException
{
return null;
log.debug( "Creating repo {}", id );
RepositoryProvider provider = getProvider( type );
EditableManagedRepository repo;
try
{
repo = provider.createManagedInstance( id, id );
}
catch ( IOException e )
{
throw new RepositoryException( "Could not create repository '" + id + "': " + e.getMessage( ) );
}
repo.registerEventHandler( RepositoryEvent.ANY, repositoryRegistry );
updateReferences( repo, null );
repo.setLastState( RepositoryState.REFERENCES_SET );
return repo;
}
private String getStagingId( String repoId )
{
return repoId + StagingRepositoryFeature.STAGING_REPO_POSTFIX;
}
private ManagedRepository getStagingRepository( ManagedRepository baseRepo ) throws RepositoryException
{
ManagedRepository stageRepo = get( getStagingId( baseRepo.getId( ) ) );
final RepositoryType type = baseRepo.getType( );
if ( stageRepo == null )
{
RepositoryProvider provider = getProvider( type );
ManagedRepositoryConfiguration cfg = provider.getManagedConfiguration( baseRepo );
stageRepo = provider.createStagingInstance( cfg );
if ( stageRepo.supportsFeature( StagingRepositoryFeature.class ) )
{
stageRepo.getFeature( StagingRepositoryFeature.class ).get( ).setStageRepoNeeded( false );
}
updateReferences( stageRepo, cfg );
}
return stageRepo;
}
public ArchivaIndexManager getIndexManager( RepositoryType type )
{
return indexManagerFactory.getIndexManager( type );
}
private void createIndexingContext( EditableRepository editableRepo ) throws RepositoryException
{
if ( editableRepo.supportsFeature( IndexCreationFeature.class ) )
{
ArchivaIndexManager idxManager = getIndexManager( editableRepo.getType( ) );
try
{
editableRepo.setIndexingContext( idxManager.createContext( editableRepo ) );
idxManager.updateLocalIndexPath( editableRepo );
}
catch ( IndexCreationFailedException e )
{
throw new RepositoryException( "Could not create index for repository " + editableRepo.getId( ) + ": " + e.getMessage( ), e );
}
}
}
@Override
public ManagedRepository newInstance( ManagedRepositoryConfiguration repositoryConfiguration ) throws RepositoryException
{
return null;
RepositoryType type = RepositoryType.valueOf( repositoryConfiguration.getType( ) );
RepositoryProvider provider = getProvider( type );
if ( provider == null )
{
throw new RepositoryException( "Provider not found for repository type: " + repositoryConfiguration.getType( ) );
}
final ManagedRepository repo = provider.createManagedInstance( repositoryConfiguration );
repo.registerEventHandler( RepositoryEvent.ANY, repositoryRegistry );
updateReferences( repo, null );
if ( repo instanceof EditableRepository )
{
( (EditableRepository) repo ).setLastState( RepositoryState.REFERENCES_SET );
}
return repo;
}
@Override
public ManagedRepository put( ManagedRepository repository ) throws RepositoryException
protected ManagedRepositoryConfiguration findRepositoryConfiguration( final Configuration configuration, final String id )
{
return null;
return configuration.findManagedRepositoryById( id );
}
@Override
public ManagedRepository put( ManagedRepositoryConfiguration repositoryConfiguration ) throws RepositoryException
protected void removeRepositoryConfiguration( final Configuration configuration, final ManagedRepositoryConfiguration repoConfiguration )
{
return null;
configuration.removeManagedRepository( repoConfiguration );
}
@Override
protected void addRepositoryConfiguration( Configuration configuration, ManagedRepositoryConfiguration repoConfiguration )
{
configuration.addManagedRepository( repoConfiguration );
}
@Override
public ManagedRepository put( ManagedRepository managedRepository ) throws RepositoryException
{
final String id = managedRepository.getId( );
ManagedRepository originRepo = getRepositories( ).remove( id );
if ( originRepo == null && repositoryRegistry.isRegisteredId( id ) )
{
throw new RepositoryException( "There exists a repository with id " + id + ". Could not update with managed repository." );
}
try
{
if ( originRepo != null && managedRepository != originRepo )
{
deactivateRepository( originRepo );
pushEvent( LifecycleEvent.UNREGISTERED, originRepo );
}
RepositoryProvider provider = getProvider( managedRepository.getType( ) );
ManagedRepositoryConfiguration newCfg = provider.getManagedConfiguration( managedRepository );
getConfigurationHandler( ).getLock( ).writeLock( ).lock( );
try
{
Configuration configuration = getConfigurationHandler( ).getBaseConfiguration( );
updateReferences( managedRepository, newCfg );
ManagedRepositoryConfiguration oldCfg = configuration.findManagedRepositoryById( id );
if ( oldCfg != null )
{
configuration.removeManagedRepository( oldCfg );
}
configuration.addManagedRepository( newCfg );
getConfigurationHandler( ).save( configuration, ConfigurationHandler.REGISTRY_EVENT_TAG );
setLastState( managedRepository, RepositoryState.SAVED );
activateRepository( managedRepository );
}
finally
{
getConfigurationHandler( ).getLock( ).writeLock( ).unlock( );
}
getRepositories( ).put( id, managedRepository );
setLastState( managedRepository, RepositoryState.REGISTERED );
return managedRepository;
}
catch ( Exception e )
{
// Rollback only partly, because repository is closed already
if ( originRepo != null )
{
getRepositories( ).put( id, originRepo );
}
else
{
getRepositories( ).remove( id );
}
log.error( "Exception during configuration update {}", e.getMessage( ), e );
throw new RepositoryException( "Could not save the configuration" + ( e.getMessage( ) == null ? "" : ": " + e.getMessage( ) ) );
}
}
@Override
public ManagedRepository put( ManagedRepositoryConfiguration managedRepositoryConfiguration ) throws RepositoryException
{
final String id = managedRepositoryConfiguration.getId( );
final RepositoryType repositoryType = RepositoryType.valueOf( managedRepositoryConfiguration.getType( ) );
final RepositoryProvider provider = getProvider( repositoryType );
ReentrantReadWriteLock.WriteLock configLock = this.getConfigurationHandler( ).getLock( ).writeLock( );
configLock.lock( );
ManagedRepository repo = null;
ManagedRepository oldRepository = null;
Configuration configuration = null;
try
{
boolean updated = false;
configuration = getConfigurationHandler( ).getBaseConfiguration( );
repo = getRepositories( ).get( id );
oldRepository = repo == null ? null : clone( repo, id );
if ( repo == null )
{
repo = put( managedRepositoryConfiguration, configuration );
}
else
{
setManagedRepositoryDefaults( managedRepositoryConfiguration );
provider.updateManagedInstance( (EditableManagedRepository) repo, managedRepositoryConfiguration );
updated = true;
pushEvent( LifecycleEvent.UPDATED, repo );
}
registerNewRepository( managedRepositoryConfiguration, repo, configuration, updated );
}
catch ( IndeterminateConfigurationException | RegistryException e )
{
if ( oldRepository != null )
{
ManagedRepositoryConfiguration oldCfg = provider.getManagedConfiguration( oldRepository );
provider.updateManagedInstance( (EditableManagedRepository) repo, oldCfg );
rollback( configuration, oldRepository, e, oldCfg );
}
else
{
getRepositories( ).remove( id );
}
log.error( "Could not save the configuration for repository {}: {}", id, e.getMessage( ), e );
throw new RepositoryException( "Could not save the configuration for repository " + id + ": " + e.getMessage( ) );
}
finally
{
configLock.unlock( );
}
return repo;
}
@Override
public ManagedRepository put( ManagedRepositoryConfiguration repositoryConfiguration, Configuration configuration ) throws RepositoryException
{
return null;
final String id = repositoryConfiguration.getId( );
final RepositoryType repoType = RepositoryType.valueOf( repositoryConfiguration.getType( ) );
ManagedRepository repo;
setManagedRepositoryDefaults( repositoryConfiguration );
if ( getRepositories( ).containsKey( id ) )
{
repo = clone( getRepositories( ).get( id ), id );
if ( repo instanceof EditableManagedRepository )
{
getProvider( repoType ).updateManagedInstance( (EditableManagedRepository) repo, repositoryConfiguration );
}
else
{
throw new RepositoryException( "The repository is not editable " + id );
}
}
else
{
repo = getProvider( repoType ).createManagedInstance( repositoryConfiguration );
setLastState( repo, RepositoryState.CREATED );
}
if ( configuration != null )
{
replaceOrAddRepositoryConfig( repositoryConfiguration, configuration );
}
updateReferences( repo, repositoryConfiguration );
setLastState( repo, RepositoryState.REFERENCES_SET );
return repo;
}
@SuppressWarnings( "unused" )
private void setManagedRepositoryDefaults( ManagedRepositoryConfiguration repositoryConfiguration )
{
// We do nothing here
}
@Override
public <D> CheckedResult<ManagedRepository, D> putWithCheck( ManagedRepositoryConfiguration repositoryConfiguration, RepositoryChecker<ManagedRepository, D> checker ) throws RepositoryException
public ManagedRepository clone( ManagedRepository repo, String id ) throws RepositoryException
{
return null;
RepositoryProvider provider = getProvider( repo.getType( ) );
ManagedRepositoryConfiguration cfg = provider.getManagedConfiguration( repo );
cfg.setId( id );
ManagedRepository cloned = provider.createManagedInstance( cfg );
cloned.registerEventHandler( RepositoryEvent.ANY, repositoryRegistry );
setLastState( cloned, RepositoryState.CREATED );
return cloned;
}
@Override
public void remove( String id ) throws RepositoryException
{
}
@Override
public void remove( String id, Configuration configuration ) throws RepositoryException
{
}
@Override
public ManagedRepository get( String id )
{
return null;
}
@Override
public ManagedRepository clone( ManagedRepository repo ) throws RepositoryException
{
return null;
}
@Override
public void updateReferences( ManagedRepository repo, ManagedRepositoryConfiguration repositoryConfiguration ) throws RepositoryException
{
}
@Override
public Collection<ManagedRepository> getAll( )
log.debug( "Updating references of repo {}", repo.getId( ) );
if ( repo.supportsFeature( StagingRepositoryFeature.class ) )
{
return null;
}
@Override
public RepositoryValidator<ManagedRepository> getValidator( )
Configuration configuration = getConfigurationHandler( ).getBaseConfiguration( );
RepositoryProvider provider = getProvider( repo.getType( ) );
StagingRepositoryFeature feature = repo.getFeature( StagingRepositoryFeature.class ).get( );
if ( feature.isStageRepoNeeded( ) && feature.getStagingRepository( ) == null )
{
return null;
}
@Override
public ValidationResponse<ManagedRepository> validateRepository( ManagedRepository repository )
ManagedRepository stageRepo = get( getStagingId( repo.getId( ) ) );
if ( stageRepo == null )
{
return null;
}
@Override
public ValidationResponse<ManagedRepository> validateRepositoryForUpdate( ManagedRepository repository )
stageRepo = getStagingRepository( repo );
getRepositories( ).put( stageRepo.getId( ), stageRepo );
if ( configuration != null )
{
return null;
replaceOrAddRepositoryConfig( provider.getManagedConfiguration( stageRepo ), configuration );
}
@Override
public boolean hasRepository( String id )
{
return false;
pushEvent( new LifecycleEvent( LifecycleEvent.REGISTERED, this, stageRepo ) );
}
@Override
public void init( )
feature.setStagingRepository( stageRepo );
}
}
if ( repo instanceof EditableManagedRepository )
{
EditableManagedRepository editableRepo = (EditableManagedRepository) repo;
if ( repo.getContent( ) == null )
{
editableRepo.setContent( repositoryContentFactory.getManagedRepositoryContent( repo ) );
editableRepo.getContent( ).setRepository( editableRepo );
}
log.debug( "Index repo: " + repo.hasIndex( ) );
if ( repo.hasIndex( ) && ( repo.getIndexingContext( ) == null || !repo.getIndexingContext( ).isOpen( ) ) )
{
log.debug( "Creating indexing context for {}", repo.getId( ) );
createIndexingContext( editableRepo );
}
}
repo.registerEventHandler( RepositoryEvent.ANY, repositoryRegistry );
}
@Override
public void close( )
{
getRepositories( ).values( ).stream( ).forEach(
r -> deactivateRepository( r )
);
}
@Override
public void deactivateRepository( ManagedRepository repository )
{
repository.close( );
}
}

22
archiva-modules/archiva-base/archiva-repository-layer/src/test/java/org/apache/archiva/repository/base/ArchivaRepositoryRegistryTest.java
View File

@ -32,6 +32,7 @@ import org.apache.archiva.repository.RepositoryRegistry;
import org.apache.archiva.repository.RepositoryType;
import org.apache.archiva.repository.base.group.RepositoryGroupHandler;
import org.apache.archiva.repository.base.managed.BasicManagedRepository;
import org.apache.archiva.repository.base.managed.ManagedRepositoryHandler;
import org.apache.archiva.repository.base.remote.BasicRemoteRepository;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.AfterEach;
@ -51,6 +52,7 @@ import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.Collection;
import java.util.List;
import static org.junit.jupiter.api.Assertions.*;
@ -73,6 +75,9 @@ public class ArchivaRepositoryRegistryTest
@Inject
RepositoryGroupHandler repositoryGroupHandler;
@Inject
ManagedRepositoryHandler managedRepositoryHandler;
private static final Path userCfg = Paths.get(System.getProperty( "user.home" ), ".m2/archiva.xml");
private static Path cfgCopy;
@ -269,30 +274,31 @@ public class ArchivaRepositoryRegistryTest
public void putManagedRepositoryFromConfigWithoutSave( ) throws Exception
{
Configuration configuration = archivaConfiguration.getConfiguration();
int actualSize = configuration.getManagedRepositories( ).size( );
Configuration newConfiguration = new Configuration( );
ManagedRepositoryConfiguration cfg = new ManagedRepositoryConfiguration();
cfg.setId("test002");
cfg.setName("This is test 002");
ManagedRepository repo = repositoryRegistry.putRepository( cfg, configuration );
ManagedRepository repo = repositoryRegistry.putRepository( cfg, newConfiguration );
assertNotNull(repo);
assertEquals("test002", repo.getId());
assertEquals("This is test 002", repo.getName());
assertNotNull(repo.getContent());
archivaConfiguration.reload();
assertEquals(3, archivaConfiguration.getConfiguration().getManagedRepositories().size());
Collection<ManagedRepository> repos = repositoryRegistry.getManagedRepositories();
assertEquals(5, repos.size());
assertEquals(actualSize, configuration.getManagedRepositories().size());
List<ManagedRepositoryConfiguration> repos = newConfiguration.getManagedRepositories( );
assertEquals(1, repos.size());
ManagedRepository internalRepo = repositoryRegistry.getManagedRepository( "internal" );
cfg = new ManagedRepositoryConfiguration();
cfg.setId("internal");
cfg.setName("This is internal test 002");
repo = repositoryRegistry.putRepository( cfg, configuration );
assertSame( internalRepo, repo );
repo = repositoryRegistry.putRepository( cfg, newConfiguration );
assertEquals("This is internal test 002",repo.getName());
assertEquals(5, repositoryRegistry.getManagedRepositories().size());
assertEquals(2, newConfiguration.getManagedRepositories().size());
repositoryRegistry.reload();
assertEquals(4, repositoryRegistry.getManagedRepositories().size());
assertEquals(actualSize, configuration.getManagedRepositories().size());
}
@Test

8
archiva-modules/archiva-base/archiva-repository-layer/src/test/java/org/apache/archiva/repository/base/group/BasicRepositoryGroupValidatorTest.java
View File

@ -18,8 +18,6 @@ package org.apache.archiva.repository.base.group;
* under the License.
*/
import org.apache.archiva.common.filelock.DefaultFileLockManager;
import org.apache.archiva.common.filelock.FileLockManager;
import org.apache.archiva.repository.EditableManagedRepository;
import org.apache.archiva.repository.EditableRepositoryGroup;
import org.apache.archiva.repository.ManagedRepository;
@ -28,9 +26,8 @@ import org.apache.archiva.repository.RepositoryGroup;
import org.apache.archiva.repository.RepositoryRegistry;
import org.apache.archiva.repository.base.ConfigurationHandler;
import org.apache.archiva.repository.base.managed.BasicManagedRepository;
import org.apache.archiva.repository.base.managed.BasicManagedRepositoryValidator;
import org.apache.archiva.repository.base.managed.ManagedRepositoryHandler;
import org.apache.archiva.repository.mock.ManagedRepositoryContentMock;
import org.apache.archiva.repository.storage.fs.FilesystemStorage;
import org.apache.archiva.repository.validation.ValidationResponse;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;
@ -64,6 +61,9 @@ class BasicRepositoryGroupValidatorTest
@Inject
RepositoryGroupHandler repositoryGroupHandler;
@Inject
ManagedRepositoryHandler managedRepositoryHandler;
Path repoBaseDir;
@AfterEach

40
archiva-modules/archiva-base/archiva-repository-layer/src/test/java/org/apache/archiva/repository/base/group/RepositoryGroupHandlerTest.java
View File

@ -21,29 +21,29 @@ package org.apache.archiva.repository.base.group;
import org.apache.archiva.common.filelock.DefaultFileLockManager;
import org.apache.archiva.common.filelock.FileLockManager;
import org.apache.archiva.common.utils.FileUtils;
import org.apache.archiva.common.utils.PathUtil;
import org.apache.archiva.components.registry.RegistryException;
import org.apache.archiva.configuration.ArchivaConfiguration;
import org.apache.archiva.configuration.Configuration;
import org.apache.archiva.configuration.IndeterminateConfigurationException;
import org.apache.archiva.configuration.ManagedRepositoryConfiguration;
import org.apache.archiva.configuration.RepositoryGroupConfiguration;
import org.apache.archiva.indexer.merger.MergedRemoteIndexesScheduler;
import org.apache.archiva.repository.EditableRepositoryGroup;
import org.apache.archiva.repository.Repository;
import org.apache.archiva.repository.ManagedRepository;
import org.apache.archiva.repository.RepositoryException;
import org.apache.archiva.repository.RepositoryGroup;
import org.apache.archiva.repository.RepositoryHandler;
import org.apache.archiva.repository.RepositoryState;
import org.apache.archiva.repository.RepositoryType;
import org.apache.archiva.repository.base.ArchivaRepositoryRegistry;
import org.apache.archiva.repository.base.ConfigurationHandler;
import org.apache.archiva.repository.base.managed.BasicManagedRepository;
import org.apache.archiva.repository.storage.fs.FilesystemStorage;
import org.apache.archiva.repository.validation.CheckedResult;
import org.apache.archiva.repository.validation.RepositoryValidator;
import org.apache.archiva.repository.validation.ValidationError;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
@ -87,8 +87,8 @@ class RepositoryGroupHandlerTest
// @Named( "mergedRemoteIndexesScheduler#default" )
MergedRemoteIndexesScheduler mergedRemoteIndexesScheduler;
@Inject
List<RepositoryValidator<? extends Repository>> repositoryValidatorList;
@Mock
RepositoryHandler<ManagedRepository, ManagedRepositoryConfiguration> managedRepositoryHandler;
@Inject
ArchivaConfiguration archivaConfiguration;
@ -142,7 +142,19 @@ class RepositoryGroupHandlerTest
private RepositoryGroupHandler createHandler( )
{
RepositoryGroupHandler groupHandler = new RepositoryGroupHandler( repositoryRegistry, configurationHandler, mergedRemoteIndexesScheduler, repositoryValidatorList );
Mockito.when( managedRepositoryHandler.getVariant( ) ).thenReturn( ManagedRepository.class );
final ManagedRepository internalRepo;
try
{
internalRepo = getManaged( "internal", "internal");
}
catch ( IOException e )
{
throw new Error( e );
}
Mockito.when( managedRepositoryHandler.get( ArgumentMatchers.eq("internal") ) ).thenReturn( internalRepo );
repositoryRegistry.registerHandler( managedRepositoryHandler );
RepositoryGroupHandler groupHandler = new RepositoryGroupHandler( repositoryRegistry, configurationHandler, mergedRemoteIndexesScheduler);
groupHandler.init( );
return groupHandler;
}
@ -156,6 +168,13 @@ class RepositoryGroupHandlerTest
return repoBaseDir;
}
protected ManagedRepository getManaged(String id, String name) throws IOException
{
Path path = getRepoBaseDir().resolve( "../managed" );
FileLockManager lockManager = new DefaultFileLockManager();
FilesystemStorage storage = new FilesystemStorage(path.toAbsolutePath(), lockManager);
return new BasicManagedRepository( id, name, storage );
}
protected EditableRepositoryGroup createRepository( String id, String name, Path location ) throws IOException
@ -200,9 +219,8 @@ class RepositoryGroupHandlerTest
@Test
void newInstancesFromConfig( )
{
RepositoryGroupHandler groupHandler = new RepositoryGroupHandler( repositoryRegistry, configurationHandler, mergedRemoteIndexesScheduler, repositoryValidatorList );
RepositoryGroupHandler groupHandler = createHandler( );
Map<String, RepositoryGroup> instances = groupHandler.newInstancesFromConfig( );
assertFalse( groupHandler.hasRepository( "test-group-01" ) );
assertTrue( instances.containsKey( "test-group-01" ) );
assertEquals( RepositoryState.REFERENCES_SET, instances.get( "test-group-01" ).getLastState( ) );
}

427
archiva-modules/archiva-base/archiva-repository-layer/src/test/java/org/apache/archiva/repository/base/managed/ManagedRepositoryHandlerTest.java Normal file
View File

@ -0,0 +1,427 @@
package org.apache.archiva.repository.base.managed;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
import org.apache.archiva.common.filelock.DefaultFileLockManager;
import org.apache.archiva.common.filelock.FileLockManager;
import org.apache.archiva.common.utils.FileUtils;
import org.apache.archiva.configuration.ArchivaConfiguration;
import org.apache.archiva.configuration.Configuration;
import org.apache.archiva.configuration.ManagedRepositoryConfiguration;
import org.apache.archiva.indexer.IndexManagerFactory;
import org.apache.archiva.indexer.merger.MergedRemoteIndexesScheduler;
import org.apache.archiva.repository.EditableManagedRepository;
import org.apache.archiva.repository.ManagedRepository;
import org.apache.archiva.repository.Repository;
import org.apache.archiva.repository.RepositoryContentFactory;
import org.apache.archiva.repository.RepositoryException;
import org.apache.archiva.repository.RepositoryState;
import org.apache.archiva.repository.RepositoryType;
import org.apache.archiva.repository.base.ArchivaRepositoryRegistry;
import org.apache.archiva.repository.base.ConfigurationHandler;
import org.apache.archiva.repository.storage.fs.FilesystemStorage;
import org.apache.archiva.repository.validation.CheckedResult;
import org.apache.archiva.repository.validation.RepositoryValidator;
import org.apache.archiva.repository.validation.ValidationError;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import javax.inject.Inject;
import javax.inject.Named;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import static org.apache.archiva.repository.validation.ErrorKeys.ISEMPTY;
import static org.junit.jupiter.api.Assertions.*;
/**
* @author Martin Stockhammer <martin_s@apache.org>
*/
@ExtendWith( {MockitoExtension.class, SpringExtension.class} )
@ContextConfiguration( locations = {"classpath*:/META-INF/spring-context.xml", "classpath:/spring-context-managed.xml"} )
class ManagedRepositoryHandlerTest
{
static {
initialize();
}
@Inject
@Named( "repositoryRegistry" )
ArchivaRepositoryRegistry repositoryRegistry;
@Inject
@Named( "repositoryContentFactory#default" )
RepositoryContentFactory repositoryContentFactory;
@Inject
IndexManagerFactory indexManagerFactory;
@Inject
ConfigurationHandler configurationHandler;
@Inject
List<RepositoryValidator<? extends Repository>> repositoryValidatorList;
@Inject
ArchivaConfiguration archivaConfiguration;
Path repoBaseDir;
private static void initialize() {
Path baseDir = Paths.get( FileUtils.getBasedir( ) );
Path config = baseDir.resolve( "src/test/resources/archiva-managed.xml" );
if ( Files.exists( config ) )
{
Path destConfig = baseDir.resolve( "target/test-classes/archiva-managed.xml" );
try
{
Files.copy( config, destConfig );
}
catch ( IOException e )
{
System.err.println( "Could not copy file: " + e.getMessage( ) );
}
}
}
// Helper method that removes a repo from the configuration
private void removeRepositoryFromConfig( String id) {
Configuration configuration = configurationHandler.getBaseConfiguration( );
Iterator<ManagedRepositoryConfiguration> iter = configuration.getManagedRepositories().iterator();
while(iter.hasNext()) {
ManagedRepositoryConfiguration repo = iter.next( );
if (id.equals(repo.getId())) {
iter.remove();
break;
}
}
try
{
configurationHandler.save( configuration );
}
catch ( Throwable e )
{
System.err.println( "Could not remove repo from config "+id );
}
}
private boolean hasRepositoryInConfig( String id) {
assertNotNull( configurationHandler.getBaseConfiguration( ).getManagedRepositories() );
return configurationHandler.getBaseConfiguration( ).getManagedRepositories( ).stream( ).anyMatch( g -> g != null && id.equals( g.getId( ) ) ) ;
}
private ManagedRepositoryHandler createHandler( )
{
ManagedRepositoryHandler repositoryHandler = new ManagedRepositoryHandler( repositoryRegistry, configurationHandler, indexManagerFactory, repositoryContentFactory );
repositoryHandler.init( );
return repositoryHandler;
}
private Path getRepoBaseDir() throws IOException
{
if (repoBaseDir==null) {
this.repoBaseDir = archivaConfiguration.getRepositoryBaseDir( ).resolve( "managed" );
Files.createDirectories( this.repoBaseDir );
}
return repoBaseDir;
}
protected EditableManagedRepository createRepository( String id, String name, Path location ) throws IOException
{
FileLockManager lockManager = new DefaultFileLockManager();
FilesystemStorage storage = new FilesystemStorage(location.toAbsolutePath(), lockManager);
BasicManagedRepository repo = new BasicManagedRepository(id, name, storage);
repo.setLocation( location.toAbsolutePath().toUri());
return repo;
}
protected EditableManagedRepository createRepository( String id, String name) throws IOException
{
Path dir = getRepoBaseDir( ).resolve( id );
Files.createDirectories( dir );
return createRepository( id, name, dir );
}
@Test
void initializeFromConfig( )
{
ManagedRepositoryHandler repoHandler = createHandler( );
repoHandler.initializeFromConfig( );
assertEquals( 5, repoHandler.getAll( ).size( ) );
assertNotNull( repoHandler.get( "test-repo-01" ) );
assertEquals( "n-test-repo-01", repoHandler.get( "test-repo-01" ).getName() );
}
@Test
void activateRepository( ) throws RepositoryException
{
String id = "test-repo-02";
ManagedRepositoryHandler repoHandler = createHandler( );
ManagedRepository repo = repoHandler.newInstance( RepositoryType.MAVEN, id );
repoHandler.activateRepository( repo );
assertFalse( hasRepositoryInConfig( id ));
assertNull( repoHandler.get( id ) );
}
@Test
void newInstancesFromConfig( ) throws RepositoryException
{
final String id = "test-repo-01";
ManagedRepositoryHandler repoHandler = createHandler( );
Configuration configuration = new Configuration( );
repoHandler.remove( "test-repo-01", configuration );
Map<String, ManagedRepository> instances = repoHandler.newInstancesFromConfig( );
assertFalse( repoHandler.hasRepository( id ) );
assertTrue( instances.containsKey( id ) );
assertEquals( RepositoryState.REFERENCES_SET, instances.get( id ).getLastState( ) );
}
@Test
void newInstance( ) throws RepositoryException
{
String id = "test-repo-03";
ManagedRepositoryHandler repoHandler = createHandler( );
ManagedRepository instance = repoHandler.newInstance( RepositoryType.MAVEN, id );
assertNotNull( instance );
assertEquals( id, instance.getId( ) );
assertFalse( repoHandler.hasRepository( id ) );
assertEquals( RepositoryState.REFERENCES_SET, instance.getLastState( ) );
assertFalse( hasRepositoryInConfig( id ) );
}
@Test
void put( ) throws IOException, RepositoryException
{
final String id = "test-repo-04";
try
{
ManagedRepositoryHandler repoHandler = createHandler( );
EditableManagedRepository repository = createRepository( id, "n-"+id );
repoHandler.put( repository );
ManagedRepository storedRepository = repoHandler.get( id );
assertNotNull( storedRepository );
assertEquals( id, storedRepository.getId( ) );
assertEquals( "n-"+id, storedRepository.getName( ) );
EditableManagedRepository repository2 = createRepository( id, "n2-"+id );
repoHandler.put( repository2 );
storedRepository = repoHandler.get( id );
assertNotNull( storedRepository );
assertEquals( id, storedRepository.getId( ) );
assertEquals( "n2-"+id, storedRepository.getName( ) );
assertTrue( hasRepositoryInConfig( id ));
} finally {
removeRepositoryFromConfig( id );
}
}
@Test
void putWithConfiguration( ) throws RepositoryException
{
String id = "test-repo-05";
try
{
ManagedRepositoryHandler repoHandler = createHandler( );
ManagedRepositoryConfiguration configuration = new ManagedRepositoryConfiguration( );
configuration.setId( id );
configuration.setName( "n-" + id );
repoHandler.put( configuration );
ManagedRepository repo = repoHandler.get( id );
assertNotNull( repo );
assertEquals( id, repo.getId( ) );
assertEquals( "n-" + id, repo.getName( ) );
assertTrue( hasRepositoryInConfig( id ) );
}
finally
{
removeRepositoryFromConfig( id );
}
}
@Test
void testPutWithoutRegister( ) throws RepositoryException
{
final String id = "test-repo-06";
ManagedRepositoryHandler repoHandler = createHandler( );
Configuration aCfg = new Configuration( );
ManagedRepositoryConfiguration configuration = new ManagedRepositoryConfiguration( );
configuration.setId( id );
configuration.setName( "n-"+id );
repoHandler.put( configuration, aCfg );
ManagedRepository repo = repoHandler.get( id );
assertNull( repo );
assertFalse( hasRepositoryInConfig( id ) );
assertTrue( aCfg.getManagedRepositories( ).stream( ).anyMatch( g -> g!=null && id.equals( g.getId( ) ) ) );
}
@Test
void putWithCheck_invalid( ) throws RepositoryException
{
final String id = "test-repo-07";
final String name = "n-"+id;
try
{
ManagedRepositoryHandler repoHandler = createHandler( );
BasicManagedRepositoryValidator checker = new BasicManagedRepositoryValidator( configurationHandler );
checker.setRepositoryRegistry( repositoryRegistry );
ManagedRepositoryConfiguration configuration = new ManagedRepositoryConfiguration();
configuration.setId( "" );
configuration.setName( name );
CheckedResult<ManagedRepository, Map<String, List<ValidationError>>> result = repoHandler.putWithCheck( configuration, checker );
assertNull( repoHandler.get( id ) );
assertNotNull( result.getResult( ) );
assertNotNull( result.getResult( ).get( "id" ) );
assertEquals( 2, result.getResult( ).get( "id" ).size( ) );
assertEquals( ISEMPTY, result.getResult( ).get( "id" ).get( 0 ).getType( ) );
assertFalse( hasRepositoryInConfig( id ) );
assertFalse( hasRepositoryInConfig( "" ) );
} finally
{
removeRepositoryFromConfig( id );
}
}
@Test
void remove( ) throws RepositoryException
{
final String id = "test-repo-08";
ManagedRepositoryHandler repoHandler = createHandler( );
ManagedRepositoryConfiguration configuration = new ManagedRepositoryConfiguration( );
configuration.setId( id );
configuration.setName( "n-"+id );
repoHandler.put( configuration );
assertTrue( hasRepositoryInConfig( id ) );
assertNotNull( repoHandler.get( id ) );
repoHandler.remove( id );
assertNull( repoHandler.get( id ) );
assertFalse( hasRepositoryInConfig( id ) );
}
@Test
void removeWithoutSave( ) throws RepositoryException
{
final String id = "test-repo-09";
ManagedRepositoryHandler repoHandler = createHandler( );
Configuration aCfg = new Configuration( );
ManagedRepositoryConfiguration configuration = new ManagedRepositoryConfiguration( );
configuration.setId( id );
configuration.setName( "n-"+id );
repoHandler.put( configuration, aCfg );
assertTrue( aCfg.getManagedRepositories( ).stream( ).anyMatch( g -> g != null && id.equals( g.getId( ) ) ) );
repoHandler.remove( id, aCfg );
assertNull( repoHandler.get( id ) );
assertTrue( aCfg.getManagedRepositories( ).stream( ).noneMatch( g -> g != null && id.equals( g.getId( ) ) ) );
assertNull( repoHandler.get( id ) );
}
@Test
void validateRepository( ) throws IOException
{
final String id = "test-repo-10";
ManagedRepositoryHandler repoHandler = createHandler( );
EditableManagedRepository repository = createRepository( id, "n-"+id );
CheckedResult<ManagedRepository, Map<String, List<ValidationError>>> result = repoHandler.validateRepository( repository );
assertNotNull( result );
assertEquals( 0, result.getResult( ).size( ) );
repository = createRepository( id, "n-test-repo-10###" );
result = repoHandler.validateRepository( repository );
assertNotNull( result );
assertEquals( 1, result.getResult( ).size( ) );
assertNotNull( result.getResult().get( "name" ) );
}
@Test
void validateRepositoryIfExisting( ) throws IOException, RepositoryException
{
final String id = "test-repo-11";
try
{
ManagedRepositoryHandler repoHandler = createHandler( );
EditableManagedRepository repository = createRepository( id, "n-" + id );
repoHandler.put( repository );
CheckedResult<ManagedRepository, Map<String, List<ValidationError>>> result = repoHandler.validateRepository( repository );
assertNotNull( result );
assertEquals( 1, result.getResult( ).size( ) );
} finally
{
removeRepositoryFromConfig( id );
}
}
@Test
void validateRepositoryForUpdate( ) throws IOException, RepositoryException
{
final String id = "test-repo-12";
try
{
ManagedRepositoryHandler repoHandler = createHandler( );
EditableManagedRepository repository = createRepository( id, "n-" + id );
repoHandler.put( repository );
CheckedResult<ManagedRepository, Map<String, List<ValidationError>>> result = repoHandler.validateRepositoryForUpdate( repository );
assertNotNull( result );
assertEquals( 0, result.getResult( ).size( ) );
} finally
{
removeRepositoryFromConfig( id );
}
}
@Test
void has( ) throws IOException, RepositoryException
{
final String id = "test-repo-13";
try
{
ManagedRepositoryHandler repoHandler = createHandler( );
EditableManagedRepository repository = createRepository( id, "n-" + id );
assertFalse( repoHandler.hasRepository( id ) );
repoHandler.put( repository );
assertTrue( repoHandler.hasRepository( id ) );
} finally
{
removeRepositoryFromConfig( id );
}
}
}

225
archiva-modules/archiva-base/archiva-repository-layer/src/test/resources/archiva-managed.xml Normal file
View File

@ -0,0 +1,225 @@
<?xml version="1.0" encoding="UTF-8"?>
<!--
~ Licensed to the Apache Software Foundation (ASF) under one
~ or more contributor license agreements. See the NOTICE file
~ distributed with this work for additional information
~ regarding copyright ownership. The ASF licenses this file
~ to you under the Apache License, Version 2.0 (the
~ "License"); you may not use this file except in compliance
~ with the License. You may obtain a copy of the License at
~
~ http://www.apache.org/licenses/LICENSE-2.0
~
~ Unless required by applicable law or agreed to in writing,
~ software distributed under the License is distributed on an
~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
~ KIND, either express or implied. See the License for the
~ specific language governing permissions and limitations
~ under the License.
-->
<configuration>
<version>3.0.0</version>
<managedRepositories>
<managedRepository>
<id>internal</id>
<name>Archiva Managed Internal Repository</name>
<description>This is internal repository.</description>
<location>${appserver.base}/repositories/internal</location>
<indexDir>${appserver.base}/repositories/internal/.indexer</indexDir>
<layout>default</layout>
<releases>true</releases>
<snapshots>false</snapshots>
<blockRedeployments>true</blockRedeployments>
<scanned>true</scanned>
<refreshCronExpression>0 0 * * * ?</refreshCronExpression>
<retentionPeriod>30</retentionPeriod>
</managedRepository>
<managedRepository>
<id>staging</id>
<name>Repository with staging</name>
<description>This is repository with staging.</description>
<location>${appserver.base}/repositories/internal</location>
<indexDir>${appserver.base}/repositories/internal/.indexer</indexDir>
<layout>default</layout>
<releases>true</releases>
<snapshots>false</snapshots>
<blockRedeployments>true</blockRedeployments>
<scanned>true</scanned>
<refreshCronExpression>0 0 * * * ?</refreshCronExpression>
<retentionPeriod>30</retentionPeriod>
<stageRepoNeeded>true</stageRepoNeeded>
</managedRepository>
<managedRepository>
<id>snapshots</id>
<name>Archiva Managed Snapshot Repository</name>
<location>${appserver.base}/repositories/snapshots</location>
<indexDir>${appserver.base}/repositories/snapshots/.indexer</indexDir>
<layout>default</layout>
<releases>false</releases>
<snapshots>true</snapshots>
<blockRedeployments>false</blockRedeployments>
<scanned>true</scanned>
<refreshCronExpression>0 0\,30 * * * ?</refreshCronExpression>
<retentionPeriod>30</retentionPeriod>
</managedRepository>
<managedRepository>
<id>test-repo-01</id>
<name>n-test-repo-01</name>
<location>${appserver.base}/repositories/test-repo-01</location>
<indexDir>${appserver.base}/repositories/test-repo-01/.indexer</indexDir>
<layout>default</layout>
<releases>true</releases>
<snapshots>false</snapshots>
<blockRedeployments>false</blockRedeployments>
<scanned>true</scanned>
<refreshCronExpression>0 0\,30 * * * ?</refreshCronExpression>
<retentionPeriod>30</retentionPeriod>
</managedRepository>
</managedRepositories>
<remoteRepositories>
<remoteRepository>
<id>central</id>
<name>Central Repository</name>
<url>https://repo.maven.apache.org/maven2</url>
<layout>default</layout>
<timeout>35</timeout>
</remoteRepository>
</remoteRepositories>
<repositoryGroups>
<repositoryGroup>
<id>test-group-01</id>
<name>Test Group 01</name>
<type>MAVEN</type>
<repositories>
<repository>internal</repository>
</repositories>
</repositoryGroup>
</repositoryGroups>
<proxyConnectors>
<proxyConnector>
<sourceRepoId>internal</sourceRepoId>
<targetRepoId>central</targetRepoId>
<proxyId/>
<policies>
<snapshots>disabled</snapshots>
<releases>once</releases>
<checksum>fix</checksum>
<cache-failures>cached</cache-failures>
</policies>
<whiteListPatterns>
<whiteListPattern>**/*</whiteListPattern>
</whiteListPatterns>
</proxyConnector>
</proxyConnectors>
<legacyArtifactPaths>
<legacyArtifactPath>
<path>jaxen/jars/jaxen-1.0-FCS-full.jar</path>
<artifact>jaxen:jaxen:1.0-FCS:full:jar</artifact>
</legacyArtifactPath>
</legacyArtifactPaths>
<repositoryScanning>
<fileTypes>
<fileType>
<id>artifacts</id>
<patterns>
<pattern>**/*.pom</pattern>
<pattern>**/*.jar</pattern>
<pattern>**/*.ear</pattern>
<pattern>**/*.war</pattern>
<pattern>**/*.car</pattern>
<pattern>**/*.sar</pattern>
<pattern>**/*.mar</pattern>
<pattern>**/*.rar</pattern>
<pattern>**/*.dtd</pattern>
<pattern>**/*.tld</pattern>
<pattern>**/*.tar.gz</pattern>
<pattern>**/*.tar.bz2</pattern>
<pattern>**/*.zip</pattern>
</patterns>
</fileType>
<fileType>
<id>indexable-content</id>
<patterns>
<pattern>**/*.txt</pattern>
<pattern>**/*.TXT</pattern>
<pattern>**/*.block</pattern>
<pattern>**/*.config</pattern>
<pattern>**/*.pom</pattern>
<pattern>**/*.xml</pattern>
<pattern>**/*.xsd</pattern>
<pattern>**/*.dtd</pattern>
<pattern>**/*.tld</pattern>
</patterns>
</fileType>
<fileType>
<id>auto-remove</id>
<patterns>
<pattern>**/*.bak</pattern>
<pattern>**/*~</pattern>
<pattern>**/*-</pattern>
</patterns>
</fileType>
<fileType>
<id>ignored</id>
<patterns>
<pattern>**/.htaccess</pattern>
<pattern>**/KEYS</pattern>
<pattern>**/*.rb</pattern>
<pattern>**/*.sh</pattern>
<pattern>**/.svn/**</pattern>
<pattern>**/.DAV/**</pattern>
<pattern>.index/**</pattern>
<pattern>.indexer/**</pattern>
</patterns>
</fileType>
</fileTypes>
<knownContentConsumers>
<knownContentConsumer>create-missing-checksums</knownContentConsumer>
<knownContentConsumer>validate-checksum</knownContentConsumer>
<knownContentConsumer>validate-signature</knownContentConsumer>
<knownContentConsumer>index-content</knownContentConsumer>
<knownContentConsumer>auto-remove</knownContentConsumer>
<knownContentConsumer>auto-rename</knownContentConsumer>
<knownContentConsumer>metadata-updater</knownContentConsumer>
<knownContentConsumer>create-archiva-metadata</knownContentConsumer>
<knownContentConsumer>duplicate-artifacts</knownContentConsumer>
<!--knownContentConsumer>repository-purge</knownContentConsumer-->
</knownContentConsumers>
<invalidContentConsumers>
<invalidContentConsumer>update-db-bad-content</invalidContentConsumer>
</invalidContentConsumers>
</repositoryScanning>
<webapp>
<ui>
<showFindArtifacts>true</showFindArtifacts>
<appletFindEnabled>true</appletFindEnabled>
</ui>
</webapp>
<redbackRuntimeConfiguration>
<userManagerImpls>
<userManagerImpl>jpa</userManagerImpl>
</userManagerImpls>
<rbacManagerImpls>
<rbacManagerImpl>cached</rbacManagerImpl>
</rbacManagerImpls>
</redbackRuntimeConfiguration>
<archivaDefaultConfiguration>
<defaultCheckPaths>
<defaultCheckPath>
<url>http://download.oracle.com/maven</url>
<path>com/sleepycat/je/license.txt</path>
</defaultCheckPath>
<defaultCheckPath>
<url>https://download.oracle.com/maven</url>
<path>com/sleepycat/je/license.txt</path>
</defaultCheckPath>
</defaultCheckPaths>
</archivaDefaultConfiguration>
</configuration>

57
archiva-modules/archiva-base/archiva-repository-layer/src/test/resources/spring-context-managed.xml Normal file
View File

@ -0,0 +1,57 @@
<?xml version="1.0"?>
<!--
~ Licensed to the Apache Software Foundation (ASF) under one
~ or more contributor license agreements. See the NOTICE file
~ distributed with this work for additional information
~ regarding copyright ownership. The ASF licenses this file
~ to you under the Apache License, Version 2.0 (the
~ "License"); you may not use this file except in compliance
~ with the License. You may obtain a copy of the License at
~
~ http://www.apache.org/licenses/LICENSE-2.0
~
~ Unless required by applicable law or agreed to in writing,
~ software distributed under the License is distributed on an
~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
~ KIND, either express or implied. See the License for the
~ specific language governing permissions and limitations
~ under the License.
-->
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd"
default-lazy-init="true">
<context:annotation-config/>
<context:component-scan base-package="org.apache.archiva.repository.mock"/>
<bean name="commons-configuration" class="org.apache.archiva.components.registry.commons.CommonsConfigurationRegistry">
<property name="initialConfiguration">
<value>
<![CDATA[
<configuration>
<system/>
<xml fileName="archiva-managed.xml" config-forceCreate="true"
config-optional="true"
config-name="org.apache.archiva.base" config-at="org.apache.archiva"/>
</configuration>
]]>
</value>
</property>
</bean>
<bean name="taskScheduler#mergeRemoteIndexes"
class="org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler">
<property name="poolSize" value="4"/>
<property name="threadGroupName" value="mergeRemoteIndexes"/>
</bean>
</beans>

5
archiva-modules/archiva-base/archiva-storage-api/pom.xml
View File

@ -50,11 +50,6 @@
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>

6
archiva-modules/archiva-maven/archiva-maven-indexer/src/test/java/org/apache/archiva/indexer/maven/MavenIndexManagerTest.java
View File

@ -25,6 +25,7 @@ import org.apache.archiva.indexer.IndexCreationFailedException;
import org.apache.archiva.repository.base.ArchivaRepositoryRegistry;
import org.apache.archiva.repository.RepositoryType;
import org.apache.archiva.repository.base.group.RepositoryGroupHandler;
import org.apache.archiva.repository.base.managed.ManagedRepositoryHandler;
import org.apache.archiva.repository.features.IndexCreationFeature;
import org.apache.archiva.repository.features.RemoteIndexFeature;
import org.apache.archiva.repository.maven.MavenManagedRepository;
@ -62,6 +63,11 @@ public class MavenIndexManagerTest {
@Inject
ArchivaRepositoryRegistry repositoryRegistry;
@SuppressWarnings( "unused" )
@Inject
ManagedRepositoryHandler managedRepositoryHandler;
@SuppressWarnings( "unused" )
@Inject
RepositoryGroupHandler groupHandler;

35
archiva-modules/archiva-maven/archiva-maven-indexer/src/test/java/org/apache/archiva/indexer/maven/search/AbstractMavenRepositorySearch.java
View File

@ -32,6 +32,7 @@ import org.apache.archiva.proxy.ProxyRegistry;
import org.apache.archiva.repository.base.ArchivaRepositoryRegistry;
import org.apache.archiva.repository.Repository;
import org.apache.archiva.repository.base.group.RepositoryGroupHandler;
import org.apache.archiva.repository.base.managed.ManagedRepositoryHandler;
import org.apache.archiva.repository.features.IndexCreationFeature;
import org.apache.archiva.test.utils.ArchivaSpringJUnit4ClassRunner;
import org.apache.commons.lang3.SystemUtils;
@ -46,6 +47,7 @@ import org.apache.maven.index.Scanner;
import org.apache.maven.index.ScanningRequest;
import org.apache.maven.index.ScanningResult;
import org.apache.maven.index.context.IndexingContext;
import org.apache.maven.index_shaded.lucene.index.IndexUpgrader;
import org.easymock.EasyMock;
import org.easymock.IMocksControl;
import org.junit.After;
@ -93,8 +95,14 @@ public abstract class AbstractMavenRepositorySearch
@Inject
ArchivaRepositoryRegistry repositoryRegistry;
@SuppressWarnings( "unused" )
@Inject
RepositoryGroupHandler repositoryGroupHandler;
ManagedRepositoryHandler managedRepositoryHandler;
@SuppressWarnings( "unused" )
@Inject
RepositoryGroupHandler groupHandler;
@Inject
ProxyRegistry proxyRegistry;
@ -124,9 +132,11 @@ public abstract class AbstractMavenRepositorySearch
FileUtils.deleteDirectory( Paths.get( org.apache.archiva.common.utils.FileUtils.getBasedir(), "/target/repos/" + TEST_REPO_1 + "/.indexer" ) );
assertFalse( Files.exists(Paths.get( org.apache.archiva.common.utils.FileUtils.getBasedir(), "/target/repos/" + TEST_REPO_1 + "/.indexer" )) );
Files.createDirectories( Paths.get( org.apache.archiva.common.utils.FileUtils.getBasedir(), "/target/repos/" + TEST_REPO_1 + "/.indexer" ) );
FileUtils.deleteDirectory( Paths.get( org.apache.archiva.common.utils.FileUtils.getBasedir(), "/target/repos/" + TEST_REPO_2 + "/.indexer" ) );
assertFalse( Files.exists(Paths.get( org.apache.archiva.common.utils.FileUtils.getBasedir(), "/target/repos/" + TEST_REPO_2 + "/.indexer" )) );
Files.createDirectories( Paths.get( org.apache.archiva.common.utils.FileUtils.getBasedir(), "/target/repos/" + TEST_REPO_2 + "/.indexer" ) );
archivaConfigControl = EasyMock.createControl();
@ -212,7 +222,7 @@ public abstract class AbstractMavenRepositorySearch
protected void createIndex( String repository, List<Path> filesToBeIndexed, boolean scan, Path indexDir, boolean copyFiles)
throws Exception
{
Repository rRepo = repositoryRegistry.getRepository(repository);
final Repository rRepo = repositoryRegistry.getRepository(repository);
IndexCreationFeature icf = rRepo.getFeature(IndexCreationFeature.class).get();
@ -228,12 +238,12 @@ public abstract class AbstractMavenRepositorySearch
Path indexerDirectory = repoDir.resolve(".indexer" );
if ( Files.exists(indexerDirectory) )
if ( indexDir == null && Files.exists(indexerDirectory) )
{
FileUtils.deleteDirectory( indexerDirectory );
assertFalse( Files.exists(indexerDirectory) );
}
assertFalse( Files.exists(indexerDirectory) );
Path lockFile = repoDir.resolve(".indexer/write.lock" );
if ( Files.exists(lockFile) )
@ -247,10 +257,21 @@ public abstract class AbstractMavenRepositorySearch
indexDirectory.toFile().deleteOnExit();
FileUtils.deleteDirectory(indexDirectory);
icf.setIndexPath(indexDirectory.toUri());
config.getManagedRepositories( ).stream( ).filter( r -> r.getId( ).equals( rRepo.getId( ) ) ).findFirst( ).ifPresent( r ->
r.setIndexDir( indexDirectory.toAbsolutePath( ).toString( ) )
);
// IndexUpgrader.main(new String[]{indexDirectory.toAbsolutePath().toString()});
} else {
icf.setIndexPath(indexDir.toUri());
Files.createDirectories( indexDir );
config.getManagedRepositories( ).stream( ).filter( r -> r.getId( ).equals( rRepo.getId( ) ) ).findFirst( ).ifPresent( r ->
r.setIndexDir( indexDir.toAbsolutePath( ).toString( ) )
);
IndexUpgrader.main(new String[]{indexDir.toAbsolutePath().toString()});
}
if (copyFiles) {
Path repo = Paths.get(org.apache.archiva.common.utils.FileUtils.getBasedir(), "src/test/" + repository);
assertTrue(Files.exists(repo));
@ -269,11 +290,11 @@ public abstract class AbstractMavenRepositorySearch
repositoryRegistry.reload();
archivaConfigControl.reset();
rRepo = repositoryRegistry.getRepository(repository);
icf = rRepo.getFeature(IndexCreationFeature.class).get();
Repository rRepo2 = repositoryRegistry.getRepository( repository );
icf = rRepo2.getFeature(IndexCreationFeature.class).get();
archivaCtx = rRepo.getIndexingContext();
archivaCtx = rRepo2.getIndexingContext();
context = archivaCtx.getBaseContext(IndexingContext.class);

9
archiva-modules/archiva-maven/archiva-maven-indexer/src/test/java/org/apache/archiva/indexer/maven/search/MavenRepositorySearchOSGITest.java
View File

@ -24,6 +24,7 @@ import org.apache.archiva.indexer.search.SearchResultHit;
import org.apache.archiva.indexer.search.SearchResults;
import org.apache.archiva.repository.base.ArchivaRepositoryRegistry;
import org.apache.archiva.repository.base.group.RepositoryGroupHandler;
import org.apache.archiva.repository.base.managed.ManagedRepositoryHandler;
import org.easymock.EasyMock;
import org.junit.After;
import org.junit.Test;
@ -44,8 +45,14 @@ public class MavenRepositorySearchOSGITest
@Inject
ArchivaRepositoryRegistry repositoryRegistry;
@SuppressWarnings( "unused" )
@Inject
RepositoryGroupHandler repositoryGroupHandler;
ManagedRepositoryHandler managedRepositoryHandler;
@SuppressWarnings( "unused" )
@Inject
RepositoryGroupHandler groupHandler;
@After
@Override

9
archiva-modules/archiva-maven/archiva-maven-indexer/src/test/java/org/apache/archiva/indexer/maven/search/MavenRepositorySearchPaginateTest.java
View File

@ -25,6 +25,7 @@ import org.apache.archiva.indexer.search.SearchResults;
import org.apache.archiva.indexer.util.SearchUtil;
import org.apache.archiva.repository.base.ArchivaRepositoryRegistry;
import org.apache.archiva.repository.base.group.RepositoryGroupHandler;
import org.apache.archiva.repository.base.managed.ManagedRepositoryHandler;
import org.apache.archiva.test.utils.ArchivaSpringJUnit4ClassRunner;
import org.junit.After;
import org.junit.Test;
@ -46,8 +47,14 @@ public class MavenRepositorySearchPaginateTest
@Inject
ArchivaRepositoryRegistry repositoryRegistry;
@SuppressWarnings( "unused" )
@Inject
RepositoryGroupHandler repositoryGroupHandler;
ManagedRepositoryHandler managedRepositoryHandler;
@SuppressWarnings( "unused" )
@Inject
RepositoryGroupHandler groupHandler;
@After
public void endTests() {

5
archiva-modules/archiva-maven/archiva-maven-indexer/src/test/java/org/apache/archiva/indexer/maven/search/MavenRepositorySearchTest.java
View File

@ -33,6 +33,7 @@ import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
@ -895,12 +896,12 @@ public class MavenRepositorySearchTest
throws Exception
{
Path repo = Paths.get("target/repo-release");
Path repo = Paths.get("target/repo-release-index-test/repo-release");
try {
Path indexDirectory = repo.resolve(".indexer");
Path zipFile = Paths.get(Thread.currentThread().getContextClassLoader().getResource("repo-release.zip").toURI());
FileUtils.unzip(zipFile, repo.getParent());
IndexUpgrader.main(new String[]{indexDirectory.toAbsolutePath().toString()});
// IndexUpgrader.main(new String[]{indexDirectory.toAbsolutePath().toString(), "-delete-prior-commits"});
createIndex(REPO_RELEASE, Collections.emptyList(), false, indexDirectory, false);
// indexer.addIndexingContext( REPO_RELEASE, REPO_RELEASE, repo.toFile(), indexDirectory.toFile(),

6
archiva-modules/archiva-maven/archiva-maven-proxy/src/test/java/org/apache/archiva/proxy/AbstractProxyTestCase.java
View File

@ -25,6 +25,7 @@ import org.apache.archiva.policies.*;
import org.apache.archiva.proxy.model.RepositoryProxyHandler;
import org.apache.archiva.repository.*;
import org.apache.archiva.repository.base.managed.BasicManagedRepository;
import org.apache.archiva.repository.base.managed.ManagedRepositoryHandler;
import org.apache.archiva.repository.storage.StorageAsset;
import org.apache.archiva.test.utils.ArchivaSpringJUnit4ClassRunner;
import org.apache.maven.wagon.Wagon;
@ -70,6 +71,11 @@ public abstract class AbstractProxyTestCase
@Inject
RepositoryRegistry repositoryRegistry;
@SuppressWarnings( "unused" )
@Inject
ManagedRepositoryHandler managedRepositoryHandler;
protected static final String ID_PROXIED1 = "proxied1";
protected static final String ID_PROXIED1_TARGET = "proxied1-target";

2
archiva-modules/archiva-maven/archiva-maven-proxy/src/test/java/org/apache/archiva/proxy/CacheFailuresTransferTest.java
View File

@ -25,6 +25,7 @@ import org.apache.archiva.policies.ChecksumPolicy;
import org.apache.archiva.policies.ReleasesPolicy;
import org.apache.archiva.policies.SnapshotsPolicy;
import org.apache.archiva.policies.urlcache.UrlFailureCache;
import org.apache.archiva.repository.base.managed.ManagedRepositoryHandler;
import org.apache.archiva.repository.content.BaseRepositoryContentLayout;
import org.apache.archiva.repository.content.Artifact;
import org.apache.archiva.repository.storage.StorageAsset;
@ -53,6 +54,7 @@ public class CacheFailuresTransferTest
@Inject
UrlFailureCache urlFailureCache;
@Test
public void testGetWithCacheFailuresOn( )
throws Exception

6
archiva-modules/archiva-maven/archiva-maven-proxy/src/test/java/org/apache/archiva/proxy/HttpProxyTransferTest.java
View File

@ -30,6 +30,7 @@ import org.apache.archiva.policies.PropagateErrorsOnUpdateDownloadPolicy;
import org.apache.archiva.policies.ReleasesPolicy;
import org.apache.archiva.policies.SnapshotsPolicy;
import org.apache.archiva.proxy.model.RepositoryProxyHandler;
import org.apache.archiva.repository.base.managed.ManagedRepositoryHandler;
import org.apache.archiva.repository.content.BaseRepositoryContentLayout;
import org.apache.archiva.repository.ManagedRepository;
import org.apache.archiva.repository.ManagedRepositoryContent;
@ -100,6 +101,11 @@ public class HttpProxyTransferTest
@Inject
private ProxyRegistry proxyRegistry;
@SuppressWarnings( "unused" )
@Inject
ManagedRepositoryHandler managedRepositoryHandler;
private Server server;
protected ManagedRepositoryContent createRepository( String id, String name, String path, String layout )

7
archiva-modules/archiva-maven/archiva-maven-repository/src/main/java/org/apache/archiva/repository/maven/MavenRepositoryProvider.java
View File

@ -497,7 +497,12 @@ public class MavenRepositoryProvider implements RepositoryProvider {
if (StringUtils.isNotBlank(repository.getIndexDir())) {
Path indexDir;
try {
indexDir = Paths.get(new URI(repository.getIndexDir().startsWith("file://") ? repository.getIndexDir() : "file://" + repository.getIndexDir()));
if (repository.getIndexDir().startsWith( "file:" )) {
indexDir = Paths.get( new URI( repository.getIndexDir( ) ) );
} else
{
indexDir = Paths.get( repository.getIndexDir( ) );
}
if (indexDir.isAbsolute()) {
Path newDir = indexDir.getParent().resolve(indexDir.getFileName() + StagingRepositoryFeature.STAGING_REPO_POSTFIX);
log.debug("Changing index directory {} -> {}", indexDir, newDir);

6
archiva-modules/archiva-maven/archiva-maven-repository/src/test/java/org/apache/archiva/repository/maven/metadata/storage/Maven2RepositoryMetadataResolverMRM1411RepoGroupTest.java
View File

@ -36,6 +36,7 @@ import org.apache.archiva.metadata.repository.storage.ReadMetadataRequest;
import org.apache.archiva.proxy.maven.WagonFactory;
import org.apache.archiva.proxy.maven.WagonFactoryRequest;
import org.apache.archiva.repository.RepositoryRegistry;
import org.apache.archiva.repository.base.managed.ManagedRepositoryHandler;
import org.apache.archiva.test.utils.ArchivaSpringJUnit4ClassRunner;
import org.apache.commons.io.FileUtils;
import org.apache.maven.wagon.Wagon;
@ -100,6 +101,11 @@ public class Maven2RepositoryMetadataResolverMRM1411RepoGroupTest
@Inject
RepositoryRegistry repositoryRegistry;
@SuppressWarnings( "unused" )
@Inject
ManagedRepositoryHandler managedRepositoryHandler;
private WagonFactory wagonFactory;
ManagedRepositoryConfiguration testRepo;

11
archiva-modules/archiva-maven/archiva-maven-repository/src/test/java/org/apache/archiva/repository/maven/metadata/storage/Maven2RepositoryMetadataResolverMRM1411Test.java
View File

@ -37,6 +37,7 @@ import org.apache.archiva.proxy.maven.WagonFactory;
import org.apache.archiva.proxy.maven.WagonFactoryRequest;
import org.apache.archiva.repository.ReleaseScheme;
import org.apache.archiva.repository.RepositoryRegistry;
import org.apache.archiva.repository.base.managed.ManagedRepositoryHandler;
import org.apache.archiva.test.utils.ArchivaSpringJUnit4ClassRunner;
import org.apache.commons.io.FileUtils;
import org.apache.maven.wagon.Wagon;
@ -97,6 +98,11 @@ public class Maven2RepositoryMetadataResolverMRM1411Test
@Inject
RepositoryRegistry repositoryRegistry;
@SuppressWarnings( "unused" )
@Inject
ManagedRepositoryHandler managedRepositoryHandler;
private WagonFactory wagonFactory;
ManagedRepositoryConfiguration testRepo;
@ -141,6 +147,7 @@ public class Maven2RepositoryMetadataResolverMRM1411Test
wagonFactory = mock( WagonFactory.class );
assertNotNull( storage );
storage.setWagonFactory( wagonFactory );
Wagon wagon = new MockWagon();
@ -153,6 +160,7 @@ public class Maven2RepositoryMetadataResolverMRM1411Test
public void testGetProjectVersionMetadataWithParentSuccessful()
throws Exception
{
assertNotNull( storage );
copyTestArtifactWithParent( "target/test-classes/com/example/test/test-artifact-module-a",
"target/test-repository/com/example/test/test-artifact-module-a" );
copyTestArtifactWithParent( "src/test/resources/com/example/test/test-artifact-parent",
@ -201,12 +209,14 @@ public class Maven2RepositoryMetadataResolverMRM1411Test
public void testGetProjectVersionMetadataWithParentNoRemoteReposConfigured()
throws Exception
{
assertNotNull( storage );
// remove configuration
Configuration config = configuration.getConfiguration();
RemoteRepositoryConfiguration remoteRepo = config.findRemoteRepositoryById( TEST_REMOTE_REPO_ID );
config.removeRemoteRepository( remoteRepo );
configuration.save( config );
assertNotNull( storage );
copyTestArtifactWithParent( "target/test-classes/com/example/test/test-artifact-module-a",
"target/test-repository/com/example/test/test-artifact-module-a" );
@ -233,6 +243,7 @@ public class Maven2RepositoryMetadataResolverMRM1411Test
public void testGetProjectVersionMetadataWithParentNotInAnyRemoteRepo()
throws Exception
{
assertNotNull( storage );
copyTestArtifactWithParent( "target/test-classes/com/example/test/test-artifact-module-a",
"target/test-repository/com/example/test/test-artifact-module-a" );

6
archiva-modules/archiva-maven/archiva-maven-repository/src/test/java/org/apache/archiva/repository/maven/metadata/storage/Maven2RepositoryMetadataResolverManagedReleaseTest.java
View File

@ -25,6 +25,7 @@ import org.apache.archiva.metadata.repository.storage.ReadMetadataRequest;
import org.apache.archiva.metadata.repository.storage.RepositoryStorageRuntimeException;
import org.apache.archiva.proxy.maven.WagonFactory;
import org.apache.archiva.repository.RepositoryRegistry;
import org.apache.archiva.repository.base.managed.ManagedRepositoryHandler;
import org.junit.Before;
import org.junit.Test;
@ -44,6 +45,11 @@ public class Maven2RepositoryMetadataResolverManagedReleaseTest
@Inject
RepositoryRegistry repositoryRegistry;
@SuppressWarnings( "unused" )
@Inject
ManagedRepositoryHandler managedRepositoryHandler;
private static final String TEST_REPO_ID = "test";
private static final String TEST_REMOTE_REPO_ID = "central";

6
archiva-modules/archiva-maven/archiva-maven-repository/src/test/java/org/apache/archiva/repository/maven/metadata/storage/Maven2RepositoryMetadataResolverManagedSnapshotTest.java
View File

@ -24,6 +24,7 @@ import org.apache.archiva.metadata.model.ProjectVersionMetadata;
import org.apache.archiva.metadata.repository.storage.ReadMetadataRequest;
import org.apache.archiva.metadata.repository.storage.RepositoryStorageRuntimeException;
import org.apache.archiva.repository.RepositoryRegistry;
import org.apache.archiva.repository.base.managed.ManagedRepositoryHandler;
import org.junit.Before;
import org.junit.Test;
@ -42,6 +43,11 @@ public class Maven2RepositoryMetadataResolverManagedSnapshotTest
@Inject
RepositoryRegistry repositoryRegistry;
@SuppressWarnings( "unused" )
@Inject
ManagedRepositoryHandler managedRepositoryHandler;
private static final String TEST_REPO_ID = "test";
private static final String TEST_REMOTE_REPO_ID = "central";

6
archiva-modules/archiva-maven/archiva-maven-repository/src/test/java/org/apache/archiva/repository/maven/metadata/storage/Maven2RepositoryMetadataResolverTest.java
View File

@ -40,6 +40,7 @@ import org.apache.archiva.metadata.repository.storage.RepositoryStorageMetadataN
import org.apache.archiva.proxy.maven.WagonFactory;
import org.apache.archiva.proxy.maven.WagonFactoryRequest;
import org.apache.archiva.repository.RepositoryRegistry;
import org.apache.archiva.repository.base.managed.ManagedRepositoryHandler;
import org.apache.archiva.test.utils.ArchivaSpringJUnit4ClassRunner;
import org.apache.commons.io.FileUtils;
import org.apache.maven.wagon.Wagon;
@ -80,6 +81,11 @@ public class Maven2RepositoryMetadataResolverTest
@Inject
RepositoryRegistry repositoryRegistry;
@SuppressWarnings( "unused" )
@Inject
ManagedRepositoryHandler managedRepositoryHandler;
private static final String TEST_REPO_ID = "test";
private static final String TEST_REMOTE_REPO_ID = "central";

6
archiva-modules/archiva-maven/archiva-maven-scheduler/src/test/java/org/apache/archiva/scheduler/indexing/maven/ArchivaIndexingTaskExecutorTest.java
View File

@ -27,6 +27,7 @@ import org.apache.archiva.repository.base.managed.BasicManagedRepository;
import org.apache.archiva.repository.ManagedRepository;
import org.apache.archiva.repository.ReleaseScheme;
import org.apache.archiva.repository.base.group.RepositoryGroupHandler;
import org.apache.archiva.repository.base.managed.ManagedRepositoryHandler;
import org.apache.archiva.repository.storage.StorageAsset;
import org.apache.archiva.repository.features.IndexCreationFeature;
import org.apache.archiva.scheduler.indexing.ArtifactIndexingTask;
@ -74,6 +75,11 @@ public class ArchivaIndexingTaskExecutorTest
@Inject
ArchivaRepositoryRegistry repositoryRegistry;
@SuppressWarnings( "unused" )
@Inject
ManagedRepositoryHandler managedRepositoryHandler;
@SuppressWarnings( "unused" )
@Inject
RepositoryGroupHandler repositoryGroupHandler;

11
archiva-modules/archiva-maven/archiva-maven-scheduler/src/test/java/org/apache/archiva/scheduler/indexing/maven/DownloadRemoteIndexTaskTest.java
View File

@ -29,6 +29,8 @@ import org.apache.archiva.repository.RepositoryProvider;
import org.apache.archiva.repository.RepositoryRegistry;
import org.apache.archiva.repository.RepositoryType;
import org.apache.archiva.repository.UnsupportedURIException;
import org.apache.archiva.repository.base.group.RepositoryGroupHandler;
import org.apache.archiva.repository.base.managed.ManagedRepositoryHandler;
import org.apache.archiva.repository.features.IndexCreationFeature;
import org.apache.archiva.repository.features.RemoteIndexFeature;
import org.apache.archiva.test.utils.ArchivaSpringJUnit4ClassRunner;
@ -90,6 +92,15 @@ public class DownloadRemoteIndexTaskTest
@Inject
RepositoryRegistry repositoryRegistry;
@SuppressWarnings( "unused" )
@Inject
ManagedRepositoryHandler managedRepositoryHandler;
@SuppressWarnings( "unused" )
@Inject
RepositoryGroupHandler repositoryGroupHandler;
@Inject
RepositoryProvider repositoryProvider;

6
archiva-modules/archiva-scheduler/archiva-scheduler-repository/src/test/java/org/apache/archiva/scheduler/repository/AbstractArchivaRepositoryScanningTaskExecutorTest.java
View File

@ -30,6 +30,7 @@ import org.apache.archiva.components.taskqueue.execution.TaskExecutor;
import org.apache.archiva.repository.ManagedRepository;
import org.apache.archiva.repository.RepositoryRegistry;
import org.apache.archiva.repository.base.group.RepositoryGroupHandler;
import org.apache.archiva.repository.base.managed.ManagedRepositoryHandler;
import org.apache.archiva.scheduler.repository.model.RepositoryTask;
import org.apache.archiva.test.utils.ArchivaSpringJUnit4ClassRunner;
import org.junit.After;
@ -66,6 +67,11 @@ public abstract class AbstractArchivaRepositoryScanningTaskExecutorTest
@Inject
RepositoryRegistry repositoryRegistry;
@SuppressWarnings( "unused" )
@Inject
ManagedRepositoryHandler managedRepositoryHandler;
@SuppressWarnings( "unused" )
@Inject
RepositoryGroupHandler groupHandler;

54
archiva-modules/archiva-web/archiva-webdav/src/test/java/org/apache/archiva/webdav/AbstractRepositoryServletTestCase.java
View File

@ -27,10 +27,12 @@ import org.apache.archiva.configuration.Configuration;
import org.apache.archiva.configuration.ManagedRepositoryConfiguration;
import org.apache.archiva.configuration.RemoteRepositoryConfiguration;
import org.apache.archiva.indexer.ArchivaIndexingContext;
import org.apache.archiva.repository.RepositoryException;
import org.apache.archiva.repository.base.ArchivaRepositoryRegistry;
import org.apache.archiva.repository.ManagedRepository;
import org.apache.archiva.repository.RepositoryType;
import org.apache.archiva.repository.base.group.RepositoryGroupHandler;
import org.apache.archiva.repository.base.managed.ManagedRepositoryHandler;
import org.apache.archiva.test.utils.ArchivaSpringJUnit4ClassRunner;
import org.apache.archiva.webdav.httpunit.MkColMethodWebRequest;
import org.apache.commons.io.FileUtils;
@ -104,6 +106,10 @@ public abstract class AbstractRepositoryServletTestCase
@Inject
RepositoryGroupHandler repositoryGroupHandler;
@SuppressWarnings( "unused" )
@Inject
ManagedRepositoryHandler managedRepositoryHandler;
@Inject
ArchivaRepositoryRegistry repositoryRegistry;
@ -166,8 +172,16 @@ public abstract class AbstractRepositoryServletTestCase
System.setProperty( "appserver.base", getAppserverBase().toAbsolutePath().toString());
log.info("setUp appserverBase={}, projectBase={}, workingDir={}", getAppserverBase(), getProjectBase(), Paths.get("").toString());
repositoryRegistry.getRepositories().stream().forEach(r -> r.close());
repositoryRegistry.getRepositories().stream().forEach(r -> {
try
{
repositoryRegistry.removeRepository( r );
}
catch ( RepositoryException e )
{
e.printStackTrace( );
}
} );
org.apache.archiva.common.utils.FileUtils.deleteDirectory( getAppserverBase() );
Path testConf = getProjectBase().resolve( "src/test/resources/repository-archiva.xml" );
@ -191,20 +205,21 @@ public abstract class AbstractRepositoryServletTestCase
config.getRemoteRepositories().clear();
saveConfiguration( archivaConfiguration );
// repositoryRegistry.reload();
ArchivaIndexingContext ctx = repositoryRegistry.getManagedRepository( REPOID_INTERNAL ).getIndexingContext( );
try
{
if (repositoryRegistry.getIndexManager(RepositoryType.MAVEN)!=null) {
repositoryRegistry.getIndexManager(RepositoryType.MAVEN).pack(ctx);
}
} finally
{
if (ctx!=null)
{
ctx.close( );
}
}
// ArchivaIndexingContext ctx = repositoryRegistry.getManagedRepository( REPOID_INTERNAL ).getIndexingContext( );
// try
// {
// if (repositoryRegistry.getIndexManager(RepositoryType.MAVEN)!=null) {
// repositoryRegistry.getIndexManager(RepositoryType.MAVEN).pack(ctx);
// }
// } finally
// {
// if (ctx!=null)
// {
// ctx.close( );
// }
// }
CacheManager.getInstance().clearAll();
@ -856,8 +871,8 @@ public abstract class AbstractRepositoryServletTestCase
repo.setLocation( location.toAbsolutePath().toString() );
repo.setBlockRedeployments( blockRedeployments );
repo.setType( "MAVEN" );
repo.setIndexDir(".indexer");
repo.setPackedIndexDir(".index");
repo.setIndexDir(location.resolve( ".indexer" ).toAbsolutePath().toString());
repo.setPackedIndexDir( location.resolve( ".index" ).toAbsolutePath( ).toString( ) );
return repo;
}
@ -891,13 +906,16 @@ public abstract class AbstractRepositoryServletTestCase
protected void setupCleanRepo( Path repoRootDir )
throws IOException
{
if (repoRootDir!=null)
{
org.apache.archiva.common.utils.FileUtils.deleteDirectory( repoRootDir );
if ( !Files.exists(repoRootDir) )
if ( !Files.exists( repoRootDir ) )
{
Files.createDirectories( repoRootDir );
}
}
}
protected void assertManagedFileNotExists( Path repoRootInternal, String resourcePath )
{

7
archiva-modules/archiva-web/archiva-webdav/src/test/java/org/apache/archiva/webdav/ArchivaDavResourceFactoryTest.java
View File

@ -35,6 +35,7 @@ import org.apache.archiva.configuration.RepositoryGroupConfiguration;
import org.apache.archiva.metadata.repository.storage.RepositoryPathTranslator;
import org.apache.archiva.repository.ManagedRepositoryContent;
import org.apache.archiva.repository.base.group.RepositoryGroupHandler;
import org.apache.archiva.repository.base.managed.ManagedRepositoryHandler;
import org.apache.archiva.repository.maven.content.MavenContentHelper;
import org.apache.archiva.repository.maven.metadata.storage.ArtifactMappingProvider;
import org.apache.archiva.proxy.ProxyRegistry;
@ -163,6 +164,10 @@ public class ArchivaDavResourceFactoryTest
@Inject
RepositoryGroupHandler repositoryGroupHandler;
@SuppressWarnings( "unused" )
@Inject
ManagedRepositoryHandler managedRepositoryHandler;
public Path getProjectBase() {
if (this.projectBase.get()==null) {
String pathVal = System.getProperty("mvn.project.base.dir");
@ -195,7 +200,7 @@ public class ArchivaDavResourceFactoryTest
archivaConfiguration = archivaConfigurationControl.createMock( ArchivaConfiguration.class );
config = new Configuration();
expect( archivaConfiguration.getConfiguration() ).andReturn( config ).times( 2, 20 );
expect( archivaConfiguration.getConfiguration() ).andReturn( config ).times( 2, 25 );
expect (archivaConfiguration.getDefaultLocale()).andReturn( Locale.getDefault() ).anyTimes();
archivaConfiguration.addListener( EasyMock.anyObject( ) );
expectLastCall().times(0, 4);

27
archiva-modules/metadata/metadata-repository-api/src/test/java/org/apache/archiva/metadata/repository/AbstractMetadataRepositoryTest.java
View File

@ -24,8 +24,19 @@ import org.apache.archiva.checksum.ChecksumAlgorithm;
import org.apache.archiva.metadata.QueryParameter;
import org.apache.archiva.metadata.generic.GenericMetadataFacet;
import org.apache.archiva.metadata.generic.GenericMetadataFacetFactory;
import org.apache.archiva.metadata.model.*;
import org.apache.archiva.test.utils.ArchivaSpringJUnit4ClassRunner;
import org.apache.archiva.metadata.model.ArtifactMetadata;
import org.apache.archiva.metadata.model.CiManagement;
import org.apache.archiva.metadata.model.Dependency;
import org.apache.archiva.metadata.model.IssueManagement;
import org.apache.archiva.metadata.model.License;
import org.apache.archiva.metadata.model.MailingList;
import org.apache.archiva.metadata.model.MetadataFacet;
import org.apache.archiva.metadata.model.MetadataFacetFactory;
import org.apache.archiva.metadata.model.Organization;
import org.apache.archiva.metadata.model.ProjectMetadata;
import org.apache.archiva.metadata.model.ProjectVersionMetadata;
import org.apache.archiva.metadata.model.ProjectVersionReference;
import org.apache.archiva.metadata.model.Scm;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
@ -36,7 +47,17 @@ import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.text.SimpleDateFormat;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.util.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.TimeZone;
import java.util.stream.Collectors;
import java.util.stream.Stream;

2
archiva-modules/metadata/metadata-store-provider/metadata-store-cassandra/pom.xml
View File

@ -31,7 +31,7 @@
<properties>
<site.staging.base>${project.parent.parent.basedir}</site.staging.base>
<cassandraVersion>3.11.10</cassandraVersion>
<cassandraVersion>3.11.11</cassandraVersion>
</properties>
<dependencies>