Examples of org.apache.archiva.metadata.repository.RepositorySession

Package org.apache.archiva.metadata.repository

Examples of org.apache.archiva.metadata.repository.RepositorySession

org.apache.archiva.metadata.repository.RepositorySession
The repository session provides a single interface to accessing Archiva repositories. It provides access to three resources:
- {@link MetadataRepository} - the metadata content repository for read/write access, in its current state (noremote resources will be retrieved in the process
- {@link MetadataResolver} - access to resolve metadata content, accommodating metadata not yet stored or up todate in the content repository (i.e. virtualised repositories, remote proxied content, or metadata in a different model format in the repository storage)
- {@link org.apache.archiva.metadata.repository.storage.RepositoryStorage} - access to the physical storage of arepository and the source artifacts and project models

                }


                long sinceWhen = RepositoryScanner.FRESH_SCAN;
                long previousFileCount = 0;


                RepositorySession repositorySession = repositorySessionFactory.createSession();
                MetadataRepository metadataRepository = repositorySession.getRepository();
                try
                {
                    if ( !repoTask.isScanAll() )
                    {
                        RepositoryStatistics previousStats =
                            repositoryStatisticsManager.getLastStatistics( metadataRepository, repoId );
                        if ( previousStats != null )
                        {
                            sinceWhen = previousStats.getScanStartTime().getTime();
                            previousFileCount = previousStats.getTotalFileCount();
                        }
                    }


                    RepositoryScanStatistics stats;
                    try
                    {
                        stats = repoScanner.scan( arepo, sinceWhen );
                    }
                    catch ( RepositoryScannerException e )
                    {
                        throw new TaskExecutionException( "Repository error when executing repository job.", e );
                    }


                    log.info( "Finished first scan: {}", stats.toDump( arepo ) );


                    // further statistics will be populated by the following method
                    Date endTime = new Date( stats.getWhenGathered().getTime() + stats.getDuration() );


                    log.info( "Gathering repository statistics" );


                    repositoryStatisticsManager.addStatisticsAfterScan( metadataRepository, repoId,
                                                                        stats.getWhenGathered(), endTime,
                                                                        stats.getTotalFileCount(),
                                                                        stats.getTotalFileCount() - previousFileCount );
                    repositorySession.save();
                }
                catch ( MetadataRepositoryException e )
                {
                    throw new TaskExecutionException( "Unable to store updated statistics: " + e.getMessage(), e );
                }
                finally
                {
                    repositorySession.close();
                }


//                log.info( "Scanning for removed repository content" );


//                metadataRepository.findAllProjects();

View Full Code Here


        Collections.sort( managedRepositories, new RepositoryComparator() );
        Collections.sort( remoteRepositories, new RepositoryComparator() );


        repositoryStatistics = new HashMap<String, RepositoryStatistics>();
        RepositorySession repositorySession = repositorySessionFactory.createSession();
        try
        {
            MetadataRepository metadataRepository = repositorySession.getRepository();
            for ( ManagedRepository repo : managedRepositories )
            {
                RepositoryStatistics stats = null;
                try
                {
                    stats = repositoryStatisticsManager.getLastStatistics( metadataRepository, repo.getId() );
                }
                catch ( MetadataRepositoryException e )
                {
                    addActionError(
                        "Error retrieving statistics for repository " + repo.getId() + " - consult application logs" );
                    log.warn( "Error retrieving repository statistics: " + e.getMessage(), e );
                }
                if ( stats != null )
                {
                    repositoryStatistics.put( repo.getId(), stats );
                }
            }
        }
        finally
        {
            repositorySession.close();
        }
    }

View Full Code Here

        return SUCCESS;
    }


    public String deleteMetadataEntry()
    {
        RepositorySession repositorySession = repositorySessionFactory.createSession();
        try
        {
            MetadataRepository metadataRepository = repositorySession.getRepository();
            ProjectVersionMetadata projectMetadata = getProjectVersionMetadata( repositorySession );


            if ( projectMetadata == null )
            {
                addActionError( "Artifact not found" );
                return ERROR;
            }


            if ( projectMetadata.getFacet( GenericMetadataFacet.FACET_ID ) != null )
            {
                genericMetadata = projectMetadata.getFacet( GenericMetadataFacet.FACET_ID ).toProperties();


                if ( !StringUtils.isEmpty( deleteItem ) )
                {
                    genericMetadata.remove( deleteItem );


                    try
                    {
                        updateProjectMetadata( projectMetadata, metadataRepository );
                        repositorySession.save();
                    }
                    catch ( MetadataRepositoryException e )
                    {
                        log.warn( "Unable to persist modified project metadata after removing entry: " + e.getMessage(),
                                  e );
                        addActionError(
                            "Unable to remove metadata item to underlying content storage - consult application logs." );
                        return ERROR;
                    }


                    // TODO: why re-retrieve?
                    projectMetadata = getProjectVersionMetadata( repositorySession );


                    genericMetadata = projectMetadata.getFacet( GenericMetadataFacet.FACET_ID ).toProperties();


                    model = projectMetadata;


                    addActionMessage( "Property successfully deleted." );
                }


                deleteItem = "";
            }
            else
            {
                addActionError( "No generic metadata facet for this artifact." );
                return ERROR;
            }
        }
        finally
        {
            repositorySession.close();
        }


        return SUCCESS;
    }

