KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > sun > enterprise > web > TomcatDeploymentConfig


1 /*
2  * The contents of this file are subject to the terms
3  * of the Common Development and Distribution License
4  * (the License). You may not use this file except in
5  * compliance with the License.
6  *
7  * You can obtain a copy of the license at
8  * https://glassfish.dev.java.net/public/CDDLv1.0.html or
9  * glassfish/bootstrap/legal/CDDLv1.0.txt.
10  * See the License for the specific language governing
11  * permissions and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL
14  * Header Notice in each file and include the License file
15  * at glassfish/bootstrap/legal/CDDLv1.0.txt.
16  * If applicable, add the following below the CDDL Header,
17  * with the fields enclosed by brackets [] replaced by
18  * you own identifying information:
19  * "Portions Copyrighted [year] [name of copyright owner]"
20  *
21  * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
22  */

23
24 package com.sun.enterprise.web;
25
26 import java.util.Collection JavaDoc;
27 import java.util.Enumeration JavaDoc;
28 import java.util.Iterator JavaDoc;
29 import java.util.Set JavaDoc;
30 import java.util.Vector JavaDoc;
31 import java.util.logging.Logger JavaDoc;
32 import java.util.logging.Level JavaDoc;
33
34 import com.sun.enterprise.deployment.EjbReferenceDescriptor;
35 import com.sun.enterprise.deployment.EnvironmentProperty;
36 import com.sun.enterprise.deployment.SecurityRoleDescriptor;
37 import com.sun.enterprise.deployment.WebBundleDescriptor;
38 import com.sun.enterprise.deployment.JspConfigDescriptor;
39 import com.sun.enterprise.deployment.JspGroupDescriptor;
40 import com.sun.enterprise.deployment.ResourceReferenceDescriptor;
41 import com.sun.enterprise.deployment.MessageDestinationDescriptor;
42 import com.sun.enterprise.deployment.MessageDestinationReferenceDescriptor;
43 import com.sun.enterprise.deployment.WebComponentDescriptor;
44 import com.sun.enterprise.deployment.LocaleEncodingMappingListDescriptor;
45 import com.sun.enterprise.deployment.LocaleEncodingMappingDescriptor;
46 import com.sun.enterprise.deployment.TagLibConfigurationDescriptor;
47
48 import com.sun.enterprise.deployment.web.AuthorizationConstraint;
49 import com.sun.enterprise.deployment.web.AppListenerDescriptor;
50 import com.sun.enterprise.deployment.web.ContextParameter;
51 import com.sun.enterprise.deployment.web.EnvironmentEntry;
52 import com.sun.enterprise.deployment.web.ErrorPageDescriptor;
53 import com.sun.enterprise.deployment.web.InitializationParameter;
54 import com.sun.enterprise.deployment.web.LoginConfiguration;
55 import com.sun.enterprise.deployment.web.MimeMapping;
56 import com.sun.enterprise.deployment.web.ResourceReference;
57 import com.sun.enterprise.deployment.web.ServletFilter;
58 import com.sun.enterprise.deployment.web.ServletFilterMapping;
59 import com.sun.enterprise.deployment.web.SecurityConstraint;
60 import com.sun.enterprise.deployment.web.SecurityRoleReference;
61 import com.sun.enterprise.deployment.web.WebResourceCollection;
62
63 import com.sun.enterprise.web.WebModule;
64 import com.sun.enterprise.web.deploy.ContextEjbDecorator;
65 import com.sun.enterprise.web.deploy.ContextEnvironmentDecorator;
66 import com.sun.enterprise.web.deploy.ContextLocalEjbDecorator;
67 import com.sun.enterprise.web.deploy.ContextResourceDecorator;
68 import com.sun.enterprise.web.deploy.ErrorPageDecorator;
69 import com.sun.enterprise.web.deploy.FilterDefDecorator;
70 import com.sun.enterprise.web.deploy.LoginConfigDecorator;
71 import com.sun.enterprise.web.deploy.MessageDestinationDecorator;
72 import com.sun.enterprise.web.deploy.MessageDestinationRefDecorator;
73 import com.sun.enterprise.web.deploy.SecurityConstraintDecorator;
74 import com.sun.enterprise.web.deploy.SecurityCollectionDecorator;
75
76 import com.sun.logging.LogDomains;
77
78 import org.apache.catalina.Lifecycle;
79 import org.apache.catalina.Container;
80 import org.apache.catalina.Wrapper;
81 import org.apache.catalina.core.StandardWrapper;
82 import org.apache.catalina.deploy.ContextEjb;
83 import org.apache.catalina.deploy.ContextLocalEjb;
84 import org.apache.catalina.deploy.ContextEnvironment;
85 import org.apache.catalina.deploy.ErrorPage;
86 import org.apache.catalina.deploy.FilterDef;
87 import org.apache.catalina.deploy.FilterMap;
88 import org.apache.catalina.deploy.ContextResource;
89 import org.apache.catalina.deploy.ApplicationParameter;
90 import org.apache.catalina.deploy.MessageDestination;
91 import org.apache.catalina.deploy.MessageDestinationRef;
92 import org.apache.catalina.deploy.LoginConfig;
93 import org.apache.catalina.util.CharsetMapper;
94
95 /**
96  * This class decorates all <code>com.sun.enterprise.deployment.*</code>
97  * objects in order to make them usuable by the Catalina container.
98  * This avoid having duplicate memory representation of the web.xml (as well
99  * as parsing the web.xml twice)
100  *
101  * @author Jean-Francois Arcand
102  */

