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