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