103 public class TomcatDeploymentConfig{
104
105     private static Logger JavaDoc logger = LogDomains.getLogger(LogDomains.WEB_LOGGER);
106     /**
107      * Single instance used as a singleton.
108      */

109     private static TomcatDeploymentConfig tomcatDeploymentConfig;
110     
111     
112     /**
113      * Empty constructor
114      */

115     public TomcatDeploymentConfig(){
116     }
117     
118     
119     /**
120      * Configure a <code>WebModule</code> by applying default-web.xml
121      * information contained in the default <code>WebModule</code>.
122      *
123      * @param webModule Web Module to be configured with default web module
124      * @param defaultWebModule Default web module
125      */

126     public static void configureWebModule(WebModule webModule,
127                                           WebModule defaultWebModule){
128                                               
129         configureStandardContext(webModule,defaultWebModule);
130         
131         configureContextParam(webModule,defaultWebModule);
132
133         configureApplicationListener(webModule,defaultWebModule);
134         
135         configureEjbReference(webModule,defaultWebModule);
136  
137         configureContextEnvironment(webModule,defaultWebModule);
138         
139         configureErrorPage(webModule,defaultWebModule);
140
141         configureFilterDef(webModule,defaultWebModule);
142
143         configureFilterMap(webModule,defaultWebModule);
144         
145         configureLoginConfig(webModule,defaultWebModule);
146         
147         configureMimeMapping(webModule,defaultWebModule);
148         
149         configureResourceRef(webModule,defaultWebModule);
150
151         configureMessageDestination(webModule,defaultWebModule);
152         
153         configureMessageRef(webModule,defaultWebModule);
154         
155  
156     }
157     
158     
159     /**
160      * Configure a <code>WebModule</code> by applying web.xml information
161      * contained in <code>WebBundleDescriptor</code>. This astatic void calling
162      * Tomcat 5 internal deployment mechanism by re-using the DOL objects.
163      */

164     public static void configureWebModule(WebModule webModule,
165                                           WebBundleDescriptor webModuleDescriptor) {
166
167         // When context root = "/"
168
if ( webModuleDescriptor == null ){
169             return;
170         }
171         
172         webModule.setDisplayName(webModuleDescriptor.getDisplayName());
173         webModule.setDistributable(webModuleDescriptor.isDistributable());
174         webModule.setReplaceWelcomeFiles(true);
175         
176         configureStandardContext(webModule,webModuleDescriptor);
177         
178         configureContextParam(webModule,webModuleDescriptor);
179
180         configureApplicationListener(webModule,webModuleDescriptor);
181         
182         configureEjbReference(webModule,webModuleDescriptor);
183  
184         configureContextEnvironment(webModule,webModuleDescriptor);
185         
186         configureErrorPage(webModule,webModuleDescriptor);
187
188         configureFilterDef(webModule,webModuleDescriptor);
189
190         configureFilterMap(webModule,webModuleDescriptor);
191         
192         configureLoginConfig(webModule,webModuleDescriptor);
193         
194         configureMimeMapping(webModule,webModuleDescriptor);
195         
196         configureResourceRef(webModule,webModuleDescriptor);
197
198         configureMessageDestination(webModule,webModuleDescriptor);
199
200         configureContextResource(webModule,webModuleDescriptor);
201
202         configureSecurityConstraint(webModule,webModuleDescriptor);
203         
204         configureJspConfig(webModule,webModuleDescriptor);
205         
206         configureSecurityRoles(webModule, webModuleDescriptor);
207
208     }
209
210     
211     /**
212      * Configures EJB resource reference for a web application, as
213      * represented in a <code>&lt;ejb-ref&gt;</code> and
214      * <code>&lt;ejb-local-ref&gt;</code>element in the
215      * deployment descriptor.
216      */

217     protected static void configureEjbReference(WebModule webModule,
218                                          WebBundleDescriptor wmd) {
219                                                         
220        Set JavaDoc set = wmd.getEjbReferenceDescriptors();
221        Iterator JavaDoc iterator = set.iterator();
222        
223        EjbReferenceDescriptor ejbDescriptor;
224        while( iterator.hasNext() ){
225             
226            ejbDescriptor = (EjbReferenceDescriptor)iterator.next();
227            if ( ejbDescriptor.isLocal() ){
228                 configureContextLocalEjb(webModule,ejbDescriptor);
229            } else {
230                 configureContextEjb(webModule,ejbDescriptor);
231            }
232        }
233     }
234     
235      
236     /**:q
237      *
238      * Configures EJB resource reference for a web application, as
239      * represented in a <code>&lt;ejb-ref&gt;</code> and
240      * <code>&lt;ejb-local-ref&gt;</code>element in the
241      * deployment descriptor.
242      */

243     protected static void configureEjbReference(WebModule webModule,
244                                                 WebModule defaultWebModule) {
245          
246         ContextLocalEjb[] localEjbs = (ContextLocalEjb[])
247                             defaultWebModule.getCachedFindOperation()
248                                         [WebModuleContextConfig.LOCAL_EJBS];
249         for (int i=0; i < localEjbs.length; i++){
250             webModule.addLocalEjb(localEjbs[i]);
251         }
252         
253         ContextEjb[] ejbs = (ContextEjb[])
254                             defaultWebModule.getCachedFindOperation()
255                                                 [WebModuleContextConfig.EJBS];
256         for (int i=0; i <ejbs.length; i++){
257             webModule.addEjb(ejbs[i]);
258         }
259     }
260     
261     
262     /**
263      * Configures EJB resource reference for a web application, as
264      * represented in a <code>&lt;ejb-ref&gt;</code> in the
265      * deployment descriptor.
266      */

267     protected static void configureContextLocalEjb(WebModule webModule,
268                                         EjbReferenceDescriptor ejbDescriptor) {
269         ContextLocalEjbDecorator decorator =
270                                 new ContextLocalEjbDecorator(ejbDescriptor);
271         webModule.addLocalEjb(decorator);
272     
273     }
274
275     
276     /**
277      * Configures EJB resource reference for a web application, as
278      * represented in a <code>&lt;ejb-local-ref&gt;</code>element in the
279      * deployment descriptor.
280      */

281     protected static void configureContextEjb(WebModule webModule,
282                                        EjbReferenceDescriptor ejbDescriptor) {
283                                          
284         ContextEjbDecorator decorator = new ContextEjbDecorator(ejbDescriptor);
285         webModule.addEjb(decorator);
286         
287     }
288
289     
290     /**
291      * Configure application environment entry, as represented in
292      * an <code>&lt;env-entry&gt;</code> element in the deployment descriptor.
293      */

294     protected static void configureContextEnvironment(WebModule webModule,
295                                                  WebBundleDescriptor wmd) {
296                                                         
297         Set JavaDoc set = wmd.getContextParametersSet();
298         Iterator JavaDoc iterator = set.iterator();
299           
300         ContextEnvironmentDecorator decorator;
301         EnvironmentProperty envRef;
302         while (iterator.hasNext()){
303             envRef = (EnvironmentProperty)iterator.next();
304             decorator = new ContextEnvironmentDecorator(envRef);
305             webModule.addEnvironment(decorator);
306         }
307     }
308
309     
310     /**
311      * Configure application environment entry, as represented in
312      * an <code>&lt;env-entry&gt;</code> element in the deployment descriptor.
313      */

314     protected static void configureContextEnvironment(
315                                     WebModule webModule,
316                                     WebModule defaultWebModule) {
317                                                         
318        ContextEnvironment[] contextEnvironment = (ContextEnvironment[])
319                     defaultWebModule.getCachedFindOperation()
320                                         [WebModuleContextConfig.ENVIRONMENTS];
321        for(int i=0; i < contextEnvironment.length; i++){
322             webModule.addEnvironment(contextEnvironment[i]);
323        }
324     }
325     
326     
327     /**
328      * Configure error page element for a web application,
329      * as represented in a <code>&lt;error-page&gt;</code> element in the
330      * deployment descriptor.
331      */

332     protected static void configureErrorPage(WebModule webModule,
333                                       WebBundleDescriptor wmd) {
334             
335        Enumeration JavaDoc enumeration = wmd.getErrorPageDescriptors();
336        
337        ErrorPageDescriptor errorPageDesc;
338        ErrorPageDecorator decorator;
339        while (enumeration.hasMoreElements()){
340             errorPageDesc = (ErrorPageDescriptor)enumeration.nextElement();
341             decorator = new ErrorPageDecorator(errorPageDesc);
342             webModule.addErrorPage(decorator);
343        }
344                                              
345     }
346     
347     
348     /**
349      * Configure error page element for a web application,
350      * as represented in a <code>&lt;error-page&gt;</code> element in the
351      * deployment descriptor.
352      */

353     protected static void configureErrorPage(WebModule webModule,
354                                              WebModule defaultWebModule) {
355             
356        ErrorPage[] errorPages = (ErrorPage[])
357                         defaultWebModule.getCachedFindOperation()
358                                     [WebModuleContextConfig.ERROR_PAGES];
359                                                  
360        for(int i=0; i < errorPages.length; i++){
361             webModule.addErrorPage(errorPages[i]);
362        }
363                                              
364     }
365        
366     
367     /**
368      * Configure filter definition for a web application, as represented
369      * in a <code>&lt;filter&gt;</code> element in the deployment descriptor.
370      */

371     protected static void configureFilterDef(WebModule webModule,
372                                       WebBundleDescriptor wmd) {
373                                                         
374        Vector JavaDoc vector = wmd.getServletFilters();
375        
376        FilterDefDecorator filterDef;
377        ServletFilter servletFilter;
378        
379        for (int i=0; i < vector.size(); i++) {
380            servletFilter = (ServletFilter)vector.get(i);
381            filterDef = new FilterDefDecorator(servletFilter);
382           
383            webModule.addFilterDef(filterDef);
384        }
385                                                                      
386     }
387     
388     
389     /**
390      * Configure filter definition for a web application, as represented
391      * in a <code>&lt;filter&gt;</code> element in the deployment descriptor.
392      */

393     protected static void configureFilterDef(WebModule webModule,
394                                              WebModule defaultWebModule) {
395                                                         
396        FilterDef[] filterDefs = (FilterDef[])
397             defaultWebModule.getCachedFindOperation()
398                                         [WebModuleContextConfig.FILTER_DEFS];
399        
400        for (int i=0; i < filterDefs.length; i++) {
401            webModule.addFilterDef(filterDefs[i]);
402        }
403                                                                      
404     }
405     
406     
407     /**
408      * Configure filter mapping for a web application, as represented
409      * in a <code>&lt;filter-mapping&gt;</code> element in the deployment
410      * descriptor. Each filter mapping must contain a filter name plus either
411      * a URL pattern or a servlet name.
412      */

413     protected static void configureFilterMap(WebModule webModule,
414                                              WebBundleDescriptor wmd) {
415                                                         
416         Vector JavaDoc vector = wmd.getServletFilterMappingDescriptors();
417         for (int i=0; i < vector.size(); i++) {
418             webModule.addFilterMap((ServletFilterMapping)vector.get(i));
419         }
420     }
421     
422     
423     /**
424      * Configure filter mapping for a web application, as represented
425      * in a <code>&lt;filter-mapping&gt;</code> element in the deployment
426      * descriptor. Each filter mapping must contain a filter name plus either
427      * a URL pattern or a servlet name.
428      */

429     protected static void configureFilterMap(WebModule webModule,
430                                              WebModule defaultWebModule) {
431                                                         
432         FilterMap[] filterMaps = (FilterMap[])
433                         defaultWebModule.getCachedFindOperation()
434                                         [WebModuleContextConfig.FILTER_MAPS];
435        
436         for (int i=0; i < filterMaps.length; i++) {
437             webModule.addFilterMap(filterMaps[i]);
438         }
439     }
440     
441     
442     /**
443      * Configure context initialization parameter that is configured
444      * in the server configuration file, rather than the application deployment
445      * descriptor. This is convenient for establishing default values (which
446      * may be configured to allow application overrides or not) without having
447      * to modify the application deployment descriptor itself.
448      */

449     protected static void configureApplicationListener( WebModule webModule,
450                                                         WebModule defaultWebModule) {
451         
452        String JavaDoc[] applicationListeners = (String JavaDoc[])
453                      defaultWebModule.getCachedFindOperation()
454                                 [WebModuleContextConfig.APPLICATION_LISTENERS];
455        
456        for (int i=0; i < applicationListeners.length ; i++){
457             webModule.addApplicationListener(applicationListeners[i]);
458        }
459          
460     }
461     
462     
463     /**
464      * Configure context initialization parameter that is configured
465      * in the server configuration file, rather than the application deployment
466      * descriptor. This is convenient for establishing default values (which
467      * may be configured to allow application overrides or not) without having
468      * to modify the application deployment descriptor itself.
469      */

470     protected static void configureApplicationListener( WebModule webModule,
471                                                     WebBundleDescriptor wmd) {
472         
473         Vector JavaDoc vector = wmd.getAppListenerDescriptors();
474         for (int i=0; i < vector.size() ; i++){
475             webModule.addApplicationListener(
476                         ((AppListenerDescriptor)vector.get(i)).getListener() );
477         }
478          
479     }
480     
481     
482     /**
483      * Configure <code>jsp-config</code> element contained in the deployment
484      * descriptor
485      */

486     protected static void configureJspConfig( WebModule webModule,
487                                        WebBundleDescriptor wmd) {
488                                                         
489        JspConfigDescriptor jspConfigDescriptor = wmd.getJspConfigDescriptor();
490        
491        if ( jspConfigDescriptor == null ){
492             return;
493        }
494        
495        Collection JavaDoc set = jspConfigDescriptor.getJspGroupSet();
496        if ( set.isEmpty() ){
497            return;
498        }
499        Iterator JavaDoc iterator = set.iterator();
500        
501        JspGroupDescriptor jspGroupDescriptor;
502        
503        Iterator JavaDoc iterator2;
504        while (iterator.hasNext()){
505            jspGroupDescriptor = (JspGroupDescriptor)iterator.next();
506            
507            iterator2 = jspGroupDescriptor.getUrlPatternsSet().iterator();
508            while (iterator2.hasNext()){
509                webModule.addJspMapping( (String JavaDoc)iterator2.next() );
510            }
511        }
512         
513        // REVISIT: DO NOT manually add the TagLib since they will be scanned by
514
// class org.apache.catalina.startup.TldConfig
515
//
516
/*
517        set = jspConfigDescriptor.getTagLibSet();
518        iterator = set.iterator();
519        TagLibConfigurationDescriptor tlcd = null;
520        while (iterator.hasNext()){
521            tlcd = (TagLibConfigurationDescriptor)iterator.next();
522            
523            // XXX substring to avoid making changes in TLDConfig
524            webModule.addTaglib( tlcd.getTagLibURI(),
525                                 tlcd.getTagLibLocation());
526        }
527         **/

528        
529     }
530
531         
532     /**
533      * Configure a login configuration element for a web application,
534      * as represented in a <code>&lt;login-config&gt;</code> element in the
535      * deployment descriptor.
536      */

537     protected static void configureLoginConfig(WebModule webModule,
538                                                WebModule defaultWebModule) {
539         LoginConfig loginConf = defaultWebModule.getLoginConfig();
540         if ( loginConf == null ){
541             return;
542         }
543         webModule.setLoginConfig(loginConf);
544         
545     }
546     
547     
548     /**
549      * Configure a login configuration element for a web application,
550      * as represented in a <code>&lt;login-config&gt;</code> element in the
551      * deployment descriptor.
552      */

553     protected static void configureLoginConfig(WebModule webModule,
554                                         WebBundleDescriptor wmd) {
555                                             
556         LoginConfiguration loginConf = wmd.getLoginConfiguration();
557         if ( loginConf == null ){
558             return;
559         }
560
561         LoginConfigDecorator decorator = new LoginConfigDecorator(loginConf);
562         webModule.setLoginConfig(decorator);
563     }
564     
565     
566     /**
567      * Configure mime-mapping defined in the deployment descriptor.
568      */

569     protected static void configureMimeMapping(WebModule webModule,
570                                                WebBundleDescriptor wmd) {
571                                                         
572         Enumeration JavaDoc enumeration = wmd.getMimeMappings();
573         MimeMapping mimeMapping;
574         while (enumeration.hasMoreElements()){
575             mimeMapping = (MimeMapping)enumeration.nextElement();
576             webModule.addMimeMapping(mimeMapping.getExtension(),
577                                      mimeMapping.getMimeType());
578         }
579                                                         
580     }
581     
582     
583     /**
584      * Adds the MIME mappings defined in default-web.xml to the given
585      * web module.
586      *
587      * @param webModule Web module to which the MIME mappings specified in
588      * default-web.xml are to be added
589      * @param defaultWebModule Web Module representing default-web.xml
590      */

591     protected static void configureMimeMapping(WebModule webModule,
592                                                WebModule defaultWebModule) {
593         String JavaDoc[] mimeMappings = (String JavaDoc[])
594             defaultWebModule.getCachedFindOperation()
595                                     [WebModuleContextConfig.MIME_MAPPINGS];
596        
597         for (int i=0; mimeMappings!=null && i<mimeMappings.length; i++) {
598             webModule.addMimeMapping(
599                             mimeMappings[i],
600                             defaultWebModule.findMimeMapping(mimeMappings[i]));
601         }
602     }
603     
604     
605     /**
606      * Configure resource-reference defined in the deployment descriptor.
607      */

608     protected static void configureResourceRef(WebModule webModule,
609                                                WebBundleDescriptor wmd) {
610         Set JavaDoc set = wmd.getEnvironmentProperties();
611         if ( set.isEmpty() ){
612            return;
613         }
614         Iterator JavaDoc iterator = set.iterator();
615         
616         EnvironmentEntry envEntry;
617         while(iterator.hasNext()){
618             envEntry = (EnvironmentEntry)iterator.next();
619             
620             webModule.addResourceEnvRef(envEntry.getName(),
621                                         envEntry.getType());
622                        
623         }
624     }
625     
626     /**
627      * Configure resource-reference defined in the deployment descriptor.
628      */

629     protected static void configureResourceRef(WebModule webModule,
630                                                WebModule defaultWebModule) {
631         
632         ContextResource[] contextResources = (ContextResource[])
633                                 defaultWebModule.getCachedFindOperation()
634                                         [WebModuleContextConfig.RESOURCES];
635
636         for (int i=0; i < contextResources.length; i++){
637             webModule.addResource(contextResources[i]);
638         }
639     }
640  
641     
642     /**
643      * Configure context parameter defined in the deployment descriptor.
644      */

645     protected static void configureContextParam(WebModule webModule,
646                                                 WebBundleDescriptor wmd) {
647         
648        Set JavaDoc set = wmd.getContextParametersSet();
649        if ( set.isEmpty() ){
650            return;
651        }
652        Iterator JavaDoc iterator = set.iterator();
653        
654        ContextParameter ctxParam;
655        while(iterator.hasNext()){
656            ctxParam = (ContextParameter)iterator.next();
657            
658            webModule.addParameter(ctxParam.getName(), ctxParam.getValue());
659        }
660     }
661     
662     
663     /**
664      * Configure context parameter defined in the deployment descriptor.
665      */

666     protected static void configureContextParam(WebModule webModule,
667                                                 WebModule defaultWebModule) {
668         
669         ApplicationParameter[] params = (ApplicationParameter[])
670                     defaultWebModule.getCachedFindOperation()
671                             [WebModuleContextConfig.APPLICATION_PARAMETERS];
672        
673         for (int i=0 ; i < params.length; i++){
674             webModule.addParameter(params[i].getName(), params[i].getValue());
675         }
676     }
677     
678     
679     /**
680      * Configure of a message destination for a web application, as
681      * represented in a <code>&lt;message-destination&gt;</code> element
682      * in the deployment descriptor.
683      */

684     protected static void configureMessageDestination(WebModule webModule,
685                                                       WebBundleDescriptor wmd) {
686                                                         
687         Set JavaDoc set = wmd.getMessageDestinations();
688         if ( set.isEmpty() ){
689             return;
690         }
691         Iterator JavaDoc iterator = set.iterator();
692         
693         MessageDestinationDescriptor msgDrd = null;
694         MessageDestinationDecorator decorator;
695         while(iterator.hasNext()){
696             msgDrd = (MessageDestinationDescriptor)iterator.next();
697             decorator = new MessageDestinationDecorator(msgDrd);
698             
699             webModule.addMessageDestination(decorator);
700         }
701                                                        
702     }
703
704     
705     /**
706      * Configure of a message destination for a web application, as
707      * represented in a <code>&lt;message-destination&gt;</code> element
708      * in the deployment descriptor.
709      */

710     protected static void configureMessageDestination(WebModule webModule,
711                                                       WebModule defaultWebModule) {
712                                                         
713         MessageDestination[] messageDestinations = (MessageDestination[])
714                     defaultWebModule.getCachedFindOperation()
715                                 [WebModuleContextConfig.MESSAGE_DESTINATIONS];
716         
717         for(int i=0; i < messageDestinations.length; i++){
718             webModule.addMessageDestination(messageDestinations[i]);
719         }
720     }
721
722     
723     
724     /**
725      * Representation of a message destination reference for a web application,
726      * as represented in a <code>&lt;message-destination-ref&gt;</code> element
727      * in the deployment descriptor.
728      */

729     protected static void configureMessageDestinationRef(WebModule webModule,
730                                                   WebBundleDescriptor wmd) {
731                                                         
732         Set JavaDoc set = wmd.getMessageDestinationReferenceDescriptors();
733         if ( set.isEmpty() ){
734             return;
735         }
736         Iterator JavaDoc iterator = set.iterator();
737         
738         MessageDestinationReferenceDescriptor msgDrd = null;
739         MessageDestinationRefDecorator decorator;
740         while(iterator.hasNext()){
741             msgDrd = (MessageDestinationReferenceDescriptor)iterator.next();
742             decorator = new MessageDestinationRefDecorator(msgDrd);
743             
744             webModule.addMessageDestinationRef(decorator);
745         }
746     }
747     
748         
749     /**
750      * Configure of a message destination for a web application, as
751      * represented in a <code>&lt;message-destination&gt;</code> element
752      * in the deployment descriptor.
753      */

754     protected static void configureMessageRef(WebModule webModule,
755                                               WebModule defaultWebModule) {
756                                                         
757         MessageDestinationRef[] messageDestinationRefs = (MessageDestinationRef[])
758                 defaultWebModule.getCachedFindOperation()
759                             [WebModuleContextConfig.MESSAGE_DESTINATION_REFS];
760         
761         for(int i=0; i < messageDestinationRefs.length; i++){
762             webModule.addMessageDestinationRef(messageDestinationRefs[i]);
763         }
764     }
765       
766     
767     /**
768      * Configure a resource reference for a web application, as
769      * represented in a <code>&lt;resource-ref&gt;</code> element in the
770      * deployment descriptor.
771      */

772     protected static void configureContextResource(WebModule webModule,
773                                                    WebBundleDescriptor wmd) {
774         Set JavaDoc set = wmd.getResourceReferenceDescriptors();
775         if ( set.isEmpty() ){
776             return;
777         }
778         Iterator JavaDoc iterator = set.iterator();
779         
780         ResourceReferenceDescriptor resRefDesc;
781         ContextResourceDecorator decorator;
782         while(iterator.hasNext()){
783             resRefDesc = (ResourceReferenceDescriptor)iterator.next();
784             decorator = new ContextResourceDecorator(resRefDesc);
785                         
786             webModule.addResource(decorator);
787         }
788
789     }
790    
791     
792     /**
793      * Configure the <code>WebModule</code> instance by creating
794      * <code>StandardWrapper</code> using the information contained
795      * in the deployment descriptor (Welcome Files, JSP, Servlets etc.)
796      */

797     protected static void configureStandardContext(WebModule webModule,
798                                                    WebBundleDescriptor wmd) {
799     
800        Set JavaDoc set = wmd.getWebComponentDescriptorsSet();
801        StandardWrapper wrapper;
802        WebComponentDescriptor webComponentDesc;
803        Enumeration JavaDoc enumeration;
804        SecurityRoleReference securityRoleReference;
805        
806        Set JavaDoc set2;
807        Iterator JavaDoc iterator2;
808        
809        if ( !set.isEmpty() ){
810            Iterator JavaDoc iterator = set.iterator();
811
812            while (iterator.hasNext()) {
813
814                 webComponentDesc = (WebComponentDescriptor)iterator.next();
815
816                 wrapper = (StandardWrapper)webModule.createWrapper();
817                 wrapper.setName(webComponentDesc.getCanonicalName());
818                 webModule.addChild(wrapper);
819
820                 enumeration = webComponentDesc.getInitializationParameters();
821                 InitializationParameter initP = null;
822                 while (enumeration.hasMoreElements()){
823                     initP = (InitializationParameter)enumeration.nextElement();
824                     wrapper.addInitParameter(initP.getName(), initP.getValue());
825                 }
826
827                 if (webComponentDesc.isServlet()){
828                         wrapper.setServletClass(
829                                 webComponentDesc.getWebComponentImplementation());
830                 } else {
831                     wrapper.setJspFile(webComponentDesc.
832                                                  getWebComponentImplementation());
833                 }
834
835                 wrapper.setLoadOnStartup(webComponentDesc.getLoadOnStartUp());
836                 if (webComponentDesc.getRunAsIdentity() != null)
837                     wrapper.setRunAs(webComponentDesc.getRunAsIdentity().getRoleName());
838
839
840                 set2 = webComponentDesc.getUrlPatternsSet();
841                 iterator2 = set2.iterator();
842                 while (iterator2.hasNext()){
843                     webModule.addServletMapping((String JavaDoc)iterator2.next(),
844                                                 webComponentDesc.getCanonicalName());
845                 }
846
847                 enumeration = webComponentDesc.getSecurityRoleReferences();
848                 while (enumeration.hasMoreElements()){
849                     securityRoleReference =
850                                 (SecurityRoleReference)enumeration.nextElement();
851                     wrapper.
852                         addSecurityReference(securityRoleReference.getRolename(),
853                              securityRoleReference.getSecurityRoleLink().getName());
854                 }
855             }
856         }
857        
858         webModule.setSessionTimeout(wmd.getSessionTimeout());
859            
860         enumeration = wmd.getWelcomeFiles();
861         while (enumeration.hasMoreElements()){
862             webModule.addWelcomeFile((String JavaDoc)enumeration.nextElement());
863         }
864         
865         LocaleEncodingMappingListDescriptor lemds =
866                             wmd.getLocaleEncodingMappingListDescriptor();
867         if (lemds != null) {
868             set2 = lemds.getLocaleEncodingMappingSet();
869             iterator2 = set2.iterator();
870             LocaleEncodingMappingDescriptor lemd;
871             while (iterator2.hasNext()){
872                 lemd = (LocaleEncodingMappingDescriptor) iterator2.next();
873                 webModule.
874                     addLocaleEncodingMappingParameter(lemd.getLocale(),
875                                                       lemd.getEncoding());
876             }
877         }
878     }
879
880     
881     /**
882      * Configure security constraint element for a web application,
883      * as represented in a <code>&lt;security-constraint&gt;</code> element in
884      * the deployment descriptor.
885      *
886      * Configure a web resource collection for a web application's security
887      * constraint, as represented in a <code>&lt;web-resource-collection&gt;</code>
888      * element in the deployment descriptor.
889      *
890      */

891     protected static void configureSecurityConstraint(WebModule webModule,
892                                                       WebBundleDescriptor wmd) {
893                                                    
894         Enumeration JavaDoc enumeration = wmd.getSecurityConstraints();
895         SecurityConstraint securityConstraint;
896         SecurityConstraintDecorator decorator;
897         Enumeration JavaDoc enumeration2;
898         SecurityCollectionDecorator secCollDecorator;
899         while (enumeration.hasMoreElements()){
900             securityConstraint =(SecurityConstraint)enumeration.nextElement();
901              
902             decorator = new SecurityConstraintDecorator(securityConstraint,
903                                                         webModule);
904             
905             enumeration2 = securityConstraint.getWebResourceCollections();
906             while (enumeration2.hasMoreElements()){
907                 secCollDecorator = new SecurityCollectionDecorator
908                             ((WebResourceCollection) enumeration2.nextElement());
909                    
910                 decorator.addCollection(secCollDecorator);
911             }
912             webModule.addConstraint(decorator);
913         }
914                                                 
915     }
916     
917     
918     /**
919      * Validate the usage of security role names in the web application
920      * deployment descriptor. If any problems are found, issue warning
921      * messages (for backwards compatibility) and add the missing roles.
922      * (To make these problems fatal instead, simply set the <code>ok</code>
923      * instance variable to <code>false</code> as well).
924      */

925     protected static void configureSecurityRoles(WebModule webModule,
926                                                  WebBundleDescriptor wmd) {
927
928         Enumeration JavaDoc<SecurityRoleDescriptor> e = wmd.getSecurityRoles();
929         if (e != null) {
930             while (e.hasMoreElements()){
931                 webModule.addSecurityRole(e.nextElement().getName());
932             }
933         }
934
935         // Check role names used in <security-constraint> elements
936
org.apache.catalina.deploy.SecurityConstraint
937                             constraints[] = webModule.findConstraints();
938         for (int i = 0; i < constraints.length; i++) {
939             String JavaDoc roles[] = constraints[i].findAuthRoles();
940             for (int j = 0; j < roles.length; j++) {
941                 if (!"*".equals(roles[j]) &&
942                     !webModule.findSecurityRole(roles[j])) {
943                     logger.log(
944                         Level.WARNING,"tomcatDeploymentConfig.role.auth", roles[j]);
945                     webModule.addSecurityRole(roles[j]);
946                 }
947             }
948         }
949
950         // Check role names used in <servlet> elements
951
Container wrappers[] = webModule.findChildren();
952         for (int i = 0; i < wrappers.length; i++) {
953             Wrapper wrapper = (Wrapper) wrappers[i];
954             String JavaDoc runAs = wrapper.getRunAs();
955             if ((runAs != null) && !webModule.findSecurityRole(runAs)) {
956                 logger.log(
957                     Level.WARNING,"tomcatDeploymentConfig.role.runas", runAs);
958                 webModule.addSecurityRole(runAs);
959             }
960             String JavaDoc names[] = wrapper.findSecurityReferences();
961             for (int j = 0; j < names.length; j++) {
962                 String JavaDoc link = wrapper.findSecurityReference(names[j]);
963                 if ((link != null) && !webModule.findSecurityRole(link)) {
964                     logger.log(
965                         Level.WARNING,"tomcatDeploymentConfig.role.link", link);
966                     webModule.addSecurityRole(link);
967                 }
968             }
969         }
970
971     }
972     
973     protected static void configureStandardContext(WebModule webModule,
974                                                    WebModule defaultWebModule) {
975                                                       
976         // 1. Add the default Wrapper
977
Container wrappers[] = (Container[])
978                             defaultWebModule.getCachedFindOperation()
979                                             [WebModuleContextConfig.CHILDREN];
980         
981         StandardWrapper wrapper, defaultWrapper;
982         for(int i=0; i < wrappers.length; i++){
983             defaultWrapper = (StandardWrapper)wrappers[i];
984             wrapper = (StandardWrapper)webModule.createWrapper();
985             wrapper.setName(defaultWrapper.getName());
986             webModule.addChild(wrapper);
987             
988             String JavaDoc[] initParams = defaultWrapper.findInitParameters();
989             for (int j=0; j < initParams.length; j++){
990                 wrapper.addInitParameter(
991                     initParams[j], defaultWrapper.findInitParameter(initParams[j]));
992             }
993        
994             if (defaultWrapper.getJspFile() == null){
995                 wrapper.setServletClass(defaultWrapper.getServletClass());
996             } else {
997                 wrapper.setJspFile(defaultWrapper.getJspFile());
998             }
999     
1000            wrapper.setLoadOnStartup(defaultWrapper.getLoadOnStartup());
1001            if (defaultWrapper.getRunAs() != null)
1002                wrapper.setRunAs(defaultWrapper.getRunAs());
1003        }
1004                           
1005        String JavaDoc[] servletMappings = (String JavaDoc[])
1006                    defaultWebModule.getCachedFindOperation()
1007                                    [WebModuleContextConfig.SERVLET_MAPPINGS];
1008        
1009        String JavaDoc servletName;
1010        for (int j=0; j < servletMappings.length; j++){
1011            servletName =
1012                defaultWebModule.findServletMapping(servletMappings[j]);
1013            if (servletName.equals("jsp")){
1014                webModule.addServletMapping(
1015                    servletMappings[j], servletName, true);
1016            } else {
1017                webModule.addServletMapping(servletMappings[j],servletName);
1018            }
1019        }
1020        
1021        webModule.setSessionTimeout(defaultWebModule.getSessionTimeout());
1022           
1023        String JavaDoc[] welcomeFiles = defaultWebModule.getWelcomeFiles();
1024        for(int i=0; i < welcomeFiles.length; i++){
1025            webModule.addWelcomeFile(welcomeFiles[i]);
1026        }
1027        
1028        webModule.setCharsetMapper((CharsetMapper)
1029            defaultWebModule.getCharsetMapper().clone());
1030    }
1031       
1032}
1033
Popular Tags