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