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