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