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 removeFiletypePattern()
 144     {
 145         log.info( "Remove File Type Pattern [" + getFileTypeId() + ":" + getPattern() + "]" );
 146
 147         if ( !isValidFiletypeCommand() )
 148         {
 149             return INPUT;
 150         }
 151
 152         FileType filetype = findFileType( getFileTypeId() );
 153         if ( filetype == null )
 154         {
 155             addActionError( "Pattern not removed, unable to find filetype " + getFileTypeId() );
 156             return INPUT;
 157         }
 158
 159         filetype.removePattern( getPattern() );
 160
 161         triggerAuditEvent( AuditEvent.REMOVE_PATTERN + " " + pattern );
 162
 163         return saveConfiguration();
 164     }
 165
 166     public String getFileTypeId()
 167     {
 168         return fileTypeId;
 169     }
 170
 171     public List<String> getFileTypeIds()
 172     {
 173         return fileTypeIds;
 174     }
 175
 176     public Map<String, FileType> getFileTypeMap()
 177     {
 178         return fileTypeMap;
 179     }
 180
 181     public List<AdminRepositoryConsumer> getInvalidContentConsumers()
 182     {
 183         return invalidContentConsumers;
 184     }
 185
 186     public List<AdminRepositoryConsumer> getKnownContentConsumers()
 187     {
 188         return knownContentConsumers;
 189     }
 190
 191     public String getPattern()
 192     {
 193         return pattern;
 194     }
 195
 196     public SecureActionBundle getSecureActionBundle()
 197         throws SecureActionException
 198     {
 199         SecureActionBundle bundle = new SecureActionBundle();
 200
 201         bundle.setRequiresAuthentication( true );
 202         bundle.addRequiredAuthorization( ArchivaRoleConstants.OPERATION_MANAGE_CONFIGURATION, Resource.GLOBAL );
 203
 204         return bundle;
 205     }
 206
 207     public void prepare()
 208         throws Exception
 209     {
 210         Configuration config = archivaConfiguration.getConfiguration();
 211         RepositoryScanningConfiguration reposcanning = config.getRepositoryScanning();
 212
 213         FiletypeToMapClosure filetypeToMapClosure = new FiletypeToMapClosure();
 214
 215         CollectionUtils.forAllDo( reposcanning.getFileTypes(), filetypeToMapClosure );
 216         fileTypeMap = filetypeToMapClosure.getMap();
 217
 218         AddAdminRepoConsumerClosure addAdminRepoConsumer =
 219             new AddAdminRepoConsumerClosure( reposcanning.getKnownContentConsumers() );
 220         CollectionUtils.forAllDo( repoconsumerUtil.getAvailableKnownConsumers(), addAdminRepoConsumer );
 221         this.knownContentConsumers = addAdminRepoConsumer.getList();
 222         Collections.sort( knownContentConsumers, AdminRepositoryConsumerComparator.getInstance() );
 223
 224         addAdminRepoConsumer = new AddAdminRepoConsumerClosure( reposcanning.getInvalidContentConsumers() );
 225         CollectionUtils.forAllDo( repoconsumerUtil.getAvailableInvalidConsumers(), addAdminRepoConsumer );
 226         this.invalidContentConsumers = addAdminRepoConsumer.getList();
 227         Collections.sort( invalidContentConsumers, AdminRepositoryConsumerComparator.getInstance() );
 228
 229         fileTypeIds = new ArrayList<String>();
 230         fileTypeIds.addAll( fileTypeMap.keySet() );
 231         Collections.sort( fileTypeIds );
 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 =
 249             archivaConfiguration.getConfiguration().getRepositoryScanning().getInvalidContentConsumers();
 250
 251         archivaConfiguration.getConfiguration().getRepositoryScanning().setInvalidContentConsumers(
 252             enabledInvalidContentConsumers );
 253
 254         if ( enabledInvalidContentConsumers != null )
 255         {
 256             filterAddedConsumers( oldConsumers, enabledInvalidContentConsumers );
 257             filterRemovedConsumers( oldConsumers, enabledInvalidContentConsumers );
 258         }
 259         else
 260         {
 261             disableAllEnabledConsumers( oldConsumers );
 262         }
 263
 264         return saveConfiguration();
 265     }
 266
 267     public String updateKnownConsumers()
 268     {
 269         addActionMessage( "Update Known Consumers" );
 270
 271         List<String> oldConsumers =
 272             archivaConfiguration.getConfiguration().getRepositoryScanning().getKnownContentConsumers();
 273
 274         archivaConfiguration.getConfiguration().getRepositoryScanning().setKnownContentConsumers(
 275             enabledKnownContentConsumers );
 276
 277         if ( enabledKnownContentConsumers != null )
 278         {
 279             filterAddedConsumers( oldConsumers, enabledKnownContentConsumers );
 280             filterRemovedConsumers( oldConsumers, enabledKnownContentConsumers );
 281         }
 282         else
 283         {
 284             disableAllEnabledConsumers( oldConsumers );
 285         }
 286
 287         return saveConfiguration();
 288     }
 289
 290     private FileType findFileType( String id )
 291     {
 292         RepositoryScanningConfiguration scanning = archivaConfiguration.getConfiguration().getRepositoryScanning();
 293         return (FileType) CollectionUtils.find( scanning.getFileTypes(), new FiletypeSelectionPredicate( id ) );
 294     }
 295
 296     private boolean isValidFiletypeCommand()
 297     {
 298         if ( StringUtils.isBlank( getFileTypeId() ) )
 299         {
 300             addActionError( "Unable to process blank filetype id." );
 301         }
 302
 303         if ( StringUtils.isBlank( getPattern() ) )
 304         {
 305             addActionError( "Unable to process blank pattern." );
 306         }
 307
 308         return !hasActionErrors();
 309     }
 310
 311     private String saveConfiguration()
 312     {
 313         try
 314         {
 315             archivaConfiguration.save( archivaConfiguration.getConfiguration() );
 316             addActionMessage( "Successfully saved configuration" );
 317         }
 318         catch ( RegistryException e )
 319         {
 320             addActionError( "Unable to save configuration: " + e.getMessage() );
 321             return INPUT;
 322         }
 323         catch ( IndeterminateConfigurationException e )
 324         {
 325             addActionError( e.getMessage() );
 326             return INPUT;
 327         }
 328
 329         return SUCCESS;
 330     }
 331
 332     private void filterAddedConsumers( List<String> oldList, List<String> newList )
 333     {
 334         for ( String consumer : newList )
 335         {
 336             if ( !oldList.contains( consumer ) )
 337             {
 338                 triggerAuditEvent( AuditEvent.ENABLE_REPO_CONSUMER + " " + consumer );
 339             }
 340         }
 341     }
 342
 343     private void filterRemovedConsumers( List<String> oldList, List<String> newList )
 344     {
 345         for ( String consumer : oldList )
 346         {
 347             if ( !newList.contains( consumer ) )
 348             {
 349                 triggerAuditEvent( AuditEvent.DISABLE_REPO_CONSUMER + " " + consumer );
 350             }
 351         }
 352     }
 353
 354     private void disableAllEnabledConsumers( List<String> consumers )
 355     {
 356         for ( String consumer : consumers )
 357         {
 358             triggerAuditEvent( AuditEvent.DISABLE_REPO_CONSUMER + " " + consumer );
 359         }
 360     }
 361
 362     public List<String> getEnabledInvalidContentConsumers()
 363     {
 364         return enabledInvalidContentConsumers;
 365     }
 366
 367     public void setEnabledInvalidContentConsumers( List<String> enabledInvalidContentConsumers )
 368     {
 369         this.enabledInvalidContentConsumers = enabledInvalidContentConsumers;
 370     }
 371
 372     public List<String> getEnabledKnownContentConsumers()
 373     {
 374         return enabledKnownContentConsumers;
 375     }
 376
 377     public void setEnabledKnownContentConsumers( List<String> enabledKnownContentConsumers )
 378     {
 379         this.enabledKnownContentConsumers = enabledKnownContentConsumers;
 380     }
 381
 382     public ArchivaConfiguration getArchivaConfiguration()
 383     {
 384         return archivaConfiguration;
 385     }
 386
 387     public void setArchivaConfiguration( ArchivaConfiguration archivaConfiguration )
 388     {
 389         this.archivaConfiguration = archivaConfiguration;
 390     }
 391 }