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