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