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