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