package org.apache.archiva.web.xmlrpc.services;
/*
* 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.admin.ArchivaAdministration;
import org.apache.archiva.admin.model.beans.ProxyConnector;
import org.apache.archiva.admin.model.group.RepositoryGroupAdmin;
import org.apache.archiva.admin.model.managed.ManagedRepositoryAdmin;
import org.apache.archiva.admin.model.proxyconnector.ProxyConnectorAdmin;
import org.apache.archiva.admin.model.remote.RemoteRepositoryAdmin;
import org.apache.archiva.audit.AuditEvent;
import org.apache.archiva.audit.AuditListener;
import org.apache.archiva.metadata.model.ArtifactMetadata;
import org.apache.archiva.metadata.repository.MetadataRepository;
import org.apache.archiva.metadata.repository.RepositorySession;
import org.apache.archiva.metadata.repository.RepositorySessionFactory;
import org.apache.archiva.metadata.repository.filter.Filter;
import org.apache.archiva.metadata.repository.filter.IncludesFilter;
import org.apache.archiva.metadata.repository.stats.RepositoryStatisticsManager;
import org.apache.archiva.repository.events.RepositoryListener;
import org.apache.archiva.repository.scanner.RepositoryContentConsumers;
import org.apache.archiva.scheduler.repository.RepositoryArchivaTaskScheduler;
import org.apache.archiva.scheduler.repository.RepositoryTask;
import org.apache.archiva.stagerepository.merge.RepositoryMerger;
import org.apache.archiva.web.xmlrpc.api.AdministrationService;
import org.apache.archiva.web.xmlrpc.api.beans.ManagedRepository;
import org.apache.archiva.web.xmlrpc.api.beans.RemoteRepository;
import org.apache.commons.io.FileUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.archiva.consumers.InvalidRepositoryContentConsumer;
import org.apache.archiva.consumers.KnownRepositoryContentConsumer;
import org.apache.archiva.model.VersionedReference;
import org.apache.archiva.repository.ContentNotFoundException;
import org.apache.archiva.repository.ManagedRepositoryContent;
import org.apache.archiva.repository.RepositoryContentFactory;
import org.apache.archiva.repository.RepositoryException;
import org.apache.archiva.repository.RepositoryNotFoundException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Map;
/**
* AdministrationServiceImpl
*
* @version $Id: AdministrationServiceImpl.java
*/
public class AdministrationServiceImpl
implements AdministrationService
{
protected Logger log = LoggerFactory.getLogger( getClass() );
private RepositoryContentConsumers repoConsumersUtil;
private RepositoryContentFactory repoFactory;
private RepositoryArchivaTaskScheduler repositoryTaskScheduler;
private Collection<RepositoryListener> listeners;
private RepositoryStatisticsManager repositoryStatisticsManager;
private RepositoryMerger repositoryMerger;
private static final String STAGE = "-stage";
private AuditListener auditListener;
private RepositorySessionFactory repositorySessionFactory;
private ManagedRepositoryAdmin managedRepositoryAdmin;
private RemoteRepositoryAdmin remoteRepositoryAdmin;
private ArchivaAdministration archivaAdministration;
private ProxyConnectorAdmin proxyConnectorAdmin;
private RepositoryGroupAdmin repositoryGroupAdmin;
private static final String REPOSITORY_ID_VALID_EXPRESSION = "^[a-zA-Z0-9._-]+$";
private static final String REPOSITORY_NAME_VALID_EXPRESSION = "^([a-zA-Z0-9.)/_(-]|\\s)+$";
private static final String REPOSITORY_LOCATION_VALID_EXPRESSION = "^[-a-zA-Z0-9._/~:?!&=\\\\]+$";
public AdministrationServiceImpl( ArchivaAdministration archivaAdministration,
RepositoryContentConsumers repoConsumersUtil,
RepositoryContentFactory repoFactory,
RepositorySessionFactory repositorySessionFactory,
RepositoryArchivaTaskScheduler repositoryTaskScheduler,
Collection<RepositoryListener> listeners,
RepositoryStatisticsManager repositoryStatisticsManager,
RepositoryMerger repositoryMerger, AuditListener auditListener,
ManagedRepositoryAdmin managedRepositoryAdmin,
RemoteRepositoryAdmin remoteRepositoryAdmin,
ProxyConnectorAdmin proxyConnectorAdmin,
RepositoryGroupAdmin repositoryGroupAdmin )
{
this.repoConsumersUtil = repoConsumersUtil;
this.repoFactory = repoFactory;
this.repositoryTaskScheduler = repositoryTaskScheduler;
this.listeners = listeners;
this.repositorySessionFactory = repositorySessionFactory;
this.repositoryStatisticsManager = repositoryStatisticsManager;
this.repositoryMerger = repositoryMerger;
this.auditListener = auditListener;
this.managedRepositoryAdmin = managedRepositoryAdmin;
this.remoteRepositoryAdmin = remoteRepositoryAdmin;
this.archivaAdministration = archivaAdministration;
this.proxyConnectorAdmin = proxyConnectorAdmin;
this.repositoryGroupAdmin = repositoryGroupAdmin;
}
/**
* @see AdministrationService#configureRepositoryConsumer(String, String, boolean)
*/
public Boolean configureRepositoryConsumer( String repoId, String consumerId, boolean enable )
throws Exception
{
// TODO use repoId once consumers are configured per repository! (MRM-930)
List<KnownRepositoryContentConsumer> knownConsumers = repoConsumersUtil.getAvailableKnownConsumers();
List<InvalidRepositoryContentConsumer> invalidConsumers = repoConsumersUtil.getAvailableInvalidConsumers();
boolean found = false;
boolean isKnownContentConsumer = false;
for ( KnownRepositoryContentConsumer consumer : knownConsumers )
{
if ( consumer.getId().equals( consumerId ) )
{
found = true;
isKnownContentConsumer = true;
break;
}
}
if ( !found )
{
for ( InvalidRepositoryContentConsumer consumer : invalidConsumers )
{
if ( consumer.getId().equals( consumerId ) )
{
found = true;
break;
}
}
}
if ( !found )
{
throw new Exception( "Invalid repository consumer." );
}
if ( isKnownContentConsumer )
{
if ( enable )
{
archivaAdministration.addKnownContentConsumer( consumerId, getAuditInformation() );
}
else
{
archivaAdministration.removeKnownContentConsumer( consumerId, getAuditInformation() );
}
}
else
{
if ( enable )
{
archivaAdministration.addInvalidContentConsumer( consumerId, getAuditInformation() );
}
else
{
archivaAdministration.removeInvalidContentConsumer( consumerId, getAuditInformation() );
}
}
return true;
}
/**
* @see AdministrationService#deleteArtifact(String, String, String, String)
*/
public Boolean deleteArtifact( String repoId, String groupId, String artifactId, String version )
throws Exception
{
// TODO: remove duplication with web
org.apache.archiva.admin.model.beans.ManagedRepository repoConfig =
managedRepositoryAdmin.getManagedRepository( repoId );
if ( repoConfig == null )
{
throw new Exception( "Repository does not exist." );
}
RepositorySession repositorySession = repositorySessionFactory.createSession();
try
{
ManagedRepositoryContent repoContent = repoFactory.getManagedRepositoryContent( repoId );
VersionedReference ref = new VersionedReference();
ref.setGroupId( groupId );
ref.setArtifactId( artifactId );
ref.setVersion( version );
// delete from file system
repoContent.deleteVersion( ref );
MetadataRepository metadataRepository = repositorySession.getRepository();
Collection<ArtifactMetadata> artifacts =
metadataRepository.getArtifacts( repoId, groupId, artifactId, version );
for ( ArtifactMetadata artifact : artifacts )
{
// TODO: mismatch between artifact (snapshot) version and project (base) version here
if ( artifact.getVersion().equals( version ) )
{
metadataRepository.removeArtifact( artifact.getRepositoryId(), artifact.getNamespace(),
artifact.getProject(), artifact.getVersion(), artifact.getId() );
// TODO: move into the metadata repository proper - need to differentiate attachment of
// repository metadata to an artifact
for ( RepositoryListener listener : listeners )
{
listener.deleteArtifact( metadataRepository, repoId, artifact.getNamespace(),
artifact.getProject(), artifact.getVersion(), artifact.getId() );
}
}
}
repositorySession.save();
}
catch ( ContentNotFoundException e )
{
throw new Exception( "Artifact does not exist." );
}
catch ( RepositoryNotFoundException e )
{
throw new Exception( "Repository does not exist." );
}
catch ( RepositoryException e )
{
throw new Exception( "Repository exception occurred." );
}
finally
{
repositorySession.close();
}
return true;
}
/**
* @see AdministrationService#executeRepositoryScanner(String)
*/
public Boolean executeRepositoryScanner( String repoId )
throws Exception
{
if ( managedRepositoryAdmin.getManagedRepository( repoId ) == null )
{
throw new Exception( "Repository does not exist." );
}
if ( repositoryTaskScheduler.isProcessingRepositoryTask( repoId ) )
{
return false;
}
RepositoryTask task = new RepositoryTask();
task.setRepositoryId( repoId );
repositoryTaskScheduler.queueTask( task );
return true;
}
/**
* @see AdministrationService#getAllRepositoryConsumers()
*/
public List<String> getAllRepositoryConsumers()
{
List<String> consumers = new ArrayList<String>();
List<KnownRepositoryContentConsumer> knownConsumers = repoConsumersUtil.getAvailableKnownConsumers();
List<InvalidRepositoryContentConsumer> invalidConsumers = repoConsumersUtil.getAvailableInvalidConsumers();
for ( KnownRepositoryContentConsumer consumer : knownConsumers )
{
consumers.add( consumer.getId() );
}
for ( InvalidRepositoryContentConsumer consumer : invalidConsumers )
{
consumers.add( consumer.getId() );
}
return consumers;
}
/**
* @see AdministrationService#getAllManagedRepositories()
*/
public List<ManagedRepository> getAllManagedRepositories()
throws RepositoryAdminException
{
List<ManagedRepository> managedRepos = new ArrayList<ManagedRepository>();
for ( org.apache.archiva.admin.model.beans.ManagedRepository repoConfig : managedRepositoryAdmin.getManagedRepositories() )
{
ManagedRepository repo =
new ManagedRepository( repoConfig.getId(), repoConfig.getName(), repoConfig.getLocation(),
repoConfig.getLayout(), repoConfig.isSnapshots(), repoConfig.isReleases() );
managedRepos.add( repo );
}
return managedRepos;
}
/**
* @see AdministrationService#getAllRemoteRepositories()
*/
public List<RemoteRepository> getAllRemoteRepositories()
throws RepositoryAdminException
{
List<RemoteRepository> remoteRepos = new ArrayList<RemoteRepository>();
for ( org.apache.archiva.admin.model.beans.RemoteRepository repoConfig : remoteRepositoryAdmin.getRemoteRepositories() )
{
RemoteRepository repo = new RemoteRepository( repoConfig.getId(), repoConfig.getName(), repoConfig.getUrl(),
repoConfig.getLayout() );
remoteRepos.add( repo );
}
return remoteRepos;
}
public Boolean addManagedRepository( String repoId, String layout, String name, String location,
boolean blockRedeployments, boolean releasesIncluded,
boolean snapshotsIncluded, boolean stageRepoNeeded, String cronExpression,
int daysOlder, int retentionCount, boolean deleteReleasedSnapshots )
throws Exception
{
org.apache.archiva.admin.model.beans.ManagedRepository repository =
new org.apache.archiva.admin.model.beans.ManagedRepository( repoId, name, location, layout,
snapshotsIncluded, releasesIncluded,
blockRedeployments, cronExpression, null, false,
daysOlder, retentionCount,
deleteReleasedSnapshots, false );
return managedRepositoryAdmin.addManagedRepository( repository, stageRepoNeeded, getAuditInformation() );
}
public Boolean deleteManagedRepository( String repoId )
throws Exception
{
org.apache.archiva.admin.model.beans.ManagedRepository repository =
managedRepositoryAdmin.getManagedRepository( repoId );
if ( repository == null )
{
throw new Exception( "A repository with that id does not exist" );
}
RepositorySession repositorySession = repositorySessionFactory.createSession();
try
{
MetadataRepository metadataRepository = repositorySession.getRepository();
metadataRepository.removeRepository( repository.getId() );
repositoryStatisticsManager.deleteStatistics( metadataRepository, repository.getId() );
repositorySession.save();
}
finally
{
repositorySession.close();
}
managedRepositoryAdmin.deleteManagedRepository( repoId, getAuditInformation(), false );
File dir = new File( repository.getLocation() );
if ( !FileUtils.deleteQuietly( dir ) )
{
throw new IOException( "Cannot delete repository " + dir );
}
List<ProxyConnector> proxyConnectors = proxyConnectorAdmin.getProxyConnectors();
for ( ProxyConnector proxyConnector : proxyConnectors )
{
if ( StringUtils.equals( proxyConnector.getSourceRepoId(), repository.getId() ) )
{
proxyConnectorAdmin.deleteProxyConnector( proxyConnector, getAuditInformation() );
}
}
Map<String, List<String>> repoToGroupMap = repositoryGroupAdmin.getRepositoryToGroupMap();
if ( repoToGroupMap != null )
{
if ( repoToGroupMap.containsKey( repository.getId() ) )
{
List<String> repoGroups = repoToGroupMap.get( repository.getId() );
for ( String repoGroup : repoGroups )
{
repositoryGroupAdmin.deleteRepositoryFromGroup( repoGroup, repository.getId(),
getAuditInformation() );
}
}
}
return Boolean.TRUE;
}
public Boolean deleteManagedRepositoryContent( String repoId )
throws Exception
{
org.apache.archiva.admin.model.beans.ManagedRepository repository =
managedRepositoryAdmin.getManagedRepository( repoId );
if ( repository == null )
{
throw new Exception( "Repository Id : " + repoId + " not found." );
}
RepositorySession repositorySession = repositorySessionFactory.createSession();
try
{
MetadataRepository metadataRepository = repositorySession.getRepository();
metadataRepository.removeRepository( repository.getId() );
repositorySession.save();
}
finally
{
repositorySession.close();
}
File repoDir = new File( repository.getLocation() );
File[] children = repoDir.listFiles();
if ( children != null )
{
for ( File child : children )
{
FileUtils.deleteQuietly( child );
}
if ( repoDir.listFiles().length > 0 )
{
throw new IOException( "Cannot delete repository contents of " + repoDir );
}
}
return Boolean.TRUE;
}
public ManagedRepository getManagedRepository( String repoId )
throws Exception
{
org.apache.archiva.admin.model.beans.ManagedRepository managedRepository =
managedRepositoryAdmin.getManagedRepository( repoId );
if ( managedRepository == null )
{
throw new Exception( "A repository with that id does not exist" );
}
ManagedRepository repo = new ManagedRepository( managedRepository.getId(), managedRepository.getName(), "URL",
managedRepository.getLayout(), managedRepository.isSnapshots(),
managedRepository.isReleases() );
return repo;
}
public boolean merge( String repoId, boolean skipConflicts )
throws Exception
{
String stagingId = repoId + STAGE;
org.apache.archiva.admin.model.beans.ManagedRepository repoConfig;
org.apache.archiva.admin.model.beans.ManagedRepository stagingConfig;
repoConfig = managedRepositoryAdmin.getManagedRepository( repoId );
log.debug( "Retrieved repository configuration for repo '" + repoId + "'" );
RepositorySession repositorySession = repositorySessionFactory.createSession();
try
{
MetadataRepository metadataRepository = repositorySession.getRepository();
if ( repoConfig != null )
{
stagingConfig = managedRepositoryAdmin.getManagedRepository( stagingId );
if ( stagingConfig != null )
{
List<ArtifactMetadata> sourceArtifacts = metadataRepository.getArtifacts( stagingId );
if ( repoConfig.isReleases() && !repoConfig.isSnapshots() )
{
log.info( "Repository to be merged contains releases only.." );
if ( skipConflicts )
{
List<ArtifactMetadata> conflicts =
repositoryMerger.getConflictingArtifacts( metadataRepository, repoId, stagingId );
if ( log.isDebugEnabled() )
{
log.debug( "Artifacts in conflict.." );
for ( ArtifactMetadata metadata : conflicts )
{
log.debug( metadata.getNamespace() + ":" + metadata.getProject() + ":"
+ metadata.getProjectVersion() );
}
}
sourceArtifacts.removeAll( conflicts );
log.debug( "Source artifacts size :: " + sourceArtifacts.size() );
mergeWithOutSnapshots( sourceArtifacts, stagingId, repoId, metadataRepository );
}
else
{
log.debug( "Source artifacts size :: " + sourceArtifacts.size() );
mergeWithOutSnapshots( sourceArtifacts, stagingId, repoId, metadataRepository );
}
}
else
{
log.info( "Repository to be merged has snapshot artifacts.." );
if ( skipConflicts )
{
List<ArtifactMetadata> conflicts =
repositoryMerger.getConflictingArtifacts( metadataRepository, repoId, stagingId );
if ( log.isDebugEnabled() )
{
log.debug( "Artifacts in conflict.." );
for ( ArtifactMetadata metadata : conflicts )
{
log.debug( metadata.getNamespace() + ":" + metadata.getProject() + ":"
+ metadata.getProjectVersion() );
}
}
sourceArtifacts.removeAll( conflicts );
log.debug( "Source artifacts size :: " + sourceArtifacts.size() );
Filter<ArtifactMetadata> artifactsWithOutConflicts =
new IncludesFilter<ArtifactMetadata>( sourceArtifacts );
repositoryMerger.merge( metadataRepository, stagingId, repoId, artifactsWithOutConflicts );
log.info( "Staging repository '" + stagingId + "' merged successfully with managed repo '"
+ repoId + "'." );
}
else
{
repositoryMerger.merge( metadataRepository, stagingId, repoId );
log.info( "Staging repository '" + stagingId + "' merged successfully with managed repo '"
+ repoId + "'." );
}
}
}
else
{
throw new Exception( "Staging Id : " + stagingId + " not found." );
}
}
else
{
throw new Exception( "Repository Id : " + repoId + " not found." );
}
if ( !repositoryTaskScheduler.isProcessingRepositoryTask( repoId ) )
{
RepositoryTask task = new RepositoryTask();
task.setRepositoryId( repoId );
repositoryTaskScheduler.queueTask( task );
}
AuditEvent event = createAuditEvent( repoConfig );
// add event for audit log reports
metadataRepository.addMetadataFacet( event.getRepositoryId(), event );
// log event in archiva audit log
auditListener.auditEvent( createAuditEvent( repoConfig ) );
repositorySession.save();
}
finally
{
repositorySession.close();
}
return true;
}
// todo: setting userid of audit event
private AuditEvent createAuditEvent( org.apache.archiva.admin.model.beans.ManagedRepository repoConfig )
{
AuditEvent event = new AuditEvent();
event.setAction( AuditEvent.MERGE_REPO_REMOTE );
event.setRepositoryId( repoConfig.getId() );
event.setResource( repoConfig.getLocation() );
event.setTimestamp( new Date() );
return event;
}
private void mergeWithOutSnapshots( List<ArtifactMetadata> sourceArtifacts, String sourceRepoId, String repoid,
MetadataRepository metadataRepository )
throws Exception
{
List<ArtifactMetadata> artifactsWithOutSnapshots = new ArrayList<ArtifactMetadata>();
for ( ArtifactMetadata metadata : sourceArtifacts )
{
if ( metadata.getProjectVersion().contains( "SNAPSHOT" ) )
{
artifactsWithOutSnapshots.add( metadata );
}
}
sourceArtifacts.removeAll( artifactsWithOutSnapshots );
Filter<ArtifactMetadata> artifactListWithOutSnapShots = new IncludesFilter<ArtifactMetadata>( sourceArtifacts );
repositoryMerger.merge( metadataRepository, sourceRepoId, repoid, artifactListWithOutSnapShots );
}
// FIXME find a way to get user id and adress
private AuditInformation getAuditInformation()
{
return new AuditInformation( null, null );
}
}