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

   1 package org.apache.maven.archiva.web.action;
   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 com.opensymphony.xwork2.Preparable;
  23 import com.opensymphony.xwork2.Validateable;
  24 import org.apache.archiva.audit.AuditEvent;
  25 import org.apache.archiva.audit.Auditable;
  26 import org.apache.archiva.metadata.model.ArtifactMetadata;
  27 import org.apache.archiva.metadata.repository.MetadataRepository;
  28 import org.apache.archiva.metadata.repository.RepositorySession;
  29 import org.apache.archiva.metadata.repository.filter.Filter;
  30 import org.apache.archiva.metadata.repository.filter.IncludesFilter;
  31 import org.apache.archiva.scheduler.repository.RepositoryArchivaTaskScheduler;
  32 import org.apache.archiva.scheduler.repository.RepositoryTask;
  33 import org.apache.archiva.stagerepository.merge.Maven2RepositoryMerger;
  34 import org.apache.maven.archiva.configuration.ArchivaConfiguration;
  35 import org.apache.maven.archiva.configuration.Configuration;
  36 import org.apache.maven.archiva.configuration.ManagedRepositoryConfiguration;
  37 import org.codehaus.plexus.taskqueue.TaskQueueException;
  38 import org.springframework.context.annotation.Scope;
  39 import org.springframework.stereotype.Controller;
  40
  41 import java.util.ArrayList;
  42 import java.util.HashMap;
  43 import java.util.List;
  44 import javax.inject.Inject;
  45 import javax.inject.Named;
  46
  47 /**
  48  *
  49  */
  50 @Controller( "mergeAction" )
  51 @Scope( "prototype" )
  52 public class MergeAction
  53     extends AbstractActionSupport
  54     implements Validateable, Preparable, Auditable
  55
  56 {
  57
  58     @Inject
  59     @Named( value = "repositoryMerger#maven2" )
  60     private Maven2RepositoryMerger repositoryMerger;
  61
  62     @Inject
  63     protected ArchivaConfiguration archivaConfiguration;
  64
  65     @Inject
  66     @Named( value = "archivaTaskScheduler#repository" )
  67     private RepositoryArchivaTaskScheduler repositoryTaskScheduler;
  68
  69     private ManagedRepositoryConfiguration repository;
  70
  71     private String repoid;
  72
  73     private String sourceRepoId;
  74
  75     private final String action = "merge";
  76
  77     private final String hasConflicts = "CONFLICTS";
  78
  79     private List<ArtifactMetadata> conflictSourceArtifacts;
  80
  81     private List<ArtifactMetadata> conflictSourceArtifactsToBeDisplayed;
  82
  83     public String getConflicts()
  84     {
  85         sourceRepoId = repoid + "-stage";
  86         Configuration config = archivaConfiguration.getConfiguration();
  87         ManagedRepositoryConfiguration targetRepoConfig = config.findManagedRepositoryById( sourceRepoId );
  88
  89         if ( targetRepoConfig != null )
  90         {
  91             return hasConflicts;
  92
  93         }
  94         else
  95         {
  96             return ERROR;
  97         }
  98     }
  99
 100     public String doMerge()
 101     {
 102         RepositorySession repositorySession = repositorySessionFactory.createSession();
 103         try
 104         {
 105             MetadataRepository metadataRepository = repositorySession.getRepository();
 106             List<ArtifactMetadata> sourceArtifacts = metadataRepository.getArtifacts( sourceRepoId );
 107
 108             if ( repository.isReleases() && !repository.isSnapshots() )
 109             {
 110                 mergeWithOutSnapshots( metadataRepository, sourceArtifacts, sourceRepoId, repoid );
 111             }
 112             else
 113             {
 114                 repositoryMerger.merge( metadataRepository, sourceRepoId, repoid );
 115
 116                 for ( ArtifactMetadata metadata : sourceArtifacts )
 117                 {
 118                     triggerAuditEvent( repoid, metadata.getId(), AuditEvent.MERGING_REPOSITORIES );
 119                 }
 120             }
 121
 122             scanRepository();
 123
 124             addActionMessage( "Repository '" + sourceRepoId + "' successfully merged to '" + repoid + "'." );
 125
 126             return SUCCESS;
 127         }
 128         catch ( Exception e )
 129         {
 130             log.error( e.getMessage(), e );
 131             addActionError( "Error occurred while merging the repositories: " + e.getMessage() );
 132             return ERROR;
 133         }
 134         finally
 135         {
 136             repositorySession.close();
 137         }
 138     }
 139
 140     public String mergeBySkippingConflicts()
 141     {
 142         RepositorySession repositorySession = repositorySessionFactory.createSession();
 143         try
 144         {
 145             MetadataRepository metadataRepository = repositorySession.getRepository();
 146             List<ArtifactMetadata> sourceArtifacts = metadataRepository.getArtifacts( sourceRepoId );
 147             sourceArtifacts.removeAll( conflictSourceArtifacts );
 148
 149             if ( repository.isReleases() && !repository.isSnapshots() )
 150             {
 151                 mergeWithOutSnapshots( metadataRepository, sourceArtifacts, sourceRepoId, repoid );
 152             }
 153             else
 154             {
 155
 156                 Filter<ArtifactMetadata> artifactsWithOutConflicts =
 157                     new IncludesFilter<ArtifactMetadata>( sourceArtifacts );
 158                 repositoryMerger.merge( metadataRepository, sourceRepoId, repoid, artifactsWithOutConflicts );
 159                 for ( ArtifactMetadata metadata : sourceArtifacts )
 160                 {
 161                     triggerAuditEvent( repoid, metadata.getId(), AuditEvent.MERGING_REPOSITORIES );
 162                 }
 163             }
 164
 165             scanRepository();
 166
 167             addActionMessage( "Repository '" + sourceRepoId + "' successfully merged to '" + repoid + "'." );
 168
 169             return SUCCESS;
 170         }
 171         catch ( Exception e )
 172         {
 173             log.error( e.getMessage(), e );
 174             addActionError( "Error occurred while merging the repositories: " + e.getMessage() );
 175             return ERROR;
 176         }
 177         finally
 178         {
 179             repositorySession.close();
 180         }
 181     }
 182
 183     public String mergeWithOutConlficts()
 184     {
 185         sourceRepoId = repoid + "-stage";
 186
 187         RepositorySession repositorySession = repositorySessionFactory.createSession();
 188         try
 189         {
 190             conflictSourceArtifacts =
 191                 repositoryMerger.getConflictingArtifacts( repositorySession.getRepository(), sourceRepoId, repoid );
 192         }
 193         catch ( Exception e )
 194         {
 195             addActionError( "Error occurred while merging the repositories." );
 196             return ERROR;
 197         }
 198         finally
 199         {
 200             repositorySession.close();
 201         }
 202
 203         addActionMessage( "Repository '" + sourceRepoId + "' successfully merged to '" + repoid + "'." );
 204
 205         return SUCCESS;
 206     }
 207
 208     public ManagedRepositoryConfiguration getRepository()
 209     {
 210         return repository;
 211     }
 212
 213     public void setRepository( ManagedRepositoryConfiguration repository )
 214     {
 215         this.repository = repository;
 216     }
 217
 218     public void prepare()
 219         throws Exception
 220     {
 221         sourceRepoId = repoid + "-stage";
 222         RepositorySession repositorySession = repositorySessionFactory.createSession();
 223         try
 224         {
 225             conflictSourceArtifacts =
 226                 repositoryMerger.getConflictingArtifacts( repositorySession.getRepository(), sourceRepoId, repoid );
 227         }
 228         finally
 229         {
 230             repositorySession.close();
 231         }
 232
 233         Configuration config = archivaConfiguration.getConfiguration();
 234         this.repository = config.findManagedRepositoryById( repoid );
 235         setConflictSourceArtifactsToBeDisplayed( conflictSourceArtifacts );
 236     }
 237
 238     public String getSourceRepoId()
 239     {
 240         return sourceRepoId;
 241     }
 242
 243     public void setSourceRepoId( String sourceRepoId )
 244     {
 245         this.sourceRepoId = sourceRepoId;
 246     }
 247
 248     public String getRepoid()
 249     {
 250         return repoid;
 251     }
 252
 253     public void setRepoid( String repoid )
 254     {
 255         this.repoid = repoid;
 256     }
 257
 258     public List<ArtifactMetadata> getConflictSourceArtifacts()
 259     {
 260         return conflictSourceArtifacts;
 261     }
 262
 263     public void setConflictSourceArtifacts( List<ArtifactMetadata> conflictSourceArtifacts )
 264     {
 265         this.conflictSourceArtifacts = conflictSourceArtifacts;
 266     }
 267
 268     public List<ArtifactMetadata> getConflictSourceArtifactsToBeDisplayed()
 269     {
 270         return conflictSourceArtifactsToBeDisplayed;
 271     }
 272
 273     public void setConflictSourceArtifactsToBeDisplayed( List<ArtifactMetadata> conflictSourceArtifacts )
 274         throws Exception
 275     {
 276         this.conflictSourceArtifactsToBeDisplayed = new ArrayList<ArtifactMetadata>();
 277         HashMap<String, ArtifactMetadata> map = new HashMap<String, ArtifactMetadata>();
 278         for ( ArtifactMetadata metadata : conflictSourceArtifacts )
 279         {
 280             String metadataId =
 281                 metadata.getNamespace() + metadata.getProject() + metadata.getProjectVersion() + metadata.getVersion();
 282             map.put( metadataId, metadata );
 283         }
 284         conflictSourceArtifactsToBeDisplayed.addAll( map.values() );
 285     }
 286
 287     private void mergeWithOutSnapshots( MetadataRepository metadataRepository, List<ArtifactMetadata> sourceArtifacts,
 288                                         String sourceRepoId, String repoid )
 289         throws Exception
 290     {
 291         List<ArtifactMetadata> artifactsWithOutSnapshots = new ArrayList<ArtifactMetadata>();
 292         for ( ArtifactMetadata metadata : sourceArtifacts )
 293         {
 294
 295             if ( metadata.getProjectVersion().contains( "SNAPSHOT" ) )
 296             {
 297                 artifactsWithOutSnapshots.add( metadata );
 298             }
 299             else
 300             {
 301                 triggerAuditEvent( repoid, metadata.getId(), AuditEvent.MERGING_REPOSITORIES );
 302             }
 303
 304         }
 305         sourceArtifacts.removeAll( artifactsWithOutSnapshots );
 306
 307         Filter<ArtifactMetadata> artifactListWithOutSnapShots = new IncludesFilter<ArtifactMetadata>( sourceArtifacts );
 308         repositoryMerger.merge( metadataRepository, sourceRepoId, repoid, artifactListWithOutSnapShots );
 309     }
 310
 311     private void scanRepository()
 312     {
 313         RepositoryTask task = new RepositoryTask();
 314         task.setRepositoryId( repoid );
 315         task.setScanAll( true );
 316
 317         if ( repositoryTaskScheduler.isProcessingRepositoryTask( repoid ) )
 318         {
 319             log.info( "Repository [" + repoid + "] task was already queued." );
 320         }
 321         else
 322         {
 323             try
 324             {
 325                 log.info( "Your request to have repository [" + repoid + "] be indexed has been queued." );
 326                 repositoryTaskScheduler.queueTask( task );
 327             }
 328             catch ( TaskQueueException e )
 329             {
 330                 log.warn(
 331                     "Unable to queue your request to have repository [" + repoid + "] be indexed: " + e.getMessage() );
 332             }
 333         }
 334     }
 335 }