AbstractRepositoryPurge.java

package org.apache.archiva.consumers.core.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.facets.AuditEvent;
import org.apache.archiva.common.utils.VersionUtil;
import org.apache.archiva.metadata.model.ArtifactMetadata;
import org.apache.archiva.metadata.model.maven2.MavenArtifactFacet;
import org.apache.archiva.metadata.repository.MetadataRepository;
import org.apache.archiva.metadata.repository.MetadataRepositoryException;
import org.apache.archiva.metadata.repository.MetadataResolutionException;
import org.apache.archiva.metadata.repository.RepositorySession;
import org.apache.archiva.model.ArtifactReference;
import org.apache.archiva.repository.ContentNotFoundException;
import org.apache.archiva.repository.ManagedRepositoryContent;
import org.apache.archiva.repository.events.RepositoryListener;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.FilenameFilter;
import java.util.Collection;
import java.util.List;
import java.util.Set;

/**
 * Base class for all repository purge tasks.
 */
public abstract class AbstractRepositoryPurge
    implements RepositoryPurge
{
    protected Logger log = LoggerFactory.getLogger( getClass() );

    protected final ManagedRepositoryContent repository;

    protected final RepositorySession repositorySession;

    protected final List<RepositoryListener> listeners;

    private Logger logger = LoggerFactory.getLogger( "org.apache.archiva.AuditLog" );

    private static final char DELIM = ' ';

    public AbstractRepositoryPurge( ManagedRepositoryContent repository, RepositorySession repositorySession,
                                    List<RepositoryListener> listeners )
    {
        this.repository = repository;
        this.repositorySession = repositorySession;
        this.listeners = listeners;
    }

    /**
     * Purge the repo. Update db and index of removed artifacts.
     *
     * @param references
     */
    protected void purge( Set<ArtifactReference> references )
    {
        if ( references != null && !references.isEmpty() )
        {
            MetadataRepository metadataRepository = repositorySession.getRepository();
            for ( ArtifactReference reference : references )
            {
                File artifactFile = repository.toFile( reference );

                for ( RepositoryListener listener : listeners )
                {
                    listener.deleteArtifact( metadataRepository, repository.getId(), reference.getGroupId(),
                                             reference.getArtifactId(), reference.getVersion(),
                                             artifactFile.getName() );
                }

                // TODO: this needs to be logged
                artifactFile.delete();
                try
                {
                    repository.deleteArtifact( reference );
                }
                catch ( ContentNotFoundException e )
                {
                    log.warn( "skip error deleting artifact {}: {}", reference, e.getMessage() );
                }

                try
                {
                    metadataRepository.removeProjectVersion( repository.getId(), reference.getGroupId(),
                                                             reference.getArtifactId(), reference.getVersion() );
                }
                catch ( MetadataRepositoryException e )
                {
                    log.warn( "skip error removeProjectVersion artifact {}: {}", reference, e.getMessage() );
                }

                boolean snapshotVersion = VersionUtil.isSnapshot( reference.getVersion() );

                try
                {
                    if ( snapshotVersion )
                    {
                        String baseVersion = VersionUtil.getBaseVersion( reference.getVersion() );
                        Collection<ArtifactMetadata> artifacts =
                            metadataRepository.getArtifacts( repository.getId(), reference.getGroupId(),
                                                             reference.getArtifactId(), baseVersion );
                        if ( artifacts != null )
                        {
                            // cleanup snapshots metadata
                            for ( ArtifactMetadata artifactMetadata : artifacts )
                            {

                                // TODO: mismatch between artifact (snapshot) version and project (base) version here
                                if ( artifactMetadata.getVersion().equals( reference.getVersion() ) )
                                {
                                    if ( StringUtils.isNotBlank( reference.getClassifier() ) )
                                    {

                                        // cleanup facet which contains classifier information
                                        MavenArtifactFacet mavenArtifactFacet =
                                            (MavenArtifactFacet) artifactMetadata.getFacet(
                                                MavenArtifactFacet.FACET_ID );

                                        if ( StringUtils.equals( reference.getClassifier(),
                                                                 mavenArtifactFacet.getClassifier() ) )
                                        {
                                            artifactMetadata.removeFacet( MavenArtifactFacet.FACET_ID );
                                            String groupId = reference.getGroupId(), artifactId =
                                                reference.getArtifactId(),
                                                version = reference.getVersion();
                                            MavenArtifactFacet mavenArtifactFacetToCompare = new MavenArtifactFacet();
                                            mavenArtifactFacetToCompare.setClassifier( reference.getClassifier() );
                                            metadataRepository.removeArtifact( repository.getId(), groupId, artifactId,
                                                                               version, mavenArtifactFacetToCompare );
                                            metadataRepository.save();
                                        }

                                    }
                                    else
                                    {
                                        metadataRepository.removeArtifact( artifactMetadata, VersionUtil.getBaseVersion(
                                            reference.getVersion() ) );
                                    }

                                }
                            }
                        }
                    }
                }
                catch ( MetadataResolutionException e )
                {
                    log.warn( "skip error deleting metadata {}: {}", reference, e.getMessage() );
                }
                catch ( MetadataRepositoryException e )
                {
                    log.warn( "skip error deleting metadata {}: {}", reference, e.getMessage() );
                }

                repositorySession.save();

                triggerAuditEvent( repository.getRepository().getId(), ArtifactReference.toKey( reference ),
                                   AuditEvent.PURGE_ARTIFACT );
                purgeSupportFiles( artifactFile );
            }
        }
    }

    /**
     * <p>
     * This find support files for the artifactFile and deletes them.
     * </p>
     * <p>
     * Support Files are things like ".sha1", ".md5", ".asc", etc.
     * </p>
     *
     * @param artifactFile the file to base off of.
     */
    private void purgeSupportFiles( File artifactFile )
    {
        File parentDir = artifactFile.getParentFile();

        if ( !parentDir.exists() )
        {
            return;
        }

        FilenameFilter filter = new ArtifactFilenameFilter( artifactFile.getName() );

        File[] files = parentDir.listFiles( filter );

        for ( File file : files )
        {
            if ( file.exists() && file.isFile() )
            {
                String fileName = file.getName();
                file.delete();
                // TODO: log that it was deleted
                triggerAuditEvent( repository.getRepository().getId(), fileName, AuditEvent.PURGE_FILE );
            }
        }
    }

    private void triggerAuditEvent( String repoId, String resource, String action )
    {
        String msg =
            repoId + DELIM + "<system-purge>" + DELIM + "<system>" + DELIM + '\"' + resource + '\"' + DELIM + '\"' +
                action + '\"';

        logger.info( msg );
    }
}