This project has retired. For details please refer to its
Attic page.
1 package org.apache.archiva.rest.services;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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
109
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
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
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
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
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
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
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
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 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
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
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 log.debug("copyArtifact {}", msg);
486
487 }
488 catch ( RepositoryException e )
489 {
490 log.error( "RepositoryException: " + e.getMessage(), e );
491 throw new ArchivaRestServiceException( e.getMessage(), e );
492 }
493 catch ( RepositoryAdminException e )
494 {
495 log.error( "RepositoryAdminException: " + e.getMessage(), e );
496 throw new ArchivaRestServiceException( e.getMessage(), e );
497 }
498 catch ( IOException e )
499 {
500 log.error( "IOException: " + e.getMessage(), e );
501 throw new ArchivaRestServiceException( e.getMessage(), e );
502 }
503 return true;
504 }
505
506 private void queueRepositoryTask( String repositoryId, File localFile )
507 {
508 RepositoryTask task = new RepositoryTask();
509 task.setRepositoryId( repositoryId );
510 task.setResourceFile( localFile );
511 task.setUpdateRelatedArtifacts( true );
512
513
514 try
515 {
516 scheduler.queueTask( task );
517 }
518 catch ( TaskQueueException e )
519 {
520 log.error( "Unable to queue repository task to execute consumers on resource file ['" + localFile.getName()
521 + "']." );
522 }
523 }
524
525 private ArchivaRepositoryMetadata getMetadata( File metadataFile )
526 throws RepositoryMetadataException
527 {
528 ArchivaRepositoryMetadata metadata = new ArchivaRepositoryMetadata();
529 if ( metadataFile.exists() )
530 {
531 try
532 {
533 metadata = MavenMetadataReader.read( metadataFile );
534 }
535 catch ( XMLException e )
536 {
537 throw new RepositoryMetadataException( e.getMessage(), e );
538 }
539 }
540 return metadata;
541 }
542
543 private File getMetadata( String targetPath )
544 {
545 String artifactPath = targetPath.substring( 0, targetPath.lastIndexOf( File.separatorChar ) );
546
547 return new File( artifactPath, MetadataTools.MAVEN_METADATA );
548 }
549
550 private void copyFile( File sourceFile, File targetPath, String targetFilename, boolean fixChecksums )
551 throws IOException
552 {
553 Files.copy( sourceFile.toPath(), new File( targetPath, targetFilename ).toPath(), StandardCopyOption.REPLACE_EXISTING,
554 StandardCopyOption.COPY_ATTRIBUTES );
555
556 if ( fixChecksums )
557 {
558 fixChecksums( new File( targetPath, targetFilename ) );
559 }
560 }
561
562 private void fixChecksums( File file )
563 {
564 ChecksummedFile checksum = new ChecksummedFile( file );
565 checksum.fixChecksums( algorithms );
566 }
567
568 private void updateProjectMetadata( String targetPath, Date lastUpdatedTimestamp, String timestamp, int buildNumber,
569 boolean fixChecksums, ArtifactTransferRequest artifactTransferRequest )
570 throws RepositoryMetadataException
571 {
572 List<String> availableVersions = new ArrayList<>();
573 String latestVersion = artifactTransferRequest.getVersion();
574
575 File projectDir = new File( targetPath ).getParentFile();
576 File projectMetadataFile = new File( projectDir, MetadataTools.MAVEN_METADATA );
577
578 ArchivaRepositoryMetadata projectMetadata = getMetadata( projectMetadataFile );
579
580 if ( projectMetadataFile.exists() )
581 {
582 availableVersions = projectMetadata.getAvailableVersions();
583
584 Collections.sort( availableVersions, VersionComparator.getInstance() );
585
586 if ( !availableVersions.contains( artifactTransferRequest.getVersion() ) )
587 {
588 availableVersions.add( artifactTransferRequest.getVersion() );
589 }
590
591 latestVersion = availableVersions.get( availableVersions.size() - 1 );
592 }
593 else
594 {
595 availableVersions.add( artifactTransferRequest.getVersion() );
596
597 projectMetadata.setGroupId( artifactTransferRequest.getGroupId() );
598 projectMetadata.setArtifactId( artifactTransferRequest.getArtifactId() );
599 }
600
601 if ( projectMetadata.getGroupId() == null )
602 {
603 projectMetadata.setGroupId( artifactTransferRequest.getGroupId() );
604 }
605
606 if ( projectMetadata.getArtifactId() == null )
607 {
608 projectMetadata.setArtifactId( artifactTransferRequest.getArtifactId() );
609 }
610
611 projectMetadata.setLatestVersion( latestVersion );
612 projectMetadata.setLastUpdatedTimestamp( lastUpdatedTimestamp );
613 projectMetadata.setAvailableVersions( availableVersions );
614
615 if ( !VersionUtil.isSnapshot( artifactTransferRequest.getVersion() ) )
616 {
617 projectMetadata.setReleasedVersion( latestVersion );
618 }
619
620 RepositoryMetadataWriter.write( projectMetadata, projectMetadataFile );
621
622 if ( fixChecksums )
623 {
624 fixChecksums( projectMetadataFile );
625 }
626 }
627
628 @Override
629 public Boolean removeProjectVersion( String repositoryId, String namespace, String projectId, String version )
630 throws ArchivaRestServiceException
631 {
632
633 if ( !VersionUtil.isGenericSnapshot( version ) )
634 {
635 Artifact artifact = new Artifact( namespace, projectId, version );
636 artifact.setRepositoryId( repositoryId );
637 artifact.setContext( repositoryId );
638 return deleteArtifact( artifact );
639 }
640
641 if ( StringUtils.isEmpty( repositoryId ) )
642 {
643 throw new ArchivaRestServiceException( "repositoryId cannot be null", 400, null );
644 }
645
646 if ( !isAuthorizedToDeleteArtifacts( repositoryId ) )
647 {
648 throw new ArchivaRestServiceException( "not authorized to delete artifacts", 403, null );
649 }
650
651 if ( StringUtils.isEmpty( namespace ) )
652 {
653 throw new ArchivaRestServiceException( "groupId cannot be null", 400, null );
654 }
655
656 if ( StringUtils.isEmpty( projectId ) )
657 {
658 throw new ArchivaRestServiceException( "artifactId cannot be null", 400, null );
659 }
660
661 if ( StringUtils.isEmpty( version ) )
662 {
663 throw new ArchivaRestServiceException( "version cannot be null", 400, null );
664 }
665
666 RepositorySession repositorySession = repositorySessionFactory.createSession();
667
668 try
669 {
670 ManagedRepositoryContent repository = repositoryFactory.getManagedRepositoryContent( repositoryId );
671
672 VersionedReference ref = new VersionedReference();
673 ref.setArtifactId( projectId );
674 ref.setGroupId( namespace );
675 ref.setVersion( version );
676
677 repository.deleteVersion( ref );
678
679
680
681
682
683
684
685
686
687 ArtifactReference artifactReference = new ArtifactReference();
688 artifactReference.setGroupId( namespace );
689 artifactReference.setArtifactId( projectId );
690 artifactReference.setVersion( version );
691
692 MetadataRepository metadataRepository = repositorySession.getRepository();
693
694 Set<ArtifactReference> related = repository.getRelatedArtifacts( artifactReference );
695 log.debug( "related: {}", related );
696 for ( ArtifactReference artifactRef : related )
697 {
698 repository.deleteArtifact( artifactRef );
699 }
700
701 Collection<ArtifactMetadata> artifacts =
702 metadataRepository.getArtifacts( repositoryId, namespace, projectId, version );
703
704 for ( ArtifactMetadata artifactMetadata : artifacts )
705 {
706 metadataRepository.removeArtifact( artifactMetadata, version );
707 }
708
709 metadataRepository.removeProjectVersion( repositoryId, namespace, projectId, version );
710 }
711 catch ( MetadataRepositoryException e )
712 {
713 throw new ArchivaRestServiceException( "Repository exception: " + e.getMessage(), 500, e );
714 }
715 catch ( MetadataResolutionException e )
716 {
717 throw new ArchivaRestServiceException( "Repository exception: " + e.getMessage(), 500, e );
718 }
719 catch ( RepositoryException e )
720 {
721 throw new ArchivaRestServiceException( "Repository exception: " + e.getMessage(), 500, e );
722 }
723 finally
724 {
725
726 repositorySession.save();
727
728 repositorySession.close();
729 }
730
731 return Boolean.TRUE;
732 }
733
734 @Override
735 public Boolean deleteArtifact( Artifact artifact )
736 throws ArchivaRestServiceException
737 {
738
739 String repositoryId = artifact.getContext();
740
741
742 if ( StringUtils.isEmpty( repositoryId ) )
743 {
744 repositoryId = artifact.getRepositoryId();
745 }
746 if ( StringUtils.isEmpty( repositoryId ) )
747 {
748 throw new ArchivaRestServiceException( "repositoryId cannot be null", 400, null );
749 }
750
751 if ( !isAuthorizedToDeleteArtifacts( repositoryId ) )
752 {
753 throw new ArchivaRestServiceException( "not authorized to delete artifacts", 403, null );
754 }
755
756 if ( artifact == null )
757 {
758 throw new ArchivaRestServiceException( "artifact cannot be null", 400, null );
759 }
760
761 if ( StringUtils.isEmpty( artifact.getGroupId() ) )
762 {
763 throw new ArchivaRestServiceException( "artifact.groupId cannot be null", 400, null );
764 }
765
766 if ( StringUtils.isEmpty( artifact.getArtifactId() ) )
767 {
768 throw new ArchivaRestServiceException( "artifact.artifactId cannot be null", 400, null );
769 }
770
771
772
773 boolean snapshotVersion =
774 VersionUtil.isSnapshot( artifact.getVersion() ) | VersionUtil.isGenericSnapshot( artifact.getVersion() );
775
776 RepositorySession repositorySession = repositorySessionFactory.createSession();
777 try
778 {
779 Date lastUpdatedTimestamp = Calendar.getInstance().getTime();
780
781 TimeZone timezone = TimeZone.getTimeZone( "UTC" );
782 DateFormat fmt = new SimpleDateFormat( "yyyyMMdd.HHmmss" );
783 fmt.setTimeZone( timezone );
784 ManagedRepository repoConfig = managedRepositoryAdmin.getManagedRepository( repositoryId );
785
786 VersionedReference ref = new VersionedReference();
787 ref.setArtifactId( artifact.getArtifactId() );
788 ref.setGroupId( artifact.getGroupId() );
789 ref.setVersion( artifact.getVersion() );
790
791 ManagedRepositoryContent repository = repositoryFactory.getManagedRepositoryContent( repositoryId );
792
793 ArtifactReference artifactReference = new ArtifactReference();
794 artifactReference.setArtifactId( artifact.getArtifactId() );
795 artifactReference.setGroupId( artifact.getGroupId() );
796 artifactReference.setVersion( artifact.getVersion() );
797 artifactReference.setClassifier( artifact.getClassifier() );
798 artifactReference.setType( artifact.getPackaging() );
799
800 MetadataRepository metadataRepository = repositorySession.getRepository();
801
802 String path = repository.toMetadataPath( ref );
803
804 if ( StringUtils.isNotBlank( artifact.getClassifier() ) )
805 {
806 if ( StringUtils.isBlank( artifact.getPackaging() ) )
807 {
808 throw new ArchivaRestServiceException( "You must configure a type/packaging when using classifier",
809 400, null );
810 }
811
812 repository.deleteArtifact( artifactReference );
813
814 }
815 else
816 {
817
818 int index = path.lastIndexOf( '/' );
819 path = path.substring( 0, index );
820 File targetPath = new File( repoConfig.getLocation(), path );
821
822 if ( !targetPath.exists() )
823 {
824
825
826 log.warn( "targetPath {} not found skip file deletion", targetPath );
827 }
828
829
830
831 if ( !snapshotVersion )
832 {
833 repository.deleteVersion( ref );
834 }
835 else
836 {
837 Set<ArtifactReference> related = repository.getRelatedArtifacts( artifactReference );
838 log.debug( "related: {}", related );
839 for ( ArtifactReference artifactRef : related )
840 {
841 repository.deleteArtifact( artifactRef );
842 }
843 }
844 File metadataFile = getMetadata( targetPath.getAbsolutePath() );
845 ArchivaRepositoryMetadata metadata = getMetadata( metadataFile );
846
847 updateMetadata( metadata, metadataFile, lastUpdatedTimestamp, artifact );
848 }
849 Collection<ArtifactMetadata> artifacts = Collections.emptyList();
850
851 if ( snapshotVersion )
852 {
853 String baseVersion = VersionUtil.getBaseVersion( artifact.getVersion() );
854 artifacts =
855 metadataRepository.getArtifacts( repositoryId, artifact.getGroupId(), artifact.getArtifactId(),
856 baseVersion );
857 }
858 else
859 {
860 artifacts =
861 metadataRepository.getArtifacts( repositoryId, artifact.getGroupId(), artifact.getArtifactId(),
862 artifact.getVersion() );
863 }
864
865 log.debug( "artifacts: {}", artifacts );
866
867 if ( artifacts.isEmpty() )
868 {
869 if ( !snapshotVersion )
870 {
871
872 Collection<String> projectVersions =
873 metadataRepository.getProjectVersions( repositoryId, artifact.getGroupId(),
874 artifact.getArtifactId() );
875
876 if ( projectVersions.contains( artifact.getVersion() ) )
877 {
878 log.warn( "artifact not found when deleted but version still here ! so force cleanup" );
879 metadataRepository.removeProjectVersion( repositoryId, artifact.getGroupId(),
880 artifact.getArtifactId(), artifact.getVersion() );
881 }
882
883 }
884 }
885
886 for ( ArtifactMetadata artifactMetadata : artifacts )
887 {
888
889
890 if ( artifactMetadata.getVersion().equals( artifact.getVersion() ) )
891 {
892 if ( StringUtils.isNotBlank( artifact.getClassifier() ) )
893 {
894 if ( StringUtils.isBlank( artifact.getPackaging() ) )
895 {
896 throw new ArchivaRestServiceException(
897 "You must configure a type/packaging when using classifier", 400, null );
898 }
899
900 MavenArtifactFacet mavenArtifactFacet =
901 (MavenArtifactFacet) artifactMetadata.getFacet( MavenArtifactFacet.FACET_ID );
902
903 if ( StringUtils.equals( artifact.getClassifier(), mavenArtifactFacet.getClassifier() ) )
904 {
905 artifactMetadata.removeFacet( MavenArtifactFacet.FACET_ID );
906 String groupId = artifact.getGroupId(), artifactId = artifact.getArtifactId(), version =
907 artifact.getVersion();
908 MavenArtifactFacet mavenArtifactFacetToCompare = new MavenArtifactFacet();
909 mavenArtifactFacetToCompare.setClassifier( artifact.getClassifier() );
910 metadataRepository.removeArtifact( repositoryId, groupId, artifactId, version,
911 mavenArtifactFacetToCompare );
912 metadataRepository.save();
913 }
914
915 }
916 else
917 {
918 if ( snapshotVersion )
919 {
920 metadataRepository.removeArtifact( artifactMetadata,
921 VersionUtil.getBaseVersion( artifact.getVersion() ) );
922 }
923 else
924 {
925 metadataRepository.removeArtifact( artifactMetadata.getRepositoryId(),
926 artifactMetadata.getNamespace(),
927 artifactMetadata.getProject(), artifact.getVersion(),
928 artifactMetadata.getId() );
929 }
930 }
931
932
933 for ( RepositoryListener listener : listeners )
934 {
935 listener.deleteArtifact( metadataRepository, repository.getId(),
936 artifactMetadata.getNamespace(), artifactMetadata.getProject(),
937 artifactMetadata.getVersion(), artifactMetadata.getId() );
938 }
939
940 triggerAuditEvent( repositoryId, path, AuditEvent.REMOVE_FILE );
941 }
942 }
943 }
944 catch ( ContentNotFoundException e )
945 {
946 throw new ArchivaRestServiceException( "Artifact does not exist: " + e.getMessage(), 400, e );
947 }
948 catch ( RepositoryNotFoundException e )
949 {
950 throw new ArchivaRestServiceException( "Target repository cannot be found: " + e.getMessage(), 400, e );
951 }
952 catch ( RepositoryException e )
953 {
954 throw new ArchivaRestServiceException( "Repository exception: " + e.getMessage(), 500, e );
955 }
956 catch ( MetadataResolutionException e )
957 {
958 throw new ArchivaRestServiceException( "Repository exception: " + e.getMessage(), 500, e );
959 }
960 catch ( MetadataRepositoryException e )
961 {
962 throw new ArchivaRestServiceException( "Repository exception: " + e.getMessage(), 500, e );
963 }
964 catch ( RepositoryAdminException e )
965 {
966 throw new ArchivaRestServiceException( "RepositoryAdmin exception: " + e.getMessage(), 500, e );
967 }
968 finally
969 {
970
971 repositorySession.save();
972
973 repositorySession.close();
974 }
975 return Boolean.TRUE;
976 }
977
978 @Override
979 public Boolean deleteGroupId( String groupId, String repositoryId )
980 throws ArchivaRestServiceException
981 {
982 if ( StringUtils.isEmpty( repositoryId ) )
983 {
984 throw new ArchivaRestServiceException( "repositoryId cannot be null", 400, null );
985 }
986
987 if ( !isAuthorizedToDeleteArtifacts( repositoryId ) )
988 {
989 throw new ArchivaRestServiceException( "not authorized to delete artifacts", 403, null );
990 }
991
992 if ( StringUtils.isEmpty( groupId ) )
993 {
994 throw new ArchivaRestServiceException( "groupId cannot be null", 400, null );
995 }
996
997 RepositorySession repositorySession = repositorySessionFactory.createSession();
998
999 try
1000 {
1001 ManagedRepositoryContent repository = repositoryFactory.getManagedRepositoryContent( repositoryId );
1002
1003 repository.deleteGroupId( groupId );
1004
1005 MetadataRepository metadataRepository = repositorySession.getRepository();
1006
1007 metadataRepository.removeNamespace( repositoryId, groupId );
1008
1009
1010 String cacheKey = repositoryId + "-" + groupId;
1011 namespacesCache.remove( cacheKey );
1012 namespacesCache.remove( repositoryId );
1013
1014 metadataRepository.save();
1015 }
1016 catch ( MetadataRepositoryException e )
1017 {
1018 log.error( e.getMessage(), e );
1019 throw new ArchivaRestServiceException( "Repository exception: " + e.getMessage(), 500, e );
1020 }
1021 catch ( RepositoryException e )
1022 {
1023 log.error( e.getMessage(), e );
1024 throw new ArchivaRestServiceException( "Repository exception: " + e.getMessage(), 500, e );
1025 }
1026 finally
1027 {
1028
1029 repositorySession.close();
1030 }
1031 return true;
1032 }
1033
1034 @Override
1035 public Boolean deleteProject( String groupId, String projectId, String repositoryId )
1036 throws ArchivaRestServiceException
1037 {
1038 if ( StringUtils.isEmpty( repositoryId ) )
1039 {
1040 throw new ArchivaRestServiceException( "repositoryId cannot be null", 400, null );
1041 }
1042
1043 if ( !isAuthorizedToDeleteArtifacts( repositoryId ) )
1044 {
1045 throw new ArchivaRestServiceException( "not authorized to delete artifacts", 403, null );
1046 }
1047
1048 if ( StringUtils.isEmpty( groupId ) )
1049 {
1050 throw new ArchivaRestServiceException( "groupId cannot be null", 400, null );
1051 }
1052
1053 if ( StringUtils.isEmpty( projectId ) )
1054 {
1055 throw new ArchivaRestServiceException( "artifactId cannot be null", 400, null );
1056 }
1057
1058 RepositorySession repositorySession = repositorySessionFactory.createSession();
1059
1060 try
1061 {
1062 ManagedRepositoryContent repository = repositoryFactory.getManagedRepositoryContent( repositoryId );
1063
1064 repository.deleteProject( groupId, projectId );
1065 }
1066 catch ( ContentNotFoundException e )
1067 {
1068 log.warn( "skip ContentNotFoundException: {}", e.getMessage() );
1069 }
1070 catch ( RepositoryException e )
1071 {
1072 log.error( e.getMessage(), e );
1073 throw new ArchivaRestServiceException( "Repository exception: " + e.getMessage(), 500, e );
1074 }
1075
1076 try
1077 {
1078
1079 MetadataRepository metadataRepository = repositorySession.getRepository();
1080
1081 metadataRepository.removeProject( repositoryId, groupId, projectId );
1082
1083 metadataRepository.save();
1084 }
1085 catch ( MetadataRepositoryException e )
1086 {
1087 log.error( e.getMessage(), e );
1088 throw new ArchivaRestServiceException( "Repository exception: " + e.getMessage(), 500, e );
1089 }
1090 finally
1091 {
1092
1093 repositorySession.close();
1094 }
1095 return true;
1096
1097 }
1098
1099 @Override
1100 public Boolean isAuthorizedToDeleteArtifacts( String repoId )
1101 throws ArchivaRestServiceException
1102 {
1103 String userName =
1104 getAuditInformation().getUser() == null ? "guest" : getAuditInformation().getUser().getUsername();
1105
1106 try
1107 {
1108 return userRepositories.isAuthorizedToDeleteArtifacts( userName, repoId );
1109 }
1110 catch ( ArchivaSecurityException e )
1111 {
1112 throw new ArchivaRestServiceException( e.getMessage(),
1113 Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(), e );
1114 }
1115 }
1116
1117 @Override
1118 public RepositoryScanStatistics scanRepositoryDirectoriesNow( String repositoryId )
1119 throws ArchivaRestServiceException
1120 {
1121 long sinceWhen = RepositoryScanner.FRESH_SCAN;
1122 try
1123 {
1124 return repoScanner.scan( getManagedRepositoryAdmin().getManagedRepository( repositoryId ), sinceWhen );
1125 }
1126 catch ( RepositoryScannerException e )
1127 {
1128 log.error( e.getMessage(), e );
1129 throw new ArchivaRestServiceException( "RepositoryScannerException exception: " + e.getMessage(), 500, e );
1130 }
1131 catch ( RepositoryAdminException e )
1132 {
1133 log.error( e.getMessage(), e );
1134 throw new ArchivaRestServiceException( "RepositoryScannerException exception: " + e.getMessage(), 500, e );
1135 }
1136 }
1137
1138
1139
1140
1141
1142
1143 private void updateMetadata( ArchivaRepositoryMetadata metadata, File metadataFile, Date lastUpdatedTimestamp,
1144 Artifact artifact )
1145 throws RepositoryMetadataException
1146 {
1147 List<String> availableVersions = new ArrayList<>();
1148 String latestVersion = "";
1149
1150 if ( metadataFile.exists() )
1151 {
1152 if ( metadata.getAvailableVersions() != null )
1153 {
1154 availableVersions = metadata.getAvailableVersions();
1155
1156 if ( availableVersions.size() > 0 )
1157 {
1158 Collections.sort( availableVersions, VersionComparator.getInstance() );
1159
1160 if ( availableVersions.contains( artifact.getVersion() ) )
1161 {
1162 availableVersions.remove( availableVersions.indexOf( artifact.getVersion() ) );
1163 }
1164 if ( availableVersions.size() > 0 )
1165 {
1166 latestVersion = availableVersions.get( availableVersions.size() - 1 );
1167 }
1168 }
1169 }
1170 }
1171
1172 if ( metadata.getGroupId() == null )
1173 {
1174 metadata.setGroupId( artifact.getGroupId() );
1175 }
1176 if ( metadata.getArtifactId() == null )
1177 {
1178 metadata.setArtifactId( artifact.getArtifactId() );
1179 }
1180
1181 if ( !VersionUtil.isSnapshot( artifact.getVersion() ) )
1182 {
1183 if ( metadata.getReleasedVersion() != null && metadata.getReleasedVersion().equals(
1184 artifact.getVersion() ) )
1185 {
1186 metadata.setReleasedVersion( latestVersion );
1187 }
1188 }
1189
1190 metadata.setLatestVersion( latestVersion );
1191 metadata.setLastUpdatedTimestamp( lastUpdatedTimestamp );
1192 metadata.setAvailableVersions( availableVersions );
1193
1194 RepositoryMetadataWriter.write( metadata, metadataFile );
1195 ChecksummedFile checksum = new ChecksummedFile( metadataFile );
1196 checksum.fixChecksums( algorithms );
1197 }
1198
1199 @Override
1200 public StringList getRunningRemoteDownloadIds()
1201 {
1202 return new StringList( downloadRemoteIndexScheduler.getRunningRemoteDownloadIds() );
1203 }
1204
1205 public ManagedRepositoryAdmin getManagedRepositoryAdmin()
1206 {
1207 return managedRepositoryAdmin;
1208 }
1209
1210 public void setManagedRepositoryAdmin( ManagedRepositoryAdmin managedRepositoryAdmin )
1211 {
1212 this.managedRepositoryAdmin = managedRepositoryAdmin;
1213 }
1214
1215 public RepositoryContentFactory getRepositoryFactory()
1216 {
1217 return repositoryFactory;
1218 }
1219
1220 public void setRepositoryFactory( RepositoryContentFactory repositoryFactory )
1221 {
1222 this.repositoryFactory = repositoryFactory;
1223 }
1224
1225 public RepositorySessionFactory getRepositorySessionFactory()
1226 {
1227 return repositorySessionFactory;
1228 }
1229
1230 public void setRepositorySessionFactory( RepositorySessionFactory repositorySessionFactory )
1231 {
1232 this.repositorySessionFactory = repositorySessionFactory;
1233 }
1234
1235 public List<RepositoryListener> getListeners()
1236 {
1237 return listeners;
1238 }
1239
1240 public void setListeners( List<RepositoryListener> listeners )
1241 {
1242 this.listeners = listeners;
1243 }
1244
1245 public ArchivaAdministration getArchivaAdministration()
1246 {
1247 return archivaAdministration;
1248 }
1249
1250 public void setArchivaAdministration( ArchivaAdministration archivaAdministration )
1251 {
1252 this.archivaAdministration = archivaAdministration;
1253 }
1254 }
1255
1256