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

   1 package org.apache.archiva.admin.repository.admin;
   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.admin.ArchivaAdministration;
  24 import org.apache.archiva.admin.model.beans.FileType;
  25 import org.apache.archiva.admin.model.beans.LegacyArtifactPath;
  26 import org.apache.archiva.admin.model.beans.NetworkConfiguration;
  27 import org.apache.archiva.admin.model.beans.OrganisationInformation;
  28 import org.apache.archiva.admin.model.beans.UiConfiguration;
  29 import org.apache.archiva.admin.repository.AbstractRepositoryAdmin;
  30 import org.apache.archiva.configuration.Configuration;
  31 import org.apache.archiva.configuration.UserInterfaceOptions;
  32 import org.apache.archiva.configuration.WebappConfiguration;
  33 import org.apache.archiva.metadata.model.facets.AuditEvent;
  34 import org.apache.commons.lang.StringUtils;
  35 import org.apache.http.impl.conn.PoolingClientConnectionManager;
  36 import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
  37 import org.apache.maven.wagon.providers.http.HttpWagon;
  38 import org.springframework.stereotype.Service;
  39 import org.springframework.util.ResourceUtils;
  40
  41 import javax.annotation.PostConstruct;
  42 import javax.annotation.PreDestroy;
  43 import java.io.UnsupportedEncodingException;
  44 import java.net.MalformedURLException;
  45 import java.net.URL;
  46 import java.net.URLEncoder;
  47 import java.util.ArrayList;
  48 import java.util.Collections;
  49 import java.util.List;
  50
  51 /**
  52  * @author Olivier Lamy
  53  */
  54 @Service( "archivaAdministration#default" )
  55 public class DefaultArchivaAdministration
  56     extends AbstractRepositoryAdmin
  57     implements ArchivaAdministration
  58 {
  59
  60     private PoolingHttpClientConnectionManager poolingClientConnectionManager;
  61
  62     @PostConstruct
  63     public void initialize()
  64         throws RepositoryAdminException
  65     {
  66         // setup wagon on start with initial values
  67         NetworkConfiguration networkConfiguration = getNetworkConfiguration();
  68         setupWagon( networkConfiguration );
  69     }
  70
  71     @PreDestroy
  72     public void shutdown()
  73     {
  74         if ( this.poolingClientConnectionManager != null )
  75         {
  76             this.poolingClientConnectionManager.shutdown();
  77         }
  78     }
  79
  80
  81     @Override
  82     public List<LegacyArtifactPath> getLegacyArtifactPaths()
  83         throws RepositoryAdminException
  84     {
  85         List<LegacyArtifactPath> legacyArtifactPaths = new ArrayList<>(
  86             getArchivaConfiguration().getConfiguration().getLegacyArtifactPaths().size() );
  87         for ( org.apache.archiva.configuration.LegacyArtifactPath legacyArtifactPath : getArchivaConfiguration().getConfiguration().getLegacyArtifactPaths() )
  88         {
  89             legacyArtifactPaths.add(
  90                 getModelMapper().map( legacyArtifactPath, LegacyArtifactPath.class ) );
  91         }
  92         return legacyArtifactPaths;
  93     }
  94
  95     @Override
  96     public void addLegacyArtifactPath( LegacyArtifactPath legacyArtifactPath, AuditInformation auditInformation )
  97         throws RepositoryAdminException
  98     {
  99         Configuration configuration = getArchivaConfiguration().getConfiguration();
 100
 101         configuration.addLegacyArtifactPath( getModelMapper().map( legacyArtifactPath,
 102                                                                    org.apache.archiva.configuration.LegacyArtifactPath.class ) );
 103
 104         saveConfiguration( configuration );
 105         triggerAuditEvent( "", "", AuditEvent.ADD_LEGACY_PATH, auditInformation );
 106     }
 107
 108     @Override
 109     public void deleteLegacyArtifactPath( String path, AuditInformation auditInformation )
 110         throws RepositoryAdminException
 111     {
 112         Configuration configuration = getArchivaConfiguration().getConfiguration();
 113         org.apache.archiva.configuration.LegacyArtifactPath legacyArtifactPath =
 114             new org.apache.archiva.configuration.LegacyArtifactPath();
 115
 116         legacyArtifactPath.setPath( path );
 117         configuration.removeLegacyArtifactPath( legacyArtifactPath );
 118
 119         saveConfiguration( configuration );
 120         triggerAuditEvent( "", "", AuditEvent.REMOVE_LEGACY_PATH, auditInformation );
 121     }
 122
 123
 124     @Override
 125     public void addFileTypePattern( String fileTypeId, String pattern, AuditInformation auditInformation )
 126         throws RepositoryAdminException
 127     {
 128         Configuration configuration = getArchivaConfiguration().getConfiguration();
 129
 130         org.apache.archiva.configuration.FileType fileType = getFileTypeById( fileTypeId, configuration );
 131         if ( fileType == null )
 132         {
 133             return;
 134         }
 135
 136         if ( fileType.getPatterns().contains( pattern ) )
 137         {
 138             throw new RepositoryAdminException(
 139                 "File type [" + fileTypeId + "] already contains pattern [" + pattern + "]" );
 140         }
 141         fileType.addPattern( pattern );
 142
 143         saveConfiguration( configuration );
 144         triggerAuditEvent( "", "", AuditEvent.ADD_PATTERN, auditInformation );
 145     }
 146
 147     @Override
 148     public void removeFileTypePattern( String fileTypeId, String pattern, AuditInformation auditInformation )
 149         throws RepositoryAdminException
 150     {
 151         Configuration configuration = getArchivaConfiguration().getConfiguration();
 152
 153         org.apache.archiva.configuration.FileType fileType = getFileTypeById( fileTypeId, configuration );
 154         if ( fileType == null )
 155         {
 156             return;
 157         }
 158         fileType.removePattern( pattern );
 159
 160         saveConfiguration( configuration );
 161         triggerAuditEvent( "", "", AuditEvent.REMOVE_PATTERN, auditInformation );
 162     }
 163
 164     @Override
 165     public FileType getFileType( String fileTypeId )
 166         throws RepositoryAdminException
 167     {
 168         org.apache.archiva.configuration.FileType fileType =
 169             getFileTypeById( fileTypeId, getArchivaConfiguration().getConfiguration() );
 170         if ( fileType == null )
 171         {
 172             return null;
 173         }
 174         return getModelMapper().map( fileType, FileType.class );
 175     }
 176
 177     @Override
 178     public void addFileType( FileType fileType, AuditInformation auditInformation )
 179         throws RepositoryAdminException
 180     {
 181         Configuration configuration = getArchivaConfiguration().getConfiguration();
 182         if ( getFileTypeById( fileType.getId(), configuration ) != null )
 183         {
 184             throw new RepositoryAdminException(
 185                 "impossible to FileType with id " + fileType.getId() + " already exists" );
 186         }
 187
 188         configuration.getRepositoryScanning().addFileType(
 189             getModelMapper().map( fileType, org.apache.archiva.configuration.FileType.class ) );
 190         saveConfiguration( configuration );
 191     }
 192
 193     @Override
 194     public void removeFileType( String fileTypeId, AuditInformation auditInformation )
 195         throws RepositoryAdminException
 196     {
 197         Configuration configuration = getArchivaConfiguration().getConfiguration();
 198         org.apache.archiva.configuration.FileType fileType = new org.apache.archiva.configuration.FileType();
 199         fileType.setId( fileTypeId );
 200         configuration.getRepositoryScanning().removeFileType( fileType );
 201         saveConfiguration( configuration );
 202     }
 203
 204     @Override
 205     public void addKnownContentConsumer( String knownContentConsumer, AuditInformation auditInformation )
 206         throws RepositoryAdminException
 207     {
 208         Configuration configuration = getArchivaConfiguration().getConfiguration();
 209         if ( configuration.getRepositoryScanning().getKnownContentConsumers().contains( knownContentConsumer ) )
 210         {
 211             log.warn( "skip adding knownContentConsumer {} as already here", knownContentConsumer );
 212             return;
 213         }
 214         configuration.getRepositoryScanning().addKnownContentConsumer( knownContentConsumer );
 215         saveConfiguration( configuration );
 216         triggerAuditEvent( "", "", AuditEvent.ENABLE_REPO_CONSUMER, auditInformation );
 217     }
 218
 219     @Override
 220     public void removeKnownContentConsumer( String knownContentConsumer, AuditInformation auditInformation )
 221         throws RepositoryAdminException
 222     {
 223         Configuration configuration = getArchivaConfiguration().getConfiguration();
 224         configuration.getRepositoryScanning().removeKnownContentConsumer( knownContentConsumer );
 225         saveConfiguration( configuration );
 226         triggerAuditEvent( "", "", AuditEvent.DISABLE_REPO_CONSUMER, auditInformation );
 227     }
 228
 229     @Override
 230     public void addInvalidContentConsumer( String invalidContentConsumer, AuditInformation auditInformation )
 231         throws RepositoryAdminException
 232     {
 233         Configuration configuration = getArchivaConfiguration().getConfiguration();
 234         if ( configuration.getRepositoryScanning().getInvalidContentConsumers().contains( invalidContentConsumer ) )
 235         {
 236             log.warn( "skip adding invalidContentConsumer {} as already here", invalidContentConsumer );
 237             return;
 238         }
 239         configuration.getRepositoryScanning().addInvalidContentConsumer( invalidContentConsumer );
 240         saveConfiguration( configuration );
 241         triggerAuditEvent( "", "", AuditEvent.ENABLE_REPO_CONSUMER, auditInformation );
 242     }
 243
 244     @Override
 245     public void removeInvalidContentConsumer( String invalidContentConsumer, AuditInformation auditInformation )
 246         throws RepositoryAdminException
 247     {
 248         Configuration configuration = getArchivaConfiguration().getConfiguration();
 249         configuration.getRepositoryScanning().removeInvalidContentConsumer( invalidContentConsumer );
 250         saveConfiguration( configuration );
 251         triggerAuditEvent( "", "", AuditEvent.DISABLE_REPO_CONSUMER, auditInformation );
 252     }
 253
 254     @Override
 255     public void setKnownContentConsumers( List<String> knownContentConsumers, AuditInformation auditInformation )
 256         throws RepositoryAdminException
 257     {
 258         if ( knownContentConsumers == null )
 259         {
 260             return;
 261         }
 262         for ( String knowContentConsumer : knownContentConsumers )
 263         {
 264             addKnownContentConsumer( knowContentConsumer, auditInformation );
 265         }
 266     }
 267
 268     @Override
 269     public void setInvalidContentConsumers( List<String> invalidContentConsumers, AuditInformation auditInformation )
 270         throws RepositoryAdminException
 271     {
 272         if ( invalidContentConsumers == null )
 273         {
 274             return;
 275         }
 276         for ( String invalidContentConsumer : invalidContentConsumers )
 277         {
 278             addKnownContentConsumer( invalidContentConsumer, auditInformation );
 279         }
 280     }
 281
 282     @Override
 283     public List<FileType> getFileTypes()
 284         throws RepositoryAdminException
 285     {
 286         List<org.apache.archiva.configuration.FileType> configFileTypes =
 287             getArchivaConfiguration().getConfiguration().getRepositoryScanning().getFileTypes();
 288         if ( configFileTypes == null || configFileTypes.isEmpty() )
 289         {
 290             return Collections.emptyList();
 291         }
 292         List<FileType> fileTypes = new ArrayList<>( configFileTypes.size() );
 293         for ( org.apache.archiva.configuration.FileType fileType : configFileTypes )
 294         {
 295             fileTypes.add( getModelMapper().map( fileType, FileType.class ) );
 296         }
 297         return fileTypes;
 298     }
 299
 300     @Override
 301     public List<String> getKnownContentConsumers()
 302         throws RepositoryAdminException
 303     {
 304         return new ArrayList<>(
 305             getArchivaConfiguration().getConfiguration().getRepositoryScanning().getKnownContentConsumers() );
 306     }
 307
 308     @Override
 309     public List<String> getInvalidContentConsumers()
 310         throws RepositoryAdminException
 311     {
 312         return new ArrayList<>(
 313             getArchivaConfiguration().getConfiguration().getRepositoryScanning().getInvalidContentConsumers() );
 314     }
 315
 316     @Override
 317     public OrganisationInformation getOrganisationInformation()
 318         throws RepositoryAdminException
 319     {
 320         org.apache.archiva.configuration.OrganisationInformation organisationInformation =
 321             getArchivaConfiguration().getConfiguration().getOrganisationInfo();
 322         if ( organisationInformation == null )
 323         {
 324             return null;
 325         }
 326         return getModelMapper().map( organisationInformation, OrganisationInformation.class );
 327     }
 328
 329     private void checkUrl(String url, String propertyName)  throws RepositoryAdminException {
 330         if ( StringUtils.isNotEmpty( url ) )
 331         {
 332             if ( !ResourceUtils.isUrl( url ) )
 333             {
 334                 throw new RepositoryAdminException( "Bad URL in " + propertyName + ": " + url );
 335             }
 336         }
 337
 338     }
 339
 340     @Override
 341     public void setOrganisationInformation( OrganisationInformation organisationInformation )
 342         throws RepositoryAdminException
 343     {
 344         checkUrl(organisationInformation.getUrl(), "url");
 345         checkUrl( organisationInformation.getLogoLocation(), "logoLocation" );
 346         Configuration configuration = getArchivaConfiguration( ).getConfiguration( );
 347         if ( organisationInformation != null )
 348         {
 349             org.apache.archiva.configuration.OrganisationInformation organisationInformationModel =
 350                 getModelMapper( ).map( organisationInformation,
 351                     org.apache.archiva.configuration.OrganisationInformation.class );
 352             configuration.setOrganisationInfo( organisationInformationModel );
 353         }
 354         else
 355         {
 356             configuration.setOrganisationInfo( null );
 357         }
 358         saveConfiguration( configuration );
 359     }
 360
 361     @Override
 362     public UiConfiguration getUiConfiguration()
 363         throws RepositoryAdminException
 364     {
 365         WebappConfiguration webappConfiguration = getArchivaConfiguration().getConfiguration().getWebapp();
 366         if ( webappConfiguration == null )
 367         {
 368             return null;
 369         }
 370         UserInterfaceOptions userInterfaceOptions = webappConfiguration.getUi();
 371         if ( userInterfaceOptions == null )
 372         {
 373             return null;
 374         }
 375         return getModelMapper().map( userInterfaceOptions, UiConfiguration.class );
 376     }
 377
 378     @Override
 379     public void updateUiConfiguration( UiConfiguration uiConfiguration )
 380         throws RepositoryAdminException
 381     {
 382         Configuration configuration = getArchivaConfiguration().getConfiguration();
 383         if ( uiConfiguration != null )
 384         {
 385
 386             UserInterfaceOptions userInterfaceOptions =
 387                 getModelMapper().map( uiConfiguration, UserInterfaceOptions.class );
 388             configuration.getWebapp().setUi( userInterfaceOptions );
 389         }
 390         else
 391         {
 392             configuration.getWebapp().setUi( null );
 393         }
 394         saveConfiguration( configuration );
 395
 396     }
 397
 398     @Override
 399     public NetworkConfiguration getNetworkConfiguration()
 400         throws RepositoryAdminException
 401     {
 402         org.apache.archiva.configuration.NetworkConfiguration networkConfiguration =
 403             getArchivaConfiguration().getConfiguration().getNetworkConfiguration();
 404
 405         if ( networkConfiguration == null )
 406         {
 407             return null;
 408         }
 409         return getModelMapper().map( networkConfiguration, NetworkConfiguration.class );
 410     }
 411
 412     @Override
 413     public void setNetworkConfiguration( NetworkConfiguration networkConfiguration )
 414         throws RepositoryAdminException
 415     {
 416         Configuration configuration = getArchivaConfiguration().getConfiguration();
 417         if ( networkConfiguration == null )
 418         {
 419             configuration.setNetworkConfiguration( null );
 420         }
 421         else
 422         {
 423             configuration.setNetworkConfiguration( getModelMapper().map( networkConfiguration,
 424                                                                          org.apache.archiva.configuration.NetworkConfiguration.class ) );
 425         }
 426         setupWagon( networkConfiguration );
 427         saveConfiguration( configuration );
 428     }
 429
 430     protected void setupWagon( NetworkConfiguration networkConfiguration )
 431     {
 432         if ( networkConfiguration == null )
 433         {
 434             // back to default values
 435             HttpWagon.setPersistentPool( true );
 436             poolingClientConnectionManager = new PoolingHttpClientConnectionManager();
 437             poolingClientConnectionManager.setDefaultMaxPerRoute( 30 );
 438             poolingClientConnectionManager.setMaxTotal( 30 );
 439             HttpWagon.setPoolingHttpClientConnectionManager( poolingClientConnectionManager );
 440
 441         }
 442         else
 443         {
 444             HttpWagon.setPersistentPool( networkConfiguration.isUsePooling() );
 445             poolingClientConnectionManager = new PoolingHttpClientConnectionManager();
 446             poolingClientConnectionManager.setDefaultMaxPerRoute( networkConfiguration.getMaxTotalPerHost() );
 447             poolingClientConnectionManager.setMaxTotal( networkConfiguration.getMaxTotal() );
 448             HttpWagon.setPoolingHttpClientConnectionManager( poolingClientConnectionManager );
 449         }
 450     }
 451
 452     //-------------------------
 453     //
 454     //-------------------------
 455
 456     private org.apache.archiva.configuration.FileType getFileTypeById( String id, Configuration configuration )
 457     {
 458         for ( org.apache.archiva.configuration.FileType fileType : configuration.getRepositoryScanning().getFileTypes() )
 459         {
 460             if ( StringUtils.equals( id, fileType.getId() ) )
 461             {
 462                 return fileType;
 463             }
 464         }
 465         return null;
 466     }
 467
 468 }