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(), e );
 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         boolean updateIndexContext = false;
 472
 473         if ( toremove != null )
 474         {
 475             configuration.removeManagedRepository( toremove );
 476
 477             updateIndexContext = !StringUtils.equals( toremove.getIndexDir(), managedRepository.getIndexDirectory() );
 478         }
 479
 480         ManagedRepositoryConfiguration stagingRepository = getStageRepoConfig( toremove );
 481
 482         // TODO remove content from old if path has changed !!!!!
 483
 484         if ( stagingRepository != null )
 485         {
 486             configuration.removeManagedRepository( stagingRepository );
 487         }
 488
 489         ManagedRepositoryConfiguration managedRepositoryConfiguration =
 490             addManagedRepository( managedRepository.getId(), managedRepository.getLayout(), managedRepository.getName(),
 491                                   managedRepository.getLocation(), managedRepository.isBlockRedeployments(),
 492                                   managedRepository.isReleases(), managedRepository.isSnapshots(), needStageRepo,
 493                                   managedRepository.getCronExpression(), managedRepository.getIndexDirectory(),
 494                                   managedRepository.getDaysOlder(), managedRepository.getRetentionCount(),
 495                                   managedRepository.isDeleteReleasedSnapshots(), managedRepository.getDescription(),
 496                                   managedRepository.isSkipPackedIndexCreation(), managedRepository.isScanned(),
 497                                   auditInformation, getArchivaConfiguration().getConfiguration() );
 498
 499         // Save the repository configuration.
 500         RepositorySession repositorySession = getRepositorySessionFactory().createSession();
 501
 502         try
 503         {
 504             triggerAuditEvent( managedRepositoryConfiguration.getId(), null, AuditEvent.MODIFY_MANAGED_REPO,
 505                                auditInformation );
 506
 507             saveConfiguration( this.getArchivaConfiguration().getConfiguration() );
 508             if ( resetStats )
 509             {
 510                 log.debug( "call repositoryStatisticsManager.deleteStatistics" );
 511                 getRepositoryStatisticsManager().deleteStatistics( repositorySession.getRepository(),
 512                                                                    managedRepositoryConfiguration.getId() );
 513                 repositorySession.save();
 514             }
 515
 516         }
 517         catch ( MetadataRepositoryException e )
 518         {
 519             throw new RepositoryAdminException( e.getMessage(), e );
 520         }
 521         finally
 522         {
 523             repositorySession.close();
 524         }
 525
 526         if ( updateIndexContext )
 527         {
 528             try
 529             {
 530                 IndexingContext indexingContext = indexer.getIndexingContexts().get( managedRepository.getId() );
 531                 if ( indexingContext != null )
 532                 {
 533                     indexer.removeIndexingContext( indexingContext, true );
 534                 }
 535
 536                 // delete directory too as only content is deleted
 537                 File indexDirectory = indexingContext.getIndexDirectoryFile();
 538                 FileUtils.deleteDirectory( indexDirectory );
 539
 540                 createIndexContext( managedRepository );
 541             }
 542             catch ( IOException e )
 543             {
 544                 throw new RepositoryAdminException( e.getMessage(), e );
 545             }
 546         }
 547
 548         return true;
 549     }
 550
 551     //--------------------------
 552     // utils methods
 553     //--------------------------
 554
 555
 556     protected void addRepository( ManagedRepositoryConfiguration repository, Configuration configuration )
 557         throws RepositoryAdminException, IOException
 558     {
 559         // Normalize the path
 560         File file = new File( repository.getLocation() );
 561         if ( !file.isAbsolute() )
 562         {
 563             // add appserver.base/repositories
 564             file = new File(
 565                 getRegistry().getString( "appserver.base" ) + File.separatorChar + "data" + File.separatorChar
 566                     + "repositories", repository.getLocation() );
 567         }
 568         repository.setLocation( file.getCanonicalPath() );
 569         if ( !file.exists() )
 570         {
 571             file.mkdirs();
 572         }
 573         if ( !file.exists() || !file.isDirectory() )
 574         {
 575             throw new RepositoryAdminException(
 576                 "Unable to add repository - no write access, can not create the root directory: " + file );
 577         }
 578
 579         configuration.addManagedRepository( repository );
 580
 581     }
 582
 583     public IndexingContext createIndexContext( ManagedRepository repository )
 584         throws RepositoryAdminException
 585     {
 586
 587         IndexingContext context = indexer.getIndexingContexts().get( repository.getId() );
 588
 589         if ( context != null )
 590         {
 591             log.debug( "skip creating repository indexingContent with id {} as already exists", repository.getId() );
 592             return context;
 593         }
 594
 595         // take care first about repository location as can be relative
 596         File repositoryDirectory = new File( repository.getLocation() );
 597
 598         if ( !repositoryDirectory.isAbsolute() )
 599         {
 600             repositoryDirectory = new File(
 601                 getRegistry().getString( "appserver.base" ) + File.separatorChar + "data" + File.separatorChar
 602                     + "repositories", repository.getLocation() );
 603         }
 604
 605         if ( !repositoryDirectory.exists() )
 606         {
 607             repositoryDirectory.mkdirs();
 608         }
 609
 610         try
 611         {
 612
 613             String indexDir = repository.getIndexDirectory();
 614             //File managedRepository = new File( repository.getLocation() );
 615
 616             File indexDirectory = null;
 617             if ( StringUtils.isNotBlank( indexDir ) )
 618             {
 619                 indexDirectory = new File( repository.getIndexDirectory() );
 620                 // not absolute so create it in repository directory
 621                 if ( !indexDirectory.isAbsolute() )
 622                 {
 623                     indexDirectory = new File( repositoryDirectory, repository.getIndexDirectory() );
 624                     repository.setIndexDirectory( indexDirectory.getAbsolutePath() );
 625                 }
 626             }
 627             else
 628             {
 629                 indexDirectory = new File( repositoryDirectory, ".indexer" );
 630                 if ( !repositoryDirectory.isAbsolute() )
 631                 {
 632                     indexDirectory = new File( repositoryDirectory, ".indexer" );
 633                     repository.setIndexDirectory( indexDirectory.getAbsolutePath() );
 634                 }
 635             }
 636
 637             if ( !indexDirectory.exists() )
 638             {
 639                 indexDirectory.mkdirs();
 640             }
 641
 642             context = indexer.getIndexingContexts().get( repository.getId() );
 643
 644             if ( context == null )
 645             {
 646                 context = indexer.addIndexingContext( repository.getId(), repository.getId(), repositoryDirectory,
 647                                                       indexDirectory,
 648                                                       repositoryDirectory.toURI().toURL().toExternalForm(),
 649                                                       indexDirectory.toURI().toURL().toString(), indexCreators );
 650
 651                 context.setSearchable( repository.isScanned() );
 652             }
 653             return context;
 654         }
 655         catch ( MalformedURLException e )
 656         {
 657             throw new RepositoryAdminException( e.getMessage(), e );
 658         }
 659         catch ( IOException e )
 660         {
 661             throw new RepositoryAdminException( e.getMessage(), e );
 662         }
 663         catch ( UnsupportedExistingLuceneIndexException e )
 664         {
 665             throw new RepositoryAdminException( e.getMessage(), e );
 666         }
 667     }
 668
 669     private ManagedRepositoryConfiguration getStageRepoConfig( ManagedRepositoryConfiguration repository )
 670     {
 671         ManagedRepositoryConfiguration stagingRepository = new ManagedRepositoryConfiguration();
 672         stagingRepository.setId( repository.getId() + STAGE_REPO_ID_END );
 673         stagingRepository.setLayout( repository.getLayout() );
 674         stagingRepository.setName( repository.getName() + STAGE_REPO_ID_END );
 675         stagingRepository.setBlockRedeployments( repository.isBlockRedeployments() );
 676         stagingRepository.setDaysOlder( repository.getDaysOlder() );
 677         stagingRepository.setDeleteReleasedSnapshots( repository.isDeleteReleasedSnapshots() );
 678
 679         String path = repository.getLocation();
 680         int lastIndex = path.replace( '\\', '/' ).lastIndexOf( '/' );
 681         stagingRepository.setLocation( path.substring( 0, lastIndex ) + "/" + stagingRepository.getId() );
 682
 683         if ( StringUtils.isNotBlank( repository.getIndexDir() ) )
 684         {
 685             File indexDir = new File( repository.getIndexDir() );
 686             // in case of absolute dir do not use the same
 687             if ( indexDir.isAbsolute() )
 688             {
 689                 stagingRepository.setIndexDir( stagingRepository.getLocation() + "/.index" );
 690             }
 691             else
 692             {
 693                 stagingRepository.setIndexDir( repository.getIndexDir() );
 694             }
 695         }
 696         stagingRepository.setRefreshCronExpression( repository.getRefreshCronExpression() );
 697         stagingRepository.setReleases( repository.isReleases() );
 698         stagingRepository.setRetentionCount( repository.getRetentionCount() );
 699         stagingRepository.setScanned( repository.isScanned() );
 700         stagingRepository.setSnapshots( repository.isSnapshots() );
 701         stagingRepository.setSkipPackedIndexCreation( repository.isSkipPackedIndexCreation() );
 702         // do not duplicate description
 703         //stagingRepository.getDescription("")
 704         return stagingRepository;
 705     }
 706
 707     public Boolean scanRepository( String repositoryId, boolean fullScan )
 708     {
 709         if ( getRepositoryTaskScheduler().isProcessingRepositoryTask( repositoryId ) )
 710         {
 711             log.info( "scanning of repository with id {} already scheduled", repositoryId );
 712         }
 713         RepositoryTask task = new RepositoryTask();
 714         task.setRepositoryId( repositoryId );
 715         task.setScanAll( fullScan );
 716         try
 717         {
 718             getRepositoryTaskScheduler().queueTask( task );
 719         }
 720         catch ( TaskQueueException e )
 721         {
 722             log.error( "failed to schedule scanning of repo with id {}", repositoryId, e );
 723             return false;
 724         }
 725         return true;
 726     }
 727
 728     protected void addRepositoryRoles( ManagedRepositoryConfiguration newRepository )
 729         throws RoleManagerException
 730     {
 731         String repoId = newRepository.getId();
 732
 733         // TODO: double check these are configured on start up
 734         // TODO: belongs in the business logic
 735
 736         if ( !getRoleManager().templatedRoleExists( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, repoId ) )
 737         {
 738             getRoleManager().createTemplatedRole( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, repoId );
 739         }
 740
 741         if ( !getRoleManager().templatedRoleExists( ArchivaRoleConstants.TEMPLATE_REPOSITORY_MANAGER, repoId ) )
 742         {
 743             getRoleManager().createTemplatedRole( ArchivaRoleConstants.TEMPLATE_REPOSITORY_MANAGER, repoId );
 744         }
 745     }
 746
 747     protected void removeRepositoryRoles( ManagedRepositoryConfiguration existingRepository )
 748         throws RoleManagerException
 749     {
 750         String repoId = existingRepository.getId();
 751
 752         if ( getRoleManager().templatedRoleExists( ArchivaRoleConstants.TEMPLATE_REPOSITORY_MANAGER, repoId ) )
 753         {
 754             getRoleManager().removeTemplatedRole( ArchivaRoleConstants.TEMPLATE_REPOSITORY_MANAGER, repoId );
 755         }
 756
 757         if ( getRoleManager().templatedRoleExists( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, repoId ) )
 758         {
 759             getRoleManager().removeTemplatedRole( ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, repoId );
 760         }
 761
 762         log.debug( "removed user roles associated with repository {}", repoId );
 763     }
 764
 765     //--------------------------
 766     // setters/getters
 767     //--------------------------
 768
 769
 770     public RoleManager getRoleManager()
 771     {
 772         return roleManager;
 773     }
 774
 775     public void setRoleManager( RoleManager roleManager )
 776     {
 777         this.roleManager = roleManager;
 778     }
 779
 780     public RepositoryStatisticsManager getRepositoryStatisticsManager()
 781     {
 782         return repositoryStatisticsManager;
 783     }
 784
 785     public void setRepositoryStatisticsManager( RepositoryStatisticsManager repositoryStatisticsManager )
 786     {
 787         this.repositoryStatisticsManager = repositoryStatisticsManager;
 788     }
 789
 790     public RepositorySessionFactory getRepositorySessionFactory()
 791     {
 792         return repositorySessionFactory;
 793     }
 794
 795     public void setRepositorySessionFactory( RepositorySessionFactory repositorySessionFactory )
 796     {
 797         this.repositorySessionFactory = repositorySessionFactory;
 798     }
 799
 800
 801     public RepositoryArchivaTaskScheduler getRepositoryTaskScheduler()
 802     {
 803         return repositoryTaskScheduler;
 804     }
 805
 806     public void setRepositoryTaskScheduler( RepositoryArchivaTaskScheduler repositoryTaskScheduler )
 807     {
 808         this.repositoryTaskScheduler = repositoryTaskScheduler;
 809     }
 810
 811     public PlexusSisuBridge getPlexusSisuBridge()
 812     {
 813         return plexusSisuBridge;
 814     }
 815
 816     public void setPlexusSisuBridge( PlexusSisuBridge plexusSisuBridge )
 817     {
 818         this.plexusSisuBridge = plexusSisuBridge;
 819     }
 820
 821     public MavenIndexerUtils getMavenIndexerUtils()
 822     {
 823         return mavenIndexerUtils;
 824     }
 825
 826     public void setMavenIndexerUtils( MavenIndexerUtils mavenIndexerUtils )
 827     {
 828         this.mavenIndexerUtils = mavenIndexerUtils;
 829     }
 830 }