Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /*
    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
    *
    * Copyright (c) 1997-2012 Oracle and/or its affiliates. All rights reserved.
    *
    * The contents of this file are subject to the terms of either the GNU
    * General Public License Version 2 only ("GPL") or the Common Development
    * and Distribution License("CDDL") (collectively, the "License").  You
    * may not use this file except in compliance with the License.  You can
   * obtain a copy of the License at
   * https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
   * or packager/legal/LICENSE.txt.  See the License for the specific
   * language governing permissions and limitations under the License.
   *
   * When distributing the software, include this License Header Notice in each
   * file and include the License file at packager/legal/LICENSE.txt.
   *
   * GPL Classpath Exception:
   * Oracle designates this particular file as subject to the "Classpath"
   * exception as provided by Oracle in the GPL Version 2 section of the License
   * file that accompanied this code.
   *
   * Modifications:
   * If applicable, add the following below the License Header, with the fields
   * enclosed by brackets [] replaced by your own identifying information:
   * "Portions Copyright [year] [name of copyright owner]"
   *
   * Contributor(s):
   * If you wish your version of this file to be governed by only the CDDL or
   * only the GPL Version 2, indicate your decision by adding "[Contributor]
   * elects to include this software in this distribution under the [CDDL or GPL
   * Version 2] license."  If you don't indicate a single choice of license, a
   * recipient has the option to distribute your version of this file under
   * either the CDDL, the GPL Version 2 or to extend the choice of license to
   * its licensees as provided above.  However, if you add GPL Version 2 code
   * and therefore, elected the GPL Version 2 license, then the option applies
   * only if the new code is made subject to such option by the copyright
   * holder.
   */
  
  package com.sun.enterprise.web;
  
  
  
  import javax.servlet.*;
  import java.io.*;
 import java.net.*;
 import java.util.*;
