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