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

   1 package org.apache.maven.archiva.web.action;
   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 com.opensymphony.xwork2.Preparable;
  23 import com.opensymphony.xwork2.Validateable;
  24 import org.apache.archiva.audit.AuditEvent;
  25 import org.apache.archiva.audit.Auditable;
  26 import org.apache.archiva.checksum.ChecksumAlgorithm;
  27 import org.apache.archiva.checksum.ChecksummedFile;
  28 import org.apache.archiva.metadata.model.ArtifactMetadata;
  29 import org.apache.archiva.metadata.repository.MetadataRepository;
  30 import org.apache.archiva.metadata.repository.MetadataRepositoryException;
  31 import org.apache.archiva.metadata.repository.MetadataResolutionException;
  32 import org.apache.archiva.repository.events.RepositoryListener;
  33 import org.apache.maven.archiva.common.utils.VersionComparator;
  34 import org.apache.maven.archiva.common.utils.VersionUtil;
  35 import org.apache.maven.archiva.configuration.ArchivaConfiguration;
  36 import org.apache.maven.archiva.configuration.ManagedRepositoryConfiguration;
  37 import org.apache.maven.archiva.model.ArchivaRepositoryMetadata;
  38 import org.apache.maven.archiva.model.VersionedReference;
  39 import org.apache.maven.archiva.repository.ContentNotFoundException;
  40 import org.apache.maven.archiva.repository.ManagedRepositoryContent;
  41 import org.apache.maven.archiva.repository.RepositoryContentFactory;
  42 import org.apache.maven.archiva.repository.RepositoryException;
  43 import org.apache.maven.archiva.repository.RepositoryNotFoundException;
  44 import org.apache.maven.archiva.repository.metadata.MetadataTools;
  45 import org.apache.maven.archiva.repository.metadata.RepositoryMetadataException;
  46 import org.apache.maven.archiva.repository.metadata.RepositoryMetadataReader;
  47 import org.apache.maven.archiva.repository.metadata.RepositoryMetadataWriter;
  48 import org.apache.maven.archiva.security.AccessDeniedException;
  49 import org.apache.maven.archiva.security.ArchivaSecurityException;
  50 import org.apache.maven.archiva.security.PrincipalNotFoundException;
  51 import org.apache.maven.archiva.security.UserRepositories;
  52
  53 import java.io.File;
  54 import java.text.DateFormat;
  55 import java.text.SimpleDateFormat;
  56 import java.util.ArrayList;
  57 import java.util.Calendar;
  58 import java.util.Collection;
  59 import java.util.Collections;
  60 import java.util.Date;
  61 import java.util.List;
  62 import java.util.TimeZone;
  63
  64 /**
  65  * Delete an artifact. Metadata will be updated if one exists, otherwise it would be created.
  66  *
  67  * @plexus.component role="com.opensymphony.xwork2.Action" role-hint="deleteArtifactAction" instantiation-strategy="per-lookup"
  68  */
  69 public class DeleteArtifactAction
  70     extends PlexusActionSupport
  71     implements Validateable, Preparable, Auditable
  72 {
  73     /**
  74      * The groupId of the artifact to be deleted.
  75      */
  76     private String groupId;
  77
  78     /**
  79      * The artifactId of the artifact to be deleted.
  80      */
  81     private String artifactId;
  82
  83     /**
  84      * The version of the artifact to be deleted.
  85      */
  86     private String version;
  87
  88     /**
  89      * The repository where the artifact is to be deleted.
  90      */
  91     private String repositoryId;
  92
  93     /**
  94      * List of managed repositories to delete from.
  95      */
  96     private List<String> managedRepos;
  97
  98     /**
  99      * @plexus.requirement
 100      */
 101     private UserRepositories userRepositories;
 102
 103     /**
 104      * @plexus.requirement role-hint="default"
 105      */
 106     private ArchivaConfiguration configuration;
 107
 108     /**
 109      * @plexus.requirement
 110      */
 111     private RepositoryContentFactory repositoryFactory;
 112
 113     /**
 114      * @plexus.requirement role="org.apache.archiva.repository.events.RepositoryListener"
 115      */
 116     private List<RepositoryListener> listeners;
 117
 118     private ChecksumAlgorithm[] algorithms = new ChecksumAlgorithm[]{ChecksumAlgorithm.SHA1, ChecksumAlgorithm.MD5};
 119
 120     /**
 121      * @plexus.requirement
 122      */
 123     private MetadataRepository metadataRepository;
 124
 125     public String getGroupId()
 126     {
 127         return groupId;
 128     }
 129
 130     public void setGroupId( String groupId )
 131     {
 132         this.groupId = groupId;
 133     }
 134
 135     public String getArtifactId()
 136     {
 137         return artifactId;
 138     }
 139
 140     public void setArtifactId( String artifactId )
 141     {
 142         this.artifactId = artifactId;
 143     }
 144
 145     public String getVersion()
 146     {
 147         return version;
 148     }
 149
 150     public void setVersion( String version )
 151     {
 152         this.version = version;
 153     }
 154
 155     public String getRepositoryId()
 156     {
 157         return repositoryId;
 158     }
 159
 160     public void setRepositoryId( String repositoryId )
 161     {
 162         this.repositoryId = repositoryId;
 163     }
 164
 165     public List<String> getManagedRepos()
 166     {
 167         return managedRepos;
 168     }
 169
 170     public void setManagedRepos( List<String> managedRepos )
 171     {
 172         this.managedRepos = managedRepos;
 173     }
 174
 175     public void prepare()
 176     {
 177         managedRepos = getManagableRepos();
 178     }
 179
 180     public String input()
 181     {
 182         return INPUT;
 183     }
 184
 185     private void reset()
 186     {
 187         // reset the fields so the form is clear when
 188         // the action returns to the jsp page
 189         groupId = "";
 190         artifactId = "";
 191         version = "";
 192         repositoryId = "";
 193     }
 194
 195     public String doDelete()
 196     {
 197         try
 198         {
 199             Date lastUpdatedTimestamp = Calendar.getInstance().getTime();
 200
 201             TimeZone timezone = TimeZone.getTimeZone( "UTC" );
 202             DateFormat fmt = new SimpleDateFormat( "yyyyMMdd.HHmmss" );
 203             fmt.setTimeZone( timezone );
 204             ManagedRepositoryConfiguration repoConfig = configuration.getConfiguration().findManagedRepositoryById(
 205                 repositoryId );
 206
 207             VersionedReference ref = new VersionedReference();
 208             ref.setArtifactId( artifactId );
 209             ref.setGroupId( groupId );
 210             ref.setVersion( version );
 211
 212             ManagedRepositoryContent repository = repositoryFactory.getManagedRepositoryContent( repositoryId );
 213
 214             String path = repository.toMetadataPath( ref );
 215             int index = path.lastIndexOf( '/' );
 216             path = path.substring( 0, index );
 217             File targetPath = new File( repoConfig.getLocation(), path );
 218
 219             if ( !targetPath.exists() )
 220             {
 221                 throw new ContentNotFoundException( groupId + ":" + artifactId + ":" + version );
 222             }
 223
 224             // TODO: this should be in the storage mechanism so that it is all tied together
 225             // delete from file system
 226             repository.deleteVersion( ref );
 227
 228             File metadataFile = getMetadata( targetPath.getAbsolutePath() );
 229             ArchivaRepositoryMetadata metadata = getMetadata( metadataFile );
 230
 231             updateMetadata( metadata, metadataFile, lastUpdatedTimestamp );
 232
 233             Collection<ArtifactMetadata> artifacts = metadataRepository.getArtifacts( repositoryId, groupId, artifactId,
 234                                                                                       version );
 235
 236             for ( ArtifactMetadata artifact : artifacts )
 237             {
 238                 // TODO: mismatch between artifact (snapshot) version and project (base) version here
 239                 if ( artifact.getVersion().equals( version ) )
 240                 {
 241                     metadataRepository.removeArtifact( artifact.getRepositoryId(), artifact.getNamespace(),
 242                                                        artifact.getProject(), artifact.getVersion(), artifact.getId() );
 243
 244                     // TODO: move into the metadata repository proper - need to differentiate attachment of
 245                     //       repository metadata to an artifact
 246                     for ( RepositoryListener listener : listeners )
 247                     {
 248                         listener.deleteArtifact( repository.getId(), artifact.getNamespace(), artifact.getProject(),
 249                                                  artifact.getVersion(), artifact.getId() );
 250                     }
 251
 252                     triggerAuditEvent( repositoryId, path, AuditEvent.REMOVE_FILE );
 253                 }
 254             }
 255
 256             String msg = "Artifact \'" + groupId + ":" + artifactId + ":" + version +
 257                 "\' was successfully deleted from repository \'" + repositoryId + "\'";
 258
 259             addActionMessage( msg );
 260
 261             reset();
 262             return SUCCESS;
 263         }
 264         catch ( ContentNotFoundException e )
 265         {
 266             addActionError( "Artifact does not exist: " + e.getMessage() );
 267             return ERROR;
 268         }
 269         catch ( RepositoryNotFoundException e )
 270         {
 271             addActionError( "Target repository cannot be found: " + e.getMessage() );
 272             return ERROR;
 273         }
 274         catch ( RepositoryException e )
 275         {
 276             addActionError( "Repository exception: " + e.getMessage() );
 277             return ERROR;
 278         }
 279         catch ( MetadataResolutionException e )
 280         {
 281             addActionError( "Repository exception: " + e.getMessage() );
 282             return ERROR;
 283         }
 284         catch ( MetadataRepositoryException e )
 285         {
 286             addActionError( "Repository exception: " + e.getMessage() );
 287             return ERROR;
 288         }
 289     }
 290
 291     private File getMetadata( String targetPath )
 292     {
 293         String artifactPath = targetPath.substring( 0, targetPath.lastIndexOf( File.separatorChar ) );
 294
 295         return new File( artifactPath, MetadataTools.MAVEN_METADATA );
 296     }
 297
 298     private ArchivaRepositoryMetadata getMetadata( File metadataFile )
 299         throws RepositoryMetadataException
 300     {
 301         ArchivaRepositoryMetadata metadata = new ArchivaRepositoryMetadata();
 302         if ( metadataFile.exists() )
 303         {
 304             metadata = RepositoryMetadataReader.read( metadataFile );
 305         }
 306         return metadata;
 307     }
 308
 309     /**
 310      * Update artifact level metadata. Creates one if metadata does not exist after artifact deletion.
 311      *
 312      * @param metadata
 313      */
 314     private void updateMetadata( ArchivaRepositoryMetadata metadata, File metadataFile, Date lastUpdatedTimestamp )
 315         throws RepositoryMetadataException
 316     {
 317         List<String> availableVersions = new ArrayList<String>();
 318         String latestVersion = "";
 319
 320         if ( metadataFile.exists() )
 321         {
 322             if ( metadata.getAvailableVersions() != null )
 323             {
 324                 availableVersions = metadata.getAvailableVersions();
 325
 326                 if ( availableVersions.size() > 0 )
 327                 {
 328                     Collections.sort( availableVersions, VersionComparator.getInstance() );
 329
 330                     if ( availableVersions.contains( version ) )
 331                     {
 332                         availableVersions.remove( availableVersions.indexOf( version ) );
 333                     }
 334                     if ( availableVersions.size() > 0 )
 335                     {
 336                         latestVersion = availableVersions.get( availableVersions.size() - 1 );
 337                     }
 338                 }
 339             }
 340         }
 341
 342         if ( metadata.getGroupId() == null )
 343         {
 344             metadata.setGroupId( groupId );
 345         }
 346         if ( metadata.getArtifactId() == null )
 347         {
 348             metadata.setArtifactId( artifactId );
 349         }
 350
 351         if ( !VersionUtil.isSnapshot( version ) )
 352         {
 353             if ( metadata.getReleasedVersion() != null && metadata.getReleasedVersion().equals( version ) )
 354             {
 355                 metadata.setReleasedVersion( latestVersion );
 356             }
 357         }
 358
 359         metadata.setLatestVersion( latestVersion );
 360         metadata.setLastUpdatedTimestamp( lastUpdatedTimestamp );
 361         metadata.setAvailableVersions( availableVersions );
 362
 363         RepositoryMetadataWriter.write( metadata, metadataFile );
 364         ChecksummedFile checksum = new ChecksummedFile( metadataFile );
 365         checksum.fixChecksums( algorithms );
 366     }
 367
 368     public void validate()
 369     {
 370         try
 371         {
 372             if ( !userRepositories.isAuthorizedToDeleteArtifacts( getPrincipal(), repositoryId ) )
 373             {
 374                 addActionError( "User is not authorized to delete artifacts in repository '" + repositoryId + "'." );
 375             }
 376
 377             if ( ( version.length() > 0 ) && ( !VersionUtil.isVersion( version ) ) )
 378             {
 379                 addActionError( "Invalid version." );
 380             }
 381         }
 382         catch ( AccessDeniedException e )
 383         {
 384             addActionError( e.getMessage() );
 385         }
 386         catch ( ArchivaSecurityException e )
 387         {
 388             addActionError( e.getMessage() );
 389         }
 390     }
 391
 392     private List<String> getManagableRepos()
 393     {
 394         try
 395         {
 396             return userRepositories.getManagableRepositoryIds( getPrincipal() );
 397         }
 398         catch ( PrincipalNotFoundException e )
 399         {
 400             log.warn( e.getMessage(), e );
 401         }
 402         catch ( AccessDeniedException e )
 403         {
 404             log.warn( e.getMessage(), e );
 405             // TODO: pass this onto the screen.
 406         }
 407         catch ( ArchivaSecurityException e )
 408         {
 409             log.warn( e.getMessage(), e );
 410         }
 411         return Collections.emptyList();
 412     }
 413
 414     public List<RepositoryListener> getListeners()
 415     {
 416         return listeners;
 417     }
 418
 419     public void setRepositoryFactory( RepositoryContentFactory repositoryFactory )
 420     {
 421         this.repositoryFactory = repositoryFactory;
 422     }
 423
 424     public void setConfiguration( ArchivaConfiguration configuration )
 425     {
 426         this.configuration = configuration;
 427     }
 428
 429     public void setMetadataRepository( MetadataRepository metadataRepository )
 430     {
 431         this.metadataRepository = metadataRepository;
 432     }
 433 }