Class representing a web module for use by the Application Server.
 
 
 public class WebModule extends PwcWebModule implements Context {
 
     // ----------------------------------------------------- Class Variables
 
     private static final Logger logger = .;
 
     protected static final ResourceBundle rb = .getResourceBundle();
 
     @LogMessageInfo(
             message = "Unable to create custom ObjectInputStream",
             level = "SEVERE",
             cause = "An exception occurred during creating ObjectInputStream",
             action = "Check the Exception for error")
     public static final String CREATE_CUSTOM_OBJECT_INTPUT_STREAM_ERROR = "AS-WEB-00150";
 
     @LogMessageInfo(
             message = "Unable to create custom ObjectOutputStream",
             level = "SEVERE",
             cause = "An exception occurred during creating ObjectOutputStream",
             action = "Check the Exception for error")
     public static final String CREATE_CUSTOM_BOJECT_OUTPUT_STREAM_ERROR = "AS-WEB-00151";
 
     @LogMessageInfo(
             message = "The default-locale attribute of locale-charset-info element is being ignored",
             level = "WARNING")
     public static final String DEFAULT_LOCALE_DEPRECATED = "AS-WEB-00152";
 
     @LogMessageInfo(
             message = "Realm {0} is not an instance of {1}, and will be ignored",
             level = "SEVERE",
             cause = "Realm {0} is not an instance of {1}",
             action = "Check the Realm")
     public static final String IGNORE_INVALID_REALM = "AS-WEB-00153";
 
     @LogMessageInfo(
             message = "Web module [{0}] has a property with missing name or value",
             level = "WARNING")
     public static final String NULL_WEB_MODULE_PROPERTY = "AS-WEB-00154";
 
     @LogMessageInfo(
             message = "Object of type {0} is not a valve",
             level = "WARNING")
     public static final String VALVE_CLASS_NAME_NO_VALVE = "AS-WEB-00155";
 
     @LogMessageInfo(
             message = "Unable to add valve to web module {0}",
             level = "WARNING")
     public static final String VALVE_MISSING_NAME = "AS-WEB-00156";
 
     @LogMessageInfo(
             message = "Unable to add valve with name {0} to web module {1}",
             level = "WARNING")
     public static final String VALVE_MISSING_CLASS_NAME = "AS-WEB-00157";
 
     @LogMessageInfo(
             message = "No method {0}(java.lang.String) defined on valve {1} of web module {2}",
             level = "SEVERE",
             cause = "A matching method is not found",
             action = "Check the method name")
     public static final String VALVE_SPECIFIED_METHOD_MISSING = "AS-WEB-00159";
 
     @LogMessageInfo(
             message = "Exception during execution of method {0} on valve {1} of web module {2}",
             level = "SEVERE",
             cause = "An exception occurred during method execution",
             action = "Check the Exception for error")
     public static final String VALVE_SETTER_CAUSED_EXCEPTION = "AS-WEB-00160";
 
     @LogMessageInfo(
             message = "Valve {0} of web module {1} has a property without any name",
             level = "SEVERE",
             cause = "The valve is missing property name",
             action = "Check the property name")
     public static final String VALVE_MISSING_PROPERTY_NAME = "AS-WEB-00161";
 
     @LogMessageInfo(
             message = "Unable to add listener of type {0} to web module {1}",
             level = "WARNING")
     public static final String INVALID_LISTENER = "AS-WEB-00162";
 
     @LogMessageInfo(
             message = "Unable to load extension class {0} from web module {1}",
             level = "WARNING")
     public static final String UNABLE_TO_LOAD_EXTENSION = "AS-WEB-00163";
 
     @LogMessageInfo(
             message = "Null property name or value for alternate docbase",
             level = "WARNING")
     public static final String ALTERNATE_DOC_BASE_NULL_PROPERTY_NAME_VALVE = "AS-WEB-00164";
 
     @LogMessageInfo(
             message = "Alternate docbase property value {0} is missing a URL pattern or docbase",
             level = "WARNING")
     public static final String ALTERNATE_DOC_BASE_MISSING_PATH_OR_URL_PATTERN = "AS-WEB-00165";
 
     @LogMessageInfo(
             message = "URL pattern {0} for alternate docbase is invalid",
             level = "WARNING")
     public static final String ALTERNATE_DOC_BASE_ILLEGAL_URL_PATTERN = "AS-WEB-00166";
 
     @LogMessageInfo(
             message = "Failed to parse sun-web.xml singleThreadedServletPoolSize property value ({0}) of web module deployed at {1}, using default ({2})",
             level = "WARNING")
     public static final String INVALID_SERVLET_POOL_SIZE = "AS-WEB-00167";
 
     @LogMessageInfo(
             message = "Enabled session ID reuse for web module {0} deployed on virtual server {1}",
             level = "WARNING")
     public static final String SESSION_IDS_REUSED = "AS-WEB-00168";
 
     @LogMessageInfo(
             message = "Using alternate deployment descriptor {0} for web module {1}",
             level = "FINE")
     public static final String ALT_DD_NAME = "AS-WEB-00169";
 
     @LogMessageInfo(
             message = "Ignoring invalid property {0} = {1}",
             level = "WARNING")
     public static final String INVALID_PROPERTY = "AS-WEB-00170";
 
     @LogMessageInfo(
             message = "Unable to save sessions for web module {0} during redeployment",
             level = "WARNING")
     public static final String UNABLE_TO_SAVE_SESSIONS_DURING_REDEPLOY = "AS-WEB-00171";
 
     @LogMessageInfo(
             message = "Unable to restore sessions for web module [{0}] from previous deployment",
             level = "WARNING")
     public static final String UNABLE_TO_RESTORE_SESSIONS_DURING_REDEPLOY = "AS-WEB-00172";
 
     @LogMessageInfo(
             message = "Webservice based application, requires Metro to be installed. Run updatecenter client located in bin folder to install Metro",
             level = "WARNING")
     public static final String MISSING_METRO = "AS-WEB-00173";
 
     @LogMessageInfo(
             message = "WebModule[{0}]: Setting delegate to {1}",
             level = "FINE")
     public static final String SETTING_DELEGATE = "AS-WEB-00174";
 
     @LogMessageInfo(
             message = "WebModule[{0}]: Adding {1} to the classpath",
             level = "FINE")
     public static final String ADDING_CLASSPATH = "AS-WEB-00175";
 
     @LogMessageInfo(
             message = "extra-class-path component {0} is not a valid pathname",
             level = "SEVERE",
             cause = "A MalformedURLException occurred",
             action = "Check the extra-class-path component")
     public static final String CLASSPATH_ERROR = "AS-WEB-00176";
 
     @LogMessageInfo(
             message = "class-loader attribute dynamic-reload-interval in sun-web.xml not supported",
             level = "WARNING")
     public static final String DYNAMIC_RELOAD_INTERVAL = "AS-WEB-00177";
 
     @LogMessageInfo(
             message = "IN WebContainer>>ConfigureSessionManager before builder factory " +
                     "FINAL_PERSISTENCE-TYPE IS = {0} " +
                     "FINAL_PERSISTENCE_FREQUENCY IS = {1} " +
                     "FINAL_PERSISTENCE_SCOPE IS = {2}",
             level = "FINEST")
     public static final String CONFIGURE_SESSION_MANAGER = "AS-WEB-00178";
 
     @LogMessageInfo(
             message = "PersistenceStrategyBuilder class = {0}",
             level = "FINEST")
     public static final String PERSISTENCE_STRATEGY_BUILDER = "AS-WEB-00179";
 
     @LogMessageInfo(
             message = "Property [{0}] is not yet supported",
             level = "INFO")
     public static final String PROP_NOT_YET_SUPPORTED = "AS-WEB-00180";
 
     @LogMessageInfo(
             message = "WebModule[{0}] configure cookie properties {1}",
             level = "FINE")
     public static final String CONFIGURE_COOKIE_PROPERTIES = "AS-WEB-00181";
 
     @LogMessageInfo(
             message = "Unable to add listener of type: {0}, because it does not implement any of the required " +
                     "ServletContextListener, ServletContextAttributeListener, ServletRequestListener, " +
                     "ServletRequestAttributeListener, HttpSessionListener, or HttpSessionAttributeListener interfaces",
             level = "WARNING")
     public static final String INVALID_LISTENER_TYPE = "AS-WEB-00182";
 
     private static final String ALTERNATE_FROM = "from=";
     private static final String ALTERNATE_DOCBASE = "dir=";
 
     private static final GFBase64Encoder gfEncoder = new GFBase64Encoder();
     private static final GFBase64Decoder gfDecoder = new GFBase64Decoder();
 
     private static final String WS_SERVLET_CONTEXT_LISTENER =
         "com.sun.xml.ws.transport.http.servlet.WSServletContextListener";
 
     // ----------------------------------------------------- Instance Variables
 
     // Object containing sun-web.xml information
     private SunWebAppImpl iasBean = null;
 
     //locale-charset-info tag from sun-web.xml
     private LocaleCharsetMap[] _lcMap = null;

    
Is the default-web.xml parsed?
 
     private boolean hasBeenXmlConfigured = false;
 
     private WebContainer webContainer;
 
     private final Map<String,AdHocServletInfoadHocPaths;
     private boolean hasAdHocPaths;
 
     private final Map<String,AdHocServletInfoadHocSubtrees;
     private boolean hasAdHocSubtrees;
 
     private StandardPipeline adHocPipeline;
 
     // File encoding of static resources
     private String fileEncoding;

    
Cached findXXX results
 
     protected Object[] cachedFinds;
 
     private Application bean;
 
 
     private boolean hasStarted = false;
     private String compEnvId = null;
     private ServerContext serverContext = null;
 
     private ServletProbeProvider servletProbeProvider = null;
     private SessionProbeProvider sessionProbeProvider = null;
 
     private JavaEEIOUtils javaEEIOUtils;
 
     // The id of the parent container (i.e., virtual server) on which this
     // web module was deployed
     private String vsId;
 
     private String monitoringNodeName;
 
     private WebModuleConfig wmInfo;
 
     // true if standalone WAR, false if embedded in EAR file
     private boolean isStandalone = true;
 
     private ServiceLocator services;

    
Constructor.
 
     public WebModule() {
         this(null);
     }
 
     public WebModule(ServiceLocator services) {
         super();
         this. = services;
         this. = new HashMap<String,AdHocServletInfo>();
         this. = new HashMap<String,AdHocServletInfo>();
 
         this. = new StandardPipeline(this);
         this..setBasic(new AdHocContextValve(this));
 
          = false;
     }


    
set the sun-web.xml config bean
 
     public void setIasWebAppConfigBean(SunWebAppImpl iasBean) {
        this. = iasBean;
     }

    
gets the sun-web.xml config bean
 
        return ;
     }

    
