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