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

   1 package org.apache.archiva.repository;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  *  http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22 import org.apache.archiva.configuration.ArchivaConfiguration;
  23 import org.apache.archiva.configuration.ManagedRepositoryConfiguration;
  24 import org.apache.archiva.configuration.RemoteRepositoryConfiguration;
  25 import org.apache.archiva.repository.features.StagingRepositoryFeature;
  26 import org.slf4j.Logger;
  27 import org.slf4j.LoggerFactory;
  28 import org.springframework.stereotype.Service;
  29
  30 import javax.annotation.PostConstruct;
  31 import javax.inject.Inject;
  32 import java.util.ArrayList;
  33 import java.util.Collections;
  34 import java.util.HashMap;
  35 import java.util.LinkedHashMap;
  36 import java.util.List;
  37 import java.util.Map;
  38
  39 /**
  40  * Registry for repositories
  41  */
  42 @Service("repositoryRegistry")
  43 public class RepositoryRegistry
  44 {
  45
  46     private static final Logger log = LoggerFactory.getLogger( RepositoryRegistry.class );
  47
  48     /**
  49      * We inject all repository providers
  50      */
  51     @Inject
  52     List<RepositoryProvider> repositoryProviders;
  53
  54     @Inject
  55     ArchivaConfiguration archivaConfiguration;
  56
  57     @Inject
  58     RepositoryContentFactory repositoryContentFactory;
  59
  60     private Map<String, ManagedRepository> managedRepositories = new HashMap<>(  );
  61     private Map<String, RemoteRepository> remoteRepositories = new HashMap<>(  );
  62
  63     @PostConstruct
  64     private void initialize() {
  65         managedRepositories = getManagedRepositoriesFromConfig();
  66         remoteRepositories = getRemoteRepositoriesFromConfig();
  67     }
  68
  69     private Map<RepositoryType, RepositoryProvider> getProviderMap() {
  70         Map<RepositoryType, RepositoryProvider> map = new HashMap<>(  );
  71         if (repositoryProviders!=null) {
  72             for(RepositoryProvider provider : repositoryProviders) {
  73                 for (RepositoryType type : provider.provides()) {
  74                     map.put(type, provider);
  75                 }
  76             }
  77         }
  78         return map;
  79     }
  80
  81     private Map<String,ManagedRepository> getManagedRepositoriesFromConfig()
  82     {
  83         List<ManagedRepositoryConfiguration> managedRepoConfigs =
  84             getArchivaConfiguration().getConfiguration().getManagedRepositories();
  85
  86         if ( managedRepoConfigs == null )
  87         {
  88             return Collections.emptyMap();
  89         }
  90
  91         Map<String,ManagedRepository> managedRepos = new LinkedHashMap<>( managedRepoConfigs.size() );
  92
  93         Map<RepositoryType, RepositoryProvider> providerMap = getProviderMap( );
  94         for ( ManagedRepositoryConfiguration repoConfig : managedRepoConfigs )
  95         {
  96             RepositoryType repositoryType = RepositoryType.valueOf( repoConfig.getType( ) );
  97             if (providerMap.containsKey( repositoryType )) {
  98                 try
  99                 {
 100                     ManagedRepository repo = createNewManagedRepository( providerMap.get( repositoryType ), repoConfig );
 101                     managedRepos.put(repo.getId(), repo);
 102                 } catch (Exception e) {
 103                     log.error("Could not create managed repository {}: {}", repoConfig.getId(), e.getMessage(), e);
 104                 }
 105             }
 106         }
 107
 108         return managedRepos;
 109     }
 110
 111     private ManagedRepository createNewManagedRepository(RepositoryProvider provider, ManagedRepositoryConfiguration cfg) throws RepositoryException
 112     {
 113         ManagedRepository repo = provider.createManagedInstance( cfg );
 114         if (repo.supportsFeature( StagingRepositoryFeature.class )) {
 115             StagingRepositoryFeature feature = repo.getFeature( StagingRepositoryFeature.class ).get();
 116             if (feature.isStageRepoNeeded()) {
 117                 ManagedRepository stageRepo = getManagedRepository( repo.getId()+StagingRepositoryFeature.STAGING_REPO_POSTFIX );
 118                 feature.setStagingRepository( stageRepo );
 119             }
 120         }
 121         if (repo instanceof EditableManagedRepository)
 122         {
 123             ((EditableManagedRepository)repo).setContent( repositoryContentFactory.getManagedRepositoryContent( repo.getId( ) ) );
 124         }
 125         return repo;
 126
 127     }
 128
 129     private Map<String,RemoteRepository> getRemoteRepositoriesFromConfig() {
 130         List<RemoteRepositoryConfiguration> remoteRepoConfigs =
 131             getArchivaConfiguration().getConfiguration().getRemoteRepositories();
 132
 133         if ( remoteRepoConfigs == null )
 134         {
 135             return Collections.emptyMap();
 136         }
 137
 138         Map<String,RemoteRepository> remoteRepos = new LinkedHashMap<>( remoteRepoConfigs.size() );
 139
 140         Map<RepositoryType, RepositoryProvider> providerMap = getProviderMap( );
 141         for ( RemoteRepositoryConfiguration repoConfig : remoteRepoConfigs )
 142         {
 143             RepositoryType repositoryType = RepositoryType.valueOf( repoConfig.getType( ) );
 144             if (providerMap.containsKey( repositoryType )) {
 145                 try
 146                 {
 147                     remoteRepos.put(repoConfig.getId(), providerMap.get(repositoryType).createRemoteInstance( repoConfig ));
 148                 }
 149                 catch ( Exception e )
 150                 {
 151                     log.error("Could not create repository {} from config: {}", repoConfig.getId(), e.getMessage(), e);
 152                 }
 153             }
 154         }
 155
 156         return remoteRepos;
 157     }
 158
 159     private ArchivaConfiguration getArchivaConfiguration() {
 160         return this.archivaConfiguration;
 161     }
 162
 163     public List<Repository> getRepositories() {
 164         ArrayList<Repository> li = new ArrayList<>(  );
 165         li.addAll(managedRepositories.values());
 166         li.addAll(remoteRepositories.values());
 167         return Collections.unmodifiableList( li );
 168     }
 169
 170     public List<ManagedRepository> getManagedRepositories() {
 171         return Collections.unmodifiableList( new ArrayList(managedRepositories.values()) );
 172     }
 173
 174     public List<RemoteRepository> getRemoteRepositories() {
 175         return Collections.unmodifiableList( new ArrayList(remoteRepositories.values()) );
 176     }
 177
 178     public Repository getRepository(String repoId) {
 179         return null;
 180     }
 181
 182     public ManagedRepository getManagedRepository(String repoId) {
 183         return null;
 184     }
 185
 186     public RemoteRepository getRemoteRepository(String repoId) {
 187         return null;
 188     }
 189
 190 }