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

    }


    private List<RepositoryStatistics> getUniqueRepositoryReport( String repositoryId, int rowCount, Date startDate,
                                                                  Date endDate )
    {
        RepositorySession repositorySession = repositorySessionFactory.createSession();
        try
        {
            MetadataRepository metadataRepository = repositorySession.getRepository();
            List<RepositoryStatistics> stats = null;
            try
            {
                stats = repositoryStatisticsManager.getStatisticsInRange( metadataRepository, repositoryId, startDate,
                                                                          endDate );
            }
            catch ( MetadataRepositoryException e )
            {
                log.warn( "Unable to retrieve stats, assuming is empty: {}", e.getMessage(), e );
            }
            if ( stats == null || stats.isEmpty() )
            {
                return Collections.<RepositoryStatistics>emptyList();
            }


            return stats.subList( 0, stats.size() > rowCount ? rowCount : stats.size() );
        }
        finally
        {
            repositorySession.close();
        }
    }

View Full Code Here


    @Override
    public List<RepositoryProblemFacet> getHealthReport( String repository, String groupId, int rowCount )
        throws ArchivaRestServiceException
    {
        RepositorySession repositorySession = repositorySessionFactory.createSession();
        try
        {
            List<String> observableRepositories = getObservableRepos();
            if ( !ALL_REPOSITORIES.equals( repository ) && !observableRepositories.contains( repository ) )
            {
                throw new ArchivaRestServiceException(
                    "${$.i18n.prop('report.repository.illegal-access', " + repository + ")}", "repositoryId",
                    new IllegalAccessException() );
            }


            if ( !ALL_REPOSITORIES.equals( repository ) )
            {
                observableRepositories = Collections.singletonList( repository );
            }


            List<RepositoryProblemFacet> problemArtifacts = new ArrayList<>();
            MetadataRepository metadataRepository = repositorySession.getRepository();
            for ( String repoId : observableRepositories )
            {
                for ( String name : metadataRepository.getMetadataFacets( repoId, RepositoryProblemFacet.FACET_ID ) )
                {
                    RepositoryProblemFacet metadataFacet =
                        (RepositoryProblemFacet) metadataRepository.getMetadataFacet( repoId,
                                                                                      RepositoryProblemFacet.FACET_ID,
                                                                                      name );
                    if ( StringUtils.isEmpty( groupId ) || groupId.equals( metadataFacet.getNamespace() ) )
                    {
                        problemArtifacts.add( metadataFacet );
                    }
                }
            }


            return problemArtifacts;
        }
        catch ( MetadataRepositoryException e )
        {
            throw new ArchivaRestServiceException( e.getMessage(), e );
        }
        finally
        {
            repositorySession.close();
        }
    }

