source.dussan.org Git - archiva.git/blob

   1 package org.apache.archiva.consumers.core.repository;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  *  http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22 import org.apache.archiva.admin.model.RepositoryAdminException;
  23 import org.apache.archiva.admin.model.beans.ManagedRepository;
  24 import org.apache.archiva.admin.model.managed.ManagedRepositoryAdmin;
  25 import org.apache.archiva.common.utils.VersionComparator;
  26 import org.apache.archiva.common.utils.VersionUtil;
  27 import org.apache.archiva.metadata.repository.MetadataRepository;
  28 import org.apache.archiva.metadata.repository.MetadataRepositoryException;
  29 import org.apache.archiva.metadata.repository.RepositorySession;
  30 import org.apache.archiva.model.ArtifactReference;
  31 import org.apache.archiva.model.ProjectReference;
  32 import org.apache.archiva.model.VersionedReference;
  33 import org.apache.archiva.repository.ContentNotFoundException;
  34 import org.apache.archiva.repository.ManagedRepositoryContent;
  35 import org.apache.archiva.repository.ReleaseScheme;
  36 import org.apache.archiva.repository.RepositoryContentFactory;
  37 import org.apache.archiva.repository.RepositoryException;
  38 import org.apache.archiva.repository.RepositoryNotFoundException;
  39 import org.apache.archiva.repository.RepositoryRegistry;
  40 import org.apache.archiva.repository.events.RepositoryListener;
  41 import org.apache.archiva.repository.layout.LayoutException;
  42 import org.apache.archiva.repository.metadata.MetadataTools;
  43 import org.apache.archiva.repository.metadata.RepositoryMetadataException;
  44
  45 import javax.inject.Inject;
  46 import java.io.IOException;
  47 import java.nio.file.Files;
  48 import java.nio.file.Path;
  49 import java.nio.file.Paths;
  50 import java.util.ArrayList;
  51 import java.util.Collection;
  52 import java.util.Collections;
  53 import java.util.List;
  54
  55 /**
  56  * <p>
  57  * This will look in a single managed repository, and purge any snapshots that are present
  58  * that have a corresponding released version on the same repository.
  59  * </p>
  60  * <p>
  61  * So, if you have the following (presented in the m2/default layout form) ...
  62  * <pre>
  63  *   /com/foo/foo-tool/1.0-SNAPSHOT/foo-tool-1.0-SNAPSHOT.jar
  64  *   /com/foo/foo-tool/1.1-SNAPSHOT/foo-tool-1.1-SNAPSHOT.jar
  65  *   /com/foo/foo-tool/1.2.1-SNAPSHOT/foo-tool-1.2.1-SNAPSHOT.jar
  66  *   /com/foo/foo-tool/1.2.1/foo-tool-1.2.1.jar
  67  *   /com/foo/foo-tool/2.0-SNAPSHOT/foo-tool-2.0-SNAPSHOT.jar
  68  *   /com/foo/foo-tool/2.0/foo-tool-2.0.jar
  69  *   /com/foo/foo-tool/2.1-SNAPSHOT/foo-tool-2.1-SNAPSHOT.jar
  70  * </pre>
  71  * then the current highest ranked released (non-snapshot) version is 2.0, which means
  72  * the snapshots from 1.0-SNAPSHOT, 1.1-SNAPSHOT, 1.2.1-SNAPSHOT, and 2.0-SNAPSHOT can
  73  * be purged.  Leaving 2.1-SNAPSHOT in alone.
  74  */
  75 public class CleanupReleasedSnapshotsRepositoryPurge
  76     extends AbstractRepositoryPurge
  77 {
  78     private MetadataTools metadataTools;
  79
  80     private RepositoryRegistry repositoryRegistry;
  81
  82     public CleanupReleasedSnapshotsRepositoryPurge( ManagedRepositoryContent repository, MetadataTools metadataTools,
  83                                                     RepositoryRegistry repositoryRegistry,
  84                                                     RepositorySession repositorySession,
  85                                                     List<RepositoryListener> listeners )
  86     {
  87         super( repository, repositorySession, listeners );
  88         this.metadataTools = metadataTools;
  89         this.repositoryRegistry = repositoryRegistry;
  90     }
  91
  92     @Override
  93     public void process( String path )
  94         throws RepositoryPurgeException
  95     {
  96         try
  97         {
  98             Path artifactFile = Paths.get( repository.getRepoRoot( ), path );
  99
 100             if ( !Files.exists(artifactFile) )
 101             {
 102                 // Nothing to do here, file doesn't exist, skip it.
 103                 return;
 104             }
 105
 106             ArtifactReference artifactRef = repository.toArtifactReference( path );
 107
 108             if ( !VersionUtil.isSnapshot( artifactRef.getVersion( ) ) )
 109             {
 110                 // Nothing to do here, not a snapshot, skip it.
 111                 return;
 112             }
 113
 114             ProjectReference reference = new ProjectReference( );
 115             reference.setGroupId( artifactRef.getGroupId( ) );
 116             reference.setArtifactId( artifactRef.getArtifactId( ) );
 117
 118             // Gether the released versions
 119             List<String> releasedVersions = new ArrayList<>( );
 120
 121             Collection<org.apache.archiva.repository.ManagedRepository> repos = repositoryRegistry.getManagedRepositories( );
 122             for ( org.apache.archiva.repository.ManagedRepository repo : repos )
 123             {
 124
 125                 if ( repo.getActiveReleaseSchemes().contains( ReleaseScheme.RELEASE ))
 126                 {
 127                     try
 128                     {
 129                         ManagedRepositoryContent repoContent = repo.getContent();
 130                         for ( String version : repoContent.getVersions( reference ) )
 131                         {
 132                             if ( !VersionUtil.isSnapshot( version ) )
 133                             {
 134                                 releasedVersions.add( version );
 135                             }
 136                         }
 137                     }
 138                     catch ( RepositoryException e )
 139                     {
 140                         // swallow
 141                     }
 142                 }
 143             }
 144
 145             Collections.sort( releasedVersions, VersionComparator.getInstance( ) );
 146
 147             // Now clean out any version that is earlier than the highest released version.
 148             boolean needsMetadataUpdate = false;
 149
 150             VersionedReference versionRef = new VersionedReference( );
 151             versionRef.setGroupId( artifactRef.getGroupId( ) );
 152             versionRef.setArtifactId( artifactRef.getArtifactId( ) );
 153
 154             MetadataRepository metadataRepository = repositorySession.getRepository( );
 155
 156             if ( releasedVersions.contains( VersionUtil.getReleaseVersion( artifactRef.getVersion( ) ) ) )
 157             {
 158                 versionRef.setVersion( artifactRef.getVersion( ) );
 159                 repository.deleteVersion( versionRef );
 160
 161                 for ( RepositoryListener listener : listeners )
 162                 {
 163                     listener.deleteArtifact( metadataRepository, repository.getId( ), artifactRef.getGroupId( ),
 164                         artifactRef.getArtifactId( ), artifactRef.getVersion( ),
 165                         artifactFile.getFileName().toString() );
 166                 }
 167                 metadataRepository.removeProjectVersion( repository.getId( ), artifactRef.getGroupId( ),
 168                     artifactRef.getArtifactId( ), artifactRef.getVersion( ) );
 169
 170                 needsMetadataUpdate = true;
 171             }
 172
 173             if ( needsMetadataUpdate )
 174             {
 175                 updateMetadata( artifactRef );
 176             }
 177         }
 178         catch ( LayoutException e )
 179         {
 180             log.debug( "Not processing file that is not an artifact: {}", e.getMessage( ) );
 181         }
 182         catch ( ContentNotFoundException e )
 183         {
 184             throw new RepositoryPurgeException( e.getMessage( ), e );
 185         }
 186         catch ( MetadataRepositoryException e )
 187         {
 188             log.error( "Could not remove metadata during cleanup of released snapshots of {}", path, e );
 189         }
 190     }
 191
 192     private void updateMetadata( ArtifactReference artifact )
 193     {
 194         VersionedReference versionRef = new VersionedReference( );
 195         versionRef.setGroupId( artifact.getGroupId( ) );
 196         versionRef.setArtifactId( artifact.getArtifactId( ) );
 197         versionRef.setVersion( artifact.getVersion( ) );
 198
 199         ProjectReference projectRef = new ProjectReference( );
 200         projectRef.setGroupId( artifact.getGroupId( ) );
 201         projectRef.setArtifactId( artifact.getArtifactId( ) );
 202
 203         try
 204         {
 205             metadataTools.updateMetadata( repository, versionRef );
 206         }
 207         catch ( ContentNotFoundException e )
 208         {
 209             // Ignore. (Just means we have no snapshot versions left to reference).
 210         }
 211         catch ( RepositoryMetadataException e )
 212         {
 213             // Ignore.
 214         }
 215         catch ( IOException e )
 216         {
 217             // Ignore.
 218         }
 219         catch ( LayoutException e )
 220         {
 221             // Ignore.
 222         }
 223
 224         try
 225         {
 226             metadataTools.updateMetadata( repository, projectRef );
 227         }
 228         catch ( ContentNotFoundException e )
 229         {
 230             // Ignore. (Just means we have no snapshot versions left to reference).
 231         }
 232         catch ( RepositoryMetadataException e )
 233         {
 234             // Ignore.
 235         }
 236         catch ( IOException e )
 237         {
 238             // Ignore.
 239         }
 240         catch ( LayoutException e )
 241         {
 242             // Ignore.
 243         }
 244     }
 245 }