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