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.metadata.repository.storage.maven2.MavenArtifactFacet;
  41 import org.apache.archiva.model.ArchivaRepositoryMetadata;
  42 import org.apache.archiva.model.ArtifactReference;
  43 import org.apache.archiva.model.VersionedReference;
  44 import org.apache.archiva.redback.authentication.AuthenticationResult;
  45 import org.apache.archiva.redback.authorization.AuthorizationException;
  46 import org.apache.archiva.redback.components.taskqueue.TaskQueueException;
  47 import org.apache.archiva.redback.system.DefaultSecuritySession;
  48 import org.apache.archiva.redback.system.SecuritySession;
  49 import org.apache.archiva.redback.system.SecuritySystem;
  50 import org.apache.archiva.redback.users.User;
  51 import org.apache.archiva.redback.users.UserNotFoundException;
  52 import org.apache.archiva.repository.ContentNotFoundException;
  53 import org.apache.archiva.repository.ManagedRepositoryContent;
  54 import org.apache.archiva.repository.RepositoryContentFactory;
  55 import org.apache.archiva.repository.RepositoryException;
  56 import org.apache.archiva.repository.RepositoryNotFoundException;
  57 import org.apache.archiva.repository.events.RepositoryListener;
  58 import org.apache.archiva.repository.metadata.MetadataTools;
  59 import org.apache.archiva.repository.metadata.RepositoryMetadataException;
  60 import org.apache.archiva.repository.metadata.RepositoryMetadataWriter;
  61 import org.apache.archiva.repository.scanner.RepositoryScanStatistics;
  62 import org.apache.archiva.repository.scanner.RepositoryScanner;
  63 import org.apache.archiva.repository.scanner.RepositoryScannerException;
  64 import org.apache.archiva.rest.api.model.Artifact;
  65 import org.apache.archiva.rest.api.model.ArtifactTransferRequest;
  66 import org.apache.archiva.rest.api.services.ArchivaRestServiceException;
  67 import org.apache.archiva.rest.api.services.RepositoriesService;
  68 import org.apache.archiva.scheduler.ArchivaTaskScheduler;
  69 import org.apache.archiva.scheduler.indexing.ArchivaIndexingTaskExecutor;
  70 import org.apache.archiva.scheduler.indexing.ArtifactIndexingTask;
  71 import org.apache.archiva.scheduler.indexing.DownloadRemoteIndexException;
  72 import org.apache.archiva.scheduler.indexing.DownloadRemoteIndexScheduler;
  73 import org.apache.archiva.scheduler.repository.RepositoryArchivaTaskScheduler;
  74 import org.apache.archiva.scheduler.repository.RepositoryTask;
  75 import org.apache.archiva.security.ArchivaSecurityException;
  76 import org.apache.archiva.security.common.ArchivaRoleConstants;
  77 import org.apache.archiva.xml.XMLException;
  78 import org.apache.commons.io.FilenameUtils;
  79 import org.apache.commons.io.IOUtils;
  80 import org.apache.commons.lang.StringUtils;
  81 import org.apache.maven.index.context.IndexingContext;
  82 import org.slf4j.Logger;
  83 import org.slf4j.LoggerFactory;
  84 import org.springframework.stereotype.Service;
  85
  86 import javax.inject.Inject;
  87 import javax.inject.Named;
  88 import javax.ws.rs.core.Response;
  89 import java.io.File;
  90 import java.io.FileInputStream;
  91 import java.io.FileOutputStream;
  92 import java.io.IOException;
  93 import java.text.DateFormat;
  94 import java.text.SimpleDateFormat;
  95 import java.util.ArrayList;
  96 import java.util.Calendar;
  97 import java.util.Collection;
  98 import java.util.Collections;
  99 import java.util.Date;
 100 import java.util.List;
 101 import java.util.TimeZone;
 102
 103 /**
 104  * @author Olivier Lamy
 105  * @since 1.4-M1
 106  */
 107 @Service( "repositoriesService#rest" )
 108 public class DefaultRepositoriesService
 109     extends AbstractRestService
 110     implements RepositoriesService
 111 {
 112     private Logger log = LoggerFactory.getLogger( getClass() );
 113
 114     @Inject
 115     @Named( value = "archivaTaskScheduler#repository" )
 116     private RepositoryArchivaTaskScheduler repositoryTaskScheduler;
 117
 118     @Inject
 119     @Named( value = "taskExecutor#indexing" )
 120     private ArchivaIndexingTaskExecutor archivaIndexingTaskExecutor;
 121
 122     @Inject
 123     private ManagedRepositoryAdmin managedRepositoryAdmin;
 124
 125     @Inject
 126     private PlexusSisuBridge plexusSisuBridge;
 127
 128     @Inject
 129     private MavenIndexerUtils mavenIndexerUtils;
 130
 131     @Inject
 132     private SecuritySystem securitySystem;
 133
 134     @Inject
 135     private RepositoryContentFactory repositoryFactory;
 136
 137     @Inject
 138     @Named( value = "archivaTaskScheduler#repository" )
 139     private ArchivaTaskScheduler scheduler;
 140
 141     @Inject
 142     private DownloadRemoteIndexScheduler downloadRemoteIndexScheduler;
 143
 144     @Inject
 145     @Named( value = "repositorySessionFactory" )
 146     protected RepositorySessionFactory repositorySessionFactory;
 147
 148     @Inject
 149     protected List<RepositoryListener> listeners = new ArrayList<RepositoryListener>();
 150
 151     @Inject
 152     private RepositoryScanner repoScanner;
 153
 154     private ChecksumAlgorithm[] algorithms = new ChecksumAlgorithm[]{ ChecksumAlgorithm.SHA1, ChecksumAlgorithm.MD5 };
 155
 156     public Boolean scanRepository( String repositoryId, boolean fullScan )
 157     {
 158         if ( repositoryTaskScheduler.isProcessingRepositoryTask( repositoryId ) )
 159         {
 160             log.info( "scanning of repository with id {} already scheduled", repositoryId );
 161             return Boolean.FALSE;
 162         }
 163         RepositoryTask task = new RepositoryTask();
 164         task.setRepositoryId( repositoryId );
 165         task.setScanAll( fullScan );
 166         try
 167         {
 168             repositoryTaskScheduler.queueTask( task );
 169         }
 170         catch ( TaskQueueException e )
 171         {
 172             log.error( "failed to schedule scanning of repo with id {}", repositoryId, e );
 173             return false;
 174         }
 175         return true;
 176     }
 177
 178     public Boolean alreadyScanning( String repositoryId )
 179     {
 180         return repositoryTaskScheduler.isProcessingRepositoryTask( repositoryId );
 181     }
 182
 183     public Boolean removeScanningTaskFromQueue( String repositoryId )
 184     {
 185         RepositoryTask task = new RepositoryTask();
 186         task.setRepositoryId( repositoryId );
 187         try
 188         {
 189             return repositoryTaskScheduler.unQueueTask( task );
 190         }
 191         catch ( TaskQueueException e )
 192         {
 193             log.error( "failed to unschedule scanning of repo with id {}", repositoryId, e );
 194             return false;
 195         }
 196     }
 197
 198     public Boolean scanRepositoryNow( String repositoryId, boolean fullScan )
 199         throws ArchivaRestServiceException
 200     {
 201
 202         try
 203         {
 204             ManagedRepository repository = managedRepositoryAdmin.getManagedRepository( repositoryId );
 205
 206             IndexingContext context = managedRepositoryAdmin.createIndexContext( repository );
 207
 208             ArtifactIndexingTask task =
 209                 new ArtifactIndexingTask( repository, null, ArtifactIndexingTask.Action.FINISH, context );
 210
 211             task.setExecuteOnEntireRepo( true );
 212             task.setOnlyUpdate( !fullScan );
 213
 214             archivaIndexingTaskExecutor.executeTask( task );
 215             return Boolean.TRUE;
 216         }
 217         catch ( Exception e )
 218         {
 219             log.error( e.getMessage(), e );
 220             throw new ArchivaRestServiceException( e.getMessage(), e );
 221         }
 222     }
 223
 224     public Boolean scheduleDownloadRemoteIndex( String repositoryId, boolean now, boolean fullDownload )
 225         throws ArchivaRestServiceException
 226     {
 227         try
 228         {
 229             downloadRemoteIndexScheduler.scheduleDownloadRemote( repositoryId, now, fullDownload );
 230         }
 231         catch ( DownloadRemoteIndexException e )
 232         {
 233             log.error( e.getMessage(), e );
 234             throw new ArchivaRestServiceException( e.getMessage(), e );
 235         }
 236         return Boolean.TRUE;
 237     }
 238
 239     public Boolean copyArtifact( ArtifactTransferRequest artifactTransferRequest )
 240         throws ArchivaRestServiceException
 241     {
 242         // check parameters
 243         String userName = getAuditInformation().getUser().getUsername();
 244         if ( StringUtils.isBlank( userName ) )
 245         {
 246             throw new ArchivaRestServiceException( "copyArtifact call: userName not found", null );
 247         }
 248
 249         if ( StringUtils.isBlank( artifactTransferRequest.getRepositoryId() ) )
 250         {
 251             throw new ArchivaRestServiceException( "copyArtifact call: sourceRepositoryId cannot be null", null );
 252         }
 253
 254         if ( StringUtils.isBlank( artifactTransferRequest.getTargetRepositoryId() ) )
 255         {
 256             throw new ArchivaRestServiceException( "copyArtifact call: targetRepositoryId cannot be null", null );
 257         }
 258
 259         ManagedRepository source = null;
 260         try
 261         {
 262             source = managedRepositoryAdmin.getManagedRepository( artifactTransferRequest.getRepositoryId() );
 263         }
 264         catch ( RepositoryAdminException e )
 265         {
 266             throw new ArchivaRestServiceException( e.getMessage(), e );
 267         }
 268
 269         if ( source == null )
 270         {
 271             throw new ArchivaRestServiceException(
 272                 "cannot find repository with id " + artifactTransferRequest.getRepositoryId(), null );
 273         }
 274
 275         ManagedRepository target = null;
 276         try
 277         {
 278             target = managedRepositoryAdmin.getManagedRepository( artifactTransferRequest.getTargetRepositoryId() );
 279         }
 280         catch ( RepositoryAdminException e )
 281         {
 282             throw new ArchivaRestServiceException( e.getMessage(), e );
 283         }
 284
 285         if ( target == null )
 286         {
 287             throw new ArchivaRestServiceException(
 288                 "cannot find repository with id " + artifactTransferRequest.getTargetRepositoryId(), null );
 289         }
 290
 291         if ( StringUtils.isBlank( artifactTransferRequest.getGroupId() ) )
 292         {
 293             throw new ArchivaRestServiceException( "groupId is mandatory", null );
 294         }
 295
 296         if ( StringUtils.isBlank( artifactTransferRequest.getArtifactId() ) )
 297         {
 298             throw new ArchivaRestServiceException( "artifactId is mandatory", null );
 299         }
 300
 301         if ( StringUtils.isBlank( artifactTransferRequest.getVersion() ) )
 302         {
 303             throw new ArchivaRestServiceException( "version is mandatory", null );
 304         }
 305
 306         if ( VersionUtil.isSnapshot( artifactTransferRequest.getVersion() ) )
 307         {
 308             throw new ArchivaRestServiceException( "copy of SNAPSHOT not supported", null );
 309         }
 310
 311         // end check parameters
 312
 313         User user = null;
 314         try
 315         {
 316             user = securitySystem.getUserManager().findUser( userName );
 317         }
 318         catch ( UserNotFoundException e )
 319         {
 320             throw new ArchivaRestServiceException( "user " + userName + " not found", null );
 321         }
 322
 323         // check karma on source : read
 324         AuthenticationResult authn = new AuthenticationResult( true, userName, null );
 325         SecuritySession securitySession = new DefaultSecuritySession( authn, user );
 326         try
 327         {
 328             boolean authz =
 329                 securitySystem.isAuthorized( securitySession, ArchivaRoleConstants.OPERATION_REPOSITORY_ACCESS,
 330                                              artifactTransferRequest.getRepositoryId() );
 331             if ( !authz )
 332             {
 333                 throw new ArchivaRestServiceException(
 334                     "not authorized to access repo:" + artifactTransferRequest.getRepositoryId(), null );
 335             }
 336         }
 337         catch ( AuthorizationException e )
 338         {
 339             log.error( "error reading permission: " + e.getMessage(), e );
 340             throw new ArchivaRestServiceException( e.getMessage(), e );
 341         }
 342
 343         // check karma on target: write
 344         try
 345         {
 346             boolean authz =
 347                 securitySystem.isAuthorized( securitySession, ArchivaRoleConstants.OPERATION_REPOSITORY_UPLOAD,
 348                                              artifactTransferRequest.getTargetRepositoryId() );
 349             if ( !authz )
 350             {
 351                 throw new ArchivaRestServiceException(
 352                     "not authorized to write to repo:" + artifactTransferRequest.getTargetRepositoryId(), null );
 353             }
 354         }
 355         catch ( AuthorizationException e )
 356         {
 357             log.error( "error reading permission: " + e.getMessage(), e );
 358             throw new ArchivaRestServiceException( e.getMessage(), e );
 359         }
 360
 361         // sounds good we can continue !
 362
 363         ArtifactReference artifactReference = new ArtifactReference();
 364         artifactReference.setArtifactId( artifactTransferRequest.getArtifactId() );
 365         artifactReference.setGroupId( artifactTransferRequest.getGroupId() );
 366         artifactReference.setVersion( artifactTransferRequest.getVersion() );
 367         artifactReference.setClassifier( artifactTransferRequest.getClassifier() );
 368         String packaging = StringUtils.trim( artifactTransferRequest.getPackaging() );
 369         artifactReference.setType( StringUtils.isEmpty( packaging ) ? "jar" : packaging );
 370
 371         try
 372         {
 373
 374             ManagedRepositoryContent sourceRepository =
 375                 repositoryFactory.getManagedRepositoryContent( artifactTransferRequest.getRepositoryId() );
 376
 377             String artifactSourcePath = sourceRepository.toPath( artifactReference );
 378
 379             if ( StringUtils.isEmpty( artifactSourcePath ) )
 380             {
 381                 log.error( "cannot find artifact " + artifactTransferRequest.toString() );
 382                 throw new ArchivaRestServiceException( "cannot find artifact " + artifactTransferRequest.toString(),
 383                                                        null );
 384             }
 385
 386             File artifactFile = new File( source.getLocation(), artifactSourcePath );
 387
 388             if ( !artifactFile.exists() )
 389             {
 390                 log.error( "cannot find artifact " + artifactTransferRequest.toString() );
 391                 throw new ArchivaRestServiceException( "cannot find artifact " + artifactTransferRequest.toString(),
 392                                                        null );
 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", null );
 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(), e );
 476         }
 477         catch ( RepositoryAdminException e )
 478         {
 479             log.error( "RepositoryAdminException: " + e.getMessage(), e );
 480             throw new ArchivaRestServiceException( e.getMessage(), e );
 481         }
 482         catch ( IOException e )
 483         {
 484             log.error( "IOException: " + e.getMessage(), e );
 485             throw new ArchivaRestServiceException( e.getMessage(), e );
 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             IOUtils.closeQuietly( out );
 549             IOUtils.closeQuietly( input );
 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 )
 625         throws ArchivaRestServiceException
 626     {
 627
 628         String repositoryId = artifact.getContext();
 629         if ( StringUtils.isEmpty( repositoryId ) )
 630         {
 631             throw new ArchivaRestServiceException( "repositoryId cannot be null", 400, null );
 632         }
 633
 634         if ( !isAuthorizedToDeleteArtifacts( repositoryId ) )
 635         {
 636             throw new ArchivaRestServiceException( "not authorized to delete artifacts", 403, null );
 637         }
 638
 639         if ( artifact == null )
 640         {
 641             throw new ArchivaRestServiceException( "artifact cannot be null", 400, null );
 642         }
 643
 644         if ( StringUtils.isEmpty( artifact.getGroupId() ) )
 645         {
 646             throw new ArchivaRestServiceException( "artifact.groupId cannot be null", 400, null );
 647         }
 648
 649         if ( StringUtils.isEmpty( artifact.getArtifactId() ) )
 650         {
 651             throw new ArchivaRestServiceException( "artifact.artifactId cannot be null", 400, null );
 652         }
 653
 654         // TODO more control on artifact fields
 655
 656         RepositorySession repositorySession = repositorySessionFactory.createSession();
 657         try
 658         {
 659             Date lastUpdatedTimestamp = Calendar.getInstance().getTime();
 660
 661             TimeZone timezone = TimeZone.getTimeZone( "UTC" );
 662             DateFormat fmt = new SimpleDateFormat( "yyyyMMdd.HHmmss" );
 663             fmt.setTimeZone( timezone );
 664             ManagedRepository repoConfig = managedRepositoryAdmin.getManagedRepository( repositoryId );
 665
 666             VersionedReference ref = new VersionedReference();
 667             ref.setArtifactId( artifact.getArtifactId() );
 668             ref.setGroupId( artifact.getGroupId() );
 669             ref.setVersion( artifact.getVersion() );
 670
 671             ManagedRepositoryContent repository = repositoryFactory.getManagedRepositoryContent( repositoryId );
 672
 673             MetadataRepository metadataRepository = repositorySession.getRepository();
 674
 675             String path = repository.toMetadataPath( ref );
 676
 677             if ( StringUtils.isNotBlank( artifact.getClassifier() ) )
 678             {
 679                 if ( StringUtils.isBlank( artifact.getPackaging() ) )
 680                 {
 681                     throw new ArchivaRestServiceException( "You must configure a type/packaging when using classifier",
 682                                                            400, null );
 683                 }
 684                 ArtifactReference artifactReference = new ArtifactReference();
 685                 artifactReference.setArtifactId( artifact.getArtifactId() );
 686                 artifactReference.setGroupId( artifact.getGroupId() );
 687                 artifactReference.setVersion( artifact.getVersion() );
 688                 artifactReference.setClassifier( artifact.getClassifier() );
 689                 artifactReference.setType( artifact.getPackaging() );
 690                 repository.deleteArtifact( artifactReference );
 691
 692             }
 693             else
 694             {
 695
 696                 int index = path.lastIndexOf( '/' );
 697                 path = path.substring( 0, index );
 698                 File targetPath = new File( repoConfig.getLocation(), path );
 699
 700                 if ( !targetPath.exists() )
 701                 {
 702                     throw new ContentNotFoundException(
 703                         artifact.getGroupId() + ":" + artifact.getArtifactId() + ":" + artifact.getVersion() );
 704                 }
 705
 706                 // TODO: this should be in the storage mechanism so that it is all tied together
 707                 // delete from file system
 708                 repository.deleteVersion( ref );
 709
 710                 File metadataFile = getMetadata( targetPath.getAbsolutePath() );
 711                 ArchivaRepositoryMetadata metadata = getMetadata( metadataFile );
 712
 713                 updateMetadata( metadata, metadataFile, lastUpdatedTimestamp, artifact );
 714             }
 715             Collection<ArtifactMetadata> artifacts =
 716                 metadataRepository.getArtifacts( repositoryId, artifact.getGroupId(), artifact.getArtifactId(),
 717                                                  artifact.getVersion() );
 718
 719             for ( ArtifactMetadata artifactMetadata : artifacts )
 720             {
 721
 722                 // TODO: mismatch between artifact (snapshot) version and project (base) version here
 723                 if ( artifactMetadata.getVersion().equals( artifact.getVersion() ) )
 724                 {
 725                     if ( StringUtils.isNotBlank( artifact.getClassifier() ) )
 726                     {
 727                         if ( StringUtils.isBlank( artifact.getPackaging() ) )
 728                         {
 729                             throw new ArchivaRestServiceException(
 730                                 "You must configure a type/packaging when using classifier", 400, null );
 731                         }
 732                         // cleanup facet which contains classifier information
 733                         MavenArtifactFacet mavenArtifactFacet =
 734                             (MavenArtifactFacet) artifactMetadata.getFacet( MavenArtifactFacet.FACET_ID );
 735
 736                         if ( StringUtils.equals( artifact.getClassifier(), mavenArtifactFacet.getClassifier() ) )
 737                         {
 738                             artifactMetadata.removeFacet( MavenArtifactFacet.FACET_ID );
 739                             String groupId = artifact.getGroupId(), artifactId = artifact.getArtifactId(), version =
 740                                 artifact.getVersion();
 741                             //metadataRepository.updateArtifact( repositoryId, groupId, artifactId, version,
 742                             //                                   artifactMetadata );
 743                             // String repositoryId, String namespace, String project, String version, String projectId, MetadataFacet metadataFacet
 744                             MavenArtifactFacet mavenArtifactFacetToCompare = new MavenArtifactFacet();
 745                             mavenArtifactFacetToCompare.setClassifier( artifact.getClassifier() );
 746                             metadataRepository.removeArtifact( repositoryId, groupId, artifactId, version,
 747                                                                mavenArtifactFacetToCompare );
 748                             metadataRepository.save();
 749                         }
 750
 751                     }
 752                     else
 753                     {
 754                         metadataRepository.removeArtifact( artifactMetadata.getRepositoryId(),
 755                                                            artifactMetadata.getNamespace(),
 756                                                            artifactMetadata.getProject(), artifact.getVersion(),
 757                                                            artifactMetadata.getId() );
 758                     }
 759                     // TODO: move into the metadata repository proper - need to differentiate attachment of
 760                     //       repository metadata to an artifact
 761                     for ( RepositoryListener listener : listeners )
 762                     {
 763                         listener.deleteArtifact( metadataRepository, repository.getId(),
 764                                                  artifactMetadata.getNamespace(), artifactMetadata.getProject(),
 765                                                  artifactMetadata.getVersion(), artifactMetadata.getId() );
 766                     }
 767
 768                     triggerAuditEvent( repositoryId, path, AuditEvent.REMOVE_FILE );
 769                 }
 770             }
 771
 772
 773         }
 774         catch ( ContentNotFoundException e )
 775         {
 776             throw new ArchivaRestServiceException( "Artifact does not exist: " + e.getMessage(), 400, e );
 777         }
 778         catch ( RepositoryNotFoundException e )
 779         {
 780             throw new ArchivaRestServiceException( "Target repository cannot be found: " + e.getMessage(), 400, e );
 781         }
 782         catch ( RepositoryException e )
 783         {
 784             throw new ArchivaRestServiceException( "Repository exception: " + e.getMessage(), 500, e );
 785         }
 786         catch ( MetadataResolutionException e )
 787         {
 788             throw new ArchivaRestServiceException( "Repository exception: " + e.getMessage(), 500, e );
 789         }
 790         catch ( MetadataRepositoryException e )
 791         {
 792             throw new ArchivaRestServiceException( "Repository exception: " + e.getMessage(), 500, e );
 793         }
 794         catch ( RepositoryAdminException e )
 795         {
 796             throw new ArchivaRestServiceException( "RepositoryAdmin exception: " + e.getMessage(), 500, e );
 797         }
 798         finally
 799         {
 800             repositorySession.save();
 801
 802             repositorySession.close();
 803         }
 804         return Boolean.TRUE;
 805     }
 806
 807     public Boolean deleteGroupId( String groupId, String repositoryId )
 808         throws ArchivaRestServiceException
 809     {
 810         if ( StringUtils.isEmpty( repositoryId ) )
 811         {
 812             throw new ArchivaRestServiceException( "repositoryId cannot be null", 400, null );
 813         }
 814
 815         if ( !isAuthorizedToDeleteArtifacts( repositoryId ) )
 816         {
 817             throw new ArchivaRestServiceException( "not authorized to delete artifacts", 403, null );
 818         }
 819
 820         if ( StringUtils.isEmpty( groupId ) )
 821         {
 822             throw new ArchivaRestServiceException( "artifact.groupId cannot be null", 400, null );
 823         }
 824
 825         try
 826         {
 827             ManagedRepositoryContent repository = repositoryFactory.getManagedRepositoryContent( repositoryId );
 828
 829             repository.deleteGroupId( groupId );
 830
 831         }
 832         catch ( RepositoryException e )
 833         {
 834             log.error( e.getMessage(), e );
 835             throw new ArchivaRestServiceException( "Repository exception: " + e.getMessage(), 500, e );
 836         }
 837         return true;
 838     }
 839
 840     public Boolean isAuthorizedToDeleteArtifacts( String repoId )
 841         throws ArchivaRestServiceException
 842     {
 843         String userName =
 844             getAuditInformation().getUser() == null ? "guest" : getAuditInformation().getUser().getUsername();
 845
 846         try
 847         {
 848             boolean res = userRepositories.isAuthorizedToDeleteArtifacts( userName, repoId );
 849             return res;
 850         }
 851         catch ( ArchivaSecurityException e )
 852         {
 853             throw new ArchivaRestServiceException( e.getMessage(),
 854                                                    Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(), e );
 855         }
 856     }
 857
 858     public RepositoryScanStatistics scanRepositoryDirectoriesNow( String repositoryId )
 859         throws ArchivaRestServiceException
 860     {
 861         long sinceWhen = RepositoryScanner.FRESH_SCAN;
 862         try
 863         {
 864             return repoScanner.scan( getManagedRepositoryAdmin().getManagedRepository( repositoryId ), sinceWhen );
 865         }
 866         catch ( RepositoryScannerException e )
 867         {
 868             log.error( e.getMessage(), e );
 869             throw new ArchivaRestServiceException( "RepositoryScannerException exception: " + e.getMessage(), 500, e );
 870         }
 871         catch ( RepositoryAdminException e )
 872         {
 873             log.error( e.getMessage(), e );
 874             throw new ArchivaRestServiceException( "RepositoryScannerException exception: " + e.getMessage(), 500, e );
 875         }
 876     }
 877
 878     /**
 879      * Update artifact level metadata. Creates one if metadata does not exist after artifact deletion.
 880      *
 881      * @param metadata
 882      */
 883     private void updateMetadata( ArchivaRepositoryMetadata metadata, File metadataFile, Date lastUpdatedTimestamp,
 884                                  Artifact artifact )
 885         throws RepositoryMetadataException
 886     {
 887         List<String> availableVersions = new ArrayList<String>();
 888         String latestVersion = "";
 889
 890         if ( metadataFile.exists() )
 891         {
 892             if ( metadata.getAvailableVersions() != null )
 893             {
 894                 availableVersions = metadata.getAvailableVersions();
 895
 896                 if ( availableVersions.size() > 0 )
 897                 {
 898                     Collections.sort( availableVersions, VersionComparator.getInstance() );
 899
 900                     if ( availableVersions.contains( artifact.getVersion() ) )
 901                     {
 902                         availableVersions.remove( availableVersions.indexOf( artifact.getVersion() ) );
 903                     }
 904                     if ( availableVersions.size() > 0 )
 905                     {
 906                         latestVersion = availableVersions.get( availableVersions.size() - 1 );
 907                     }
 908                 }
 909             }
 910         }
 911
 912         if ( metadata.getGroupId() == null )
 913         {
 914             metadata.setGroupId( artifact.getGroupId() );
 915         }
 916         if ( metadata.getArtifactId() == null )
 917         {
 918             metadata.setArtifactId( artifact.getArtifactId() );
 919         }
 920
 921         if ( !VersionUtil.isSnapshot( artifact.getVersion() ) )
 922         {
 923             if ( metadata.getReleasedVersion() != null && metadata.getReleasedVersion().equals(
 924                 artifact.getVersion() ) )
 925             {
 926                 metadata.setReleasedVersion( latestVersion );
 927             }
 928         }
 929
 930         metadata.setLatestVersion( latestVersion );
 931         metadata.setLastUpdatedTimestamp( lastUpdatedTimestamp );
 932         metadata.setAvailableVersions( availableVersions );
 933
 934         RepositoryMetadataWriter.write( metadata, metadataFile );
 935         ChecksummedFile checksum = new ChecksummedFile( metadataFile );
 936         checksum.fixChecksums( algorithms );
 937     }
 938
 939     public ManagedRepositoryAdmin getManagedRepositoryAdmin()
 940     {
 941         return managedRepositoryAdmin;
 942     }
 943
 944     public void setManagedRepositoryAdmin( ManagedRepositoryAdmin managedRepositoryAdmin )
 945     {
 946         this.managedRepositoryAdmin = managedRepositoryAdmin;
 947     }
 948
 949     public RepositoryContentFactory getRepositoryFactory()
 950     {
 951         return repositoryFactory;
 952     }
 953
 954     public void setRepositoryFactory( RepositoryContentFactory repositoryFactory )
 955     {
 956         this.repositoryFactory = repositoryFactory;
 957     }
 958
 959     public RepositorySessionFactory getRepositorySessionFactory()
 960     {
 961         return repositorySessionFactory;
 962     }
 963
 964     public void setRepositorySessionFactory( RepositorySessionFactory repositorySessionFactory )
 965     {
 966         this.repositorySessionFactory = repositorySessionFactory;
 967     }
 968
 969     public List<RepositoryListener> getListeners()
 970     {
 971         return listeners;
 972     }
 973
 974     public void setListeners( List<RepositoryListener> listeners )
 975     {
 976         this.listeners = listeners;
 977     }
 978
 979     public ArchivaAdministration getArchivaAdministration()
 980     {
 981         return archivaAdministration;
 982     }
 983
 984     public void setArchivaAdministration( ArchivaAdministration archivaAdministration )
 985     {
 986         this.archivaAdministration = archivaAdministration;
 987     }
 988 }
 989
 990