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

   1 package org.apache.maven.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 java.io.File;
  23 import java.io.IOException;
  24 import java.util.ArrayList;
  25 import java.util.Collections;
  26 import java.util.List;
  27
  28 import org.apache.maven.archiva.common.utils.VersionComparator;
  29 import org.apache.maven.archiva.common.utils.VersionUtil;
  30 import org.apache.maven.archiva.configuration.ArchivaConfiguration;
  31 import org.apache.maven.archiva.configuration.ManagedRepositoryConfiguration;
  32 import org.apache.maven.archiva.model.ArchivaArtifact;
  33 import org.apache.maven.archiva.model.ArtifactReference;
  34 import org.apache.maven.archiva.model.ProjectReference;
  35 import org.apache.maven.archiva.model.VersionedReference;
  36 import org.apache.maven.archiva.repository.ContentNotFoundException;
  37 import org.apache.maven.archiva.repository.ManagedRepositoryContent;
  38 import org.apache.maven.archiva.repository.RepositoryContentFactory;
  39 import org.apache.maven.archiva.repository.RepositoryException;
  40 import org.apache.maven.archiva.repository.RepositoryNotFoundException;
  41 import org.apache.maven.archiva.repository.events.RepositoryListener;
  42 import org.apache.maven.archiva.repository.layout.LayoutException;
  43 import org.apache.maven.archiva.repository.metadata.MetadataTools;
  44 import org.apache.maven.archiva.repository.metadata.RepositoryMetadataException;
  45
  46 /**
  47  * <p>
  48  * This will look in a single managed repository, and purge any snapshots that are present
  49  * that have a corresponding released version on the same repository.
  50  * </p>
  51  *
  52  * <p>
  53  * So, if you have the following (presented in the m2/default layout form) ...
  54  * <pre>
  55  *   /com/foo/foo-tool/1.0-SNAPSHOT/foo-tool-1.0-SNAPSHOT.jar
  56  *   /com/foo/foo-tool/1.1-SNAPSHOT/foo-tool-1.1-SNAPSHOT.jar
  57  *   /com/foo/foo-tool/1.2.1-SNAPSHOT/foo-tool-1.2.1-SNAPSHOT.jar
  58  *   /com/foo/foo-tool/1.2.1/foo-tool-1.2.1.jar
  59  *   /com/foo/foo-tool/2.0-SNAPSHOT/foo-tool-2.0-SNAPSHOT.jar
  60  *   /com/foo/foo-tool/2.0/foo-tool-2.0.jar
  61  *   /com/foo/foo-tool/2.1-SNAPSHOT/foo-tool-2.1-SNAPSHOT.jar
  62  * </pre>
  63  * then the current highest ranked released (non-snapshot) version is 2.0, which means
  64  * the snapshots from 1.0-SNAPSHOT, 1.1-SNAPSHOT, 1.2.1-SNAPSHOT, and 2.0-SNAPSHOT can
  65  * be purged.  Leaving 2.1-SNAPSHOT in alone.
  66  * </p>
  67  *
  68  * @version $Id$
  69  */
  70 public class CleanupReleasedSnapshotsRepositoryPurge
  71     extends AbstractRepositoryPurge
  72 {
  73     private MetadataTools metadataTools;
  74
  75     private ArchivaConfiguration archivaConfig;
  76
  77     private RepositoryContentFactory repoContentFactory;
  78
  79     public CleanupReleasedSnapshotsRepositoryPurge( ManagedRepositoryContent repository, MetadataTools metadataTools,
  80                                                     ArchivaConfiguration archivaConfig,
  81                                                     RepositoryContentFactory repoContentFactory,
  82                                                     List<RepositoryListener> listeners )
  83     {
  84         super( repository, listeners );
  85         this.metadataTools = metadataTools;
  86         this.archivaConfig = archivaConfig;
  87         this.repoContentFactory = repoContentFactory;
  88     }
  89
  90     public void process( String path )
  91         throws RepositoryPurgeException
  92     {
  93         try
  94         {
  95             File artifactFile = new File( repository.getRepoRoot(), path );
  96
  97             if ( !artifactFile.exists() )
  98             {
  99                 // Nothing to do here, file doesn't exist, skip it.
 100                 return;
 101             }
 102
 103             ArtifactReference artifactRef = repository.toArtifactReference( path );
 104
 105             if ( !VersionUtil.isSnapshot( artifactRef.getVersion() ) )
 106             {
 107                 // Nothing to do here, not a snapshot, skip it.
 108                 return;
 109             }
 110
 111             ProjectReference reference = new ProjectReference();
 112             reference.setGroupId( artifactRef.getGroupId() );
 113             reference.setArtifactId( artifactRef.getArtifactId() );
 114
 115             // Gather up all of the versions.
 116             List<String> allVersions = new ArrayList<String>( repository.getVersions( reference ) );
 117
 118             List<ManagedRepositoryConfiguration> repos = archivaConfig.getConfiguration().getManagedRepositories();
 119             for( ManagedRepositoryConfiguration repo : repos )
 120             {
 121                 if( repo.isReleases() && !repo.getId().equals( repository.getId() ) )
 122                 {
 123                     try
 124                     {
 125                         ManagedRepositoryContent repoContent = repoContentFactory.getManagedRepositoryContent( repo.getId() );
 126                         allVersions.addAll( repoContent.getVersions( reference ) );
 127                     }
 128                     catch( RepositoryNotFoundException  e )
 129                     {
 130                         // swallow
 131                     }
 132                     catch( RepositoryException  e )
 133                     {
 134                         // swallow
 135                     }
 136                 }
 137             }
 138
 139             // Split the versions into released and snapshots.
 140             List<String> releasedVersions = new ArrayList<String>();
 141             List<String> snapshotVersions = new ArrayList<String>();
 142
 143             for ( String version : allVersions )
 144             {
 145                 if ( VersionUtil.isSnapshot( version ) )
 146                 {
 147                     snapshotVersions.add( version );
 148                 }
 149                 else
 150                 {
 151                     releasedVersions.add( version );
 152                 }
 153             }
 154
 155             Collections.sort( allVersions, VersionComparator.getInstance() );
 156             Collections.sort( releasedVersions, VersionComparator.getInstance() );
 157             Collections.sort( snapshotVersions, VersionComparator.getInstance() );
 158
 159             // Now clean out any version that is earlier than the highest released version.
 160             boolean needsMetadataUpdate = false;
 161
 162             VersionedReference versionRef = new VersionedReference();
 163             versionRef.setGroupId( artifactRef.getGroupId() );
 164             versionRef.setArtifactId( artifactRef.getArtifactId() );
 165
 166             ArchivaArtifact artifact =
 167                 new ArchivaArtifact( artifactRef.getGroupId(), artifactRef.getArtifactId(), artifactRef.getVersion(),
 168                                      artifactRef.getClassifier(), artifactRef.getType(), repository.getId() );
 169
 170             for ( String version : snapshotVersions )
 171             {
 172                 if( releasedVersions.contains( VersionUtil.getReleaseVersion( version ) ) )
 173                 {
 174                     versionRef.setVersion( version );
 175                     repository.deleteVersion( versionRef );
 176
 177                     // TODO: looks incomplete, might not delete related artifacts?
 178                     for ( RepositoryListener listener : listeners )
 179                     {
 180                         listener.deleteArtifact( repository, artifact );
 181                     }
 182
 183                     needsMetadataUpdate = true;
 184                 }
 185             }
 186
 187             if ( needsMetadataUpdate )
 188             {
 189                 updateMetadata( artifactRef );
 190             }
 191         }
 192         catch ( LayoutException e )
 193         {
 194             throw new RepositoryPurgeException( e.getMessage(), e );
 195         }
 196         catch ( ContentNotFoundException e )
 197         {
 198             throw new RepositoryPurgeException( e.getMessage(), e );
 199         }
 200     }
 201
 202     private void updateMetadata( ArtifactReference artifact )
 203     {
 204         VersionedReference versionRef = new VersionedReference();
 205         versionRef.setGroupId( artifact.getGroupId() );
 206         versionRef.setArtifactId( artifact.getArtifactId() );
 207         versionRef.setVersion( artifact.getVersion() );
 208
 209         ProjectReference projectRef = new ProjectReference();
 210         projectRef.setGroupId( artifact.getGroupId() );
 211         projectRef.setArtifactId( artifact.getArtifactId() );
 212
 213         try
 214         {
 215             metadataTools.updateMetadata( repository, versionRef );
 216         }
 217         catch ( ContentNotFoundException e )
 218         {
 219             // Ignore. (Just means we have no snapshot versions left to reference).
 220         }
 221         catch ( RepositoryMetadataException e )
 222         {
 223             // Ignore.
 224         }
 225         catch ( IOException e )
 226         {
 227             // Ignore.
 228         }
 229         catch ( LayoutException e )
 230         {
 231             // Ignore.
 232         }
 233
 234         try
 235         {
 236             metadataTools.updateMetadata( repository, projectRef );
 237         }
 238         catch ( ContentNotFoundException e )
 239         {
 240             // Ignore. (Just means we have no snapshot versions left to reference).
 241         }
 242         catch ( RepositoryMetadataException e )
 243         {
 244             // Ignore.
 245         }
 246         catch ( IOException e )
 247         {
 248             // Ignore.
 249         }
 250         catch ( LayoutException e )
 251         {
 252             // Ignore.
 253         }
 254     }
 255 }