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

   1 package org.apache.archiva.admin.repository.remote;
   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.RemoteRepository;
  24 import org.apache.archiva.admin.model.remote.RemoteRepositoryAdmin;
  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.ProxyConnectorConfiguration;
  32 import org.apache.archiva.configuration.RemoteRepositoryConfiguration;
  33 import org.apache.commons.lang.StringUtils;
  34 import org.apache.maven.index.NexusIndexer;
  35 import org.apache.maven.index.context.IndexCreator;
  36 import org.apache.maven.index.context.IndexingContext;
  37 import org.apache.maven.index.context.UnsupportedExistingLuceneIndexException;
  38 import org.springframework.stereotype.Service;
  39
  40 import javax.annotation.PostConstruct;
  41 import javax.annotation.PreDestroy;
  42 import javax.inject.Inject;
  43 import java.io.File;
  44 import java.io.IOException;
  45 import java.net.MalformedURLException;
  46 import java.util.ArrayList;
  47 import java.util.HashMap;
  48 import java.util.List;
  49 import java.util.Map;
  50
  51 /**
  52  * @author Olivier Lamy
  53  * @since 1.4-M1
  54  */
  55 @Service( "remoteRepositoryAdmin#default" )
  56 public class DefaultRemoteRepositoryAdmin
  57     extends AbstractRepositoryAdmin
  58     implements RemoteRepositoryAdmin
  59 {
  60
  61     @Inject
  62     private PlexusSisuBridge plexusSisuBridge;
  63
  64     @Inject
  65     private MavenIndexerUtils mavenIndexerUtils;
  66
  67     // fields
  68     List<? extends IndexCreator> indexCreators;
  69
  70     NexusIndexer indexer;
  71
  72     @PostConstruct
  73     private void initialize()
  74         throws RepositoryAdminException
  75     {
  76         try
  77         {
  78             indexCreators = mavenIndexerUtils.getAllIndexCreators();
  79             indexer = plexusSisuBridge.lookup( NexusIndexer.class );
  80         }
  81         catch ( PlexusSisuBridgeException e )
  82         {
  83             throw new RepositoryAdminException( e.getMessage(), e );
  84         }
  85         for ( RemoteRepository remoteRepository : getRemoteRepositories() )
  86         {
  87             createIndexContext( remoteRepository );
  88         }
  89     }
  90
  91     @PreDestroy
  92     private void shutdown()
  93         throws RepositoryAdminException
  94     {
  95         try
  96         {
  97             // close index on shutdown
  98             for ( RemoteRepository remoteRepository : getRemoteRepositories() )
  99             {
 100                 IndexingContext context = indexer.getIndexingContexts().get( remoteRepository.getId() );
 101                 if ( context != null )
 102                 {
 103                     indexer.removeIndexingContext( context, false );
 104                 }
 105             }
 106         }
 107         catch ( IOException e )
 108         {
 109             throw new RepositoryAdminException( e.getMessage(), e );
 110         }
 111     }
 112
 113
 114     public List<RemoteRepository> getRemoteRepositories()
 115         throws RepositoryAdminException
 116     {
 117         List<RemoteRepository> remoteRepositories = new ArrayList<RemoteRepository>(
 118             getArchivaConfiguration().getConfiguration().getRemoteRepositories().size() );
 119         for ( RemoteRepositoryConfiguration repositoryConfiguration : getArchivaConfiguration().getConfiguration().getRemoteRepositories() )
 120         {
 121             RemoteRepository remoteRepository =
 122                 new RemoteRepository( repositoryConfiguration.getId(), repositoryConfiguration.getName(),
 123                                       repositoryConfiguration.getUrl(), repositoryConfiguration.getLayout(),
 124                                       repositoryConfiguration.getUsername(), repositoryConfiguration.getPassword(),
 125                                       repositoryConfiguration.getTimeout() );
 126             remoteRepository.setDownloadRemoteIndex( repositoryConfiguration.isDownloadRemoteIndex() );
 127             remoteRepository.setRemoteIndexUrl( repositoryConfiguration.getRemoteIndexUrl() );
 128             remoteRepository.setCronExpression( repositoryConfiguration.getRefreshCronExpression() );
 129             remoteRepository.setIndexDirectory( repositoryConfiguration.getIndexDir() );
 130             remoteRepository.setRemoteDownloadNetworkProxyId(
 131                 repositoryConfiguration.getRemoteDownloadNetworkProxyId() );
 132             remoteRepository.setRemoteDownloadTimeout( repositoryConfiguration.getRemoteDownloadTimeout() );
 133             remoteRepository.setDownloadRemoteIndexOnStartup(
 134                 repositoryConfiguration.isDownloadRemoteIndexOnStartup() );
 135             remoteRepositories.add( remoteRepository );
 136         }
 137         return remoteRepositories;
 138     }
 139
 140     public RemoteRepository getRemoteRepository( String repositoryId )
 141         throws RepositoryAdminException
 142     {
 143         for ( RemoteRepository remoteRepository : getRemoteRepositories() )
 144         {
 145             if ( StringUtils.equals( repositoryId, remoteRepository.getId() ) )
 146             {
 147                 return remoteRepository;
 148             }
 149         }
 150         return null;
 151     }
 152
 153     public Boolean addRemoteRepository( RemoteRepository remoteRepository, AuditInformation auditInformation )
 154         throws RepositoryAdminException
 155     {
 156         triggerAuditEvent( remoteRepository.getId(), null, AuditEvent.ADD_REMOTE_REPO, auditInformation );
 157         getRepositoryCommonValidator().basicValidation( remoteRepository, false );
 158
 159         //TODO we can validate it's a good uri/url
 160         if ( StringUtils.isEmpty( remoteRepository.getUrl() ) )
 161         {
 162             throw new RepositoryAdminException( "url cannot be null" );
 163         }
 164
 165         //MRM-752 - url needs trimming
 166         remoteRepository.setUrl( StringUtils.trim( remoteRepository.getUrl() ) );
 167
 168         RemoteRepositoryConfiguration remoteRepositoryConfiguration =
 169             getRemoteRepositoryConfiguration( remoteRepository );
 170
 171         Configuration configuration = getArchivaConfiguration().getConfiguration();
 172         configuration.addRemoteRepository( remoteRepositoryConfiguration );
 173         saveConfiguration( configuration );
 174
 175         return Boolean.TRUE;
 176     }
 177
 178     public Boolean deleteRemoteRepository( String repositoryId, AuditInformation auditInformation )
 179         throws RepositoryAdminException
 180     {
 181
 182         triggerAuditEvent( repositoryId, null, AuditEvent.DELETE_REMOTE_REPO, auditInformation );
 183
 184         Configuration configuration = getArchivaConfiguration().getConfiguration();
 185
 186         RemoteRepositoryConfiguration remoteRepositoryConfiguration =
 187             configuration.getRemoteRepositoriesAsMap().get( repositoryId );
 188         if ( remoteRepositoryConfiguration == null )
 189         {
 190             throw new RepositoryAdminException(
 191                 "remoteRepository with id " + repositoryId + " not exist cannot remove it" );
 192         }
 193
 194         configuration.removeRemoteRepository( remoteRepositoryConfiguration );
 195
 196         // TODO use ProxyConnectorAdmin interface ?
 197         // [MRM-520] Proxy Connectors are not deleted with the deletion of a Repository.
 198         List<ProxyConnectorConfiguration> proxyConnectors =
 199             new ArrayList<ProxyConnectorConfiguration>( configuration.getProxyConnectors() );
 200         for ( ProxyConnectorConfiguration proxyConnector : proxyConnectors )
 201         {
 202             if ( StringUtils.equals( proxyConnector.getTargetRepoId(), repositoryId ) )
 203             {
 204                 configuration.removeProxyConnector( proxyConnector );
 205             }
 206         }
 207
 208         saveConfiguration( configuration );
 209
 210         return Boolean.TRUE;
 211     }
 212
 213     public Boolean updateRemoteRepository( RemoteRepository remoteRepository, AuditInformation auditInformation )
 214         throws RepositoryAdminException
 215     {
 216
 217         String repositoryId = remoteRepository.getId();
 218
 219         triggerAuditEvent( repositoryId, null, AuditEvent.MODIFY_REMOTE_REPO, auditInformation );
 220
 221         // update means : remove and add
 222
 223         Configuration configuration = getArchivaConfiguration().getConfiguration();
 224
 225         RemoteRepositoryConfiguration remoteRepositoryConfiguration =
 226             configuration.getRemoteRepositoriesAsMap().get( repositoryId );
 227         if ( remoteRepositoryConfiguration == null )
 228         {
 229             throw new RepositoryAdminException(
 230                 "remoteRepository with id " + repositoryId + " not exist cannot remove it" );
 231         }
 232
 233         configuration.removeRemoteRepository( remoteRepositoryConfiguration );
 234
 235         remoteRepositoryConfiguration = getRemoteRepositoryConfiguration( remoteRepository );
 236         configuration.addRemoteRepository( remoteRepositoryConfiguration );
 237         saveConfiguration( configuration );
 238
 239         return Boolean.TRUE;
 240     }
 241
 242     public Map<String, RemoteRepository> getRemoteRepositoriesAsMap()
 243         throws RepositoryAdminException
 244     {
 245         java.util.Map<String, RemoteRepository> map = new HashMap<String, RemoteRepository>();
 246
 247         for ( RemoteRepository repo : getRemoteRepositories() )
 248         {
 249             map.put( repo.getId(), repo );
 250         }
 251
 252         return map;
 253     }
 254
 255     public IndexingContext createIndexContext( RemoteRepository remoteRepository )
 256         throws RepositoryAdminException
 257     {
 258         try
 259         {
 260             // FIXME get this from ArchivaAdministration
 261             String appServerBase = System.getProperty( "appserver.base" );
 262
 263             String contextKey = "remote-" + remoteRepository.getId();
 264             IndexingContext indexingContext = indexer.getIndexingContexts().get( contextKey );
 265             if ( indexingContext != null )
 266             {
 267                 return indexingContext;
 268             }
 269             // create path
 270             File repoDir = new File( appServerBase, "data/remotes/" + remoteRepository.getId() );
 271             if ( !repoDir.exists() )
 272             {
 273                 repoDir.mkdirs();
 274             }
 275             File indexDirectory = new File( repoDir, ".index" );
 276             if ( !indexDirectory.exists() )
 277             {
 278                 indexDirectory.mkdirs();
 279             }
 280             return indexer.addIndexingContext( contextKey, remoteRepository.getId(), repoDir, indexDirectory,
 281                                                remoteRepository.getUrl(), calculateIndexRemoteUrl( remoteRepository ),
 282                                                mavenIndexerUtils.getAllIndexCreators() );
 283         }
 284         catch ( MalformedURLException e )
 285         {
 286             throw new RepositoryAdminException( e.getMessage(), e );
 287         }
 288         catch ( IOException e )
 289         {
 290             throw new RepositoryAdminException( e.getMessage(), e );
 291         }
 292         catch ( UnsupportedExistingLuceneIndexException e )
 293         {
 294             throw new RepositoryAdminException( e.getMessage(), e );
 295         }
 296
 297     }
 298
 299     protected String calculateIndexRemoteUrl( RemoteRepository remoteRepository )
 300     {
 301         if ( StringUtils.startsWith( remoteRepository.getRemoteIndexUrl(), "http" ) )
 302         {
 303             String baseUrl = remoteRepository.getRemoteIndexUrl();
 304             return baseUrl.endsWith( "/" ) ? StringUtils.substringBeforeLast( baseUrl, "/" ) : baseUrl;
 305         }
 306         String baseUrl = StringUtils.endsWith( remoteRepository.getUrl(), "/" ) ? StringUtils.substringBeforeLast(
 307             remoteRepository.getUrl(), "/" ) : remoteRepository.getUrl();
 308
 309         baseUrl = StringUtils.isEmpty( remoteRepository.getRemoteIndexUrl() )
 310             ? baseUrl + "/.index"
 311             : baseUrl + "/" + remoteRepository.getRemoteIndexUrl();
 312         return baseUrl;
 313
 314     }
 315
 316     private RemoteRepositoryConfiguration getRemoteRepositoryConfiguration( RemoteRepository remoteRepository )
 317     {
 318         RemoteRepositoryConfiguration remoteRepositoryConfiguration = new RemoteRepositoryConfiguration();
 319         remoteRepositoryConfiguration.setId( remoteRepository.getId() );
 320         remoteRepositoryConfiguration.setPassword( remoteRepository.getPassword() );
 321         remoteRepositoryConfiguration.setTimeout( remoteRepository.getTimeout() );
 322         remoteRepositoryConfiguration.setUrl( remoteRepository.getUrl() );
 323         remoteRepositoryConfiguration.setUsername( remoteRepository.getUserName() );
 324         remoteRepositoryConfiguration.setLayout( remoteRepository.getLayout() );
 325         remoteRepositoryConfiguration.setName( remoteRepository.getName() );
 326         remoteRepositoryConfiguration.setDownloadRemoteIndex( remoteRepository.isDownloadRemoteIndex() );
 327         remoteRepositoryConfiguration.setRemoteIndexUrl( remoteRepository.getRemoteIndexUrl() );
 328         remoteRepositoryConfiguration.setRefreshCronExpression( remoteRepository.getCronExpression() );
 329         remoteRepositoryConfiguration.setIndexDir( remoteRepository.getIndexDirectory() );
 330         remoteRepositoryConfiguration.setRemoteDownloadNetworkProxyId(
 331             remoteRepository.getRemoteDownloadNetworkProxyId() );
 332         remoteRepositoryConfiguration.setRemoteDownloadTimeout( remoteRepository.getRemoteDownloadTimeout() );
 333         remoteRepositoryConfiguration.setDownloadRemoteIndexOnStartup(
 334             remoteRepository.isDownloadRemoteIndexOnStartup() );
 335         return remoteRepositoryConfiguration;
 336     }
 337
 338 }