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.admin.model.RepositoryAdminException;
  22 import org.apache.archiva.admin.model.beans.ManagedRepository;
  23 import org.apache.archiva.audit.AuditEvent;
  24 import org.apache.archiva.common.utils.VersionUtil;
  25 import org.apache.archiva.maven2.model.Artifact;
  26 import org.apache.archiva.metadata.model.ArtifactMetadata;
  27 import org.apache.archiva.metadata.repository.MetadataRepository;
  28 import org.apache.archiva.metadata.repository.MetadataRepositoryException;
  29 import org.apache.archiva.metadata.repository.RepositorySession;
  30 import org.apache.archiva.metadata.repository.filter.Filter;
  31 import org.apache.archiva.metadata.repository.filter.IncludesFilter;
  32 import org.apache.archiva.rest.api.services.ArchivaRestServiceException;
  33 import org.apache.archiva.rest.api.services.MergeRepositoriesService;
  34 import org.apache.archiva.stagerepository.merge.Maven2RepositoryMerger;
  35 import org.apache.archiva.stagerepository.merge.RepositoryMergerException;
  36 import org.springframework.stereotype.Service;
  37
  38 import javax.inject.Inject;
  39 import javax.inject.Named;
  40 import java.util.ArrayList;
  41 import java.util.List;
  42
  43 /**
  44  * @author Olivier Lamy
  45  * @since 1.4-M3
  46  */
  47 @Service ( "mergeRepositoriesService#rest" )
  48 public class DefaultMergeRepositoriesService
  49     extends AbstractRestService
  50     implements MergeRepositoriesService
  51 {
  52
  53     @Inject
  54     @Named ( value = "repositoryMerger#maven2" )
  55     private Maven2RepositoryMerger repositoryMerger;
  56
  57
  58     public List<Artifact> getMergeConflictedArtifacts( String sourceRepositoryId, String targetRepositoryId )
  59         throws ArchivaRestServiceException
  60     {
  61         RepositorySession repositorySession = repositorySessionFactory.createSession();
  62         try
  63         {
  64             List<ArtifactMetadata> artifactMetadatas =
  65                 repositoryMerger.getConflictingArtifacts( repositorySession.getRepository(), sourceRepositoryId,
  66                                                           targetRepositoryId );
  67
  68             return buildArtifacts( artifactMetadatas, sourceRepositoryId );
  69         }
  70         catch ( RepositoryMergerException e )
  71         {
  72             throw new ArchivaRestServiceException( e.getMessage(), e );
  73         }
  74         finally
  75         {
  76             repositorySession.close();
  77         }
  78     }
  79
  80     public void mergeRepositories( String sourceRepositoryId, String targetRepositoryId, boolean skipConflicts )
  81         throws ArchivaRestServiceException
  82     {
  83         try
  84         {
  85             if ( skipConflicts )
  86             {
  87                 mergeBySkippingConflicts( sourceRepositoryId, targetRepositoryId );
  88             }
  89             else
  90             {
  91                 doMerge( sourceRepositoryId, targetRepositoryId );
  92             }
  93
  94         }
  95         catch ( RepositoryMergerException e )
  96         {
  97             throw new ArchivaRestServiceException( e.getMessage(), e );
  98         }
  99
 100     }
 101
 102
 103     protected void doMerge( String sourceRepositoryId, String targetRepositoryId )
 104         throws RepositoryMergerException, ArchivaRestServiceException
 105     {
 106         RepositorySession repositorySession = repositorySessionFactory.createSession();
 107
 108         try
 109         {
 110             ManagedRepository repository = managedRepositoryAdmin.getManagedRepository( targetRepositoryId );
 111             MetadataRepository metadataRepository = repositorySession.getRepository();
 112             List<ArtifactMetadata> sourceArtifacts = metadataRepository.getArtifacts( sourceRepositoryId );
 113
 114             if ( repository.isReleases() && !repository.isSnapshots() )
 115             {
 116                 mergeWithOutSnapshots( metadataRepository, sourceArtifacts, sourceRepositoryId, targetRepositoryId );
 117             }
 118             else
 119             {
 120                 repositoryMerger.merge( metadataRepository, sourceRepositoryId, targetRepositoryId );
 121
 122                 for ( ArtifactMetadata metadata : sourceArtifacts )
 123                 {
 124                     triggerAuditEvent( targetRepositoryId, metadata.getId(), AuditEvent.MERGING_REPOSITORIES );
 125                 }
 126             }
 127
 128             doScanRepository( targetRepositoryId, false );
 129         }
 130         catch ( MetadataRepositoryException e )
 131         {
 132             throw new ArchivaRestServiceException( e.getMessage(), e );
 133         }
 134         catch ( RepositoryAdminException e )
 135         {
 136             throw new ArchivaRestServiceException( e.getMessage(), e );
 137         }
 138         finally
 139         {
 140             repositorySession.close();
 141         }
 142     }
 143
 144     public void mergeBySkippingConflicts( String sourceRepositoryId, String targetRepositoryId )
 145         throws RepositoryMergerException, ArchivaRestServiceException
 146     {
 147
 148         RepositorySession repositorySession = repositorySessionFactory.createSession();
 149         try
 150         {
 151             List<ArtifactMetadata> conflictSourceArtifacts =
 152                 repositoryMerger.getConflictingArtifacts( repositorySession.getRepository(), sourceRepositoryId,
 153                                                           targetRepositoryId );
 154             MetadataRepository metadataRepository = repositorySession.getRepository();
 155             List<ArtifactMetadata> sourceArtifacts = metadataRepository.getArtifacts( sourceRepositoryId );
 156             sourceArtifacts.removeAll( conflictSourceArtifacts );
 157
 158             ManagedRepository repository = managedRepositoryAdmin.getManagedRepository( targetRepositoryId );
 159
 160             if ( repository.isReleases() && !repository.isSnapshots() )
 161             {
 162                 mergeWithOutSnapshots( metadataRepository, sourceArtifacts, sourceRepositoryId, targetRepositoryId );
 163             }
 164             else
 165             {
 166
 167                 Filter<ArtifactMetadata> artifactsWithOutConflicts =
 168                     new IncludesFilter<ArtifactMetadata>( sourceArtifacts );
 169                 repositoryMerger.merge( metadataRepository, sourceRepositoryId, targetRepositoryId,
 170                                         artifactsWithOutConflicts );
 171                 for ( ArtifactMetadata metadata : sourceArtifacts )
 172                 {
 173                     triggerAuditEvent( targetRepositoryId, metadata.getId(), AuditEvent.MERGING_REPOSITORIES );
 174                 }
 175             }
 176
 177             doScanRepository( targetRepositoryId, false );
 178         }
 179         catch ( MetadataRepositoryException e )
 180         {
 181             throw new ArchivaRestServiceException( e.getMessage(), e );
 182         }
 183         catch ( RepositoryAdminException e )
 184         {
 185             throw new ArchivaRestServiceException( e.getMessage(), e );
 186
 187         }
 188         finally
 189         {
 190             repositorySession.close();
 191         }
 192     }
 193
 194     private void mergeWithOutSnapshots( MetadataRepository metadataRepository, List<ArtifactMetadata> sourceArtifacts,
 195                                         String sourceRepoId, String repoid )
 196         throws RepositoryMergerException
 197     {
 198         List<ArtifactMetadata> artifactsWithOutSnapshots = new ArrayList<ArtifactMetadata>();
 199         for ( ArtifactMetadata metadata : sourceArtifacts )
 200         {
 201             if ( VersionUtil.isSnapshot( metadata.getProjectVersion() ) )
 202             //if ( metadata.getProjectVersion().contains( VersionUtil.SNAPSHOT ) )
 203             {
 204                 artifactsWithOutSnapshots.add( metadata );
 205             }
 206             else
 207             {
 208                 triggerAuditEvent( repoid, metadata.getId(), AuditEvent.MERGING_REPOSITORIES );
 209             }
 210
 211         }
 212         sourceArtifacts.removeAll( artifactsWithOutSnapshots );
 213
 214         Filter<ArtifactMetadata> artifactListWithOutSnapShots = new IncludesFilter<ArtifactMetadata>( sourceArtifacts );
 215         repositoryMerger.merge( metadataRepository, sourceRepoId, repoid, artifactListWithOutSnapShots );
 216     }
 217 }