Gets the web container in which this web module was loaded.

Returns:
the web container in which this web module was loaded
 
     public WebContainer getWebContainer() {
         return ;
     }

    
Sets the web container in which this web module was loaded.
 
     public void setWebContainer(WebContainer webContainer) {
         this. = webContainer;
         this. = webContainer.getServletProbeProvider();
         this. = webContainer.getSessionProbeProvider();
         this. =
             webContainer.getWebModuleProbeProvider();
         this. =
             webContainer.getJavaEEIOUtils();
     }
 
     public void setWebModuleConfig(WebModuleConfig wmInfo) {
         this. = wmInfo;
     }
 
     public WebModuleConfig getWebModuleConfig() {
         return ;
     }
 
     void setMonitoringNodeName(String monitoringNodeName) {
         this. = monitoringNodeName;
     }
 
     public String getMonitoringNodeName() {
         return ;
     }

    
Sets the parameter encoding (i18n) info from sun-web.xml.
 
     public void setI18nInfo() {
 
         if ( == null) {
             return;
         }
 
         if (.isParameterEncoding()) {
              = .getAttributeValue(
                                                 .,
                                                 .);
              = .getAttributeValue(
                                                 .,
                                                 .);
         }
 
         LocaleCharsetInfo lcinfo = .getLocaleCharsetInfo();
         if (lcinfo != null) {
             if (lcinfo.getAttributeValue(
                             .) != null) {
                .warning();
             }
             /*
              * <parameter-encoding> subelem of <sun-web-app> takes precedence
              * over that of <locale-charset-info>
              */
             if (lcinfo.isParameterEncoding()
                     && !.isParameterEncoding()) {
                  = lcinfo.getAttributeValue(
                                         .,
                                         .);
                  = lcinfo.getAttributeValue(
                                         .,
                                         .);
             }
              = lcinfo.getLocaleCharsetMap();
         }
     }

    
