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.admin.repository.RepositoryAdminException;
  25 import org.apache.archiva.admin.repository.admin.ArchivaAdministration;
  26 import org.apache.archiva.admin.repository.admin.FileType;
  27 import org.apache.archiva.admin.repository.admin.FiletypeToMapClosure;
  28 import org.apache.archiva.admin.repository.admin.RepositoryScanning;
  29 import org.apache.archiva.audit.Auditable;
  30 import org.apache.archiva.repository.scanner.RepositoryContentConsumers;
  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.maven.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 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 String addFiletypePattern()
 107     {
 108         log.info( "Add New File Type Pattern [{}:{}]", getFileTypeId(), getPattern() );
 109
 110         if ( !isValidFiletypeCommand() )
 111         {
 112             return INPUT;
 113         }
 114
 115         try
 116         {
 117             getArchivaAdministration().addFileTypePattern( getFileTypeId(), getPattern(), getAuditInformation() );
 118         }
 119         catch ( RepositoryAdminException e )
 120         {
 121             addActionError( "error adding file type pattern " + e.getMessage() );
 122             return INPUT;
 123         }
 124         return SUCCESS;
 125     }
 126
 127     public String removeFiletypePattern()
 128         throws RepositoryAdminException
 129     {
 130         log.info( "Remove File Type Pattern [{}:{}]", getFileTypeId(), getPattern() );
 131
 132         if ( !isValidFiletypeCommand() )
 133         {
 134             return INPUT;
 135         }
 136
 137         try
 138         {
 139             getArchivaAdministration().removeFileTypePattern( getFileTypeId(), getPattern(), getAuditInformation() );
 140         }
 141         catch ( RepositoryAdminException e )
 142         {
 143             addActionError( "error adding file type pattern " + e.getMessage() );
 144             return INPUT;
 145         }
 146
 147         return SUCCESS;
 148     }
 149
 150     public String getFileTypeId()
 151     {
 152         return fileTypeId;
 153     }
 154
 155     public List<String> getFileTypeIds()
 156     {
 157         return fileTypeIds;
 158     }
 159
 160     public Map<String, FileType> getFileTypeMap()
 161     {
 162         return fileTypeMap;
 163     }
 164
 165     public List<AdminRepositoryConsumer> getInvalidContentConsumers()
 166     {
 167         return invalidContentConsumers;
 168     }
 169
 170     public List<AdminRepositoryConsumer> getKnownContentConsumers()
 171     {
 172         return knownContentConsumers;
 173     }
 174
 175     public String getPattern()
 176     {
 177         return pattern;
 178     }
 179
 180     public SecureActionBundle getSecureActionBundle()
 181         throws SecureActionException
 182     {
 183         SecureActionBundle bundle = new SecureActionBundle();
 184
 185         bundle.setRequiresAuthentication( true );
 186         bundle.addRequiredAuthorization( ArchivaRoleConstants.OPERATION_MANAGE_CONFIGURATION, Resource.GLOBAL );
 187
 188         return bundle;
 189     }
 190
 191     public void prepare()
 192         throws Exception
 193     {
 194         RepositoryScanning reposcanning = archivaAdministration.getRepositoryScanning();
 195
 196         FiletypeToMapClosure filetypeToMapClosure = new FiletypeToMapClosure();
 197
 198         CollectionUtils.forAllDo( reposcanning.getFileTypes(), filetypeToMapClosure );
 199         fileTypeMap = filetypeToMapClosure.getMap();
 200
 201         AddAdminRepoConsumerClosure addAdminRepoConsumer =
 202             new AddAdminRepoConsumerClosure( reposcanning.getKnownContentConsumers() );
 203         CollectionUtils.forAllDo( repoconsumerUtil.getAvailableKnownConsumers(), addAdminRepoConsumer );
 204         this.knownContentConsumers = addAdminRepoConsumer.getList();
 205         Collections.sort( knownContentConsumers, AdminRepositoryConsumerComparator.getInstance() );
 206
 207         addAdminRepoConsumer = new AddAdminRepoConsumerClosure( reposcanning.getInvalidContentConsumers() );
 208         CollectionUtils.forAllDo( repoconsumerUtil.getAvailableInvalidConsumers(), addAdminRepoConsumer );
 209         this.invalidContentConsumers = addAdminRepoConsumer.getList();
 210         Collections.sort( invalidContentConsumers, AdminRepositoryConsumerComparator.getInstance() );
 211
 212         fileTypeIds = new ArrayList<String>();
 213         fileTypeIds.addAll( fileTypeMap.keySet() );
 214         Collections.sort( fileTypeIds );
 215     }
 216
 217     public void setFileTypeId( String fileTypeId )
 218     {
 219         this.fileTypeId = fileTypeId;
 220     }
 221
 222     public void setPattern( String pattern )
 223     {
 224         this.pattern = pattern;
 225     }
 226
 227     public String updateInvalidConsumers()
 228     {
 229
 230         try
 231         {
 232             List<String> oldConsumers = getArchivaAdministration().getRepositoryScanning().getInvalidContentConsumers();
 233
 234             if ( enabledInvalidContentConsumers != null )
 235             {
 236                 for ( String oldConsumer : oldConsumers )
 237                 {
 238                     if ( !enabledInvalidContentConsumers.contains( oldConsumer ) )
 239                     {
 240                         getArchivaAdministration().removeInvalidContentConsumer( oldConsumer, getAuditInformation() );
 241                     }
 242                 }
 243                 for ( String enabledKnowContentConsumer : enabledInvalidContentConsumers )
 244                 {
 245                     getArchivaAdministration().addInvalidContentConsumer( enabledKnowContentConsumer,
 246                                                                           getAuditInformation() );
 247                 }
 248             }
 249             else
 250             {
 251                 for ( String oldConsumer : oldConsumers )
 252                 {
 253                     getArchivaAdministration().removeInvalidContentConsumer( oldConsumer, getAuditInformation() );
 254                 }
 255             }
 256         }
 257         catch ( RepositoryAdminException e )
 258         {
 259             log.error( e.getMessage(), e );
 260             addActionError( "Error update invalidContentConsumers " + e.getMessage() );
 261             return INPUT;
 262         }
 263         addActionMessage( "Update Invalid Consumers" );
 264
 265         return SUCCESS;
 266     }
 267
 268     public String updateKnownConsumers()
 269     {
 270
 271         try
 272         {
 273             List<String> oldConsumers = getArchivaAdministration().getRepositoryScanning().getKnownContentConsumers();
 274
 275             if ( enabledKnownContentConsumers != null )
 276             {
 277                 for ( String oldConsumer : oldConsumers )
 278                 {
 279                     if ( !enabledKnownContentConsumers.contains( oldConsumer ) )
 280                     {
 281                         getArchivaAdministration().removeKnownContentConsumer( oldConsumer, getAuditInformation() );
 282                     }
 283                 }
 284                 for ( String enabledKnowContentConsumer : enabledKnownContentConsumers )
 285                 {
 286                     getArchivaAdministration().addKnownContentConsumer( enabledKnowContentConsumer,
 287                                                                         getAuditInformation() );
 288                 }
 289             }
 290             else
 291             {
 292                 for ( String oldConsumer : oldConsumers )
 293                 {
 294                     getArchivaAdministration().removeKnownContentConsumer( oldConsumer, getAuditInformation() );
 295                 }
 296             }
 297         }
 298         catch ( RepositoryAdminException e )
 299         {
 300             log.error( e.getMessage(), e );
 301             addActionError( "Error update knowContentConsumers " + e.getMessage() );
 302             return INPUT;
 303         }
 304         addActionMessage( "Update Known Consumers" );
 305
 306         return SUCCESS;
 307     }
 308
 309     private FileType findFileType( String id )
 310         throws RepositoryAdminException
 311     {
 312         return getArchivaAdministration().getFileType( id );
 313     }
 314
 315     private boolean isValidFiletypeCommand()
 316     {
 317         if ( StringUtils.isBlank( getFileTypeId() ) )
 318         {
 319             addActionError( "Unable to process blank filetype id." );
 320         }
 321
 322         if ( StringUtils.isBlank( getPattern() ) )
 323         {
 324             addActionError( "Unable to process blank pattern." );
 325         }
 326
 327         return !hasActionErrors();
 328     }
 329
 330
 331     public List<String> getEnabledInvalidContentConsumers()
 332     {
 333         return enabledInvalidContentConsumers;
 334     }
 335
 336     public void setEnabledInvalidContentConsumers( List<String> enabledInvalidContentConsumers )
 337     {
 338         this.enabledInvalidContentConsumers = enabledInvalidContentConsumers;
 339     }
 340
 341     public List<String> getEnabledKnownContentConsumers()
 342     {
 343         return enabledKnownContentConsumers;
 344     }
 345
 346     public void setEnabledKnownContentConsumers( List<String> enabledKnownContentConsumers )
 347     {
 348         this.enabledKnownContentConsumers = enabledKnownContentConsumers;
 349     }
 350
 351     public ArchivaAdministration getArchivaAdministration()
 352     {
 353         return archivaAdministration;
 354     }
 355
 356     public void setArchivaAdministration( ArchivaAdministration archivaAdministration )
 357     {
 358         this.archivaAdministration = archivaAdministration;
 359     }
 360 }