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.metadata.model.facets.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.maven2.model.Artifact;
  35 import org.apache.archiva.metadata.model.ArtifactMetadata;
  36 import org.apache.archiva.metadata.model.maven2.MavenArtifactFacet;
  37 import org.apache.archiva.metadata.repository.MetadataRepository;
  38 import org.apache.archiva.metadata.repository.MetadataRepositoryException;
  39 import org.apache.archiva.metadata.repository.MetadataResolutionException;
  40 import org.apache.archiva.metadata.repository.RepositorySession;
  41 import org.apache.archiva.metadata.repository.RepositorySessionFactory;
  42 import org.apache.archiva.model.ArchivaRepositoryMetadata;
  43 import org.apache.archiva.model.ArtifactReference;
  44 import org.apache.archiva.model.VersionedReference;
  45 import org.apache.archiva.redback.authentication.AuthenticationResult;
  46 import org.apache.archiva.redback.authorization.AuthorizationException;
  47 import org.apache.archiva.redback.components.cache.Cache;
  48 import org.apache.archiva.redback.components.taskqueue.TaskQueueException;
  49 import org.apache.archiva.redback.system.DefaultSecuritySession;
  50 import org.apache.archiva.redback.system.SecuritySession;
  51 import org.apache.archiva.redback.system.SecuritySystem;
  52 import org.apache.archiva.redback.users.User;
  53 import org.apache.archiva.redback.users.UserManagerException;
  54 import org.apache.archiva.redback.users.UserNotFoundException;
  55 import org.apache.archiva.repository.ContentNotFoundException;
  56 import org.apache.archiva.repository.ManagedRepositoryContent;
  57 import org.apache.archiva.repository.RepositoryContentFactory;
  58 import org.apache.archiva.repository.RepositoryException;
  59 import org.apache.archiva.repository.RepositoryNotFoundException;
  60 import org.apache.archiva.repository.events.RepositoryListener;
  61 import org.apache.archiva.repository.metadata.MetadataTools;
  62 import org.apache.archiva.repository.metadata.RepositoryMetadataException;
  63 import org.apache.archiva.repository.metadata.RepositoryMetadataWriter;
  64 import org.apache.archiva.repository.scanner.RepositoryScanStatistics;
  65 import org.apache.archiva.repository.scanner.RepositoryScanner;
  66 import org.apache.archiva.repository.scanner.RepositoryScannerException;
  67 import org.apache.archiva.repository.scanner.RepositoryScannerInstance;
  68 import org.apache.archiva.rest.api.model.ArtifactTransferRequest;
  69 import org.apache.archiva.rest.api.model.StringList;
  70 import org.apache.archiva.rest.api.services.ArchivaRestServiceException;
  71 import org.apache.archiva.rest.api.services.RepositoriesService;
  72 import org.apache.archiva.scheduler.ArchivaTaskScheduler;
  73 import org.apache.archiva.scheduler.indexing.ArchivaIndexingTaskExecutor;
  74 import org.apache.archiva.scheduler.indexing.ArtifactIndexingTask;
  75 import org.apache.archiva.scheduler.indexing.DownloadRemoteIndexException;
  76 import org.apache.archiva.scheduler.indexing.DownloadRemoteIndexScheduler;
  77 import org.apache.archiva.scheduler.repository.model.RepositoryTask;
  78 import org.apache.archiva.security.ArchivaSecurityException;
  79 import org.apache.archiva.security.common.ArchivaRoleConstants;
  80 import org.apache.archiva.xml.XMLException;
  81 import org.apache.commons.io.FilenameUtils;
  82 import org.apache.commons.lang.StringUtils;
  83 import org.apache.maven.index.context.IndexingContext;
  84 import org.slf4j.Logger;
  85 import org.slf4j.LoggerFactory;
  86 import org.springframework.beans.factory.annotation.Autowired;
  87 import org.springframework.stereotype.Service;
  88
  89 import javax.inject.Inject;
  90 import javax.inject.Named;
  91 import javax.ws.rs.core.Response;
  92 import java.io.File;
  93 import java.io.IOException;
  94 import java.nio.file.Files;
  95 import java.nio.file.StandardCopyOption;
  96 import java.text.DateFormat;
  97 import java.text.SimpleDateFormat;
  98 import java.util.ArrayList;
  99 import java.util.Calendar;
 100 import java.util.Collection;
 101 import java.util.Collections;
 102 import java.util.Date;
 103 import java.util.List;
 104 import java.util.Set;
 105 import java.util.TimeZone;
 106
 107 /**
 108  * @author Olivier Lamy
 109  * @since 1.4-M1
 110  */
 111 @Service("repositoriesService#rest")
 112 public class DefaultRepositoriesService
 113     extends AbstractRestService
 114     implements RepositoriesService
 115 {
 116     private Logger log = LoggerFactory.getLogger( getClass() );
 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     @Autowired(required = false)
 150     protected List<RepositoryListener> listeners = new ArrayList<RepositoryListener>();
 151
 152     @Inject
 153     private RepositoryScanner repoScanner;
 154
 155     /**
 156      * Cache used for namespaces
 157      */
 158     @Inject
 159     @Named(value = "cache#namespaces")
 160     private Cache<String, Collection<String>> namespacesCache;
 161
 162     private ChecksumAlgorithm[] algorithms = new ChecksumAlgorithm[]{ ChecksumAlgorithm.SHA1, ChecksumAlgorithm.MD5 };
 163
 164     @Override
 165     public Boolean scanRepository( String repositoryId, boolean fullScan )
 166     {
 167         return doScanRepository( repositoryId, fullScan );
 168     }
 169
 170     @Override
 171     public Boolean alreadyScanning( String repositoryId )
 172     {
 173         for ( RepositoryScannerInstance scan : repoScanner.getInProgressScans() )
 174         {
 175             if ( scan.getRepository().getId().equals( repositoryId ) )
 176             {
 177                 return true;
 178             }
 179         }
 180         return repositoryTaskScheduler.isProcessingRepositoryTask( repositoryId );
 181     }
 182
 183     @Override
 184     public Boolean removeScanningTaskFromQueue( String repositoryId )
 185     {
 186         RepositoryTask task = new RepositoryTask();
 187         task.setRepositoryId( repositoryId );
 188         try
 189         {
 190             return repositoryTaskScheduler.unQueueTask( task );
 191         }
 192         catch ( TaskQueueException e )
 193         {
 194             log.error( "failed to unschedule scanning of repo with id {}", repositoryId, e );
 195             return false;
 196         }
 197     }
 198
 199     @Override
 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(), e );
 223         }
 224     }
 225
 226     @Override
 227     public Boolean scheduleDownloadRemoteIndex( String repositoryId, boolean now, boolean fullDownload )
 228         throws ArchivaRestServiceException
 229     {
 230         try
 231         {
 232             downloadRemoteIndexScheduler.scheduleDownloadRemote( repositoryId, now, fullDownload );
 233         }
 234         catch ( DownloadRemoteIndexException e )
 235         {
 236             log.error( e.getMessage(), e );
 237             throw new ArchivaRestServiceException( e.getMessage(), e );
 238         }
 239         return Boolean.TRUE;
 240     }
 241
 242     @Override
 243     public Boolean copyArtifact( ArtifactTransferRequest artifactTransferRequest )
 244         throws ArchivaRestServiceException
 245     {
 246         // check parameters
 247         String userName = getAuditInformation().getUser().getUsername();
 248         if ( StringUtils.isBlank( userName ) )
 249         {
 250             throw new ArchivaRestServiceException( "copyArtifact call: userName not found", null );
 251         }
 252
 253         if ( StringUtils.isBlank( artifactTransferRequest.getRepositoryId() ) )
 254         {
 255             throw new ArchivaRestServiceException( "copyArtifact call: sourceRepositoryId cannot be null", null );
 256         }
 257
 258         if ( StringUtils.isBlank( artifactTransferRequest.getTargetRepositoryId() ) )
 259         {
 260             throw new ArchivaRestServiceException( "copyArtifact call: targetRepositoryId cannot be null", null );
 261         }
 262
 263         ManagedRepository source = null;
 264         try
 265         {
 266             source = managedRepositoryAdmin.getManagedRepository( artifactTransferRequest.getRepositoryId() );
 267         }
 268         catch ( RepositoryAdminException e )
 269         {
 270             throw new ArchivaRestServiceException( e.getMessage(), e );
 271         }
 272
 273         if ( source == null )
 274         {
 275             throw new ArchivaRestServiceException(
 276                 "cannot find repository with id " + artifactTransferRequest.getRepositoryId(), null );
 277         }
 278
 279         ManagedRepository target = null;
 280         try
 281         {
 282             target = managedRepositoryAdmin.getManagedRepository( artifactTransferRequest.getTargetRepositoryId() );
 283         }
 284         catch ( RepositoryAdminException e )
 285         {
 286             throw new ArchivaRestServiceException( e.getMessage(), e );
 287         }
 288
 289         if ( target == null )
 290         {
 291             throw new ArchivaRestServiceException(
 292                 "cannot find repository with id " + artifactTransferRequest.getTargetRepositoryId(), null );
 293         }
 294
 295         if ( StringUtils.isBlank( artifactTransferRequest.getGroupId() ) )
 296         {
 297             throw new ArchivaRestServiceException( "groupId is mandatory", null );
 298         }
 299
 300         if ( StringUtils.isBlank( artifactTransferRequest.getArtifactId() ) )
 301         {
 302             throw new ArchivaRestServiceException( "artifactId is mandatory", null );
 303         }
 304
 305         if ( StringUtils.isBlank( artifactTransferRequest.getVersion() ) )
 306         {
 307             throw new ArchivaRestServiceException( "version is mandatory", null );
 308         }
 309
 310         if ( VersionUtil.isSnapshot( artifactTransferRequest.getVersion() ) )
 311         {
 312             throw new ArchivaRestServiceException( "copy of SNAPSHOT not supported", null );
 313         }
 314
 315         // end check parameters
 316
 317         User user = null;
 318         try
 319         {
 320             user = securitySystem.getUserManager().findUser( userName );
 321         }
 322         catch ( UserNotFoundException e )
 323         {
 324             throw new ArchivaRestServiceException( "user " + userName + " not found", e );
 325         }
 326         catch ( UserManagerException e )
 327         {
 328             throw new ArchivaRestServiceException( "ArchivaRestServiceException:" + e.getMessage(), e );
 329         }
 330
 331         // check karma on source : read
 332         AuthenticationResult authn = new AuthenticationResult( true, userName, null );
 333         SecuritySession securitySession = new DefaultSecuritySession( authn, user );
 334         try
 335         {
 336             boolean authz =
 337                 securitySystem.isAuthorized( securitySession, ArchivaRoleConstants.OPERATION_REPOSITORY_ACCESS,
 338                                              artifactTransferRequest.getRepositoryId() );
 339             if ( !authz )
 340             {
 341                 throw new ArchivaRestServiceException(
 342                     "not authorized to access repo:" + artifactTransferRequest.getRepositoryId(), null );
 343             }
 344         }
 345         catch ( AuthorizationException e )
 346         {
 347             log.error( "error reading permission: " + e.getMessage(), e );
 348             throw new ArchivaRestServiceException( e.getMessage(), e );
 349         }
 350
 351         // check karma on target: write
 352         try
 353         {
 354             boolean authz =
 355                 securitySystem.isAuthorized( securitySession, ArchivaRoleConstants.OPERATION_REPOSITORY_UPLOAD,
 356                                              artifactTransferRequest.getTargetRepositoryId() );
 357             if ( !authz )
 358             {
 359                 throw new ArchivaRestServiceException(
 360                     "not authorized to write to repo:" + artifactTransferRequest.getTargetRepositoryId(), null );
 361             }
 362         }
 363         catch ( AuthorizationException e )
 364         {
 365             log.error( "error reading permission: " + e.getMessage(), e );
 366             throw new ArchivaRestServiceException( e.getMessage(), e );
 367         }
 368
 369         // sounds good we can continue !
 370
 371         ArtifactReference artifactReference = new ArtifactReference();
 372         artifactReference.setArtifactId( artifactTransferRequest.getArtifactId() );
 373         artifactReference.setGroupId( artifactTransferRequest.getGroupId() );
 374         artifactReference.setVersion( artifactTransferRequest.getVersion() );
 375         artifactReference.setClassifier( artifactTransferRequest.getClassifier() );
 376         String packaging = StringUtils.trim( artifactTransferRequest.getPackaging() );
 377         artifactReference.setType( StringUtils.isEmpty( packaging ) ? "jar" : packaging );
 378
 379         try
 380         {
 381
 382             ManagedRepositoryContent sourceRepository =
 383                 repositoryFactory.getManagedRepositoryContent( artifactTransferRequest.getRepositoryId() );
 384
 385             String artifactSourcePath = sourceRepository.toPath( artifactReference );
 386
 387             if ( StringUtils.isEmpty( artifactSourcePath ) )
 388             {
 389                 log.error( "cannot find artifact " + artifactTransferRequest.toString() );
 390                 throw new ArchivaRestServiceException( "cannot find artifact " + artifactTransferRequest.toString(),
 391                                                        null );
 392             }
 393
 394             File artifactFile = new File( source.getLocation(), artifactSourcePath );
 395
 396             if ( !artifactFile.exists() )
 397             {
 398                 log.error( "cannot find artifact " + artifactTransferRequest.toString() );
 399                 throw new ArchivaRestServiceException( "cannot find artifact " + artifactTransferRequest.toString(),
 400                                                        null );
 401             }
 402
 403             ManagedRepositoryContent targetRepository =
 404                 repositoryFactory.getManagedRepositoryContent( artifactTransferRequest.getTargetRepositoryId() );
 405
 406             String artifactPath = targetRepository.toPath( artifactReference );
 407
 408             int lastIndex = artifactPath.lastIndexOf( '/' );
 409
 410             String path = artifactPath.substring( 0, lastIndex );
 411             File targetPath = new File( target.getLocation(), path );
 412
 413             Date lastUpdatedTimestamp = Calendar.getInstance().getTime();
 414             int newBuildNumber = 1;
 415             String timestamp = null;
 416
 417             File versionMetadataFile = new File( targetPath, MetadataTools.MAVEN_METADATA );
 418             ArchivaRepositoryMetadata versionMetadata = getMetadata( versionMetadataFile );
 419
 420             if ( !targetPath.exists() )
 421             {
 422                 targetPath.mkdirs();
 423             }
 424
 425             String filename = artifactPath.substring( lastIndex + 1 );
 426
 427             boolean fixChecksums =
 428                 !( archivaAdministration.getKnownContentConsumers().contains( "create-missing-checksums" ) );
 429
 430             File targetFile = new File( targetPath, filename );
 431             if ( targetFile.exists() && target.isBlockRedeployments() )
 432             {
 433                 throw new ArchivaRestServiceException(
 434                     "artifact already exists in target repo: " + artifactTransferRequest.getTargetRepositoryId()
 435                         + " and redeployment blocked", null
 436                 );
 437             }
 438             else
 439             {
 440                 copyFile( artifactFile, targetPath, filename, fixChecksums );
 441                 queueRepositoryTask( target.getId(), targetFile );
 442             }
 443
 444             // copy source pom to target repo
 445             String pomFilename = filename;
 446             if ( StringUtils.isNotBlank( artifactTransferRequest.getClassifier() ) )
 447             {
 448                 pomFilename = StringUtils.remove( pomFilename, "-" + artifactTransferRequest.getClassifier() );
 449             }
 450             pomFilename = FilenameUtils.removeExtension( pomFilename ) + ".pom";
 451
 452             File pomFile = new File(
 453                 new File( source.getLocation(), artifactSourcePath.substring( 0, artifactPath.lastIndexOf( '/' ) ) ),
 454                 pomFilename );
 455
 456             if ( pomFile != null && pomFile.length() > 0 )
 457             {
 458                 copyFile( pomFile, targetPath, pomFilename, fixChecksums );
 459                 queueRepositoryTask( target.getId(), new File( targetPath, pomFilename ) );
 460
 461
 462             }
 463
 464             // explicitly update only if metadata-updater consumer is not enabled!
 465             if ( !archivaAdministration.getKnownContentConsumers().contains( "metadata-updater" ) )
 466             {
 467                 updateProjectMetadata( targetPath.getAbsolutePath(), lastUpdatedTimestamp, timestamp, newBuildNumber,
 468                                        fixChecksums, artifactTransferRequest );
 469
 470
 471             }
 472
 473             String msg =
 474                 "Artifact \'" + artifactTransferRequest.getGroupId() + ":" + artifactTransferRequest.getArtifactId()
 475                     + ":" + artifactTransferRequest.getVersion() + "\' was successfully deployed to repository \'"
 476                     + artifactTransferRequest.getTargetRepositoryId() + "\'";
 477
 478         }
 479         catch ( RepositoryException e )
 480         {
 481             log.error( "RepositoryException: " + e.getMessage(), e );
 482             throw new ArchivaRestServiceException( e.getMessage(), e );
 483         }
 484         catch ( RepositoryAdminException e )
 485         {
 486             log.error( "RepositoryAdminException: " + e.getMessage(), e );
 487             throw new ArchivaRestServiceException( e.getMessage(), e );
 488         }
 489         catch ( IOException e )
 490         {
 491             log.error( "IOException: " + e.getMessage(), e );
 492             throw new ArchivaRestServiceException( e.getMessage(), e );
 493         }
 494         return true;
 495     }
 496
 497     private void queueRepositoryTask( String repositoryId, File localFile )
 498     {
 499         RepositoryTask task = new RepositoryTask();
 500         task.setRepositoryId( repositoryId );
 501         task.setResourceFile( localFile );
 502         task.setUpdateRelatedArtifacts( true );
 503         //task.setScanAll( true );
 504
 505         try
 506         {
 507             scheduler.queueTask( task );
 508         }
 509         catch ( TaskQueueException e )
 510         {
 511             log.error( "Unable to queue repository task to execute consumers on resource file ['" + localFile.getName()
 512                            + "']." );
 513         }
 514     }
 515
 516     private ArchivaRepositoryMetadata getMetadata( File metadataFile )
 517         throws RepositoryMetadataException
 518     {
 519         ArchivaRepositoryMetadata metadata = new ArchivaRepositoryMetadata();
 520         if ( metadataFile.exists() )
 521         {
 522             try
 523             {
 524                 metadata = MavenMetadataReader.read( metadataFile );
 525             }
 526             catch ( XMLException e )
 527             {
 528                 throw new RepositoryMetadataException( e.getMessage(), e );
 529             }
 530         }
 531         return metadata;
 532     }
 533
 534     private File getMetadata( String targetPath )
 535     {
 536         String artifactPath = targetPath.substring( 0, targetPath.lastIndexOf( File.separatorChar ) );
 537
 538         return new File( artifactPath, MetadataTools.MAVEN_METADATA );
 539     }
 540
 541     private void copyFile( File sourceFile, File targetPath, String targetFilename, boolean fixChecksums )
 542         throws IOException
 543     {
 544         Files.copy( sourceFile.toPath(), new File( targetPath, targetFilename ).toPath(), StandardCopyOption.REPLACE_EXISTING,
 545                     StandardCopyOption.COPY_ATTRIBUTES );
 546
 547         if ( fixChecksums )
 548         {
 549             fixChecksums( new File( targetPath, targetFilename ) );
 550         }
 551     }
 552
 553     private void fixChecksums( File file )
 554     {
 555         ChecksummedFile checksum = new ChecksummedFile( file );
 556         checksum.fixChecksums( algorithms );
 557     }
 558
 559     private void updateProjectMetadata( String targetPath, Date lastUpdatedTimestamp, String timestamp, int buildNumber,
 560                                         boolean fixChecksums, ArtifactTransferRequest artifactTransferRequest )
 561         throws RepositoryMetadataException
 562     {
 563         List<String> availableVersions = new ArrayList<>();
 564         String latestVersion = artifactTransferRequest.getVersion();
 565
 566         File projectDir = new File( targetPath ).getParentFile();
 567         File projectMetadataFile = new File( projectDir, MetadataTools.MAVEN_METADATA );
 568
 569         ArchivaRepositoryMetadata projectMetadata = getMetadata( projectMetadataFile );
 570
 571         if ( projectMetadataFile.exists() )
 572         {
 573             availableVersions = projectMetadata.getAvailableVersions();
 574
 575             Collections.sort( availableVersions, VersionComparator.getInstance() );
 576
 577             if ( !availableVersions.contains( artifactTransferRequest.getVersion() ) )
 578             {
 579                 availableVersions.add( artifactTransferRequest.getVersion() );
 580             }
 581
 582             latestVersion = availableVersions.get( availableVersions.size() - 1 );
 583         }
 584         else
 585         {
 586             availableVersions.add( artifactTransferRequest.getVersion() );
 587
 588             projectMetadata.setGroupId( artifactTransferRequest.getGroupId() );
 589             projectMetadata.setArtifactId( artifactTransferRequest.getArtifactId() );
 590         }
 591
 592         if ( projectMetadata.getGroupId() == null )
 593         {
 594             projectMetadata.setGroupId( artifactTransferRequest.getGroupId() );
 595         }
 596
 597         if ( projectMetadata.getArtifactId() == null )
 598         {
 599             projectMetadata.setArtifactId( artifactTransferRequest.getArtifactId() );
 600         }
 601
 602         projectMetadata.setLatestVersion( latestVersion );
 603         projectMetadata.setLastUpdatedTimestamp( lastUpdatedTimestamp );
 604         projectMetadata.setAvailableVersions( availableVersions );
 605
 606         if ( !VersionUtil.isSnapshot( artifactTransferRequest.getVersion() ) )
 607         {
 608             projectMetadata.setReleasedVersion( latestVersion );
 609         }
 610
 611         RepositoryMetadataWriter.write( projectMetadata, projectMetadataFile );
 612
 613         if ( fixChecksums )
 614         {
 615             fixChecksums( projectMetadataFile );
 616         }
 617     }
 618
 619     @Override
 620     public Boolean removeProjectVersion( String repositoryId, String namespace, String projectId, String version )
 621         throws ArchivaRestServiceException
 622     {
 623         // if not a generic we can use the standard way to delete artifact
 624         if ( !VersionUtil.isGenericSnapshot( version ) )
 625         {
 626             Artifact artifact = new Artifact( namespace, projectId, version );
 627             artifact.setRepositoryId( repositoryId );
 628             artifact.setContext( repositoryId );
 629             return deleteArtifact( artifact );
 630         }
 631
 632         if ( StringUtils.isEmpty( repositoryId ) )
 633         {
 634             throw new ArchivaRestServiceException( "repositoryId cannot be null", 400, null );
 635         }
 636
 637         if ( !isAuthorizedToDeleteArtifacts( repositoryId ) )
 638         {
 639             throw new ArchivaRestServiceException( "not authorized to delete artifacts", 403, null );
 640         }
 641
 642         if ( StringUtils.isEmpty( namespace ) )
 643         {
 644             throw new ArchivaRestServiceException( "groupId cannot be null", 400, null );
 645         }
 646
 647         if ( StringUtils.isEmpty( projectId ) )
 648         {
 649             throw new ArchivaRestServiceException( "artifactId cannot be null", 400, null );
 650         }
 651
 652         if ( StringUtils.isEmpty( version ) )
 653         {
 654             throw new ArchivaRestServiceException( "version cannot be null", 400, null );
 655         }
 656
 657         RepositorySession repositorySession = repositorySessionFactory.createSession();
 658
 659         try
 660         {
 661             ManagedRepositoryContent repository = repositoryFactory.getManagedRepositoryContent( repositoryId );
 662
 663             VersionedReference ref = new VersionedReference();
 664             ref.setArtifactId( projectId );
 665             ref.setGroupId( namespace );
 666             ref.setVersion( version );
 667
 668             repository.deleteVersion( ref );
 669
 670             /*
 671             ProjectReference projectReference = new ProjectReference();
 672             projectReference.setGroupId( namespace );
 673             projectReference.setArtifactId( projectId );
 674
 675             repository.getVersions(  )
 676             */
 677
 678             ArtifactReference artifactReference = new ArtifactReference();
 679             artifactReference.setGroupId( namespace );
 680             artifactReference.setArtifactId( projectId );
 681             artifactReference.setVersion( version );
 682
 683             MetadataRepository metadataRepository = repositorySession.getRepository();
 684
 685             Set<ArtifactReference> related = repository.getRelatedArtifacts( artifactReference );
 686             log.debug( "related: {}", related );
 687             for ( ArtifactReference artifactRef : related )
 688             {
 689                 repository.deleteArtifact( artifactRef );
 690             }
 691
 692             Collection<ArtifactMetadata> artifacts =
 693                 metadataRepository.getArtifacts( repositoryId, namespace, projectId, version );
 694
 695             for ( ArtifactMetadata artifactMetadata : artifacts )
 696             {
 697                 metadataRepository.removeArtifact( artifactMetadata, version );
 698             }
 699
 700             metadataRepository.removeProjectVersion( repositoryId, namespace, projectId, version );
 701         }
 702         catch ( MetadataRepositoryException e )
 703         {
 704             throw new ArchivaRestServiceException( "Repository exception: " + e.getMessage(), 500, e );
 705         }
 706         catch ( MetadataResolutionException e )
 707         {
 708             throw new ArchivaRestServiceException( "Repository exception: " + e.getMessage(), 500, e );
 709         }
 710         catch ( RepositoryException e )
 711         {
 712             throw new ArchivaRestServiceException( "Repository exception: " + e.getMessage(), 500, e );
 713         }
 714         finally
 715         {
 716
 717             repositorySession.save();
 718
 719             repositorySession.close();
 720         }
 721
 722         return Boolean.TRUE;
 723     }
 724
 725     @Override
 726     public Boolean deleteArtifact( Artifact artifact )
 727         throws ArchivaRestServiceException
 728     {
 729
 730         String repositoryId = artifact.getContext();
 731         // some rest call can use context or repositoryId
 732         // so try both!!
 733         if ( StringUtils.isEmpty( repositoryId ) )
 734         {
 735             repositoryId = artifact.getRepositoryId();
 736         }
 737         if ( StringUtils.isEmpty( repositoryId ) )
 738         {
 739             throw new ArchivaRestServiceException( "repositoryId cannot be null", 400, null );
 740         }
 741
 742         if ( !isAuthorizedToDeleteArtifacts( repositoryId ) )
 743         {
 744             throw new ArchivaRestServiceException( "not authorized to delete artifacts", 403, null );
 745         }
 746
 747         if ( artifact == null )
 748         {
 749             throw new ArchivaRestServiceException( "artifact cannot be null", 400, null );
 750         }
 751
 752         if ( StringUtils.isEmpty( artifact.getGroupId() ) )
 753         {
 754             throw new ArchivaRestServiceException( "artifact.groupId cannot be null", 400, null );
 755         }
 756
 757         if ( StringUtils.isEmpty( artifact.getArtifactId() ) )
 758         {
 759             throw new ArchivaRestServiceException( "artifact.artifactId cannot be null", 400, null );
 760         }
 761
 762         // TODO more control on artifact fields
 763
 764         boolean snapshotVersion =
 765             VersionUtil.isSnapshot( artifact.getVersion() ) | VersionUtil.isGenericSnapshot( artifact.getVersion() );
 766
 767         RepositorySession repositorySession = repositorySessionFactory.createSession();
 768         try
 769         {
 770             Date lastUpdatedTimestamp = Calendar.getInstance().getTime();
 771
 772             TimeZone timezone = TimeZone.getTimeZone( "UTC" );
 773             DateFormat fmt = new SimpleDateFormat( "yyyyMMdd.HHmmss" );
 774             fmt.setTimeZone( timezone );
 775             ManagedRepository repoConfig = managedRepositoryAdmin.getManagedRepository( repositoryId );
 776
 777             VersionedReference ref = new VersionedReference();
 778             ref.setArtifactId( artifact.getArtifactId() );
 779             ref.setGroupId( artifact.getGroupId() );
 780             ref.setVersion( artifact.getVersion() );
 781
 782             ManagedRepositoryContent repository = repositoryFactory.getManagedRepositoryContent( repositoryId );
 783
 784             ArtifactReference artifactReference = new ArtifactReference();
 785             artifactReference.setArtifactId( artifact.getArtifactId() );
 786             artifactReference.setGroupId( artifact.getGroupId() );
 787             artifactReference.setVersion( artifact.getVersion() );
 788             artifactReference.setClassifier( artifact.getClassifier() );
 789             artifactReference.setType( artifact.getPackaging() );
 790
 791             MetadataRepository metadataRepository = repositorySession.getRepository();
 792
 793             String path = repository.toMetadataPath( ref );
 794
 795             if ( StringUtils.isNotBlank( artifact.getClassifier() ) )
 796             {
 797                 if ( StringUtils.isBlank( artifact.getPackaging() ) )
 798                 {
 799                     throw new ArchivaRestServiceException( "You must configure a type/packaging when using classifier",
 800                                                            400, null );
 801                 }
 802
 803                 repository.deleteArtifact( artifactReference );
 804
 805             }
 806             else
 807             {
 808
 809                 int index = path.lastIndexOf( '/' );
 810                 path = path.substring( 0, index );
 811                 File targetPath = new File( repoConfig.getLocation(), path );
 812
 813                 if ( !targetPath.exists() )
 814                 {
 815                     //throw new ContentNotFoundException(
 816                     //    artifact.getGroupId() + ":" + artifact.getArtifactId() + ":" + artifact.getVersion() );
 817                     log.warn( "targetPath {} not found skip file deletion", targetPath );
 818                 }
 819
 820                 // TODO: this should be in the storage mechanism so that it is all tied together
 821                 // delete from file system
 822                 if ( !snapshotVersion )
 823                 {
 824                     repository.deleteVersion( ref );
 825                 }
 826                 else
 827                 {
 828                     Set<ArtifactReference> related = repository.getRelatedArtifacts( artifactReference );
 829                     log.debug( "related: {}", related );
 830                     for ( ArtifactReference artifactRef : related )
 831                     {
 832                         repository.deleteArtifact( artifactRef );
 833                     }
 834                 }
 835                 File metadataFile = getMetadata( targetPath.getAbsolutePath() );
 836                 ArchivaRepositoryMetadata metadata = getMetadata( metadataFile );
 837
 838                 updateMetadata( metadata, metadataFile, lastUpdatedTimestamp, artifact );
 839             }
 840             Collection<ArtifactMetadata> artifacts = Collections.emptyList();
 841
 842             if ( snapshotVersion )
 843             {
 844                 String baseVersion = VersionUtil.getBaseVersion( artifact.getVersion() );
 845                 artifacts =
 846                     metadataRepository.getArtifacts( repositoryId, artifact.getGroupId(), artifact.getArtifactId(),
 847                                                      baseVersion );
 848             }
 849             else
 850             {
 851                 artifacts =
 852                     metadataRepository.getArtifacts( repositoryId, artifact.getGroupId(), artifact.getArtifactId(),
 853                                                      artifact.getVersion() );
 854             }
 855
 856             log.debug( "artifacts: {}", artifacts );
 857
 858             if ( artifacts.isEmpty() )
 859             {
 860                 if ( !snapshotVersion )
 861                 {
 862                     // verify metata repository doesn't contains anymore the version
 863                     Collection<String> projectVersions =
 864                         metadataRepository.getProjectVersions( repositoryId, artifact.getGroupId(),
 865                                                                artifact.getArtifactId() );
 866
 867                     if ( projectVersions.contains( artifact.getVersion() ) )
 868                     {
 869                         log.warn( "artifact not found when deleted but version still here ! so force cleanup" );
 870                         metadataRepository.removeProjectVersion( repositoryId, artifact.getGroupId(),
 871                                                                  artifact.getArtifactId(), artifact.getVersion() );
 872                     }
 873
 874                 }
 875             }
 876
 877             for ( ArtifactMetadata artifactMetadata : artifacts )
 878             {
 879
 880                 // TODO: mismatch between artifact (snapshot) version and project (base) version here
 881                 if ( artifactMetadata.getVersion().equals( artifact.getVersion() ) )
 882                 {
 883                     if ( StringUtils.isNotBlank( artifact.getClassifier() ) )
 884                     {
 885                         if ( StringUtils.isBlank( artifact.getPackaging() ) )
 886                         {
 887                             throw new ArchivaRestServiceException(
 888                                 "You must configure a type/packaging when using classifier", 400, null );
 889                         }
 890                         // cleanup facet which contains classifier information
 891                         MavenArtifactFacet mavenArtifactFacet =
 892                             (MavenArtifactFacet) artifactMetadata.getFacet( MavenArtifactFacet.FACET_ID );
 893
 894                         if ( StringUtils.equals( artifact.getClassifier(), mavenArtifactFacet.getClassifier() ) )
 895                         {
 896                             artifactMetadata.removeFacet( MavenArtifactFacet.FACET_ID );
 897                             String groupId = artifact.getGroupId(), artifactId = artifact.getArtifactId(), version =
 898                                 artifact.getVersion();
 899                             MavenArtifactFacet mavenArtifactFacetToCompare = new MavenArtifactFacet();
 900                             mavenArtifactFacetToCompare.setClassifier( artifact.getClassifier() );
 901                             metadataRepository.removeArtifact( repositoryId, groupId, artifactId, version,
 902                                                                mavenArtifactFacetToCompare );
 903                             metadataRepository.save();
 904                         }
 905
 906                     }
 907                     else
 908                     {
 909                         if ( snapshotVersion )
 910                         {
 911                             metadataRepository.removeArtifact( artifactMetadata,
 912                                                                VersionUtil.getBaseVersion( artifact.getVersion() ) );
 913                         }
 914                         else
 915                         {
 916                             metadataRepository.removeArtifact( artifactMetadata.getRepositoryId(),
 917                                                                artifactMetadata.getNamespace(),
 918                                                                artifactMetadata.getProject(), artifact.getVersion(),
 919                                                                artifactMetadata.getId() );
 920                         }
 921                     }
 922                     // TODO: move into the metadata repository proper - need to differentiate attachment of
 923                     //       repository metadata to an artifact
 924                     for ( RepositoryListener listener : listeners )
 925                     {
 926                         listener.deleteArtifact( metadataRepository, repository.getId(),
 927                                                  artifactMetadata.getNamespace(), artifactMetadata.getProject(),
 928                                                  artifactMetadata.getVersion(), artifactMetadata.getId() );
 929                     }
 930
 931                     triggerAuditEvent( repositoryId, path, AuditEvent.REMOVE_FILE );
 932                 }
 933             }
 934         }
 935         catch ( ContentNotFoundException e )
 936         {
 937             throw new ArchivaRestServiceException( "Artifact does not exist: " + e.getMessage(), 400, e );
 938         }
 939         catch ( RepositoryNotFoundException e )
 940         {
 941             throw new ArchivaRestServiceException( "Target repository cannot be found: " + e.getMessage(), 400, e );
 942         }
 943         catch ( RepositoryException e )
 944         {
 945             throw new ArchivaRestServiceException( "Repository exception: " + e.getMessage(), 500, e );
 946         }
 947         catch ( MetadataResolutionException e )
 948         {
 949             throw new ArchivaRestServiceException( "Repository exception: " + e.getMessage(), 500, e );
 950         }
 951         catch ( MetadataRepositoryException e )
 952         {
 953             throw new ArchivaRestServiceException( "Repository exception: " + e.getMessage(), 500, e );
 954         }
 955         catch ( RepositoryAdminException e )
 956         {
 957             throw new ArchivaRestServiceException( "RepositoryAdmin exception: " + e.getMessage(), 500, e );
 958         }
 959         finally
 960         {
 961
 962             repositorySession.save();
 963
 964             repositorySession.close();
 965         }
 966         return Boolean.TRUE;
 967     }
 968
 969     @Override
 970     public Boolean deleteGroupId( String groupId, String repositoryId )
 971         throws ArchivaRestServiceException
 972     {
 973         if ( StringUtils.isEmpty( repositoryId ) )
 974         {
 975             throw new ArchivaRestServiceException( "repositoryId cannot be null", 400, null );
 976         }
 977
 978         if ( !isAuthorizedToDeleteArtifacts( repositoryId ) )
 979         {
 980             throw new ArchivaRestServiceException( "not authorized to delete artifacts", 403, null );
 981         }
 982
 983         if ( StringUtils.isEmpty( groupId ) )
 984         {
 985             throw new ArchivaRestServiceException( "groupId cannot be null", 400, null );
 986         }
 987
 988         RepositorySession repositorySession = repositorySessionFactory.createSession();
 989
 990         try
 991         {
 992             ManagedRepositoryContent repository = repositoryFactory.getManagedRepositoryContent( repositoryId );
 993
 994             repository.deleteGroupId( groupId );
 995
 996             MetadataRepository metadataRepository = repositorySession.getRepository();
 997
 998             metadataRepository.removeNamespace( repositoryId, groupId );
 999
1000             // just invalidate cache entry
1001             String cacheKey = repositoryId + "-" + groupId;
1002             namespacesCache.remove( cacheKey );
1003             namespacesCache.remove( repositoryId );
1004
1005             metadataRepository.save();
1006         }
1007         catch ( MetadataRepositoryException e )
1008         {
1009             log.error( e.getMessage(), e );
1010             throw new ArchivaRestServiceException( "Repository exception: " + e.getMessage(), 500, e );
1011         }
1012         catch ( RepositoryException e )
1013         {
1014             log.error( e.getMessage(), e );
1015             throw new ArchivaRestServiceException( "Repository exception: " + e.getMessage(), 500, e );
1016         }
1017         finally
1018         {
1019
1020             repositorySession.close();
1021         }
1022         return true;
1023     }
1024
1025     @Override
1026     public Boolean deleteProject( String groupId, String projectId, String repositoryId )
1027         throws ArchivaRestServiceException
1028     {
1029         if ( StringUtils.isEmpty( repositoryId ) )
1030         {
1031             throw new ArchivaRestServiceException( "repositoryId cannot be null", 400, null );
1032         }
1033
1034         if ( !isAuthorizedToDeleteArtifacts( repositoryId ) )
1035         {
1036             throw new ArchivaRestServiceException( "not authorized to delete artifacts", 403, null );
1037         }
1038
1039         if ( StringUtils.isEmpty( groupId ) )
1040         {
1041             throw new ArchivaRestServiceException( "groupId cannot be null", 400, null );
1042         }
1043
1044         if ( StringUtils.isEmpty( projectId ) )
1045         {
1046             throw new ArchivaRestServiceException( "artifactId cannot be null", 400, null );
1047         }
1048
1049         RepositorySession repositorySession = repositorySessionFactory.createSession();
1050
1051         try
1052         {
1053             ManagedRepositoryContent repository = repositoryFactory.getManagedRepositoryContent( repositoryId );
1054
1055             repository.deleteProject( groupId, projectId );
1056         }
1057         catch ( ContentNotFoundException e )
1058         {
1059             log.warn( "skip ContentNotFoundException: {}", e.getMessage() );
1060         }
1061         catch ( RepositoryException e )
1062         {
1063             log.error( e.getMessage(), e );
1064             throw new ArchivaRestServiceException( "Repository exception: " + e.getMessage(), 500, e );
1065         }
1066
1067         try
1068         {
1069
1070             MetadataRepository metadataRepository = repositorySession.getRepository();
1071
1072             metadataRepository.removeProject( repositoryId, groupId, projectId );
1073
1074             metadataRepository.save();
1075         }
1076         catch ( MetadataRepositoryException e )
1077         {
1078             log.error( e.getMessage(), e );
1079             throw new ArchivaRestServiceException( "Repository exception: " + e.getMessage(), 500, e );
1080         }
1081         finally
1082         {
1083
1084             repositorySession.close();
1085         }
1086         return true;
1087
1088     }
1089
1090     @Override
1091     public Boolean isAuthorizedToDeleteArtifacts( String repoId )
1092         throws ArchivaRestServiceException
1093     {
1094         String userName =
1095             getAuditInformation().getUser() == null ? "guest" : getAuditInformation().getUser().getUsername();
1096
1097         try
1098         {
1099             return userRepositories.isAuthorizedToDeleteArtifacts( userName, repoId );
1100         }
1101         catch ( ArchivaSecurityException e )
1102         {
1103             throw new ArchivaRestServiceException( e.getMessage(),
1104                                                    Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(), e );
1105         }
1106     }
1107
1108     @Override
1109     public RepositoryScanStatistics scanRepositoryDirectoriesNow( String repositoryId )
1110         throws ArchivaRestServiceException
1111     {
1112         long sinceWhen = RepositoryScanner.FRESH_SCAN;
1113         try
1114         {
1115             return repoScanner.scan( getManagedRepositoryAdmin().getManagedRepository( repositoryId ), sinceWhen );
1116         }
1117         catch ( RepositoryScannerException e )
1118         {
1119             log.error( e.getMessage(), e );
1120             throw new ArchivaRestServiceException( "RepositoryScannerException exception: " + e.getMessage(), 500, e );
1121         }
1122         catch ( RepositoryAdminException e )
1123         {
1124             log.error( e.getMessage(), e );
1125             throw new ArchivaRestServiceException( "RepositoryScannerException exception: " + e.getMessage(), 500, e );
1126         }
1127     }
1128
1129     /**
1130      * Update artifact level metadata. Creates one if metadata does not exist after artifact deletion.
1131      *
1132      * @param metadata
1133      */
1134     private void updateMetadata( ArchivaRepositoryMetadata metadata, File metadataFile, Date lastUpdatedTimestamp,
1135                                  Artifact artifact )
1136         throws RepositoryMetadataException
1137     {
1138         List<String> availableVersions = new ArrayList<>();
1139         String latestVersion = "";
1140
1141         if ( metadataFile.exists() )
1142         {
1143             if ( metadata.getAvailableVersions() != null )
1144             {
1145                 availableVersions = metadata.getAvailableVersions();
1146
1147                 if ( availableVersions.size() > 0 )
1148                 {
1149                     Collections.sort( availableVersions, VersionComparator.getInstance() );
1150
1151                     if ( availableVersions.contains( artifact.getVersion() ) )
1152                     {
1153                         availableVersions.remove( availableVersions.indexOf( artifact.getVersion() ) );
1154                     }
1155                     if ( availableVersions.size() > 0 )
1156                     {
1157                         latestVersion = availableVersions.get( availableVersions.size() - 1 );
1158                     }
1159                 }
1160             }
1161         }
1162
1163         if ( metadata.getGroupId() == null )
1164         {
1165             metadata.setGroupId( artifact.getGroupId() );
1166         }
1167         if ( metadata.getArtifactId() == null )
1168         {
1169             metadata.setArtifactId( artifact.getArtifactId() );
1170         }
1171
1172         if ( !VersionUtil.isSnapshot( artifact.getVersion() ) )
1173         {
1174             if ( metadata.getReleasedVersion() != null && metadata.getReleasedVersion().equals(
1175                 artifact.getVersion() ) )
1176             {
1177                 metadata.setReleasedVersion( latestVersion );
1178             }
1179         }
1180
1181         metadata.setLatestVersion( latestVersion );
1182         metadata.setLastUpdatedTimestamp( lastUpdatedTimestamp );
1183         metadata.setAvailableVersions( availableVersions );
1184
1185         RepositoryMetadataWriter.write( metadata, metadataFile );
1186         ChecksummedFile checksum = new ChecksummedFile( metadataFile );
1187         checksum.fixChecksums( algorithms );
1188     }
1189
1190     @Override
1191     public StringList getRunningRemoteDownloadIds()
1192     {
1193         return new StringList( downloadRemoteIndexScheduler.getRunningRemoteDownloadIds() );
1194     }
1195
1196     public ManagedRepositoryAdmin getManagedRepositoryAdmin()
1197     {
1198         return managedRepositoryAdmin;
1199     }
1200
1201     public void setManagedRepositoryAdmin( ManagedRepositoryAdmin managedRepositoryAdmin )
1202     {
1203         this.managedRepositoryAdmin = managedRepositoryAdmin;
1204     }
1205
1206     public RepositoryContentFactory getRepositoryFactory()
1207     {
1208         return repositoryFactory;
1209     }
1210
1211     public void setRepositoryFactory( RepositoryContentFactory repositoryFactory )
1212     {
1213         this.repositoryFactory = repositoryFactory;
1214     }
1215
1216     public RepositorySessionFactory getRepositorySessionFactory()
1217     {
1218         return repositorySessionFactory;
1219     }
1220
1221     public void setRepositorySessionFactory( RepositorySessionFactory repositorySessionFactory )
1222     {
1223         this.repositorySessionFactory = repositorySessionFactory;
1224     }
1225
1226     public List<RepositoryListener> getListeners()
1227     {
1228         return listeners;
1229     }
1230
1231     public void setListeners( List<RepositoryListener> listeners )
1232     {
1233         this.listeners = listeners;
1234     }
1235
1236     public ArchivaAdministration getArchivaAdministration()
1237     {
1238         return archivaAdministration;
1239     }
1240
1241     public void setArchivaAdministration( ArchivaAdministration archivaAdministration )
1242     {
1243         this.archivaAdministration = archivaAdministration;
1244     }
1245 }
1246
1247