return locale-charset-map
 
     public LocaleCharsetMap[] getLocaleCharsetMap() {
         return ;
     }

    
Returns true if this web module specifies a locale-charset-map in its sun-web.xml, false otherwise.

Returns:
true if this web module specifies a locale-charset-map in its sun-web.xml, false otherwise
 
     @Override
     public boolean hasLocaleToCharsetMapping() {
         LocaleCharsetMap[] locCharsetMap = getLocaleCharsetMap();
         return (locCharsetMap != null && locCharsetMap.length > 0);
     }

    
Matches the given request locales against the charsets specified in the locale-charset-map of this web module's sun-web.xml, and returns the first matching charset.

Parameters:
locales Request locales
Returns:
First matching charset, or null if this web module does not specify any locale-charset-map in its sun-web.xml, or no match was found
 
     @Override
     public String mapLocalesToCharset(Enumeration locales) {
 
         String encoding = null;
 
         LocaleCharsetMap[] locCharsetMap = getLocaleCharsetMap();
         if (locCharsetMap != null && locCharsetMap.length > 0) {
             /*
              * Check to see if there is a match between the request
              * locales (in preference order) and the locales in the
              * locale-charset-map.
              */
             boolean matchFound = false;
             while (locales.hasMoreElements() && !matchFound) {
                 Locale reqLoc = (Localelocales.nextElement();
                 for (int i=0; i<locCharsetMap.length && !matchFoundi++) {
                     String language = locCharsetMap[i].getAttributeValue(
                                                 .);
                     if (language == null || "".equals(language)) {
                         continue;
                     }
                     String country = null;
                     int index = language.indexOf('_');
                     if (index != -1) {
                         country = language.substring(index+1);
                         language = language.substring(0, index);
                     }
                     Locale mapLoc = null;
                     if (country != null) {
                         mapLoc = new Locale(languagecountry);
                     } else {
                         mapLoc = new Locale(language);
                     }
                     if (mapLoc.equals(reqLoc)) {
                         /*
                          * Match found. Get the charset to which the
                          * matched locale maps.
                          */
                         encoding = locCharsetMap[i].getAttributeValue(
                                                     .);
                         matchFound = true;
                     }
                 }
             }
         }
 
         return encoding;
     }

    
Creates an ObjectInputStream that provides special deserialization logic for classes that are normally not serializable (such as javax.naming.Context).
 
     @Override
             throws IOException {
 
         ObjectInputStream ois = null;
 
         Loader loader = getLoader();
         if (loader != null) {
             ClassLoader classLoader = loader.getClassLoader();
             if (classLoader != null) {
                 try {
                     ois = .createObjectInputStream(
                         istrueclassLoader);
                 } catch (Exception e) {
                     .log(.,
                             e);
                 }
             }
         }
 
         if (ois == null) {
             ois = new ObjectInputStream(is);
         }
 
         return ois;
     }

    
Creates an ObjectOutputStream that provides special serialization logic for classes that are normally not serializable (such as javax.naming.Context).
 
     @Override
             throws IOException {
 
         ObjectOutputStream oos = null;
 
         try {
             oos = .createObjectOutputStream(ostrue);
         } catch (IOException ioe) {
             .log(.,
                     ioe);
             oos = new ObjectOutputStream(os);
         }
 
         return oos;
     }

    
Set to true when the default-web.xml has been read for this module.
 
     public void setXmlConfigured(boolean hasBeenXmlConfigured){
         this. = hasBeenXmlConfigured;
     }

    
Return true if the default=web.xml has been read for this module.
 
     public boolean hasBeenXmlConfigured(){
         return ;
     }

    
Cache the result of doing findXX on this object NOTE: this method MUST be used only when loading/using the content of default-web.xml
 
     public void setCachedFindOperation(Object[] cachedFinds){
         this. = cachedFinds;
     }

    
Return the cached result of doing findXX on this object NOTE: this method MUST be used only when loading/using the content of default-web.xml
 
     public Object[] getCachedFindOperation(){
         return ;
     }
 
     @Override
     public void setRealm(Realm realm) {
         if ((realm != null) && !(realm instanceof RealmAdapter)) {
             .log(.,
                     new Object[] { realm.getClass().getName(),
                         RealmAdapter.class.getName() });
         } else {
             super.setRealm(realm);
         }
     }

    
Starts this web module.
 
     @Override
     public synchronized void start() throws LifecycleException {
         // Get interestList of ServletContainerInitializers present, if any.
         List<ObjectorderingList = null;
         boolean hasOthers = false;
         Map<StringStringwebFragmentMap = Collections.emptyMap();
         if ( != null) {
             AbsoluteOrderingDescriptor aod =
                     ((WebBundleDescriptorImpl)).getAbsoluteOrderingDescriptor();
             if (aod != null) {
                 orderingList = aod.getOrdering();
                 hasOthers = aod.hasOthers();
             }
             webFragmentMap = .getJarNameToWebFragmentNameMap();
         }
 
         Iterable<ServletContainerInitializerallInitializers =
             ServletContainerInitializerUtil.getServletContainerInitializers(
                 webFragmentMaporderingListhasOthers,
                 .getAppClassLoader());
         setServletContainerInitializerInterestList(allInitializers);
 
         if (dc != null) {
              = 
                     Boolean.valueOf(dc.getAppProps().getProperty(.));
         }
         if ( != null) {
         }
 
         // Start and register Tomcat mbeans
         super.start();
 
         // Configure catalina listeners and valves. This can only happen
         // after this web module has been started, in order to be able to
         // load the specified listener and valve classes.
         configureValves();
         configureCatalinaProperties();
         webModuleStartedEvent();
         if () {
             setDirectoryListing();
         }
 
          = true;
     }

    
Stops this web module.
 
     @Override
     public void stop() throws LifecycleException {
         // Unregister monitoring mbeans only if this web module was
         // successfully started, because if stop() is called during an
         // aborted start(), no monitoring mbeans will have been registered
         if () {
             webModuleStoppedEvent();
              = false;
         }
 
         // Stop and unregister Tomcat mbeans
         super.stop(getWebContainer().isShutdown());
     }
 
     @Override
     protected void contextListenerStart() {
         ServletContext servletContext = getServletContext();
         WebBundleDescriptor wbd = getWebBundleDescriptor();
         try {
             // for jsf injection
             servletContext.setAttribute(
                     .,
                     getWebModuleConfig().getDeploymentContext());
             // null check for OSGi/HTTP
             if (wbd != null) {
                 servletContext.setAttribute(
                         .,
                         wbd.isDistributable());
             }
             servletContext.setAttribute(
                     .,
                     Boolean.valueOf(
                         .getServerConfigLookup().calculateWebAvailabilityEnabledFromConfig(this)));
 
             super.contextListenerStart();
         } finally {
             servletContext.removeAttribute(
                     .);
             servletContext.removeAttribute(
                     .);
             servletContext.removeAttribute(
                     .);
         }
         for (ServletRegistrationImpl srImpl : .values()) {
             if (srImpl instanceof DynamicWebServletRegistrationImpl) {
                 DynamicWebServletRegistrationImpl dwsrImpl =
                     (DynamicWebServletRegistrationImpl)srImpl;
                 dwsrImpl.postProcessAnnotations();
             }
         }
     }
 
     @Override
     protected Types getTypes() {
         if (.getDeploymentContext()!=null) {
             return .getDeploymentContext().getTransientAppMetaData(Types.class.getName(), Types.class);
         } else {
             return null;
         }
     }
 
     @Override
     protected void callServletContainerInitializers()
             throws LifecycleException {
         super.callServletContainerInitializers();
         if (!isJsfApplication() && !.isEmpty()) {
             /* 
              * Remove any JSF related ServletContextListeners from
              * non-JSF apps.
              * This can be done reliably only after all
              * ServletContainerInitializers have been invoked, because
              * system-wide ServletContainerInitializers may be invoked in
              * any order, and it is only after JSF's FacesInitializer has
              * been invoked that isJsfApplication(), which checks for the
              * existence of a mapping to the FacesServlet in the app, may
              * be used reliably because such mapping would have been added
              * by JSF's FacesInitializer. See also IT 10223
              */
             ArrayList<ServletContextListenerlisteners =
                 new ArrayList<ServletContextListener>();
             String listenerClassName = null;
             for (ServletContextListener listener : listeners) {
                 if (listener instanceof
                         StandardContext.RestrictedServletContextListener) {
                     listenerClassName = ((StandardContext.RestrictedServletContextListenerlistener).getNestedListener().getClass().getName();
                 } else {
                     listenerClassName = listener.getClass().getName();
                 }
                 /*
                  * TBD: Retrieve listener class name from JSF's TldProvider
                  */
                 if ("com.sun.faces.config.ConfigureListener".equals(
                         listenerClassName)) {
                     .remove(listener);
                 }
             }
         }
     }

    
Sets the virtual server parent of this web module, and passes it on to this web module's realm adapter..

Parameters:
container The virtual server parent
 
     @Override
     public void setParent(Container container) {
         super.setParent(container);
 
         if (container instanceof VirtualServer) {
              = ((VirtualServercontainer).getID();
         }
 
         // The following assumes that the realm has been set on this WebModule
         // before the WebModule is added as a child to the virtual server on
         // which it is being deployed.
         /*RealmAdapter ra = (RealmAdapter) getRealm();
         if (ra != null) {
           1  ra.setVirtualServer(container);
         }*/
         Realm ra = getRealm();
         if (ra != null && ra instanceof RealmInitializer) {
             ((RealmInitializerra).setVirtualServer(container);
         }
     }

    
Indicates whether this web module contains any ad-hoc paths. An ad-hoc path is a servlet path that is mapped to a servlet not declared in the web module's deployment descriptor. A web module all of whose mappings are for ad-hoc paths is called an ad-hoc web module.

Returns:
true if this web module contains any ad-hoc paths, false otherwise
 
     @Override
     public boolean hasAdHocPaths() {
         return this.;
     }

    
Indicates whether this web module contains any ad-hoc subtrees.

Returns:
true if this web module contains any ad-hoc subtrees, false otherwise
 
     public boolean hasAdHocSubtrees() {
         return this.;
     }
 
     /*
      * Adds the given ad-hoc path and subtree, along with information about
      * the servlet that will be responsible for servicing it, to this web
      * module.
      *
      * @param path The ad-hoc path to add
      * @param subtree The ad-hoc subtree path to add
      * @param servletInfo Information about the servlet that is responsible
      * for servicing the given ad-hoc path
      */
     void addAdHocPathAndSubtree(String path,
                                 String subtree,
                                 AdHocServletInfo servletInfo) {
 
         if (path == null && subtree == null) {
             return;
         }
 
         Wrapper adHocWrapper = (Wrapper)
             findChild(servletInfo.getServletName());
         if (adHocWrapper == null) {
             adHocWrapper = createAdHocWrapper(servletInfo);
             addChild(adHocWrapper);
         }
 
         if (path != null) {
             .put(pathservletInfo);
              = true;
         }
 
         if (subtree != null) {
             .put(subtreeservletInfo);
              = true;
         }
     }
 
     /*
      * Adds the given ad-hoc path to servlet mappings to this web module.
      *
      * @param newPaths Mappings of ad-hoc paths to the servlets responsible
      * for servicing them
      */
     void addAdHocPaths(Map<StringAdHocServletInfonewPaths) {
 
         if (newPaths == null || newPaths.isEmpty()) {
             return;
         }
         for (Map.Entry<StringAdHocServletInfoentry : newPaths.entrySet()) {
             AdHocServletInfo servletInfo = entry.getValue();
             Wrapper adHocWrapper = (Wrapper)
                 findChild(servletInfo.getServletName());
             if(adHocWrapper == null) {
                 adHocWrapper = createAdHocWrapper(servletInfo);
                 addChild(adHocWrapper);
             }
             .put(entry.getKey(), servletInfo);
         }
 
          = true;
     }
 
     /*
      * Adds the given ad-hoc subtree path to servlet mappings to this web
      * module.
      *
      * @param newSubtrees Mappings of ad-hoc subtree paths to the servlets
      * responsible for servicing them
      */
     void addAdHocSubtrees(Map<StringAdHocServletInfonewSubtrees) {
 
         if (newSubtrees == null || newSubtrees.isEmpty()) {
             return;
         }
         for (Map.Entry<StringAdHocServletInfoentry : newSubtrees.entrySet()) {
             AdHocServletInfo servletInfo = entry.getValue();
             Wrapper adHocWrapper = (Wrapper)findChild(servletInfo.getServletName());
             if(adHocWrapper == null) {
                 adHocWrapper = createAdHocWrapper(servletInfo);
                 addChild(adHocWrapper);
             }
             .put(entry.getKey(), servletInfo);
         }
 
          = true;
     }
 
     /*
      * Gets the ad-hoc path to servlet mappings managed by this web module.
      *
      * @return The ad-hoc path to servlet mappings managed by this web
      * module.
      */
         return ;
     }
 
     /*
      * Gets the ad-hoc subtree path to servlet mappings managed by this
      * web module.
      *
      * @return The ad-hoc subtree path to servlet mappings managed by
      * this web module.
      */
         return ;
     }

    
Returns the name of the ad-hoc servlet responsible for servicing the given path.

Parameters:
path The path whose associated ad-hoc servlet is needed
Returns:
The name of the ad-hoc servlet responsible for servicing the given path, or null if the given path does not represent an ad-hoc path
 
     @Override
     public String getAdHocServletName(String path) {
 
         if (!hasAdHocPaths() && !hasAdHocSubtrees()) {
             return null;
         }
 
         AdHocServletInfo servletInfo = null;
 
         // Check if given path matches any of the ad-hoc paths (exact match)
         if (path == null) {
             servletInfo = .get("");
         } else {
             servletInfo = .get(path);
         }
        // Check if given path starts with any of the ad-hoc subtree paths
        if (servletInfo == null && path != null && hasAdHocSubtrees()) {
            for(String adHocSubtree : .keySet()) {
                if(path.startsWith(adHocSubtree)) {
                    servletInfo = .get(adHocSubtree);
                    break;
                }
            }
        }
        if (servletInfo != null) {
            return servletInfo.getServletName();
        } else {
            return null;
        }
    }
    /*
     * Removes the given ad-hoc path from this web module.
     *
     * @param path The ad-hoc path to remove
     */
    void removeAdHocPath(String path) {
        if (path == null) {
            return;
        }
        .remove(path);
        if (.isEmpty()) {
            this. = false;
        }
    }
    /*
     * Removes the given ad-hoc path from this web module.
     *
     * @param subtree The ad-hoc subtree to remove
     */
    void removeAdHocSubtree(String subtree) {
        if (subtree == null) {
            return;
        }
        .remove(subtree);
        if (.isEmpty()) {
            this. = false;
        }
    }

    
Adds the given valve to this web module's ad-hoc pipeline.

Parameters:
valve The valve to add
    public void addAdHocValve(GlassFishValve valve) {
        .addValve(valve);
    }

    
Removes the given valve from this web module's ad-hoc pipeline.

Parameters:
valve The valve to remove
    public void removeAdHocValve(GlassFishValve valve) {
        .removeValve(valve);
    }

    
Gets this web module's ad-hoc pipeline.

Returns:
This web module's ad-hoc pipeline
    public Pipeline getAdHocPipeline() {
        return ;
    }

    
Sets the file encoding of all static resources of this web module.

Parameters:
enc The file encoding of static resources of this web module
    public void setFileEncoding(String enc) {
        this. = enc;
    }

    
Gets the file encoding of all static resources of this web module.

Returns:
The file encoding of static resources of this web module
    public String getFileEncoding() {
        return ;
    }

    
Configures this web module with the filter mappings specified in the deployment descriptor.

Parameters:
sfm The filter mappings of this web module as specified in the deployment descriptor
    @SuppressWarnings({"unchecked"})
    void addFilterMap(ServletFilterMapping sfm) {
        FilterMaps filterMaps = new FilterMaps();
        filterMaps.setFilterName(sfm.getName());
        filterMaps.setDispatcherTypes(sfm.getDispatchers());
        List<StringservletNames = sfm.getServletNames();
        if (servletNames != null) {
            for(String servletName : servletNames) {
                filterMaps.addServletName(servletName);
            }
        }
        List<StringurlPatterns = sfm.getUrlPatterns();
        if (urlPatterns != null) {
            for(String urlPattern : urlPatterns) {
                filterMaps.addURLPattern(urlPattern);
            }
        }
        addFilterMaps(filterMaps);
    }

    
Creates an ad-hoc servlet wrapper from the given ad-hoc servlet info.

Parameters:
servletInfo Ad-hoc servlet info from which to generate ad-hoc servlet wrapper
Returns:
The generated ad-hoc servlet wrapper
    private Wrapper createAdHocWrapper(AdHocServletInfo servletInfo) {
        Wrapper adHocWrapper = new StandardWrapper();
        adHocWrapper.setServletClassName(
            servletInfo.getServletClass().getName());
        adHocWrapper.setName(servletInfo.getServletName());
        Map<String,StringinitParams = servletInfo.getServletInitParams();
        if (initParams != null && !initParams.isEmpty()) {
            for(Map.Entry<String,Stringentry : initParams.entrySet()) {
                adHocWrapper.addInitParameter(entry.getKey(), entry.getValue());
            }
        }
        return adHocWrapper;
    }

    
Configure the WebModule valves.
    protected void configureValves(){
        if ( != null && .getValve() != null && .sizeValve() > 0) {
            org.glassfish.web.deployment.runtime.Valve[] valves = .getValve();
            for (org.glassfish.web.deployment.runtime.Valve valvevalves) {
                addValve(valve);
            }
        }
    }

    
Configure the WebModule< properties.
    protected void configureCatalinaProperties(){
        String propName = null;
        String propValue = null;
        if ( != null) {
            List<Propertyprops = .getProperty();
            if (props != null) {
                for (Property prop : props) {
                    propName = prop.getName();
                    propValue = prop.getValue();
                    configureCatalinaProperties(propName,propValue);
                }
            }
        }
        if ( != null && .sizeWebProperty() > 0) {
            WebProperty[] wprops = .getWebProperty();
            for(WebProperty wprop : wprops) {
                propName = wprop.getAttributeValue("name");
                propValue = wprop.getAttributeValue("value");
                configureCatalinaProperties(propNamepropValue);
            }
        }
    }

    
Configure the WebModule< properties.

Parameters:
propName the property name
propValue the property value
    protected void configureCatalinaProperties(String propName,
                                               String propValue){
        if (propName == null || propValue == null) {
            .log(.,
                        ,
                        getName());
            return;
        }
        if (propName.startsWith("valve_")) {
            addValve(propValue);
        } else if (propName.startsWith("listener_")) {
            addCatalinaListener(propValue);
        }
    }

    
Instantiates a Valve from the given className and adds it to the Pipeline of this WebModule.

Parameters:
className the fully qualified class name of the Valve
    protected void addValve(String className) {
        Object valve = loadInstance(className);
        if (valve instanceof Valve) {
            super.addValve((Valvevalve);
        } else if (valve instanceof GlassFishValve) {
            super.addValve((GlassFishValvevalve);
        } else {
                       className);
        }
    }

    
Constructs a Valve from the given valveDescriptor and adds it to the Pipeline of this WebModule.

Parameters:
valveDescriptor the object containing the information to create the valve.
    protected void addValve(org.glassfish.web.deployment.runtime.Valve valveDescriptor) {
        String valveName = valveDescriptor.getAttributeValue(
                ......);
        String className = valveDescriptor.getAttributeValue(
                ......);
        if (valveName == null) {
            .log(.,
                       getName());
            return;
        }
        if (className == null) {
                       new Object[]{valveNamegetName()});
            return;
        }
        Object valve = loadInstance(className);
        if (valve == null) {
            return;
        }
        if (!(valve instanceof GlassFishValve) &&
                !(valve instanceof Valve)) {
            .log(.