package org.apache.archiva.admin.repository.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.admin.model.AuditInformation;
import org.apache.archiva.admin.model.RepositoryAdminException;
import org.apache.archiva.admin.model.beans.ManagedRepository;
import org.apache.archiva.admin.model.managed.ManagedRepositoryAdmin;
import org.apache.archiva.admin.repository.AbstractRepositoryAdmin;
import org.apache.archiva.common.plexusbridge.MavenIndexerUtils;
import org.apache.archiva.common.plexusbridge.PlexusSisuBridge;
import org.apache.archiva.common.plexusbridge.PlexusSisuBridgeException;
import org.apache.archiva.configuration.Configuration;
import org.apache.archiva.configuration.ManagedRepositoryConfiguration;
import org.apache.archiva.configuration.ProxyConnectorConfiguration;
import org.apache.archiva.configuration.RepositoryGroupConfiguration;
import org.apache.archiva.metadata.model.facets.AuditEvent;
import org.apache.archiva.metadata.repository.MetadataRepository;
import org.apache.archiva.metadata.repository.MetadataRepositoryException;
import org.apache.archiva.metadata.repository.RepositorySession;
import org.apache.archiva.metadata.repository.RepositorySessionFactory;
import org.apache.archiva.metadata.repository.stats.RepositoryStatisticsManager;
import org.apache.archiva.redback.components.cache.Cache;
import org.apache.archiva.redback.components.taskqueue.TaskQueueException;
import org.apache.archiva.redback.role.RoleManager;
import org.apache.archiva.redback.role.RoleManagerException;
import org.apache.archiva.scheduler.repository.model.RepositoryArchivaTaskScheduler;
import org.apache.archiva.scheduler.repository.model.RepositoryTask;
import org.apache.archiva.security.common.ArchivaRoleConstants;
import org.apache.commons.io.FileUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.maven.index.NexusIndexer;
import org.apache.maven.index.context.IndexCreator;
import org.apache.maven.index.context.IndexingContext;
import org.apache.maven.index.context.UnsupportedExistingLuceneIndexException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Named;
import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* FIXME review the staging mechanism to have a per user session one
*
* @author Olivier Lamy
*/
@Service("managedRepositoryAdmin#default")
public class DefaultManagedRepositoryAdmin
extends AbstractRepositoryAdmin
implements ManagedRepositoryAdmin
{
private Logger log = LoggerFactory.getLogger( getClass() );
public static final String STAGE_REPO_ID_END = "-stage";
@Inject
@Named(value = "archivaTaskScheduler#repository")
private RepositoryArchivaTaskScheduler repositoryTaskScheduler;
/**
* FIXME: this could be multiple implementations and needs to be configured.
*/
@Inject
private RepositorySessionFactory repositorySessionFactory;
@Inject
private RepositoryStatisticsManager repositoryStatisticsManager;
@Inject
private PlexusSisuBridge plexusSisuBridge;
@Inject
private MavenIndexerUtils mavenIndexerUtils;
@Inject
protected RoleManager roleManager;
@Inject
@Named(value = "cache#namespaces")
private Cache<String, Collection<String>> namespacesCache;
// fields
List<? extends IndexCreator> indexCreators;
NexusIndexer indexer;
@PostConstruct
public void initialize()
throws RepositoryAdminException, RoleManagerException
{
try
{
indexCreators = mavenIndexerUtils.getAllIndexCreators();
indexer = plexusSisuBridge.lookup( NexusIndexer.class );
}
catch ( PlexusSisuBridgeException e )
{
throw new RepositoryAdminException( e.getMessage(), e );
}
// initialize index context on start and check roles here
for ( ManagedRepository managedRepository : getManagedRepositories() )
{
createIndexContext( managedRepository );
addRepositoryRoles( managedRepository.getId() );
}
}
@PreDestroy
public void shutdown()
throws RepositoryAdminException
{
try
{
// close index on shutdown
for ( ManagedRepository managedRepository : getManagedRepositories() )
{
IndexingContext context = indexer.getIndexingContexts().get( managedRepository.getId() );
if ( context != null )
{
indexer.removeIndexingContext( context, false );
}
}
}
catch ( IOException e )
{
throw new RepositoryAdminException( e.getMessage(), e );
}
}
@Override
public List<ManagedRepository> getManagedRepositories()
throws RepositoryAdminException
{
List<ManagedRepositoryConfiguration> managedRepoConfigs =
getArchivaConfiguration().getConfiguration().getManagedRepositories();
if ( managedRepoConfigs == null )
{
return Collections.emptyList();
}
List<ManagedRepository> managedRepos = new ArrayList<ManagedRepository>( managedRepoConfigs.size() );
for ( ManagedRepositoryConfiguration repoConfig : managedRepoConfigs )
{
ManagedRepository repo =
new ManagedRepository( repoConfig.getId(), repoConfig.getName(), repoConfig.getLocation(),
repoConfig.getLayout(), repoConfig.isSnapshots(), repoConfig.isReleases(),
repoConfig.isBlockRedeployments(), repoConfig.getRefreshCronExpression(),
repoConfig.getIndexDir(), repoConfig.isScanned(), repoConfig.getDaysOlder(),
repoConfig.getRetentionCount(), repoConfig.isDeleteReleasedSnapshots(),
repoConfig.isStageRepoNeeded() );
repo.setDescription( repoConfig.getDescription() );
repo.setSkipPackedIndexCreation( repoConfig.isSkipPackedIndexCreation() );
managedRepos.add( repo );
}
return managedRepos;
}
@Override
public Map<String, ManagedRepository> getManagedRepositoriesAsMap()
throws RepositoryAdminException
{
List<ManagedRepository> managedRepositories = getManagedRepositories();
Map<String, ManagedRepository> repositoriesMap = new HashMap<>( managedRepositories.size() );
for ( ManagedRepository managedRepository : managedRepositories )
{
repositoriesMap.put( managedRepository.getId(), managedRepository );
}
return repositoriesMap;
}
@Override
public ManagedRepository getManagedRepository( String repositoryId )
throws RepositoryAdminException
{
List<ManagedRepository> repos = getManagedRepositories();
for ( ManagedRepository repo : repos )
{
if ( StringUtils.equals( repo.getId(), repositoryId ) )
{
return repo;
}
}
return null;
}
@Override
public Boolean addManagedRepository( ManagedRepository managedRepository, boolean needStageRepo,
AuditInformation auditInformation )
throws RepositoryAdminException
{
getRepositoryCommonValidator().basicValidation( managedRepository, false );
getRepositoryCommonValidator().validateManagedRepository( managedRepository );
triggerAuditEvent( managedRepository.getId(), null, AuditEvent.ADD_MANAGED_REPO, auditInformation );
Boolean res =
addManagedRepository( managedRepository.getId(), managedRepository.getLayout(), managedRepository.getName(),
managedRepository.getLocation(), managedRepository.isBlockRedeployments(),
managedRepository.isReleases(), managedRepository.isSnapshots(), needStageRepo,
managedRepository.getCronExpression(), managedRepository.getIndexDirectory(),
managedRepository.getDaysOlder(), managedRepository.getRetentionCount(),
managedRepository.isDeleteReleasedSnapshots(), managedRepository.getDescription(),
managedRepository.isSkipPackedIndexCreation(), managedRepository.isScanned(),
auditInformation, getArchivaConfiguration().getConfiguration() ) != null;
createIndexContext( managedRepository );
return res;
}
private ManagedRepositoryConfiguration addManagedRepository( String repoId, String layout, String name,
String location, boolean blockRedeployments,
boolean releasesIncluded, boolean snapshotsIncluded,
boolean stageRepoNeeded, String cronExpression,
String indexDir, int daysOlder, int retentionCount,
boolean deteleReleasedSnapshots, String description,
boolean skipPackedIndexCreation, boolean scanned,
AuditInformation auditInformation,
Configuration config )
throws RepositoryAdminException
{
ManagedRepositoryConfiguration repository = new ManagedRepositoryConfiguration();
repository.setId( repoId );
repository.setBlockRedeployments( blockRedeployments );
repository.setReleases( releasesIncluded );
repository.setSnapshots( snapshotsIncluded );
repository.setScanned( scanned );
repository.setName( name );
repository.setLocation( getRepositoryCommonValidator().removeExpressions( location ) );
repository.setLayout( layout );
repository.setRefreshCronExpression( cronExpression );
repository.setIndexDir( indexDir );
repository.setDaysOlder( daysOlder );
repository.setRetentionCount( retentionCount );
repository.setDeleteReleasedSnapshots( deteleReleasedSnapshots );
repository.setIndexDir( indexDir );
repository.setDescription( description );
repository.setSkipPackedIndexCreation( skipPackedIndexCreation );
repository.setStageRepoNeeded( stageRepoNeeded );
try
{
addRepository( repository, config );
addRepositoryRoles( repository.getId() );
if ( stageRepoNeeded )
{
ManagedRepositoryConfiguration stagingRepository = getStageRepoConfig( repository );
addRepository( stagingRepository, config );
addRepositoryRoles( stagingRepository.getId() );
triggerAuditEvent( stagingRepository.getId(), null, AuditEvent.ADD_MANAGED_REPO, auditInformation );
}
}
catch ( RoleManagerException e )
{
throw new RepositoryAdminException( "failed to add repository roles " + e.getMessage(), e );
}
catch ( IOException e )
{
throw new RepositoryAdminException( "failed to add repository " + e.getMessage(), e );
}
saveConfiguration( config );
//MRM-1342 Repository statistics report doesn't appear to be working correctly
//scan repository when adding of repository is successful
try
{
if ( scanned )
{
scanRepository( repoId, true );
}
// TODO need a better to define scanning or not for staged repo
if ( stageRepoNeeded && scanned )
{
ManagedRepositoryConfiguration stagingRepository = getStageRepoConfig( repository );
scanRepository( stagingRepository.getId(), true );
}
}
catch ( Exception e )
{
log.warn( new StringBuilder( "Unable to scan repository [" ).append( repoId ).append( "]: " ).append(
e.getMessage() ).toString(), e );
}
return repository;
}
@Override
public Boolean deleteManagedRepository( String repositoryId, AuditInformation auditInformation,
boolean deleteContent )
throws RepositoryAdminException
{
Configuration config = getArchivaConfiguration().getConfiguration();
ManagedRepositoryConfiguration repository = config.findManagedRepositoryById( repositoryId );
if ( repository == null )
{
throw new RepositoryAdminException( "A repository with that id does not exist" );
}
triggerAuditEvent( repositoryId, null, AuditEvent.DELETE_MANAGED_REPO, auditInformation );
deleteManagedRepository( repository, deleteContent, config, false );
// stage repo exists ?
ManagedRepositoryConfiguration stagingRepository =
getArchivaConfiguration().getConfiguration().findManagedRepositoryById( repositoryId + STAGE_REPO_ID_END );
if ( stagingRepository != null )
{
// do not trigger event when deleting the staged one
deleteManagedRepository( stagingRepository, deleteContent, config, true );
}
try
{
saveConfiguration( config );
}
catch ( Exception e )
{
throw new RepositoryAdminException( "Error saving configuration for delete action" + e.getMessage(), e );
}
return Boolean.TRUE;
}
private Boolean deleteManagedRepository( ManagedRepositoryConfiguration repository, boolean deleteContent,
Configuration config, boolean stagedOne )
throws RepositoryAdminException
{
try
{
NexusIndexer nexusIndexer = plexusSisuBridge.lookup( NexusIndexer.class );
IndexingContext context = nexusIndexer.getIndexingContexts().get( repository.getId() );
if ( context != null )
{
// delete content only if directory exists
nexusIndexer.removeIndexingContext( context,
deleteContent && context.getIndexDirectoryFile().exists() );
}
}
catch ( PlexusSisuBridgeException e )
{
throw new RepositoryAdminException( e.getMessage(), e );
}
catch ( IOException e )
{
throw new RepositoryAdminException( e.getMessage(), e );
}
if ( !stagedOne )
{
RepositorySession repositorySession = getRepositorySessionFactory().createSession();
try
{
MetadataRepository metadataRepository = repositorySession.getRepository();
metadataRepository.removeRepository( repository.getId() );
//invalidate cache
namespacesCache.remove( repository.getId() );
log.debug( "call repositoryStatisticsManager.deleteStatistics" );
getRepositoryStatisticsManager().deleteStatistics( metadataRepository, repository.getId() );
repositorySession.save();
}
catch ( MetadataRepositoryException e )
{
//throw new RepositoryAdminException( e.getMessage(), e );
log.warn( "skip error during removing repository from MetadataRepository:{}", e.getMessage(), e );
}
finally
{
repositorySession.close();
}
}
config.removeManagedRepository( repository );
if ( deleteContent )
{
// TODO could be async ? as directory can be huge
File dir = new File( repository.getLocation() );
if ( !FileUtils.deleteQuietly( dir ) )
{
throw new RepositoryAdminException( "Cannot delete repository " + dir );
}
}
// olamy: copy list for reading as a unit test in webapp fail with ConcurrentModificationException
List<ProxyConnectorConfiguration> proxyConnectors = new ArrayList<>( config.getProxyConnectors() );
for ( ProxyConnectorConfiguration proxyConnector : proxyConnectors )
{
if ( StringUtils.equals( proxyConnector.getSourceRepoId(), repository.getId() ) )
{
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 );
}
catch ( RoleManagerException e )
{
throw new RepositoryAdminException(
"fail to remove repository roles for repository " + repository.getId() + " : " + e.getMessage(), e );
}
saveConfiguration( config );
return Boolean.TRUE;
}
@Override
public Boolean updateManagedRepository( ManagedRepository managedRepository, boolean needStageRepo,
AuditInformation auditInformation, boolean resetStats )
throws RepositoryAdminException
{
log.debug( "updateManagedConfiguration repo {} needStage {} resetStats {} ", managedRepository, needStageRepo,
resetStats );
// Ensure that the fields are valid.
getRepositoryCommonValidator().basicValidation( managedRepository, true );
getRepositoryCommonValidator().validateManagedRepository( managedRepository );
Configuration configuration = getArchivaConfiguration().getConfiguration();
ManagedRepositoryConfiguration toremove = configuration.findManagedRepositoryById( managedRepository.getId() );
boolean updateIndexContext = false;
if ( toremove != null )
{
configuration.removeManagedRepository( toremove );
updateIndexContext = !StringUtils.equals( toremove.getIndexDir(), managedRepository.getIndexDirectory() );
}
ManagedRepositoryConfiguration stagingRepository = getStageRepoConfig( toremove );
// TODO remove content from old if path has changed !!!!!
if ( stagingRepository != null )
{
configuration.removeManagedRepository( stagingRepository );
}
ManagedRepositoryConfiguration managedRepositoryConfiguration =
addManagedRepository( managedRepository.getId(), managedRepository.getLayout(), managedRepository.getName(),
managedRepository.getLocation(), managedRepository.isBlockRedeployments(),
managedRepository.isReleases(), managedRepository.isSnapshots(), needStageRepo,
managedRepository.getCronExpression(), managedRepository.getIndexDirectory(),
managedRepository.getDaysOlder(), managedRepository.getRetentionCount(),
managedRepository.isDeleteReleasedSnapshots(), managedRepository.getDescription(),
managedRepository.isSkipPackedIndexCreation(), managedRepository.isScanned(),
auditInformation, getArchivaConfiguration().getConfiguration() );
// Save the repository configuration.
RepositorySession repositorySession = getRepositorySessionFactory().createSession();
try
{
triggerAuditEvent( managedRepositoryConfiguration.getId(), null, AuditEvent.MODIFY_MANAGED_REPO,
auditInformation );
saveConfiguration( this.getArchivaConfiguration().getConfiguration() );
if ( resetStats )
{
log.debug( "call repositoryStatisticsManager.deleteStatistics" );
getRepositoryStatisticsManager().deleteStatistics( repositorySession.getRepository(),
managedRepositoryConfiguration.getId() );
repositorySession.save();
}
}
catch ( MetadataRepositoryException e )
{
throw new RepositoryAdminException( e.getMessage(), e );
}
finally
{
repositorySession.close();
}
if ( updateIndexContext )
{
try
{
IndexingContext indexingContext = indexer.getIndexingContexts().get( managedRepository.getId() );
if ( indexingContext != null )
{
indexer.removeIndexingContext( indexingContext, true );
}
// delete directory too as only content is deleted
File indexDirectory = indexingContext.getIndexDirectoryFile();
FileUtils.deleteDirectory( indexDirectory );
createIndexContext( managedRepository );
}
catch ( IOException e )
{
throw new RepositoryAdminException( e.getMessage(), e );
}
}
return true;
}
//--------------------------
// utils methods
//--------------------------
protected void addRepository( ManagedRepositoryConfiguration repository, Configuration configuration )
throws RepositoryAdminException, IOException
{
// Normalize the path
File file = new File( repository.getLocation() );
if ( !file.isAbsolute() )
{
// add appserver.base/repositories
file = new File( getRegistry().getString( "appserver.base" ) + File.separatorChar + "repositories",
repository.getLocation() );
}
repository.setLocation( file.getCanonicalPath() );
if ( !file.exists() )
{
file.mkdirs();
}
if ( !file.exists() || !file.isDirectory() )
{
throw new RepositoryAdminException(
"Unable to add repository - no write access, can not create the root directory: " + file );
}
configuration.addManagedRepository( repository );
}
@Override
public IndexingContext createIndexContext( ManagedRepository repository )
throws RepositoryAdminException
{
IndexingContext context = indexer.getIndexingContexts().get( repository.getId() );
if ( context != null )
{
log.debug( "skip creating repository indexingContent with id {} as already exists", repository.getId() );
return context;
}
// take care first about repository location as can be relative
File repositoryDirectory = new File( repository.getLocation() );
if ( !repositoryDirectory.isAbsolute() )
{
repositoryDirectory =
new File( getRegistry().getString( "appserver.base" ) + File.separatorChar + "repositories",
repository.getLocation() );
}
if ( !repositoryDirectory.exists() )
{
repositoryDirectory.mkdirs();
}
try
{
String indexDir = repository.getIndexDirectory();
//File managedRepository = new File( repository.getLocation() );
File indexDirectory = null;
if ( StringUtils.isNotBlank( indexDir ) )
{
indexDirectory = new File( repository.getIndexDirectory() );
// not absolute so create it in repository directory
if ( !indexDirectory.isAbsolute() )
{
indexDirectory = new File( repositoryDirectory, repository.getIndexDirectory() );
}
repository.setIndexDirectory( indexDirectory.getAbsolutePath() );
}
else
{
indexDirectory = new File( repositoryDirectory, ".indexer" );
if ( !repositoryDirectory.isAbsolute() )
{
indexDirectory = new File( repositoryDirectory, ".indexer" );
}
repository.setIndexDirectory( indexDirectory.getAbsolutePath() );
}
if ( !indexDirectory.exists() )
{
indexDirectory.mkdirs();
}
context = indexer.getIndexingContexts().get( repository.getId() );
if ( context == null )
{
context = indexer.addIndexingContext( repository.getId(), repository.getId(), repositoryDirectory,
indexDirectory,
repositoryDirectory.toURI().toURL().toExternalForm(),
indexDirectory.toURI().toURL().toString(), indexCreators );
context.setSearchable( repository.isScanned() );
}
return context;
}
catch ( MalformedURLException e )
{
throw new RepositoryAdminException( e.getMessage(), e );
}
catch ( IOException e )
{
throw new RepositoryAdminException( e.getMessage(), e );
}
catch ( UnsupportedExistingLuceneIndexException e )
{
throw new RepositoryAdminException( e.getMessage(), e );
}
}
private ManagedRepositoryConfiguration getStageRepoConfig( ManagedRepositoryConfiguration repository )
{
ManagedRepositoryConfiguration stagingRepository = new ManagedRepositoryConfiguration();
stagingRepository.setId( repository.getId() + STAGE_REPO_ID_END );
stagingRepository.setLayout( repository.getLayout() );
stagingRepository.setName( repository.getName() + STAGE_REPO_ID_END );
stagingRepository.setBlockRedeployments( repository.isBlockRedeployments() );
stagingRepository.setDaysOlder( repository.getDaysOlder() );
stagingRepository.setDeleteReleasedSnapshots( repository.isDeleteReleasedSnapshots() );
String path = repository.getLocation();
int lastIndex = path.replace( '\\', '/' ).lastIndexOf( '/' );
stagingRepository.setLocation( path.substring( 0, lastIndex ) + "/" + stagingRepository.getId() );
if ( StringUtils.isNotBlank( repository.getIndexDir() ) )
{
File indexDir = new File( repository.getIndexDir() );
// in case of absolute dir do not use the same
if ( indexDir.isAbsolute() )
{
stagingRepository.setIndexDir( stagingRepository.getLocation() + "/.index" );
}
else
{
stagingRepository.setIndexDir( repository.getIndexDir() );
}
}
stagingRepository.setRefreshCronExpression( repository.getRefreshCronExpression() );
stagingRepository.setReleases( repository.isReleases() );
stagingRepository.setRetentionCount( repository.getRetentionCount() );
stagingRepository.setScanned( repository.isScanned() );
stagingRepository.setSnapshots( repository.isSnapshots() );
stagingRepository.setSkipPackedIndexCreation( repository.isSkipPackedIndexCreation() );
// do not duplicate description
//stagingRepository.getDescription("")
return stagingRepository;
}
public Boolean scanRepository( String repositoryId, boolean fullScan )
{
if ( getRepositoryTaskScheduler().isProcessingRepositoryTask( repositoryId ) )
{
log.info( "scanning of repository with id {} already scheduled", repositoryId );
}
RepositoryTask task = new RepositoryTask();
task.setRepositoryId( repositoryId );
task.setScanAll( fullScan );
try
{
getRepositoryTaskScheduler().queueTask( task );
}
catch ( TaskQueueException e )
{
log.error( "failed to schedule scanning of repo with id {}", repositoryId, e );
return false;
}
return true;
}
private void addRepositoryRoles( String repoId )
throws RoleManagerException
{
// TODO: double check these are configured on start up
// TODO: belongs in the business logic
if ( !getRoleManager().templatedRoleExists( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, repoId ) )
{
getRoleManager().createTemplatedRole( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, repoId );
}
if ( !getRoleManager().templatedRoleExists( ArchivaRoleConstants.TEMPLATE_REPOSITORY_MANAGER, repoId ) )
{
getRoleManager().createTemplatedRole( ArchivaRoleConstants.TEMPLATE_REPOSITORY_MANAGER, repoId );
}
}
protected void removeRepositoryRoles( ManagedRepositoryConfiguration existingRepository )
throws RoleManagerException
{
String repoId = existingRepository.getId();
if ( getRoleManager().templatedRoleExists( ArchivaRoleConstants.TEMPLATE_REPOSITORY_MANAGER, repoId ) )
{
getRoleManager().removeTemplatedRole( ArchivaRoleConstants.TEMPLATE_REPOSITORY_MANAGER, repoId );
}
if ( getRoleManager().templatedRoleExists( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, repoId ) )
{
getRoleManager().removeTemplatedRole( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, repoId );
}
log.debug( "removed user roles associated with repository {}", repoId );
}
//--------------------------
// setters/getters
//--------------------------
public RoleManager getRoleManager()
{
return roleManager;
}
public void setRoleManager( RoleManager roleManager )
{
this.roleManager = roleManager;
}
public RepositoryStatisticsManager getRepositoryStatisticsManager()
{
return repositoryStatisticsManager;
}
public void setRepositoryStatisticsManager( RepositoryStatisticsManager repositoryStatisticsManager )
{
this.repositoryStatisticsManager = repositoryStatisticsManager;
}
public RepositorySessionFactory getRepositorySessionFactory()
{
return repositorySessionFactory;
}
public void setRepositorySessionFactory( RepositorySessionFactory repositorySessionFactory )
{
this.repositorySessionFactory = repositorySessionFactory;
}
public RepositoryArchivaTaskScheduler getRepositoryTaskScheduler()
{
return repositoryTaskScheduler;
}
public void setRepositoryTaskScheduler( RepositoryArchivaTaskScheduler repositoryTaskScheduler )
{
this.repositoryTaskScheduler = repositoryTaskScheduler;
}
public PlexusSisuBridge getPlexusSisuBridge()
{
return plexusSisuBridge;
}
public void setPlexusSisuBridge( PlexusSisuBridge plexusSisuBridge )
{
this.plexusSisuBridge = plexusSisuBridge;
}
public MavenIndexerUtils getMavenIndexerUtils()
{
return mavenIndexerUtils;
}
public void setMavenIndexerUtils( MavenIndexerUtils mavenIndexerUtils )
{
this.mavenIndexerUtils = mavenIndexerUtils;
}
public NexusIndexer getIndexer()
{
return indexer;
}
public void setIndexer( NexusIndexer indexer )
{
this.indexer = indexer;
}
public List<? extends IndexCreator> getIndexCreators()
{
return indexCreators;
}
public void setIndexCreators( List<? extends IndexCreator> indexCreators )
{
this.indexCreators = indexCreators;
}
}