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