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