source.dussan.org Git - archiva.git/blob

   1 package org.apache.archiva.rest.services;
   2 /*
   3  * Licensed to the Apache Software Foundation (ASF) under one
   4  * or more contributor license agreements.  See the NOTICE file
   5  * distributed with this work for additional information
   6  * regarding copyright ownership.  The ASF licenses this file
   7  * to you under the Apache License, Version 2.0 (the
   8  * "License"); you may not use this file except in compliance
   9  * with the License.  You may obtain a copy of the License at
  10  *
  11  *   http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing,
  14  * software distributed under the License is distributed on an
  15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  16  * KIND, either express or implied.  See the License for the
  17  * specific language governing permissions and limitations
  18  * under the License.
  19  */
  20
  21 import org.apache.archiva.common.utils.VersionUtil;
  22 import org.apache.archiva.maven2.model.Artifact;
  23 import org.apache.archiva.metadata.model.ArtifactMetadata;
  24 import org.apache.archiva.metadata.model.facets.AuditEvent;
  25 import org.apache.archiva.metadata.repository.MetadataRepository;
  26 import org.apache.archiva.metadata.repository.MetadataRepositoryException;
  27 import org.apache.archiva.metadata.repository.RepositorySession;
  28 import org.apache.archiva.filter.Filter;
  29 import org.apache.archiva.filter.IncludesFilter;
  30 import org.apache.archiva.repository.ReleaseScheme;
  31 import org.apache.archiva.repository.Repository;
  32 import org.apache.archiva.repository.RepositoryNotFoundException;
  33 import org.apache.archiva.repository.RepositoryRegistry;
  34 import org.apache.archiva.rest.api.services.ArchivaRestServiceException;
  35 import org.apache.archiva.rest.api.services.MergeRepositoriesService;
  36 import org.apache.archiva.stagerepository.merge.RepositoryMerger;
  37 import org.apache.archiva.stagerepository.merge.RepositoryMergerException;
  38 import org.springframework.stereotype.Service;
  39
  40 import javax.inject.Inject;
  41 import java.util.ArrayList;
  42 import java.util.List;
  43
  44 /**
  45  * @author Olivier Lamy
  46  * @since 1.4-M3
  47  */
  48 @Service ( "mergeRepositoriesService#rest" )
  49 public class DefaultMergeRepositoriesService
  50     extends AbstractRestService
  51     implements MergeRepositoriesService
  52 {
  53
  54     // FIXME check archiva-merge-repository to sourceRepoId
  55
  56     @Inject
  57     private List<RepositoryMerger> repositoryMerger;
  58
  59     @Inject
  60     private RepositoryRegistry repositoryRegistry;
  61
  62
  63     @Override
  64     public List<Artifact> getMergeConflictedArtifacts( String sourceRepositoryId, String targetRepositoryId )
  65         throws ArchivaRestServiceException
  66     {
  67         RepositorySession repositorySession = null;
  68         try
  69         {
  70             repositorySession = repositorySessionFactory.createSession();
  71         }
  72         catch ( MetadataRepositoryException e )
  73         {
  74             log.error( "Error while creating repository session {}", e.getMessage( ), e );
  75         }
  76         try
  77         {
  78             RepositoryMerger merger = findMerger( sourceRepositoryId );
  79             List<ArtifactMetadata> artifactMetadatas =
  80                 merger.getConflictingArtifacts( repositorySession.getRepository(), sourceRepositoryId,
  81                                                           targetRepositoryId );
  82
  83             return buildArtifacts( artifactMetadatas, sourceRepositoryId );
  84         }
  85         catch ( RepositoryMergerException | RepositoryNotFoundException e )
  86         {
  87             throw new ArchivaRestServiceException( e.getMessage(), e );
  88         }
  89         finally
  90         {
  91             repositorySession.close();
  92         }
  93     }
  94
  95     RepositoryMerger findMerger(String repositoryId) throws RepositoryNotFoundException
  96     {
  97         Repository repo = repositoryRegistry.getRepository( repositoryId );
  98         if (repo==null) {
  99             throw new RepositoryNotFoundException( repositoryId );
 100         } else {
 101             return repositoryMerger.stream( ).filter( m -> m.supportsRepository( repo.getType( ) ) ).findFirst().get();
 102         }
 103     }
 104
 105     @Override
 106     public void mergeRepositories( String sourceRepositoryId, String targetRepositoryId, boolean skipConflicts )
 107         throws ArchivaRestServiceException
 108     {
 109         try
 110         {
 111             RepositoryMerger merger = findMerger( sourceRepositoryId );
 112
 113             if ( skipConflicts )
 114             {
 115                 mergeBySkippingConflicts( merger,  sourceRepositoryId, targetRepositoryId );
 116             }
 117             else
 118             {
 119                 doMerge( merger, sourceRepositoryId, targetRepositoryId );
 120             }
 121
 122         }
 123         catch ( RepositoryMergerException | RepositoryNotFoundException e )
 124         {
 125             throw new ArchivaRestServiceException( e.getMessage(), e );
 126         }
 127
 128     }
 129
 130
 131     protected void doMerge( RepositoryMerger merger, String sourceRepositoryId, String targetRepositoryId )
 132         throws RepositoryMergerException, ArchivaRestServiceException
 133     {
 134         RepositorySession repositorySession = null;
 135         try
 136         {
 137             repositorySession = repositorySessionFactory.createSession();
 138         }
 139         catch ( MetadataRepositoryException e )
 140         {
 141             e.printStackTrace( );
 142         }
 143
 144         try
 145         {
 146             org.apache.archiva.repository.ManagedRepository managedRepo = repositoryRegistry.getManagedRepository(targetRepositoryId);
 147             MetadataRepository metadataRepository = repositorySession.getRepository();
 148             List<ArtifactMetadata> sourceArtifacts = metadataRepository.getArtifacts(repositorySession , sourceRepositoryId );
 149
 150             if ( managedRepo.getActiveReleaseSchemes().contains(ReleaseScheme.RELEASE) && !managedRepo.getActiveReleaseSchemes().contains(ReleaseScheme.SNAPSHOT) )
 151             {
 152                 mergeWithOutSnapshots(merger, metadataRepository, sourceArtifacts, sourceRepositoryId, targetRepositoryId );
 153             }
 154             else
 155             {
 156                 merger.merge( metadataRepository, sourceRepositoryId, targetRepositoryId );
 157
 158                 for ( ArtifactMetadata metadata : sourceArtifacts )
 159                 {
 160                     triggerAuditEvent( targetRepositoryId, metadata.getId(), AuditEvent.MERGING_REPOSITORIES );
 161                 }
 162             }
 163
 164             doScanRepository( targetRepositoryId, false );
 165         }
 166         catch ( MetadataRepositoryException e )
 167         {
 168             throw new ArchivaRestServiceException( e.getMessage(), e );
 169         } finally
 170         {
 171             repositorySession.close();
 172         }
 173     }
 174
 175     private void mergeBySkippingConflicts( RepositoryMerger merger, String sourceRepositoryId, String targetRepositoryId )
 176         throws RepositoryMergerException, ArchivaRestServiceException
 177     {
 178
 179         RepositorySession repositorySession = null;
 180         try
 181         {
 182             repositorySession = repositorySessionFactory.createSession();
 183         }
 184         catch ( MetadataRepositoryException e )
 185         {
 186             e.printStackTrace( );
 187         }
 188         try
 189         {
 190             List<ArtifactMetadata> conflictSourceArtifacts =
 191                 merger.getConflictingArtifacts( repositorySession.getRepository(), sourceRepositoryId,
 192                                                           targetRepositoryId );
 193             MetadataRepository metadataRepository = repositorySession.getRepository();
 194             List<ArtifactMetadata> sourceArtifacts = metadataRepository.getArtifacts(repositorySession , sourceRepositoryId );
 195             sourceArtifacts.removeAll( conflictSourceArtifacts );
 196
 197             org.apache.archiva.repository.ManagedRepository managedRepo = repositoryRegistry.getManagedRepository(targetRepositoryId);
 198
 199             if ( managedRepo.getActiveReleaseSchemes().contains(ReleaseScheme.RELEASE) && !managedRepo.getActiveReleaseSchemes().contains(ReleaseScheme.SNAPSHOT))
 200             {
 201                 mergeWithOutSnapshots( merger, metadataRepository, sourceArtifacts, sourceRepositoryId, targetRepositoryId );
 202             }
 203             else
 204             {
 205
 206                 Filter<ArtifactMetadata> artifactsWithOutConflicts =
 207                     new IncludesFilter<ArtifactMetadata>( sourceArtifacts );
 208                 merger.merge( metadataRepository, sourceRepositoryId, targetRepositoryId,
 209                                         artifactsWithOutConflicts );
 210                 for ( ArtifactMetadata metadata : sourceArtifacts )
 211                 {
 212                     triggerAuditEvent( targetRepositoryId, metadata.getId(), AuditEvent.MERGING_REPOSITORIES );
 213                 }
 214             }
 215
 216             doScanRepository( targetRepositoryId, false );
 217         }
 218         catch ( MetadataRepositoryException e )
 219         {
 220             throw new ArchivaRestServiceException( e.getMessage(), e );
 221         } finally
 222         {
 223             repositorySession.close();
 224         }
 225     }
 226
 227     private void mergeWithOutSnapshots( RepositoryMerger merger, MetadataRepository metadataRepository, List<ArtifactMetadata> sourceArtifacts,
 228                                         String sourceRepoId, String repoid )
 229         throws RepositoryMergerException
 230     {
 231         List<ArtifactMetadata> artifactsWithOutSnapshots = new ArrayList<>();
 232         for ( ArtifactMetadata metadata : sourceArtifacts )
 233         {
 234             if ( VersionUtil.isSnapshot( metadata.getProjectVersion() ) )
 235             //if ( metadata.getProjectVersion().contains( VersionUtil.SNAPSHOT ) )
 236             {
 237                 artifactsWithOutSnapshots.add( metadata );
 238             }
 239             else
 240             {
 241                 triggerAuditEvent( repoid, metadata.getId(), AuditEvent.MERGING_REPOSITORIES );
 242             }
 243
 244         }
 245         sourceArtifacts.removeAll( artifactsWithOutSnapshots );
 246
 247         Filter<ArtifactMetadata> artifactListWithOutSnapShots = new IncludesFilter<ArtifactMetadata>( sourceArtifacts );
 248         merger.merge( metadataRepository, sourceRepoId, repoid, artifactListWithOutSnapShots );
 249     }
 250 }