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

   1 package org.apache.maven.archiva.web.action.admin.connectors.proxy;
   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 java.util.ArrayList;
  23 import java.util.HashMap;
  24 import java.util.List;
  25 import java.util.Map;
  26
  27 import com.google.common.collect.Lists;
  28 import org.apache.archiva.audit.AuditListener;
  29 import org.apache.commons.lang.StringUtils;
  30 import org.apache.maven.archiva.configuration.ProxyConnectorConfiguration;
  31 import org.apache.maven.archiva.policies.DownloadErrorPolicy;
  32 import org.apache.maven.archiva.policies.Policy;
  33 import org.apache.maven.archiva.policies.PostDownloadPolicy;
  34 import org.apache.maven.archiva.policies.PreDownloadPolicy;
  35
  36 import com.opensymphony.xwork2.Preparable;
  37
  38 import javax.annotation.PostConstruct;
  39
  40 /**
  41  * AbstractProxyConnectorFormAction - generic fields and methods for either add or edit actions related with the
  42  * Proxy Connector.
  43  *
  44  * @version $Id$
  45  */
  46 public abstract class AbstractProxyConnectorFormAction
  47     extends AbstractProxyConnectorAction
  48     implements Preparable
  49 {
  50
  51     /**
  52      * plexus.requirement role="org.apache.maven.archiva.policies.PreDownloadPolicy"
  53      */
  54     private Map<String, PreDownloadPolicy> preDownloadPolicyMap;
  55
  56     /**
  57      * plexus.requirement role="org.apache.maven.archiva.policies.PostDownloadPolicy"
  58      */
  59     private Map<String, PostDownloadPolicy> postDownloadPolicyMap;
  60
  61     /**
  62      * plexus.requirement role="org.apache.maven.archiva.policies.DownloadErrorPolicy"
  63      */
  64     private Map<String, DownloadErrorPolicy> downloadErrorPolicyMap;
  65
  66     /**
  67      * The list of network proxy ids that are available.
  68      */
  69     private List<String> proxyIdOptions;
  70
  71     /**
  72      * The list of managed repository ids that are available.
  73      */
  74     private List<String> managedRepoIdList;
  75
  76     /**
  77      * The list of remove repository ids that are available.
  78      */
  79     private List<String> remoteRepoIdList;
  80
  81     /**
  82      * The map of policies that are available to be set.
  83      */
  84     private Map<String, Policy> policyMap;
  85
  86     /**
  87      * The property key to add or remove.
  88      */
  89     private String propertyKey;
  90
  91     /**
  92      * The property value to add.
  93      */
  94     private String propertyValue;
  95
  96     /**
  97      * The blacklist pattern to add.
  98      */
  99     private String blackListPattern;
 100
 101     /**
 102      * The whitelist pattern to add.
 103      */
 104     private String whiteListPattern;
 105
 106     /**
 107      * The pattern to add or remove (black or white).
 108      */
 109     private String pattern;
 110
 111     /**
 112      * The model for this action.
 113      */
 114     protected ProxyConnectorConfiguration connector;
 115
 116
 117     @PostConstruct
 118     public void initialize()
 119     {
 120         super.initialize();
 121         this.preDownloadPolicyMap = getBeansOfType( PreDownloadPolicy.class );
 122         this.postDownloadPolicyMap = getBeansOfType( PostDownloadPolicy.class );
 123         this.downloadErrorPolicyMap = getBeansOfType( DownloadErrorPolicy.class );
 124     }
 125
 126     protected List<String> escapePatterns( List<String> patterns )
 127     {
 128         List<String> escapedPatterns = new ArrayList<String>();
 129         if( patterns != null )
 130         {
 131             for( String pattern : patterns )
 132             {
 133                 escapedPatterns.add( StringUtils.replace( pattern, "\\", "\\\\" ) );
 134             }
 135         }
 136
 137         return escapedPatterns;
 138     }
 139
 140     protected List<String> unescapePatterns( List<String> patterns )
 141     {
 142         List<String> rawPatterns = new ArrayList<String>();
 143         if( patterns != null )
 144         {
 145             for( String pattern : patterns )
 146             {
 147                 rawPatterns.add( StringUtils.replace( pattern, "\\\\", "\\" ) );
 148             }
 149         }
 150
 151         return rawPatterns;
 152     }
 153
 154     private String escapePattern( String pattern )
 155     {
 156         return StringUtils.replace( pattern, "\\", "\\\\" );
 157     }
 158
 159     public String addBlackListPattern()
 160     {
 161         String pattern = getBlackListPattern();
 162
 163         if ( StringUtils.isBlank( pattern ) )
 164         {
 165             addActionError( "Cannot add a blank black list pattern." );
 166         }
 167
 168         if ( !hasActionErrors() )
 169         {
 170             getConnector().getBlackListPatterns().add( escapePattern( pattern ) );
 171             setBlackListPattern( null );
 172         }
 173
 174         return INPUT;
 175     }
 176
 177     @SuppressWarnings("unchecked")
 178     public String addProperty()
 179     {
 180         String key = getPropertyKey();
 181         String value = getPropertyValue();
 182
 183         if ( StringUtils.isBlank( key ) )
 184         {
 185             addActionError( "Unable to add property with blank key." );
 186         }
 187
 188         if ( StringUtils.isBlank( value ) )
 189         {
 190             addActionError( "Unable to add property with blank value." );
 191         }
 192
 193         if ( !hasActionErrors() )
 194         {
 195             getConnector().getProperties().put( key, value );
 196             setPropertyKey( null );
 197             setPropertyValue( null );
 198         }
 199
 200         return INPUT;
 201     }
 202
 203     public String addWhiteListPattern()
 204     {
 205         String pattern = getWhiteListPattern();
 206
 207         if ( StringUtils.isBlank( pattern ) )
 208         {
 209             addActionError( "Cannot add a blank white list pattern." );
 210         }
 211
 212         if ( !hasActionErrors() )
 213         {
 214             getConnector().getWhiteListPatterns().add( escapePattern( pattern ) );
 215             setWhiteListPattern( null );
 216         }
 217
 218         return INPUT;
 219     }
 220
 221     public String getBlackListPattern()
 222     {
 223         return blackListPattern;
 224     }
 225
 226     public ProxyConnectorConfiguration getConnector()
 227     {
 228         return connector;
 229     }
 230
 231     public List<String> getManagedRepoIdList()
 232     {
 233         return managedRepoIdList;
 234     }
 235
 236     public String getPattern()
 237     {
 238         return pattern;
 239     }
 240
 241     public Map<String, Policy> getPolicyMap()
 242     {
 243         return policyMap;
 244     }
 245
 246     public String getPropertyKey()
 247     {
 248         return propertyKey;
 249     }
 250
 251     public String getPropertyValue()
 252     {
 253         return propertyValue;
 254     }
 255
 256     public List<String> getProxyIdOptions()
 257     {
 258         return proxyIdOptions;
 259     }
 260
 261     public List<String> getRemoteRepoIdList()
 262     {
 263         return remoteRepoIdList;
 264     }
 265
 266     public String getWhiteListPattern()
 267     {
 268         return whiteListPattern;
 269     }
 270
 271     public void prepare()
 272     {
 273         proxyIdOptions = createNetworkProxyOptions();
 274         managedRepoIdList = createManagedRepoOptions();
 275         remoteRepoIdList = createRemoteRepoOptions();
 276         policyMap = createPolicyMap();
 277     }
 278
 279     public String removeBlackListPattern()
 280     {
 281         String pattern = getPattern();
 282
 283         if ( StringUtils.isBlank( pattern ) )
 284         {
 285             addActionError( "Cannot remove a blank black list pattern." );
 286         }
 287
 288         if ( !getConnector().getBlackListPatterns().contains( pattern ) &&
 289             !getConnector().getBlackListPatterns().contains( StringUtils.replace( pattern, "\\", "\\\\" ) ) )
 290         {
 291             addActionError( "Non-existant black list pattern [" + pattern + "], no black list pattern removed." );
 292         }
 293
 294         if ( !hasActionErrors() )
 295         {
 296             getConnector().getBlackListPatterns().remove( escapePattern( pattern ) );
 297         }
 298
 299         setBlackListPattern( null );
 300         setPattern( null );
 301
 302         return INPUT;
 303     }
 304
 305     public String removeProperty()
 306     {
 307         String key = getPropertyKey();
 308
 309         if ( StringUtils.isBlank( key ) )
 310         {
 311             addActionError( "Unable to remove property with blank key." );
 312         }
 313
 314         if ( !getConnector().getProperties().containsKey( key ) )
 315         {
 316             addActionError( "Non-existant property key [" + pattern + "], no property was removed." );
 317         }
 318
 319         if ( !hasActionErrors() )
 320         {
 321             getConnector().getProperties().remove( key );
 322         }
 323
 324         setPropertyKey( null );
 325         setPropertyValue( null );
 326
 327         return INPUT;
 328     }
 329
 330     public String removeWhiteListPattern()
 331     {
 332         String pattern = getPattern();
 333
 334         if ( StringUtils.isBlank( pattern ) )
 335         {
 336             addActionError( "Cannot remove a blank white list pattern." );
 337         }
 338
 339         if ( !getConnector().getWhiteListPatterns().contains( pattern ) &&
 340                 !getConnector().getWhiteListPatterns().contains( StringUtils.replace( pattern, "\\", "\\\\" ) ) )
 341         {
 342             addActionError( "Non-existant white list pattern [" + pattern + "], no white list pattern removed." );
 343         }
 344
 345         if ( !hasActionErrors() )
 346         {
 347             getConnector().getWhiteListPatterns().remove( escapePattern( pattern ) );
 348         }
 349
 350         setWhiteListPattern( null );
 351         setPattern( null );
 352
 353         return INPUT;
 354     }
 355
 356     public void setBlackListPattern( String blackListPattern )
 357     {
 358         this.blackListPattern = blackListPattern;
 359     }
 360
 361     public void setConnector( ProxyConnectorConfiguration connector )
 362     {
 363         this.connector = connector;
 364     }
 365
 366     public void setManagedRepoIdList( List<String> managedRepoIdList )
 367     {
 368         this.managedRepoIdList = managedRepoIdList;
 369     }
 370
 371     public void setPattern( String pattern )
 372     {
 373         this.pattern = pattern;
 374     }
 375
 376     public void setPolicyMap( Map<String, Policy> policyMap )
 377     {
 378         this.policyMap = policyMap;
 379     }
 380
 381     public void setPropertyKey( String propertyKey )
 382     {
 383         this.propertyKey = propertyKey;
 384     }
 385
 386     public void setPropertyValue( String propertyValue )
 387     {
 388         this.propertyValue = propertyValue;
 389     }
 390
 391     public void setProxyIdOptions( List<String> proxyIdOptions )
 392     {
 393         this.proxyIdOptions = proxyIdOptions;
 394     }
 395
 396     public void setRemoteRepoIdList( List<String> remoteRepoIdList )
 397     {
 398         this.remoteRepoIdList = remoteRepoIdList;
 399     }
 400
 401     public void setWhiteListPattern( String whiteListPattern )
 402     {
 403         this.whiteListPattern = whiteListPattern;
 404     }
 405
 406     protected List<String> createManagedRepoOptions()
 407     {
 408         return new ArrayList<String>( getConfig().getManagedRepositoriesAsMap().keySet() );
 409     }
 410
 411     protected List<String> createNetworkProxyOptions()
 412     {
 413         List<String> options = new ArrayList<String>();
 414
 415         options.add( DIRECT_CONNECTION );
 416         options.addAll( getConfig().getNetworkProxiesAsMap().keySet() );
 417
 418         return options;
 419     }
 420
 421     protected Map<String, Policy> createPolicyMap()
 422     {
 423         Map<String, Policy> policyMap = new HashMap<String, Policy>();
 424
 425         policyMap.putAll( preDownloadPolicyMap );
 426         policyMap.putAll( postDownloadPolicyMap );
 427         policyMap.putAll( downloadErrorPolicyMap );
 428
 429         return policyMap;
 430     }
 431
 432     protected List<String> createRemoteRepoOptions()
 433     {
 434         return new ArrayList<String>( getConfig().getRemoteRepositoriesAsMap().keySet() );
 435     }
 436
 437     @SuppressWarnings("unchecked")
 438     protected void validateConnector()
 439     {
 440         if ( connector.getPolicies() == null )
 441         {
 442             addActionError( "Policies must be set." );
 443         }
 444         else
 445         {
 446             // Validate / Fix policy settings arriving from browser.
 447             for ( Map.Entry<String, Policy> entry : getPolicyMap().entrySet() )
 448             {
 449                 String policyId = entry.getKey();
 450                 Policy policy = entry.getValue();
 451                 List<String> options = policy.getOptions();
 452
 453                 if ( !connector.getPolicies().containsKey( policyId ) )
 454                 {
 455                     addActionError( "Policy [" + policyId + "] must be set (missing id)." );
 456                     continue;
 457                 }
 458
 459                 Map<String, Object> properties = connector.getProperties();
 460                 for ( String key : properties.keySet() )
 461                 {
 462                     Object value = properties.get( key );
 463                     if ( value.getClass().isArray() )
 464                     {
 465                         String[] arr = (String[]) value;
 466                         properties.put( key, arr[0] );
 467                     }
 468                 }
 469
 470                 // Ugly hack to compensate for ugly browsers.
 471                 Object o = connector.getPolicies().get( policyId );
 472                 String value;
 473                 if ( o.getClass().isArray() )
 474                 {
 475                     String arr[] = (String[]) o;
 476                     value = arr[0];
 477                 }
 478                 else
 479                 {
 480                     value = (String) o;
 481                 }
 482
 483                 connector.getPolicies().put( policyId, value );
 484
 485                 if ( StringUtils.isBlank( value ) )
 486                 {
 487                     addActionError( "Policy [" + policyId + "] must be set (missing value)." );
 488                     continue;
 489                 }
 490
 491                 if ( !options.contains( value ) )
 492                 {
 493                     addActionError( "Value of [" + value + "] is invalid for policy [" + policyId + "], valid values: "
 494                         + options );
 495                     continue;
 496                 }
 497             }
 498         }
 499     }
 500 }