View Full Code Here

        if ( repoConfig == null )
        {
            throw new Exception( "Repository does not exist." );
        }


        RepositorySession repositorySession = repositorySessionFactory.createSession();
        try
        {
            ManagedRepositoryContent repoContent = repoFactory.getManagedRepositoryContent( repoId );
            VersionedReference ref = new VersionedReference();
            ref.setGroupId( groupId );
            ref.setArtifactId( artifactId );
            ref.setVersion( version );


            // delete from file system
            repoContent.deleteVersion( ref );


            MetadataRepository metadataRepository = repositorySession.getRepository();
            Collection<ArtifactMetadata> artifacts =
                metadataRepository.getArtifacts( repoId, groupId, artifactId, version );


            for ( ArtifactMetadata artifact : artifacts )
            {
                // TODO: mismatch between artifact (snapshot) version and project (base) version here
                if ( artifact.getVersion().equals( version ) )
                {
                    metadataRepository.removeArtifact( artifact.getRepositoryId(), artifact.getNamespace(),
                                                       artifact.getProject(), artifact.getVersion(), artifact.getId() );


                    // TODO: move into the metadata repository proper - need to differentiate attachment of
                    // repository metadata to an artifact
                    for ( RepositoryListener listener : listeners )
                    {
                        listener.deleteArtifact( metadataRepository, repoId, artifact.getNamespace(),
                                                 artifact.getProject(), artifact.getVersion(), artifact.getId() );
                    }
                }
            }
            repositorySession.save();
        }
        catch ( ContentNotFoundException e )
        {
            throw new Exception( "Artifact does not exist." );
        }
        catch ( RepositoryNotFoundException e )
        {
            throw new Exception( "Repository does not exist." );
        }
        catch ( RepositoryException e )
        {
            throw new Exception( "Repository exception occurred." );
        }
        finally
        {
            repositorySession.close();
        }


        return true;
    }

View Full Code Here

        if ( repository == null )
        {
            throw new Exception( "A repository with that id does not exist" );
        }


        RepositorySession repositorySession = repositorySessionFactory.createSession();
        try
        {
            MetadataRepository metadataRepository = repositorySession.getRepository();
            metadataRepository.removeRepository( repository.getId() );
            repositoryStatisticsManager.deleteStatistics( metadataRepository, repository.getId() );
            repositorySession.save();
        }
        finally
        {
            repositorySession.close();
        }
        managedRepositoryAdmin.deleteManagedRepository( repoId, getAuditInformation(), false );


        File dir = new File( repository.getLocation() );
        if ( !FileUtils.deleteQuietly( dir ) )

View Full Code Here

        if ( repository == null )
        {
            throw new Exception( "Repository Id : " + repoId + " not found." );
        }


        RepositorySession repositorySession = repositorySessionFactory.createSession();
        try
        {
            MetadataRepository metadataRepository = repositorySession.getRepository();
            metadataRepository.removeRepository( repository.getId() );
            repositorySession.save();
        }
        finally
        {
            repositorySession.close();
        }


        File repoDir = new File( repository.getLocation() );
        File[] children = repoDir.listFiles();

