initial work on removing hardcoded staging repositories. Still several tasks to do and some tests are failing in this state

git-svn-id: https://svn.apache.org/repos/asf/archiva/branches/staging-refactor@1185127 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Brett Porter 2011-10-17 12:34:20 +00:00
parent 23943dcdc2
commit 07f0744a63
39 changed files with 305 additions and 685 deletions
archiva-modules
archiva-base
archiva-configuration/src/main
java/org/apache/archiva/configuration
mdo
archiva-consumers/archiva-core-consumers/src/test/java/org/apache/archiva/consumers/core/repository
archiva-proxy/src/test/java/org/apache/archiva/proxy
archiva-repository-admin
archiva-repository-admin-api/src/main/java/org/apache/archiva/admin/model
archiva-repository-admin-default/src
main/java/org/apache/archiva/admin/repository/managed
test/java/org/apache/archiva/admin/repository
archiva-scheduler/archiva-scheduler-repository/src/test/java/org/apache/archiva/mock
archiva-web
archiva-rest/archiva-rest-services/src/main/java/org/apache/archiva/rest/services
archiva-webapp-test/src/test/testng/org/apache/archiva/web/test
archiva-webapp/src
archiva-webdav/src
main/java/org/apache/archiva/webdav
test/java/org/apache/archiva/webdav
archiva-xmlrpc/archiva-xmlrpc-services/src
main/java/org/apache/archiva/web/xmlrpc/services
test/java/org/apache/archiva/web/xmlrpc/services
plugins/stage-repository-merge/src
main/java/org/apache/archiva/stagerepository/merge
test/java/org/apache/archiva/stagerepository/merge

View File

@ -19,12 +19,12 @@ package org.apache.archiva.configuration;
* under the License. * under the License.
*/ */
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.Predicate;
import org.apache.commons.configuration.CombinedConfiguration;
import org.apache.archiva.common.FileTypeUtils; import org.apache.archiva.common.FileTypeUtils;
import org.apache.archiva.configuration.functors.FiletypeSelectionPredicate; import org.apache.archiva.configuration.functors.FiletypeSelectionPredicate;
import org.apache.archiva.configuration.io.registry.ConfigurationRegistryReader; import org.apache.archiva.configuration.io.registry.ConfigurationRegistryReader;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.Predicate;
import org.apache.commons.configuration.CombinedConfiguration;
import org.codehaus.plexus.registry.Registry; import org.codehaus.plexus.registry.Registry;
import org.codehaus.plexus.registry.RegistryException; import org.codehaus.plexus.registry.RegistryException;
import org.codehaus.plexus.registry.RegistryListener; import org.codehaus.plexus.registry.RegistryListener;
@ -32,15 +32,15 @@ import org.codehaus.plexus.util.SelectorUtils;
import org.codehaus.redback.components.registry.commons.CommonsConfigurationRegistry; import org.codehaus.redback.components.registry.commons.CommonsConfigurationRegistry;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Named;
import java.lang.reflect.Field; import java.lang.reflect.Field;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collections; import java.util.Collections;
import java.util.HashMap; import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Named;
/** /**
* FileTypes * FileTypes

View File

@ -136,6 +136,7 @@
The repository scanning configuration. The repository scanning configuration.
</description> </description>
</field> </field>
<!-- TODO: remove? can't seem to use ranges to not generate above 1.3.0 -->
<field> <field>
<name>webapp</name> <name>webapp</name>
<version>1.0.0+</version> <version>1.0.0+</version>
@ -567,6 +568,15 @@
The file system location for this repository. The file system location for this repository.
</description> </description>
</field> </field>
<field>
<name>stagingLocation</name>
<version>1.4.0+</version>
<type>String</type>
<required>false</required>
<description>
The file system location for any attached staging repositories.
</description>
</field>
<field> <field>
<name>releases</name> <name>releases</name>
<version>1.0.0+</version> <version>1.0.0+</version>
@ -595,6 +605,14 @@
<description>True if this repository should be scanned and processed.</description> <description>True if this repository should be scanned and processed.</description>
<defaultValue>true</defaultValue> <defaultValue>true</defaultValue>
</field> </field>
<field>
<name>stagingRequired</name>
<version>1.4.0+</version>
<type>boolean</type>
<description>
Whether staging repositories can be created for this repository.
</description>
</field>
<field> <field>
<name>refreshCronExpression</name> <name>refreshCronExpression</name>
<version>1.0.0+</version> <version>1.0.0+</version>

View File

@ -99,7 +99,7 @@ public class CleanupReleasedSnapshotsRepositoryPurgeTest
applicationContext.getBean( ManagedRepositoryAdmin.class ).deleteManagedRepository( TEST_REPO_ID, null, false ); applicationContext.getBean( ManagedRepositoryAdmin.class ).deleteManagedRepository( TEST_REPO_ID, null, false );
applicationContext.getBean( ManagedRepositoryAdmin.class ).addManagedRepository( applicationContext.getBean( ManagedRepositoryAdmin.class ).addManagedRepository(
getRepoConfiguration( TEST_REPO_ID, TEST_REPO_NAME ), false, null ); getRepoConfiguration( TEST_REPO_ID, TEST_REPO_NAME ), null );
String repoRoot = prepareTestRepos(); String repoRoot = prepareTestRepos();
@ -160,7 +160,7 @@ public class CleanupReleasedSnapshotsRepositoryPurgeTest
applicationContext.getBean( ManagedRepositoryAdmin.class ).deleteManagedRepository( TEST_REPO_ID, null, false ); applicationContext.getBean( ManagedRepositoryAdmin.class ).deleteManagedRepository( TEST_REPO_ID, null, false );
applicationContext.getBean( ManagedRepositoryAdmin.class ).addManagedRepository( applicationContext.getBean( ManagedRepositoryAdmin.class ).addManagedRepository(
getRepoConfiguration( TEST_REPO_ID, TEST_REPO_NAME ), false, null ); getRepoConfiguration( TEST_REPO_ID, TEST_REPO_NAME ), null );
String repoRoot = prepareTestRepos(); String repoRoot = prepareTestRepos();
@ -195,10 +195,10 @@ public class CleanupReleasedSnapshotsRepositoryPurgeTest
*/ */
applicationContext.getBean( ManagedRepositoryAdmin.class ).deleteManagedRepository( TEST_REPO_ID, null, false ); applicationContext.getBean( ManagedRepositoryAdmin.class ).deleteManagedRepository( TEST_REPO_ID, null, false );
applicationContext.getBean( ManagedRepositoryAdmin.class ).addManagedRepository( applicationContext.getBean( ManagedRepositoryAdmin.class ).addManagedRepository(
getRepoConfiguration( TEST_REPO_ID, TEST_REPO_NAME ), false, null ); getRepoConfiguration( TEST_REPO_ID, TEST_REPO_NAME ), null );
applicationContext.getBean( ManagedRepositoryAdmin.class ).addManagedRepository( applicationContext.getBean( ManagedRepositoryAdmin.class ).addManagedRepository(
getRepoConfiguration( RELEASES_TEST_REPO_ID, RELEASES_TEST_REPO_NAME ), false, null ); getRepoConfiguration( RELEASES_TEST_REPO_ID, RELEASES_TEST_REPO_NAME ), null );
String repoRoot = prepareTestRepos(); String repoRoot = prepareTestRepos();
@ -248,7 +248,7 @@ public class CleanupReleasedSnapshotsRepositoryPurgeTest
*/ */
applicationContext.getBean( ManagedRepositoryAdmin.class ).deleteManagedRepository( TEST_REPO_ID, null, false ); applicationContext.getBean( ManagedRepositoryAdmin.class ).deleteManagedRepository( TEST_REPO_ID, null, false );
applicationContext.getBean( ManagedRepositoryAdmin.class ).addManagedRepository( applicationContext.getBean( ManagedRepositoryAdmin.class ).addManagedRepository(
getRepoConfiguration( TEST_REPO_ID, TEST_REPO_NAME ), false, null ); getRepoConfiguration( TEST_REPO_ID, TEST_REPO_NAME ), null );
String repoRoot = prepareTestRepos(); String repoRoot = prepareTestRepos();

View File

@ -196,7 +196,7 @@ public class RepositoryPurgeConsumerTest
{ {
managedRepositoryAdmin.deleteManagedRepository( repoConfiguration.getId(), null, false ); managedRepositoryAdmin.deleteManagedRepository( repoConfiguration.getId(), null, false );
} }
managedRepositoryAdmin.addManagedRepository( repoConfiguration, false, null ); managedRepositoryAdmin.addManagedRepository( repoConfiguration, null );
} }
private void removeRepoFromConfiguration( String configHint, ManagedRepository repoConfiguration ) private void removeRepoFromConfiguration( String configHint, ManagedRepository repoConfiguration )

View File

@ -160,7 +160,7 @@ public abstract class AbstractProxyTestCase
( (DefaultManagedRepositoryAdmin) applicationContext.getBean( ( (DefaultManagedRepositoryAdmin) applicationContext.getBean(
ManagedRepositoryAdmin.class ) ).setArchivaConfiguration( config ); ManagedRepositoryAdmin.class ) ).setArchivaConfiguration( config );
applicationContext.getBean( ManagedRepositoryAdmin.class ).addManagedRepository( repoConfig, false, null ); applicationContext.getBean( ManagedRepositoryAdmin.class ).addManagedRepository( repoConfig, null );
//config.getConfiguration().addManagedRepository( repoConfig ); //config.getConfiguration().addManagedRepository( repoConfig );
// Setup source repository (using legacy layout) // Setup source repository (using legacy layout)
@ -180,7 +180,7 @@ public abstract class AbstractProxyTestCase
repoConfig = managedLegacyRepository.getRepository(); repoConfig = managedLegacyRepository.getRepository();
//config.getConfiguration().addManagedRepository( repoConfig ); //config.getConfiguration().addManagedRepository( repoConfig );
applicationContext.getBean( ManagedRepositoryAdmin.class ).addManagedRepository( repoConfig, false, null ); applicationContext.getBean( ManagedRepositoryAdmin.class ).addManagedRepository( repoConfig, null );
// Setup target (proxied to) repository. // Setup target (proxied to) repository.
saveRemoteRepositoryConfig( ID_PROXIED1, "Proxied Repository 1", saveRemoteRepositoryConfig( ID_PROXIED1, "Proxied Repository 1",

View File

@ -128,7 +128,7 @@ public class HttpProxyTransferTest
ManagedRepositoryAdmin managedRepositoryAdmin = applicationContext.getBean( ManagedRepositoryAdmin.class ); ManagedRepositoryAdmin managedRepositoryAdmin = applicationContext.getBean( ManagedRepositoryAdmin.class );
if ( managedRepositoryAdmin.getManagedRepository( repo.getId() ) == null ) if ( managedRepositoryAdmin.getManagedRepository( repo.getId() ) == null )
{ {
managedRepositoryAdmin.addManagedRepository( repo, false, null ); managedRepositoryAdmin.addManagedRepository( repo, null );
} }
//config.getConfiguration().addManagedRepository( repo ); //config.getConfiguration().addManagedRepository( repo );

View File

@ -45,15 +45,8 @@ public class ManagedRepository
*/ */
private String cronExpression = "0 0 * * * ?"; private String cronExpression = "0 0 * * * ?";
/**
* not need when creating the repo : only available when reading
*/
private ManagedRepository stagingRepository;
private boolean scanned = false; private boolean scanned = false;
/** /**
* default model value * default model value
*/ */
@ -66,7 +59,8 @@ public class ManagedRepository
private boolean deleteReleasedSnapshots; private boolean deleteReleasedSnapshots;
private boolean stageRepoNeeded; // TODO: move to staging plugin and allow custom per-repository configuration from plugins
private boolean stagingRequired;
private boolean resetStats; private boolean resetStats;
@ -78,7 +72,7 @@ public class ManagedRepository
public ManagedRepository( String id, String name, String location, String layout, boolean snapshots, public ManagedRepository( String id, String name, String location, String layout, boolean snapshots,
boolean releases, boolean blockRedeployments, String cronExpression, String indexDir, boolean releases, boolean blockRedeployments, String cronExpression, String indexDir,
boolean scanned, int daysOlder, int retentionCount, boolean deleteReleasedSnapshots, boolean scanned, int daysOlder, int retentionCount, boolean deleteReleasedSnapshots,
boolean stageRepoNeeded ) boolean stagingRequired )
{ {
super( id, name, layout ); super( id, name, layout );
@ -92,7 +86,7 @@ public class ManagedRepository
this.daysOlder = daysOlder; this.daysOlder = daysOlder;
this.retentionCount = retentionCount; this.retentionCount = retentionCount;
this.deleteReleasedSnapshots = deleteReleasedSnapshots; this.deleteReleasedSnapshots = deleteReleasedSnapshots;
this.stageRepoNeeded = stageRepoNeeded; this.stagingRequired = stagingRequired;
} }
public String getCronExpression() public String getCronExpression()
@ -151,16 +145,6 @@ public class ManagedRepository
} }
public ManagedRepository getStagingRepository()
{
return stagingRepository;
}
public void setStagingRepository( ManagedRepository stagingRepository )
{
this.stagingRepository = stagingRepository;
}
public boolean isScanned() public boolean isScanned()
{ {
@ -203,14 +187,14 @@ public class ManagedRepository
this.deleteReleasedSnapshots = deleteReleasedSnapshots; this.deleteReleasedSnapshots = deleteReleasedSnapshots;
} }
public boolean isStageRepoNeeded() public boolean isStagingRequired()
{ {
return stageRepoNeeded; return stagingRequired;
} }
public void setStageRepoNeeded( boolean stageRepoNeeded ) public void setStagingRequired( boolean stagingRequired )
{ {
this.stageRepoNeeded = stageRepoNeeded; this.stagingRequired = stagingRequired;
} }
public boolean isResetStats() public boolean isResetStats()
@ -233,17 +217,15 @@ public class ManagedRepository
sb.append( ", snapshots=" ).append( snapshots ); sb.append( ", snapshots=" ).append( snapshots );
sb.append( ", releases=" ).append( releases ); sb.append( ", releases=" ).append( releases );
sb.append( ", blockRedeployments=" ).append( blockRedeployments ); sb.append( ", blockRedeployments=" ).append( blockRedeployments );
sb.append( ", stagingRequired=" ).append( stagingRequired );
sb.append( ", cronExpression='" ).append( cronExpression ).append( '\'' ); sb.append( ", cronExpression='" ).append( cronExpression ).append( '\'' );
sb.append( ", stagingRepository=" ).append( stagingRepository );
sb.append( ", scanned=" ).append( scanned ); sb.append( ", scanned=" ).append( scanned );
sb.append( ", daysOlder=" ).append( daysOlder ); sb.append( ", daysOlder=" ).append( daysOlder );
sb.append( ", retentionCount=" ).append( retentionCount ); sb.append( ", retentionCount=" ).append( retentionCount );
sb.append( ", deleteReleasedSnapshots=" ).append( deleteReleasedSnapshots ); sb.append( ", deleteReleasedSnapshots=" ).append( deleteReleasedSnapshots );
sb.append( ", stageRepoNeeded=" ).append( stageRepoNeeded ); sb.append( ", stagingRequired=" ).append( stagingRequired );
sb.append( ", resetStats=" ).append( resetStats ); sb.append( ", resetStats=" ).append( resetStats );
sb.append( '}' ); sb.append( '}' );
return sb.toString(); return sb.toString();
} }
}
}

