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