View Full Code Here


        repoConfig = managedRepositoryAdmin.getManagedRepository( repoId );


        log.debug( "Retrieved repository configuration for repo '" + repoId + "'" );


        RepositorySession repositorySession = repositorySessionFactory.createSession();
        try
        {
            MetadataRepository metadataRepository = repositorySession.getRepository();
            if ( repoConfig != null )
            {
                stagingConfig = managedRepositoryAdmin.getManagedRepository( stagingId );


                if ( stagingConfig != null )
                {
                    List<ArtifactMetadata> sourceArtifacts = metadataRepository.getArtifacts( stagingId );


                    if ( repoConfig.isReleases() && !repoConfig.isSnapshots() )
                    {
                        log.info( "Repository to be merged contains releases only.." );
                        if ( skipConflicts )
                        {
                            List<ArtifactMetadata> conflicts =
                                repositoryMerger.getConflictingArtifacts( metadataRepository, repoId, stagingId );


                            if ( log.isDebugEnabled() )
                            {
                                log.debug( "Artifacts in conflict.." );
                                for ( ArtifactMetadata metadata : conflicts )
                                {
                                    log.debug( metadata.getNamespace() + ":" + metadata.getProject() + ":"
                                                   + metadata.getProjectVersion() );
                                }
                            }


                            sourceArtifacts.removeAll( conflicts );


                            log.debug( "Source artifacts size :: " + sourceArtifacts.size() );
                            mergeWithOutSnapshots( sourceArtifacts, stagingId, repoId, metadataRepository );
                        }
                        else
                        {
                            log.debug( "Source artifacts size :: " + sourceArtifacts.size() );
                            mergeWithOutSnapshots( sourceArtifacts, stagingId, repoId, metadataRepository );
                        }
                    }
                    else
                    {
                        log.info( "Repository to be merged has snapshot artifacts.." );
                        if ( skipConflicts )
                        {
                            List<ArtifactMetadata> conflicts =
                                repositoryMerger.getConflictingArtifacts( metadataRepository, repoId, stagingId );


                            if ( log.isDebugEnabled() )
                            {
                                log.debug( "Artifacts in conflict.." );
                                for ( ArtifactMetadata metadata : conflicts )
                                {
                                    log.debug( metadata.getNamespace() + ":" + metadata.getProject() + ":"
                                                   + metadata.getProjectVersion() );
                                }
                            }


                            sourceArtifacts.removeAll( conflicts );


                            log.debug( "Source artifacts size :: " + sourceArtifacts.size() );


                            Filter<ArtifactMetadata> artifactsWithOutConflicts =
                                new IncludesFilter<ArtifactMetadata>( sourceArtifacts );
                            repositoryMerger.merge( metadataRepository, stagingId, repoId, artifactsWithOutConflicts );


                            log.info( "Staging repository '" + stagingId + "' merged successfully with managed repo '"
                                          + repoId + "'." );
                        }
                        else
                        {
                            repositoryMerger.merge( metadataRepository, stagingId, repoId );


                            log.info( "Staging repository '" + stagingId + "' merged successfully with managed repo '"
                                          + repoId + "'." );
                        }
                    }
                }
                else
                {
                    throw new Exception( "Staging Id : " + stagingId + " not found." );
                }
            }
            else
            {
                throw new Exception( "Repository Id : " + repoId + " not found." );
            }


            if ( !repositoryTaskScheduler.isProcessingRepositoryTask( repoId ) )
            {
                RepositoryTask task = new RepositoryTask();
                task.setRepositoryId( repoId );


                repositoryTaskScheduler.queueTask( task );
            }


            AuditEvent event = createAuditEvent( repoConfig );


            // add event for audit log reports
            metadataRepository.addMetadataFacet( event.getRepositoryId(), event );


            // log event in archiva audit log
            auditListener.auditEvent( createAuditEvent( repoConfig ) );
            repositorySession.save();
        }
        finally
        {
            repositorySession.close();
        }


        return true;
    }

View Full Code Here

        }
    }


    public String doMerge()
    {
        RepositorySession repositorySession = repositorySessionFactory.createSession();
        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();
        }
    }

View Full Code Here

        }
    }


    public String mergeBySkippingConflicts()
    {
        RepositorySession repositorySession = repositorySessionFactory.createSession();
        try
        {
            MetadataRepository metadataRepository = repositorySession.getRepository();
            List<ArtifactMetadata> sourceArtifacts = metadataRepository.getArtifacts( sourceRepoId );
            sourceArtifacts.removeAll( conflictSourceArtifacts );


            if ( repository.isReleases() && !repository.isSnapshots() )
            {
                mergeWithOutSnapshots( metadataRepository, sourceArtifacts, sourceRepoId, repoid );
            }
            else
            {


                Filter<ArtifactMetadata> artifactsWithOutConflicts =
                    new IncludesFilter<ArtifactMetadata>( sourceArtifacts );
                repositoryMerger.merge( metadataRepository, sourceRepoId, repoid, artifactsWithOutConflicts );
                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();
        }
    }

View Full Code Here


    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;

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.apache.archiva.metadata.repository.RepositorySession

$package.SimpleArtifactConsumerTest

org.apache.archiva.admin.mock.MockRepositorySessionFactory

org.apache.archiva.admin.repository.managed.DefaultManagedRepositoryAdmin

org.apache.archiva.audit.MetadataAuditListener

org.apache.archiva.consumers.lucene.test.TestRepositorySessionFactory

org.apache.archiva.consumers.metadata.ArchivaMetadataCreationConsumer

org.apache.archiva.dependency.tree.maven2.DefaultDependencyTreeBuilder

org.apache.archiva.indexer.search.mock.MockRepositorySessionFactory

org.apache.archiva.metadata.repository.cassandra.CassandraRepositorySessionFactory

org.apache.archiva.metadata.repository.file.FileRepositorySessionFactory

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.