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