if (section == null) {
section = baseSection;
if (section == null) {
- section = createDefaultConfigurationFile();
+ section = createDefaultConfigurationFile(eventTag);
}
} else if (baseSection != null) {
Collection<String> keys = baseSection.getKeys();
}
}
- private Registry createDefaultConfigurationFile()
+ private Registry createDefaultConfigurationFile(String eventTag)
throws RegistryException {
// TODO: may not be needed under commons-configuration 1.4 - check
addRegistryChangeListener(regListener);
}
- triggerEvent(ConfigurationEvent.SAVED, "default-file");
+ triggerEvent(ConfigurationEvent.SAVED, eventTag==null?"default-file":eventTag);
Registry section = registry.getSection(KEY + ".user");
if (section == null) {
* @version $Revision$ $Date$
*/
@SuppressWarnings( "all" )
-public class RepositoryGroupConfiguration
+public class RepositoryGroupConfiguration extends AbstractRepositoryConfiguration
implements Serializable
{
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;
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;
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();
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;
@Inject
ArchivaConfiguration archivaConfiguration;
+ @SuppressWarnings( "unused" )
+ @Inject
+ RepositoryRegistry repositoryRegistry;
+
+ @SuppressWarnings( "unused" )
+ @Inject
+ RepositoryGroupHandler repositoryGroupHandler;
+
+ @SuppressWarnings( "unused" )
+ @Inject
+ ManagedRepositoryHandler managedRepositoryHandler;
+
+
@Before
public void setUp()
throws Exception
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;
@Inject
RepositoryGroupHandler repositoryGroupHandler;
+ @SuppressWarnings( "unused" )
+ @Inject
+ ManagedRepositoryHandler managedRepositoryHandler;
+
@Before
public void setUp()
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;
@Inject
RepositoryGroupHandler repositoryGroupHandler;
+ @SuppressWarnings( "unused" )
+ @Inject
+ ManagedRepositoryHandler managedRepositoryHandler;
+
@Override
@Before
public void setUp()
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;
@Inject
private RepositoryRegistry repositoryRegistry;
+ @Inject
+ private ManagedRepositoryHandler managedRepositoryHandler;
+
+ @Inject
+ private RepositoryGroupHandler repositoryGroupHandler;
+
@Inject
@Named(value = "archivaTaskScheduler#repository")
private RepositoryArchivaTaskScheduler repositoryTaskScheduler;
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
scanRepository( newRepo.getId(), true );
}
- if ( stagingRepo!=null && stagingRepo.isScanned() )
+ org.apache.archiva.repository.ManagedRepository stagingRepo = newRepo.getFeature( StagingRepositoryFeature.class ).get( ).getStagingRepository( );
+ if ( stagingRepo!=null)
{
- scanRepository( stagingRepo.getId(), true );
+ if (stagingRepo.isScanned()) {
+ scanRepository( stagingRepo.getId(), true );
+ }
+ addRepositoryRoles( stagingRepo.getId( ) );
}
}
catch ( Exception e )
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.");
+ if (repo.supportsFeature(StagingRepositoryFeature.class)) {
+ stagingRepository = repo.getFeature(StagingRepositoryFeature.class).get().getStagingRepository();
}
} else {
throw new RepositoryAdminException("A repository with that id does not exist");
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);
+ if (stagingRepositoryConfig != null) {
+ deleteManagedRepository(stagingRepositoryConfig, deleteContent, config, true);
}
}
}
- 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() );
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 );
}
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());
saveConfiguration( config );
+
return Boolean.TRUE;
}
getRepositoryCommonValidator().validateManagedRepository( managedRepository );
- Configuration configuration = getArchivaConfiguration().getConfiguration();
-
ManagedRepositoryConfiguration updatedRepoConfig = getRepositoryConfiguration( managedRepository );
updatedRepoConfig.setStageRepoNeeded( needStageRepo );
// 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)
}
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
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;
@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");
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;
@Inject
RepositoryGroupAdmin repositoryGroupAdmin;
- @Inject
- RepositoryRegistry repositoryRegistry;
-
- @Inject
- RepositoryGroupHandler repositoryGroupHandler;
@Test
public void addAndDeleteGroup()
* 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;
*
* @author Martin Stockhammer <martin_s@apache.org>
*/
-public interface RepositoryHandler<R extends Repository, C>
+public interface RepositoryHandler<R extends Repository, C extends AbstractRepositoryConfiguration>
{
/**
*/
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.
*
* 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.
*/
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.
*/
*/
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();
}
--- /dev/null
+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);
+
+}
* @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
*/
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;
* 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 );
+ }
+
+
}
*/
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;
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;
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;
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;
@Inject
List<MetadataReader> metadataReaderList;
+ @Inject
+ List<RepositoryValidator<? extends Repository>> repositoryValidatorList;
+
@Inject
@Named( "repositoryContentFactory#default" )
RepositoryContentFactory repositoryContentFactory;
- private final EventManager eventManager;
+ 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;
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 );
}
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 );
}
}
- 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( ) )
{
}
}
+ 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( );
*/
private void updateManagedRepositoriesFromConfig( )
{
- try
- {
-
- Set<String> configRepoIds = new HashSet<>( );
- List<ManagedRepositoryConfiguration> managedRepoConfigs =
- configurationHandler.getBaseConfiguration( ).getManagedRepositories( );
-
- if ( managedRepoConfigs == null )
- {
- return;
- }
-
- 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;
- }
+ managedRepositoryHandler.initializeFromConfig( );
}
- 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 )
}
}
- 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( )
{
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
{
rwLock.readLock( ).lock( );
try
{
- return uManagedRepository.values( );
+ return managed_initialized.get() ? managedRepositoryHandler.getAll( ) : Collections.emptyList();
}
finally
{
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 ) )
{
rwLock.readLock( ).lock( );
try
{
- return managedRepositories.get( repoId );
+ return managed_initialized.get() ? managedRepositoryHandler.get( repoId ) : null;
}
finally
{
@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
@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
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
{
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
{
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
{
rwLock.writeLock( ).lock( );
try
{
- return groupHandler.putWithCheck( repositoryGroupConfiguration, groupHandler.getValidator() );
+ return groupHandler.putWithCheck( repositoryGroupConfiguration, groupHandler.getValidator( ) );
}
finally
{
}
}
- 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 )
}
}
- 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
{
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." );
}
{
return;
}
- final String id = managedRepository.getId( );
- ManagedRepository repo = getManagedRepository( id );
- if ( repo != null )
+ rwLock.writeLock( ).lock( );
+ try
{
- 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( ) );
- }
- finally
- {
- rwLock.writeLock( ).unlock( );
- }
+ if (managed_initialized.get() ) managedRepositoryHandler.remove( managedRepository.getId( ) );
+ }
+ finally
+ {
+ rwLock.writeLock( ).unlock( );
}
}
{
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( );
}
- }
}
*/
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
*/
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 );
}
{
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( ),
{
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( ),
private void handleIndexCreationEvent( RepositoryIndexEvent event )
{
- RepositoryIndexEvent idxEvent = event;
- EditableRepository repo = (EditableRepository) idxEvent.getRepository( );
- if ( repo != null )
+ if (!ignoreIndexing && !( event.getRepository() instanceof ManagedRepository ))
{
- ArchivaIndexManager idxmgr = getIndexManager( repo.getType( ) );
- if ( repo.getIndexingContext( ) != null )
+ RepositoryIndexEvent idxEvent = event;
+ EditableRepository repo = (EditableRepository) idxEvent.getRepository( );
+ if ( repo != null )
{
- try
+ ArchivaIndexManager idxmgr = getIndexManager( repo.getType( ) );
+ if ( repo.getIndexingContext( ) != null )
{
- ArchivaIndexingContext newCtx = idxmgr.move( repo.getIndexingContext( ), repo );
- repo.setIndexingContext( newCtx );
- idxmgr.updateLocalIndexPath( repo );
+ try
+ {
+ ArchivaIndexingContext newCtx = idxmgr.move( repo.getIndexingContext( ), repo );
+ repo.setIndexingContext( newCtx );
+ idxmgr.updateLocalIndexPath( repo );
+ }
+ catch ( IndexCreationFailedException e )
+ {
+ log.error( "Could not move index to new directory: '{}'", e.getMessage( ), e );
+ }
}
- catch ( IndexCreationFailedException e )
- {
- log.error( "Could not move index to new directory: '{}'", e.getMessage( ), e );
- }
- }
- else
- {
- try
- {
- ArchivaIndexingContext context = idxmgr.createContext( repo );
- repo.setIndexingContext( context );
- idxmgr.updateLocalIndexPath( repo );
- }
- catch ( IndexCreationFailedException e )
+ else
{
- log.error( "Could not create index: '{}'", e.getMessage( ), e );
+ try
+ {
+ ArchivaIndexingContext context = idxmgr.createContext( repo );
+ repo.setIndexingContext( context );
+ idxmgr.updateLocalIndexPath( repo );
+ }
+ catch ( IndexCreationFailedException e )
+ {
+ log.error( "Could not create index: '{}'", e.getMessage( ), e );
+ }
}
}
}
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;
+ }
+
}
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;
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;
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;
{
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;
* @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
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 );
}
private void initializeStorage( )
{
- Path baseDir = this.configurationHandler.getArchivaConfiguration( ).getRepositoryGroupBaseDir( );
+ Path baseDir = this.getConfigurationHandler().getArchivaConfiguration( ).getRepositoryGroupBaseDir( );
if ( !Files.exists( baseDir ) )
{
try
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 )
try
{
List<RepositoryGroupConfiguration> repositoryGroupConfigurations =
- this.configurationHandler.getBaseConfiguration( ).getRepositoryGroups( );
+ this.getConfigurationHandler().getBaseConfiguration( ).getRepositoryGroups( );
if ( repositoryGroupConfigurations == null )
{
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
{
@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 );
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 );
}
{
( (EditableRepository) repositoryGroup ).setLastState( RepositoryState.REFERENCES_SET );
}
+ repositoryGroup.registerEventHandler( RepositoryEvent.ANY, repositoryRegistry );
return repositoryGroup;
}
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 )
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 );
}
{
configLock.unlock( );
}
- repositoryGroups.put( id, repositoryGroup );
+ getRepositories().put( id, repositoryGroup );
setLastState( repositoryGroup, RepositoryState.REGISTERED );
return repositoryGroup;
}
// 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);
{
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 )
{
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) {
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
{
}
else
{
- repo = repositoryRegistry.getProvider( repoType ).createRepositoryGroup( repositoryGroupConfiguration );
+ repo = getProvider( repoType ).createRepositoryGroup( repositoryGroupConfiguration );
setLastState( repo, RepositoryState.CREATED );
}
replaceOrAddRepositoryConfig( repositoryGroupConfiguration, configuration );
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( ) ) )
}
}
- 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 );
- }
- 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
- {
- 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;
- }
+ getRepositories().values( ).stream( ).filter( repoGroup -> repoGroup instanceof EditableRepository ).
+ map( repoGroup -> (EditableRepositoryGroup) repoGroup ).forEach( repoGroup -> repoGroup.removeRepository( (ManagedRepository) repo ) );
}
}
- @Override
- public RepositoryGroup get( String groupId )
- {
- return repositoryGroups.get( groupId );
- }
@Override
- public RepositoryGroup clone( RepositoryGroup repo ) throws RepositoryException
+ public RepositoryGroup clone( RepositoryGroup repo, String newId ) 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 );
}
@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( )
+ @PreDestroy
+ private void destroy( )
{
- return this.validator;
+ this.close( );
}
@Override
- public CheckedResult<RepositoryGroup, Map<String, List<ValidationError>>> validateRepository( RepositoryGroup repository )
+ protected RepositoryGroupConfiguration findRepositoryConfiguration( Configuration configuration, String id )
{
- return this.validator.apply( repository );
-
+ return configuration.findRepositoryGroupById( id );
}
@Override
- public CheckedResult<RepositoryGroup,Map<String, List<ValidationError>>> validateRepositoryForUpdate( RepositoryGroup repository )
+ protected void removeRepositoryConfiguration( Configuration configuration, RepositoryGroupConfiguration cfg )
{
- return this.validator.applyForUpdate( repository );
- }
- @Override
- public boolean hasRepository( String id )
- {
- return repositoryGroups.containsKey( id );
- }
-
- @PreDestroy
- private void destroy( )
- {
- this.close( );
+ configuration.removeRepositoryGroup( cfg );
}
@Override
- public void close( )
+ protected void addRepositoryConfiguration( Configuration configuration, RepositoryGroupConfiguration repoConfiguration )
{
- 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( );
+ configuration.addRepositoryGroup( repoConfiguration );
}
-
}
* 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
- public void initializeFromConfig( )
+ @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( )
{
- this.managedRepositories.clear( );
- this.managedRepositories.putAll( newInstancesFromConfig( ) );
- for ( ManagedRepository managedRepository : this.managedRepositories.values( ) )
- {
- activateRepository( managedRepository );
- }
}
@Override
- public void activateRepository( ManagedRepository repository )
+ public void initializeFromConfig( )
{
+ 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 );
+ }
}
{
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( ) );
+ ManagedRepository stagingRepo = getStagingRepository( repo );
+ if ( stagingRepo != null )
+ {
+ result.put( stagingRepo.getId( ), stagingRepo );
+ }
}
}
}
- List<String> toRemove = managedRepositories.keySet( ).stream( ).filter( id -> !configRepoIds.contains( id ) ).collect( Collectors.toList( ) );
- for ( String id : toRemove )
+ return result;
+ }
+ catch ( Throwable e )
+ {
+ log.error( "Could not initialize repositories from config: {}", e.getMessage( ), e );
+ return new HashMap<>( );
+ }
+ }
+
+ public Map<String, ManagedRepository> newOrUpdateInstancesFromConfig( Map<String, ManagedRepository> currentInstances)
+ {
+ try
+ {
+ List<ManagedRepositoryConfiguration> managedRepoConfigs =
+ new ArrayList<>(
+ getConfigurationHandler( ).getBaseConfiguration( ).getManagedRepositories( ) );
+
+ if ( managedRepoConfigs == null )
{
- ManagedRepository removed = managedRepositories.remove( id );
- removed.close( );
+ 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 managedRepositories;
+ return new HashMap<>( );
}
- return managedRepositories;
}
+
@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;
}
- @Override
- public ManagedRepository newInstance( ManagedRepositoryConfiguration repositoryConfiguration ) throws RepositoryException
+ private String getStagingId( String repoId )
{
- return null;
+ return repoId + StagingRepositoryFeature.STAGING_REPO_POSTFIX;
}
- @Override
- public ManagedRepository put( ManagedRepository repository ) throws RepositoryException
- {
- return null;
- }
- @Override
- public ManagedRepository put( ManagedRepositoryConfiguration repositoryConfiguration ) throws RepositoryException
+ private ManagedRepository getStagingRepository( ManagedRepository baseRepo ) throws RepositoryException
{
- return null;
+ 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;
}
- @Override
- public ManagedRepository put( ManagedRepositoryConfiguration repositoryConfiguration, Configuration configuration ) throws RepositoryException
+ public ArchivaIndexManager getIndexManager( RepositoryType type )
{
- return null;
+ return indexManagerFactory.getIndexManager( type );
}
- @Override
- public <D> CheckedResult<ManagedRepository, D> putWithCheck( ManagedRepositoryConfiguration repositoryConfiguration, RepositoryChecker<ManagedRepository, D> checker ) throws RepositoryException
+ private void createIndexingContext( EditableRepository editableRepo ) throws RepositoryException
{
- return null;
+ 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 void remove( String id ) throws RepositoryException
+ public ManagedRepository newInstance( ManagedRepositoryConfiguration repositoryConfiguration ) throws RepositoryException
{
-
+ 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 void remove( String id, Configuration configuration ) throws RepositoryException
+ protected ManagedRepositoryConfiguration findRepositoryConfiguration( final Configuration configuration, final String id )
{
-
+ return configuration.findManagedRepositoryById( id );
}
@Override
- public ManagedRepository get( String id )
+ protected void removeRepositoryConfiguration( final Configuration configuration, final ManagedRepositoryConfiguration repoConfiguration )
{
- return null;
+ configuration.removeManagedRepository( repoConfiguration );
}
@Override
- public ManagedRepository clone( ManagedRepository repo ) throws RepositoryException
+ protected void addRepositoryConfiguration( Configuration configuration, ManagedRepositoryConfiguration repoConfiguration )
{
- return null;
+ configuration.addManagedRepository( repoConfiguration );
}
@Override
- public void updateReferences( ManagedRepository repo, ManagedRepositoryConfiguration repositoryConfiguration ) throws RepositoryException
+ 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 Collection<ManagedRepository> getAll( )
+ public ManagedRepository put( ManagedRepositoryConfiguration managedRepositoryConfiguration ) throws RepositoryException
{
- return null;
+ 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 RepositoryValidator<ManagedRepository> getValidator( )
+ 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;
}
- @Override
- public ValidationResponse<ManagedRepository> validateRepository( ManagedRepository repository )
+ @SuppressWarnings( "unused" )
+ private void setManagedRepositoryDefaults( ManagedRepositoryConfiguration repositoryConfiguration )
{
- return null;
+ // We do nothing here
}
@Override
- public ValidationResponse<ManagedRepository> validateRepositoryForUpdate( ManagedRepository repository )
+ 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 boolean hasRepository( String id )
+ public void updateReferences( ManagedRepository repo, ManagedRepositoryConfiguration repositoryConfiguration ) throws RepositoryException
{
- return false;
+ log.debug( "Updating references of repo {}", repo.getId( ) );
+ if ( repo.supportsFeature( StagingRepositoryFeature.class ) )
+ {
+ Configuration configuration = getConfigurationHandler( ).getBaseConfiguration( );
+ RepositoryProvider provider = getProvider( repo.getType( ) );
+ StagingRepositoryFeature feature = repo.getFeature( StagingRepositoryFeature.class ).get( );
+ if ( feature.isStageRepoNeeded( ) && feature.getStagingRepository( ) == null )
+ {
+ ManagedRepository stageRepo = get( getStagingId( repo.getId( ) ) );
+ if ( stageRepo == null )
+ {
+ stageRepo = getStagingRepository( repo );
+ getRepositories( ).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, repositoryRegistry );
}
@Override
- public void init( )
+ public void close( )
{
-
+ getRepositories( ).values( ).stream( ).forEach(
+ r -> deactivateRepository( r )
+ );
}
@Override
- public void close( )
+ public void deactivateRepository( ManagedRepository repository )
{
-
+ repository.close( );
}
}
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;
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.*;
@Inject
RepositoryGroupHandler repositoryGroupHandler;
+ @Inject
+ ManagedRepositoryHandler managedRepositoryHandler;
+
private static final Path userCfg = Paths.get(System.getProperty( "user.home" ), ".m2/archiva.xml");
private static Path cfgCopy;
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
* 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;
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;
@Inject
RepositoryGroupHandler repositoryGroupHandler;
+ @Inject
+ ManagedRepositoryHandler managedRepositoryHandler;
+
Path repoBaseDir;
@AfterEach
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;
// @Named( "mergedRemoteIndexesScheduler#default" )
MergedRemoteIndexesScheduler mergedRemoteIndexesScheduler;
- @Inject
- List<RepositoryValidator<? extends Repository>> repositoryValidatorList;
+ @Mock
+ RepositoryHandler<ManagedRepository, ManagedRepositoryConfiguration> managedRepositoryHandler;
@Inject
ArchivaConfiguration archivaConfiguration;
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;
}
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
@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( ) );
}
--- /dev/null
+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 );
+ }
+ }
+
+}
\ No newline at end of file
--- /dev/null
+<?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>
--- /dev/null
+<?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>
\ No newline at end of file
<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>
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;
@Inject
ArchivaRepositoryRegistry repositoryRegistry;
+ @SuppressWarnings( "unused" )
+ @Inject
+ ManagedRepositoryHandler managedRepositoryHandler;
+
+ @SuppressWarnings( "unused" )
@Inject
RepositoryGroupHandler groupHandler;
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;
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;
@Inject
ArchivaRepositoryRegistry repositoryRegistry;
+ @SuppressWarnings( "unused" )
@Inject
- RepositoryGroupHandler repositoryGroupHandler;
+ ManagedRepositoryHandler managedRepositoryHandler;
+
+ @SuppressWarnings( "unused" )
+ @Inject
+ RepositoryGroupHandler groupHandler;
+
@Inject
ProxyRegistry proxyRegistry;
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();
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();
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) )
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));
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);
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;
@Inject
ArchivaRepositoryRegistry repositoryRegistry;
+ @SuppressWarnings( "unused" )
@Inject
- RepositoryGroupHandler repositoryGroupHandler;
+ ManagedRepositoryHandler managedRepositoryHandler;
+
+ @SuppressWarnings( "unused" )
+ @Inject
+ RepositoryGroupHandler groupHandler;
+
@After
@Override
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;
@Inject
ArchivaRepositoryRegistry repositoryRegistry;
+ @SuppressWarnings( "unused" )
@Inject
- RepositoryGroupHandler repositoryGroupHandler;
+ ManagedRepositoryHandler managedRepositoryHandler;
+
+ @SuppressWarnings( "unused" )
+ @Inject
+ RepositoryGroupHandler groupHandler;
+
@After
public void endTests() {
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;
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(),
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;
@Inject
RepositoryRegistry repositoryRegistry;
+ @SuppressWarnings( "unused" )
+ @Inject
+ ManagedRepositoryHandler managedRepositoryHandler;
+
+
protected static final String ID_PROXIED1 = "proxied1";
protected static final String ID_PROXIED1_TARGET = "proxied1-target";
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;
@Inject
UrlFailureCache urlFailureCache;
+
@Test
public void testGetWithCacheFailuresOn( )
throws Exception
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;
@Inject
private ProxyRegistry proxyRegistry;
+ @SuppressWarnings( "unused" )
+ @Inject
+ ManagedRepositoryHandler managedRepositoryHandler;
+
+
private Server server;
protected ManagedRepositoryContent createRepository( String id, String name, String path, String layout )
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);
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;
@Inject
RepositoryRegistry repositoryRegistry;
+ @SuppressWarnings( "unused" )
+ @Inject
+ ManagedRepositoryHandler managedRepositoryHandler;
+
+
private WagonFactory wagonFactory;
ManagedRepositoryConfiguration testRepo;
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;
@Inject
RepositoryRegistry repositoryRegistry;
+ @SuppressWarnings( "unused" )
+ @Inject
+ ManagedRepositoryHandler managedRepositoryHandler;
+
+
private WagonFactory wagonFactory;
ManagedRepositoryConfiguration testRepo;
wagonFactory = mock( WagonFactory.class );
+ assertNotNull( storage );
storage.setWagonFactory( wagonFactory );
Wagon wagon = new MockWagon();
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",
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" );
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" );
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;
@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";
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;
@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";
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;
@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";
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;
@Inject
ArchivaRepositoryRegistry repositoryRegistry;
+ @SuppressWarnings( "unused" )
+ @Inject
+ ManagedRepositoryHandler managedRepositoryHandler;
+
+ @SuppressWarnings( "unused" )
@Inject
RepositoryGroupHandler repositoryGroupHandler;
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;
@Inject
RepositoryRegistry repositoryRegistry;
+ @SuppressWarnings( "unused" )
+ @Inject
+ ManagedRepositoryHandler managedRepositoryHandler;
+
+ @SuppressWarnings( "unused" )
+ @Inject
+ RepositoryGroupHandler repositoryGroupHandler;
+
+
@Inject
RepositoryProvider repositoryProvider;
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;
@Inject
RepositoryRegistry repositoryRegistry;
+ @SuppressWarnings( "unused" )
+ @Inject
+ ManagedRepositoryHandler managedRepositoryHandler;
+
+ @SuppressWarnings( "unused" )
@Inject
RepositoryGroupHandler groupHandler;
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;
@Inject
RepositoryGroupHandler repositoryGroupHandler;
+ @SuppressWarnings( "unused" )
+ @Inject
+ ManagedRepositoryHandler managedRepositoryHandler;
+
@Inject
ArchivaRepositoryRegistry repositoryRegistry;
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" );
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();
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;
}
protected void setupCleanRepo( Path repoRootDir )
throws IOException
{
- org.apache.archiva.common.utils.FileUtils.deleteDirectory( repoRootDir );
- if ( !Files.exists(repoRootDir) )
+ if (repoRootDir!=null)
{
- Files.createDirectories( repoRootDir );
+ org.apache.archiva.common.utils.FileUtils.deleteDirectory( repoRootDir );
+ if ( !Files.exists( repoRootDir ) )
+ {
+ Files.createDirectories( repoRootDir );
+ }
}
}
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;
@Inject
RepositoryGroupHandler repositoryGroupHandler;
+ @SuppressWarnings( "unused" )
+ @Inject
+ ManagedRepositoryHandler managedRepositoryHandler;
+
public Path getProjectBase() {
if (this.projectBase.get()==null) {
String pathVal = System.getProperty("mvn.project.base.dir");
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);
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;
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;
<properties>
<site.staging.base>${project.parent.parent.basedir}</site.staging.base>
- <cassandraVersion>3.11.10</cassandraVersion>
+ <cassandraVersion>3.11.11</cassandraVersion>
</properties>
<dependencies>
projects / archiva.git / commitdiff