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