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.archiva.admin.repository.RepositoryAdminException;
  24 import org.apache.archiva.admin.repository.proxyconnector.ProxyConnector;
  25 import org.apache.commons.lang.StringUtils;
  26 import org.apache.maven.archiva.configuration.ArchivaConfiguration;
  27 import org.apache.maven.archiva.policies.DownloadErrorPolicy;
  28 import org.apache.maven.archiva.policies.Policy;
  29 import org.apache.maven.archiva.policies.PostDownloadPolicy;
  30 import org.apache.maven.archiva.policies.PreDownloadPolicy;
  31
  32 import javax.annotation.PostConstruct;
  33 import javax.inject.Inject;
  34 import java.util.ArrayList;
  35 import java.util.HashMap;
  36 import java.util.List;
  37 import java.util.Map;
  38
  39 /**
  40  * AbstractProxyConnectorFormAction - generic fields and methods for either add or edit actions related with the
  41  * Proxy Connector.
  42  *
  43  * @version $Id$
  44  */
  45 public abstract class AbstractProxyConnectorFormAction
  46     extends AbstractProxyConnectorAction
  47     implements Preparable
  48 {
  49
  50
  51     private Map<String, PreDownloadPolicy> preDownloadPolicyMap;
  52
  53     private Map<String, PostDownloadPolicy> postDownloadPolicyMap;
  54
  55     private Map<String, DownloadErrorPolicy> downloadErrorPolicyMap;
  56
  57     private List<String> proxyIdOptions;
  58
  59     private List<String> managedRepoIdList;
  60
  61     private List<String> remoteRepoIdList;
  62
  63     /**
  64      * The map of policies that are available to be set.
  65      */
  66     private Map<String, Policy> policyMap;
  67
  68     /**
  69      * The property key to add or remove.
  70      */
  71     private String propertyKey;
  72
  73     /**
  74      * The property value to add.
  75      */
  76     private String propertyValue;
  77
  78     /**
  79      * The blacklist pattern to add.
  80      */
  81     private String blackListPattern;
  82
  83     /**
  84      * The whitelist pattern to add.
  85      */
  86     private String whiteListPattern;
  87
  88     /**
  89      * The pattern to add or remove (black or white).
  90      */
  91     private String pattern;
  92
  93     /**
  94      * The model for this action.
  95      */
  96     protected ProxyConnector connector;
  97
  98     @Inject
  99     private ArchivaConfiguration archivaConfiguration;
 100
 101     @PostConstruct
 102     public void initialize()
 103     {
 104         super.initialize();
 105         this.preDownloadPolicyMap = getBeansOfType( PreDownloadPolicy.class );
 106         this.postDownloadPolicyMap = getBeansOfType( PostDownloadPolicy.class );
 107         this.downloadErrorPolicyMap = getBeansOfType( DownloadErrorPolicy.class );
 108     }
 109
 110     protected List<String> escapePatterns( List<String> patterns )
 111     {
 112         List<String> escapedPatterns = new ArrayList<String>();
 113         if ( patterns != null )
 114         {
 115             for ( String pattern : patterns )
 116             {
 117                 escapedPatterns.add( StringUtils.replace( pattern, "\\", "\\\\" ) );
 118             }
 119         }
 120
 121         return escapedPatterns;
 122     }
 123
 124     protected List<String> unescapePatterns( List<String> patterns )
 125     {
 126         List<String> rawPatterns = new ArrayList<String>();
 127         if ( patterns != null )
 128         {
 129             for ( String pattern : patterns )
 130             {
 131                 rawPatterns.add( StringUtils.replace( pattern, "\\\\", "\\" ) );
 132             }
 133         }
 134
 135         return rawPatterns;
 136     }
 137
 138     private String escapePattern( String pattern )
 139     {
 140         return StringUtils.replace( pattern, "\\", "\\\\" );
 141     }
 142
 143     public String addBlackListPattern()
 144     {
 145         String pattern = getBlackListPattern();
 146
 147         if ( StringUtils.isBlank( pattern ) )
 148         {
 149             addActionError( "Cannot add a blank black list pattern." );
 150         }
 151
 152         if ( !hasActionErrors() )
 153         {
 154             getConnector().getBlackListPatterns().add( escapePattern( pattern ) );
 155             setBlackListPattern( null );
 156         }
 157
 158         return INPUT;
 159     }
 160
 161     @SuppressWarnings( "unchecked" )
 162     public String addProperty()
 163     {
 164         String key = getPropertyKey();
 165         String value = getPropertyValue();
 166
 167         if ( StringUtils.isBlank( key ) )
 168         {
 169             addActionError( "Unable to add property with blank key." );
 170         }
 171
 172         if ( StringUtils.isBlank( value ) )
 173         {
 174             addActionError( "Unable to add property with blank value." );
 175         }
 176
 177         if ( !hasActionErrors() )
 178         {
 179             getConnector().getProperties().put( key, value );
 180             setPropertyKey( null );
 181             setPropertyValue( null );
 182         }
 183
 184         return INPUT;
 185     }
 186
 187     public String addWhiteListPattern()
 188     {
 189         String pattern = getWhiteListPattern();
 190
 191         if ( StringUtils.isBlank( pattern ) )
 192         {
 193             addActionError( "Cannot add a blank white list pattern." );
 194         }
 195
 196         if ( !hasActionErrors() )
 197         {
 198             getConnector().getWhiteListPatterns().add( escapePattern( pattern ) );
 199             setWhiteListPattern( null );
 200         }
 201
 202         return INPUT;
 203     }
 204
 205     public String getBlackListPattern()
 206     {
 207         return blackListPattern;
 208     }
 209
 210     public ProxyConnector getConnector()
 211     {
 212         return connector;
 213     }
 214
 215     public List<String> getManagedRepoIdList()
 216     {
 217         return managedRepoIdList;
 218     }
 219
 220     public String getPattern()
 221     {
 222         return pattern;
 223     }
 224
 225     public Map<String, Policy> getPolicyMap()
 226     {
 227         return policyMap;
 228     }
 229
 230     public String getPropertyKey()
 231     {
 232         return propertyKey;
 233     }
 234
 235     public String getPropertyValue()
 236     {
 237         return propertyValue;
 238     }
 239
 240     public List<String> getProxyIdOptions()
 241     {
 242         return proxyIdOptions;
 243     }
 244
 245     public List<String> getRemoteRepoIdList()
 246     {
 247         return remoteRepoIdList;
 248     }
 249
 250     public String getWhiteListPattern()
 251     {
 252         return whiteListPattern;
 253     }
 254
 255     public void prepare()
 256         throws RepositoryAdminException
 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( ProxyConnector 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         throws RepositoryAdminException
 393     {
 394         return new ArrayList<String>( getManagedRepositoryAdmin().getManagedRepositoriesAsMap().keySet() );
 395     }
 396
 397     protected List<String> createNetworkProxyOptions()
 398     {
 399         List<String> options = new ArrayList<String>();
 400
 401         options.add( DIRECT_CONNECTION );
 402         options.addAll( archivaConfiguration.getConfiguration().getNetworkProxiesAsMap().keySet() );
 403
 404         return options;
 405     }
 406
 407     protected Map<String, Policy> createPolicyMap()
 408     {
 409         Map<String, Policy> policyMap = new HashMap<String, Policy>();
 410
 411         policyMap.putAll( preDownloadPolicyMap );
 412         policyMap.putAll( postDownloadPolicyMap );
 413         policyMap.putAll( downloadErrorPolicyMap );
 414
 415         return policyMap;
 416     }
 417
 418     protected List<String> createRemoteRepoOptions()
 419         throws RepositoryAdminException
 420     {
 421         return new ArrayList<String>( getRemoteRepositoryAdmin().getRemoteRepositoriesAsMap().keySet() );
 422     }
 423
 424     @SuppressWarnings( "unchecked" )
 425     protected void validateConnector()
 426     {
 427         if ( connector.getPolicies() == null )
 428         {
 429             addActionError( "Policies must be set." );
 430         }
 431         else
 432         {
 433             // Validate / Fix policy settings arriving from browser.
 434             for ( Map.Entry<String, Policy> entry : getPolicyMap().entrySet() )
 435             {
 436                 String policyId = entry.getKey();
 437                 Policy policy = entry.getValue();
 438                 List<String> options = policy.getOptions();
 439
 440                 if ( !connector.getPolicies().containsKey( policyId ) )
 441                 {
 442                     addActionError( "Policy [" + policyId + "] must be set (missing id)." );
 443                     continue;
 444                 }
 445
 446                 Map<String, String> properties = connector.getProperties();
 447                 for ( Map.Entry<String, String> entry2 : properties.entrySet() )
 448                 {
 449                     Object value = entry2.getValue();
 450                     if ( value.getClass().isArray() )
 451                     {
 452                         String[] arr = (String[]) value;
 453                         properties.put( entry2.getKey(), arr[0] );
 454                     }
 455                 }
 456
 457                 // Ugly hack to compensate for ugly browsers.
 458                 Object o = connector.getPolicies().get( policyId );
 459                 String value;
 460                 if ( o.getClass().isArray() )
 461                 {
 462                     String arr[] = (String[]) o;
 463                     value = arr[0];
 464                 }
 465                 else
 466                 {
 467                     value = (String) o;
 468                 }
 469
 470                 connector.getPolicies().put( policyId, value );
 471
 472                 if ( StringUtils.isBlank( value ) )
 473                 {
 474                     addActionError( "Policy [" + policyId + "] must be set (missing value)." );
 475                     continue;
 476                 }
 477
 478                 if ( !options.contains( value ) )
 479                 {
 480                     addActionError(
 481                         "Value of [" + value + "] is invalid for policy [" + policyId + "], valid values: " + options );
 482                     continue;
 483                 }
 484             }
 485         }
 486     }
 487
 488     public ArchivaConfiguration getArchivaConfiguration()
 489     {
 490         return archivaConfiguration;
 491     }
 492
 493     public void setArchivaConfiguration( ArchivaConfiguration archivaConfiguration )
 494     {
 495         this.archivaConfiguration = archivaConfiguration;
 496     }
 497 }