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

   1 package org.apache.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.admin.model.RepositoryAdminException;
  25 import org.apache.archiva.admin.model.admin.ArchivaAdministration;
  26 import org.apache.archiva.admin.model.beans.FileType;
  27 import org.apache.archiva.admin.repository.admin.FiletypeToMapClosure;
  28 import org.apache.archiva.audit.Auditable;
  29 import org.apache.archiva.repository.scanner.RepositoryContentConsumers;
  30 import org.apache.archiva.security.common.ArchivaRoleConstants;
  31 import org.apache.commons.collections.CollectionUtils;
  32 import org.apache.commons.lang.StringUtils;
  33 import org.apache.archiva.web.action.AbstractActionSupport;
  34 import org.codehaus.plexus.redback.rbac.Resource;
  35 import org.codehaus.redback.integration.interceptor.SecureAction;
  36 import org.codehaus.redback.integration.interceptor.SecureActionBundle;
  37 import org.codehaus.redback.integration.interceptor.SecureActionException;
  38 import org.springframework.context.annotation.Scope;
  39 import org.springframework.stereotype.Controller;
  40
  41 import javax.inject.Inject;
  42 import java.util.ArrayList;
  43 import java.util.Collections;
  44 import java.util.List;
  45 import java.util.Map;
  46
  47 /**
  48  * RepositoryScanningAction
  49  *
  50  * @version $Id$
  51  */
  52 @Controller( "repositoryScanningAction" )
  53 @Scope( "prototype" )
  54 public class RepositoryScanningAction
  55     extends AbstractActionSupport
  56     implements Preparable, Validateable, SecureAction, Auditable
  57 {
  58
  59     @Inject
  60     private RepositoryContentConsumers repoconsumerUtil;
  61
  62     @Inject
  63     private ArchivaAdministration archivaAdministration;
  64
  65     private Map<String, FileType> fileTypeMap;
  66
  67     private List<String> fileTypeIds;
  68
  69     /**
  70      * List of {@link AdminRepositoryConsumer} objects for consumers of known content.
  71      */
  72     private List<AdminRepositoryConsumer> knownContentConsumers;
  73
  74     /**
  75      * List of enabled {@link AdminRepositoryConsumer} objects for consumers of known content.
  76      */
  77     private List<String> enabledKnownContentConsumers;
  78
  79     /**
  80      * List of {@link AdminRepositoryConsumer} objects for consumers of invalid/unknown content.
  81      */
  82     private List<AdminRepositoryConsumer> invalidContentConsumers;
  83
  84     /**
  85      * List of enabled {@link AdminRepositoryConsumer} objects for consumers of invalid/unknown content.
  86      */
  87     private List<String> enabledInvalidContentConsumers;
  88
  89     private String pattern;
  90
  91     private String fileTypeId;
  92
  93     public void addActionError( String anErrorMessage )
  94     {
  95         super.addActionError( anErrorMessage );
  96         log.warn( "[ActionError] {}", anErrorMessage );
  97     }
  98
  99     public void addActionMessage( String aMessage )
 100     {
 101         super.addActionMessage( aMessage );
 102         log.info( "[ActionMessage] {}", aMessage );
 103     }
 104
 105     public String addFiletypePattern()
 106     {
 107         log.info( "Add New File Type Pattern [{}:{}]", getFileTypeId(), getPattern() );
 108
 109         if ( !isValidFiletypeCommand() )
 110         {
 111             return INPUT;
 112         }
 113
 114         try
 115         {
 116             getArchivaAdministration().addFileTypePattern( getFileTypeId(), getPattern(), getAuditInformation() );
 117         }
 118         catch ( RepositoryAdminException e )
 119         {
 120             addActionError( e.getMessage() );
 121             return INPUT;
 122         }
 123         return SUCCESS;
 124     }
 125
 126     public String removeFiletypePattern()
 127         throws RepositoryAdminException
 128     {
 129         log.info( "Remove File Type Pattern [{}:{}]", getFileTypeId(), getPattern() );
 130
 131         if ( !isValidFiletypeCommand() )
 132         {
 133             return INPUT;
 134         }
 135
 136         try
 137         {
 138             getArchivaAdministration().removeFileTypePattern( getFileTypeId(), getPattern(), getAuditInformation() );
 139         }
 140         catch ( RepositoryAdminException e )
 141         {
 142             addActionError( "error adding file type pattern " + e.getMessage() );
 143             return INPUT;
 144         }
 145
 146         return SUCCESS;
 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
 194
 195         FiletypeToMapClosure filetypeToMapClosure = new FiletypeToMapClosure();
 196
 197         CollectionUtils.forAllDo( archivaAdministration.getFileTypes(), filetypeToMapClosure );
 198         fileTypeMap = filetypeToMapClosure.getMap();
 199
 200         AddAdminRepoConsumerClosure addAdminRepoConsumer =
 201             new AddAdminRepoConsumerClosure( archivaAdministration.getKnownContentConsumers() );
 202         CollectionUtils.forAllDo( repoconsumerUtil.getAvailableKnownConsumers(), addAdminRepoConsumer );
 203         this.knownContentConsumers = addAdminRepoConsumer.getList();
 204         Collections.sort( knownContentConsumers, AdminRepositoryConsumerComparator.getInstance() );
 205
 206         addAdminRepoConsumer = new AddAdminRepoConsumerClosure( archivaAdministration.getInvalidContentConsumers() );
 207         CollectionUtils.forAllDo( repoconsumerUtil.getAvailableInvalidConsumers(), addAdminRepoConsumer );
 208         this.invalidContentConsumers = addAdminRepoConsumer.getList();
 209         Collections.sort( invalidContentConsumers, AdminRepositoryConsumerComparator.getInstance() );
 210
 211         fileTypeIds = new ArrayList<String>();
 212         fileTypeIds.addAll( fileTypeMap.keySet() );
 213         Collections.sort( fileTypeIds );
 214     }
 215
 216     public void setFileTypeId( String fileTypeId )
 217     {
 218         this.fileTypeId = fileTypeId;
 219     }
 220
 221     public void setPattern( String pattern )
 222     {
 223         this.pattern = pattern;
 224     }
 225
 226     public String updateInvalidConsumers()
 227     {
 228
 229         try
 230         {
 231             List<String> oldConsumers = getArchivaAdministration().getInvalidContentConsumers();
 232
 233             if ( enabledInvalidContentConsumers != null )
 234             {
 235                 for ( String oldConsumer : oldConsumers )
 236                 {
 237                     if ( !enabledInvalidContentConsumers.contains( oldConsumer ) )
 238                     {
 239                         getArchivaAdministration().removeInvalidContentConsumer( oldConsumer, getAuditInformation() );
 240                     }
 241                 }
 242                 for ( String enabledKnowContentConsumer : enabledInvalidContentConsumers )
 243                 {
 244                     getArchivaAdministration().addInvalidContentConsumer( enabledKnowContentConsumer,
 245                                                                           getAuditInformation() );
 246                 }
 247             }
 248             else
 249             {
 250                 for ( String oldConsumer : oldConsumers )
 251                 {
 252                     getArchivaAdministration().removeInvalidContentConsumer( oldConsumer, getAuditInformation() );
 253                 }
 254             }
 255         }
 256         catch ( RepositoryAdminException e )
 257         {
 258             log.error( e.getMessage(), e );
 259             addActionError( "Error update invalidContentConsumers " + e.getMessage() );
 260             return INPUT;
 261         }
 262         addActionMessage( "Update Invalid Consumers" );
 263
 264         return SUCCESS;
 265     }
 266
 267     public String updateKnownConsumers()
 268     {
 269
 270         try
 271         {
 272             List<String> oldConsumers = getArchivaAdministration().getKnownContentConsumers();
 273
 274             if ( enabledKnownContentConsumers != null )
 275             {
 276                 for ( String oldConsumer : oldConsumers )
 277                 {
 278                     if ( !enabledKnownContentConsumers.contains( oldConsumer ) )
 279                     {
 280                         getArchivaAdministration().removeKnownContentConsumer( oldConsumer, getAuditInformation() );
 281                     }
 282                 }
 283                 for ( String enabledKnowContentConsumer : enabledKnownContentConsumers )
 284                 {
 285                     getArchivaAdministration().addKnownContentConsumer( enabledKnowContentConsumer,
 286                                                                         getAuditInformation() );
 287                 }
 288             }
 289             else
 290             {
 291                 for ( String oldConsumer : oldConsumers )
 292                 {
 293                     getArchivaAdministration().removeKnownContentConsumer( oldConsumer, getAuditInformation() );
 294                 }
 295             }
 296         }
 297         catch ( RepositoryAdminException e )
 298         {
 299             log.error( e.getMessage(), e );
 300             addActionError( "Error update knowContentConsumers " + e.getMessage() );
 301             return INPUT;
 302         }
 303         addActionMessage( "Update Known Consumers" );
 304
 305         return SUCCESS;
 306     }
 307
 308     private boolean isValidFiletypeCommand()
 309     {
 310         if ( StringUtils.isBlank( getFileTypeId() ) )
 311         {
 312             addActionError( "Unable to process blank filetype id." );
 313         }
 314
 315         if ( StringUtils.isBlank( getPattern() ) )
 316         {
 317             addActionError( "Unable to process blank pattern." );
 318         }
 319
 320         return !hasActionErrors();
 321     }
 322
 323
 324     public List<String> getEnabledInvalidContentConsumers()
 325     {
 326         return enabledInvalidContentConsumers;
 327     }
 328
 329     public void setEnabledInvalidContentConsumers( List<String> enabledInvalidContentConsumers )
 330     {
 331         this.enabledInvalidContentConsumers = enabledInvalidContentConsumers;
 332     }
 333
 334     public List<String> getEnabledKnownContentConsumers()
 335     {
 336         return enabledKnownContentConsumers;
 337     }
 338
 339     public void setEnabledKnownContentConsumers( List<String> enabledKnownContentConsumers )
 340     {
 341         this.enabledKnownContentConsumers = enabledKnownContentConsumers;
 342     }
 343
 344     public ArchivaAdministration getArchivaAdministration()
 345     {
 346         return archivaAdministration;
 347     }
 348
 349     public void setArchivaAdministration( ArchivaAdministration archivaAdministration )
 350     {
 351         this.archivaAdministration = archivaAdministration;
 352     }
 353 }