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

   1 package org.apache.maven.archiva.web.action.admin.scanning;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  *  http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22 import java.util.ArrayList;
  23 import java.util.Collections;
  24 import java.util.List;
  25 import java.util.Map;
  26
  27 import com.opensymphony.xwork2.Preparable;
  28 import com.opensymphony.xwork2.Validateable;
  29 import org.apache.archiva.repository.scanner.RepositoryContentConsumers;
  30 import org.apache.commons.collections.CollectionUtils;
  31 import org.apache.commons.lang.StringUtils;
  32 import org.apache.maven.archiva.configuration.ArchivaConfiguration;
  33 import org.apache.maven.archiva.configuration.Configuration;
  34 import org.apache.maven.archiva.configuration.FileType;
  35 import org.apache.maven.archiva.configuration.IndeterminateConfigurationException;
  36 import org.apache.maven.archiva.configuration.RepositoryScanningConfiguration;
  37 import org.apache.maven.archiva.configuration.functors.FiletypeSelectionPredicate;
  38 import org.apache.maven.archiva.configuration.functors.FiletypeToMapClosure;
  39 import org.apache.maven.archiva.repository.audit.AuditEvent;
  40 import org.apache.maven.archiva.repository.audit.Auditable;
  41 import org.apache.maven.archiva.security.ArchivaRoleConstants;
  42 import org.apache.maven.archiva.web.action.PlexusActionSupport;
  43 import org.codehaus.plexus.redback.rbac.Resource;
  44 import org.codehaus.plexus.registry.RegistryException;
  45 import org.codehaus.redback.integration.interceptor.SecureAction;
  46 import org.codehaus.redback.integration.interceptor.SecureActionBundle;
  47 import org.codehaus.redback.integration.interceptor.SecureActionException;
  48
  49 /**
  50  * RepositoryScanningAction
  51  *
  52  * @version $Id$
  53  * @plexus.component role="com.opensymphony.xwork2.Action" role-hint="repositoryScanningAction" instantiation-strategy="per-lookup"
  54  */
  55 public class RepositoryScanningAction
  56     extends PlexusActionSupport
  57     implements Preparable, Validateable, SecureAction, Auditable
  58 {
  59     /**
  60      * @plexus.requirement
  61      */
  62     private ArchivaConfiguration archivaConfiguration;
  63
  64     /**
  65      * @plexus.requirement
  66      */
  67     private RepositoryContentConsumers repoconsumerUtil;
  68
  69     private Map<String, FileType> fileTypeMap;
  70
  71     private List<String> fileTypeIds;
  72
  73     /**
  74      * List of {@link AdminRepositoryConsumer} objects for consumers of known content.
  75      */
  76     private List<AdminRepositoryConsumer> knownContentConsumers;
  77
  78     /**
  79      * List of enabled {@link AdminRepositoryConsumer} objects for consumers of known content.
  80      */
  81     private List<String> enabledKnownContentConsumers;
  82
  83     /**
  84      * List of {@link AdminRepositoryConsumer} objects for consumers of invalid/unknown content.
  85      */
  86     private List<AdminRepositoryConsumer> invalidContentConsumers;
  87
  88     /**
  89      * List of enabled {@link AdminRepositoryConsumer} objects for consumers of invalid/unknown content.
  90      */
  91     private List<String> enabledInvalidContentConsumers;
  92
  93     private String pattern;
  94
  95     private String fileTypeId;
  96
  97     public void addActionError( String anErrorMessage )
  98     {
  99         super.addActionError( anErrorMessage );
 100         log.warn( "[ActionError] " + anErrorMessage );
 101     }
 102
 103     public void addActionMessage( String aMessage )
 104     {
 105         super.addActionMessage( aMessage );
 106         log.info( "[ActionMessage] " + aMessage );
 107     }
 108
 109     public String addFiletypePattern()
 110     {
 111         log.info( "Add New File Type Pattern [" + getFileTypeId() + ":" + getPattern() + "]" );
 112
 113         if ( !isValidFiletypeCommand() )
 114         {
 115             return INPUT;
 116         }
 117
 118         String id = getFileTypeId();
 119         String pattern = getPattern();
 120
 121         FileType filetype = findFileType( id );
 122         if ( filetype == null )
 123         {
 124             addActionError( "Pattern not added, unable to find filetype " + id );
 125             return INPUT;
 126         }
 127
 128         if ( filetype.getPatterns().contains( pattern ) )
 129         {
 130             addActionError( "Not adding pattern \"" + pattern + "\" to filetype " + id + " as it already exists." );
 131             return INPUT;
 132         }
 133
 134         filetype.addPattern( pattern );
 135         addActionMessage( "Added pattern \"" + pattern + "\" to filetype " + id );
 136
 137         triggerAuditEvent( AuditEvent.ADD_PATTERN + " " + pattern );
 138
 139         return saveConfiguration();
 140     }
 141
 142     public String getFileTypeId()
 143     {
 144         return fileTypeId;
 145     }
 146
 147     public List<String> getFileTypeIds()
 148     {
 149         return fileTypeIds;
 150     }
 151
 152     public Map<String, FileType> getFileTypeMap()
 153     {
 154         return fileTypeMap;
 155     }
 156
 157     public List<AdminRepositoryConsumer> getInvalidContentConsumers()
 158     {
 159         return invalidContentConsumers;
 160     }
 161
 162     public List<AdminRepositoryConsumer> getKnownContentConsumers()
 163     {
 164         return knownContentConsumers;
 165     }
 166
 167     public String getPattern()
 168     {
 169         return pattern;
 170     }
 171
 172     public SecureActionBundle getSecureActionBundle()
 173         throws SecureActionException
 174     {
 175         SecureActionBundle bundle = new SecureActionBundle();
 176
 177         bundle.setRequiresAuthentication( true );
 178         bundle.addRequiredAuthorization( ArchivaRoleConstants.OPERATION_MANAGE_CONFIGURATION, Resource.GLOBAL );
 179
 180         return bundle;
 181     }
 182
 183     public void prepare()
 184         throws Exception
 185     {
 186         Configuration config = archivaConfiguration.getConfiguration();
 187         RepositoryScanningConfiguration reposcanning = config.getRepositoryScanning();
 188
 189         FiletypeToMapClosure filetypeToMapClosure = new FiletypeToMapClosure();
 190
 191         CollectionUtils.forAllDo( reposcanning.getFileTypes(), filetypeToMapClosure );
 192         fileTypeMap = filetypeToMapClosure.getMap();
 193
 194         AddAdminRepoConsumerClosure addAdminRepoConsumer;
 195
 196         addAdminRepoConsumer = new AddAdminRepoConsumerClosure( reposcanning.getKnownContentConsumers() );
 197         CollectionUtils.forAllDo( repoconsumerUtil.getAvailableKnownConsumers(), addAdminRepoConsumer );
 198         this.knownContentConsumers = addAdminRepoConsumer.getList();
 199         Collections.sort( knownContentConsumers, AdminRepositoryConsumerComparator.getInstance() );
 200
 201         addAdminRepoConsumer = new AddAdminRepoConsumerClosure( reposcanning.getInvalidContentConsumers() );
 202         CollectionUtils.forAllDo( repoconsumerUtil.getAvailableInvalidConsumers(), addAdminRepoConsumer );
 203         this.invalidContentConsumers = addAdminRepoConsumer.getList();
 204         Collections.sort( invalidContentConsumers, AdminRepositoryConsumerComparator.getInstance() );
 205
 206         fileTypeIds = new ArrayList<String>();
 207         fileTypeIds.addAll( fileTypeMap.keySet() );
 208         Collections.sort( fileTypeIds );
 209     }
 210
 211     public String removeFiletypePattern()
 212     {
 213         log.info( "Remove File Type Pattern [" + getFileTypeId() + ":" + getPattern() + "]" );
 214
 215         if ( !isValidFiletypeCommand() )
 216         {
 217             return INPUT;
 218         }
 219
 220         FileType filetype = findFileType( getFileTypeId() );
 221         if ( filetype == null )
 222         {
 223             addActionError( "Pattern not removed, unable to find filetype " + getFileTypeId() );
 224             return INPUT;
 225         }
 226
 227         filetype.removePattern( getPattern() );
 228
 229         triggerAuditEvent( AuditEvent.REMOVE_PATTERN + " " + pattern );
 230
 231         return saveConfiguration();
 232     }
 233
 234     public void setFileTypeId( String fileTypeId )
 235     {
 236         this.fileTypeId = fileTypeId;
 237     }
 238
 239     public void setPattern( String pattern )
 240     {
 241         this.pattern = pattern;
 242     }
 243
 244     public String updateInvalidConsumers()
 245     {
 246         addActionMessage( "Update Invalid Consumers" );
 247
 248         List<String> oldConsumers = archivaConfiguration.getConfiguration().getRepositoryScanning().getInvalidContentConsumers();
 249
 250         archivaConfiguration.getConfiguration().getRepositoryScanning().setInvalidContentConsumers(
 251             enabledInvalidContentConsumers );
 252
 253         if ( enabledInvalidContentConsumers != null )
 254         {
 255             filterAddedConsumers( oldConsumers, enabledInvalidContentConsumers );
 256             filterRemovedConsumers( oldConsumers, enabledInvalidContentConsumers );
 257         }
 258         else
 259         {
 260             disableAllEnabledConsumers( oldConsumers );
 261         }
 262
 263         return saveConfiguration();
 264     }
 265
 266     public String updateKnownConsumers()
 267     {
 268         addActionMessage( "Update Known Consumers" );
 269
 270         List<String> oldConsumers = archivaConfiguration.getConfiguration().getRepositoryScanning().getKnownContentConsumers();
 271
 272         archivaConfiguration.getConfiguration().getRepositoryScanning().setKnownContentConsumers(
 273             enabledKnownContentConsumers );
 274
 275         if ( enabledKnownContentConsumers != null )
 276         {
 277             filterAddedConsumers( oldConsumers, enabledKnownContentConsumers );
 278             filterRemovedConsumers( oldConsumers, enabledKnownContentConsumers );
 279         }
 280         else
 281         {
 282             disableAllEnabledConsumers( oldConsumers );
 283         }
 284
 285         return saveConfiguration();
 286     }
 287
 288     private FileType findFileType( String id )
 289     {
 290         RepositoryScanningConfiguration scanning = archivaConfiguration.getConfiguration().getRepositoryScanning();
 291         return (FileType) CollectionUtils.find( scanning.getFileTypes(), new FiletypeSelectionPredicate( id ) );
 292     }
 293
 294     private boolean isValidFiletypeCommand()
 295     {
 296         if ( StringUtils.isBlank( getFileTypeId() ) )
 297         {
 298             addActionError( "Unable to process blank filetype id." );
 299         }
 300
 301         if ( StringUtils.isBlank( getPattern() ) )
 302         {
 303             addActionError( "Unable to process blank pattern." );
 304         }
 305
 306         return !hasActionErrors();
 307     }
 308
 309     private String saveConfiguration()
 310     {
 311         try
 312         {
 313             archivaConfiguration.save( archivaConfiguration.getConfiguration() );
 314             addActionMessage( "Successfully saved configuration" );
 315         }
 316         catch ( RegistryException e )
 317         {
 318             addActionError( "Unable to save configuration: " + e.getMessage() );
 319             return INPUT;
 320         }
 321         catch ( IndeterminateConfigurationException e )
 322         {
 323             addActionError( e.getMessage() );
 324             return INPUT;
 325         }
 326
 327         return SUCCESS;
 328     }
 329
 330     private void filterAddedConsumers( List<String> oldList, List<String> newList )
 331     {
 332         for ( String consumer : newList )
 333         {
 334             if ( !oldList.contains( consumer ) )
 335             {
 336                 triggerAuditEvent( AuditEvent.ENABLE_REPO_CONSUMER + " " + consumer );
 337             }
 338         }
 339     }
 340
 341     private void filterRemovedConsumers( List<String> oldList, List<String> newList )
 342     {
 343         for ( String consumer : oldList )
 344         {
 345             if ( !newList.contains( consumer ) )
 346             {
 347                 triggerAuditEvent( AuditEvent.DISABLE_REPO_CONSUMER + " " + consumer );
 348             }
 349         }
 350     }
 351
 352     private void disableAllEnabledConsumers( List<String> consumers )
 353     {
 354         for ( String consumer : consumers )
 355         {
 356             triggerAuditEvent( AuditEvent.DISABLE_REPO_CONSUMER + " " + consumer );
 357         }
 358     }
 359
 360     public List<String> getEnabledInvalidContentConsumers()
 361     {
 362         return enabledInvalidContentConsumers;
 363     }
 364
 365     public void setEnabledInvalidContentConsumers( List<String> enabledInvalidContentConsumers )
 366     {
 367         this.enabledInvalidContentConsumers = enabledInvalidContentConsumers;
 368     }
 369
 370     public List<String> getEnabledKnownContentConsumers()
 371     {
 372         return enabledKnownContentConsumers;
 373     }
 374
 375     public void setEnabledKnownContentConsumers( List<String> enabledKnownContentConsumers )
 376     {
 377         this.enabledKnownContentConsumers = enabledKnownContentConsumers;
 378     }
 379
 380     public ArchivaConfiguration getArchivaConfiguration()
 381     {
 382         return archivaConfiguration;
 383     }
 384
 385     public void setArchivaConfiguration( ArchivaConfiguration archivaConfiguration )
 386     {
 387         this.archivaConfiguration = archivaConfiguration;
 388     }
 389 }