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

   1 package org.apache.archiva.configuration;
   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.beans.NetworkProxy;
  25 import org.apache.archiva.admin.model.beans.ProxyConnector;
  26 import org.apache.archiva.admin.model.beans.ProxyConnectorRule;
  27 import org.apache.archiva.admin.model.beans.RemoteRepository;
  28 import org.apache.archiva.admin.model.managed.ManagedRepositoryAdmin;
  29 import org.apache.archiva.admin.model.networkproxy.NetworkProxyAdmin;
  30 import org.apache.archiva.admin.model.proxyconnector.ProxyConnectorAdmin;
  31 import org.apache.archiva.admin.model.proxyconnector.ProxyConnectorOrderComparator;
  32 import org.apache.archiva.admin.model.remote.RemoteRepositoryAdmin;
  33 import org.apache.archiva.indexer.ArchivaIndexingContext;
  34 import org.apache.commons.lang3.StringUtils;
  35 import org.modelmapper.ModelMapper;
  36 import org.springframework.stereotype.Service;
  37
  38 import javax.inject.Inject;
  39 import javax.inject.Named;
  40 import java.util.ArrayList;
  41 import java.util.Collections;
  42 import java.util.HashMap;
  43 import java.util.Iterator;
  44 import java.util.List;
  45 import java.util.Locale;
  46 import java.util.Map;
  47
  48 /**
  49  * @author Olivier Lamy
  50  */
  51 @Service
  52 public class MockRepoAdmin
  53     implements RemoteRepositoryAdmin, ManagedRepositoryAdmin, ProxyConnectorAdmin, NetworkProxyAdmin
  54 {
  55     @Inject
  56     @Named ( "archivaConfiguration#test" )
  57     private ArchivaConfiguration archivaConfiguration;
  58
  59     @Override
  60     public List<RemoteRepository> getRemoteRepositories()
  61         throws RepositoryAdminException
  62     {
  63         List<RemoteRepository> remoteRepositories =
  64             new ArrayList<>( archivaConfiguration.getConfiguration().getRemoteRepositories().size() );
  65         for ( RemoteRepositoryConfiguration repositoryConfiguration : archivaConfiguration.getConfiguration().getRemoteRepositories() )
  66         {
  67             RemoteRepository remoteRepository =
  68                 new RemoteRepository( Locale.getDefault(), repositoryConfiguration.getId(), repositoryConfiguration.getName(),
  69                                       repositoryConfiguration.getUrl(), repositoryConfiguration.getLayout(),
  70                                       repositoryConfiguration.getUsername(), repositoryConfiguration.getPassword(),
  71                                       repositoryConfiguration.getTimeout() );
  72             remoteRepository.setDownloadRemoteIndex( repositoryConfiguration.isDownloadRemoteIndex() );
  73             remoteRepository.setRemoteIndexUrl( repositoryConfiguration.getRemoteIndexUrl() );
  74             remoteRepository.setCronExpression( repositoryConfiguration.getRefreshCronExpression() );
  75             remoteRepository.setIndexDirectory( repositoryConfiguration.getIndexDir() );
  76             remoteRepository.setRemoteDownloadNetworkProxyId(
  77                 repositoryConfiguration.getRemoteDownloadNetworkProxyId() );
  78             remoteRepository.setRemoteDownloadTimeout( repositoryConfiguration.getRemoteDownloadTimeout() );
  79             remoteRepository.setDownloadRemoteIndexOnStartup(
  80                 repositoryConfiguration.isDownloadRemoteIndexOnStartup() );
  81             remoteRepositories.add( remoteRepository );
  82         }
  83         return remoteRepositories;
  84     }
  85
  86     @Override
  87     public RemoteRepository getRemoteRepository( String repositoryId )
  88         throws RepositoryAdminException
  89     {
  90         for ( RemoteRepository remoteRepository : getRemoteRepositories() )
  91         {
  92             if ( StringUtils.equals( repositoryId, remoteRepository.getId() ) )
  93             {
  94                 return remoteRepository;
  95             }
  96         }
  97         return null;
  98     }
  99
 100     @Override
 101     public Boolean deleteRemoteRepository( String repositoryId, AuditInformation auditInformation )
 102         throws RepositoryAdminException
 103     {
 104         return null;  //To change body of implemented methods use File | Settings | File Templates.
 105     }
 106
 107     @Override
 108     public Boolean addRemoteRepository( RemoteRepository remoteRepository, AuditInformation auditInformation )
 109         throws RepositoryAdminException
 110     {
 111         return null;  //To change body of implemented methods use File | Settings | File Templates.
 112     }
 113
 114     @Override
 115     public Boolean updateRemoteRepository( RemoteRepository remoteRepository, AuditInformation auditInformation )
 116         throws RepositoryAdminException
 117     {
 118         return null;  //To change body of implemented methods use File | Settings | File Templates.
 119     }
 120
 121     @Override
 122     public Map<String, RemoteRepository> getRemoteRepositoriesAsMap()
 123         throws RepositoryAdminException
 124     {
 125         return null;  //To change body of implemented methods use File | Settings | File Templates.
 126     }
 127
 128     @Override
 129     public ArchivaIndexingContext createIndexContext( RemoteRepository repository )
 130         throws RepositoryAdminException
 131     {
 132         return null;  //To change body of implemented methods use File | Settings | File Templates.
 133     }
 134
 135     @Override
 136     public List<ManagedRepository> getManagedRepositories()
 137         throws RepositoryAdminException
 138     {
 139         return null;  //To change body of implemented methods use File | Settings | File Templates.
 140     }
 141
 142     @Override
 143     public Map<String, ManagedRepository> getManagedRepositoriesAsMap()
 144         throws RepositoryAdminException
 145     {
 146         return null;  //To change body of implemented methods use File | Settings | File Templates.
 147     }
 148
 149     @Override
 150     public ManagedRepository getManagedRepository( String repositoryId )
 151         throws RepositoryAdminException
 152     {
 153         for ( ManagedRepositoryConfiguration repoConfig : archivaConfiguration.getConfiguration().getManagedRepositories() )
 154         {
 155             if ( StringUtils.equals( repositoryId, repoConfig.getId() ) )
 156             {
 157                 return new ManagedRepository( Locale.getDefault(), repoConfig.getId(), repoConfig.getName(), repoConfig.getLocation(),
 158                                               repoConfig.getLayout(), repoConfig.isSnapshots(), repoConfig.isReleases(),
 159                                               repoConfig.isBlockRedeployments(), repoConfig.getRefreshCronExpression(),
 160                                               repoConfig.getIndexDir(), repoConfig.isScanned(),
 161                                               repoConfig.getRetentionPeriod(), repoConfig.getRetentionCount(),
 162                                               repoConfig.isDeleteReleasedSnapshots(), false );
 163             }
 164         }
 165         return null;
 166     }
 167
 168     @Override
 169     public Boolean deleteManagedRepository( String repositoryId, AuditInformation auditInformation,
 170                                             boolean deleteContent )
 171         throws RepositoryAdminException
 172     {
 173         return null;  //To change body of implemented methods use File | Settings | File Templates.
 174     }
 175
 176     @Override
 177     public Boolean addManagedRepository( ManagedRepository managedRepository, boolean needStageRepo,
 178                                          AuditInformation auditInformation )
 179         throws RepositoryAdminException
 180     {
 181         return null;  //To change body of implemented methods use File | Settings | File Templates.
 182     }
 183
 184     @Override
 185     public Boolean updateManagedRepository( ManagedRepository managedRepository, boolean needStageRepo,
 186                                             AuditInformation auditInformation, boolean resetStats )
 187         throws RepositoryAdminException
 188     {
 189         return null;  //To change body of implemented methods use File | Settings | File Templates.
 190     }
 191
 192
 193     @Override
 194     public List<ProxyConnector> getProxyConnectors()
 195         throws RepositoryAdminException
 196     {
 197         List<ProxyConnectorConfiguration> proxyConnectorConfigurations =
 198             archivaConfiguration.getConfiguration().getProxyConnectors();
 199         List<ProxyConnector> proxyConnectors = new ArrayList<>( proxyConnectorConfigurations.size() );
 200         for ( ProxyConnectorConfiguration configuration : proxyConnectorConfigurations )
 201         {
 202             proxyConnectors.add( getProxyConnector( configuration ) );
 203         }
 204         Collections.sort( proxyConnectors, ProxyConnectorOrderComparator.getInstance() );
 205         return proxyConnectors;
 206     }
 207
 208     @Override
 209     public ProxyConnector getProxyConnector( String sourceRepoId, String targetRepoId )
 210         throws RepositoryAdminException
 211     {
 212         return null;  //To change body of implemented methods use File | Settings | File Templates.
 213     }
 214
 215     @Override
 216     public Boolean addProxyConnector( ProxyConnector proxyConnector, AuditInformation auditInformation )
 217         throws RepositoryAdminException
 218     {
 219         return null;  //To change body of implemented methods use File | Settings | File Templates.
 220     }
 221
 222     @Override
 223     public Boolean deleteProxyConnector( ProxyConnector proxyConnector, AuditInformation auditInformation )
 224         throws RepositoryAdminException
 225     {
 226         return null;  //To change body of implemented methods use File | Settings | File Templates.
 227     }
 228
 229     @Override
 230     public Boolean updateProxyConnector( ProxyConnector proxyConnector, AuditInformation auditInformation )
 231         throws RepositoryAdminException
 232     {
 233         return null;
 234     }
 235
 236     @Override
 237     public Map<String, List<ProxyConnector>> getProxyConnectorAsMap()
 238         throws RepositoryAdminException
 239     {
 240         Map<String, List<ProxyConnector>> proxyConnectorMap = new HashMap<>();
 241
 242         Iterator<ProxyConnector> it = getProxyConnectors().iterator();
 243         while ( it.hasNext() )
 244         {
 245             ProxyConnector proxyConfig = it.next();
 246             String key = proxyConfig.getSourceRepoId();
 247
 248             List<ProxyConnector> connectors = proxyConnectorMap.get( key );
 249             if ( connectors == null )
 250             {
 251                 connectors = new ArrayList<>( 1 );
 252                 proxyConnectorMap.put( key, connectors );
 253             }
 254
 255             connectors.add( proxyConfig );
 256
 257             Collections.sort( connectors, ProxyConnectorOrderComparator.getInstance() );
 258         }
 259
 260         return proxyConnectorMap;
 261     }
 262
 263     @Override
 264     public List<NetworkProxy> getNetworkProxies()
 265         throws RepositoryAdminException
 266     {
 267         return null;  //To change body of implemented methods use File | Settings | File Templates.
 268     }
 269
 270     @Override
 271     public NetworkProxy getNetworkProxy( String networkProxyId )
 272         throws RepositoryAdminException
 273     {
 274         return null;  //To change body of implemented methods use File | Settings | File Templates.
 275     }
 276
 277     @Override
 278     public void addNetworkProxy( NetworkProxy networkProxy, AuditInformation auditInformation )
 279         throws RepositoryAdminException
 280     {
 281         //To change body of implemented methods use File | Settings | File Templates.
 282     }
 283
 284     @Override
 285     public void updateNetworkProxy( NetworkProxy networkProxy, AuditInformation auditInformation )
 286         throws RepositoryAdminException
 287     {
 288         //To change body of implemented methods use File | Settings | File Templates.
 289     }
 290
 291     @Override
 292     public void deleteNetworkProxy( String networkProxyId, AuditInformation auditInformation )
 293         throws RepositoryAdminException
 294     {
 295         //To change body of implemented methods use File | Settings | File Templates.
 296     }
 297
 298     protected ProxyConnector getProxyConnector( ProxyConnectorConfiguration proxyConnectorConfiguration )
 299     {
 300         return proxyConnectorConfiguration == null
 301             ? null
 302             : new ModelMapper().map( proxyConnectorConfiguration, ProxyConnector.class );
 303     }
 304
 305     public List<ProxyConnectorRule> getProxyConnectorRules()
 306         throws RepositoryAdminException
 307     {
 308         return null;
 309     }
 310
 311     public void addProxyConnectorRule( ProxyConnectorRule proxyConnectorRule )
 312         throws RepositoryAdminException
 313     {
 314
 315     }
 316
 317     public void deleteProxyConnectorRule( ProxyConnectorRule proxyConnectorRule )
 318         throws RepositoryAdminException
 319     {
 320
 321     }
 322
 323     public void updateProxyConnectorRule( ProxyConnectorRule proxyConnectorRule )
 324         throws RepositoryAdminException
 325     {
 326
 327     }
 328 }