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     protected List<String> escapePatterns( List<String> patterns )
 113     {
 114         List<String> escapedPatterns = new ArrayList<String>();
 115         if( patterns != null )
 116         {
 117             for( String pattern : patterns )
 118             {
 119                 escapedPatterns.add( StringUtils.replace( pattern, "\\", "\\\\" ) );
 120             }
 121         }
 122
 123         return escapedPatterns;
 124     }
 125
 126     protected List<String> unescapePatterns( List<String> patterns )
 127     {
 128         List<String> rawPatterns = new ArrayList<String>();
 129         if( patterns != null )
 130         {
 131             for( String pattern : patterns )
 132             {
 133                 rawPatterns.add( StringUtils.replace( pattern, "\\\\", "\\" ) );
 134             }
 135         }
 136
 137         return rawPatterns;
 138     }
 139
 140     private String escapePattern( String pattern )
 141     {
 142         return StringUtils.replace( pattern, "\\", "\\\\" );
 143     }
 144
 145     public String addBlackListPattern()
 146     {
 147         String pattern = getBlackListPattern();
 148
 149         if ( StringUtils.isBlank( pattern ) )
 150         {
 151             addActionError( "Cannot add a blank black list pattern." );
 152         }
 153
 154         if ( !hasActionErrors() )
 155         {
 156             getConnector().getBlackListPatterns().add( escapePattern( pattern ) );
 157             setBlackListPattern( null );
 158         }
 159
 160         return INPUT;
 161     }
 162
 163     public String addProperty()
 164     {
 165         String key = getPropertyKey();
 166         String value = getPropertyValue();
 167
 168         if ( StringUtils.isBlank( key ) )
 169         {
 170             addActionError( "Unable to add property with blank key." );
 171         }
 172
 173         if ( StringUtils.isBlank( value ) )
 174         {
 175             addActionError( "Unable to add property with blank value." );
 176         }
 177
 178         if ( !hasActionErrors() )
 179         {
 180             getConnector().getProperties().put( key, value );
 181             setPropertyKey( null );
 182             setPropertyValue( null );
 183         }
 184
 185         return INPUT;
 186     }
 187
 188     public String addWhiteListPattern()
 189     {
 190         String pattern = getWhiteListPattern();
 191
 192         if ( StringUtils.isBlank( pattern ) )
 193         {
 194             addActionError( "Cannot add a blank white list pattern." );
 195         }
 196
 197         if ( !hasActionErrors() )
 198         {
 199             getConnector().getWhiteListPatterns().add( escapePattern( pattern ) );
 200             setWhiteListPattern( null );
 201         }
 202
 203         return INPUT;
 204     }
 205
 206     public String getBlackListPattern()
 207     {
 208         return blackListPattern;
 209     }
 210
 211     public ProxyConnectorConfiguration getConnector()
 212     {
 213         return connector;
 214     }
 215
 216     public List<String> getManagedRepoIdList()
 217     {
 218         return managedRepoIdList;
 219     }
 220
 221     public String getPattern()
 222     {
 223         return pattern;
 224     }
 225
 226     public Map<String, Policy> getPolicyMap()
 227     {
 228         return policyMap;
 229     }
 230
 231     public String getPropertyKey()
 232     {
 233         return propertyKey;
 234     }
 235
 236     public String getPropertyValue()
 237     {
 238         return propertyValue;
 239     }
 240
 241     public List<String> getProxyIdOptions()
 242     {
 243         return proxyIdOptions;
 244     }
 245
 246     public List<String> getRemoteRepoIdList()
 247     {
 248         return remoteRepoIdList;
 249     }
 250
 251     public String getWhiteListPattern()
 252     {
 253         return whiteListPattern;
 254     }
 255
 256     public void prepare()
 257     {
 258         proxyIdOptions = createNetworkProxyOptions();
 259         managedRepoIdList = createManagedRepoOptions();
 260         remoteRepoIdList = createRemoteRepoOptions();
 261         policyMap = createPolicyMap();
 262     }
 263
 264     public String removeBlackListPattern()
 265     {
 266         String pattern = getPattern();
 267
 268         if ( StringUtils.isBlank( pattern ) )
 269         {
 270             addActionError( "Cannot remove a blank black list pattern." );
 271         }
 272
 273         if ( !getConnector().getBlackListPatterns().contains( pattern ) &&
 274             !getConnector().getBlackListPatterns().contains( StringUtils.replace( pattern, "\\", "\\\\" ) ) )
 275         {
 276             addActionError( "Non-existant black list pattern [" + pattern + "], no black list pattern removed." );
 277         }
 278
 279         if ( !hasActionErrors() )
 280         {
 281             getConnector().getBlackListPatterns().remove( escapePattern( pattern ) );
 282         }
 283
 284         setBlackListPattern( null );
 285         setPattern( null );
 286
 287         return INPUT;
 288     }
 289
 290     public String removeProperty()
 291     {
 292         String key = getPropertyKey();
 293
 294         if ( StringUtils.isBlank( key ) )
 295         {
 296             addActionError( "Unable to remove property with blank key." );
 297         }
 298
 299         if ( !getConnector().getProperties().containsKey( key ) )
 300         {
 301             addActionError( "Non-existant property key [" + pattern + "], no property was removed." );
 302         }
 303
 304         if ( !hasActionErrors() )
 305         {
 306             getConnector().getProperties().remove( key );
 307         }
 308
 309         setPropertyKey( null );
 310         setPropertyValue( null );
 311
 312         return INPUT;
 313     }
 314
 315     public String removeWhiteListPattern()
 316     {
 317         String pattern = getPattern();
 318
 319         if ( StringUtils.isBlank( pattern ) )
 320         {
 321             addActionError( "Cannot remove a blank white list pattern." );
 322         }
 323
 324         if ( !getConnector().getWhiteListPatterns().contains( pattern ) &&
 325                 !getConnector().getWhiteListPatterns().contains( StringUtils.replace( pattern, "\\", "\\\\" ) ) )
 326         {
 327             addActionError( "Non-existant white list pattern [" + pattern + "], no white list pattern removed." );
 328         }
 329
 330         if ( !hasActionErrors() )
 331         {
 332             getConnector().getWhiteListPatterns().remove( escapePattern( pattern ) );
 333         }
 334
 335         setWhiteListPattern( null );
 336         setPattern( null );
 337
 338         return INPUT;
 339     }
 340
 341     public void setBlackListPattern( String blackListPattern )
 342     {
 343         this.blackListPattern = blackListPattern;
 344     }
 345
 346     public void setConnector( ProxyConnectorConfiguration connector )
 347     {
 348         this.connector = connector;
 349     }
 350
 351     public void setManagedRepoIdList( List<String> managedRepoIdList )
 352     {
 353         this.managedRepoIdList = managedRepoIdList;
 354     }
 355
 356     public void setPattern( String pattern )
 357     {
 358         this.pattern = pattern;
 359     }
 360
 361     public void setPolicyMap( Map<String, Policy> policyMap )
 362     {
 363         this.policyMap = policyMap;
 364     }
 365
 366     public void setPropertyKey( String propertyKey )
 367     {
 368         this.propertyKey = propertyKey;
 369     }
 370
 371     public void setPropertyValue( String propertyValue )
 372     {
 373         this.propertyValue = propertyValue;
 374     }
 375
 376     public void setProxyIdOptions( List<String> proxyIdOptions )
 377     {
 378         this.proxyIdOptions = proxyIdOptions;
 379     }
 380
 381     public void setRemoteRepoIdList( List<String> remoteRepoIdList )
 382     {
 383         this.remoteRepoIdList = remoteRepoIdList;
 384     }
 385
 386     public void setWhiteListPattern( String whiteListPattern )
 387     {
 388         this.whiteListPattern = whiteListPattern;
 389     }
 390
 391     protected List<String> createManagedRepoOptions()
 392     {
 393         return new ArrayList<String>( getConfig().getManagedRepositoriesAsMap().keySet() );
 394     }
 395
 396     protected List<String> createNetworkProxyOptions()
 397     {
 398         List<String> options = new ArrayList<String>();
 399
 400         options.add( DIRECT_CONNECTION );
 401         options.addAll( getConfig().getNetworkProxiesAsMap().keySet() );
 402
 403         return options;
 404     }
 405
 406     protected Map<String, Policy> createPolicyMap()
 407     {
 408         Map<String, Policy> policyMap = new HashMap<String, Policy>();
 409
 410         policyMap.putAll( preDownloadPolicyMap );
 411         policyMap.putAll( postDownloadPolicyMap );
 412         policyMap.putAll( downloadErrorPolicyMap );
 413
 414         return policyMap;
 415     }
 416
 417     protected List<String> createRemoteRepoOptions()
 418     {
 419         return new ArrayList<String>( getConfig().getRemoteRepositoriesAsMap().keySet() );
 420     }
 421
 422     protected void validateConnector()
 423     {
 424         if ( connector.getPolicies() == null )
 425         {
 426             addActionError( "Policies must be set." );
 427         }
 428         else
 429         {
 430             // Validate / Fix policy settings arriving from browser.
 431             for ( Map.Entry<String, Policy> entry : getPolicyMap().entrySet() )
 432             {
 433                 String policyId = entry.getKey();
 434                 Policy policy = entry.getValue();
 435                 List<String> options = policy.getOptions();
 436
 437                 if ( !connector.getPolicies().containsKey( policyId ) )
 438                 {
 439                     addActionError( "Policy [" + policyId + "] must be set (missing id)." );
 440                     continue;
 441                 }
 442
 443                 Map properties = connector.getProperties();
 444                 for ( Iterator j = properties.keySet().iterator(); j.hasNext(); )
 445                 {
 446                     String key = (String) j.next();
 447
 448                     Object value = properties.get( key );
 449                     if ( value.getClass().isArray() )
 450                     {
 451                         String[] arr = (String[]) value;
 452                         properties.put( key, arr[0] );
 453                     }
 454                 }
 455
 456                 // Ugly hack to compensate for ugly browsers.
 457                 Object o = connector.getPolicies().get( policyId );
 458                 String value;
 459                 if ( o.getClass().isArray() )
 460                 {
 461                     String arr[] = (String[]) o;
 462                     value = arr[0];
 463                 }
 464                 else
 465                 {
 466                     value = (String) o;
 467                 }
 468
 469                 connector.getPolicies().put( policyId, value );
 470
 471                 if ( StringUtils.isBlank( value ) )
 472                 {
 473                     addActionError( "Policy [" + policyId + "] must be set (missing value)." );
 474                     continue;
 475                 }
 476
 477                 if ( !options.contains( value ) )
 478                 {
 479                     addActionError( "Value of [" + value + "] is invalid for policy [" + policyId + "], valid values: "
 480                         + options );
 481                     continue;
 482                 }
 483             }
 484         }
 485     }
 486 }