View Full Code Here


        // TODO: this logic should be optional, particularly remembering we want to keep this code simple
        //       it is located here to avoid the content repository implementation needing to do too much for what
        //       is essentially presentation code
        Set<String> namespacesToCollapse = new LinkedHashSet<String>();
        RepositorySession repositorySession = repositorySessionFactory.createSession();
        try
        {
            MetadataResolver metadataResolver = repositorySession.getResolver();


            for ( String repoId : selectedRepos )
            {
                namespacesToCollapse.addAll( metadataResolver.resolveRootNamespaces( repositorySession, repoId ) );
            }
            for ( String n : namespacesToCollapse )
            {
                // TODO: check performance of this
                namespaces.add( collapseNamespaces( repositorySession, metadataResolver, selectedRepos, n ) );
            }
        }
        catch ( MetadataResolutionException e )
        {
            throw new ArchivaRestServiceException( e.getMessage(),
                                                   Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(), e );
        }
        finally
        {
            repositorySession.close();
        }


        List<BrowseResultEntry> browseGroupResultEntries = new ArrayList<>( namespaces.size() );
        for ( String namespace : namespaces )
        {

View Full Code Here

    {
        List<String> selectedRepos = getSelectedRepos( repositoryId );


        Set<String> projects = new LinkedHashSet<>();


        RepositorySession repositorySession = repositorySessionFactory.createSession();
        Set<String> namespaces;
        try
        {
            MetadataResolver metadataResolver = repositorySession.getResolver();


            Set<String> namespacesToCollapse = new LinkedHashSet<>();
            for ( String repoId : selectedRepos )
            {
                namespacesToCollapse.addAll( metadataResolver.resolveNamespaces( repositorySession, repoId, groupId ) );


                projects.addAll( metadataResolver.resolveProjects( repositorySession, repoId, groupId ) );
            }


            // TODO: this logic should be optional, particularly remembering we want to keep this code simple
            // it is located here to avoid the content repository implementation needing to do too much for what
            // is essentially presentation code
            namespaces = new LinkedHashSet<>();
            for ( String n : namespacesToCollapse )
            {
                // TODO: check performance of this
                namespaces.add(
                    collapseNamespaces( repositorySession, metadataResolver, selectedRepos, groupId + "." + n ) );
            }
        }
        catch ( MetadataResolutionException e )
        {
            throw new ArchivaRestServiceException( e.getMessage(),
                                                   Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(), e );
        }
        finally
        {
            repositorySession.close();
        }
        List<BrowseResultEntry> browseGroupResultEntries = new ArrayList<>( namespaces.size() + projects.size() );
        for ( String namespace : namespaces )
        {
            browseGroupResultEntries.add( new BrowseResultEntry( namespace, false ).groupId( namespace ) );

View Full Code Here


    private Collection<String> getVersions( List<String> selectedRepos, String groupId, String artifactId )
        throws MetadataResolutionException


    {
        RepositorySession repositorySession = repositorySessionFactory.createSession();
        try
        {
            MetadataResolver metadataResolver = repositorySession.getResolver();


            Set<String> versions = new LinkedHashSet<String>();


            for ( String repoId : selectedRepos )
            {
                Collection<String> projectVersions =
                    metadataResolver.resolveProjectVersions( repositorySession, repoId, groupId, artifactId );
                versions.addAll( projectVersions );
            }


            List<String> sortedVersions = new ArrayList<>( versions );


            Collections.sort( sortedVersions, VersionComparator.getInstance() );


            return sortedVersions;
        }
        finally
        {
            repositorySession.close();
        }
    }

View Full Code Here

                                                      String repositoryId )
        throws ArchivaRestServiceException
    {
        List<String> selectedRepos = getSelectedRepos( repositoryId );


        RepositorySession repositorySession = null;
        try
        {
            repositorySession = repositorySessionFactory.createSession();


            MetadataResolver metadataResolver = repositorySession.getResolver();


            ProjectVersionMetadata versionMetadata = null;
            for ( String repoId : selectedRepos )
            {
                if ( versionMetadata == null || versionMetadata.isIncomplete() )
                {
                    try
                    {
                        versionMetadata =
                            metadataResolver.resolveProjectVersion( repositorySession, repoId, groupId, artifactId,
                                                                    version );
                    }
                    catch ( MetadataResolutionException e )
                    {
                        log.warn( "Skipping invalid metadata while compiling shared model for {}:{} in repo {}: {}",
                                  groupId, artifactId, repoId, e.getMessage() );
                    }
                }
            }


            return versionMetadata;
        }
        finally
        {
            if ( repositorySession != null )
            {
                repositorySession.close();
            }
        }


    }

View Full Code Here

        throws ArchivaRestServiceException
    {


        List<String> selectedRepos = getSelectedRepos( repositoryId );


        RepositorySession repositorySession = null;
        try
        {


            Collection<String> projectVersions = getVersions( selectedRepos, groupId, artifactId );


            repositorySession = repositorySessionFactory.createSession();


            MetadataResolver metadataResolver = repositorySession.getResolver();


            ProjectVersionMetadata sharedModel = new ProjectVersionMetadata();


            MavenProjectFacet mavenFacet = new MavenProjectFacet();
            mavenFacet.setGroupId( groupId );
            mavenFacet.setArtifactId( artifactId );
            sharedModel.addFacet( mavenFacet );


            boolean isFirstVersion = true;


            for ( String version : projectVersions )
            {
                ProjectVersionMetadata versionMetadata = null;
                for ( String repoId : selectedRepos )
                {
                    if ( versionMetadata == null || versionMetadata.isIncomplete() )
                    {
                        try
                        {
                            ProjectVersionMetadata projectVersionMetadataResolved = null;
                            boolean useCache = !StringUtils.endsWith( version, VersionUtil.SNAPSHOT );
                            String cacheKey = null;
                            boolean cacheToUpdate = false;
                            // FIXME a bit maven centric!!!
                            // not a snapshot so get it from cache
                            if ( useCache )
                            {
                                cacheKey = repoId + groupId + artifactId + version;
                                projectVersionMetadataResolved = versionMetadataCache.get( cacheKey );
                            }
                            if ( useCache && projectVersionMetadataResolved != null )
                            {
                                versionMetadata = projectVersionMetadataResolved;
                            }
                            else
                            {
                                projectVersionMetadataResolved =
                                    metadataResolver.resolveProjectVersion( repositorySession, repoId, groupId,
                                                                            artifactId, version );
                                versionMetadata = projectVersionMetadataResolved;
                                cacheToUpdate = true;
                            }


                            if ( useCache && cacheToUpdate )
                            {
                                versionMetadataCache.put( cacheKey, projectVersionMetadataResolved );
                            }


                        }
                        catch ( MetadataResolutionException e )
                        {
                            log.error( "Skipping invalid metadata while compiling shared model for " + groupId + ":"
                                           + artifactId + " in repo " + repoId + ": " + e.getMessage() );
                        }
                    }
                }


                if ( versionMetadata == null )
                {
                    continue;
                }


                if ( isFirstVersion )
                {
                    sharedModel = versionMetadata;
                    sharedModel.setId( null );
                }
                else
                {
                    MavenProjectFacet versionMetadataMavenFacet =
                        (MavenProjectFacet) versionMetadata.getFacet( MavenProjectFacet.FACET_ID );
                    if ( versionMetadataMavenFacet != null )
                    {
                        if ( mavenFacet.getPackaging() != null //
                            && !StringUtils.equalsIgnoreCase( mavenFacet.getPackaging(),
                                                              versionMetadataMavenFacet.getPackaging() ) )
                        {
                            mavenFacet.setPackaging( null );
                        }
                    }


                    if ( StringUtils.isEmpty( sharedModel.getName() ) //
                        && !StringUtils.isEmpty( versionMetadata.getName() ) )
                    {
                        sharedModel.setName( versionMetadata.getName() );
                    }


                    if ( sharedModel.getDescription() != null //
                        && !StringUtils.equalsIgnoreCase( sharedModel.getDescription(),
                                                          versionMetadata.getDescription() ) )
                    {
                        sharedModel.setDescription( StringUtils.isNotEmpty( versionMetadata.getDescription() )
                                                        ? versionMetadata.getDescription()
                                                        : "" );
                    }


                    if ( sharedModel.getIssueManagement() != null //
                        && versionMetadata.getIssueManagement() != null //
                        && !StringUtils.equalsIgnoreCase( sharedModel.getIssueManagement().getUrl(),
                                                          versionMetadata.getIssueManagement().getUrl() ) )
                    {
                        sharedModel.setIssueManagement( versionMetadata.getIssueManagement() );
                    }


                    if ( sharedModel.getCiManagement() != null //
                        && versionMetadata.getCiManagement() != null //
                        && !StringUtils.equalsIgnoreCase( sharedModel.getCiManagement().getUrl(),
                                                          versionMetadata.getCiManagement().getUrl() ) )
                    {
                        sharedModel.setCiManagement( versionMetadata.getCiManagement() );
                    }


                    if ( sharedModel.getOrganization() != null //
                        && versionMetadata.getOrganization() != null //
                        && !StringUtils.equalsIgnoreCase( sharedModel.getOrganization().getName(),
                                                          versionMetadata.getOrganization().getName() ) )
                    {
                        sharedModel.setOrganization( versionMetadata.getOrganization() );
                    }


                    if ( sharedModel.getUrl() != null //
                        && !StringUtils.equalsIgnoreCase( sharedModel.getUrl(), versionMetadata.getUrl() ) )
                    {
                        sharedModel.setUrl( versionMetadata.getUrl() );
                    }
                }


                isFirstVersion = false;
            }
            return sharedModel;
        }
        catch ( MetadataResolutionException e )
        {
            throw new ArchivaRestServiceException( e.getMessage(),
                                                   Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(), e );
        }
        finally
        {
            if ( repositorySession != null )
            {
                repositorySession.close();
            }
        }
    }

View Full Code Here

    public List<Artifact> getDependees( String groupId, String artifactId, String version, String repositoryId )
        throws ArchivaRestServiceException
    {
        List<ProjectVersionReference> references = new ArrayList<>();
        // TODO: what if we get duplicates across repositories?
        RepositorySession repositorySession = repositorySessionFactory.createSession();
        try
        {
            MetadataResolver metadataResolver = repositorySession.getResolver();
            for ( String repoId : getObservableRepos() )
            {
                // TODO: what about if we want to see this irrespective of version?
                references.addAll(
                    metadataResolver.resolveProjectReferences( repositorySession, repoId, groupId, artifactId,
                                                               version ) );
            }
        }
        catch ( MetadataResolutionException e )
        {
            throw new ArchivaRestServiceException( e.getMessage(),
                                                   Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(), e );
        }
        finally
        {
            repositorySession.close();
        }


        List<Artifact> artifacts = new ArrayList<>( references.size() );


        for ( ProjectVersionReference projectVersionReference : references )

View Full Code Here


        metadataFacet.fromProperties( properties );


        projectVersionMetadata.addFacet( metadataFacet );


        RepositorySession repositorySession = repositorySessionFactory.createSession();


        try
        {
            MetadataRepository metadataRepository = repositorySession.getRepository();


            metadataRepository.updateProjectVersion( repositoryId, groupId, artifactId, projectVersionMetadata );


            repositorySession.save();
        }
        catch ( MetadataRepositoryException e )
        {
            log.error( e.getMessage(), e );
            throw new ArchivaRestServiceException( e.getMessage(),
                                                   Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(), e );
        }
        finally
        {
            repositorySession.close();
        }
        return Boolean.TRUE;
    }

View Full Code Here

        else
        {
            return Boolean.TRUE;
        }


        RepositorySession repositorySession = repositorySessionFactory.createSession();


        try
        {
            MetadataRepository metadataRepository = repositorySession.getRepository();


            metadataRepository.updateProjectVersion( repositoryId, groupId, artifactId, projectVersionMetadata );


            repositorySession.save();
        }
        catch ( MetadataRepositoryException e )
        {
            log.error( e.getMessage(), e );
            throw new ArchivaRestServiceException( e.getMessage(),
                                                   Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(), e );
        }
        finally
        {
            repositorySession.close();
        }
        return Boolean.TRUE;
    }

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.