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