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