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