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

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