if (this.repository==null) {
throw new RepositoryNotFoundException( "Repository content not found: "+repoConfig.getId() );
}
- this.repositoryDir = repository.getRepository().getAsset( "" );
+ this.repositoryDir = repository.getRepository().getRoot();
this.scanStartTimestamp = System.currentTimeMillis( );
}
catch ( RepositoryException e )
{
try
{
- StorageAsset artifactFile = repository.getRepository( ).getAsset( "" ).resolve( path );
+ StorageAsset artifactFile = repository.getRepository( ).getRoot().resolve( path );
BaseRepositoryContentLayout layout = repository.getLayout( BaseRepositoryContentLayout.class );
if ( !artifactFile.exists() )
private StorageAsset getIndexPath( Repository repo) throws IOException {
IndexCreationFeature icf = repo.getFeature(IndexCreationFeature.class).get();
- Path repoDir = repo.getAsset("").getFilePath();
+ Path repoDir = repo.getRoot().getFilePath();
URI indexDir = icf.getIndexPath();
String indexPath = indexDir.getPath();
Path indexDirectory = null;
- FilesystemStorage filesystemStorage = (FilesystemStorage) repo.getAsset("").getStorage();
+ FilesystemStorage filesystemStorage = (FilesystemStorage) repo.getRoot().getStorage();
if ( ! StringUtils.isEmpty(indexDir.toString( ) ) )
{
// create remote repository path
- Path repoDir = remoteRepository.getAsset("").getFilePath();
+ Path repoDir = remoteRepository.getRoot().getFilePath();
if ( !Files.exists( repoDir ) )
{
Files.createDirectories( repoDir );
IndexingContext context;
// take care first about repository location as can be relative
- Path repositoryDirectory = repository.getAsset("").getFilePath();
+ Path repositoryDirectory = repository.getRoot().getFilePath();
if ( !Files.exists( repositoryDirectory ) )
{
*/
@Override
public StorageAsset getLocalPath() {
- return getStorage().getAsset("");
+ return getStorage().getRoot();
}
@Override
@Override
public StorageAsset getLocalPath() {
- return storage.getAsset("");
+ return storage.getRoot( );
+ }
+
+ @Override
+ public StorageAsset getRoot( )
+ {
+ return storage.getRoot( );
}
@Override
return (Repository)asset;
} else
{
- return getRepositories( ).stream( ).filter( r -> r.getAsset( "" )
+ return getRepositories( ).stream( ).filter( r -> r.getRoot()
.getStorage( ).equals( asset.getStorage( ) ) ).findFirst( ).orElse( null );
}
}
import org.apache.archiva.repository.RepositoryRequestInfo;
import org.apache.archiva.repository.RepositoryType;
import org.apache.archiva.repository.StandardCapabilities;
+import org.apache.archiva.repository.storage.StorageAsset;
import org.apache.archiva.repository.storage.fs.FilesystemStorage;
import org.apache.archiva.repository.storage.RepositoryStorage;
import org.apache.archiva.repository.features.ArtifactCleanupFeature;
path = path.substring( 0, idx );
}
- StorageAsset repoDir = managedRepository.getGenericContent( ).getRepository( ).getAsset( "" );
+ StorageAsset repoDir = managedRepository.getGenericContent( ).getRepository( ).getRoot();
if ( !repoDir.exists())
{
this.storage = new FilesystemStorage( Paths.get( "target" ), new DefaultFileLockManager( ) );
- this.asset = storage.getAsset( "" );
+ this.asset = storage.getRoot();
}
@Override
public ContentItem toItem( String path ) throws LayoutException
{
- StorageAsset asset = repository.getAsset( "" ).resolve( path );
+ StorageAsset asset = repository.getRoot().resolve( path );
return toItem( asset );
}
throw new IllegalArgumentException( "Unable to operate on a null repository." );
}
- StorageAsset repositoryBase = repository.getAsset("");
+ StorageAsset repositoryBase = repository.getRoot();
//MRM-1342 Repository statistics report doesn't appear to be working correctly
//create the repo if not existing to have an empty stats
e.printStackTrace();
}
}
- return fsStorage.getAsset("");
+ return fsStorage.getRoot();
}
@Override
*/
StorageAsset getAsset(String path);
+ /**
+ * Returns the root asset of the storage
+ * @return the storage asset that represents the root
+ */
+ StorageAsset getRoot( );
+
/**
* Consumes the data and sets a lock for the file during the operation.
*
return parent;
}
+ @Override
+ public StorageAsset getRoot( )
+ {
+ return root;
+ }
+
@Override
public void consumeData( StorageAsset asset, Consumer<InputStream> consumerFunction, boolean readLock ) throws IOException
{
}
}
+ @Override
+ public StorageAsset getRoot( )
+ {
+ return new FilesystemAsset( this, "", basePath, basePath );
+ }
+
@Override
public StorageAsset addAsset( String path, boolean container )
{
@Override
public StorageAsset getPath() {
if (dir==null) {
- StorageAsset repositoryDirAsset = repository.getAsset("");
+ StorageAsset repositoryDirAsset = repository.getRoot();
Path repositoryDir = repositoryDirAsset.getFilePath().toAbsolutePath();
Path indexDir = delegate.getIndexDirectoryFile().toPath();
if (indexDir.startsWith(repositoryDir)) {
} else {
try {
FilesystemStorage storage = new FilesystemStorage(indexDir, new DefaultFileLockManager());
- dir = storage.getAsset("");
+ dir = storage.getRoot();
} catch (IOException e) {
log.error("Error occured while creating storage for index dir");
}
private StorageAsset getIndexPath(URI indexDirUri, RepositoryStorage repoStorage, String defaultDir) throws IOException
{
- StorageAsset rootAsset = repoStorage.getAsset("");
+ StorageAsset rootAsset = repoStorage.getRoot();
RepositoryStorage storage = rootAsset.getStorage();
Path indexDirectory;
Path repositoryPath = rootAsset.getFilePath().toAbsolutePath();
// create remote repository path
- Path repoDir = remoteRepository.getAsset( "" ).getFilePath();
+ Path repoDir = remoteRepository.getRoot().getFilePath();
if ( !Files.exists( repoDir ) )
{
Files.createDirectories( repoDir );
IndexingContext context;
// take care first about repository location as can be relative
- Path repositoryDirectory = repository.getAsset( "" ).getFilePath();
+ Path repositoryDirectory = repository.getRoot().getFilePath();
if ( !Files.exists( repositoryDirectory ) )
{
@Test
public void pack() throws Exception {
createTestContext();
- Path destDir = repository.getAsset( "" ).getFilePath().resolve("org/apache/archiva/archiva-webapp/1.0");
+ Path destDir = repository.getRoot().getFilePath().resolve("org/apache/archiva/archiva-webapp/1.0");
Path srcDir = Paths.get("src/test/maven-search-test-repo/org/apache/archiva/archiva-webapp/1.0");
org.apache.commons.io.FileUtils.copyDirectory(srcDir.toFile(),destDir.toFile());
mavenIndexManager.scan(ctx);
@Test
public void scan() throws Exception {
createTestContext();
- Path destDir = repository.getAsset("").getFilePath().resolve("org/apache/archiva/archiva-webapp/1.0");
+ Path destDir = repository.getRoot().getFilePath().resolve("org/apache/archiva/archiva-webapp/1.0");
Path srcDir = Paths.get("src/test/maven-search-test-repo/org/apache/archiva/archiva-webapp/1.0");
org.apache.commons.io.FileUtils.copyDirectory(srcDir.toFile(),destDir.toFile());
mavenIndexManager.scan(ctx);
ArchivaIndexingContext ctx = createTestContext();
try {
- Path destDir = repository.getAsset("").getFilePath().resolve("org/apache/archiva/archiva-search/1.0");
+ Path destDir = repository.getRoot().getFilePath().resolve("org/apache/archiva/archiva-search/1.0");
Path srcDir = Paths.get("src/test/maven-search-test-repo/org/apache/archiva/archiva-search/1.0");
org.apache.commons.io.FileUtils.copyDirectory(srcDir.toFile(), destDir.toFile());
List<URI> uriList = new ArrayList<>();
@Test
public void removeArtifactsFromIndex() throws Exception {
ArchivaIndexingContext ctx = createTestContext();
- Path destDir = repository.getAsset( "" ).getFilePath().resolve("org/apache/archiva/archiva-search/1.0");
+ Path destDir = repository.getRoot().getFilePath().resolve("org/apache/archiva/archiva-search/1.0");
Path srcDir = Paths.get("src/test/maven-search-test-repo/org/apache/archiva/archiva-search/1.0");
org.apache.commons.io.FileUtils.copyDirectory(srcDir.toFile(), destDir.toFile());
List<URI> uriList = new ArrayList<>();
managedDefaultRepository = repositoryRegistry.getManagedRepository(MANAGED_ID).getContent();
BaseRepositoryContentLayout layout = managedDefaultRepository.getLayout( BaseRepositoryContentLayout.class );
- Path expectedFile = managedDefaultRepository.getRepository().getAsset( "" ).resolve( path ).getFilePath();
+ Path expectedFile = managedDefaultRepository.getRepository().getRoot().resolve( path ).getFilePath();
Files.deleteIfExists( expectedFile );
ArtifactReference artifact = managedDefaultRepository.toArtifactReference( path );
@Override
public ContentItem toItem( String path ) throws LayoutException
{
- StorageAsset asset = repository.getAsset( "" ).resolve( path );
+ StorageAsset asset = repository.getRoot().resolve( path );
return toItem( asset );
}
e.printStackTrace();
}
}
- return fsStorage.getAsset("");
+ return fsStorage.getRoot();
}
@Override
super( RepositoryType.MAVEN, id, name, storage);
this.indexCreationFeature = new IndexCreationFeature(this, this);
- setLocation(storage.getAsset("").getFilePath().toUri());
+ setLocation(storage.getRoot().getFilePath().toUri());
}
public MavenManagedRepository( Locale primaryLocale, String id, String name, FilesystemStorage storage )
{
super( primaryLocale, RepositoryType.MAVEN, id, name, storage );
- setLocation(storage.getAsset("").getFilePath().toUri());
+ setLocation(storage.getRoot().getFilePath().toUri());
}
@Override
}
private Path getRepositoryPath() {
- return getStorage().getAsset("").getFilePath();
+ return getStorage().getRoot().getFilePath();
}
private void init() {
throw new RepositoryException("The location entry is not a valid uri: " + cfg.getLocation());
}
setBaseConfig(repo, cfg);
- Path repoDir = repo.getAsset("").getFilePath();
+ Path repoDir = repo.getRoot().getFilePath();
if (!Files.exists(repoDir)) {
log.debug("Creating repo directory {}", repoDir);
try {
IndexCreationFeature indexCreationFeature = repositoryGroup.getFeature( IndexCreationFeature.class ).get();
indexCreationFeature.setIndexPath( getURIFromString(configuration.getMergedIndexPath()) );
Path localPath = Paths.get(configuration.getMergedIndexPath());
- Path repoGroupPath = repositoryGroup.getAsset("").getFilePath().toAbsolutePath();
+ Path repoGroupPath = repositoryGroup.getRoot().getFilePath().toAbsolutePath();
if (localPath.isAbsolute() && !localPath.startsWith(repoGroupPath)) {
try {
FilesystemStorage storage = new FilesystemStorage(localPath.getParent(), fileLockManager);
final Predicate<StorageAsset> filter = getItemFileFilterFromSelector( selector );
StorageAsset startDir;
if (selector.getNamespace().contains("*")) {
- startDir = getAsset( "" );
+ startDir = getAsset("");
} else if ( selector.hasProjectId( ) && selector.getProjectId().contains("*") )
{
startDir = getAsset( selector.getNamespace( ) );
private Path getRepoDir( )
{
- return repository.getAsset( "" ).getFilePath( );
+ return repository.getRoot().getFilePath( );
}
private RepositoryStorage getStorage( )
{
- return repository.getAsset( "" ).getStorage( );
+ return repository.getRoot().getStorage( );
}
/**
// FIXME take care of relative path
ResolveRequest resolveRequest = new ResolveRequest();
resolveRequest.dependencyVisitor = dependencyVisitor;
- resolveRequest.localRepoDir = repository.getAsset( "" ).getFilePath().toAbsolutePath().toString();
+ resolveRequest.localRepoDir = repository.getRoot().getFilePath().toAbsolutePath().toString();
resolveRequest.groupId = groupId;
resolveRequest.artifactId = artifactId;
resolveRequest.version = version;
for ( String repoId : repositoryIds )
{
ManagedRepository managedRepo = repositoryRegistry.getManagedRepository(repoId);
- StorageAsset repoDir = managedRepo.getAsset("");
+ StorageAsset repoDir = managedRepo.getRoot();
StorageAsset file = pathTranslator.toFile( repoDir, projectArtifact.getGroupId(), projectArtifact.getArtifactId(),
projectArtifact.getBaseVersion(),
}
}
}
- StorageAsset basedir = managedRepository.getAsset("");
+ StorageAsset basedir = managedRepository.getRoot();
if (VersionUtil.isSnapshot(artifactVersion)) {
StorageAsset metadataFile = pathTranslator.toFile(basedir, readMetadataRequest.getNamespace(),
readMetadataRequest.getProjectId(), artifactVersion,
private StorageAsset getRepositoryBasedir(String repoId)
throws RepositoryStorageRuntimeException {
- ManagedRepository repositoryConfiguration = repositoryRegistry.getManagedRepository(repoId);
+ ManagedRepository repository = repositoryRegistry.getManagedRepository(repoId);
- return repositoryConfiguration.getAsset("");
+ return repository.getRoot();
}
@Override
Map<String, NetworkProxy> networkProxiesMap, ManagedRepository targetRepository,
MavenSystemManager mavenSystemManager, MavenMetadataReader metadataReader)
{
- this( managedRepository.getAsset(""), pathTranslator );
+ this( managedRepository.getRoot(), pathTranslator );
this.managedRepository = managedRepository;
this.targetRepository = targetRepository;
- this.session = MavenSystemManager.newRepositorySystemSession( managedRepository.getAsset("").getFilePath().toString() );
+ this.session = MavenSystemManager.newRepositorySystemSession( managedRepository.getRoot().getFilePath().toString() );
this.versionRangeResolver = mavenSystemManager.getLocator().getService(VersionRangeResolver.class);
Path tmpSha1 = null;
Path tmpResource = null;
String artifactPath = pathTranslator.toPath( groupId, artifactId, version, filename );
- Path resource = targetRepository.getAsset("").getFilePath().resolve( artifactPath );
+ Path resource = targetRepository.getRoot().getFilePath().resolve( artifactPath );
Path workingDirectory = createWorkingDirectory( targetRepository.getLocation().toString() );
try
{
ManagedRepository repo = createManagedRepoWithContent( "delete-repository" );
ManagedRepositoryContent myRepoContent = repo.getContent( );
- Path repoRoot = repo.getAsset( "" ).getFilePath( );
+ Path repoRoot = repo.getRoot().getFilePath( );
assertTrue( Files.exists(repoRoot.resolve( "org/apache/maven" )) );
ArchivaItemSelector selector = ArchivaItemSelector.builder( )
.withNamespace( "org.apache.maven" ).build();
{
ManagedRepository repo = createManagedRepoWithContent( "delete-repository" );
ManagedRepositoryContent myRepoContent = repo.getContent( );
- Path repoRoot = repo.getAsset( "" ).getFilePath( );
+ Path repoRoot = repo.getRoot().getFilePath( );
assertTrue( Files.exists(repoRoot.resolve( "org/apache/maven/A" )) );
ArchivaItemSelector selector = ArchivaItemSelector.builder( )
.withNamespace( "org.apache.maven" )
{
ManagedRepository repo = createManagedRepoWithContent( "delete-repository" );
ManagedRepositoryContent myRepoContent = repo.getContent( );
- Path repoRoot = repo.getAsset( "" ).getFilePath( );
+ Path repoRoot = repo.getRoot().getFilePath( );
assertTrue( Files.exists(repoRoot.resolve( "org/apache/maven/A/1.0" )) );
ArchivaItemSelector selector = ArchivaItemSelector.builder( )
.withNamespace( "org.apache.maven" )
{
ManagedRepository repo = createManagedRepoWithContent( "delete-repository" );
ManagedRepositoryContent myRepoContent = repo.getContent( );
- Path repoRoot = repo.getAsset( "" ).getFilePath( );
+ Path repoRoot = repo.getRoot().getFilePath( );
assertTrue( Files.exists(repoRoot.resolve( "org/apache/maven/A/1.0/A-1.0.pom" )) );
assertTrue( Files.exists(repoRoot.resolve( "org/apache/maven/A/1.0/A-1.0.war" )) );
ArchivaItemSelector selector = ArchivaItemSelector.builder( )
{
ManagedRepository repo = createManagedRepoWithContent( "delete-repository" );
ManagedRepositoryContent myRepoContent = repo.getContent( );
- Path repoRoot = repo.getAsset( "" ).getFilePath( );
+ Path repoRoot = repo.getRoot().getFilePath( );
ArchivaItemSelector selector = ArchivaItemSelector.builder( )
.withNamespace( "org.apache.test2" )
ManagedRepository repo = createManagedRepoWithContent( "delete-repository" );
ManagedRepositoryContent myRepoContent = repo.getContent( );
BaseRepositoryContentLayout layout = myRepoContent.getLayout( BaseRepositoryContentLayout.class );
- Path repoRoot = repo.getAsset( "" ).getFilePath( );
+ Path repoRoot = repo.getRoot().getFilePath( );
Path tmpFile = Files.createTempFile( "archiva-mvn-repotest", "jar" );
try( OutputStream outputStream = Files.newOutputStream( tmpFile ))
assertNotNull( ns );
assertEquals( "org.apache.archiva", ns );
- asset = storage.getAsset( "" );
+ asset = storage.getRoot();
ns = MavenContentHelper.getNamespaceFromNamespacePath( asset );
assertNotNull( ns );
assertEquals( "", ns );
ProjectReference reference )
throws LayoutException, IOException, SAXException, ParserConfigurationException
{
- Path metadataFile = repository.getRepository().getAsset( "" ).getFilePath().resolve(tools.toPath( reference ) );
+ Path metadataFile = repository.getRepository().getRoot().getFilePath().resolve(tools.toPath( reference ) );
String actualMetadata = org.apache.archiva.common.utils.FileUtils.readFileToString( metadataFile, Charset.defaultCharset() );
Diff detailedDiff = DiffBuilder.compare( expectedMetadata ).withTest( actualMetadata ).checkForSimilar().build();
VersionedReference reference )
throws LayoutException, IOException, SAXException, ParserConfigurationException
{
- Path metadataFile = repository.getRepository().getAsset("").getFilePath().resolve( tools.toPath( reference ) );
+ Path metadataFile = repository.getRepository().getRoot().getFilePath().resolve( tools.toPath( reference ) );
String actualMetadata = org.apache.archiva.common.utils.FileUtils.readFileToString( metadataFile, Charset.defaultCharset() );
Diff detailedDiff = DiffBuilder.compare( expectedMetadata ).withTest( actualMetadata ).checkForSimilar().build();
Path srcRepoDir = getRepositoryPath( "metadata-repository" );
Path srcDir = srcRepoDir.resolve( path );
- Path destDir = repo.getRepository().getAsset( "" ).getFilePath().resolve( path );
+ Path destDir = repo.getRepository().getRoot().getFilePath().resolve( path );
assertTrue( "Source Dir exists: " + srcDir, Files.exists(srcDir) );
Files.createDirectories(destDir);
private StorageAsset getIndexPath( Repository repo) throws IOException {
IndexCreationFeature icf = repo.getFeature(IndexCreationFeature.class).get();
- Path repoDir = repo.getAsset( "" ).getFilePath();
+ Path repoDir = repo.getRoot().getFilePath();
URI indexDir = icf.getIndexPath();
String indexPath = indexDir.getPath();
Path indexDirectory = null;
- FilesystemStorage fsStorage = (FilesystemStorage) repo.getAsset("").getStorage();
+ FilesystemStorage fsStorage = (FilesystemStorage) repo.getRoot().getStorage();
if ( ! StringUtils.isEmpty(indexDir.toString( ) ) )
{
// create remote repository path
- Path repoDir = remoteRepository.getAsset("").getFilePath();
+ Path repoDir = remoteRepository.getRoot().getFilePath();
if ( !Files.exists( repoDir ) )
{
Files.createDirectories( repoDir );
IndexingContext context;
// take care first about repository location as can be relative
- Path repositoryDirectory = repository.getAsset("").getFilePath();
+ Path repositoryDirectory = repository.getRoot().getFilePath();
if ( !Files.exists( repositoryDirectory ) )
{
@Override
public StorageAsset getPath() {
- return indexStorage.getAsset("");
+ return indexStorage.getRoot();
}
@Override
public void testAddArtifactToIndex()
throws Exception
{
- Path basePath = repo.getAsset("").getFilePath();
+ Path basePath = repo.getLocalPath().getFilePath();
Path artifactFile = basePath.resolve(
"org/apache/archiva/archiva-index-methods-jar-test/1.0/archiva-index-methods-jar-test-1.0.jar" );
public void testUpdateArtifactInIndex()
throws Exception
{
- Path basePath = repo.getAsset("").getFilePath();
+ Path basePath = repo.getLocalPath().getFilePath();
Path artifactFile = basePath.resolve(
"org/apache/archiva/archiva-index-methods-jar-test/1.0/archiva-index-methods-jar-test-1.0.jar" );
public void testRemoveArtifactFromIndex()
throws Exception
{
- Path basePath = repo.getAsset("").getFilePath();
+ Path basePath = repo.getLocalPath().getFilePath();
Path artifactFile = basePath.resolve(
"org/apache/archiva/archiva-index-methods-jar-test/1.0/archiva-index-methods-jar-test-1.0.jar" );
throws Exception
{
- Path basePath = repo.getAsset("").getFilePath();
+ Path basePath = repo.getLocalPath().getFilePath();
IndexCreationFeature icf = repo.getFeature( IndexCreationFeature.class ).get();
StorageAsset packedIndexDirectory = icf.getLocalPackedIndexPath();
StorageAsset indexerDirectory = icf.getLocalIndexPath();
private StorageAsset getIndexPath( Repository repo) throws IOException {
IndexCreationFeature icf = repo.getFeature(IndexCreationFeature.class).get();
- Path repoDir = repo.getAsset("").getFilePath();
+ Path repoDir = repo.getRoot().getFilePath();
URI indexDir = icf.getIndexPath();
String indexPath = indexDir.getPath();
Path indexDirectory = null;
- FilesystemStorage filesystemStorage = (FilesystemStorage) repo.getAsset("").getStorage();
+ FilesystemStorage filesystemStorage = (FilesystemStorage) repo.getRoot().getStorage();
if ( ! StringUtils.isEmpty(indexDir.toString( ) ) )
{
// create remote repository path
- Path repoDir = remoteRepository.getAsset("").getFilePath();
+ Path repoDir = remoteRepository.getRoot().getFilePath();
if ( !Files.exists( repoDir ) )
{
Files.createDirectories( repoDir );
IndexingContext context;
// take care first about repository location as can be relative
- Path repositoryDirectory = repository.getAsset("").getFilePath();
+ Path repositoryDirectory = repository.getRoot().getFilePath();
if ( !Files.exists( repositoryDirectory ) )
{
repositoryRequestInfo = repo.getRequestInfo();
String logicalResource = getLogicalResource( archivaLocator, null, false );
resourcesInAbsolutePath.add(
- managedRepositoryContent.getRepository().getAsset( "" ).getFilePath().resolve(logicalResource ).toAbsolutePath().toString() );
+ managedRepositoryContent.getRepository().getLocalPath().getFilePath().resolve(logicalResource ).toAbsolutePath().toString() );
}
logicalResource = logicalResource.substring( 1 );
}
resourcesInAbsolutePath.add(
- managedRepositoryContent.getRepository().getAsset( "" ).resolve( logicalResource ).getFilePath().toAbsolutePath().toString() );
+ managedRepositoryContent.getRepository().getLocalPath().resolve( logicalResource ).getFilePath().toAbsolutePath().toString() );
}
catch ( DavException e )
{
* create the collections themselves.
*/
- StorageAsset rootDirectory = managedRepositoryContent.getRepository( ).getAsset( "" );
+ StorageAsset rootDirectory = managedRepositoryContent.getRepository( ).getLocalPath();
StorageAsset destDir = rootDirectory.resolve( logicalResource.getPath() ).getParent();
if ( !destDir.exists() )
}
try {
FilesystemStorage storage = new FilesystemStorage(tmpDirectory.getParent(), new DefaultFileLockManager());
- mergedRepositoryContents.add( storage.getAsset("") );
+ mergedRepositoryContents.add( storage.getRoot() );
} catch (IOException e) {
throw new DavException(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "Could not create storage for " + tmpDirectory);
}
Path tempRepoFile = Files.createTempDirectory( "temp" );
tempRepoFile.toFile( ).deleteOnExit( );
FilesystemStorage storage = new FilesystemStorage(tempRepoFile, new DefaultFileLockManager());
- StorageAsset tmpAsset = storage.getAsset("");
+ StorageAsset tmpAsset = storage.getRoot();
IndexMergerRequest indexMergerRequest =
new IndexMergerRequest( authzRepos, true, id,