Package org.apache.maven.archiva.repository

Examples of org.apache.maven.archiva.repository.ManagedRepositoryContent


    public DavResource createResource( final DavResourceLocator locator, final DavSession davSession )
        throws DavException
    {
        ArchivaDavResourceLocator archivaLocator = checkLocatorIsInstanceOfRepositoryLocator( locator );

        ManagedRepositoryContent managedRepository;
        try
        {
            managedRepository = repositoryFactory.getManagedRepositoryContent( archivaLocator.getRepositoryId() );
        }
        catch ( RepositoryNotFoundException e )
        {
            throw new DavException( HttpServletResponse.SC_NOT_FOUND,
                                    "Invalid repository: " + archivaLocator.getRepositoryId() );
        }
        catch ( RepositoryException e )
        {
            throw new DavException( HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e );
        }

        String logicalResource = RepositoryPathUtil.getLogicalResource( locator.getResourcePath() );
        if ( logicalResource.startsWith( "/" ) )
        {
            logicalResource = logicalResource.substring( 1 );
        }
        File resourceFile = new File( managedRepository.getRepoRoot(), logicalResource );
        DavResource resource =
            new ArchivaDavResource( resourceFile.getAbsolutePath(), logicalResource, managedRepository.getRepository(),
                                    davSession, archivaLocator, this, mimeTypes, auditListeners, scheduler, auditLogsDao );

        resource.addLockManager( lockManager );
        return resource;
    }
