| package org.apache.archiva.metadata.repository; |
| |
| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| import org.apache.archiva.metadata.model.ArtifactMetadata; |
| import org.apache.archiva.metadata.model.ProjectMetadata; |
| import org.apache.archiva.metadata.model.ProjectVersionMetadata; |
| import org.apache.archiva.metadata.model.ProjectVersionReference; |
| import org.apache.archiva.metadata.repository.filter.ExcludesFilter; |
| import org.apache.archiva.metadata.repository.storage.ReadMetadataRequest; |
| import org.apache.archiva.metadata.repository.storage.RepositoryStorage; |
| import org.apache.archiva.metadata.repository.storage.RepositoryStorageMetadataInvalidException; |
| import org.apache.archiva.metadata.repository.storage.RepositoryStorageMetadataNotFoundException; |
| import org.apache.archiva.metadata.repository.storage.RepositoryStorageRuntimeException; |
| import org.apache.archiva.redback.components.cache.Cache; |
| import org.apache.archiva.repository.events.RepositoryListener; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| import org.springframework.beans.factory.annotation.Autowired; |
| import org.springframework.stereotype.Service; |
| |
| import javax.inject.Inject; |
| import javax.inject.Named; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.List; |
| |
| /** |
| * <p> |
| * Default implementation of the metadata resolver API. At present it will handle updating the content repository |
| * from new or changed information in the model and artifacts from the repository storage. |
| * </p> |
| * <p> |
| * This is a singleton component to allow an alternate implementation to be provided. It is intended to be the same |
| * system-wide for the whole content repository instead of on a per-managed-repository basis. Therefore, the session is |
| * passed in as an argument to obtain any necessary resources, rather than the class being instantiated within the |
| * session in the context of a single managed repository's resolution needs. |
| * </p> |
| * <p> |
| * Note that the caller is responsible for the session, such as closing and saving (which is implied by the resolver |
| * being obtained from within the session). The {@link RepositorySession#markDirty()} method is used as a hint to ensure |
| * that the session knows we've made changes at close. We cannot ensure the changes will be persisted if the caller |
| * chooses to revert first. This is preferable to storing the metadata immediately - a separate session would require |
| * having a bi-directional link with the session factory, and saving the existing session might save other changes |
| * unknowingly by the caller. |
| * </p> |
| */ |
| @Service("metadataResolver#default") |
| public class DefaultMetadataResolver |
| implements MetadataResolver |
| { |
| |
| private Logger log = LoggerFactory.getLogger( DefaultMetadataResolver.class ); |
| |
| /** |
| * <p> |
| * FIXME: this needs to be configurable based on storage type - and could also be instantiated per repo. Change to a |
| * factory, and perhaps retrieve from the session. We should avoid creating one per request, however. |
| * </p> |
| * <p> |
| * TODO: Also need to accommodate availability of proxy module |
| * ... could be a different type since we need methods to modify the storage metadata, which would also allow more |
| * appropriate methods to pass in the already determined repository configuration, for example, instead of the ID |
| * </p> |
| */ |
| @Inject |
| @Named(value = "repositoryStorage#maven2") |
| private RepositoryStorage repositoryStorage; |
| |
| @Inject |
| @Autowired(required = false) |
| private List<RepositoryListener> listeners = new ArrayList<>(); |
| |
| /** |
| * Cache used for namespaces |
| */ |
| @Inject |
| @Named( value = "cache#namespaces" ) |
| private Cache<String, Collection<String>> namespacesCache; |
| |
| @Override |
| public ProjectVersionMetadata resolveProjectVersion( RepositorySession session, String repoId, String namespace, |
| String projectId, String projectVersion ) |
| throws MetadataResolutionException |
| { |
| MetadataRepository metadataRepository = session.getRepository(); |
| |
| ProjectVersionMetadata metadata = |
| metadataRepository.getProjectVersion( repoId, namespace, projectId, projectVersion ); |
| // TODO: do we want to detect changes as well by comparing timestamps? isProjectVersionNewerThan(updated) |
| // in such cases we might also remove/update stale metadata, including adjusting plugin-based facets |
| // This would also be better than checking for completeness - we can then refresh only when fixed (though |
| // sometimes this has an additional dependency - such as a parent - requesting the user to force an update |
| // may then work here and be more efficient than always trying again) |
| if ( metadata == null || metadata.isIncomplete() ) |
| { |
| try |
| { |
| ReadMetadataRequest readMetadataRequest = |
| new ReadMetadataRequest().repositoryId( repoId ).namespace( namespace ).projectId( |
| projectId ).projectVersion( projectVersion ).browsingRequest( true ); |
| metadata = repositoryStorage.readProjectVersionMetadata( readMetadataRequest ); |
| |
| log.debug( "Resolved project version metadata from storage: {}", metadata ); |
| |
| // FIXME: make this a more generic post-processing that plugins can take advantage of |
| // eg. maven projects should be able to process parent here |
| if ( !metadata.getDependencies().isEmpty() ) |
| { |
| ProjectVersionReference ref = new ProjectVersionReference(); |
| ref.setNamespace( namespace ); |
| ref.setProjectId( projectId ); |
| ref.setProjectVersion( projectVersion ); |
| ref.setReferenceType( ProjectVersionReference.ReferenceType.DEPENDENCY ); |
| } |
| try |
| { |
| for ( RepositoryListener listener : listeners ) |
| { |
| listener.addArtifact( session, repoId, namespace, projectId, metadata ); |
| } |
| metadataRepository.updateProjectVersion( repoId, namespace, projectId, metadata ); |
| } |
| catch ( MetadataRepositoryException e ) |
| { |
| log.warn( "Unable to persist resolved information: {}", e.getMessage(), e ); |
| } |
| |
| session.markDirty(); |
| } |
| catch ( RepositoryStorageMetadataInvalidException e ) |
| { |
| for ( RepositoryListener listener : listeners ) |
| { |
| listener.addArtifactProblem( session, repoId, namespace, projectId, projectVersion, e ); |
| } |
| throw new MetadataResolutionException( e.getMessage(), e ); |
| } |
| catch ( RepositoryStorageMetadataNotFoundException e ) |
| { |
| for ( RepositoryListener listener : listeners ) |
| { |
| listener.addArtifactProblem( session, repoId, namespace, projectId, projectVersion, e ); |
| } |
| // no need to rethrow - return null |
| } |
| catch ( RepositoryStorageRuntimeException e ) |
| { |
| for ( RepositoryListener listener : listeners ) |
| { |
| listener.addArtifactProblem( session, repoId, namespace, projectId, projectVersion, e ); |
| } |
| throw new MetadataResolutionException( e.getMessage(), e ); |
| } |
| |
| } |
| return metadata; |
| } |
| |
| @Override |
| public Collection<ProjectVersionReference> resolveProjectReferences( RepositorySession session, String repoId, |
| String namespace, String projectId, |
| String projectVersion ) |
| throws MetadataResolutionException |
| { |
| // TODO: is this assumption correct? could a storage mech. actually know all references in a non-Maven scenario? |
| // not passed to the storage mechanism as resolving references would require iterating all artifacts |
| MetadataRepository metadataRepository = session.getRepository(); |
| return metadataRepository.getProjectReferences( repoId, namespace, projectId, projectVersion ); |
| } |
| |
| @Override |
| public Collection<String> resolveRootNamespaces( RepositorySession session, String repoId ) |
| throws MetadataResolutionException |
| { |
| try |
| { |
| |
| Collection<String> namespaces = namespacesCache.get( repoId ); |
| if ( namespaces != null ) |
| { |
| return namespaces; |
| } |
| |
| MetadataRepository metadataRepository = session.getRepository(); |
| namespaces = metadataRepository.getRootNamespaces( repoId ); |
| Collection<String> storageNamespaces = |
| repositoryStorage.listRootNamespaces( repoId, new ExcludesFilter<String>( namespaces ) ); |
| if ( storageNamespaces != null && !storageNamespaces.isEmpty() ) |
| { |
| |
| log.debug( "Resolved root namespaces from storage: {}", storageNamespaces ); |
| |
| for ( String n : storageNamespaces ) |
| { |
| try |
| { |
| metadataRepository.updateNamespace( repoId, n ); |
| // just invalidate cache entry |
| String cacheKey = repoId + "-" + n; |
| namespacesCache.remove( cacheKey ); |
| } |
| catch ( MetadataRepositoryException e ) |
| { |
| log.warn( "Unable to persist resolved information: {}", e.getMessage(), e ); |
| } |
| } |
| session.markDirty(); |
| |
| namespaces = new ArrayList<>( namespaces ); |
| namespaces.addAll( storageNamespaces ); |
| } |
| |
| namespacesCache.put( repoId, namespaces ); |
| |
| return namespaces; |
| } |
| catch ( RepositoryStorageRuntimeException e ) |
| { |
| throw new MetadataResolutionException( e.getMessage(), e ); |
| } |
| } |
| |
| @Override |
| public Collection<String> resolveNamespaces( RepositorySession session, String repoId, String namespace ) |
| throws MetadataResolutionException |
| { |
| try |
| { |
| MetadataRepository metadataRepository = session.getRepository(); |
| String cacheKey = repoId + "-" + namespace; |
| Collection<String> namespaces = namespacesCache.get( cacheKey ); |
| if ( namespaces == null ) |
| { |
| namespaces = metadataRepository.getNamespaces( repoId, namespace ); |
| namespacesCache.put( cacheKey, namespaces ); |
| } |
| Collection<String> exclusions = new ArrayList<>( namespaces ); |
| exclusions.addAll( metadataRepository.getProjects( repoId, namespace ) ); |
| Collection<String> storageNamespaces = |
| repositoryStorage.listNamespaces( repoId, namespace, new ExcludesFilter<String>( exclusions ) ); |
| if ( storageNamespaces != null && !storageNamespaces.isEmpty() ) |
| { |
| |
| log.debug( "Resolved namespaces from storage: {}", storageNamespaces ); |
| |
| for ( String n : storageNamespaces ) |
| { |
| try |
| { |
| metadataRepository.updateNamespace( repoId, namespace + "." + n ); |
| // just invalidate cache entry |
| cacheKey = repoId + "-" + namespace + "." + n; |
| namespacesCache.remove( cacheKey ); |
| } |
| catch ( MetadataRepositoryException e ) |
| { |
| log.warn( "Unable to persist resolved information: {}", e.getMessage(), e ); |
| } |
| } |
| session.markDirty(); |
| |
| namespaces = new ArrayList<>( namespaces ); |
| namespaces.addAll( storageNamespaces ); |
| } |
| return namespaces; |
| } |
| catch ( RepositoryStorageRuntimeException e ) |
| { |
| throw new MetadataResolutionException( e.getMessage(), e ); |
| } |
| } |
| |
| @Override |
| public Collection<String> resolveProjects( RepositorySession session, String repoId, String namespace ) |
| throws MetadataResolutionException |
| { |
| try |
| { |
| MetadataRepository metadataRepository = session.getRepository(); |
| Collection<String> projects = metadataRepository.getProjects( repoId, namespace ); |
| Collection<String> exclusions = new ArrayList<>( projects ); |
| |
| String cacheKey = repoId + "-" + namespace; |
| Collection<String> namespaces = namespacesCache.get( cacheKey ); |
| if ( namespaces == null ) |
| { |
| namespaces = metadataRepository.getNamespaces( repoId, namespace ); |
| namespacesCache.put( cacheKey, namespaces ); |
| } |
| |
| exclusions.addAll( namespaces ); |
| |
| Collection<String> storageProjects = |
| repositoryStorage.listProjects( repoId, namespace, new ExcludesFilter<>( exclusions ) ); |
| if ( storageProjects != null && !storageProjects.isEmpty() ) |
| { |
| |
| log.debug( "Resolved projects from storage: {}", storageProjects ); |
| for ( String projectId : storageProjects ) |
| { |
| ProjectMetadata projectMetadata = |
| repositoryStorage.readProjectMetadata( repoId, namespace, projectId ); |
| if ( projectMetadata != null ) |
| { |
| try |
| { |
| metadataRepository.updateProject( repoId, projectMetadata ); |
| } |
| catch ( MetadataRepositoryException e ) |
| { |
| log.warn( "Unable to persist resolved information: {}", e.getMessage(), e ); |
| } |
| } |
| } |
| session.markDirty(); |
| |
| projects = new ArrayList<>( projects ); |
| projects.addAll( storageProjects ); |
| } |
| return projects; |
| } |
| catch ( RepositoryStorageRuntimeException e ) |
| { |
| throw new MetadataResolutionException( e.getMessage(), e ); |
| } |
| } |
| |
| @Override |
| public Collection<String> resolveProjectVersions( RepositorySession session, String repoId, String namespace, |
| String projectId ) |
| throws MetadataResolutionException |
| { |
| try |
| { |
| MetadataRepository metadataRepository = session.getRepository(); |
| |
| Collection<String> projectVersions = metadataRepository.getProjectVersions( repoId, namespace, projectId ); |
| Collection<String> storageProjectVersions = |
| repositoryStorage.listProjectVersions( repoId, namespace, projectId, |
| new ExcludesFilter<String>( projectVersions ) ); |
| if ( storageProjectVersions != null && !storageProjectVersions.isEmpty() ) |
| { |
| log.debug( "Resolved project versions from storage: {}", storageProjectVersions ); |
| |
| for ( String projectVersion : storageProjectVersions ) |
| { |
| try |
| { |
| ReadMetadataRequest readMetadataRequest = |
| new ReadMetadataRequest().repositoryId( repoId ).namespace( namespace ).projectId( |
| projectId ).projectVersion( projectVersion ); |
| ProjectVersionMetadata versionMetadata = |
| repositoryStorage.readProjectVersionMetadata( readMetadataRequest ); |
| for ( RepositoryListener listener : listeners ) |
| { |
| listener.addArtifact( session, repoId, namespace, projectId, versionMetadata ); |
| } |
| |
| metadataRepository.updateProjectVersion( repoId, namespace, projectId, versionMetadata ); |
| } |
| catch ( MetadataRepositoryException e ) |
| { |
| log.warn( "Unable to persist resolved information: {}", e.getMessage(), e ); |
| } |
| catch ( RepositoryStorageMetadataInvalidException e ) |
| { |
| log.warn( |
| "Not update project in metadata repository due to an error resolving it from storage: {}", |
| e.getMessage() ); |
| |
| for ( RepositoryListener listener : listeners ) |
| { |
| listener.addArtifactProblem( session, repoId, namespace, projectId, projectVersion, e ); |
| } |
| } |
| catch ( RepositoryStorageMetadataNotFoundException e ) |
| { |
| for ( RepositoryListener listener : listeners ) |
| { |
| listener.addArtifactProblem( session, repoId, namespace, projectId, projectVersion, e ); |
| } |
| } |
| } |
| session.markDirty(); |
| |
| projectVersions = new ArrayList<>( projectVersions ); |
| projectVersions.addAll( storageProjectVersions ); |
| } |
| return projectVersions; |
| } |
| catch ( RepositoryStorageRuntimeException e ) |
| { |
| throw new MetadataResolutionException( e.getMessage(), e ); |
| } |
| } |
| |
| @Override |
| public Collection<ArtifactMetadata> resolveArtifacts( RepositorySession session, String repoId, String namespace, |
| String projectId, String projectVersion ) |
| throws MetadataResolutionException |
| { |
| try |
| { |
| MetadataRepository metadataRepository = session.getRepository(); |
| Collection<ArtifactMetadata> artifacts = |
| metadataRepository.getArtifacts( repoId, namespace, projectId, projectVersion ); |
| ExcludesFilter<String> filter = new ExcludesFilter<String>( createArtifactIdList( artifacts ) ); |
| |
| ReadMetadataRequest readMetadataRequest = |
| new ReadMetadataRequest().repositoryId( repoId ).namespace( namespace ).projectId( |
| projectId ).projectVersion( projectVersion ).filter( filter ); |
| |
| Collection<ArtifactMetadata> storageArtifacts = |
| repositoryStorage.readArtifactsMetadata( readMetadataRequest ); |
| if ( storageArtifacts != null && !storageArtifacts.isEmpty() ) |
| { |
| |
| log.debug( "Resolved artifacts from storage: {}", storageArtifacts ); |
| |
| for ( ArtifactMetadata artifact : storageArtifacts ) |
| { |
| try |
| { |
| metadataRepository.updateArtifact( repoId, namespace, projectId, projectVersion, artifact ); |
| } |
| catch ( MetadataRepositoryException e ) |
| { |
| log.warn( "Unable to persist resolved information: {}", e.getMessage(), e ); |
| } |
| } |
| session.markDirty(); |
| |
| artifacts = new ArrayList<>( artifacts ); |
| artifacts.addAll( storageArtifacts ); |
| } |
| return artifacts; |
| } |
| catch ( RepositoryStorageRuntimeException e ) |
| { |
| for ( RepositoryListener listener : listeners ) |
| { |
| listener.addArtifactProblem( session, repoId, namespace, projectId, projectVersion, e ); |
| } |
| throw new MetadataResolutionException( e.getMessage(), e ); |
| } |
| } |
| |
| private Collection<String> createArtifactIdList( Collection<ArtifactMetadata> artifacts ) |
| { |
| Collection<String> artifactIds = new ArrayList<>(); |
| for ( ArtifactMetadata artifact : artifacts ) |
| { |
| artifactIds.add( artifact.getId() ); |
| } |
| return artifactIds; |
| } |
| } |
