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