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