View Full Code Here


        if ( allow )
        {
            for ( String repository : repositories )
            {
                ManagedRepositoryContent managedRepository = null;

                try
                {
                    managedRepository = repositoryFactory.getManagedRepositoryContent( repository );
                }
                catch ( RepositoryNotFoundException e )
                {
                    throw new DavException( HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
                                            "Invalid managed repository <" + repository + ">: " + e.getMessage() );
                }
                catch ( RepositoryException e )
                {
                    throw new DavException( HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
                                            "Invalid managed repository <" + repository + ">: " + e.getMessage() );
                }

                File resourceFile = new File( managedRepository.getRepoRoot(), logicalResource.getPath() );
                if ( resourceFile.exists() )
                {
                    // for prompted authentication
                    if ( httpAuth.getSecuritySession( request.getSession( true ) ) != null )
                    {
View Full Code Here

            artifactReference.setGroupId( groupId );
            artifactReference.setVersion( version );
            artifactReference.setClassifier( classifier );
            artifactReference.setType( packaging );

            ManagedRepositoryContent repository = repositoryFactory.getManagedRepositoryContent( repositoryId );

            String artifactPath = repository.toPath( artifactReference );

            int lastIndex = artifactPath.lastIndexOf( '/' );

            File targetPath = new File( repoConfig.getLocation(), artifactPath.substring( 0, lastIndex ) );

            Date lastUpdatedTimestamp = Calendar.getInstance().getTime();
            int newBuildNumber = -1;
            String timestamp = null;
           
            File metadataFile = getMetadata( targetPath.getAbsolutePath() );
            ArchivaRepositoryMetadata metadata = getMetadata( metadataFile );

            if (VersionUtil.isSnapshot(version))
            {
                TimeZone timezone = TimeZone.getTimeZone( "UTC" );
                DateFormat fmt = new SimpleDateFormat( "yyyyMMdd.HHmmss" );
                fmt.setTimeZone( timezone );
                timestamp = fmt.format( lastUpdatedTimestamp );
                if ( metadata.getSnapshotVersion() != null )
                {
                    newBuildNumber = metadata.getSnapshotVersion().getBuildNumber() + 1;
                }
                else
                {
                  metadata.setSnapshotVersion( new SnapshotVersion() );
                  newBuildNumber = 1;
                }
            }

            if ( !targetPath.exists() )
            {
                targetPath.mkdirs();
            }

            String filename = artifactPath.substring( lastIndex + 1 );
            if ( VersionUtil.isSnapshot( version ) )
            {
                filename = filename.replaceAll( "SNAPSHOT", timestamp + "-" + newBuildNumber );
            }

            try
            {
                copyFile( artifactFile, targetPath, filename );
                consumers.executeConsumers( repoConfig, repository.toFile( artifactReference ) );
            }
            catch ( IOException ie )
            {
                addActionError( "Error encountered while uploading file: " + ie.getMessage() );
                return ERROR;
View Full Code Here

            List<ArchivaArtifact> relatedArtifacts = dao.getArtifactDAO().queryArtifacts( constraint );

            if ( relatedArtifacts != null )
            {
                String repoId = ( (ArchivaArtifact) relatedArtifacts.get( 0 ) ).getModel().getRepositoryId();
                ManagedRepositoryContent repo = repositoryFactory.getManagedRepositoryContent( repoId );

                String prefix = req.getContextPath() + "/repository/" + repoId;

                if ( mini )
                {
View Full Code Here

        List<String> resourcesInAbsolutePath = new ArrayList<String>();
        DavException e = null;
       
        for ( String repositoryId : repositories )
        {
            ManagedRepositoryContent managedRepository = null;

            try
            {
                managedRepository = getManagedRepository( repositoryId );               
            }
            catch ( DavException de )
            {
                throw new DavException( HttpServletResponse.SC_NOT_FOUND, "Invalid managed repository <" +
                    repositoryId + ">" );
            }
           
            DavResource resource = null;
           
            if ( !locator.getResourcePath().startsWith( ArchivaDavResource.HIDDEN_PATH_PREFIX ) )
            {               
                if ( managedRepository != null )
                {
                    try
                    {
                        if( isAuthorized( request, repositoryId ) )
                        {  
                            LogicalResource logicalResource =
                                new LogicalResource( RepositoryPathUtil.getLogicalResource( locator.getResourcePath() ) );

                            if ( isGet )
                            {
                                resource = doGet( managedRepository, request, archivaLocator, logicalResource );
                            }

                            if ( isPut )
                            {
                                resource = doPut( managedRepository, request, archivaLocator, logicalResource );                               
                            }
                        }
                    }
                    catch ( DavException de )
                    {                       
                        e = de;
                        continue;
                    }

                    if( resource == null )
                    {
                        e = new DavException( HttpServletResponse.SC_NOT_FOUND, "Resource does not exist" );
                    }
                    else
                    {                          
                        availableResources.add( resource );

                        String logicalResource = RepositoryPathUtil.getLogicalResource( locator.getResourcePath() );
                        resourcesInAbsolutePath.add( managedRepository.getRepoRoot() + logicalResource );                       
                    }
                }
                else
                {
                    e = new DavException( HttpServletResponse.SC_NOT_FOUND, "Repository does not exist" );
View Full Code Here

        ArchivaDavResourceLocator archivaLocator = (ArchivaDavResourceLocator) locator;

        DavResource resource = null;
        if ( !locator.getResourcePath().startsWith( ArchivaDavResource.HIDDEN_PATH_PREFIX ) )
        {
            ManagedRepositoryContent managedRepository = getManagedRepository( archivaLocator.getRepositoryId() );
            String logicalResource = RepositoryPathUtil.getLogicalResource( locator.getResourcePath() );
            File resourceFile = new File( managedRepository.getRepoRoot(), logicalResource );
            resource =
                new ArchivaDavResource( resourceFile.getAbsolutePath(), logicalResource,
                                        managedRepository.getRepository(), davSession, archivaLocator, this, mimeTypes,
                                        auditListeners, consumers, archivaXworkUser );
        }
        resource.addLockManager(lockManager);
        return resource;
    }
View Full Code Here

    private void getResource( ArchivaDavResourceLocator locator, List<File> mergedRepositoryContents,
                              LogicalResource logicalResource, String repository )
        throws DavException
    {
        ManagedRepositoryContent managedRepository = null;

        try
        {
            managedRepository = getManagedRepository( repository );
        }
        catch ( DavException de )
        {
            throw new DavException( HttpServletResponse.SC_NOT_FOUND, "Invalid managed repository <" +
                repository + ">" );
        }

        if ( !locator.getResourcePath().startsWith( ArchivaVirtualDavResource.HIDDEN_PATH_PREFIX ) )
        {
            if( managedRepository != null )
            {
                File resourceFile = new File( managedRepository.getRepoRoot(), logicalResource.getPath() );
                if( resourceFile.exists() )
                {
                    mergedRepositoryContents.add( resourceFile );
                }
            }
View Full Code Here

            {  
                if( repo.isReleases() && !repo.getId().equals( repository.getId() ) )
                {  
                    try
                    {  
                        ManagedRepositoryContent repoContent = repoContentFactory.getManagedRepositoryContent( repo.getId() );                       
                        allVersions.addAll( repoContent.getVersions( reference ) );
                    }
                    catch( RepositoryNotFoundException  e )
                    {
                        // swallow
                    }
View Full Code Here

            Map<String, RepositoryContentIndex> indices = new HashMap<String, RepositoryContentIndex>();
            indices.put( "bytecode", indexFactory.createBytecodeIndex( repository ) );
            indices.put( "hashcodes", indexFactory.createHashcodeIndex( repository ) );
            indices.put( "filecontent", indexFactory.createFileContentIndex( repository ) );
           
            ManagedRepositoryContent repositoryContent = repositoryFactory.getManagedRepositoryContent( repository
                .getId() );

            if ( repository.getDaysOlder() != 0 )
            {
                repoPurge = new DaysOldRepositoryPurge( repositoryContent, dao.getArtifactDAO(), repository
View Full Code Here

    public void processArchivaArtifact( ArchivaArtifact artifact )
        throws ConsumerException
    {
        try
        {  
            ManagedRepositoryContent repoContent =
                repoFactory.getManagedRepositoryContent( artifact.getModel().getRepositoryId() );

            File file = new File( repoContent.getRepoRoot(), repoContent.toPath( artifact ) );
           
            if( !file.exists() )
            {  
                RepositoryContentIndex bytecodeIndex = repoIndexFactory.createBytecodeIndex( repoContent.getRepository() );
                RepositoryContentIndex hashcodesIndex = repoIndexFactory.createHashcodeIndex( repoContent.getRepository() );
                RepositoryContentIndex fileContentIndex =
                    repoIndexFactory.createFileContentIndex( repoContent.getRepository() );
   
                FileContentRecord fileContentRecord = new FileContentRecord();
                fileContentRecord.setFilename( repoContent.toPath( artifact ) );
                fileContentIndex.deleteRecord( fileContentRecord );
   
                HashcodesRecord hashcodesRecord = new HashcodesRecord();
                hashcodesRecord.setArtifact( artifact );
                hashcodesIndex.deleteRecord( hashcodesRecord );
View Full Code Here

TOP

Related Classes of org.apache.maven.archiva.repository.ManagedRepositoryContent

Copyright © 2018 www.massapicom. All rights reserved.
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.