View File

@ -44,13 +44,12 @@ public interface ManagedRepositoryAdmin
Boolean deleteManagedRepository( String repositoryId, AuditInformation auditInformation, boolean deleteContent ) Boolean deleteManagedRepository( String repositoryId, AuditInformation auditInformation, boolean deleteContent )
throws RepositoryAdminException; throws RepositoryAdminException;
Boolean addManagedRepository( ManagedRepository managedRepository, boolean needStageRepo, Boolean addManagedRepository( ManagedRepository managedRepository, AuditInformation auditInformation )
AuditInformation auditInformation )
throws RepositoryAdminException; throws RepositoryAdminException;
Boolean updateManagedRepository( ManagedRepository managedRepository, boolean needStageRepo, Boolean updateManagedRepository( ManagedRepository managedRepository, AuditInformation auditInformation,
AuditInformation auditInformation, boolean resetStats ) boolean resetStats )
throws RepositoryAdminException; throws RepositoryAdminException;

View File

@ -51,8 +51,6 @@ import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import javax.inject.Inject;
import javax.inject.Named;
import java.io.File; import java.io.File;
import java.io.IOException; import java.io.IOException;
import java.util.ArrayList; import java.util.ArrayList;
@ -60,6 +58,8 @@ import java.util.Arrays;
import java.util.HashMap; import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import javax.inject.Inject;
import javax.inject.Named;
/** /**
* FIXME remove all generic Exception to have usefull ones * FIXME remove all generic Exception to have usefull ones
@ -77,8 +77,6 @@ public class DefaultManagedRepositoryAdmin
private Logger log = LoggerFactory.getLogger( getClass() ); private Logger log = LoggerFactory.getLogger( getClass() );
public static final String STAGE_REPO_ID_END = "-stage";
@Inject @Inject
@Named( value = "archivaTaskScheduler#repository" ) @Named( value = "archivaTaskScheduler#repository" )
@ -107,13 +105,13 @@ public class DefaultManagedRepositoryAdmin
for ( ManagedRepositoryConfiguration repoConfig : managedRepoConfigs ) for ( ManagedRepositoryConfiguration repoConfig : managedRepoConfigs )
{ {
// TODO add staging repo information back too
ManagedRepository repo = ManagedRepository repo =
new ManagedRepository( repoConfig.getId(), repoConfig.getName(), repoConfig.getLocation(), new ManagedRepository( repoConfig.getId(), repoConfig.getName(), repoConfig.getLocation(),
repoConfig.getLayout(), repoConfig.isSnapshots(), repoConfig.isReleases(), repoConfig.getLayout(), repoConfig.isSnapshots(), repoConfig.isReleases(),
repoConfig.isBlockRedeployments(), repoConfig.getRefreshCronExpression(), repoConfig.isBlockRedeployments(), repoConfig.getRefreshCronExpression(),
repoConfig.getIndexDir(), repoConfig.isScanned(), repoConfig.getDaysOlder(), repoConfig.getIndexDir(), repoConfig.isScanned(), repoConfig.getDaysOlder(),
repoConfig.getRetentionCount(), repoConfig.isDeleteReleasedSnapshots(), false ); repoConfig.getRetentionCount(), repoConfig.isDeleteReleasedSnapshots(),
repoConfig.isStagingRequired() );
managedRepos.add( repo ); managedRepos.add( repo );
} }
@ -148,8 +146,7 @@ public class DefaultManagedRepositoryAdmin
return null; return null;
} }
public Boolean addManagedRepository( ManagedRepository managedRepository, boolean needStageRepo, public Boolean addManagedRepository( ManagedRepository managedRepository, AuditInformation auditInformation )
AuditInformation auditInformation )
throws RepositoryAdminException throws RepositoryAdminException
{ {
@ -158,18 +155,18 @@ public class DefaultManagedRepositoryAdmin
return return
addManagedRepository( managedRepository.getId(), managedRepository.getLayout(), managedRepository.getName(), addManagedRepository( managedRepository.getId(), managedRepository.getLayout(), managedRepository.getName(),
managedRepository.getLocation(), managedRepository.isBlockRedeployments(), managedRepository.getLocation(), managedRepository.isBlockRedeployments(),
managedRepository.isReleases(), managedRepository.isSnapshots(), needStageRepo, managedRepository.isReleases(), managedRepository.isSnapshots(),
managedRepository.getCronExpression(), managedRepository.getIndexDirectory(), managedRepository.isStagingRequired(), managedRepository.getCronExpression(),
managedRepository.getDaysOlder(), managedRepository.getRetentionCount(), managedRepository.getIndexDirectory(), managedRepository.getDaysOlder(),
managedRepository.isDeleteReleasedSnapshots(), auditInformation, managedRepository.getRetentionCount(), managedRepository.isDeleteReleasedSnapshots(),
getArchivaConfiguration().getConfiguration() ) != null; auditInformation, getArchivaConfiguration().getConfiguration() ) != null;
} }
private ManagedRepositoryConfiguration addManagedRepository( String repoId, String layout, String name, private ManagedRepositoryConfiguration addManagedRepository( String repoId, String layout, String name,
String location, boolean blockRedeployments, String location, boolean blockRedeployments,
boolean releasesIncluded, boolean snapshotsIncluded, boolean releasesIncluded, boolean snapshotsIncluded,
boolean stageRepoNeeded, String cronExpression, boolean stagingRequired, String cronExpression,
String indexDir, int daysOlder, int retentionCount, String indexDir, int daysOlder, int retentionCount,
boolean deteleReleasedSnapshots, boolean deteleReleasedSnapshots,
AuditInformation auditInformation, AuditInformation auditInformation,
@ -205,6 +202,7 @@ public class DefaultManagedRepositoryAdmin
repository.setId( repoId ); repository.setId( repoId );
repository.setBlockRedeployments( blockRedeployments ); repository.setBlockRedeployments( blockRedeployments );
repository.setStagingRequired( stagingRequired );
repository.setReleases( releasesIncluded ); repository.setReleases( releasesIncluded );
repository.setSnapshots( snapshotsIncluded ); repository.setSnapshots( snapshotsIncluded );
repository.setName( name ); repository.setName( name );
@ -221,14 +219,6 @@ public class DefaultManagedRepositoryAdmin
{ {
addRepository( repository, config ); addRepository( repository, config );
addRepositoryRoles( repository ); addRepositoryRoles( repository );
if ( stageRepoNeeded )
{
ManagedRepositoryConfiguration stagingRepository = getStageRepoConfig( repository );
addRepository( stagingRepository, config );
addRepositoryRoles( stagingRepository );
triggerAuditEvent( stagingRepository.getId(), null, AuditEvent.ADD_MANAGED_REPO, auditInformation );
}
} }
catch ( RoleManagerException e ) catch ( RoleManagerException e )
{ {
@ -246,13 +236,6 @@ public class DefaultManagedRepositoryAdmin
try try
{ {
scanRepository( repoId, true ); scanRepository( repoId, true );
// olamy no need of scanning staged repo
/*
if ( stageRepoNeeded )
{
ManagedRepositoryConfiguration stagingRepository = getStageRepoConfig( repository );
scanRepository( stagingRepository.getId(), true );
}*/
} }
catch ( Exception e ) catch ( Exception e )
{ {
@ -282,14 +265,7 @@ public class DefaultManagedRepositoryAdmin
deleteManagedRepository( repository, deleteContent, config, false ); deleteManagedRepository( repository, deleteContent, config, false );
// stage repo exists ? // STAGE FIXME: delete staging location too
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 try
{ {
@ -405,13 +381,14 @@ public class DefaultManagedRepositoryAdmin
} }
public Boolean updateManagedRepository( ManagedRepository managedRepository, boolean needStageRepo, public Boolean updateManagedRepository( ManagedRepository managedRepository, AuditInformation auditInformation,
AuditInformation auditInformation, boolean resetStats ) boolean resetStats )
throws RepositoryAdminException throws RepositoryAdminException
{ {
if ( log.isDebugEnabled() )
log.debug( "updateManagedConfiguration repo {} needStage {} resetStats {} ", {
Arrays.asList( managedRepository, needStageRepo, resetStats ).toArray() ); log.debug( "updateManagedConfiguration repo {} resetStats {} ", Arrays.asList( managedRepository, resetStats ).toArray() );
}
// Ensure that the fields are valid. // Ensure that the fields are valid.
@ -426,23 +403,16 @@ public class DefaultManagedRepositoryAdmin
configuration.removeManagedRepository( toremove ); configuration.removeManagedRepository( toremove );
} }
ManagedRepositoryConfiguration stagingRepository = getStageRepoConfig( toremove );
// TODO remove content from old if path has changed !!!!! // TODO remove content from old if path has changed !!!!!
if ( stagingRepository != null )
{
configuration.removeManagedRepository( stagingRepository );
}
ManagedRepositoryConfiguration managedRepositoryConfiguration = ManagedRepositoryConfiguration managedRepositoryConfiguration =
addManagedRepository( managedRepository.getId(), managedRepository.getLayout(), managedRepository.getName(), addManagedRepository( managedRepository.getId(), managedRepository.getLayout(), managedRepository.getName(),
managedRepository.getLocation(), managedRepository.isBlockRedeployments(), managedRepository.getLocation(), managedRepository.isBlockRedeployments(),
managedRepository.isReleases(), managedRepository.isSnapshots(), needStageRepo, managedRepository.isReleases(), managedRepository.isSnapshots(),
managedRepository.getCronExpression(), managedRepository.getIndexDirectory(), managedRepository.isStagingRequired(), managedRepository.getCronExpression(),
managedRepository.getDaysOlder(), managedRepository.getRetentionCount(), managedRepository.getIndexDirectory(), managedRepository.getDaysOlder(),
managedRepository.isDeleteReleasedSnapshots(), auditInformation, managedRepository.getRetentionCount(), managedRepository.isDeleteReleasedSnapshots(),
getArchivaConfiguration().getConfiguration() ); auditInformation, getArchivaConfiguration().getConfiguration() );
// Save the repository configuration. // Save the repository configuration.
RepositorySession repositorySession = getRepositorySessionFactory().createSession(); RepositorySession repositorySession = getRepositorySessionFactory().createSession();
@ -498,27 +468,6 @@ public class DefaultManagedRepositoryAdmin
configuration.addManagedRepository( repository ); configuration.addManagedRepository( repository );
} }
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() );
stagingRepository.setIndexDir( repository.getIndexDir() );
String path = repository.getLocation();
int lastIndex = path.lastIndexOf( '/' );
stagingRepository.setLocation( path.substring( 0, lastIndex ) + "/" + stagingRepository.getId() );
stagingRepository.setRefreshCronExpression( repository.getRefreshCronExpression() );
stagingRepository.setReleases( repository.isReleases() );
stagingRepository.setRetentionCount( repository.getRetentionCount() );
stagingRepository.setScanned( repository.isScanned() );
stagingRepository.setSnapshots( repository.isSnapshots() );
return stagingRepository;
}
public Boolean scanRepository( String repositoryId, boolean fullScan ) public Boolean scanRepository( String repositoryId, boolean fullScan )
{ {
if ( getRepositoryTaskScheduler().isProcessingRepositoryTask( repositoryId ) ) if ( getRepositoryTaskScheduler().isProcessingRepositoryTask( repositoryId ) )

View File

@ -93,8 +93,8 @@ public abstract class AbstractRepositoryAdminTest
protected ManagedRepository getTestManagedRepository( String repoId, String repoLocation ) protected ManagedRepository getTestManagedRepository( String repoId, String repoLocation )
{ {
return new ManagedRepository( repoId, "test repo", repoLocation, "default", false, true, true, "0 0 * * * ?", return new ManagedRepository( repoId, "test repo", repoLocation, "default", false, true, true,
repoLocation + "/.index", false, 1, 2, true, false ); "0 0 * * * ?", repoLocation + "/.index", false, 1, 2, true, false );
} }
protected File clearRepoLocation( String path ) protected File clearRepoLocation( String path )

View File

@ -50,9 +50,9 @@ public class RepositoryGroupAdminTest
ManagedRepository managedRepositoryTwo = ManagedRepository managedRepositoryTwo =
getTestManagedRepository( "test-new-two", APPSERVER_BASE_PATH + File.separator + "test-new-two" ); getTestManagedRepository( "test-new-two", APPSERVER_BASE_PATH + File.separator + "test-new-two" );
managedRepositoryAdmin.addManagedRepository( managedRepositoryOne, false, getFakeAuditInformation() ); managedRepositoryAdmin.addManagedRepository( managedRepositoryOne, getFakeAuditInformation() );
managedRepositoryAdmin.addManagedRepository( managedRepositoryTwo, false, getFakeAuditInformation() ); managedRepositoryAdmin.addManagedRepository( managedRepositoryTwo, getFakeAuditInformation() );
RepositoryGroup repositoryGroup = RepositoryGroup repositoryGroup =
new RepositoryGroup( "repo-group-one", Arrays.asList( "test-new-one", "test-new-two" ) ); new RepositoryGroup( "repo-group-one", Arrays.asList( "test-new-one", "test-new-two" ) );
@ -96,9 +96,9 @@ public class RepositoryGroupAdminTest
ManagedRepository managedRepositoryTwo = ManagedRepository managedRepositoryTwo =
getTestManagedRepository( "test-new-two", APPSERVER_BASE_PATH + File.separator + "test-new-two" ); getTestManagedRepository( "test-new-two", APPSERVER_BASE_PATH + File.separator + "test-new-two" );
managedRepositoryAdmin.addManagedRepository( managedRepositoryOne, false, getFakeAuditInformation() ); managedRepositoryAdmin.addManagedRepository( managedRepositoryOne, getFakeAuditInformation() );
managedRepositoryAdmin.addManagedRepository( managedRepositoryTwo, false, getFakeAuditInformation() ); managedRepositoryAdmin.addManagedRepository( managedRepositoryTwo, getFakeAuditInformation() );
RepositoryGroup repositoryGroup = new RepositoryGroup( "repo-group-one", Arrays.asList( "test-new-one" ) ); RepositoryGroup repositoryGroup = new RepositoryGroup( "repo-group-one", Arrays.asList( "test-new-one" ) );
@ -156,9 +156,9 @@ public class RepositoryGroupAdminTest
ManagedRepository managedRepositoryTwo = ManagedRepository managedRepositoryTwo =
getTestManagedRepository( "test-new-two", APPSERVER_BASE_PATH + File.separator + "test-new-two" ); getTestManagedRepository( "test-new-two", APPSERVER_BASE_PATH + File.separator + "test-new-two" );
managedRepositoryAdmin.addManagedRepository( managedRepositoryOne, false, getFakeAuditInformation() ); managedRepositoryAdmin.addManagedRepository( managedRepositoryOne, getFakeAuditInformation() );
managedRepositoryAdmin.addManagedRepository( managedRepositoryTwo, false, getFakeAuditInformation() ); managedRepositoryAdmin.addManagedRepository( managedRepositoryTwo, getFakeAuditInformation() );
RepositoryGroup repositoryGroup = RepositoryGroup repositoryGroup =
new RepositoryGroup( "repo-group-one", Arrays.asList( "test-new-one", "test-new-two" ) ); new RepositoryGroup( "repo-group-one", Arrays.asList( "test-new-one", "test-new-two" ) );

View File

@ -33,7 +33,6 @@ import java.util.List;
public class ManagedRepositoryAdminTest public class ManagedRepositoryAdminTest
extends AbstractRepositoryAdminTest extends AbstractRepositoryAdminTest
{ {
public static final String STAGE_REPO_ID_END = DefaultManagedRepositoryAdmin.STAGE_REPO_ID_END;
@Test @Test
public void getAllManagedRepos() public void getAllManagedRepos()
@ -85,7 +84,7 @@ public class ManagedRepositoryAdminTest
repo.setName( "test repo" ); repo.setName( "test repo" );
repo.setLocation( repoLocation ); repo.setLocation( repoLocation );
repo.setCronExpression( "0 0 * * * ?" ); repo.setCronExpression( "0 0 * * * ?" );
managedRepositoryAdmin.addManagedRepository( repo, false, getFakeAuditInformation() ); managedRepositoryAdmin.addManagedRepository( repo, getFakeAuditInformation() );
repos = managedRepositoryAdmin.getManagedRepositories(); repos = managedRepositoryAdmin.getManagedRepositories();
assertNotNull( repos ); assertNotNull( repos );
assertEquals( initialSize + 1, repos.size() ); assertEquals( initialSize + 1, repos.size() );
@ -133,7 +132,7 @@ public class ManagedRepositoryAdminTest
repo.setName( "test repo" ); repo.setName( "test repo" );
repo.setLocation( repoLocation ); repo.setLocation( repoLocation );
repo.setCronExpression( "0 0 * * * ?" ); repo.setCronExpression( "0 0 * * * ?" );
managedRepositoryAdmin.addManagedRepository( repo, false, getFakeAuditInformation() ); managedRepositoryAdmin.addManagedRepository( repo, getFakeAuditInformation() );
assertTemplateRoleExists( repoId ); assertTemplateRoleExists( repoId );
@ -148,7 +147,7 @@ public class ManagedRepositoryAdminTest
repo.setLocation( repoLocation ); repo.setLocation( repoLocation );
repo.setCronExpression( "0 0 * * * ?" ); repo.setCronExpression( "0 0 * * * ?" );
managedRepositoryAdmin.updateManagedRepository( repo, false, getFakeAuditInformation(), false ); managedRepositoryAdmin.updateManagedRepository( repo, getFakeAuditInformation(), false );
repo = managedRepositoryAdmin.getManagedRepository( repoId ); repo = managedRepositoryAdmin.getManagedRepository( repoId );
assertNotNull( repo ); assertNotNull( repo );
@ -193,7 +192,8 @@ public class ManagedRepositoryAdminTest
repo.setName( "test repo" ); repo.setName( "test repo" );
repo.setLocation( repoLocation ); repo.setLocation( repoLocation );
repo.setCronExpression( "0 0 * * * ?" ); repo.setCronExpression( "0 0 * * * ?" );
managedRepositoryAdmin.addManagedRepository( repo, true, getFakeAuditInformation() ); repo.setStagingRequired( true );
managedRepositoryAdmin.addManagedRepository( repo, getFakeAuditInformation() );
repos = managedRepositoryAdmin.getManagedRepositories(); repos = managedRepositoryAdmin.getManagedRepositories();
assertNotNull( repos ); assertNotNull( repos );
assertEquals( initialSize + 2, repos.size() ); assertEquals( initialSize + 2, repos.size() );
@ -204,27 +204,32 @@ public class ManagedRepositoryAdminTest
assertTrue( repoDir.exists() ); assertTrue( repoDir.exists() );
// STAGE FIXME: check the things that should exist here
/*
assertNotNull( managedRepositoryAdmin.getManagedRepository( repoId + STAGE_REPO_ID_END ) ); assertNotNull( managedRepositoryAdmin.getManagedRepository( repoId + STAGE_REPO_ID_END ) );
assertTemplateRoleExists( repoId + STAGE_REPO_ID_END ); assertTemplateRoleExists( repoId + STAGE_REPO_ID_END );
assertTrue( new File( repoLocation + STAGE_REPO_ID_END ).exists() ); assertTrue( new File( repoLocation + STAGE_REPO_ID_END ).exists() );
*/
managedRepositoryAdmin.deleteManagedRepository( repoId, getFakeAuditInformation(), true ); managedRepositoryAdmin.deleteManagedRepository( repoId, getFakeAuditInformation(), true );
assertFalse( repoDir.exists() ); assertFalse( repoDir.exists() );
// STAGE FIXME: check the things that should have been removed
/*
assertFalse( new File( repoLocation + STAGE_REPO_ID_END ).exists() ); assertFalse( new File( repoLocation + STAGE_REPO_ID_END ).exists() );
assertTemplateRoleNotExists( repoId + STAGE_REPO_ID_END ); assertTemplateRoleNotExists( repoId + STAGE_REPO_ID_END );
*/
repos = managedRepositoryAdmin.getManagedRepositories(); repos = managedRepositoryAdmin.getManagedRepositories();
assertNotNull( repos ); assertNotNull( repos );
assertEquals( initialSize, repos.size() ); assertEquals( initialSize, repos.size() );
assertTemplateRoleNotExists( repoId ); assertTemplateRoleNotExists( repoId );
assertTemplateRoleNotExists( repoId + STAGE_REPO_ID_END ); // STAGE FIXME: check the things that should have been removed
// assertTemplateRoleNotExists( repoId + STAGE_REPO_ID_END );
mockAuditListener.clearEvents(); mockAuditListener.clearEvents();
@ -250,13 +255,16 @@ public class ManagedRepositoryAdminTest
ManagedRepository repo = getTestManagedRepository( repoId, repoLocation ); ManagedRepository repo = getTestManagedRepository( repoId, repoLocation );
managedRepositoryAdmin.addManagedRepository( repo, false, getFakeAuditInformation() ); managedRepositoryAdmin.addManagedRepository( repo, getFakeAuditInformation() );
assertTemplateRoleExists( repoId ); assertTemplateRoleExists( repoId );
// STAGE FIXME: check the things that should have been removed
/*
assertFalse( new File( repoLocation + STAGE_REPO_ID_END ).exists() ); assertFalse( new File( repoLocation + STAGE_REPO_ID_END ).exists() );
assertTemplateRoleNotExists( repoId + STAGE_REPO_ID_END ); assertTemplateRoleNotExists( repoId + STAGE_REPO_ID_END );
*/
repos = managedRepositoryAdmin.getManagedRepositories(); repos = managedRepositoryAdmin.getManagedRepositories();
assertNotNull( repos ); assertNotNull( repos );
@ -272,7 +280,9 @@ public class ManagedRepositoryAdminTest
repo.setLocation( repoLocation ); repo.setLocation( repoLocation );
managedRepositoryAdmin.updateManagedRepository( repo, true, getFakeAuditInformation(), false ); repo.setStagingRequired( true );
managedRepositoryAdmin.updateManagedRepository( repo, getFakeAuditInformation(), false );
repo = managedRepositoryAdmin.getManagedRepository( repoId ); repo = managedRepositoryAdmin.getManagedRepository( repoId );
assertNotNull( repo ); assertNotNull( repo );
@ -291,9 +301,12 @@ public class ManagedRepositoryAdminTest
assertTemplateRoleExists( repoId ); assertTemplateRoleExists( repoId );
// STAGE FIXME: check the things that should have been removed
/*
assertTrue( new File( stageRepoLocation + STAGE_REPO_ID_END ).exists() ); assertTrue( new File( stageRepoLocation + STAGE_REPO_ID_END ).exists() );
assertTemplateRoleExists( repoId + STAGE_REPO_ID_END ); assertTemplateRoleExists( repoId + STAGE_REPO_ID_END );
*/
managedRepositoryAdmin.deleteManagedRepository( repo.getId(), getFakeAuditInformation(), false ); managedRepositoryAdmin.deleteManagedRepository( repo.getId(), getFakeAuditInformation(), false );
@ -302,9 +315,12 @@ public class ManagedRepositoryAdminTest
assertTemplateRoleNotExists( repoId ); assertTemplateRoleNotExists( repoId );
// STAGE FIXME: check the things that should have been removed
/*
assertTrue( new File( stageRepoLocation + STAGE_REPO_ID_END ).exists() ); assertTrue( new File( stageRepoLocation + STAGE_REPO_ID_END ).exists() );
assertTemplateRoleNotExists( repoId + STAGE_REPO_ID_END ); assertTemplateRoleNotExists( repoId + STAGE_REPO_ID_END );
*/
assertAuditListenerCallAndUpdateAddAndDelete( true ); assertAuditListenerCallAndUpdateAddAndDelete( true );

View File

@ -48,13 +48,14 @@ public class MockManagedRepositoryAdmin
for ( ManagedRepositoryConfiguration repoConfig : managedRepoConfigs ) for ( ManagedRepositoryConfiguration repoConfig : managedRepoConfigs )
{ {
// TODO add staging repo information back too
ManagedRepository repo = ManagedRepository repo =
new ManagedRepository( repoConfig.getId(), repoConfig.getName(), repoConfig.getLocation(), new ManagedRepository( repoConfig.getId(), repoConfig.getName(),
repoConfig.getLayout(), repoConfig.isSnapshots(), repoConfig.isReleases(), repoConfig.getLocation(), repoConfig.getLayout(), repoConfig.isSnapshots(),
repoConfig.isBlockRedeployments(), repoConfig.getRefreshCronExpression(), repoConfig.isReleases(), repoConfig.isBlockRedeployments(),
repoConfig.getIndexDir(), repoConfig.isScanned(), repoConfig.getDaysOlder(), repoConfig.getRefreshCronExpression(), repoConfig.getIndexDir(),
repoConfig.getRetentionCount(), repoConfig.isDeleteReleasedSnapshots(), true ); repoConfig.isScanned(), repoConfig.getDaysOlder(),
repoConfig.getRetentionCount(), repoConfig.isDeleteReleasedSnapshots(),
repoConfig.isStagingRequired() );
managedRepos.add( repo ); managedRepos.add( repo );
} }
@ -89,15 +90,14 @@ public class MockManagedRepositoryAdmin
return null; return null;
} }
public Boolean addManagedRepository( ManagedRepository managedRepository, boolean needStageRepo, public Boolean addManagedRepository( ManagedRepository managedRepository, AuditInformation auditInformation )
AuditInformation auditInformation )
throws RepositoryAdminException throws RepositoryAdminException
{ {
return null; return null;
} }
public Boolean updateManagedRepository( ManagedRepository managedRepository, boolean needStageRepo, public Boolean updateManagedRepository( ManagedRepository managedRepository, AuditInformation auditInformation,
AuditInformation auditInformation, boolean resetStats ) boolean resetStats )
throws RepositoryAdminException throws RepositoryAdminException
{ {
return null; return null;

View File

@ -99,9 +99,7 @@ public class DefaultManagedRepositoriesService
try try
{ {
return managedRepositoryAdmin.addManagedRepository( managedRepository, return managedRepositoryAdmin.addManagedRepository( managedRepository, getAuditInformation() );
managedRepository.isStageRepoNeeded(),
getAuditInformation() );
} }
catch ( RepositoryAdminException e ) catch ( RepositoryAdminException e )
{ {
@ -116,9 +114,7 @@ public class DefaultManagedRepositoriesService
try try
{ {
return managedRepositoryAdmin.updateManagedRepository( managedRepository, return managedRepositoryAdmin.updateManagedRepository( managedRepository, getAuditInformation(),
managedRepository.isStageRepoNeeded(),
getAuditInformation(),
managedRepository.isResetStats() ); managedRepository.isResetStats() );
} }
catch ( RepositoryAdminException e ) catch ( RepositoryAdminException e )

View File

@ -41,9 +41,9 @@ public class MergingRepositoriesTest
public void testAddArtifactToStagingRepository() public void testAddArtifactToStagingRepository()
{ {
addArtifact( getGroupId(), getArtifactId(), getVersion(), getPackaging(), getValidArtifactFilePath(), addArtifact( getGroupId(), getArtifactId(), getVersion(), getPackaging(), getValidArtifactFilePath(),
"merging-repo-stage", true ); "merging-repo", true );
assertTextPresent( "Artifact '" + getGroupId() + ":" + getArtifactId() + ":" + getVersion() + assertTextPresent( "Artifact '" + getGroupId() + ":" + getArtifactId() + ":" + getVersion() +
"' was successfully deployed to repository 'merging-repo-stage'" ); "' was successfully staged for repository 'merging-repo'" );
} }
// here we test the merging (no conflicts artifacts are available) // here we test the merging (no conflicts artifacts are available)
@ -92,6 +92,7 @@ public class MergingRepositoriesTest
@Test(dependsOnMethods = {"testAddArtifactToStagingRepository"}) @Test(dependsOnMethods = {"testAddArtifactToStagingRepository"})
public void testConfigurationChangesOfStagingRepository() public void testConfigurationChangesOfStagingRepository()
{ {
// STAGE FIXME: hardcoded ID
editManagedRepository(); editManagedRepository();
addArtifact( getGroupId(), getArtifactId(), getVersion(), getPackaging(), getValidArtifactFilePath(), addArtifact( getGroupId(), getArtifactId(), getVersion(), getPackaging(), getValidArtifactFilePath(),
"merging-repo-stage", true ); "merging-repo-stage", true );

View File

@ -730,7 +730,7 @@ public abstract class AbstractArchivaTest
setFieldValue( "repository.cronExpression", cron ); setFieldValue( "repository.cronExpression", cron );
setFieldValue( "repository.daysOlder", daysOlder ); setFieldValue( "repository.daysOlder", daysOlder );
setFieldValue( "repository.retentionCount", retentionCount ); setFieldValue( "repository.retentionCount", retentionCount );
checkField( "stageNeeded" ); checkField( "repository.stagingRequired" );
clickButtonWithValue( "Add Repository" ); clickButtonWithValue( "Add Repository" );
} }

View File

@ -21,7 +21,6 @@ package org.apache.archiva.web.action;
import com.opensymphony.xwork2.Preparable; import com.opensymphony.xwork2.Preparable;
import com.opensymphony.xwork2.Validateable; import com.opensymphony.xwork2.Validateable;
import org.apache.archiva.admin.model.RepositoryAdminException;
import org.apache.archiva.admin.model.beans.ManagedRepository; import org.apache.archiva.admin.model.beans.ManagedRepository;
import org.apache.archiva.admin.model.managed.ManagedRepositoryAdmin; import org.apache.archiva.admin.model.managed.ManagedRepositoryAdmin;
import org.apache.archiva.audit.AuditEvent; import org.apache.archiva.audit.AuditEvent;
@ -38,11 +37,13 @@ import org.codehaus.plexus.taskqueue.TaskQueueException;
import org.springframework.context.annotation.Scope; import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Controller; import org.springframework.stereotype.Controller;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import javax.inject.Inject; import javax.inject.Inject;
import javax.inject.Named; import javax.inject.Named;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
/** /**
* *
@ -69,104 +70,72 @@ public class MergeAction
private String repoid; private String repoid;
private String sourceRepoId; private Collection<ArtifactMetadata> conflictSourceArtifactsToBeDisplayed;
private final String action = "merge"; private static String SESSION_KEY = "default";
private final String hasConflicts = "CONFLICTS"; public String requestMerge()
throws Exception
private List<ArtifactMetadata> conflictSourceArtifacts;
private List<ArtifactMetadata> conflictSourceArtifactsToBeDisplayed;
public String getConflicts()
{ {
try if ( !repository.isStagingRequired() )
{ {
sourceRepoId = repoid + "-stage"; addActionError( "Repository [" + repository.getId() + "] is not configured for staging" );
ManagedRepository targetRepoConfig = managedRepositoryAdmin.getManagedRepository( sourceRepoId );
if ( targetRepoConfig != null )
{
return hasConflicts;
}
else
{
return ERROR;
}
}
catch ( RepositoryAdminException e )
{
addActionError( "RepositoryAdminException " + e.getMessage() );
return ERROR; return ERROR;
} }
// check for conflicts to display
HashMap<String, ArtifactMetadata> map = new LinkedHashMap<String, ArtifactMetadata>();
for ( ArtifactMetadata metadata : getConflictSourceArtifacts() )
{
String metadataId = metadata.getNamespace() + ":" + metadata.getProject() + ":" + metadata.getVersion();
map.put( metadataId, metadata );
}
conflictSourceArtifactsToBeDisplayed = map.values();
return "confirm";
} }
public String doMerge() public String doMerge()
{ {
RepositorySession repositorySession = repositorySessionFactory.createSession(); return merge( true );
try
{
MetadataRepository metadataRepository = repositorySession.getRepository();
List<ArtifactMetadata> sourceArtifacts = metadataRepository.getArtifacts( sourceRepoId );
if ( repository.isReleases() && !repository.isSnapshots() )
{
mergeWithOutSnapshots( metadataRepository, sourceArtifacts, sourceRepoId, repoid );
}
else
{
repositoryMerger.merge( metadataRepository, sourceRepoId, repoid );
for ( ArtifactMetadata metadata : sourceArtifacts )
{
triggerAuditEvent( repoid, metadata.getId(), AuditEvent.MERGING_REPOSITORIES );
}
}
scanRepository();
addActionMessage( "Repository '" + sourceRepoId + "' successfully merged to '" + repoid + "'." );
return SUCCESS;
}
catch ( Exception e )
{
log.error( e.getMessage(), e );
addActionError( "Error occurred while merging the repositories: " + e.getMessage() );
return ERROR;
}
finally
{
repositorySession.close();
}
} }
public String mergeBySkippingConflicts() public String mergeBySkippingConflicts()
{ {
return merge( false );
}
private String merge( boolean overwriteConflicts )
{
// FIXME: stage repo should only need the repoid
String sourceRepoId = null;
RepositorySession repositorySession = repositorySessionFactory.createSession(); RepositorySession repositorySession = repositorySessionFactory.createSession();
try try
{ {
MetadataRepository metadataRepository = repositorySession.getRepository(); MetadataRepository metadataRepository = repositorySession.getRepository();
List<ArtifactMetadata> sourceArtifacts = metadataRepository.getArtifacts( sourceRepoId ); List<ArtifactMetadata> sourceArtifacts = metadataRepository.getArtifacts( sourceRepoId );
sourceArtifacts.removeAll( conflictSourceArtifacts ); if ( !overwriteConflicts )
if ( repository.isReleases() && !repository.isSnapshots() )
{ {
mergeWithOutSnapshots( metadataRepository, sourceArtifacts, sourceRepoId, repoid ); sourceArtifacts.removeAll( getConflictSourceArtifacts() );
Filter<ArtifactMetadata> artifactsWithOutConflicts = new IncludesFilter<ArtifactMetadata>(
sourceArtifacts );
repositoryMerger.merge( metadataRepository, sourceRepoId, repoid, artifactsWithOutConflicts );
} }
else else
{ {
repositoryMerger.merge( metadataRepository, sourceRepoId, repoid );
Filter<ArtifactMetadata> artifactsWithOutConflicts =
new IncludesFilter<ArtifactMetadata>( sourceArtifacts );
repositoryMerger.merge( metadataRepository, sourceRepoId, repoid, artifactsWithOutConflicts );
for ( ArtifactMetadata metadata : sourceArtifacts )
{
triggerAuditEvent( repoid, metadata.getId(), AuditEvent.MERGING_REPOSITORIES );
}
} }
// FIXME: this should happen in the merge itself
for ( ArtifactMetadata metadata : sourceArtifacts )
{
triggerAuditEvent( repoid, metadata.getId(), AuditEvent.MERGING_REPOSITORIES );
}
// FIXME: this should happen in the merge itself, don't re-scan the whole thing. Make sure we test the
// results
scanRepository(); scanRepository();
addActionMessage( "Repository '" + sourceRepoId + "' successfully merged to '" + repoid + "'." ); addActionMessage( "Repository '" + sourceRepoId + "' successfully merged to '" + repoid + "'." );
@ -185,31 +154,6 @@ public class MergeAction
} }
} }
public String mergeWithOutConlficts()
{
sourceRepoId = repoid + "-stage";
RepositorySession repositorySession = repositorySessionFactory.createSession();
try
{
conflictSourceArtifacts =
repositoryMerger.getConflictingArtifacts( repositorySession.getRepository(), sourceRepoId, repoid );
}
catch ( Exception e )
{
addActionError( "Error occurred while merging the repositories." );
return ERROR;
}
finally
{
repositorySession.close();
}
addActionMessage( "Repository '" + sourceRepoId + "' successfully merged to '" + repoid + "'." );
return SUCCESS;
}
public ManagedRepository getRepository() public ManagedRepository getRepository()
{ {
return repository; return repository;
@ -223,30 +167,7 @@ public class MergeAction
public void prepare() public void prepare()
throws Exception throws Exception
{ {
sourceRepoId = repoid + "-stage";
RepositorySession repositorySession = repositorySessionFactory.createSession();
try
{
conflictSourceArtifacts =
repositoryMerger.getConflictingArtifacts( repositorySession.getRepository(), sourceRepoId, repoid );
}
finally
{
repositorySession.close();
}
this.repository = managedRepositoryAdmin.getManagedRepository( repoid ); this.repository = managedRepositoryAdmin.getManagedRepository( repoid );
setConflictSourceArtifactsToBeDisplayed( conflictSourceArtifacts );
}
public String getSourceRepoId()
{
return sourceRepoId;
}
public void setSourceRepoId( String sourceRepoId )
{
this.sourceRepoId = sourceRepoId;
} }
public String getRepoid() public String getRepoid()
@ -260,56 +181,39 @@ public class MergeAction
} }
public List<ArtifactMetadata> getConflictSourceArtifacts() public List<ArtifactMetadata> getConflictSourceArtifacts()
throws Exception
{ {
return conflictSourceArtifacts; RepositorySession repositorySession = repositorySessionFactory.createSession();
try
{
return repositoryMerger.getConflictingArtifacts( repositorySession.getRepository(), repoid );
}
finally
{
repositorySession.close();
}
} }
public void setConflictSourceArtifacts( List<ArtifactMetadata> conflictSourceArtifacts ) public Collection<ArtifactMetadata> getConflictSourceArtifactsToBeDisplayed()
{
this.conflictSourceArtifacts = conflictSourceArtifacts;
}
public List<ArtifactMetadata> getConflictSourceArtifactsToBeDisplayed()
{ {
return conflictSourceArtifactsToBeDisplayed; return conflictSourceArtifactsToBeDisplayed;
} }
public void setConflictSourceArtifactsToBeDisplayed( List<ArtifactMetadata> conflictSourceArtifacts ) private Filter<ArtifactMetadata> filterOutSnapshots( List<ArtifactMetadata> sourceArtifacts, String repoid )
throws Exception
{ {
this.conflictSourceArtifactsToBeDisplayed = new ArrayList<ArtifactMetadata>(); for ( Iterator<ArtifactMetadata> i = sourceArtifacts.iterator(); i.hasNext(); )
HashMap<String, ArtifactMetadata> map = new HashMap<String, ArtifactMetadata>();
for ( ArtifactMetadata metadata : conflictSourceArtifacts )
{ {
String metadataId = ArtifactMetadata metadata = i.next();
metadata.getNamespace() + metadata.getProject() + metadata.getProjectVersion() + metadata.getVersion();
map.put( metadataId, metadata );
}
conflictSourceArtifactsToBeDisplayed.addAll( map.values() );
}
private void mergeWithOutSnapshots( MetadataRepository metadataRepository, List<ArtifactMetadata> sourceArtifacts,
String sourceRepoId, String repoid )
throws Exception
{
List<ArtifactMetadata> artifactsWithOutSnapshots = new ArrayList<ArtifactMetadata>();
for ( ArtifactMetadata metadata : sourceArtifacts )
{
if ( metadata.getProjectVersion().contains( "SNAPSHOT" ) ) if ( metadata.getProjectVersion().contains( "SNAPSHOT" ) )
{ {
artifactsWithOutSnapshots.add( metadata ); i.remove();
} }
else else
{ {
triggerAuditEvent( repoid, metadata.getId(), AuditEvent.MERGING_REPOSITORIES ); triggerAuditEvent( repoid, metadata.getId(), AuditEvent.MERGING_REPOSITORIES );
} }
} }
sourceArtifacts.removeAll( artifactsWithOutSnapshots ); return new IncludesFilter<ArtifactMetadata>( sourceArtifacts );
Filter<ArtifactMetadata> artifactListWithOutSnapShots = new IncludesFilter<ArtifactMetadata>( sourceArtifacts );
repositoryMerger.merge( metadataRepository, sourceRepoId, repoid, artifactListWithOutSnapShots );
} }
private void scanRepository() private void scanRepository()
@ -346,4 +250,4 @@ public class MergeAction
{ {
this.managedRepositoryAdmin = managedRepositoryAdmin; this.managedRepositoryAdmin = managedRepositoryAdmin;
} }
} }

View File

@ -292,6 +292,7 @@ public class UploadAction
{ {
try try
{ {
// STAGE FIXME: handle staging, reduce external duplication - should be a wrapper like block redeployment
ManagedRepository repoConfig = managedRepositoryAdmin.getManagedRepository( repositoryId ); ManagedRepository repoConfig = managedRepositoryAdmin.getManagedRepository( repositoryId );
ArtifactReference artifactReference = new ArtifactReference(); ArtifactReference artifactReference = new ArtifactReference();
@ -424,6 +425,7 @@ public class UploadAction
} }
} }
// STAGE FIXME: if it was staged, say "staged for"
String msg = "Artifact \'" + groupId + ":" + artifactId + ":" + version String msg = "Artifact \'" + groupId + ":" + artifactId + ":" + version
+ "\' was successfully deployed to repository \'" + repositoryId + "\'"; + "\' was successfully deployed to repository \'" + repositoryId + "\'";

View File

@ -44,8 +44,6 @@ public class AddManagedRepositoryAction
private ManagedRepository repository; private ManagedRepository repository;
private boolean stageNeeded;
private String action = "addRepository"; private String action = "addRepository";
public void prepare() public void prepare()
@ -54,6 +52,7 @@ public class AddManagedRepositoryAction
this.repository.setReleases( false ); this.repository.setReleases( false );
this.repository.setScanned( false ); this.repository.setScanned( false );
this.repository.setBlockRedeployments( false ); this.repository.setBlockRedeployments( false );
this.repository.setStagingRequired( false );
} }
public String input() public String input()
@ -88,7 +87,7 @@ public class AddManagedRepositoryAction
String result = SUCCESS; String result = SUCCESS;
try try
{ {
getManagedRepositoryAdmin().addManagedRepository( repository, stageNeeded, getAuditInformation() ); getManagedRepositoryAdmin().addManagedRepository( repository, getAuditInformation() );
} }
catch ( RepositoryAdminException e ) catch ( RepositoryAdminException e )
{ {
@ -147,12 +146,6 @@ public class AddManagedRepositoryAction
this.repository = repository; this.repository = repository;
} }
public void setStageNeeded( boolean stageNeeded )
{
this.stageNeeded = stageNeeded;
}
public String getAction() public String getAction()
{ {
return action; return action;

View File

@ -41,8 +41,6 @@ public class DeleteManagedRepositoryAction
private ManagedRepository repository; private ManagedRepository repository;
private ManagedRepository stagingRepository;
private String repoid; private String repoid;
public void prepare() public void prepare()
@ -51,7 +49,6 @@ public class DeleteManagedRepositoryAction
if ( StringUtils.isNotBlank( repoid ) ) if ( StringUtils.isNotBlank( repoid ) )
{ {
this.repository = getManagedRepositoryAdmin().getManagedRepository( repoid ); this.repository = getManagedRepositoryAdmin().getManagedRepository( repoid );
this.stagingRepository = getManagedRepositoryAdmin().getManagedRepository( repoid + "-stage" );
} }
} }

View File

@ -44,15 +44,10 @@ public class EditManagedRepositoryAction
private ManagedRepository repository; private ManagedRepository repository;
private ManagedRepository stagingRepository;
private String repoid; private String repoid;
private final String action = "editRepository"; private final String action = "editRepository";
private boolean stageNeeded;
// FIXME better error message // FIXME better error message
public void prepare() public void prepare()
throws RepositoryAdminException throws RepositoryAdminException
@ -60,12 +55,12 @@ public class EditManagedRepositoryAction
if ( StringUtils.isNotBlank( repoid ) ) if ( StringUtils.isNotBlank( repoid ) )
{ {
repository = getManagedRepositoryAdmin().getManagedRepository( repoid ); repository = getManagedRepositoryAdmin().getManagedRepository( repoid );
stagingRepository = getManagedRepositoryAdmin().getManagedRepository( repoid + "-stage" );
} }
else if ( repository != null ) else if ( repository != null )
{ {
repository.setReleases( false ); repository.setReleases( false );
repository.setScanned( false ); repository.setScanned( false );
repository.setStagingRequired( false );
} }
} }
@ -115,7 +110,7 @@ public class EditManagedRepositoryAction
String result = SUCCESS; String result = SUCCESS;
try try
{ {
getManagedRepositoryAdmin().updateManagedRepository( repository, stageNeeded, getAuditInformation(), getManagedRepositoryAdmin().updateManagedRepository( repository, getAuditInformation(),
resetStats ); resetStats );
} }
catch ( RepositoryAdminException e ) catch ( RepositoryAdminException e )
@ -175,17 +170,6 @@ public class EditManagedRepositoryAction
} }
public boolean isStageNeeded()
{
return stageNeeded;
}
public void setStageNeeded( boolean stageNeeded )
{
this.stageNeeded = stageNeeded;
}
public String getAction() public String getAction()
{ {
return action; return action;
@ -200,14 +184,4 @@ public class EditManagedRepositoryAction
{ {
this.repository = repository; this.repository = repository;
} }
public ManagedRepository getStagingRepository()
{
return stagingRepository;
}
public void setStagingRepository( ManagedRepository stagingRepository )
{
this.stagingRepository = stagingRepository;
}
} }

View File

@ -43,13 +43,13 @@ import org.codehaus.redback.integration.interceptor.SecureActionException;
import org.springframework.context.annotation.Scope; import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Controller; import org.springframework.stereotype.Controller;
import javax.inject.Inject;
import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collections; import java.util.Collections;
import java.util.HashMap; import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import javax.inject.Inject;
import javax.servlet.http.HttpServletRequest;
/** /**
* Shows the Repositories Tab for the administrator. * Shows the Repositories Tab for the administrator.
@ -152,10 +152,7 @@ public class RepositoriesAction
List<ManagedRepository> managedRepositoriesList = new ArrayList<ManagedRepository>(); List<ManagedRepository> managedRepositoriesList = new ArrayList<ManagedRepository>();
for ( ManagedRepository repoConfig : managedRepositories ) for ( ManagedRepository repoConfig : managedRepositories )
{ {
if ( !repoConfig.getId().endsWith( "-stage" ) ) managedRepositoriesList.add( repoConfig );
{
managedRepositoriesList.add( repoConfig );
}
} }
return managedRepositoriesList; return managedRepositoriesList;
} }

View File

@ -415,8 +415,8 @@
</action> </action>
<action name="merge" class="mergeAction" method="getConflicts"> <action name="merge" class="mergeAction" method="requestMerge">
<result name="CONFLICTS">/WEB-INF/jsp/admin/mergeExcludeConflicts.jsp</result> <result name="confirm">/WEB-INF/jsp/admin/mergeExcludeConflicts.jsp</result>
<result name="success">/WEB-INF/jsp/admin/mergeResults.jsp</result> <result name="success">/WEB-INF/jsp/admin/mergeResults.jsp</result>
<interceptor-ref name="configuredPrepareParamsStack"/> <interceptor-ref name="configuredPrepareParamsStack"/>
</action> </action>

View File

@ -49,7 +49,6 @@
<s:form method="post" action="addRepository!commit" namespace="/admin" validate="true"> <s:form method="post" action="addRepository!commit" namespace="/admin" validate="true">
<s:textfield name="repository.id" label="Identifier" size="10" required="true"/> <s:textfield name="repository.id" label="Identifier" size="10" required="true"/>
<%@ include file="/WEB-INF/jsp/admin/include/repositoryForm.jspf" %> <%@ include file="/WEB-INF/jsp/admin/include/repositoryForm.jspf" %>
<s:checkbox name="stageNeeded" value="stageNeeded" label="Create stage repository"/>
<s:submit value="Add Repository"/> <s:submit value="Add Repository"/>
</s:form> </s:form>

View File

@ -52,15 +52,6 @@
<s:hidden name="repository.id"/> <s:hidden name="repository.id"/>
<s:label label="ID" name="repository.id" /> <s:label label="ID" name="repository.id" />
<%@ include file="/WEB-INF/jsp/admin/include/repositoryForm.jspf" %> <%@ include file="/WEB-INF/jsp/admin/include/repositoryForm.jspf" %>
<c:choose>
<c:when test="${empty(stagingRepository)}">
<s:checkbox id="stageNeeded" name="stageNeeded" value="false" label="Create stage repository"/>
</c:when>
<c:otherwise>
<s:checkbox name="stageNeeded" value="true" label="Create stage repository"/>
</c:otherwise>
</c:choose>
<s:submit value="Update Repository"/> <s:submit value="Update Repository"/>
</s:form> </s:form>

View File

@ -34,3 +34,4 @@
<s:checkbox name="repository.scanned" value="repository.scanned" label="Scannable"/> <s:checkbox name="repository.scanned" value="repository.scanned" label="Scannable"/>
<s:checkbox name="repository.deleteReleasedSnapshots" value="repository.deleteReleasedSnapshots" <s:checkbox name="repository.deleteReleasedSnapshots" value="repository.deleteReleasedSnapshots"
label="Delete Released Snapshots"/> label="Delete Released Snapshots"/>
<s:checkbox name="repository.stagingRequired" value="repository.stagingRequired" label="Require staging repository"/>

View File

@ -36,79 +36,38 @@
</p> </p>
<div class="infobox"> <div class="infobox">
<table class="infotable"> <c:choose>
<c:when test="${empty (conflictSourceArtifactsToBeDisplayed)}">
<h1>No conflicting artifacts</h1>
<c:choose> <s:form method="post" action="merge" namespace="/admin" validate="false" theme="simple">
<c:when test="${empty (conflictSourceArtifacts)}"> <s:hidden name="repoid"/>
<h1>No conflicting artifacts</h1> <div class="buttons">
<s:submit value="Merge All" method="doMerge"/>
<c:if test="${!repository.snapshots and repository.releases}"> </div>
<div class="warningbox"> </s:form>
<p> </c:when>
<strong>WARNING: Repository "${repoid}" does not allow to merge snapshots</strong> <c:otherwise>
</p> <div class="warningbox">
</div> <p><strong>WARNING! The following are the artifacts in conflict:</strong></p>
</c:if> </div>
<table class="infotable">
<s:form method="post" action="merge" namespace="/admin" validate="false" theme="simple"> <c:forEach items="${conflictSourceArtifactsToBeDisplayed}" var="artifact">
<s:hidden name="repoid"/>
<div class="buttons">
<s:submit value="Merge All" method="doMerge"/>
</div>
</s:form>
</c:when>
<c:otherwise>
<div class="warningbox">
<c:if test="${!repository.snapshots and repository.releases}">
<p>
<strong>WARNING: Repository "${repoid}" does not allow to merge snapshots</strong>
</p>
</c:if>
<p>
<strong>WARNING: The following are the artifacts in conflict.</strong>
</p>
</div>
<c:forEach items="${conflictSourceArtifactsToBeDisplayed}" var="artifact">
<tr>
<td>Artifact Id :</td>
<%--<td><code>${artifact.id}</code></td>--%>
<td align="left"> <code>${artifact.namespace} ${" "} ${artifact.project} ${" "} ${artifact.version}</code></td>
</tr>
</c:forEach>
<tr> <tr>
<td> <td>Artifact Id :</td>
<s:form action="merge" method="post" namespace="/admin" validate="false"> <td align="left"> <code>${artifact.namespace} : ${artifact.project} : ${artifact.version}</code></td>
<s:hidden name="repoid"/>
<div class="buttons">
<table>
<tr>
<td>
<table>
<tr>
<td>
<s:submit value="Merge All" method="doMerge"/>
</td>
</tr>
</table>
</td>
<td>
<table>
<tr>
<td>
<s:submit value="Merge With Skip" method="mergeBySkippingConflicts"/>
</td>
</tr>
</table>
</td>
</tr>
</table>
</div>
</s:form>
</td>
</tr> </tr>
</c:otherwise> </c:forEach>
</c:choose> </table>
</table> <s:form action="merge" method="post" namespace="/admin" validate="false">
<s:hidden name="repoid"/>
<div class="buttons">
<s:submit value="Merge and Overwrite Conflicts" method="doMerge"/>
<s:submit value="Merge and Skip Conflicts" method="mergeBySkippingConflicts"/>
</div>
</s:form>
</c:otherwise>
</c:choose>
</div> </div>
</body> </body>
</html> </html>

View File

@ -271,21 +271,13 @@
<archiva:copy-paste-snippet object="${repository}" wrapper="toggle" /> <archiva:copy-paste-snippet object="${repository}" wrapper="toggle" />
</td> </td>
</tr> </tr>
<c:if test="${repository.stagingRequired}">
<tr>
<c:set var="str" value="${repository.id}" /> <th>
<jsp:useBean id="str" type="java.lang.String" scope="page"/> Stage repository location
<c:set var="location" value="${repository.location}"/> </th>
<jsp:useBean id="location" type="java.lang.String" scope="page"/>
<%-- TODO: fix this hard coding - make stage repository configuration more transparent than the actual ManagedRepositoryConfiguration --%>
<c:if test='<%= new File (new File(location ).getParent() ,str + "-stage" ).exists()%>'>
<tr>
<th>
stage repository location
</th>
<td> <td>
${repository.location}${'-stage'} ${repository.stagingLocation}
</td> </td>
</tr> </tr>
<redback:ifAuthorized permission="archiva-merge-repository" resource="${repository.id}"> <redback:ifAuthorized permission="archiva-merge-repository" resource="${repository.id}">
@ -294,22 +286,12 @@
<td> <td>
<s:form action="merge" theme="simple"> <s:form action="merge" theme="simple">
<s:hidden name="repoid" value="%{#attr.repository.id}"/> <s:hidden name="repoid" value="%{#attr.repository.id}"/>
<%--<s:hidden name="repository" value="%{repository}"/>--%> <s:submit id="Merge" value="Merge"/>
<table>
<tr>
<td><s:submit id="Merge" value="Merge"/></td>
</tr>
</table>
</s:form> </s:form>
</td> </td>
</tr> </tr>
</redback:ifAuthorized> </redback:ifAuthorized>
</c:if>
</c:if>
</table> </table>
</div> </div>

View File

@ -1,42 +0,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.
--%>
<%-- http://www.opensymphony.com/webwork/wikidocs/File%20Upload%20Interceptor.html --%>
<%@ page contentType="text/html; charset=UTF-8" %>
<%@ taglib prefix="s" uri="/struts-tags" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<s:hidden name="repository.id"/>
<s:label label="ID" name="repository.id" />
<s:textfield name="repository.name" label="Name" size="50" required="true"/>
<s:textfield name="repository.location" label="Directory" size="50" required="true"/>
<s:textfield name="repository.indexDir" label="Index Directory" size="50"/>
<s:select list="#@java.util.LinkedHashMap@{'default' : 'Maven 2.x Repository', 'legacy' : 'Maven 1.x Repository'}"
name="repository.layout" label="Type"/>
<s:textfield name="repository.cronExpression" label="Cron" size="40" required="true"/>
<s:textfield name="repository.daysOlder" label="Repository Purge By Days Older Than" size="5"/>
<s:textfield name="repository.retentionCount" label="Repository Purge By Retention Count" size="5"/>
<s:checkbox name="repository.releases" value="repository.releases" label="Releases Included"/>
<s:checkbox name="repository.blockRedeployments" value="repository.blockRedeployments" label="Block Re-deployment of Released Artifacts"/>
<s:checkbox name="repository.snapshots" value="repository.snapshots" label="Snapshots Included"/>
<s:checkbox name="repository.scanned" value="repository.scanned" label="Scannable"/>
<s:checkbox name="repository.deleteReleasedSnapshots" value="repository.deleteReleasedSnapshots"
label="Delete Released Snapshots"/>

View File

@ -846,6 +846,8 @@ public class UploadActionTest
verifyProjectMetadataChecksums( repoLocation ); verifyProjectMetadataChecksums( repoLocation );
} }
// FIXME STAGE: test staging pushes it to the right place
ManagedRepository getManagedRepository() ManagedRepository getManagedRepository()
{ {
return new BeanReplicator().replicateBean( this.managedRepository, ManagedRepository.class ); return new BeanReplicator().replicateBean( this.managedRepository, ManagedRepository.class );

View File

@ -181,15 +181,6 @@ public class DeleteManagedRepositoryActionTest
archivaConfiguration.getConfiguration(); archivaConfiguration.getConfiguration();
archivaConfigurationControl.setReturnValue( configuration ); archivaConfigurationControl.setReturnValue( configuration );
Configuration stageRepoConfiguration = new Configuration();
stageRepoConfiguration.addManagedRepository( createStagingRepository() );
archivaConfigurationControl.setReturnValue( stageRepoConfiguration );
archivaConfiguration.getConfiguration();
archivaConfigurationControl.setReturnValue( configuration );
archivaConfigurationControl.replay(); archivaConfigurationControl.replay();
action.setRepoid( REPO_ID ); action.setRepoid( REPO_ID );
@ -344,13 +335,6 @@ public class DeleteManagedRepositoryActionTest
archivaConfiguration.getConfiguration(); archivaConfiguration.getConfiguration();
archivaConfigurationControl.setReturnValue( configuration, expectCountGetConfig ); archivaConfigurationControl.setReturnValue( configuration, expectCountGetConfig );
Configuration stageRepoConfiguration = new Configuration();
stageRepoConfiguration.addManagedRepository( createStagingRepository() );
archivaConfigurationControl.setReturnValue( stageRepoConfiguration );
archivaConfiguration.save( configuration );
// save for staging repo delete
archivaConfiguration.save( configuration ); archivaConfiguration.save( configuration );
archivaConfigurationControl.replay(); archivaConfigurationControl.replay();
@ -410,23 +394,6 @@ public class DeleteManagedRepositoryActionTest
return r; return r;
} }
private ManagedRepositoryConfiguration createStagingRepository()
{
ManagedRepositoryConfiguration r = new ManagedRepositoryConfiguration();
r.setId( REPO_ID + "-stage" );
r.setName( "repo name" );
r.setLocation( location.getAbsolutePath() );
r.setLayout( "default" );
r.setRefreshCronExpression( "* 0/5 * * * ?" );
r.setDaysOlder( 0 );
r.setRetentionCount( 0 );
r.setReleases( true );
r.setSnapshots( true );
r.setScanned( false );
r.setDeleteReleasedSnapshots( false );
return r;
}
private RemoteRepositoryConfiguration createRemoteRepository( String id, String url ) private RemoteRepositoryConfiguration createRemoteRepository( String id, String url )
{ {
RemoteRepositoryConfiguration r = new RemoteRepositoryConfiguration(); RemoteRepositoryConfiguration r = new RemoteRepositoryConfiguration();

View File

@ -154,9 +154,6 @@ public class EditManagedRepositoryActionTest
archivaConfiguration.getConfiguration(); archivaConfiguration.getConfiguration();
archivaConfigurationControl.setReturnValue( configuration ); archivaConfigurationControl.setReturnValue( configuration );
Configuration stageRepoConfiguration = new Configuration();
stageRepoConfiguration.addManagedRepository( createStagingRepository() );
archivaConfigurationControl.setReturnValue( stageRepoConfiguration );
archivaConfigurationControl.replay(); archivaConfigurationControl.replay();
@ -180,8 +177,6 @@ public class EditManagedRepositoryActionTest
public void testEditRepository() public void testEditRepository()
throws Exception throws Exception
{ {
String stageRepoId = REPO_ID + "-stage";
roleManager.templatedRoleExists( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, REPO_ID ); roleManager.templatedRoleExists( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, REPO_ID );
roleManagerControl.setReturnValue( false ); roleManagerControl.setReturnValue( false );
roleManager.createTemplatedRole( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, REPO_ID ); roleManager.createTemplatedRole( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, REPO_ID );
@ -192,16 +187,6 @@ public class EditManagedRepositoryActionTest
roleManager.createTemplatedRole( ArchivaRoleConstants.TEMPLATE_REPOSITORY_MANAGER, REPO_ID ); roleManager.createTemplatedRole( ArchivaRoleConstants.TEMPLATE_REPOSITORY_MANAGER, REPO_ID );
roleManagerControl.setVoidCallable(); roleManagerControl.setVoidCallable();
roleManager.templatedRoleExists( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, stageRepoId );
roleManagerControl.setReturnValue( false );
roleManager.createTemplatedRole( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, stageRepoId );
roleManagerControl.setVoidCallable();
roleManager.templatedRoleExists( ArchivaRoleConstants.TEMPLATE_REPOSITORY_MANAGER, stageRepoId );
roleManagerControl.setReturnValue( false );
roleManager.createTemplatedRole( ArchivaRoleConstants.TEMPLATE_REPOSITORY_MANAGER, stageRepoId );
roleManagerControl.setVoidCallable();
roleManagerControl.replay(); roleManagerControl.replay();
registry.getString( "appserver.base", "${appserver.base}" ); registry.getString( "appserver.base", "${appserver.base}" );
@ -223,13 +208,6 @@ public class EditManagedRepositoryActionTest
repositoryTaskScheduler.queueTask( task ); repositoryTaskScheduler.queueTask( task );
repositoryTaskSchedulerControl.setVoidCallable(); repositoryTaskSchedulerControl.setVoidCallable();
RepositoryTask stageTask = new RepositoryTask();
stageTask.setRepositoryId( stageRepoId );
repositoryTaskScheduler.isProcessingRepositoryTask( stageRepoId );
repositoryTaskSchedulerControl.setReturnValue( false );
repositoryTaskScheduler.queueTask( stageTask );
repositoryTaskSchedulerControl.setVoidCallable();
repositoryTaskSchedulerControl.replay(); repositoryTaskSchedulerControl.replay();
Configuration configuration = createConfigurationForEditing( createRepository() ); Configuration configuration = createConfigurationForEditing( createRepository() );
@ -241,9 +219,6 @@ public class EditManagedRepositoryActionTest
archivaConfigurationControl.setReturnValue( configuration ); archivaConfigurationControl.setReturnValue( configuration );
archivaConfigurationControl.setReturnValue( configuration ); archivaConfigurationControl.setReturnValue( configuration );
Configuration stageRepoConfiguration = new Configuration();
stageRepoConfiguration.addManagedRepository( createStagingRepository() );
archivaConfigurationControl.setReturnValue( stageRepoConfiguration );
archivaConfigurationControl.setReturnValue( configuration ); archivaConfigurationControl.setReturnValue( configuration );
archivaConfigurationControl.setReturnValue( configuration ); archivaConfigurationControl.setReturnValue( configuration );
@ -260,6 +235,7 @@ public class EditManagedRepositoryActionTest
ManagedRepository repository = action.getRepository(); ManagedRepository repository = action.getRepository();
populateRepository( repository ); populateRepository( repository );
repository.setName( "new repo name" ); repository.setName( "new repo name" );
repository.setStagingRequired( true );
MockControl repositoryStatisticsManagerControl = MockControl.createControl( RepositoryStatisticsManager.class ); MockControl repositoryStatisticsManagerControl = MockControl.createControl( RepositoryStatisticsManager.class );
RepositoryStatisticsManager repositoryStatisticsManager = RepositoryStatisticsManager repositoryStatisticsManager =
@ -269,10 +245,10 @@ public class EditManagedRepositoryActionTest
// no deletion // no deletion
repositoryStatisticsManagerControl.replay(); repositoryStatisticsManagerControl.replay();
// STAGE FIXME: hardcoded ID
new File( "target/test/" + REPO_ID + "-stage" ).mkdirs(); new File( "target/test/" + REPO_ID + "-stage" ).mkdirs();
action.setRepository( repository ); action.setRepository( repository );
action.setStageNeeded( true );
String status = action.commit(); String status = action.commit();
assertEquals( Action.SUCCESS, status ); assertEquals( Action.SUCCESS, status );
@ -301,6 +277,7 @@ public class EditManagedRepositoryActionTest
roleManager.createTemplatedRole( ArchivaRoleConstants.TEMPLATE_REPOSITORY_MANAGER, REPO_ID ); roleManager.createTemplatedRole( ArchivaRoleConstants.TEMPLATE_REPOSITORY_MANAGER, REPO_ID );
roleManagerControl.setVoidCallable(); roleManagerControl.setVoidCallable();
// STAGE FIXME: hardcoded ID
roleManager.templatedRoleExists( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, REPO_ID + "-stage" ); roleManager.templatedRoleExists( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, REPO_ID + "-stage" );
roleManagerControl.setReturnValue( false ); roleManagerControl.setReturnValue( false );
roleManager.createTemplatedRole( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, REPO_ID + "-stage" ); roleManager.createTemplatedRole( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, REPO_ID + "-stage" );
@ -345,15 +322,8 @@ public class EditManagedRepositoryActionTest
archivaConfigurationControl.setReturnValue( buildEasyConfiguration() ); archivaConfigurationControl.setReturnValue( buildEasyConfiguration() );
Configuration stageRepoConfiguration = buildEasyConfiguration();
stageRepoConfiguration.addManagedRepository( createStagingRepository() );
archivaConfigurationControl.setReturnValue( stageRepoConfiguration );
archivaConfigurationControl.setReturnValue( configuration );
archivaConfigurationControl.setReturnValue( configuration ); archivaConfigurationControl.setReturnValue( configuration );
archivaConfiguration.save( configuration );
configuration.addManagedRepository( stageRepoConfiguration.getManagedRepositories().get( 0 ) );
archivaConfiguration.save( configuration ); archivaConfiguration.save( configuration );
archivaConfiguration.save( configuration ); archivaConfiguration.save( configuration );
@ -367,9 +337,11 @@ public class EditManagedRepositoryActionTest
repositoryStatisticsManager.deleteStatistics( metadataRepository, REPO_ID ); repositoryStatisticsManager.deleteStatistics( metadataRepository, REPO_ID );
repositoryStatisticsManagerControl.replay(); repositoryStatisticsManagerControl.replay();
// STAGE FIXME: hardcoded ID
new File( "target/test/location/" + REPO_ID + "-stage" ).mkdirs(); new File( "target/test/location/" + REPO_ID + "-stage" ).mkdirs();
action.setStageNeeded( true ); // FIXME: stage setting needed
// action.setStageNeeded( true );
action.setRepoid( REPO_ID ); action.setRepoid( REPO_ID );
action.prepare(); action.prepare();
assertEquals( REPO_ID, action.getRepoid() ); assertEquals( REPO_ID, action.getRepoid() );
@ -599,29 +571,4 @@ public class EditManagedRepositoryActionTest
populateRepository( r ); populateRepository( r );
return r; return r;
} }
private ManagedRepositoryConfiguration createStagingRepository()
throws IOException
{
ManagedRepositoryConfiguration r = new ManagedRepositoryConfiguration();
r.setId( REPO_ID + "-stage" );
populateStagingRepository( r );
return r;
}
private void populateStagingRepository( ManagedRepositoryConfiguration repository )
throws IOException
{
repository.setId( REPO_ID + "-stage" );
repository.setName( "repo name" );
repository.setLocation( "${appserver.base}/location" );
repository.setLayout( "default" );
repository.setRefreshCronExpression( "* 0/5 * * * ?" );
repository.setDaysOlder( 31 );
repository.setRetentionCount( 20 );
repository.setReleases( true );
repository.setSnapshots( true );
repository.setScanned( false );
repository.setDeleteReleasedSnapshots( true );
}
} }

View File

@ -83,16 +83,16 @@ import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Named;
import javax.servlet.http.HttpServletResponse;
import java.io.File; import java.io.File;
import java.io.FileNotFoundException; import java.io.FileNotFoundException;
import java.io.FileReader; import java.io.FileReader;
import java.io.IOException; import java.io.IOException;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Named;
import javax.servlet.http.HttpServletResponse;
/** /**
* *
@ -253,10 +253,11 @@ public class ArchivaDavResourceFactory
} }
else else
{ {
ManagedRepositoryContent managedRepository = null; ManagedRepositoryContent managedRepository;
try try
{ {
// STAGE FIXME: replace with pseudo staging repository when needed - good time to switch to new repository API, and probably only use config here
managedRepository = repositoryFactory.getManagedRepositoryContent( archivaLocator.getRepositoryId() ); managedRepository = repositoryFactory.getManagedRepositoryContent( archivaLocator.getRepositoryId() );
} }
catch ( RepositoryNotFoundException e ) catch ( RepositoryNotFoundException e )
@ -315,7 +316,7 @@ public class ArchivaDavResourceFactory
} }
else else
{ {
if ( resourcesInAbsolutePath != null && resourcesInAbsolutePath.size() > 1 ) if ( resourcesInAbsolutePath.size() > 1 )
{ {
// merge the metadata of all repos under group // merge the metadata of all repos under group
ArchivaRepositoryMetadata mergedMetadata = new ArchivaRepositoryMetadata(); ArchivaRepositoryMetadata mergedMetadata = new ArchivaRepositoryMetadata();
@ -534,16 +535,19 @@ public class ArchivaDavResourceFactory
// check if target repo is enabled for releases // check if target repo is enabled for releases
// we suppose that release-artifacts can be deployed only to repos enabled for releases // we suppose that release-artifacts can be deployed only to repos enabled for releases
if ( managedRepository.getRepository().isReleases() && !repositoryRequest.isMetadata( resourcePath ) // also ignore flag for staging repositories, no harm in redeploying there
&& !repositoryRequest.isSupportFile( resourcePath ) ) if ( managedRepository.getRepository().isReleases() && !repositoryRequest.isMetadata( resourcePath ) &&
!repositoryRequest.isSupportFile( resourcePath ) &&
!managedRepository.getRepository().isStagingRequired() )
{ {
ArtifactReference artifact = null; ArtifactReference artifact;
try try
{ {
artifact = managedRepository.toArtifactReference( resourcePath ); artifact = managedRepository.toArtifactReference( resourcePath );
if ( !VersionUtil.isSnapshot( artifact.getVersion() ) ) if ( !VersionUtil.isSnapshot( artifact.getVersion() ) )
{ {
// STAGE FIXME: make sure staging was already considered
// check if artifact already exists and if artifact re-deployment to the repository is allowed // check if artifact already exists and if artifact re-deployment to the repository is allowed
if ( managedRepository.hasContent( artifact ) if ( managedRepository.hasContent( artifact )
&& managedRepository.getRepository().isBlockRedeployments() ) && managedRepository.getRepository().isBlockRedeployments() )

View File

@ -141,13 +141,13 @@ public class ArchivaDavResourceFactoryTest
{ {
defaultManagedRepositoryAdmin.addManagedRepository( defaultManagedRepositoryAdmin.addManagedRepository(
createManagedRepository( RELEASES_REPO, new File( "target/test-classes/" + RELEASES_REPO ).getPath(), createManagedRepository( RELEASES_REPO, new File( "target/test-classes/" + RELEASES_REPO ).getPath(),
"default" ), false, null ); "default" ), null );
} }
if ( defaultManagedRepositoryAdmin.getManagedRepository( INTERNAL_REPO ) == null ) if ( defaultManagedRepositoryAdmin.getManagedRepository( INTERNAL_REPO ) == null )
{ {
defaultManagedRepositoryAdmin.addManagedRepository( defaultManagedRepositoryAdmin.addManagedRepository(
createManagedRepository( INTERNAL_REPO, new File( "target/test-classes/" + INTERNAL_REPO ).getPath(), createManagedRepository( INTERNAL_REPO, new File( "target/test-classes/" + INTERNAL_REPO ).getPath(),
"default" ), false, null ); "default" ), null );
} }
RepositoryGroup repoGroupConfig = new RepositoryGroup(); RepositoryGroup repoGroupConfig = new RepositoryGroup();
repoGroupConfig.setId( LOCAL_REPO_GROUP ); repoGroupConfig.setId( LOCAL_REPO_GROUP );
@ -335,7 +335,7 @@ public class ArchivaDavResourceFactoryTest
defaultManagedRepositoryAdmin.addManagedRepository( defaultManagedRepositoryAdmin.addManagedRepository(
createManagedRepository( LOCAL_MIRROR_REPO, new File( "target/test-classes/local-mirror" ).getPath(), createManagedRepository( LOCAL_MIRROR_REPO, new File( "target/test-classes/local-mirror" ).getPath(),
"default" ), false, null ); "default" ), null );
List<RepositoryGroupConfiguration> repoGroups = new ArrayList<RepositoryGroupConfiguration>(); List<RepositoryGroupConfiguration> repoGroups = new ArrayList<RepositoryGroupConfiguration>();
RepositoryGroupConfiguration repoGroup = new RepositoryGroupConfiguration(); RepositoryGroupConfiguration repoGroup = new RepositoryGroupConfiguration();
@ -506,7 +506,7 @@ public class ArchivaDavResourceFactoryTest
{ {
defaultManagedRepositoryAdmin.addManagedRepository( defaultManagedRepositoryAdmin.addManagedRepository(
createManagedRepository( LEGACY_REPO, new File( "target/test-classes/" + LEGACY_REPO ).getPath(), createManagedRepository( LEGACY_REPO, new File( "target/test-classes/" + LEGACY_REPO ).getPath(),
"legacy" ), false, null ); "legacy" ), null );
DavResourceLocator locator = DavResourceLocator locator =
new ArchivaDavResourceLocator( "", "/repository/" + LEGACY_REPO + "/eclipse/maven-metadata.xml", new ArchivaDavResourceLocator( "", "/repository/" + LEGACY_REPO + "/eclipse/maven-metadata.xml",
LEGACY_REPO, new ArchivaDavLocatorFactory() ); LEGACY_REPO, new ArchivaDavLocatorFactory() );

View File

@ -87,8 +87,6 @@ public class AdministrationServiceImpl
private RepositoryMerger repositoryMerger; private RepositoryMerger repositoryMerger;
private static final String STAGE = "-stage";
private AuditListener auditListener; private AuditListener auditListener;
private RepositorySessionFactory repositorySessionFactory; private RepositorySessionFactory repositorySessionFactory;
@ -360,7 +358,7 @@ public class AdministrationServiceImpl
public Boolean addManagedRepository( String repoId, String layout, String name, String location, public Boolean addManagedRepository( String repoId, String layout, String name, String location,
boolean blockRedeployments, boolean releasesIncluded, boolean blockRedeployments, boolean releasesIncluded,
boolean snapshotsIncluded, boolean stageRepoNeeded, String cronExpression, boolean snapshotsIncluded, boolean stagingRequired, String cronExpression,
int daysOlder, int retentionCount, boolean deleteReleasedSnapshots ) int daysOlder, int retentionCount, boolean deleteReleasedSnapshots )
throws Exception throws Exception
{ {
@ -370,8 +368,8 @@ public class AdministrationServiceImpl
snapshotsIncluded, releasesIncluded, snapshotsIncluded, releasesIncluded,
blockRedeployments, cronExpression, null, false, blockRedeployments, cronExpression, null, false,
daysOlder, retentionCount, daysOlder, retentionCount,
deleteReleasedSnapshots, false ); deleteReleasedSnapshots, stagingRequired );
return managedRepositoryAdmin.addManagedRepository( repository, stageRepoNeeded, getAuditInformation() ); return managedRepositoryAdmin.addManagedRepository( repository, getAuditInformation() );
} }
@ -495,9 +493,7 @@ public class AdministrationServiceImpl
public boolean merge( String repoId, boolean skipConflicts ) public boolean merge( String repoId, boolean skipConflicts )
throws Exception throws Exception
{ {
String stagingId = repoId + STAGE;
org.apache.archiva.admin.model.beans.ManagedRepository repoConfig; org.apache.archiva.admin.model.beans.ManagedRepository repoConfig;
org.apache.archiva.admin.model.beans.ManagedRepository stagingConfig;
repoConfig = managedRepositoryAdmin.getManagedRepository( repoId ); repoConfig = managedRepositoryAdmin.getManagedRepository( repoId );
@ -509,10 +505,11 @@ public class AdministrationServiceImpl
MetadataRepository metadataRepository = repositorySession.getRepository(); MetadataRepository metadataRepository = repositorySession.getRepository();
if ( repoConfig != null ) if ( repoConfig != null )
{ {
stagingConfig = managedRepositoryAdmin.getManagedRepository( stagingId ); String stagingId = "foo";
if ( repoConfig.isStagingRequired() )
if ( stagingConfig != null )
{ {
// STAGE FIXME: duplication with webapp - move all MergeAction to the staging module and have this
// use it - make sure this gets tested
List<ArtifactMetadata> sourceArtifacts = metadataRepository.getArtifacts( stagingId ); List<ArtifactMetadata> sourceArtifacts = metadataRepository.getArtifacts( stagingId );
if ( repoConfig.isReleases() && !repoConfig.isSnapshots() ) if ( repoConfig.isReleases() && !repoConfig.isSnapshots() )
@ -521,7 +518,7 @@ public class AdministrationServiceImpl
if ( skipConflicts ) if ( skipConflicts )
{ {
List<ArtifactMetadata> conflicts = List<ArtifactMetadata> conflicts =
repositoryMerger.getConflictingArtifacts( metadataRepository, repoId, stagingId ); repositoryMerger.getConflictingArtifacts( metadataRepository, repoId );
if ( log.isDebugEnabled() ) if ( log.isDebugEnabled() )
{ {
@ -550,7 +547,7 @@ public class AdministrationServiceImpl
if ( skipConflicts ) if ( skipConflicts )
{ {
List<ArtifactMetadata> conflicts = List<ArtifactMetadata> conflicts =
repositoryMerger.getConflictingArtifacts( metadataRepository, repoId, stagingId ); repositoryMerger.getConflictingArtifacts( metadataRepository, repoId );
if ( log.isDebugEnabled() ) if ( log.isDebugEnabled() )
{ {
@ -651,7 +648,6 @@ public class AdministrationServiceImpl
repositoryMerger.merge( metadataRepository, sourceRepoId, repoid, artifactListWithOutSnapShots ); repositoryMerger.merge( metadataRepository, sourceRepoId, repoid, artifactListWithOutSnapShots );
} }
// FIXME find a way to get user id and adress // FIXME find a way to get user id and adress
private AuditInformation getAuditInformation() private AuditInformation getAuditInformation()
{ {

View File

@ -158,8 +158,6 @@ public class AdministrationServiceImplTest
private Registry registry; private Registry registry;
private static final String STAGE = "-stage";
private DefaultManagedRepositoryAdmin managedRepositoryAdmin; private DefaultManagedRepositoryAdmin managedRepositoryAdmin;
private DefaultRemoteRepositoryAdmin remoteRepositoryAdmin; private DefaultRemoteRepositoryAdmin remoteRepositoryAdmin;
@ -813,6 +811,7 @@ public class AdministrationServiceImplTest
throws Exception throws Exception
{ {
archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config, 1, 5 ); archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config, 1, 5 );
// STAGE FIXME: verify no staging
configControl.expectAndReturn( config.getManagedRepositories(), configControl.expectAndReturn( config.getManagedRepositories(),
Arrays.asList( createManagedRepo( "repo", "default", "repo", true, false ) ), 1, Arrays.asList( createManagedRepo( "repo", "default", "repo", true, false ) ), 1,
@ -848,18 +847,18 @@ public class AdministrationServiceImplTest
ManagedRepositoryConfiguration merge = createManagedRepo( "merge", "default", "merge", true, true ); ManagedRepositoryConfiguration merge = createManagedRepo( "merge", "default", "merge", true, true );
merge.setLocation( "target/test-repository/merge" ); merge.setLocation( "target/test-repository/merge" );
ManagedRepositoryConfiguration staging = createStagingRepo( merge );
RepositoryTask task = new RepositoryTask(); RepositoryTask task = new RepositoryTask();
task.setScanAll( true ); task.setScanAll( true );
archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config, 1, 5 ); archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config, 1, 5 );
configControl.expectAndReturn( config.getManagedRepositories(), Arrays.asList( merge, staging ), 1, 5 ); configControl.expectAndReturn( config.getManagedRepositories(), Arrays.asList( merge ), 1, 5 );
// STAGE FIXME: verify no staging
metadataRepositoryControl.expectAndReturn( metadataRepository.getArtifacts( staging.getId() ), sources ); // metadataRepositoryControl.expectAndReturn( metadataRepository.getArtifacts( staging.getId() ), sources );
repositoryMergerControl.expectAndDefaultReturn( repositoryMergerControl.expectAndDefaultReturn(
repositoryMerger.getConflictingArtifacts( metadataRepository, staging.getId(), merge.getId() ), sources ); repositoryMerger.getConflictingArtifacts( metadataRepository, merge.getId() ), sources );
repositoryMerger.merge( metadataRepository, staging.getId(), merge.getId() ); // repositoryMerger.merge( metadataRepository, staging.getId(), merge.getId() );
repositoryMergerControl.setVoidCallable(); repositoryMergerControl.setVoidCallable();
repositoryTaskSchedulerControl.expectAndReturn( repositoryTaskScheduler.isProcessingRepositoryTask( "merge" ), repositoryTaskSchedulerControl.expectAndReturn( repositoryTaskScheduler.isProcessingRepositoryTask( "merge" ),
false ); false );
@ -919,15 +918,14 @@ public class AdministrationServiceImplTest
ManagedRepositoryConfiguration repo = createManagedRepo( "repo", "default", "repo", true, true ); ManagedRepositoryConfiguration repo = createManagedRepo( "repo", "default", "repo", true, true );
repo.setLocation( "target/test-repository/one" ); repo.setLocation( "target/test-repository/one" );
ManagedRepositoryConfiguration staging = createStagingRepo( repo );
configControl.expectAndReturn( config.getManagedRepositories(), Arrays.asList( repo, staging ), 1, 5 ); configControl.expectAndReturn( config.getManagedRepositories(), Arrays.asList( repo ), 1, 5 );
archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config, 1, 5 ); archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config, 1, 5 );
metadataRepositoryControl.expectAndReturn( metadataRepository.getArtifacts( staging.getId() ), sources ); // FIXME STAGE: get sources
repositoryMergerControl.expectAndDefaultReturn( repositoryMergerControl.expectAndDefaultReturn(
repositoryMerger.getConflictingArtifacts( metadataRepository, staging.getId(), repo.getId() ), conflicts ); repositoryMerger.getConflictingArtifacts( metadataRepository, repo.getId() ), conflicts );
repositoryMerger.merge( metadataRepository, staging.getId(), repo.getId(), artifactsWithOutConflicts ); repositoryMerger.merge( metadataRepository, null, repo.getId(), artifactsWithOutConflicts );
repositoryMergerControl.setMatcher( MockControl.ALWAYS_MATCHER ); repositoryMergerControl.setMatcher( MockControl.ALWAYS_MATCHER );
repositoryMergerControl.setVoidCallable(); repositoryMergerControl.setVoidCallable();
repositoryTaskSchedulerControl.expectAndReturn( repositoryTaskScheduler.isProcessingRepositoryTask( "repo" ), repositoryTaskSchedulerControl.expectAndReturn( repositoryTaskScheduler.isProcessingRepositoryTask( "repo" ),
@ -967,6 +965,7 @@ public class AdministrationServiceImplTest
String layout = "default"; String layout = "default";
String name = projId + " Releases"; String name = projId + " Releases";
String releaseLocation = "target/test-repository/" + projId + ".releases"; String releaseLocation = "target/test-repository/" + projId + ".releases";
// STAGE FIXME: hardcoded ID
String stageLocation = releaseLocation + "-stage"; String stageLocation = releaseLocation + "-stage";
String appserverBase = "target"; String appserverBase = "target";
@ -999,6 +998,7 @@ public class AdministrationServiceImplTest
roleManager.createTemplatedRole( ArchivaRoleConstants.TEMPLATE_REPOSITORY_MANAGER, repoId ); roleManager.createTemplatedRole( ArchivaRoleConstants.TEMPLATE_REPOSITORY_MANAGER, repoId );
roleManagerControl.setVoidCallable(); roleManagerControl.setVoidCallable();
// STAGE FIXME: hardcoded ID
roleManager.templatedRoleExists( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, repoId + "-stage" ); roleManager.templatedRoleExists( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, repoId + "-stage" );
roleManagerControl.setReturnValue( false ); roleManagerControl.setReturnValue( false );
roleManager.createTemplatedRole( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, repoId + "-stage" ); roleManager.createTemplatedRole( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, repoId + "-stage" );
@ -1033,7 +1033,8 @@ public class AdministrationServiceImplTest
repositoryTaskScheduler.queueTask( task ); repositoryTaskScheduler.queueTask( task );
repositoryTaskSchedulerControl.setVoidCallable(); repositoryTaskSchedulerControl.setVoidCallable();
//staged repo //STAGE FIXME: hardcoded id
String STAGE="-stage";
repositoryTaskSchedulerControl.expectAndReturn( repositoryTaskSchedulerControl.expectAndReturn(
repositoryTaskScheduler.isProcessingRepositoryTask( repoId + STAGE ), false ); repositoryTaskScheduler.isProcessingRepositoryTask( repoId + STAGE ), false );
task = new RepositoryTask(); task = new RepositoryTask();
@ -1259,19 +1260,6 @@ public class AdministrationServiceImplTest
return repoConfig; return repoConfig;
} }
private ManagedRepositoryConfiguration createStagingRepo( ManagedRepositoryConfiguration repoConfig )
{
ManagedRepositoryConfiguration stagingRepo = new ManagedRepositoryConfiguration();
stagingRepo.setId( repoConfig.getId() + STAGE );
stagingRepo.setLayout( repoConfig.getLayout() );
stagingRepo.setName( repoConfig + STAGE );
stagingRepo.setReleases( repoConfig.isReleases() );
stagingRepo.setSnapshots( repoConfig.isSnapshots() );
stagingRepo.setLocation( repoConfig.getLocation() );
return stagingRepo;
}
private AuditEvent createAuditEvent( ManagedRepositoryConfiguration repoConfig ) private AuditEvent createAuditEvent( ManagedRepositoryConfiguration repoConfig )
{ {
AuditEvent auditEvent = new AuditEvent(); AuditEvent auditEvent = new AuditEvent();

View File

@ -157,6 +157,7 @@ public class Maven2RepositoryMerger
// pom file copying // pom file copying
String fileName = artifactMetadata.getProject() + "-" + artifactMetadata.getVersion() + ".pom"; String fileName = artifactMetadata.getProject() + "-" + artifactMetadata.getVersion() + ".pom";
// STAGE FIXME: don't re-parse and construct the path - use the filename we already have
// pom file copying // pom file copying
// TODO need to use path translator to get the pom file path // TODO need to use path translator to get the pom file path
// String fileName = artifactMetadata.getProject() + "-" + artifactMetadata.getVersion() + ".pom"; // String fileName = artifactMetadata.getProject() + "-" + artifactMetadata.getVersion() + ".pom";
@ -172,10 +173,10 @@ public class Maven2RepositoryMerger
String index = artifactPath.substring( lastIndex + 1 ); String index = artifactPath.substring( lastIndex + 1 );
int last = index.lastIndexOf( '.' ); int last = index.lastIndexOf( '.' );
File sourcePomFile = new File( sourceRepoPath, artifactPath.substring( 0, lastIndex ) + "/" File sourcePomFile = new File( sourceRepoPath, artifactPath.substring( 0, lastIndex ) + "/" +
+ artifactPath.substring( lastIndex + 1 ).substring( 0, last ) + ".pom" ); artifactPath.substring( lastIndex + 1 ).substring( 0, last ) + ".pom" );
File targetPomFile = new File( targetRepoPath, artifactPath.substring( 0, lastIndex ) + "/" File targetPomFile = new File( targetRepoPath, artifactPath.substring( 0, lastIndex ) + "/" +
+ artifactPath.substring( lastIndex + 1 ).substring( 0, last ) + ".pom" ); artifactPath.substring( lastIndex + 1 ).substring( 0, last ) + ".pom" );
if ( !targetPomFile.exists() && sourcePomFile.exists() ) if ( !targetPomFile.exists() && sourcePomFile.exists() )
{ {
@ -187,15 +188,16 @@ public class Maven2RepositoryMerger
{ {
// updating version metadata files // updating version metadata files
File versionMetaDataFileInSourceRepo = File versionMetaDataFileInSourceRepo = pathTranslator.toFile( new File( sourceRepoPath ),
pathTranslator.toFile( new File( sourceRepoPath ), artifactMetadata.getNamespace(), artifactMetadata.getNamespace(),
artifactMetadata.getProject(), artifactMetadata.getVersion(), artifactMetadata.getProject(),
METADATA_FILENAME ); artifactMetadata.getVersion(),
METADATA_FILENAME );
if ( versionMetaDataFileInSourceRepo.exists() ) if ( versionMetaDataFileInSourceRepo.exists() )
{ {
String relativePathToVersionMetadataFile = String relativePathToVersionMetadataFile = versionMetaDataFileInSourceRepo.getAbsolutePath().split(
versionMetaDataFileInSourceRepo.getAbsolutePath().split( sourceRepoPath )[1]; sourceRepoPath )[1];
File versionMetaDataFileInTargetRepo = new File( targetRepoPath, relativePathToVersionMetadataFile ); File versionMetaDataFileInTargetRepo = new File( targetRepoPath, relativePathToVersionMetadataFile );
if ( !versionMetaDataFileInTargetRepo.exists() ) if ( !versionMetaDataFileInTargetRepo.exists() )
@ -215,8 +217,8 @@ public class Maven2RepositoryMerger
if ( projectMetadataFileInSourceRepo.exists() ) if ( projectMetadataFileInSourceRepo.exists() )
{ {
String relativePathToProjectMetadataFile = String relativePathToProjectMetadataFile = projectMetadataFileInSourceRepo.getAbsolutePath().split(
projectMetadataFileInSourceRepo.getAbsolutePath().split( sourceRepoPath )[1]; sourceRepoPath )[1];
File projectMetadataFileInTargetRepo = new File( targetRepoPath, relativePathToProjectMetadataFile ); File projectMetadataFileInTargetRepo = new File( targetRepoPath, relativePathToProjectMetadataFile );
if ( !projectMetadataFileInTargetRepo.exists() ) if ( !projectMetadataFileInTargetRepo.exists() )
@ -234,6 +236,7 @@ public class Maven2RepositoryMerger
} }
// TODO: replace with another copy method
private void copyFile( File sourceFile, File targetFile ) private void copyFile( File sourceFile, File targetFile )
throws IOException throws IOException
{ {
@ -332,12 +335,11 @@ public class Maven2RepositoryMerger
return metadata; return metadata;
} }
public List<ArtifactMetadata> getConflictingArtifacts( MetadataRepository metadataRepository, String sourceRepo, public List<ArtifactMetadata> getConflictingArtifacts( MetadataRepository metadataRepository, String targetRepo )
String targetRepo )
throws Exception throws Exception
{ {
List<ArtifactMetadata> targetArtifacts = metadataRepository.getArtifacts( targetRepo ); List<ArtifactMetadata> targetArtifacts = metadataRepository.getArtifacts( targetRepo );
List<ArtifactMetadata> sourceArtifacts = metadataRepository.getArtifacts( sourceRepo ); List<ArtifactMetadata> sourceArtifacts = Collections.emptyList(); // STAGE FIXME: metadataRepository.getArtifacts( sourceRepo );
List<ArtifactMetadata> conflictsArtifacts = new ArrayList<ArtifactMetadata>(); List<ArtifactMetadata> conflictsArtifacts = new ArrayList<ArtifactMetadata>();
for ( ArtifactMetadata targetArtifact : targetArtifacts ) for ( ArtifactMetadata targetArtifact : targetArtifacts )
@ -354,9 +356,6 @@ public class Maven2RepositoryMerger
} }
} }
sourceArtifacts.removeAll( conflictsArtifacts );
Filter<ArtifactMetadata> artifactsWithOutConflicts = new IncludesFilter<ArtifactMetadata>( sourceArtifacts );
// merge( sourceRepo, targetRepo, artifactsWithOutConflicts );
return conflictsArtifacts; return conflictsArtifacts;
} }
@ -364,10 +363,10 @@ public class Maven2RepositoryMerger
{ {
boolean isSame = false; boolean isSame = false;
if ( ( sourceArtifact.getNamespace().equals( targetArtifact.getNamespace() ) ) if ( ( sourceArtifact.getNamespace().equals( targetArtifact.getNamespace() ) ) &&
&& ( sourceArtifact.getProject().equals( targetArtifact.getProject() ) ) ( sourceArtifact.getProject().equals( targetArtifact.getProject() ) ) && ( sourceArtifact.getId().equals(
&& ( sourceArtifact.getId().equals( targetArtifact.getId() ) ) targetArtifact.getId() ) ) && ( sourceArtifact.getProjectVersion().equals(
&& ( sourceArtifact.getProjectVersion().equals( targetArtifact.getProjectVersion() ) ) ) targetArtifact.getProjectVersion() ) ) )
{ {
isSame = true; isSame = true;

View File

@ -34,7 +34,6 @@ public interface RepositoryMerger
Filter<ArtifactMetadata> filter ) Filter<ArtifactMetadata> filter )
throws Exception; throws Exception;
List<ArtifactMetadata> getConflictingArtifacts( MetadataRepository metadataRepository, String sourceRepo, List<ArtifactMetadata> getConflictingArtifacts( MetadataRepository metadataRepository, String targetRepo )
String targetRepo )
throws Exception; throws Exception;
} }

View File

@ -149,8 +149,8 @@ public class Maven2RepositoryMergerTest
when( metadataRepository.getArtifacts( sourceRepoId ) ).thenReturn( sourceRepoArtifactsList ); when( metadataRepository.getArtifacts( sourceRepoId ) ).thenReturn( sourceRepoArtifactsList );
when( metadataRepository.getArtifacts( TEST_REPO_ID ) ).thenReturn( targetRepoArtifactsList ); when( metadataRepository.getArtifacts( TEST_REPO_ID ) ).thenReturn( targetRepoArtifactsList );
assertEquals( 1, repositoryMerger.getConflictingArtifacts( metadataRepository, sourceRepoId, // STAGE FIXME: not testing the right thing
TEST_REPO_ID ).size() ); assertEquals( 1, repositoryMerger.getConflictingArtifacts( metadataRepository, TEST_REPO_ID ).size() );
verify( metadataRepository ).getArtifacts( TEST_REPO_ID ); verify( metadataRepository ).getArtifacts( TEST_REPO_ID );
} }