* under the License.
*/
-import org.apache.archiva.configuration.ArchivaConfiguration;
-import org.apache.archiva.configuration.Configuration;
-import org.apache.archiva.configuration.ConfigurationEvent;
-import org.apache.archiva.configuration.ConfigurationListener;
-import org.apache.archiva.configuration.IndeterminateConfigurationException;
-import org.apache.archiva.configuration.ManagedRepositoryConfiguration;
-import org.apache.archiva.configuration.ProxyConnectorConfiguration;
-import org.apache.archiva.configuration.RemoteRepositoryConfiguration;
+import org.apache.archiva.configuration.*;
import org.apache.archiva.indexer.ArchivaIndexManager;
import org.apache.archiva.indexer.ArchivaIndexingContext;
import org.apache.archiva.indexer.IndexCreationFailedException;
private Map<String, RemoteRepository> remoteRepositories = new HashMap<>( );
private Map<String, RemoteRepository> uRemoteRepositories = Collections.unmodifiableMap( remoteRepositories );
+ private Map<String, RepositoryGroup> repositoryGroups = new HashMap<>();
+ private Map<String, RepositoryGroup> uRepositoryGroups = Collections.unmodifiableMap(repositoryGroups);
+
private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock( );
public void setArchivaConfiguration( ArchivaConfiguration archivaConfiguration) {
}
remoteRepositories.clear( );
remoteRepositories.putAll( getRemoteRepositoriesFromConfig( ) );
+
+ repositoryGroups.clear();
+ repositoryGroups.putAll(getRepositorGroupsFromConfig());
+
// archivaConfiguration.addChangeListener(this);
archivaConfiguration.addListener(this);
}
}
}
+ private Map<String, RepositoryGroup> getRepositorGroupsFromConfig( )
+ {
+ try
+ {
+ List<RepositoryGroupConfiguration> repositoryGroupConfigurations =
+ getArchivaConfiguration( ).getConfiguration( ).getRepositoryGroups();
+
+ if ( repositoryGroupConfigurations == null )
+ {
+ return Collections.emptyMap();
+ }
+
+ Map<String, RepositoryGroup> repositoryGroupMap = new LinkedHashMap<>( repositoryGroupConfigurations.size( ) );
+
+ Map<RepositoryType, RepositoryProvider> providerMap = createProviderMap( );
+ for ( RepositoryGroupConfiguration repoConfig : repositoryGroupConfigurations )
+ {
+ RepositoryType repositoryType = RepositoryType.valueOf( repoConfig.getType( ) );
+ if ( providerMap.containsKey( repositoryType ) )
+ {
+ try
+ {
+ RepositoryGroup repo = createNewRepositoryGroup( providerMap.get( repositoryType ), repoConfig );
+ repositoryGroupMap.put( repo.getId( ), repo );
+ }
+ catch ( Exception e )
+ {
+ log.error( "Could not create repository group {}: {}", repoConfig.getId( ), e.getMessage( ), e );
+ }
+ }
+ }
+ return repositoryGroupMap;
+ } catch (Throwable e) {
+ log.error("Could not initialize repositories from config: {}",e.getMessage(), e );
+ //noinspection unchecked
+ return Collections.emptyMap();
+ }
+ }
+
+ RepositoryGroup createNewRepositoryGroup(RepositoryProvider provider, RepositoryGroupConfiguration config) throws RepositoryException {
+ RepositoryGroup repositoryGroup = provider.createRepositoryGroup(config);
+ repositoryGroup.addListener(this);
+ updateRepositoryReferences(provider, repositoryGroup, config);
+ return repositoryGroup;
+ }
+
+ private void updateRepositoryReferences(RepositoryProvider provider, RepositoryGroup group, RepositoryGroupConfiguration configuration) {
+ if (group instanceof EditableRepositoryGroup) {
+ EditableRepositoryGroup eGroup = (EditableRepositoryGroup) group;
+ eGroup.setRepositories(configuration.getRepositories().stream().map(r -> getManagedRepository(r)).collect(Collectors.toList()));
+ }
+ }
+
private ArchivaConfiguration getArchivaConfiguration( )
{
return this.archivaConfiguration;
rwLock.readLock( ).lock( );
try
{
- return Stream.concat( managedRepositories.values( ).stream( ), remoteRepositories.values( ).stream( ) ).collect( Collectors.toList( ) );
+ return Stream.concat( managedRepositories.values( ).stream( ), remoteRepositories.values( ).stream( )).collect( Collectors.toList( ) );
}
finally
{
}
}
+ public Collection<RepositoryGroup> getRepositoryGroups() {
+ rwLock.readLock().lock();
+ try {
+ return uRepositoryGroups.values();
+ } finally {
+ rwLock.readLock().unlock();
+ }
+ }
+
/**
* Returns the repository with the given id. The returned repository may be a managed or remote repository.
* It returns null, if no repository is registered with the given id.
}
}
+ public RepositoryGroup getRepositoryGroup( String groupId ) {
+ rwLock.readLock().lock();
+ try {
+ return repositoryGroups.get(groupId);
+ } finally {
+ rwLock.readLock().unlock();
+ }
+ }
+
/**
* Adds a new repository to the current list, or replaces the repository definition with
* the same id, if it exists already.
import org.apache.archiva.common.utils.VersionUtil;
import org.apache.archiva.configuration.ArchivaConfiguration;
import org.apache.archiva.configuration.RepositoryGroupConfiguration;
+import org.apache.archiva.indexer.ArchivaIndexingContext;
import org.apache.archiva.indexer.merger.IndexMerger;
import org.apache.archiva.indexer.merger.IndexMergerException;
import org.apache.archiva.indexer.merger.IndexMergerRequest;
import org.apache.archiva.redback.users.User;
import org.apache.archiva.redback.users.UserManager;
import org.apache.archiva.repository.*;
+import org.apache.archiva.repository.content.FilesystemAsset;
import org.apache.archiva.repository.content.maven2.MavenRepositoryRequestInfo;
import org.apache.archiva.repository.events.AuditListener;
import org.apache.archiva.repository.features.IndexCreationFeature;
final String sRepoId = archivaLocator.getRepositoryId();
- RepositoryGroupConfiguration repoGroupConfig =
- archivaConfiguration.getConfiguration().getRepositoryGroupsAsMap().get( sRepoId );
+ RepositoryGroup repoGroup = repositoryRegistry.getRepositoryGroup(sRepoId);
- final boolean isGroupRepo = repoGroupConfig != null;
+ final boolean isGroupRepo = repoGroup != null;
String activePrincipal = getActivePrincipal( request );
"Write method not allowed for repository groups." );
}
- log.debug( "Repository group '{}' accessed by '{}", repoGroupConfig.getId(), activePrincipal );
+ log.debug( "Repository group '{}' accessed by '{}", repoGroup.getId(), activePrincipal );
// handle browse requests for virtual repos
if ( getLogicalResource( archivaLocator, null, true ).endsWith( "/" ) )
{
DavResource davResource =
- getResourceFromGroup( request, repoGroupConfig.getRepositories(), archivaLocator,
- repoGroupConfig );
+ getResourceFromGroup( request, archivaLocator,
+ repoGroup );
setHeaders( response, locator, davResource, true );
// make a copy to avoid potential concurrent modifications (eg. by configuration)
// TODO: ultimately, locking might be more efficient than copying in this fashion since updates are
// infrequent
- List<String> repositories = new ArrayList<>( repoGroupConfig.getRepositories() );
- resource = processRepositoryGroup( request, archivaLocator, repositories, activePrincipal,
- resourcesInAbsolutePath, repoGroupConfig );
- for (String repoId: repositories ) {
- ManagedRepository repo = repositoryRegistry.getManagedRepository(repoId);
+ resource = processRepositoryGroup( request, archivaLocator, activePrincipal,
+ resourcesInAbsolutePath, repoGroup );
+ for (ManagedRepository repo : repoGroup.getRepositories() ) {
if (repo!=null) {
repositoryRequestInfo = repo.getRequestInfo();
break;
}
private DavResource processRepositoryGroup( final DavServletRequest request,
- ArchivaDavResourceLocator archivaLocator, List<String> repositories,
+ ArchivaDavResourceLocator archivaLocator,
String activePrincipal, List<String> resourcesInAbsolutePath,
- RepositoryGroupConfiguration repoGroupConfig )
+ RepositoryGroup repoGroup )
throws DavException
{
DavResource resource = null;
String rootPath = StringUtils.substringBeforeLast( pathInfo, "/" );
- if ( StringUtils.endsWith( rootPath, repoGroupConfig.getMergedIndexPath() ) )
+ if ( StringUtils.endsWith( rootPath, repoGroup.getMergedIndexPath().getPath() ) )
{
// we are in the case of index file request
String requestedFileName = StringUtils.substringAfterLast( pathInfo, "/" );
Path temporaryIndexDirectory =
- buildMergedIndexDirectory( repositories, activePrincipal, request, repoGroupConfig );
+ buildMergedIndexDirectory( activePrincipal, request, repoGroup );
+ asset = new FilesystemAsset()
Path resourceFile = temporaryIndexDirectory.resolve( requestedFileName );
- resource = new ArchivaDavResource( resourceFile.toAbsolutePath().toString(), requestedFileName, null,
- request.getRemoteAddr(), activePrincipal, request.getDavSession(),
- archivaLocator, this, mimeTypes, auditListeners, scheduler,
- fileLockManager );
+ try {
+ resource = new ArchivaDavResource( resourceFile.toAbsolutePath().toString(), requestedFileName, null,
+ request.getRemoteAddr(), activePrincipal, request.getDavSession(),
+ archivaLocator, this, mimeTypes, auditListeners, scheduler );
+ } catch (LayoutException e) {
+ log.error("Bad layout: {}", e.getMessage(), e);
+ throw new DavException(500, e);
+ }
}
else
}
}
- private DavResource getResourceFromGroup( DavServletRequest request, List<String> repositories,
+ private DavResource getResourceFromGroup( DavServletRequest request,
ArchivaDavResourceLocator locator,
- RepositoryGroupConfiguration repositoryGroupConfiguration )
+ RepositoryGroup repositoryGroup )
throws DavException
{
- if ( repositoryGroupConfiguration.getRepositories() == null
- || repositoryGroupConfiguration.getRepositories().isEmpty() )
+ final String id = repositoryGroup.getId();
+ final List<ManagedRepository> repositories = repositoryGroup.getRepositories();
+ if ( repositories == null
+ || repositories.isEmpty() )
{
- Path file =
- Paths.get( System.getProperty( "appserver.base" ), "groups/" + repositoryGroupConfiguration.getId() );
-
- return new ArchivaDavResource( file.toString(), "groups/" + repositoryGroupConfiguration.getId(), null,
- request.getDavSession(), locator, this, mimeTypes, auditListeners, scheduler,
- fileLockManager );
+ try {
+ return new ArchivaDavResource( repositoryGroup.getAsset("/"), "groups/" + id, null,
+ request.getDavSession(), locator, this, mimeTypes, auditListeners, scheduler);
+ } catch (LayoutException e) {
+ log.error("Bad repository layout: {}", e.getMessage(), e);
+ throw new DavException(500, e);
+ }
}
List<Path> mergedRepositoryContents = new ArrayList<>();
- // multiple repo types so we guess they are all the same type
- // so use the first one
- // FIXME add a method with group in the repository storage
- String firstRepoId = repositoryGroupConfiguration.getRepositories().get( 0 );
- String path = getLogicalResource( locator, repositoryRegistry.getManagedRepository( firstRepoId ), false );
+ ManagedRepository firstRepo = repositories.get( 0 );
+
+ String path = getLogicalResource( locator, firstRepo, false );
if ( path.startsWith( "/" ) )
{
path = path.substring( 1 );
if ( allow )
{
- if ( StringUtils.endsWith( pathInfo, repositoryGroupConfiguration.getMergedIndexPath() ) )
+ if ( StringUtils.endsWith( pathInfo, repositoryGroup.getMergedIndexPath().getPath() ) )
{
Path mergedRepoDir =
- buildMergedIndexDirectory( repositories, activePrincipal, request, repositoryGroupConfiguration );
+ buildMergedIndexDirectory( activePrincipal, request, repositoryGroup );
mergedRepositoryContents.add( mergedRepoDir );
}
else
{
- if ( StringUtils.equalsIgnoreCase( pathInfo, "/" + repositoryGroupConfiguration.getId() ) )
+ if ( StringUtils.equalsIgnoreCase( pathInfo, "/" + id ) )
{
Path tmpDirectory = Paths.get( SystemUtils.getJavaIoTmpDir().toString(),
- repositoryGroupConfiguration.getId(),
- repositoryGroupConfiguration.getMergedIndexPath() );
+ id,
+ repositoryGroup.getMergedIndexPath().getFilePath().toString() );
if ( !Files.exists(tmpDirectory) )
{
synchronized ( tmpDirectory.toAbsolutePath().toString() )
}
mergedRepositoryContents.add( tmpDirectory.getParent() );
}
- for ( String repository : repositories )
+ for ( ManagedRepository repo : repositories )
{
ManagedRepositoryContent managedRepository = null;
- ManagedRepository repo = repositoryRegistry.getManagedRepository( repository );
if (repo == null) {
throw new DavException( HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
- "Invalid managed repository <" + repository + ">");
+ "Invalid managed repository <" + repo.getId() + ">");
}
managedRepository = repo.getContent();
if (managedRepository==null) {
- log.error("Inconsistency detected. Repository content not found for '{}'",repository);
+ log.error("Inconsistency detected. Repository content not found for '{}'",repo.getId());
throw new DavException( HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
- "Invalid managed repository <" + repository + ">");
+ "Invalid managed repository <" + repo.getId() + ">");
}
Path resourceFile = Paths.get( managedRepository.getRepoRoot(), logicalResource.getPath() );
if ( Files.exists(resourceFile) )
{
try
{
- if ( isAuthorized( request, repository ) )
+ if ( isAuthorized( request, repo.getId() ) )
{
mergedRepositoryContents.add( resourceFile );
- log.debug( "Repository '{}' accessed by '{}'", repository, activePrincipal );
+ log.debug( "Repository '{}' accessed by '{}'", repo.getId(), activePrincipal );
}
}
catch ( DavException e )
// for the current user logged in
try
{
- if ( servletAuth.isAuthorized( activePrincipal, repository,
+ if ( servletAuth.isAuthorized( activePrincipal, repo.getId(),
WebdavMethodUtil.getMethodPermission(
request.getMethod() ) ) )
{
mergedRepositoryContents.add( resourceFile );
- log.debug( "Repository '{}' accessed by '{}'", repository, activePrincipal );
+ log.debug( "Repository '{}' accessed by '{}'", repo.getId(), activePrincipal );
}
}
catch ( UnauthorizedException e )
* @param activePrincipal
* @return
*/
- private boolean isAllowedToContinue( DavServletRequest request, List<String> repositories, String activePrincipal )
+ private boolean isAllowedToContinue( DavServletRequest request, List<ManagedRepository> repositories, String activePrincipal )
{
// when no repositories configured it's impossible to browse nothing !
// at least make possible to see nothing :-)
// if securitySession != null, it means that the user was prompted for authentication
if ( httpAuth.getSecuritySession( request.getSession() ) != null )
{
- for ( String repository : repositories )
+ for ( ManagedRepository repository : repositories )
{
try
{
- if ( isAuthorized( request, repository ) )
+ if ( isAuthorized( request, repository.getId() ) )
{
allow = true;
break;
}
else
{
- for ( String repository : repositories )
+ for ( ManagedRepository repository : repositories )
{
try
{
- if ( servletAuth.isAuthorized( activePrincipal, repository,
+ if ( servletAuth.isAuthorized( activePrincipal, repository.getId(),
WebdavMethodUtil.getMethodPermission( request.getMethod() ) ) )
{
allow = true;
}
}
- protected Path buildMergedIndexDirectory( List<String> repositories, String activePrincipal,
+ protected Path buildMergedIndexDirectory( String activePrincipal,
DavServletRequest request,
- RepositoryGroupConfiguration repositoryGroupConfiguration )
+ RepositoryGroup repositoryGroup )
throws DavException
{
try
{
+ final List<ManagedRepository> repositories = repositoryGroup.getRepositories();
HttpSession session = request.getSession();
@SuppressWarnings( "unchecked" ) Map<String, TemporaryGroupIndex> temporaryGroupIndexMap =
temporaryGroupIndexMap = new HashMap<>();
}
- TemporaryGroupIndex tmp = temporaryGroupIndexMap.get( repositoryGroupConfiguration.getId() );
+ final String id = repositoryGroup.getId();
+ TemporaryGroupIndex tmp = temporaryGroupIndexMap.get(id);
if ( tmp != null && tmp.getDirectory() != null && Files.exists(tmp.getDirectory()))
{
if ( System.currentTimeMillis() - tmp.getCreationTime() > (
- repositoryGroupConfiguration.getMergedIndexTtl() * 60 * 1000 ) )
+ repositoryGroup.getMergedIndexTTL() * 60 * 1000 ) )
{
log.debug( MarkerFactory.getMarker( "group.merged.index" ),
- "tmp group index '{}' is too old so delete it", repositoryGroupConfiguration.getId() );
+ "tmp group index '{}' is too old so delete it", id);
indexMerger.cleanTemporaryGroupIndex( tmp );
}
else
{
log.debug( MarkerFactory.getMarker( "group.merged.index" ),
- "merged index for group '{}' found in cache", repositoryGroupConfiguration.getId() );
+ "merged index for group '{}' found in cache", id);
return tmp.getDirectory();
}
}
String permission = WebdavMethodUtil.getMethodPermission( request.getMethod() );
- for ( String repository : repositories )
+ for ( ManagedRepository repository : repositories )
{
try
{
- if ( servletAuth.isAuthorized( activePrincipal, repository, permission ) )
+ if ( servletAuth.isAuthorized( activePrincipal, repository.getId(), permission ) )
{
- authzRepos.add( repository );
- authzRepos.addAll( this.repositorySearch.getRemoteIndexingContextIds( repository ) );
+ authzRepos.add( repository.getId() );
+ authzRepos.addAll( this.repositorySearch.getRemoteIndexingContextIds( repository.getId() ) );
}
}
catch ( UnauthorizedException e )
}
log.info( "generate temporary merged index for repository group '{}' for repositories '{}'",
- repositoryGroupConfiguration.getId(), authzRepos );
+ id, authzRepos );
Path tempRepoFile = Files.createTempDirectory( "temp" );
tempRepoFile.toFile().deleteOnExit();
IndexMergerRequest indexMergerRequest =
- new IndexMergerRequest( authzRepos, true, repositoryGroupConfiguration.getId(),
- repositoryGroupConfiguration.getMergedIndexPath(),
- repositoryGroupConfiguration.getMergedIndexTtl() ).mergedIndexDirectory(
+ new IndexMergerRequest( authzRepos, true, id,
+ repositoryGroup.getMergedIndexPath().getFilePath().toString(),
+ repositoryGroup.getMergedIndexTTL() ).mergedIndexDirectory(
tempRepoFile ).temporary( true );
MergedRemoteIndexesTaskRequest taskRequest =
MergedRemoteIndexesTask job = new MergedRemoteIndexesTask( taskRequest );
- IndexingContext indexingContext = job.execute().getIndexingContext();
+ ArchivaIndexingContext indexingContext = job.execute().getIndexingContext();
- Path mergedRepoDir = indexingContext.getIndexDirectoryFile().toPath();
+ Path mergedRepoDir = Paths.get(indexingContext.getPath());
TemporaryGroupIndex temporaryGroupIndex =
- new TemporaryGroupIndex( mergedRepoDir, indexingContext.getId(), repositoryGroupConfiguration.getId(),
- repositoryGroupConfiguration.getMergedIndexTtl() ) //
+ new TemporaryGroupIndex( mergedRepoDir, indexingContext.getId(), id,
+ repositoryGroup.getMergedIndexTTL() ) //
.setCreationTime( new Date().getTime() );
- temporaryGroupIndexMap.put( repositoryGroupConfiguration.getId(), temporaryGroupIndex );
+ temporaryGroupIndexMap.put( id, temporaryGroupIndex );
session.setAttribute( TemporaryGroupIndexSessionCleaner.TEMPORARY_INDEX_SESSION_KEY,
temporaryGroupIndexMap );
return mergedRepoDir;