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