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

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