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

   1 package org.apache.archiva.admin.repository.managed;
   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.AuditInformation;
  22 import org.apache.archiva.admin.model.RepositoryAdminException;
  23 import org.apache.archiva.admin.model.beans.ManagedRepository;
  24 import org.apache.archiva.admin.model.managed.ManagedRepositoryAdmin;
  25 import org.apache.archiva.admin.repository.AbstractRepositoryAdmin;
  26 import org.apache.archiva.audit.AuditEvent;
  27 import org.apache.archiva.common.plexusbridge.MavenIndexerUtils;
  28 import org.apache.archiva.common.plexusbridge.PlexusSisuBridge;
  29 import org.apache.archiva.common.plexusbridge.PlexusSisuBridgeException;
  30 import org.apache.archiva.configuration.Configuration;
  31 import org.apache.archiva.configuration.ManagedRepositoryConfiguration;
  32 import org.apache.archiva.configuration.ProxyConnectorConfiguration;
  33 import org.apache.archiva.configuration.RepositoryGroupConfiguration;
  34 import org.apache.archiva.metadata.repository.MetadataRepository;
  35 import org.apache.archiva.metadata.repository.MetadataRepositoryException;
  36 import org.apache.archiva.metadata.repository.RepositorySession;
  37 import org.apache.archiva.metadata.repository.RepositorySessionFactory;
  38 import org.apache.archiva.metadata.repository.stats.RepositoryStatisticsManager;
  39 import org.apache.archiva.scheduler.repository.RepositoryArchivaTaskScheduler;
  40 import org.apache.archiva.scheduler.repository.RepositoryTask;
  41 import org.apache.archiva.security.common.ArchivaRoleConstants;
  42 import org.apache.commons.io.FileUtils;
  43 import org.apache.commons.lang.StringUtils;
  44 import org.apache.commons.validator.GenericValidator;
  45 import org.apache.maven.index.NexusIndexer;
  46 import org.apache.maven.index.context.IndexCreator;
  47 import org.apache.maven.index.context.IndexingContext;
  48 import org.apache.maven.index.context.UnsupportedExistingLuceneIndexException;
  49 import org.codehaus.plexus.redback.role.RoleManager;
  50 import org.codehaus.plexus.redback.role.RoleManagerException;
  51 import org.codehaus.plexus.taskqueue.TaskQueueException;
  52 import org.codehaus.redback.components.scheduler.CronExpressionValidator;
  53 import org.slf4j.Logger;
  54 import org.slf4j.LoggerFactory;
  55 import org.springframework.stereotype.Service;
  56
  57 import javax.annotation.PostConstruct;
  58 import javax.annotation.PreDestroy;
  59 import javax.inject.Inject;
  60 import javax.inject.Named;
  61 import java.io.File;
  62 import java.io.IOException;
  63 import java.net.MalformedURLException;
  64 import java.util.ArrayList;
  65 import java.util.Arrays;
  66 import java.util.Collections;
  67 import java.util.HashMap;
  68 import java.util.List;
  69 import java.util.Map;
  70
  71 /**
  72  * FIXME remove all generic Exception to have usefull ones
  73  * FIXME review the staging mechanism to have a per user session one
  74  *
  75  * @author Olivier Lamy
  76  */
  77 @Service( "managedRepositoryAdmin#default" )
  78 public class DefaultManagedRepositoryAdmin
  79     extends AbstractRepositoryAdmin
  80     implements ManagedRepositoryAdmin
  81 {
  82
  83     public static final String REPOSITORY_LOCATION_VALID_EXPRESSION = "^[-a-zA-Z0-9._/~:?!&amp;=\\\\]+$";
  84
  85     private Logger log = LoggerFactory.getLogger( getClass() );
  86
  87     public static final String STAGE_REPO_ID_END = "-stage";
  88
  89
  90     @Inject
  91     @Named( value = "archivaTaskScheduler#repository" )
  92     private RepositoryArchivaTaskScheduler repositoryTaskScheduler;
  93
  94     @Inject
  95     private RepositorySessionFactory repositorySessionFactory;
  96
  97     @Inject
  98     private RepositoryStatisticsManager repositoryStatisticsManager;
  99
 100     @Inject
 101     private PlexusSisuBridge plexusSisuBridge;
 102
 103     @Inject
 104     private MavenIndexerUtils mavenIndexerUtils;
 105
 106     @Inject
 107     protected RoleManager roleManager;
 108
 109     // fields
 110     List<? extends IndexCreator> indexCreators;
 111
 112     NexusIndexer indexer;
 113
 114     @PostConstruct
 115     public void initialize()
 116         throws RepositoryAdminException
 117     {
 118         try
 119         {
 120             indexCreators = mavenIndexerUtils.getAllIndexCreators();
 121             indexer = plexusSisuBridge.lookup( NexusIndexer.class );
 122         }
 123         catch ( PlexusSisuBridgeException e )
 124         {
 125             throw new RepositoryAdminException( e.getMessage(), e );
 126         }
 127         // initialize index context on start
 128         for ( ManagedRepository managedRepository : getManagedRepositories() )
 129         {
 130             createIndexContext( managedRepository );
 131         }
 132     }
 133
 134     @PreDestroy
 135     public void shutdown()
 136         throws RepositoryAdminException
 137     {
 138         try
 139         {
 140             // close index on shutdown
 141             for ( ManagedRepository managedRepository : getManagedRepositories() )
 142             {
 143                 IndexingContext context = indexer.getIndexingContexts().get( managedRepository.getId() );
 144                 if ( context != null )
 145                 {
 146                     indexer.removeIndexingContext( context, false );
 147                 }
 148             }
 149         }
 150         catch ( IOException e )
 151         {
 152             throw new RepositoryAdminException( e.getMessage(), e );
 153         }
 154     }
 155
 156     public List<ManagedRepository> getManagedRepositories()
 157         throws RepositoryAdminException
 158     {
 159         List<ManagedRepositoryConfiguration> managedRepoConfigs =
 160             getArchivaConfiguration().getConfiguration().getManagedRepositories();
 161
 162         if ( managedRepoConfigs == null )
 163         {
 164             return Collections.emptyList();
 165         }
 166
 167         List<ManagedRepository> managedRepos = new ArrayList<ManagedRepository>( managedRepoConfigs.size() );
 168
 169         for ( ManagedRepositoryConfiguration repoConfig : managedRepoConfigs )
 170         {
 171             // TODO add staging repo information back too
 172             ManagedRepository repo =
 173                 new ManagedRepository( repoConfig.getId(), repoConfig.getName(), repoConfig.getLocation(),
 174                                        repoConfig.getLayout(), repoConfig.isSnapshots(), repoConfig.isReleases(),
 175                                        repoConfig.isBlockRedeployments(), repoConfig.getRefreshCronExpression(),
 176                                        repoConfig.getIndexDir(), repoConfig.isScanned(), repoConfig.getDaysOlder(),
 177                                        repoConfig.getRetentionCount(), repoConfig.isDeleteReleasedSnapshots(), false );
 178
 179             managedRepos.add( repo );
 180         }
 181
 182         return managedRepos;
 183     }
 184
 185     public Map<String, ManagedRepository> getManagedRepositoriesAsMap()
 186         throws RepositoryAdminException
 187     {
 188         List<ManagedRepository> managedRepositories = getManagedRepositories();
 189         Map<String, ManagedRepository> repositoriesMap =
 190             new HashMap<String, ManagedRepository>( managedRepositories.size() );
 191         for ( ManagedRepository managedRepository : managedRepositories )
 192         {
 193             repositoriesMap.put( managedRepository.getId(), managedRepository );
 194         }
 195         return repositoriesMap;
 196     }
 197
 198     public ManagedRepository getManagedRepository( String repositoryId )
 199         throws RepositoryAdminException
 200     {
 201         List<ManagedRepository> repos = getManagedRepositories();
 202         for ( ManagedRepository repo : repos )
 203         {
 204             if ( StringUtils.equals( repo.getId(), repositoryId ) )
 205             {
 206                 return repo;
 207             }
 208         }
 209         return null;
 210     }
 211
 212     public Boolean addManagedRepository( ManagedRepository managedRepository, boolean needStageRepo,
 213                                          AuditInformation auditInformation )
 214         throws RepositoryAdminException
 215     {
 216
 217         getRepositoryCommonValidator().basicValidation( managedRepository, false );
 218         triggerAuditEvent( managedRepository.getId(), null, AuditEvent.ADD_MANAGED_REPO, auditInformation );
 219         Boolean res =
 220             addManagedRepository( managedRepository.getId(), managedRepository.getLayout(), managedRepository.getName(),
 221                                   managedRepository.getLocation(), managedRepository.isBlockRedeployments(),
 222                                   managedRepository.isReleases(), managedRepository.isSnapshots(), needStageRepo,
 223                                   managedRepository.getCronExpression(), managedRepository.getIndexDirectory(),
 224                                   managedRepository.getDaysOlder(), managedRepository.getRetentionCount(),
 225                                   managedRepository.isDeleteReleasedSnapshots(), auditInformation,
 226                                   getArchivaConfiguration().getConfiguration() ) != null;
 227
 228         createIndexContext( managedRepository );
 229         return res;
 230
 231     }
 232
 233     private ManagedRepositoryConfiguration addManagedRepository( String repoId, String layout, String name,
 234                                                                  String location, boolean blockRedeployments,
 235                                                                  boolean releasesIncluded, boolean snapshotsIncluded,
 236                                                                  boolean stageRepoNeeded, String cronExpression,
 237                                                                  String indexDir, int daysOlder, int retentionCount,
 238                                                                  boolean deteleReleasedSnapshots,
 239                                                                  AuditInformation auditInformation,
 240                                                                  Configuration config )
 241         throws RepositoryAdminException
 242     {
 243
 244         // FIXME : olamy can be empty to avoid scheduled scan ?
 245         if ( StringUtils.isNotBlank( cronExpression ) )
 246         {
 247             CronExpressionValidator validator = new CronExpressionValidator();
 248
 249             if ( !validator.validate( cronExpression ) )
 250             {
 251                 throw new RepositoryAdminException( "Invalid cron expression." );
 252             }
 253         }
 254         else
 255         {
 256             throw new RepositoryAdminException( "Cron expression cannot be empty." );
 257         }
 258
 259         String repoLocation = getRepositoryCommonValidator().removeExpressions( location );
 260
 261         if ( !GenericValidator.matchRegexp( repoLocation, REPOSITORY_LOCATION_VALID_EXPRESSION ) )
 262         {
 263             throw new RepositoryAdminException(
 264                 "Invalid repository location. Directory must only contain alphanumeric characters, equals(=), question-marks(?), "
 265                     + "exclamation-points(!), ampersands(&amp;), forward-slashes(/), back-slashes(\\), underscores(_), dots(.), colons(:), tildes(~), and dashes(-)." );
 266         }
 267
 268         ManagedRepositoryConfiguration repository = new ManagedRepositoryConfiguration();
 269
 270         repository.setId( repoId );
 271         repository.setBlockRedeployments( blockRedeployments );
 272         repository.setReleases( releasesIncluded );
 273         repository.setSnapshots( snapshotsIncluded );
 274         repository.setName( name );
 275         repository.setLocation( repoLocation );
 276         repository.setLayout( layout );
 277         repository.setRefreshCronExpression( cronExpression );
 278         repository.setIndexDir( indexDir );
 279         repository.setDaysOlder( daysOlder );
 280         repository.setRetentionCount( retentionCount );
 281         repository.setDeleteReleasedSnapshots( deteleReleasedSnapshots );
 282         repository.setIndexDir( indexDir );
 283
 284         try
 285         {
 286             addRepository( repository, config );
 287             addRepositoryRoles( repository );
 288
 289             if ( stageRepoNeeded )
 290             {
 291                 ManagedRepositoryConfiguration stagingRepository = getStageRepoConfig( repository );
 292                 addRepository( stagingRepository, config );
 293                 addRepositoryRoles( stagingRepository );
 294                 triggerAuditEvent( stagingRepository.getId(), null, AuditEvent.ADD_MANAGED_REPO, auditInformation );
 295             }
 296         }
 297         catch ( RoleManagerException e )
 298         {
 299             throw new RepositoryAdminException( "failed to add repository roles " + e.getMessage(), e );
 300         }
 301         catch ( IOException e )
 302         {
 303             throw new RepositoryAdminException( "failed to add repository " + e.getMessage(), e );
 304         }
 305
 306         saveConfiguration( config );
 307
 308         //MRM-1342 Repository statistics report doesn't appear to be working correctly
 309         //scan repository when adding of repository is successful
 310         try
 311         {
 312             scanRepository( repoId, true );
 313             // olamy no need of scanning staged repo
 314             /*
 315             if ( stageRepoNeeded )
 316             {
 317                 ManagedRepositoryConfiguration stagingRepository = getStageRepoConfig( repository );
 318                 scanRepository( stagingRepository.getId(), true );
 319             }*/
 320         }
 321         catch ( Exception e )
 322         {
 323             log.warn( new StringBuilder( "Unable to scan repository [" ).append( repoId ).append( "]: " ).append(
 324                 e.getMessage() ).toString(), e );
 325         }
 326
 327         return repository;
 328     }
 329
 330     public Boolean deleteManagedRepository( String repositoryId, AuditInformation auditInformation,
 331                                             boolean deleteContent )
 332         throws RepositoryAdminException
 333     {
 334         Configuration config = getArchivaConfiguration().getConfiguration();
 335
 336         ManagedRepositoryConfiguration repository = config.findManagedRepositoryById( repositoryId );
 337
 338         if ( repository == null )
 339         {
 340             throw new RepositoryAdminException( "A repository with that id does not exist" );
 341         }
 342
 343         triggerAuditEvent( repositoryId, null, AuditEvent.DELETE_MANAGED_REPO, auditInformation );
 344
 345         deleteManagedRepository( repository, deleteContent, config, false );
 346
 347         // stage repo exists ?
 348         ManagedRepositoryConfiguration stagingRepository =
 349             getArchivaConfiguration().getConfiguration().findManagedRepositoryById( repositoryId + STAGE_REPO_ID_END );
 350         if ( stagingRepository != null )
 351         {
 352             // do not trigger event when deleting the staged one
 353             deleteManagedRepository( stagingRepository, deleteContent, config, true );
 354         }
 355
 356         try
 357         {
 358             saveConfiguration( config );
 359         }
 360         catch ( Exception e )
 361         {
 362             throw new RepositoryAdminException( "Error saving configuration for delete action" + e.getMessage() );
 363         }
 364
 365         return Boolean.TRUE;
 366     }
 367
 368     private Boolean deleteManagedRepository( ManagedRepositoryConfiguration repository, boolean deleteContent,
 369                                              Configuration config, boolean stagedOne )
 370         throws RepositoryAdminException
 371     {
 372
 373         try
 374         {
 375             NexusIndexer nexusIndexer = plexusSisuBridge.lookup( NexusIndexer.class );
 376
 377             IndexingContext context = nexusIndexer.getIndexingContexts().get( repository.getId() );
 378             if ( context != null )
 379             {
 380                 // delete content only if directory exists
 381                 nexusIndexer.removeIndexingContext( context,
 382                                                     deleteContent && context.getIndexDirectoryFile().exists() );
 383             }
 384         }
 385         catch ( PlexusSisuBridgeException e )
 386         {
 387             throw new RepositoryAdminException( e.getMessage(), e );
 388         }
 389         catch ( IOException e )
 390         {
 391             throw new RepositoryAdminException( e.getMessage(), e );
 392         }
 393         if ( !stagedOne )
 394         {
 395             RepositorySession repositorySession = getRepositorySessionFactory().createSession();
 396             try
 397             {
 398                 MetadataRepository metadataRepository = repositorySession.getRepository();
 399                 metadataRepository.removeRepository( repository.getId() );
 400                 log.debug( "call repositoryStatisticsManager.deleteStatistics" );
 401                 getRepositoryStatisticsManager().deleteStatistics( metadataRepository, repository.getId() );
 402                 repositorySession.save();
 403             }
 404             catch ( MetadataRepositoryException e )
 405             {
 406                 //throw new RepositoryAdminException( e.getMessage(), e );
 407                 log.warn( "skip error during removing repository from MetadatRepository:" + e.getMessage(), e );
 408             }
 409             finally
 410             {
 411                 repositorySession.close();
 412             }
 413         }
 414         config.removeManagedRepository( repository );
 415
 416         if ( deleteContent )
 417         {
 418             // TODO could be async ? as directory can be huge
 419             File dir = new File( repository.getLocation() );
 420             if ( !FileUtils.deleteQuietly( dir ) )
 421             {
 422                 throw new RepositoryAdminException( "Cannot delete repository " + dir );
 423             }
 424         }
 425
 426         // olamy: copy list for reading as a unit test in webapp fail with ConcurrentModificationException
 427         List<ProxyConnectorConfiguration> proxyConnectors =
 428             new ArrayList<ProxyConnectorConfiguration>( config.getProxyConnectors() );
 429         for ( ProxyConnectorConfiguration proxyConnector : proxyConnectors )
 430         {
 431             if ( StringUtils.equals( proxyConnector.getSourceRepoId(), repository.getId() ) )
 432             {
 433                 config.removeProxyConnector( proxyConnector );
 434             }
 435         }
 436
 437         Map<String, List<String>> repoToGroupMap = config.getRepositoryToGroupMap();
 438         if ( repoToGroupMap != null )
 439         {
 440             if ( repoToGroupMap.containsKey( repository.getId() ) )
 441             {
 442                 List<String> repoGroups = repoToGroupMap.get( repository.getId() );
 443                 for ( String repoGroup : repoGroups )
 444                 {
 445                     // copy to prevent UnsupportedOperationException
 446                     RepositoryGroupConfiguration repositoryGroupConfiguration =
 447                         config.findRepositoryGroupById( repoGroup );
 448                     List<String> repos = new ArrayList<String>( repositoryGroupConfiguration.getRepositories() );
 449                     config.removeRepositoryGroup( repositoryGroupConfiguration );
 450                     repos.remove( repository.getId() );
 451                     repositoryGroupConfiguration.setRepositories( repos );
 452                     config.addRepositoryGroup( repositoryGroupConfiguration );
 453                 }
 454             }
 455         }
 456
 457         try
 458         {
 459             removeRepositoryRoles( repository );
 460         }
 461         catch ( RoleManagerException e )
 462         {
 463             throw new RepositoryAdminException(
 464                 "fail to remove repository roles for repository " + repository.getId() + " : " + e.getMessage(), e );
 465         }
 466
 467         saveConfiguration( config );
 468
 469         return Boolean.TRUE;
 470     }
 471
 472
 473     public Boolean updateManagedRepository( ManagedRepository managedRepository, boolean needStageRepo,
 474                                             AuditInformation auditInformation, boolean resetStats )
 475         throws RepositoryAdminException
 476     {
 477
 478         log.debug( "updateManagedConfiguration repo {} needStage {} resetStats {} ",
 479                    Arrays.asList( managedRepository, needStageRepo, resetStats ).toArray() );
 480
 481         // Ensure that the fields are valid.
 482
 483         getRepositoryCommonValidator().basicValidation( managedRepository, true );
 484
 485         Configuration configuration = getArchivaConfiguration().getConfiguration();
 486
 487         ManagedRepositoryConfiguration toremove = configuration.findManagedRepositoryById( managedRepository.getId() );
 488
 489         if ( toremove != null )
 490         {
 491             configuration.removeManagedRepository( toremove );
 492         }
 493
 494         ManagedRepositoryConfiguration stagingRepository = getStageRepoConfig( toremove );
 495
 496         // TODO remove content from old if path has changed !!!!!
 497
 498         if ( stagingRepository != null )
 499         {
 500             configuration.removeManagedRepository( stagingRepository );
 501         }
 502
 503         ManagedRepositoryConfiguration managedRepositoryConfiguration =
 504             addManagedRepository( managedRepository.getId(), managedRepository.getLayout(), managedRepository.getName(),
 505                                   managedRepository.getLocation(), managedRepository.isBlockRedeployments(),
 506                                   managedRepository.isReleases(), managedRepository.isSnapshots(), needStageRepo,
 507                                   managedRepository.getCronExpression(), managedRepository.getIndexDirectory(),
 508                                   managedRepository.getDaysOlder(), managedRepository.getRetentionCount(),
 509                                   managedRepository.isDeleteReleasedSnapshots(), auditInformation,
 510                                   getArchivaConfiguration().getConfiguration() );
 511
 512         // Save the repository configuration.
 513         RepositorySession repositorySession = getRepositorySessionFactory().createSession();
 514
 515         try
 516         {
 517             triggerAuditEvent( managedRepositoryConfiguration.getId(), null, AuditEvent.MODIFY_MANAGED_REPO,
 518                                auditInformation );
 519
 520             saveConfiguration( this.getArchivaConfiguration().getConfiguration() );
 521             if ( resetStats )
 522             {
 523                 log.debug( "call repositoryStatisticsManager.deleteStatistics" );
 524                 getRepositoryStatisticsManager().deleteStatistics( repositorySession.getRepository(),
 525                                                                    managedRepositoryConfiguration.getId() );
 526                 repositorySession.save();
 527             }
 528
 529         }
 530         catch ( MetadataRepositoryException e )
 531         {
 532             throw new RepositoryAdminException( e.getMessage(), e );
 533         }
 534         finally
 535         {
 536             repositorySession.close();
 537         }
 538         createIndexContext( managedRepository );
 539         return true;
 540     }
 541
 542     //--------------------------
 543     // utils methods
 544     //--------------------------
 545
 546
 547     protected void addRepository( ManagedRepositoryConfiguration repository, Configuration configuration )
 548         throws RepositoryAdminException, IOException
 549     {
 550         // Normalize the path
 551         File file = new File( repository.getLocation() );
 552         repository.setLocation( file.getCanonicalPath() );
 553         if ( !file.exists() )
 554         {
 555             file.mkdirs();
 556         }
 557         if ( !file.exists() || !file.isDirectory() )
 558         {
 559             throw new RepositoryAdminException(
 560                 "Unable to add repository - no write access, can not create the root directory: " + file );
 561         }
 562
 563         configuration.addManagedRepository( repository );
 564
 565     }
 566
 567     public IndexingContext createIndexContext( ManagedRepository repository )
 568         throws RepositoryAdminException
 569     {
 570         try
 571         {
 572
 573             IndexingContext context = indexer.getIndexingContexts().get( repository.getId() );
 574
 575             if ( context != null )
 576             {
 577                 log.debug( "skip adding repository with id {} as already exists", repository.getId() );
 578                 return context;
 579             }
 580
 581             String indexDir = repository.getIndexDirectory();
 582             File managedRepository = new File( repository.getLocation() );
 583
 584             File indexDirectory = null;
 585             if ( indexDir != null && !"".equals( indexDir ) )
 586             {
 587                 indexDirectory = new File( repository.getIndexDirectory() );
 588                 if ( !indexDirectory.isAbsolute() )
 589                 {
 590                     indexDirectory = new File( managedRepository, repository.getIndexDirectory() );
 591                 }
 592             }
 593             else
 594             {
 595                 indexDirectory = new File( managedRepository, ".indexer" );
 596             }
 597
 598             if ( !indexDirectory.exists() )
 599             {
 600                 indexDirectory.mkdirs();
 601             }
 602
 603             context =
 604                 indexer.addIndexingContext( repository.getId(), repository.getId(), managedRepository, indexDirectory,
 605                                             managedRepository.toURI().toURL().toExternalForm(),
 606                                             indexDirectory.toURI().toURL().toString(), indexCreators );
 607
 608             context.setSearchable( repository.isScanned() );
 609             return context;
 610         }
 611         catch ( MalformedURLException e )
 612         {
 613             throw new RepositoryAdminException( e.getMessage(), e );
 614         }
 615         catch ( IOException e )
 616         {
 617             throw new RepositoryAdminException( e.getMessage(), e );
 618         }
 619         catch ( UnsupportedExistingLuceneIndexException e )
 620         {
 621             throw new RepositoryAdminException( e.getMessage(), e );
 622         }
 623     }
 624
 625     private ManagedRepositoryConfiguration getStageRepoConfig( ManagedRepositoryConfiguration repository )
 626     {
 627         ManagedRepositoryConfiguration stagingRepository = new ManagedRepositoryConfiguration();
 628         stagingRepository.setId( repository.getId() + STAGE_REPO_ID_END );
 629         stagingRepository.setLayout( repository.getLayout() );
 630         stagingRepository.setName( repository.getName() + STAGE_REPO_ID_END );
 631         stagingRepository.setBlockRedeployments( repository.isBlockRedeployments() );
 632         stagingRepository.setDaysOlder( repository.getDaysOlder() );
 633         stagingRepository.setDeleteReleasedSnapshots( repository.isDeleteReleasedSnapshots() );
 634         stagingRepository.setIndexDir( repository.getIndexDir() );
 635         String path = repository.getLocation();
 636         int lastIndex = path.lastIndexOf( '/' );
 637         stagingRepository.setLocation( path.substring( 0, lastIndex ) + "/" + stagingRepository.getId() );
 638         stagingRepository.setRefreshCronExpression( repository.getRefreshCronExpression() );
 639         stagingRepository.setReleases( repository.isReleases() );
 640         stagingRepository.setRetentionCount( repository.getRetentionCount() );
 641         stagingRepository.setScanned( repository.isScanned() );
 642         stagingRepository.setSnapshots( repository.isSnapshots() );
 643         return stagingRepository;
 644     }
 645
 646     public Boolean scanRepository( String repositoryId, boolean fullScan )
 647     {
 648         if ( getRepositoryTaskScheduler().isProcessingRepositoryTask( repositoryId ) )
 649         {
 650             log.info( "scanning of repository with id {} already scheduled", repositoryId );
 651         }
 652         RepositoryTask task = new RepositoryTask();
 653         task.setRepositoryId( repositoryId );
 654         task.setScanAll( fullScan );
 655         try
 656         {
 657             getRepositoryTaskScheduler().queueTask( task );
 658         }
 659         catch ( TaskQueueException e )
 660         {
 661             log.error( "failed to schedule scanning of repo with id {}", repositoryId, e );
 662             return false;
 663         }
 664         return true;
 665     }
 666
 667     protected void addRepositoryRoles( ManagedRepositoryConfiguration newRepository )
 668         throws RoleManagerException
 669     {
 670         String repoId = newRepository.getId();
 671
 672         // TODO: double check these are configured on start up
 673         // TODO: belongs in the business logic
 674
 675         if ( !getRoleManager().templatedRoleExists( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, repoId ) )
 676         {
 677             getRoleManager().createTemplatedRole( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, repoId );
 678         }
 679
 680         if ( !getRoleManager().templatedRoleExists( ArchivaRoleConstants.TEMPLATE_REPOSITORY_MANAGER, repoId ) )
 681         {
 682             getRoleManager().createTemplatedRole( ArchivaRoleConstants.TEMPLATE_REPOSITORY_MANAGER, repoId );
 683         }
 684     }
 685
 686     protected void removeRepositoryRoles( ManagedRepositoryConfiguration existingRepository )
 687         throws RoleManagerException
 688     {
 689         String repoId = existingRepository.getId();
 690
 691         if ( getRoleManager().templatedRoleExists( ArchivaRoleConstants.TEMPLATE_REPOSITORY_MANAGER, repoId ) )
 692         {
 693             getRoleManager().removeTemplatedRole( ArchivaRoleConstants.TEMPLATE_REPOSITORY_MANAGER, repoId );
 694         }
 695
 696         if ( getRoleManager().templatedRoleExists( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, repoId ) )
 697         {
 698             getRoleManager().removeTemplatedRole( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, repoId );
 699         }
 700
 701         log.debug( "removed user roles associated with repository {}", repoId );
 702     }
 703
 704     //--------------------------
 705     // setters/getters
 706     //--------------------------
 707
 708
 709     public RoleManager getRoleManager()
 710     {
 711         return roleManager;
 712     }
 713
 714     public void setRoleManager( RoleManager roleManager )
 715     {
 716         this.roleManager = roleManager;
 717     }
 718
 719     public RepositoryStatisticsManager getRepositoryStatisticsManager()
 720     {
 721         return repositoryStatisticsManager;
 722     }
 723
 724     public void setRepositoryStatisticsManager( RepositoryStatisticsManager repositoryStatisticsManager )
 725     {
 726         this.repositoryStatisticsManager = repositoryStatisticsManager;
 727     }
 728
 729     public RepositorySessionFactory getRepositorySessionFactory()
 730     {
 731         return repositorySessionFactory;
 732     }
 733
 734     public void setRepositorySessionFactory( RepositorySessionFactory repositorySessionFactory )
 735     {
 736         this.repositorySessionFactory = repositorySessionFactory;
 737     }
 738
 739
 740     public RepositoryArchivaTaskScheduler getRepositoryTaskScheduler()
 741     {
 742         return repositoryTaskScheduler;
 743     }
 744
 745     public void setRepositoryTaskScheduler( RepositoryArchivaTaskScheduler repositoryTaskScheduler )
 746     {
 747         this.repositoryTaskScheduler = repositoryTaskScheduler;
 748     }
 749
 750     public PlexusSisuBridge getPlexusSisuBridge()
 751     {
 752         return plexusSisuBridge;
 753     }
 754
 755     public void setPlexusSisuBridge( PlexusSisuBridge plexusSisuBridge )
 756     {
 757         this.plexusSisuBridge = plexusSisuBridge;
 758     }
 759
 760     public MavenIndexerUtils getMavenIndexerUtils()
 761     {
 762         return mavenIndexerUtils;
 763     }
 764
 765     public void setMavenIndexerUtils( MavenIndexerUtils mavenIndexerUtils )
 766     {
 767         this.mavenIndexerUtils = mavenIndexerUtils;
 768     }
 769 }