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

   1 package org.apache.archiva.rest.services;
   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.admin.ArchivaAdministration;
  24 import org.apache.archiva.admin.model.beans.ManagedRepository;
  25 import org.apache.archiva.admin.model.managed.ManagedRepositoryAdmin;
  26 import org.apache.archiva.audit.AuditEvent;
  27 import org.apache.archiva.checksum.ChecksumAlgorithm;
  28 import org.apache.archiva.checksum.ChecksummedFile;
  29 import org.apache.archiva.common.plexusbridge.MavenIndexerUtils;
  30 import org.apache.archiva.common.plexusbridge.PlexusSisuBridge;
  31 import org.apache.archiva.common.utils.VersionComparator;
  32 import org.apache.archiva.common.utils.VersionUtil;
  33 import org.apache.archiva.maven2.metadata.MavenMetadataReader;
  34 import org.apache.archiva.metadata.model.ArtifactMetadata;
  35 import org.apache.archiva.metadata.repository.MetadataRepository;
  36 import org.apache.archiva.metadata.repository.MetadataRepositoryException;
  37 import org.apache.archiva.metadata.repository.MetadataResolutionException;
  38 import org.apache.archiva.metadata.repository.RepositorySession;
  39 import org.apache.archiva.metadata.repository.RepositorySessionFactory;
  40 import org.apache.archiva.model.ArchivaRepositoryMetadata;
  41 import org.apache.archiva.model.ArtifactReference;
  42 import org.apache.archiva.model.VersionedReference;
  43 import org.apache.archiva.redback.users.User;
  44 import org.apache.archiva.redback.users.UserNotFoundException;
  45 import org.apache.archiva.repository.ContentNotFoundException;
  46 import org.apache.archiva.repository.ManagedRepositoryContent;
  47 import org.apache.archiva.repository.RepositoryContentFactory;
  48 import org.apache.archiva.repository.RepositoryException;
  49 import org.apache.archiva.repository.RepositoryNotFoundException;
  50 import org.apache.archiva.repository.events.RepositoryListener;
  51 import org.apache.archiva.repository.metadata.MetadataTools;
  52 import org.apache.archiva.repository.metadata.RepositoryMetadataException;
  53 import org.apache.archiva.repository.metadata.RepositoryMetadataWriter;
  54 import org.apache.archiva.repository.scanner.RepositoryScanStatistics;
  55 import org.apache.archiva.repository.scanner.RepositoryScanner;
  56 import org.apache.archiva.repository.scanner.RepositoryScannerException;
  57 import org.apache.archiva.rest.api.model.Artifact;
  58 import org.apache.archiva.rest.api.model.ArtifactTransferRequest;
  59 import org.apache.archiva.rest.api.services.ArchivaRestServiceException;
  60 import org.apache.archiva.rest.api.services.RepositoriesService;
  61 import org.apache.archiva.scheduler.ArchivaTaskScheduler;
  62 import org.apache.archiva.scheduler.indexing.ArchivaIndexingTaskExecutor;
  63 import org.apache.archiva.scheduler.indexing.ArtifactIndexingTask;
  64 import org.apache.archiva.scheduler.indexing.DownloadRemoteIndexException;
  65 import org.apache.archiva.scheduler.indexing.DownloadRemoteIndexScheduler;
  66 import org.apache.archiva.scheduler.repository.RepositoryArchivaTaskScheduler;
  67 import org.apache.archiva.scheduler.repository.RepositoryTask;
  68 import org.apache.archiva.security.ArchivaSecurityException;
  69 import org.apache.archiva.security.common.ArchivaRoleConstants;
  70 import org.apache.archiva.xml.XMLException;
  71 import org.apache.commons.io.FilenameUtils;
  72 import org.apache.commons.io.IOUtils;
  73 import org.apache.commons.lang.StringUtils;
  74 import org.apache.maven.index.context.IndexingContext;
  75 import org.apache.archiva.redback.authentication.AuthenticationResult;
  76 import org.apache.archiva.redback.authorization.AuthorizationException;
  77 import org.codehaus.plexus.redback.system.DefaultSecuritySession;
  78 import org.codehaus.plexus.redback.system.SecuritySession;
  79 import org.codehaus.plexus.redback.system.SecuritySystem;
  80 import org.codehaus.plexus.taskqueue.TaskQueueException;
  81 import org.slf4j.Logger;
  82 import org.slf4j.LoggerFactory;
  83 import org.springframework.stereotype.Service;
  84
  85 import javax.inject.Inject;
  86 import javax.inject.Named;
  87 import javax.ws.rs.core.Response;
  88 import java.io.File;
  89 import java.io.FileInputStream;
  90 import java.io.FileOutputStream;
  91 import java.io.IOException;
  92 import java.text.DateFormat;
  93 import java.text.SimpleDateFormat;
  94 import java.util.ArrayList;
  95 import java.util.Calendar;
  96 import java.util.Collection;
  97 import java.util.Collections;
  98 import java.util.Date;
  99 import java.util.List;
 100 import java.util.TimeZone;
 101
 102 /**
 103  * @author Olivier Lamy
 104  * @since 1.4-M1
 105  */
 106 @Service( "repositoriesService#rest" )
 107 public class DefaultRepositoriesService
 108     extends AbstractRestService
 109     implements RepositoriesService
 110 {
 111     private Logger log = LoggerFactory.getLogger( getClass() );
 112
 113     @Inject
 114     @Named( value = "archivaTaskScheduler#repository" )
 115     private RepositoryArchivaTaskScheduler repositoryTaskScheduler;
 116
 117     @Inject
 118     @Named( value = "taskExecutor#indexing" )
 119     private ArchivaIndexingTaskExecutor archivaIndexingTaskExecutor;
 120
 121     @Inject
 122     private ManagedRepositoryAdmin managedRepositoryAdmin;
 123
 124     @Inject
 125     private PlexusSisuBridge plexusSisuBridge;
 126
 127     @Inject
 128     private MavenIndexerUtils mavenIndexerUtils;
 129
 130     @Inject
 131     private SecuritySystem securitySystem;
 132
 133     @Inject
 134     private RepositoryContentFactory repositoryFactory;
 135
 136     @Inject
 137     private ArchivaAdministration archivaAdministration;
 138
 139     @Inject
 140     @Named( value = "archivaTaskScheduler#repository" )
 141     private ArchivaTaskScheduler scheduler;
 142
 143     @Inject
 144     private DownloadRemoteIndexScheduler downloadRemoteIndexScheduler;
 145
 146     @Inject
 147     @Named( value = "repositorySessionFactory" )
 148     protected RepositorySessionFactory repositorySessionFactory;
 149
 150     @Inject
 151     protected List<RepositoryListener> listeners = new ArrayList<RepositoryListener>();
 152
 153     @Inject
 154     private RepositoryScanner repoScanner;
 155
 156     private ChecksumAlgorithm[] algorithms = new ChecksumAlgorithm[]{ ChecksumAlgorithm.SHA1, ChecksumAlgorithm.MD5 };
 157
 158     public Boolean scanRepository( String repositoryId, boolean fullScan )
 159     {
 160         if ( repositoryTaskScheduler.isProcessingRepositoryTask( repositoryId ) )
 161         {
 162             log.info( "scanning of repository with id {} already scheduled", repositoryId );
 163             return Boolean.FALSE;
 164         }
 165         RepositoryTask task = new RepositoryTask();
 166         task.setRepositoryId( repositoryId );
 167         task.setScanAll( fullScan );
 168         try
 169         {
 170             repositoryTaskScheduler.queueTask( task );
 171         }
 172         catch ( TaskQueueException e )
 173         {
 174             log.error( "failed to schedule scanning of repo with id {}", repositoryId, e );
 175             return false;
 176         }
 177         return true;
 178     }
 179
 180     public Boolean alreadyScanning( String repositoryId )
 181     {
 182         return repositoryTaskScheduler.isProcessingRepositoryTask( repositoryId );
 183     }
 184
 185     public Boolean removeScanningTaskFromQueue( String repositoryId )
 186     {
 187         RepositoryTask task = new RepositoryTask();
 188         task.setRepositoryId( repositoryId );
 189         try
 190         {
 191             return repositoryTaskScheduler.unQueueTask( task );
 192         }
 193         catch ( TaskQueueException e )
 194         {
 195             log.error( "failed to unschedule scanning of repo with id {}", repositoryId, e );
 196             return false;
 197         }
 198     }
 199
 200     public Boolean scanRepositoryNow( String repositoryId, boolean fullScan )
 201         throws ArchivaRestServiceException
 202     {
 203
 204         try
 205         {
 206             ManagedRepository repository = managedRepositoryAdmin.getManagedRepository( repositoryId );
 207
 208             IndexingContext context = managedRepositoryAdmin.createIndexContext( repository );
 209
 210             ArtifactIndexingTask task =
 211                 new ArtifactIndexingTask( repository, null, ArtifactIndexingTask.Action.FINISH, context );
 212
 213             task.setExecuteOnEntireRepo( true );
 214             task.setOnlyUpdate( !fullScan );
 215
 216             archivaIndexingTaskExecutor.executeTask( task );
 217             return Boolean.TRUE;
 218         }
 219         catch ( Exception e )
 220         {
 221             log.error( e.getMessage(), e );
 222             throw new ArchivaRestServiceException( e.getMessage() );
 223         }
 224     }
 225
 226     public Boolean scheduleDownloadRemoteIndex( String repositoryId, boolean now, boolean fullDownload )
 227         throws ArchivaRestServiceException
 228     {
 229         try
 230         {
 231             downloadRemoteIndexScheduler.scheduleDownloadRemote( repositoryId, now, fullDownload );
 232         }
 233         catch ( DownloadRemoteIndexException e )
 234         {
 235             log.error( e.getMessage(), e );
 236             throw new ArchivaRestServiceException( e.getMessage() );
 237         }
 238         return Boolean.TRUE;
 239     }
 240
 241     public Boolean copyArtifact( ArtifactTransferRequest artifactTransferRequest )
 242         throws ArchivaRestServiceException
 243     {
 244         // check parameters
 245         String userName = getAuditInformation().getUser().getUsername();
 246         if ( StringUtils.isBlank( userName ) )
 247         {
 248             throw new ArchivaRestServiceException( "copyArtifact call: userName not found" );
 249         }
 250
 251         if ( StringUtils.isBlank( artifactTransferRequest.getRepositoryId() ) )
 252         {
 253             throw new ArchivaRestServiceException( "copyArtifact call: sourceRepositoryId cannot be null" );
 254         }
 255
 256         if ( StringUtils.isBlank( artifactTransferRequest.getTargetRepositoryId() ) )
 257         {
 258             throw new ArchivaRestServiceException( "copyArtifact call: targetRepositoryId cannot be null" );
 259         }
 260
 261         ManagedRepository source = null;
 262         try
 263         {
 264             source = managedRepositoryAdmin.getManagedRepository( artifactTransferRequest.getRepositoryId() );
 265         }
 266         catch ( RepositoryAdminException e )
 267         {
 268             throw new ArchivaRestServiceException( e.getMessage() );
 269         }
 270
 271         if ( source == null )
 272         {
 273             throw new ArchivaRestServiceException(
 274                 "cannot find repository with id " + artifactTransferRequest.getRepositoryId() );
 275         }
 276
 277         ManagedRepository target = null;
 278         try
 279         {
 280             target = managedRepositoryAdmin.getManagedRepository( artifactTransferRequest.getTargetRepositoryId() );
 281         }
 282         catch ( RepositoryAdminException e )
 283         {
 284             throw new ArchivaRestServiceException( e.getMessage() );
 285         }
 286
 287         if ( target == null )
 288         {
 289             throw new ArchivaRestServiceException(
 290                 "cannot find repository with id " + artifactTransferRequest.getTargetRepositoryId() );
 291         }
 292
 293         if ( StringUtils.isBlank( artifactTransferRequest.getGroupId() ) )
 294         {
 295             throw new ArchivaRestServiceException( "groupId is mandatory" );
 296         }
 297
 298         if ( StringUtils.isBlank( artifactTransferRequest.getArtifactId() ) )
 299         {
 300             throw new ArchivaRestServiceException( "artifactId is mandatory" );
 301         }
 302
 303         if ( StringUtils.isBlank( artifactTransferRequest.getVersion() ) )
 304         {
 305             throw new ArchivaRestServiceException( "version is mandatory" );
 306         }
 307
 308         if ( VersionUtil.isSnapshot( artifactTransferRequest.getVersion() ) )
 309         {
 310             throw new ArchivaRestServiceException( "copy of SNAPSHOT not supported" );
 311         }
 312
 313         // end check parameters
 314
 315         User user = null;
 316         try
 317         {
 318             user = securitySystem.getUserManager().findUser( userName );
 319         }
 320         catch ( UserNotFoundException e )
 321         {
 322             throw new ArchivaRestServiceException( "user " + userName + " not found" );
 323         }
 324
 325         // check karma on source : read
 326         AuthenticationResult authn = new AuthenticationResult( true, userName, null );
 327         SecuritySession securitySession = new DefaultSecuritySession( authn, user );
 328         try
 329         {
 330             boolean authz =
 331                 securitySystem.isAuthorized( securitySession, ArchivaRoleConstants.OPERATION_REPOSITORY_ACCESS,
 332                                              artifactTransferRequest.getRepositoryId() );
 333             if ( !authz )
 334             {
 335                 throw new ArchivaRestServiceException(
 336                     "not authorized to access repo:" + artifactTransferRequest.getRepositoryId() );
 337             }
 338         }
 339         catch ( AuthorizationException e )
 340         {
 341             log.error( "error reading permission: " + e.getMessage(), e );
 342             throw new ArchivaRestServiceException( e.getMessage() );
 343         }
 344
 345         // check karma on target: write
 346         try
 347         {
 348             boolean authz =
 349                 securitySystem.isAuthorized( securitySession, ArchivaRoleConstants.OPERATION_REPOSITORY_UPLOAD,
 350                                              artifactTransferRequest.getTargetRepositoryId() );
 351             if ( !authz )
 352             {
 353                 throw new ArchivaRestServiceException(
 354                     "not authorized to write to repo:" + artifactTransferRequest.getTargetRepositoryId() );
 355             }
 356         }
 357         catch ( AuthorizationException e )
 358         {
 359             log.error( "error reading permission: " + e.getMessage(), e );
 360             throw new ArchivaRestServiceException( e.getMessage() );
 361         }
 362
 363         // sounds good we can continue !
 364
 365         ArtifactReference artifactReference = new ArtifactReference();
 366         artifactReference.setArtifactId( artifactTransferRequest.getArtifactId() );
 367         artifactReference.setGroupId( artifactTransferRequest.getGroupId() );
 368         artifactReference.setVersion( artifactTransferRequest.getVersion() );
 369         artifactReference.setClassifier( artifactTransferRequest.getClassifier() );
 370         String packaging = StringUtils.trim( artifactTransferRequest.getPackaging() );
 371         artifactReference.setType( StringUtils.isEmpty( packaging ) ? "jar" : packaging );
 372
 373         try
 374         {
 375
 376             ManagedRepositoryContent sourceRepository =
 377                 repositoryFactory.getManagedRepositoryContent( artifactTransferRequest.getRepositoryId() );
 378
 379             String artifactSourcePath = sourceRepository.toPath( artifactReference );
 380
 381             if ( StringUtils.isEmpty( artifactSourcePath ) )
 382             {
 383                 log.error( "cannot find artifact " + artifactTransferRequest.toString() );
 384                 throw new ArchivaRestServiceException( "cannot find artifact " + artifactTransferRequest.toString() );
 385             }
 386
 387             File artifactFile = new File( source.getLocation(), artifactSourcePath );
 388
 389             if ( !artifactFile.exists() )
 390             {
 391                 log.error( "cannot find artifact " + artifactTransferRequest.toString() );
 392                 throw new ArchivaRestServiceException( "cannot find artifact " + artifactTransferRequest.toString() );
 393             }
 394
 395             ManagedRepositoryContent targetRepository =
 396                 repositoryFactory.getManagedRepositoryContent( artifactTransferRequest.getTargetRepositoryId() );
 397
 398             String artifactPath = targetRepository.toPath( artifactReference );
 399
 400             int lastIndex = artifactPath.lastIndexOf( '/' );
 401
 402             String path = artifactPath.substring( 0, lastIndex );
 403             File targetPath = new File( target.getLocation(), path );
 404
 405             Date lastUpdatedTimestamp = Calendar.getInstance().getTime();
 406             int newBuildNumber = 1;
 407             String timestamp = null;
 408
 409             File versionMetadataFile = new File( targetPath, MetadataTools.MAVEN_METADATA );
 410             ArchivaRepositoryMetadata versionMetadata = getMetadata( versionMetadataFile );
 411
 412             if ( !targetPath.exists() )
 413             {
 414                 targetPath.mkdirs();
 415             }
 416
 417             String filename = artifactPath.substring( lastIndex + 1 );
 418
 419             // FIXME some dupe with uploadaction
 420
 421             boolean fixChecksums =
 422                 !( archivaAdministration.getKnownContentConsumers().contains( "create-missing-checksums" ) );
 423
 424             File targetFile = new File( targetPath, filename );
 425             if ( targetFile.exists() && target.isBlockRedeployments() )
 426             {
 427                 throw new ArchivaRestServiceException(
 428                     "artifact already exists in target repo: " + artifactTransferRequest.getTargetRepositoryId()
 429                         + " and redeployment blocked" );
 430             }
 431             else
 432             {
 433                 copyFile( artifactFile, targetPath, filename, fixChecksums );
 434                 queueRepositoryTask( target.getId(), targetFile );
 435             }
 436
 437             // copy source pom to target repo
 438             String pomFilename = filename;
 439             if ( StringUtils.isNotBlank( artifactTransferRequest.getClassifier() ) )
 440             {
 441                 pomFilename = StringUtils.remove( pomFilename, "-" + artifactTransferRequest.getClassifier() );
 442             }
 443             pomFilename = FilenameUtils.removeExtension( pomFilename ) + ".pom";
 444
 445             File pomFile = new File(
 446                 new File( source.getLocation(), artifactSourcePath.substring( 0, artifactPath.lastIndexOf( '/' ) ) ),
 447                 pomFilename );
 448
 449             if ( pomFile != null && pomFile.length() > 0 )
 450             {
 451                 copyFile( pomFile, targetPath, pomFilename, fixChecksums );
 452                 queueRepositoryTask( target.getId(), new File( targetPath, pomFilename ) );
 453
 454
 455             }
 456
 457             // explicitly update only if metadata-updater consumer is not enabled!
 458             if ( !archivaAdministration.getKnownContentConsumers().contains( "metadata-updater" ) )
 459             {
 460                 updateProjectMetadata( targetPath.getAbsolutePath(), lastUpdatedTimestamp, timestamp, newBuildNumber,
 461                                        fixChecksums, artifactTransferRequest );
 462
 463
 464             }
 465
 466             String msg =
 467                 "Artifact \'" + artifactTransferRequest.getGroupId() + ":" + artifactTransferRequest.getArtifactId()
 468                     + ":" + artifactTransferRequest.getVersion() + "\' was successfully deployed to repository \'"
 469                     + artifactTransferRequest.getTargetRepositoryId() + "\'";
 470
 471         }
 472         catch ( RepositoryException e )
 473         {
 474             log.error( "RepositoryException: " + e.getMessage(), e );
 475             throw new ArchivaRestServiceException( e.getMessage() );
 476         }
 477         catch ( RepositoryAdminException e )
 478         {
 479             log.error( "RepositoryAdminException: " + e.getMessage(), e );
 480             throw new ArchivaRestServiceException( e.getMessage() );
 481         }
 482         catch ( IOException e )
 483         {
 484             log.error( "IOException: " + e.getMessage(), e );
 485             throw new ArchivaRestServiceException( e.getMessage() );
 486         }
 487         return true;
 488     }
 489
 490     //FIXME some duplicate with UploadAction
 491
 492     private void queueRepositoryTask( String repositoryId, File localFile )
 493     {
 494         RepositoryTask task = new RepositoryTask();
 495         task.setRepositoryId( repositoryId );
 496         task.setResourceFile( localFile );
 497         task.setUpdateRelatedArtifacts( true );
 498         //task.setScanAll( true );
 499
 500         try
 501         {
 502             scheduler.queueTask( task );
 503         }
 504         catch ( TaskQueueException e )
 505         {
 506             log.error( "Unable to queue repository task to execute consumers on resource file ['" + localFile.getName()
 507                            + "']." );
 508         }
 509     }
 510
 511     private ArchivaRepositoryMetadata getMetadata( File metadataFile )
 512         throws RepositoryMetadataException
 513     {
 514         ArchivaRepositoryMetadata metadata = new ArchivaRepositoryMetadata();
 515         if ( metadataFile.exists() )
 516         {
 517             try
 518             {
 519                 metadata = MavenMetadataReader.read( metadataFile );
 520             }
 521             catch ( XMLException e )
 522             {
 523                 throw new RepositoryMetadataException( e.getMessage(), e );
 524             }
 525         }
 526         return metadata;
 527     }
 528
 529     private File getMetadata( String targetPath )
 530     {
 531         String artifactPath = targetPath.substring( 0, targetPath.lastIndexOf( File.separatorChar ) );
 532
 533         return new File( artifactPath, MetadataTools.MAVEN_METADATA );
 534     }
 535
 536     private void copyFile( File sourceFile, File targetPath, String targetFilename, boolean fixChecksums )
 537         throws IOException
 538     {
 539         FileOutputStream out = new FileOutputStream( new File( targetPath, targetFilename ) );
 540         FileInputStream input = new FileInputStream( sourceFile );
 541
 542         try
 543         {
 544             IOUtils.copy( input, out );
 545         }
 546         finally
 547         {
 548             out.close();
 549             input.close();
 550         }
 551
 552         if ( fixChecksums )
 553         {
 554             fixChecksums( new File( targetPath, targetFilename ) );
 555         }
 556     }
 557
 558     private void fixChecksums( File file )
 559     {
 560         ChecksummedFile checksum = new ChecksummedFile( file );
 561         checksum.fixChecksums( algorithms );
 562     }
 563
 564     private void updateProjectMetadata( String targetPath, Date lastUpdatedTimestamp, String timestamp, int buildNumber,
 565                                         boolean fixChecksums, ArtifactTransferRequest artifactTransferRequest )
 566         throws RepositoryMetadataException
 567     {
 568         List<String> availableVersions = new ArrayList<String>();
 569         String latestVersion = artifactTransferRequest.getVersion();
 570
 571         File projectDir = new File( targetPath ).getParentFile();
 572         File projectMetadataFile = new File( projectDir, MetadataTools.MAVEN_METADATA );
 573
 574         ArchivaRepositoryMetadata projectMetadata = getMetadata( projectMetadataFile );
 575
 576         if ( projectMetadataFile.exists() )
 577         {
 578             availableVersions = projectMetadata.getAvailableVersions();
 579
 580             Collections.sort( availableVersions, VersionComparator.getInstance() );
 581
 582             if ( !availableVersions.contains( artifactTransferRequest.getVersion() ) )
 583             {
 584                 availableVersions.add( artifactTransferRequest.getVersion() );
 585             }
 586
 587             latestVersion = availableVersions.get( availableVersions.size() - 1 );
 588         }
 589         else
 590         {
 591             availableVersions.add( artifactTransferRequest.getVersion() );
 592
 593             projectMetadata.setGroupId( artifactTransferRequest.getGroupId() );
 594             projectMetadata.setArtifactId( artifactTransferRequest.getArtifactId() );
 595         }
 596
 597         if ( projectMetadata.getGroupId() == null )
 598         {
 599             projectMetadata.setGroupId( artifactTransferRequest.getGroupId() );
 600         }
 601
 602         if ( projectMetadata.getArtifactId() == null )
 603         {
 604             projectMetadata.setArtifactId( artifactTransferRequest.getArtifactId() );
 605         }
 606
 607         projectMetadata.setLatestVersion( latestVersion );
 608         projectMetadata.setLastUpdatedTimestamp( lastUpdatedTimestamp );
 609         projectMetadata.setAvailableVersions( availableVersions );
 610
 611         if ( !VersionUtil.isSnapshot( artifactTransferRequest.getVersion() ) )
 612         {
 613             projectMetadata.setReleasedVersion( latestVersion );
 614         }
 615
 616         RepositoryMetadataWriter.write( projectMetadata, projectMetadataFile );
 617
 618         if ( fixChecksums )
 619         {
 620             fixChecksums( projectMetadataFile );
 621         }
 622     }
 623
 624     public Boolean deleteArtifact( Artifact artifact, String repositoryId )
 625         throws ArchivaRestServiceException
 626     {
 627
 628         if ( StringUtils.isEmpty( repositoryId ) )
 629         {
 630             throw new ArchivaRestServiceException( "repositoryId cannot be null", 400 );
 631         }
 632
 633         if ( !isAuthorizedToDeleteArtifacts( repositoryId ) )
 634         {
 635             throw new ArchivaRestServiceException( "not authorized to delete artifacts", 403 );
 636         }
 637
 638         if ( artifact == null )
 639         {
 640             throw new ArchivaRestServiceException( "artifact cannot be null", 400 );
 641         }
 642
 643         if ( StringUtils.isEmpty( artifact.getGroupId() ) )
 644         {
 645             throw new ArchivaRestServiceException( "artifact.groupId cannot be null", 400 );
 646         }
 647
 648         if ( StringUtils.isEmpty( artifact.getArtifactId() ) )
 649         {
 650             throw new ArchivaRestServiceException( "artifact.artifactId cannot be null", 400 );
 651         }
 652
 653         // TODO more control on artifact fields
 654
 655         RepositorySession repositorySession = repositorySessionFactory.createSession();
 656         try
 657         {
 658             Date lastUpdatedTimestamp = Calendar.getInstance().getTime();
 659
 660             TimeZone timezone = TimeZone.getTimeZone( "UTC" );
 661             DateFormat fmt = new SimpleDateFormat( "yyyyMMdd.HHmmss" );
 662             fmt.setTimeZone( timezone );
 663             ManagedRepository repoConfig = managedRepositoryAdmin.getManagedRepository( repositoryId );
 664
 665             VersionedReference ref = new VersionedReference();
 666             ref.setArtifactId( artifact.getArtifactId() );
 667             ref.setGroupId( artifact.getGroupId() );
 668             ref.setVersion( artifact.getVersion() );
 669
 670             ManagedRepositoryContent repository = repositoryFactory.getManagedRepositoryContent( repositoryId );
 671
 672             if ( StringUtils.isNotBlank( artifact.getClassifier() ) )
 673             {
 674                 if ( StringUtils.isBlank( artifact.getPackaging() ) )
 675                 {
 676                     throw new ArchivaRestServiceException( "You must configure a type/packaging when using classifier",
 677                                                            400 );
 678                 }
 679                 ArtifactReference artifactReference = new ArtifactReference();
 680                 artifactReference.setArtifactId( artifact.getArtifactId() );
 681                 artifactReference.setGroupId( artifact.getGroupId() );
 682                 artifactReference.setVersion( artifact.getVersion() );
 683                 artifactReference.setClassifier( artifact.getClassifier() );
 684                 artifactReference.setType( artifact.getPackaging() );
 685                 repository.deleteArtifact( artifactReference );
 686
 687                 // TODO cleanup facet which contains classifier information
 688                 return Boolean.TRUE;
 689             }
 690
 691             String path = repository.toMetadataPath( ref );
 692             int index = path.lastIndexOf( '/' );
 693             path = path.substring( 0, index );
 694             File targetPath = new File( repoConfig.getLocation(), path );
 695
 696             if ( !targetPath.exists() )
 697             {
 698                 throw new ContentNotFoundException(
 699                     artifact.getGroupId() + ":" + artifact.getArtifactId() + ":" + artifact.getVersion() );
 700             }
 701
 702             // TODO: this should be in the storage mechanism so that it is all tied together
 703             // delete from file system
 704             repository.deleteVersion( ref );
 705
 706             File metadataFile = getMetadata( targetPath.getAbsolutePath() );
 707             ArchivaRepositoryMetadata metadata = getMetadata( metadataFile );
 708
 709             updateMetadata( metadata, metadataFile, lastUpdatedTimestamp, artifact );
 710
 711             MetadataRepository metadataRepository = repositorySession.getRepository();
 712
 713             Collection<ArtifactMetadata> artifacts =
 714                 metadataRepository.getArtifacts( repositoryId, artifact.getGroupId(), artifact.getArtifactId(),
 715                                                  artifact.getVersion() );
 716
 717             for ( ArtifactMetadata artifactMetadata : artifacts )
 718             {
 719                 // TODO: mismatch between artifact (snapshot) version and project (base) version here
 720                 if ( artifact.getVersion().equals( artifact.getVersion() ) )
 721                 {
 722                     metadataRepository.removeArtifact( artifactMetadata.getRepositoryId(),
 723                                                        artifactMetadata.getNamespace(), artifactMetadata.getProject(),
 724                                                        artifact.getVersion(), artifactMetadata.getId() );
 725
 726                     // TODO: move into the metadata repository proper - need to differentiate attachment of
 727                     //       repository metadata to an artifact
 728                     for ( RepositoryListener listener : listeners )
 729                     {
 730                         listener.deleteArtifact( metadataRepository, repository.getId(),
 731                                                  artifactMetadata.getNamespace(), artifactMetadata.getProject(),
 732                                                  artifactMetadata.getVersion(), artifactMetadata.getId() );
 733                     }
 734
 735                     triggerAuditEvent( repositoryId, path, AuditEvent.REMOVE_FILE );
 736                 }
 737             }
 738             repositorySession.save();
 739         }
 740
 741         catch ( ContentNotFoundException e )
 742         {
 743             throw new ArchivaRestServiceException( "Artifact does not exist: " + e.getMessage(), 400 );
 744         }
 745         catch ( RepositoryNotFoundException e )
 746         {
 747             throw new ArchivaRestServiceException( "Target repository cannot be found: " + e.getMessage(), 400 );
 748         }
 749         catch ( RepositoryException e )
 750         {
 751             throw new ArchivaRestServiceException( "Repository exception: " + e.getMessage(), 500 );
 752         }
 753         catch ( MetadataResolutionException e )
 754         {
 755             throw new ArchivaRestServiceException( "Repository exception: " + e.getMessage(), 500 );
 756         }
 757         catch ( MetadataRepositoryException e )
 758         {
 759             throw new ArchivaRestServiceException( "Repository exception: " + e.getMessage(), 500 );
 760         }
 761         catch ( RepositoryAdminException e )
 762         {
 763             throw new ArchivaRestServiceException( "RepositoryAdmin exception: " + e.getMessage(), 500 );
 764         }
 765         finally
 766
 767         {
 768             repositorySession.close();
 769         }
 770         return Boolean.TRUE;
 771     }
 772
 773     public Boolean isAuthorizedToDeleteArtifacts( String repoId )
 774         throws ArchivaRestServiceException
 775     {
 776         String userName =
 777             getAuditInformation().getUser() == null ? "guest" : getAuditInformation().getUser().getUsername();
 778
 779         try
 780         {
 781             boolean res = userRepositories.isAuthorizedToDeleteArtifacts( userName, repoId );
 782             return res;
 783         }
 784         catch ( ArchivaSecurityException e )
 785         {
 786             throw new ArchivaRestServiceException( e.getMessage(),
 787                                                    Response.Status.INTERNAL_SERVER_ERROR.getStatusCode() );
 788         }
 789     }
 790
 791     public RepositoryScanStatistics scanRepositoryDirectoriesNow( String repositoryId )
 792         throws ArchivaRestServiceException
 793     {
 794         long sinceWhen = RepositoryScanner.FRESH_SCAN;
 795         try
 796         {
 797             return repoScanner.scan( getManagedRepositoryAdmin().getManagedRepository( repositoryId ), sinceWhen );
 798         }
 799         catch ( RepositoryScannerException e )
 800         {
 801             log.error( e.getMessage(), e );
 802             throw new ArchivaRestServiceException( "RepositoryScannerException exception: " + e.getMessage(), 500 );
 803         }
 804         catch ( RepositoryAdminException e )
 805         {
 806             log.error( e.getMessage(), e );
 807             throw new ArchivaRestServiceException( "RepositoryScannerException exception: " + e.getMessage(), 500 );
 808         }
 809     }
 810
 811     /**
 812      * Update artifact level metadata. Creates one if metadata does not exist after artifact deletion.
 813      *
 814      * @param metadata
 815      */
 816     private void updateMetadata( ArchivaRepositoryMetadata metadata, File metadataFile, Date lastUpdatedTimestamp,
 817                                  Artifact artifact )
 818         throws RepositoryMetadataException
 819     {
 820         List<String> availableVersions = new ArrayList<String>();
 821         String latestVersion = "";
 822
 823         if ( metadataFile.exists() )
 824         {
 825             if ( metadata.getAvailableVersions() != null )
 826             {
 827                 availableVersions = metadata.getAvailableVersions();
 828
 829                 if ( availableVersions.size() > 0 )
 830                 {
 831                     Collections.sort( availableVersions, VersionComparator.getInstance() );
 832
 833                     if ( availableVersions.contains( artifact.getVersion() ) )
 834                     {
 835                         availableVersions.remove( availableVersions.indexOf( artifact.getVersion() ) );
 836                     }
 837                     if ( availableVersions.size() > 0 )
 838                     {
 839                         latestVersion = availableVersions.get( availableVersions.size() - 1 );
 840                     }
 841                 }
 842             }
 843         }
 844
 845         if ( metadata.getGroupId() == null )
 846         {
 847             metadata.setGroupId( artifact.getGroupId() );
 848         }
 849         if ( metadata.getArtifactId() == null )
 850         {
 851             metadata.setArtifactId( artifact.getArtifactId() );
 852         }
 853
 854         if ( !VersionUtil.isSnapshot( artifact.getVersion() ) )
 855         {
 856             if ( metadata.getReleasedVersion() != null && metadata.getReleasedVersion().equals(
 857                 artifact.getVersion() ) )
 858             {
 859                 metadata.setReleasedVersion( latestVersion );
 860             }
 861         }
 862
 863         metadata.setLatestVersion( latestVersion );
 864         metadata.setLastUpdatedTimestamp( lastUpdatedTimestamp );
 865         metadata.setAvailableVersions( availableVersions );
 866
 867         RepositoryMetadataWriter.write( metadata, metadataFile );
 868         ChecksummedFile checksum = new ChecksummedFile( metadataFile );
 869         checksum.fixChecksums( algorithms );
 870     }
 871
 872     public ManagedRepositoryAdmin getManagedRepositoryAdmin()
 873     {
 874         return managedRepositoryAdmin;
 875     }
 876
 877     public void setManagedRepositoryAdmin( ManagedRepositoryAdmin managedRepositoryAdmin )
 878     {
 879         this.managedRepositoryAdmin = managedRepositoryAdmin;
 880     }
 881
 882     public RepositoryContentFactory getRepositoryFactory()
 883     {
 884         return repositoryFactory;
 885     }
 886
 887     public void setRepositoryFactory( RepositoryContentFactory repositoryFactory )
 888     {
 889         this.repositoryFactory = repositoryFactory;
 890     }
 891
 892     public RepositorySessionFactory getRepositorySessionFactory()
 893     {
 894         return repositorySessionFactory;
 895     }
 896
 897     public void setRepositorySessionFactory( RepositorySessionFactory repositorySessionFactory )
 898     {
 899         this.repositorySessionFactory = repositorySessionFactory;
 900     }
 901
 902     public List<RepositoryListener> getListeners()
 903     {
 904         return listeners;
 905     }
 906
 907     public void setListeners( List<RepositoryListener> listeners )
 908     {
 909         this.listeners = listeners;
 910     }
 911
 912     public ArchivaAdministration getArchivaAdministration()
 913     {
 914         return archivaAdministration;
 915     }
 916
 917     public void setArchivaAdministration( ArchivaAdministration archivaAdministration )
 918     {
 919         this.archivaAdministration = archivaAdministration;
 920     }
 921 }
 922
 923