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.rest.services.utils.AddAdminRepoConsumerClosure;
  32 import org.apache.archiva.rest.services.utils.AdminRepositoryConsumerComparator;
  33 import org.apache.archiva.security.common.ArchivaRoleConstants;
  34 import org.apache.commons.collections.CollectionUtils;
  35 import org.apache.commons.lang.StringUtils;
  36 import org.apache.archiva.web.action.AbstractActionSupport;
  37 import org.apache.archiva.redback.rbac.Resource;
  38 import org.apache.archiva.redback.integration.interceptor.SecureAction;
  39 import org.apache.archiva.redback.integration.interceptor.SecureActionBundle;
  40 import org.apache.archiva.redback.integration.interceptor.SecureActionException;
  41 import org.springframework.context.annotation.Scope;
  42 import org.springframework.stereotype.Controller;
  43
  44 import javax.inject.Inject;
  45 import java.util.ArrayList;
  46 import java.util.Collections;
  47 import java.util.List;
  48 import java.util.Map;
  49
  50 /**
  51  * RepositoryScanningAction
  52  *
  53  * @version $Id$
  54  */
  55 @Controller( "repositoryScanningAction" )
  56 @Scope( "prototype" )
  57 public class RepositoryScanningAction
  58     extends AbstractActionSupport
  59     implements Preparable, Validateable, SecureAction, Auditable
  60 {
  61
  62     @Inject
  63     private RepositoryContentConsumers repoconsumerUtil;
  64
  65     @Inject
  66     private ArchivaAdministration archivaAdministration;
  67
  68     private Map<String, FileType> fileTypeMap;
  69
  70     private List<String> fileTypeIds;
  71
  72     /**
  73      * List of {@link org.apache.archiva.rest.api.model.AdminRepositoryConsumer} objects for consumers of known content.
  74      */
  75     private List<AdminRepositoryConsumer> knownContentConsumers;
  76
  77     /**
  78      * List of enabled {@link AdminRepositoryConsumer} objects for consumers of known content.
  79      */
  80     private List<String> enabledKnownContentConsumers;
  81
  82     /**
  83      * List of {@link AdminRepositoryConsumer} objects for consumers of invalid/unknown content.
  84      */
  85     private List<AdminRepositoryConsumer> invalidContentConsumers;
  86
  87     /**
  88      * List of enabled {@link AdminRepositoryConsumer} objects for consumers of invalid/unknown content.
  89      */
  90     private List<String> enabledInvalidContentConsumers;
  91
  92     private String pattern;
  93
  94     private String fileTypeId;
  95
  96     public void addActionError( String anErrorMessage )
  97     {
  98         super.addActionError( anErrorMessage );
  99         log.warn( "[ActionError] {}", anErrorMessage );
 100     }
 101
 102     public void addActionMessage( String aMessage )
 103     {
 104         super.addActionMessage( aMessage );
 105         log.info( "[ActionMessage] {}", aMessage );
 106     }
 107
 108     public void prepare()
 109         throws Exception
 110     {
 111         FiletypeToMapClosure filetypeToMapClosure = new FiletypeToMapClosure();
 112
 113         CollectionUtils.forAllDo( archivaAdministration.getFileTypes(), filetypeToMapClosure );
 114         fileTypeMap = filetypeToMapClosure.getMap();
 115
 116         AddAdminRepoConsumerClosure addAdminRepoConsumer =
 117             new AddAdminRepoConsumerClosure( archivaAdministration.getKnownContentConsumers() );
 118         CollectionUtils.forAllDo( repoconsumerUtil.getAvailableKnownConsumers(), addAdminRepoConsumer );
 119         this.knownContentConsumers = addAdminRepoConsumer.getList();
 120         Collections.sort( knownContentConsumers, AdminRepositoryConsumerComparator.getInstance() );
 121
 122         addAdminRepoConsumer = new AddAdminRepoConsumerClosure( archivaAdministration.getInvalidContentConsumers() );
 123         CollectionUtils.forAllDo( repoconsumerUtil.getAvailableInvalidConsumers(), addAdminRepoConsumer );
 124         this.invalidContentConsumers = addAdminRepoConsumer.getList();
 125         Collections.sort( invalidContentConsumers, AdminRepositoryConsumerComparator.getInstance() );
 126
 127         fileTypeIds = new ArrayList<String>();
 128         fileTypeIds.addAll( fileTypeMap.keySet() );
 129         Collections.sort( fileTypeIds );
 130     }
 131
 132     public String addFiletypePattern()
 133     {
 134         log.info( "Add New File Type Pattern [{}:{}]", getFileTypeId(), getPattern() );
 135
 136         if ( !isValidFiletypeCommand() )
 137         {
 138             return INPUT;
 139         }
 140
 141         try
 142         {
 143             getArchivaAdministration().addFileTypePattern( getFileTypeId(), getPattern(), getAuditInformation() );
 144         }
 145         catch ( RepositoryAdminException e )
 146         {
 147             addActionError( e.getMessage() );
 148             return INPUT;
 149         }
 150         return SUCCESS;
 151     }
 152
 153     public String removeFiletypePattern()
 154         throws RepositoryAdminException
 155     {
 156         log.info( "Remove File Type Pattern [{}:{}]", getFileTypeId(), getPattern() );
 157
 158         if ( !isValidFiletypeCommand() )
 159         {
 160             return INPUT;
 161         }
 162
 163         try
 164         {
 165             getArchivaAdministration().removeFileTypePattern( getFileTypeId(), getPattern(), getAuditInformation() );
 166         }
 167         catch ( RepositoryAdminException e )
 168         {
 169             addActionError( "error adding file type pattern " + e.getMessage() );
 170             return INPUT;
 171         }
 172
 173         return SUCCESS;
 174     }
 175
 176     public String getFileTypeId()
 177     {
 178         return fileTypeId;
 179     }
 180
 181     public List<String> getFileTypeIds()
 182     {
 183         return fileTypeIds;
 184     }
 185
 186     public Map<String, FileType> getFileTypeMap()
 187     {
 188         return fileTypeMap;
 189     }
 190
 191     public List<AdminRepositoryConsumer> getInvalidContentConsumers()
 192     {
 193         return invalidContentConsumers;
 194     }
 195
 196     public List<AdminRepositoryConsumer> getKnownContentConsumers()
 197     {
 198         return knownContentConsumers;
 199     }
 200
 201     public String getPattern()
 202     {
 203         return pattern;
 204     }
 205
 206     public SecureActionBundle getSecureActionBundle()
 207         throws SecureActionException
 208     {
 209         SecureActionBundle bundle = new SecureActionBundle();
 210
 211         bundle.setRequiresAuthentication( true );
 212         bundle.addRequiredAuthorization( ArchivaRoleConstants.OPERATION_MANAGE_CONFIGURATION, Resource.GLOBAL );
 213
 214         return bundle;
 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().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().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 boolean isValidFiletypeCommand()
 310     {
 311         if ( StringUtils.isBlank( getFileTypeId() ) )
 312         {
 313             addActionError( "Unable to process blank filetype id." );
 314         }
 315
 316         if ( StringUtils.isBlank( getPattern() ) )
 317         {
 318             addActionError( "Unable to process blank pattern." );
 319         }
 320
 321         return !hasActionErrors();
 322     }
 323
 324
 325     public List<String> getEnabledInvalidContentConsumers()
 326     {
 327         return enabledInvalidContentConsumers;
 328     }
 329
 330     public void setEnabledInvalidContentConsumers( List<String> enabledInvalidContentConsumers )
 331     {
 332         this.enabledInvalidContentConsumers = enabledInvalidContentConsumers;
 333     }
 334
 335     public List<String> getEnabledKnownContentConsumers()
 336     {
 337         return enabledKnownContentConsumers;
 338     }
 339
 340     public void setEnabledKnownContentConsumers( List<String> enabledKnownContentConsumers )
 341     {
 342         this.enabledKnownContentConsumers = enabledKnownContentConsumers;
 343     }
 344
 345     public ArchivaAdministration getArchivaAdministration()
 346     {
 347         return archivaAdministration;
 348     }
 349
 350     public void setArchivaAdministration( ArchivaAdministration archivaAdministration )
 351     {
 352         this.archivaAdministration = archivaAdministration;
 353     }
 354 }