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