Java > Open Source Codes > org > apache > geronimo > jetty > deployment > JettyModuleBuilder


1 /**
2  *
3  * Copyright 2003-2004 The Apache Software Foundation
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17
18 package org.apache.geronimo.jetty.deployment;
19
20 import java.io.File ;
21 import java.io.FileFilter ;
22 import java.io.IOException ;
23 import java.net.MalformedURLException ;
24 import java.net.URI ;
25 import java.net.URISyntaxException ;
26 import java.net.URL ;
27 import java.security.Permission ;
28 import java.security.PermissionCollection ;
29 import java.security.Permissions ;
30 import java.util.ArrayList ;
31 import java.util.Collection ;
32 import java.util.Collections ;
33 import java.util.Enumeration ;
34 import java.util.HashMap ;
35 import java.util.HashSet ;
36 import java.util.Iterator ;
37 import java.util.List ;
38 import java.util.Map ;
39 import java.util.Set ;
40 import java.util.jar.JarFile ;
41 import java.util.zip.ZipEntry ;
42 import javax.management.MalformedObjectNameException ;
43 import javax.management.ObjectName ;
44 import javax.security.jacc.WebResourcePermission ;
45 import javax.security.jacc.WebRoleRefPermission ;
46 import javax.security.jacc.WebUserDataPermission ;
47 import javax.servlet.Servlet ;
48 import javax.transaction.UserTransaction ;
49
50 import org.apache.geronimo.common.DeploymentException;
51 import org.apache.geronimo.deployment.service.ServiceConfigBuilder;
52 import org.apache.geronimo.deployment.util.DeploymentUtil;
53 import org.apache.geronimo.deployment.xbeans.DependencyType;
54 import org.apache.geronimo.deployment.xbeans.GbeanType;
55 import org.apache.geronimo.gbean.GBeanData;
56 import org.apache.geronimo.gbean.GBeanInfo;
57 import org.apache.geronimo.gbean.GBeanInfoBuilder;
58 import org.apache.geronimo.j2ee.deployment.EARContext;
59 import org.apache.geronimo.j2ee.deployment.Module;
60 import org.apache.geronimo.j2ee.deployment.ModuleBuilder;
61 import org.apache.geronimo.j2ee.deployment.WebServiceBuilder;
62 import org.apache.geronimo.j2ee.deployment.WebModule;
63 import org.apache.geronimo.j2ee.j2eeobjectnames.J2eeContext;
64 import org.apache.geronimo.j2ee.j2eeobjectnames.J2eeContextImpl;
65 import org.apache.geronimo.j2ee.j2eeobjectnames.NameFactory;
66 import org.apache.geronimo.jetty.JettyClassLoader;
67 import org.apache.geronimo.jetty.JettyFilterHolder;
68 import org.apache.geronimo.jetty.JettyFilterMapping;
69 import org.apache.geronimo.jetty.JettyServletHolder;
70 import org.apache.geronimo.jetty.JettyWebAppContext;
71 import org.apache.geronimo.kernel.GBeanNotFoundException;
72 import org.apache.geronimo.kernel.Kernel;
73 import org.apache.geronimo.kernel.repository.Repository;
74 import org.apache.geronimo.naming.deployment.ENCConfigBuilder;
75 import org.apache.geronimo.naming.deployment.GBeanResourceEnvironmentBuilder;
76 import org.apache.geronimo.schema.SchemaConversionUtils;
77 import org.apache.geronimo.security.deploy.DefaultPrincipal;
78 import org.apache.geronimo.security.deployment.SecurityBuilder;
79 import org.apache.geronimo.security.deployment.SecurityConfiguration;
80 import org.apache.geronimo.security.jacc.ComponentPermissions;
81 import org.apache.geronimo.security.util.URLPattern;
82 import org.apache.geronimo.transaction.context.OnlineUserTransaction;
83 import org.apache.geronimo.xbeans.geronimo.jetty.JettyWebAppDocument;
84 import org.apache.geronimo.xbeans.geronimo.jetty.JettyWebAppType;
85 import org.apache.geronimo.xbeans.j2ee.DispatcherType;
86 import org.apache.geronimo.xbeans.j2ee.ErrorPageType;
87 import org.apache.geronimo.xbeans.j2ee.FilterMappingType;
88 import org.apache.geronimo.xbeans.j2ee.FilterType;
89 import org.apache.geronimo.xbeans.j2ee.FormLoginConfigType;
90 import org.apache.geronimo.xbeans.j2ee.HttpMethodType;
91 import org.apache.geronimo.xbeans.j2ee.JspConfigType;
92 import org.apache.geronimo.xbeans.j2ee.ListenerType;
93 import org.apache.geronimo.xbeans.j2ee.LocaleEncodingMappingListType;
94 import org.apache.geronimo.xbeans.j2ee.LocaleEncodingMappingType;
95 import org.apache.geronimo.xbeans.j2ee.LoginConfigType;
96 import org.apache.geronimo.xbeans.j2ee.MimeMappingType;
97 import org.apache.geronimo.xbeans.j2ee.ParamValueType;
98 import org.apache.geronimo.xbeans.j2ee.RoleNameType;
99 import org.apache.geronimo.xbeans.j2ee.SecurityConstraintType;
100 import org.apache.geronimo.xbeans.j2ee.SecurityRoleRefType;
101 import org.apache.geronimo.xbeans.j2ee.SecurityRoleType;
102 import org.apache.geronimo.xbeans.j2ee.ServletMappingType;
103 import org.apache.geronimo.xbeans.j2ee.ServletType;
104 import org.apache.geronimo.xbeans.j2ee.TaglibType;
105 import org.apache.geronimo.xbeans.j2ee.UrlPatternType;
106 import org.apache.geronimo.xbeans.j2ee.WebAppDocument;
107 import org.apache.geronimo.xbeans.j2ee.WebAppType;
108 import org.apache.geronimo.xbeans.j2ee.WebResourceCollectionType;
109 import org.apache.geronimo.xbeans.j2ee.WelcomeFileListType;
110 import org.apache.xmlbeans.XmlException;
111 import org.apache.xmlbeans.XmlObject;
112 import org.mortbay.http.BasicAuthenticator;
113 import org.mortbay.http.ClientCertAuthenticator;
114 import org.mortbay.http.DigestAuthenticator;
115 import org.mortbay.jetty.servlet.FormAuthenticator;
116
117
118 /**
119  * @version $Rev: 169154 $ $Date: 2005-05-08 12:35:23 -0700 (Sun, 08 May 2005) $
120  */
121 public class JettyModuleBuilder implements ModuleBuilder {
122     private final URI defaultParentId;
123     private final ObjectName jettyContainerObjectName;
124     private final ObjectName defaultServlets;
125     private final ObjectName defaultFilters;
126     private final ObjectName defaultFilterMappings;
127     private final ObjectName pojoWebServiceTemplate;
128
129     private final WebServiceBuilder webServiceBuilder;
130
131     private final List defaultWelcomeFiles;
132     private final Integer defaultSessionTimeoutSeconds;
133
134     private final Repository repository;
135     private final Kernel kernel;
136
137     public JettyModuleBuilder(URI defaultParentId,
138                               Integer defaultSessionTimeoutSeconds,
139                               List defaultWelcomeFiles,
140                               ObjectName jettyContainerObjectName,
141                               ObjectName defaultServlets,
142                               ObjectName defaultFilters,
143                               ObjectName defaultFilterMappings,
144                               ObjectName pojoWebServiceTemplate,
145                               WebServiceBuilder webServiceBuilder,
146                               Repository repository,
147                               Kernel kernel) {
148         this.defaultParentId = defaultParentId;
149         this.defaultSessionTimeoutSeconds = (defaultSessionTimeoutSeconds == null) ? new Integer (30 * 60) : defaultSessionTimeoutSeconds;
150         this.jettyContainerObjectName = jettyContainerObjectName;
151         this.defaultServlets = defaultServlets;
152         this.defaultFilters = defaultFilters;
153         this.defaultFilterMappings = defaultFilterMappings;
154         this.pojoWebServiceTemplate = pojoWebServiceTemplate;
155         this.webServiceBuilder = webServiceBuilder;
156         this.repository = repository;
157         this.kernel = kernel;
158
159         //todo locale mappings
160
161         this.defaultWelcomeFiles = defaultWelcomeFiles;
162     }
163
164     public Module createModule(File plan, JarFile moduleFile) throws DeploymentException {
165         return createModule(plan, moduleFile, "war", null, true);
166     }
167
168     public Module createModule(Object plan, JarFile moduleFile, String targetPath, URL specDDUrl, URI earConfigId) throws DeploymentException {
169         return createModule(plan, moduleFile, targetPath, specDDUrl, false);
170     }
171
172     private Module createModule(Object plan, JarFile moduleFile, String targetPath, URL specDDUrl, boolean standAlone) throws DeploymentException {
173         assert moduleFile != null: "moduleFile is null";
174         assert targetPath != null: "targetPath is null";
175         assert !targetPath.endsWith("/"): "targetPath must not end with a '/'";
176
177         // parse the spec dd
178 String specDD;
179         WebAppType webApp;
180         try {
181             if (specDDUrl == null) {
182                 specDDUrl = DeploymentUtil.createJarURL(moduleFile, "WEB-INF/web.xml");
183             }
184
185             // read in the entire specDD as a string, we need this for getDeploymentDescriptor
186 // on the J2ee management object
187 specDD = DeploymentUtil.readAll(specDDUrl);
188         } catch (Exception e) {
189             //no web.xml, not for us
190 return null;
191         }
192         //we found web.xml, if it won't parse that's an error.
193 try {
194             // parse it
195 XmlObject parsed = SchemaConversionUtils.parse(specDD);
196             WebAppDocument webAppDoc = SchemaConversionUtils.convertToServletSchema(parsed);
197             webApp = webAppDoc.getWebApp();
198         } catch (XmlException xmle) {
199             throw new DeploymentException("Error parsing web.xml", xmle);
200         }
201         check(webApp);
202
203         //look for a webservices dd
204 Map portMap = Collections.EMPTY_MAP;
205         try {
206             URL wsDDUrl = DeploymentUtil.createJarURL(moduleFile, "WEB-INF/webservices.xml");
207             portMap = webServiceBuilder.parseWebServiceDescriptor(wsDDUrl, moduleFile, false);
208         } catch (MalformedURLException e) {
209             //no descriptor
210 }
211
212         // parse vendor dd
213 JettyWebAppType jettyWebApp = getJettyWebApp(plan, moduleFile, standAlone, targetPath, webApp);
214
215         // get the ids from either the application plan or for a stand alone module from the specific deployer
216 URI configId = null;
217         try {
218             configId = new URI (jettyWebApp.getConfigId());
219         } catch (URISyntaxException e) {
220             throw new DeploymentException("Invalid configId " + jettyWebApp.getConfigId(), e);
221         }
222
223         URI parentId = null;
224         if (jettyWebApp.isSetParentId()) {
225             try {
226                 parentId = new URI (jettyWebApp.getParentId());
227             } catch (URISyntaxException e) {
228                 throw new DeploymentException("Invalid parentId " + jettyWebApp.getParentId(), e);
229             }
230         } else {
231             parentId = defaultParentId;
232         }
233
234         WebModule module = new WebModule(standAlone, configId, parentId, moduleFile, targetPath, webApp, jettyWebApp, specDD, portMap);
235         module.setContextRoot(jettyWebApp.getContextRoot());
236         return module;
237     }
238
239     JettyWebAppType getJettyWebApp(Object plan, JarFile moduleFile, boolean standAlone, String targetPath, WebAppType webApp) throws DeploymentException {
240         JettyWebAppType jettyWebApp = null;
241         try {
242             // load the geronimo-jetty.xml from either the supplied plan or from the earFile
243 try {
244                 if (plan instanceof XmlObject) {
245                     jettyWebApp = (JettyWebAppType) SchemaConversionUtils.getNestedObjectAsType((XmlObject) plan,
246                             "web-app",
247                             JettyWebAppType.type);
248                 } else {
249                     JettyWebAppDocument jettyWebAppdoc = null;
250                     if (plan != null) {
251                         jettyWebAppdoc = JettyWebAppDocument.Factory.parse((File ) plan);
252                     } else {
253                         URL path = DeploymentUtil.createJarURL(moduleFile, "WEB-INF/geronimo-jetty.xml");
254                         jettyWebAppdoc = JettyWebAppDocument.Factory.parse(path);
255                     }
256                     if (jettyWebAppdoc != null) {
257                         jettyWebApp = jettyWebAppdoc.getWebApp();
258                     }
259                 }
260             } catch (IOException e) {
261             }
262
263             // if we got one extract and validate it otherwise create a default one
264 if (jettyWebApp != null) {
265                 jettyWebApp = (JettyWebAppType) SchemaConversionUtils.convertToGeronimoNamingSchema(jettyWebApp);
266                 jettyWebApp = (JettyWebAppType) SchemaConversionUtils.convertToGeronimoSecuritySchema(jettyWebApp);
267                 jettyWebApp = (JettyWebAppType) SchemaConversionUtils.convertToGeronimoServiceSchema(jettyWebApp);
268                 SchemaConversionUtils.validateDD(jettyWebApp);
269             } else {
270                 String path;
271                 if (standAlone) {
272                     // default configId is based on the moduleFile name
273 path = new File (moduleFile.getName()).getName();
274                 } else {
275                     // default configId is based on the module uri from the application.xml
276 path = targetPath;
277                 }
278                 jettyWebApp = createDefaultPlan(path, webApp);
279             }
280         } catch (XmlException e) {
281             throw new DeploymentException("xml problem", e);
282         }
283         return jettyWebApp;
284     }
285
286     private JettyWebAppType createDefaultPlan(String path, WebAppType webApp) {
287         String id = webApp.getId();
288         if (id == null) {
289             id = path;
290             if (id.endsWith(".war")) {
291                 id = id.substring(0, id.length() - 4);
292             }
293             if (id.endsWith("/")) {
294                 id = id.substring(0, id.length() - 1);
295             }
296         }
297
298         JettyWebAppType jettyWebApp = JettyWebAppType.Factory.newInstance();
299
300         // set the parentId, configId and context root
301 jettyWebApp.setParentId(defaultParentId.toString());
302         if (null != webApp.getId()) {
303             id = webApp.getId();
304         }
305         jettyWebApp.setConfigId(id);
306         jettyWebApp.setContextRoot(id);
307         return jettyWebApp;
308     }
309
310     public void installModule(JarFile earFile, EARContext earContext, Module module) throws DeploymentException {
311         try {
312             URI baseDir = URI.create(module.getTargetPath() + "/");
313
314             // add the warfile's content to the configuration
315 JarFile warFile = module.getModuleFile();
316             Enumeration entries = warFile.entries();
317             while (entries.hasMoreElements()) {
318                 ZipEntry entry = (ZipEntry ) entries.nextElement();
319                 URI targetPath = baseDir.resolve(new URI (null, entry.getName(), null));
320                 if (entry.getName().equals("WEB-INF/web.xml")) {
321                     earContext.addFile(targetPath, module.getOriginalSpecDD());
322                 } else {
323                     earContext.addFile(targetPath, warFile, entry);
324                 }
325             }
326
327             // add the manifest classpath entries declared in the war to the class loader
328 // we have to explicitly add these since we are unpacking the web module
329 // and the url class loader will not pick up a manifiest from an unpacked dir
330 earContext.addManifestClassPath(warFile, URI.create(module.getTargetPath()));
331
332             // add the dependencies declared in the geronimo-jetty.xml file
333 JettyWebAppType jettyWebApp = (JettyWebAppType) module.getVendorDD();
334             DependencyType[] dependencies = jettyWebApp.getDependencyArray();
335             ServiceConfigBuilder.addDependencies(earContext, dependencies, repository);
336         } catch (IOException e) {
337             throw new DeploymentException("Problem deploying war", e);
338         } catch (URISyntaxException e) {
339             throw new DeploymentException("Could not construct URI for location of war entry", e);
340         }
341     }
342
343     public void initContext(EARContext earContext, Module module, ClassLoader cl) {
344         // web application do not add anything to the shared context
345 }
346
347     public void addGBeans(EARContext earContext, Module module, ClassLoader cl) throws DeploymentException {
348         J2eeContext earJ2eeContext = earContext.getJ2eeContext();
349         J2eeContext moduleJ2eeContext = J2eeContextImpl.newModuleContextFromApplication(earJ2eeContext, NameFactory.WEB_MODULE, module.getName());
350         WebModule webModule = (WebModule) module;
351
352         WebAppType webApp = (WebAppType) webModule.getSpecDD();
353         JettyWebAppType jettyWebApp = (JettyWebAppType) webModule.getVendorDD();
354
355         boolean contextPriorityClassLoader = false;
356         if (jettyWebApp != null) {
357             contextPriorityClassLoader = Boolean.valueOf(jettyWebApp.getContextPriorityClassloader()).booleanValue();
358         }
359         // construct the webClassLoader
360 ClassLoader webClassLoader = getWebClassLoader(earContext, webModule, cl, contextPriorityClassLoader);
361
362         if (jettyWebApp != null) {
363             GbeanType[] gbeans = jettyWebApp.getGbeanArray();
364             ServiceConfigBuilder.addGBeans(gbeans, webClassLoader, moduleJ2eeContext, earContext);
365         }
366
367         ObjectName webModuleName = null;
368         try {
369             webModuleName = NameFactory.getModuleName(null, null, null, null, null, moduleJ2eeContext);
370         } catch (MalformedObjectNameException e) {
371             throw new DeploymentException("Could not construct module name", e);
372         }
373
374         UserTransaction userTransaction = new OnlineUserTransaction();
375         //this may add to the web classpath with enhanced classes.
376 Map compContext = buildComponentContext(earContext, webModule, webApp, jettyWebApp, userTransaction, webClassLoader);
377
378         GBeanData webModuleData = new GBeanData(webModuleName, JettyWebAppContext.GBEAN_INFO);
379         try {
380             webModuleData.setReferencePattern("J2EEServer", earContext.getServerObjectName());
381             if (!earContext.getJ2EEApplicationName().equals("null")) {
382                 webModuleData.setReferencePattern("J2EEApplication", earContext.getApplicationObjectName());
383             }
384
385             webModuleData.setAttribute("deploymentDescriptor", module.getOriginalSpecDD());
386             Set securityRoles = collectRoleNames(webApp);
387             Map rolePermissions = new HashMap ();
388
389             webModuleData.setAttribute("uri", URI.create(module.getTargetPath() + "/"));
390             webModuleData.setAttribute("componentContext", compContext);
391             webModuleData.setAttribute("userTransaction", userTransaction);
392             //classpath may have been augmented with enhanced classes
393 webModuleData.setAttribute("webClassPath", webModule.getWebClasspath());
394             // unsharableResources, applicationManagedSecurityResources
395 GBeanResourceEnvironmentBuilder rebuilder = new GBeanResourceEnvironmentBuilder(webModuleData);
396             ENCConfigBuilder.setResourceEnvironment(earContext, webModule.getModuleURI(), rebuilder, webApp.getResourceRefArray(), jettyWebApp.getResourceRefArray());
397
398             webModuleData.setAttribute("contextPath", webModule.getContextRoot());
399             webModuleData.setAttribute("contextPriorityClassLoader", Boolean.valueOf(contextPriorityClassLoader));
400
401             webModuleData.setReferencePattern("TransactionContextManager", earContext.getTransactionContextManagerObjectName());
402             webModuleData.setReferencePattern("TrackedConnectionAssociator", earContext.getConnectionTrackerObjectName());
403             webModuleData.setReferencePattern("JettyContainer", jettyContainerObjectName);
404             //stuff that jetty used to do
405 if (webApp.getDisplayNameArray().length > 0) {
406                 webModuleData.setAttribute("displayName", webApp.getDisplayNameArray()[0].getStringValue());
407             }
408
409             ParamValueType[] contextParamArray = webApp.getContextParamArray();
410             Map contextParams = new HashMap ();
411             for (int i = 0; i < contextParamArray.length; i++) {
412                 ParamValueType contextParam = contextParamArray[i];
413                 contextParams.put(contextParam.getParamName().getStringValue().trim(), contextParam.getParamValue().getStringValue().trim());
414             }
415             webModuleData.setAttribute("contextParamMap", contextParams);
416
417             ListenerType[] listenerArray = webApp.getListenerArray();
418             Collection listeners = new ArrayList ();
419             for (int i = 0; i < listenerArray.length; i++) {
420                 ListenerType listenerType = listenerArray[i];
421                 listeners.add(listenerType.getListenerClass().getStringValue());
422             }
423             webModuleData.setAttribute("listenerClassNames", listeners);
424
425             webModuleData.setAttribute("distributable", webApp.getDistributableArray().length == 1 ? Boolean.TRUE : Boolean.FALSE);
426
427             webModuleData.setAttribute("sessionTimeoutSeconds",
428                     (webApp.getSessionConfigArray().length == 1 && webApp.getSessionConfigArray(0).getSessionTimeout() != null) ?
429                     new Integer (webApp.getSessionConfigArray(0).getSessionTimeout().getBigIntegerValue().intValue() * 60) :
430                     defaultSessionTimeoutSeconds);
431
432             MimeMappingType[] mimeMappingArray = webApp.getMimeMappingArray();
433             Map mimeMappingMap = new HashMap ();
434             for (int i = 0; i < mimeMappingArray.length; i++) {
435                 MimeMappingType mimeMappingType = mimeMappingArray[i];
436                 mimeMappingMap.put(mimeMappingType.getExtension().getStringValue(), mimeMappingType.getMimeType().getStringValue());
437             }
438             webModuleData.setAttribute("mimeMap", mimeMappingMap);
439
440             WelcomeFileListType[] welcomeFileArray = webApp.getWelcomeFileListArray();
441             List welcomeFiles;
442             if (welcomeFileArray.length > 0) {
443                 welcomeFiles = new ArrayList ();
444                 for (int i = 0; i < welcomeFileArray.length; i++) {
445                     String [] welcomeFileListType = welcomeFileArray[i].getWelcomeFileArray();
446                     for (int j = 0; j < welcomeFileListType.length; j++) {
447                         String welcomeFile = welcomeFileListType[j].trim();
448                         welcomeFiles.add(welcomeFile);
449                     }
450                 }
451             } else {
452                 welcomeFiles = new ArrayList (defaultWelcomeFiles);
453             }
454             webModuleData.setAttribute("welcomeFiles", welcomeFiles.toArray(new String [welcomeFiles.size()]));
455
456             LocaleEncodingMappingListType[] localeEncodingMappingListArray = webApp.getLocaleEncodingMappingListArray();
457             Map localeEncodingMappingMap = new HashMap ();
458             for (int i = 0; i < localeEncodingMappingListArray.length; i++) {
459                 LocaleEncodingMappingType[] localeEncodingMappingArray = localeEncodingMappingListArray[i].getLocaleEncodingMappingArray();
460                 for (int j = 0; j < localeEncodingMappingArray.length; j++) {
461                     LocaleEncodingMappingType localeEncodingMapping = localeEncodingMappingArray[j];
462                     localeEncodingMappingMap.put(localeEncodingMapping.getLocale(), localeEncodingMapping.getEncoding());
463                 }
464             }
465             webModuleData.setAttribute("localeEncodingMapping", localeEncodingMappingMap);
466
467             ErrorPageType[] errorPageArray = webApp.getErrorPageArray();
468             Map errorPageMap = new HashMap ();
469             for (int i = 0; i < errorPageArray.length; i++) {
470                 ErrorPageType errorPageType = errorPageArray[i];
471                 if (errorPageType.isSetErrorCode()) {
472                     errorPageMap.put(errorPageType.getErrorCode().getStringValue(), errorPageType.getLocation().getStringValue());
473                 } else {
474                     errorPageMap.put(errorPageType.getExceptionType().getStringValue(), errorPageType.getLocation().getStringValue());
475                 }
476             }
477             webModuleData.setAttribute("errorPages", errorPageMap);
478
479             JspConfigType[] jspConfigArray = webApp.getJspConfigArray();
480             if (jspConfigArray.length > 1) {
481                 throw new DeploymentException("At most one jsp-config element, not " + jspConfigArray.length);
482             }
483             Map tagLibMap = new HashMap ();
484             for (int i = 0; i < jspConfigArray.length; i++) {
485                 TaglibType[] tagLibArray = jspConfigArray[i].getTaglibArray();
486                 for (int j = 0; j < tagLibArray.length; j++) {
487                     TaglibType taglib = tagLibArray[j];
488                     tagLibMap.put(taglib.getTaglibUri().getStringValue().trim(), taglib.getTaglibLocation().getStringValue().trim());
489                 }
490             }
491             webModuleData.setAttribute("tagLibMap", tagLibMap);
492
493             LoginConfigType[] loginConfigArray = webApp.getLoginConfigArray();
494             if (loginConfigArray.length > 1) {
495                 throw new DeploymentException("At most one login-config element, not " + loginConfigArray.length);
496             }
497             if (loginConfigArray.length == 1) {
498                 LoginConfigType loginConfig = loginConfigArray[0];
499                 if (loginConfig.isSetAuthMethod()) {
500                     String authMethod = loginConfig.getAuthMethod().getStringValue();
501                     if ("BASIC".equals(authMethod)) {
502                         webModuleData.setAttribute("authenticator", new BasicAuthenticator());
503                     } else if ("DIGEST".equals(authMethod)) {
504                         webModuleData.setAttribute("authenticator", new DigestAuthenticator());
505                     } else if ("FORM".equals(authMethod)) {
506
507                         FormAuthenticator formAuthenticator = new FormAuthenticator();
508                         webModuleData.setAttribute("authenticator", formAuthenticator);
509                         if (loginConfig.isSetFormLoginConfig()) {
510                             FormLoginConfigType formLoginConfig = loginConfig.getFormLoginConfig();
511                             formAuthenticator.setLoginPage(formLoginConfig.getFormLoginPage().getStringValue());
512                             formAuthenticator.setErrorPage(formLoginConfig.getFormErrorPage().getStringValue());
513                         }
514                     } else if ("CLIENT-CERT".equals(authMethod)) {
515                         webModuleData.setAttribute("authenticator", new ClientCertAuthenticator());
516                     }
517                 }
518                 if (loginConfig.isSetRealmName()) {
519                     webModuleData.setAttribute("realmName", loginConfig.getRealmName().getStringValue());
520                 }
521
522             }
523             earContext.addGBean(webModuleData);
524
525             //never add a duplicate pattern.
526 Set knownServletMappings = new HashSet ();
527
528             ServletMappingType[] servletMappingArray = webApp.getServletMappingArray();
529             Map servletMappings = new HashMap ();
530             for (int i = 0; i < servletMappingArray.length; i++) {
531                 ServletMappingType servletMappingType = servletMappingArray[i];
532                 String servletName = servletMappingType.getServletName().getStringValue().trim();
533                 String urlPattern = servletMappingType.getUrlPattern().getStringValue();
534                 if (!knownServletMappings.contains(urlPattern)) {
535                     knownServletMappings.add(urlPattern);
536                     checkString(urlPattern);
537                     Set urlsForServlet = (Set ) servletMappings.get(servletName);
538                     if (urlsForServlet == null) {
539                         urlsForServlet = new HashSet ();
540                         servletMappings.put(servletName, urlsForServlet);
541                     }
542                     urlsForServlet.add(urlPattern);
543                 }
544             }
545
546             //"previous" filter mapping for linked list to keep dd's ordering.
547 ObjectName previous = null;
548
549             //add default filters
550 if (defaultFilters != null) {
551                 Set defaultFilterNames = kernel.listGBeans(defaultFilters);
552                 for (Iterator iterator = defaultFilterNames.iterator(); iterator.hasNext();) {
553
554                     GBeanData filterGBeanData = kernel.getGBeanData((ObjectName ) iterator.next());
555                     String filterName = (String ) filterGBeanData.getAttribute("filterName");
556                     ObjectName defaultFilterObjectName = NameFactory.getWebComponentName(null, null, null, null, filterName, NameFactory.WEB_FILTER, moduleJ2eeContext);
557                     filterGBeanData.setName(defaultFilterObjectName);
558                     filterGBeanData.setReferencePattern("JettyServletRegistration", webModuleName);
559                     earContext.addGBean(filterGBeanData);
560                     //add a mapping to /*
561
562                     GBeanData filterMappingGBeanData = new GBeanData(JettyFilterMapping.GBEAN_INFO);
563                     filterMappingGBeanData.setReferencePattern("Previous", previous);
564                     filterMappingGBeanData.setReferencePattern("JettyServletRegistration", webModuleName);
565                     String urlPattern = "/*";
566                     filterMappingGBeanData.setAttribute("urlPattern", urlPattern);
567                     ObjectName filterMappingName = NameFactory.getWebFilterMappingName(null, null, null, null, filterName, null, urlPattern, moduleJ2eeContext);
568                     filterMappingGBeanData.setName(filterMappingName);
569                     previous = filterMappingName;
570
571
572                     filterMappingGBeanData.setAttribute("requestDispatch", Boolean.TRUE);
573                     filterMappingGBeanData.setAttribute("forwardDispatch", Boolean.TRUE);
574                     filterMappingGBeanData.setAttribute("includeDispatch", Boolean.TRUE);
575                     filterMappingGBeanData.setAttribute("errorDispatch", Boolean.FALSE);
576                     filterMappingGBeanData.setReferencePattern("Filter", defaultFilterObjectName);
577                     earContext.addGBean(filterMappingGBeanData);
578                 }
579             }
580
581             //add default filtermappings
582 // if (defaultFilterMappings != null) {
583 // Set defaultFilterMappingNames = kernel.listGBeans(defaultFilterMappings);
584 // for (Iterator iterator = defaultFilterMappingNames.iterator(); iterator.hasNext();) {
585 //
586 // GBeanData filterMappingGBeanData = kernel.getGBeanData((ObjectName) iterator.next());
587 // String filterName = (String) filterMappingGBeanData.getAttribute("filterName");
588 // ObjectName defaultFilterMappingObjectName;
589 // if (filterMappingGBeanData.getAttribute("urlPattern") != null) {
590 // String urlPattern = (String) filterMappingGBeanData.getAttribute("urlPattern");
591 // defaultFilterMappingObjectName = NameFactory.getWebFilterMappingName(null, null, null, null, filterName, null, urlPattern, moduleJ2eeContext);
592 // } else {
593 // Set servletNames = filterMappingGBeanData.getReferencePatterns("Servlet");
594 // if (servletNames == null || servletNames.size() != 1) {
595 // throw new DeploymentException("Exactly one servlet name must be supplied");
596 // }
597 // ObjectName servletObjectName = (ObjectName) servletNames.iterator().next();
598 // String servletName = servletObjectName.getKeyProperty("name");
599 // defaultFilterMappingObjectName = NameFactory.getWebFilterMappingName(null, null, null, null, filterName, servletName, null, moduleJ2eeContext);
600 // }
601 // filterMappingGBeanData.setName(defaultFilterMappingObjectName);
602 // filterMappingGBeanData.setReferencePattern("JettyFilterMappingRegistration", webModuleName);
603 // earContext.addGBean(filterMappingGBeanData);
604 // }
605