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