| Methods Summary |
|---|
| public void | addChild(org.apache.catalina.Container child)Refuse to add a child Container, because Wrappers are the lowest level
of the Container hierarchy.
throw new IllegalStateException
(sm.getString("standardWrapper.notChild"));
|
| protected void | addDefaultMapper(java.lang.String mapperClass)Add a default Mapper implementation if none have been configured
explicitly.
; // No need for a default Mapper on a Wrapper
|
| public void | addInitParameter(java.lang.String name, java.lang.String value)Add a new servlet initialization parameter for this servlet.
synchronized (parameters) {
parameters.put(name, value);
}
if (notifyContainerListeners) {
fireContainerEvent("addInitParameter", name);
}
|
| public void | addInstanceListener(org.apache.catalina.InstanceListener listener)Add a new listener interested in InstanceEvents.
instanceSupport.addInstanceListener(listener);
|
| public void | addMapping(java.lang.String mapping)Add a mapping associated with the Wrapper.
synchronized (mappings) {
mappings.add(mapping);
}
if (notifyContainerListeners) {
fireContainerEvent("addMapping", mapping);
}
|
| public void | addSecurityReference(java.lang.String name, java.lang.String link)Add a new security role reference record to the set of records for
this servlet.
synchronized (references) {
references.put(name, link);
}
if (notifyContainerListeners) {
fireContainerEvent("addSecurityReference", name);
}
|
| public synchronized void | addValve(org.apache.catalina.Valve valve)
/*
* This exception should never be thrown in reality, because we never
* add any valves to a StandardWrapper.
* This exception is added here as an alert mechanism only, should
* there ever be a need to add valves to a StandardWrapper in the
* future.
* In that case, the optimization in StandardContextValve related to
* GlassFish 1343 will need to be adjusted, by calling
* pipeline.getValves() and checking the pipeline's length to
* determine whether the basic valve may be invoked directly. The
* optimization currently avoids a call to pipeline.getValves(),
* because it is expensive.
*/
throw new UnsupportedOperationException(
"Adding valves to wrappers not supported");
|
| public javax.servlet.Servlet | allocate()Allocate an initialized instance of this Servlet that is ready to have
its service() method called. If the servlet class does
not implement SingleThreadModel, the (only) initialized
instance may be returned immediately. If the servlet class implements
SingleThreadModel, the Wrapper implementation must ensure
that this instance is not allocated again until it is deallocated by a
call to deallocate().
// If we are currently unloading this servlet, throw an exception
if (unloading)
throw new ServletException
(sm.getString("standardWrapper.unloading", getName()));
// If not SingleThreadedModel, return the same instance every time
if (!singleThreadModel) {
// Load and initialize our instance if necessary
if (instance == null) {
synchronized (this) {
if (instance == null) {
try {
if (log.isTraceEnabled())
log.trace("Allocating non-STM instance");
instance = loadServlet();
} catch (ServletException e) {
throw e;
} catch (Throwable e) {
throw new ServletException
(sm.getString("standardWrapper.allocate"), e);
}
}
}
}
if (!singleThreadModel) {
if (log.isTraceEnabled())
log.trace(" Returning non-STM instance");
countAllocated++;
return (instance);
}
}
synchronized (instancePool) {
while (countAllocated >= nInstances) {
// Allocate a new instance if possible, or else wait
if (nInstances < maxInstances) {
try {
instancePool.push(loadServlet());
nInstances++;
} catch (ServletException e) {
throw e;
} catch (Throwable e) {
throw new ServletException
(sm.getString("standardWrapper.allocate"), e);
}
} else {
try {
instancePool.wait();
} catch (InterruptedException e) {
;
}
}
}
if (log.isTraceEnabled())
log.trace(" Returning allocated STM instance");
countAllocated++;
return (Servlet) instancePool.pop();
}
|
| public void | deallocate(javax.servlet.Servlet servlet)Return this previously allocated servlet to the pool of available
instances. If this servlet class does not implement SingleThreadModel,
no action is actually required.
// If not SingleThreadModel, no action is required
if (!singleThreadModel) {
countAllocated--;
return;
}
// Unlock and free this instance
synchronized (instancePool) {
countAllocated--;
instancePool.push(servlet);
instancePool.notify();
}
|
| public java.lang.String | findInitParameter(java.lang.String name)Return the value for the specified initialization parameter name,
if any; otherwise return null.
synchronized (parameters) {
return ((String) parameters.get(name));
}
|
| public java.lang.String[] | findInitParameters()Return the names of all defined initialization parameters for this
servlet.
synchronized (parameters) {
String results[] = new String[parameters.size()];
return ((String[]) parameters.keySet().toArray(results));
}
|
| public org.apache.catalina.Wrapper | findMappingObject()FIXME: Fooling introspection ...
return (Wrapper) getMappingObject();
|
| public java.lang.String[] | findMappings()Return the mappings associated with this wrapper.
synchronized (mappings) {
return (String[]) mappings.toArray(new String[mappings.size()]);
}
|
| public java.lang.String | findSecurityReference(java.lang.String name)Return the security role link for the specified security role
reference name, if any; otherwise return null.
synchronized (references) {
return ((String) references.get(name));
}
|
| public java.lang.String[] | findSecurityReferences()Return the set of security role reference names associated with
this servlet, if any; otherwise return a zero-length array.
synchronized (references) {
String results[] = new String[references.size()];
return ((String[]) references.keySet().toArray(results));
}
|
| private java.lang.reflect.Method[] | getAllDeclaredMethods(java.lang.Class c)
if (c.equals(javax.servlet.http.HttpServlet.class)) {
return null;
}
Method[] parentMethods = getAllDeclaredMethods(c.getSuperclass());
Method[] thisMethods = c.getDeclaredMethods();
if (thisMethods == null) {
return parentMethods;
}
if ((parentMethods != null) && (parentMethods.length > 0)) {
Method[] allMethods =
new Method[parentMethods.length + thisMethods.length];
System.arraycopy(parentMethods, 0, allMethods, 0,
parentMethods.length);
System.arraycopy(thisMethods, 0, allMethods, parentMethods.length,
thisMethods.length);
thisMethods = allMethods;
}
return thisMethods;
|
| public long | getAvailable()Return the available date/time for this servlet, in milliseconds since
the epoch. If this date/time is Long.MAX_VALUE, it is considered to mean
that unavailability is permanent and any request for this servlet will return
an SC_NOT_FOUND error. If this date/time is in the future, any request for
this servlet will return an SC_SERVICE_UNAVAILABLE error. If it is zero,
the servlet is currently available.
// ------------------------------------------------------------- Properties
return (this.available);
|
| public int | getClassLoadTime()
return classLoadTime;
|
| public int | getCountAllocated()Return the number of active allocations of this servlet, even if they
are all for the same instance (as will be true for servlets that do
not implement SingleThreadModel.
return (this.countAllocated);
|
| public int | getDebug()Return the debugging detail level for this component.
return (this.debug);
|
| public java.lang.String | getEngineName()
return ((StandardContext)getParent()).getEngineName();
|
| public int | getErrorCount()
return swValve.getErrorCount();
|
| public java.lang.String | getInfo()Return descriptive information about this Container implementation and
the corresponding version number, in the format
<description>/<version>.
return (info);
|
| public java.lang.String | getInitParameter(java.lang.String name)Return the initialization parameter value for the specified name,
if any; otherwise return null.
return (findInitParameter(name));
|
| public java.util.Enumeration | getInitParameterNames()Return the set of initialization parameter names defined for this
servlet. If none are defined, an empty Enumeration is returned.
synchronized (parameters) {
return (new Enumerator(parameters.keySet()));
}
|
| public org.apache.catalina.util.InstanceSupport | getInstanceSupport()Return the InstanceSupport object for this Wrapper instance.
return (this.instanceSupport);
|
| public java.lang.String | getJspFile()Return the context-relative URI of the JSP file for this servlet.
return (this.jspFile);
|
| public int | getLoadOnStartup()Return the load-on-startup order value (negative value means
load on first call).
if (isJspServlet && loadOnStartup < 0) {
/*
* JspServlet must always be preloaded, because its instance is
* used during registerJMX (when registering the JSP
* monitoring mbean)
*/
return Integer.MAX_VALUE;
} else {
return (this.loadOnStartup);
}
|
| public java.lang.String | getLoadOnStartupString()
return Integer.toString( getLoadOnStartup());
|
| public long | getLoadTime()
return loadTime;
|
| public int | getMaxInstances()Return maximum number of instances that will be allocated when a single
thread model servlet is used.
return (this.maxInstances);
|
| public long | getMaxTimeMillis()
return swValve.getMaxTimeMillis();
|
| public long | getMinTimeMillis()
return swValve.getMinTimeMillis();
|
| public long | getProcessingTimeMillis()
return swValve.getProcessingTimeMillis();
|
| public int | getRequestCount()
return swValve.getRequestCount();
|
| public static java.lang.Throwable | getRootCause(javax.servlet.ServletException e)Extract the root cause from a servlet exception.
Throwable rootCause = e;
Throwable rootCauseCheck = null;
// Extra aggressive rootCause finding
do {
try {
rootCauseCheck = (Throwable)IntrospectionUtils.getProperty
(rootCause, "rootCause");
if (rootCauseCheck!=null)
rootCause = rootCauseCheck;
} catch (ClassCastException ex) {
rootCauseCheck = null;
}
} while (rootCauseCheck != null);
return rootCause;
|
| public java.lang.String | getRunAs()Return the run-as identity for this servlet.
return (this.runAs);
|
| public java.lang.String | getServletClass()Return the fully qualified servlet class name for this servlet.
return (this.servletClass);
|
| public javax.servlet.ServletContext | getServletContext()Return the servlet context with which this servlet is associated.
if (parent == null)
return (null);
else if (!(parent instanceof Context))
return (null);
else
return (((Context) parent).getServletContext());
|
| public java.lang.String[] | getServletMethods()Gets the names of the methods supported by the underlying servlet.
This is the same set of methods included in the Allow response header
in response to an OPTIONS request method processed by the underlying
servlet.
Class servletClazz = loadServlet().getClass();
if (!javax.servlet.http.HttpServlet.class.isAssignableFrom(
servletClazz)) {
return DEFAULT_SERVLET_METHODS;
}
HashSet allow = new HashSet();
allow.add("TRACE");
allow.add("OPTIONS");
Method[] methods = getAllDeclaredMethods(servletClazz);
for (int i=0; methods != null && i<methods.length; i++) {
Method m = methods[i];
if (m.getName().equals("doGet")) {
allow.add("GET");
allow.add("HEAD");
} else if (m.getName().equals("doPost")) {
allow.add("POST");
} else if (m.getName().equals("doPut")) {
allow.add("PUT");
} else if (m.getName().equals("doDelete")) {
allow.add("DELETE");
}
}
String[] methodNames = new String[allow.size()];
return (String[]) allow.toArray(methodNames);
|
| public java.lang.String | getServletName()Return the name of this servlet.
return (getName());
|
| public void | incrementErrorCount()Increment the error count used for monitoring.
swValve.setErrorCount(swValve.getErrorCount() + 1);
|
| private boolean | isContainerProvidedServlet(java.lang.String classname)Return true if the specified class name represents a
container provided servlet class that should be loaded by the
server class loader.
if (classname.startsWith("org.apache.catalina.")) {
return (true);
}
try {
Class clazz =
this.getClass().getClassLoader().loadClass(classname);
return (ContainerServlet.class.isAssignableFrom(clazz));
} catch (Throwable t) {
return (false);
}
|
| public boolean | isEventProvider()
return false;
|
| private boolean | isServletAllowed(java.lang.Object servlet)Return true if loading this servlet is allowed.
if (servlet instanceof ContainerServlet) {
if (((Context) getParent()).getPrivileged()
|| (servlet.getClass().getName().equals
("org.apache.catalina.servlets.InvokerServlet"))) {
return (true);
} else {
return (false);
}
}
return (true);
|
| public boolean | isSingleThreadModel()Return true if the servlet class represented by this
component implements the SingleThreadModel interface.
try {
loadServlet();
} catch (Throwable t) {
;
}
return (singleThreadModel);
|
| public boolean | isStateManageable()
return false;
|
| public boolean | isStatisticsProvider()
return false;
|
| public boolean | isUnavailable()Is this servlet currently unavailable?
if (available == 0L)
return (false);
else if (available <= System.currentTimeMillis()) {
available = 0L;
return (false);
} else
return (true);
|
| public synchronized void | load()Load and initialize an instance of this servlet, if there is not already
at least one initialized instance. This can be used, for example, to
load servlets that are marked in the deployment descriptor to be loaded
at server startup time.
IMPLEMENTATION NOTE: Servlets whose classnames begin with
org.apache.catalina. (so-called "container" servlets)
are loaded by the same classloader that loaded this class, rather than
the classloader for the current web application.
This gives such classes access to Catalina internals, which are
prevented for classes loaded for web applications.
instance = loadServlet();
|
| public synchronized javax.servlet.Servlet | loadServlet()Load and initialize an instance of this servlet, if there is not already
at least one initialized instance. This can be used, for example, to
load servlets that are marked in the deployment descriptor to be loaded
at server startup time.
// Nothing to do if we already have an instance or an instance pool
if (!singleThreadModel && (instance != null))
return instance;
PrintStream out = System.out;
if (swallowOutput) {
SystemLogHandler.startCapture();
}
Servlet servlet;
try {
long t1=System.currentTimeMillis();
// If this "servlet" is really a JSP file, get the right class.
// HOLD YOUR NOSE - this is a kludge that avoids having to do special
// case Catalina-specific code in Jasper - it also requires that the
// servlet path be replaced by the <jsp-file> element content in
// order to be completely effective
String actualClass = servletClass;
if ((actualClass == null) && (jspFile != null)) {
Wrapper jspWrapper = (Wrapper)
((Context) getParent()).findChild(Constants.JSP_SERVLET_NAME);
if (jspWrapper != null) {
actualClass = jspWrapper.getServletClass();
// Merge init parameters
String paramNames[] = jspWrapper.findInitParameters();
for (int i = 0; i < paramNames.length; i++) {
if (parameters.get(paramNames[i]) == null) {
parameters.put
(paramNames[i],
jspWrapper.findInitParameter(paramNames[i]));
}
}
}
}
// Complain if no servlet class has been specified
if (actualClass == null) {
unavailable(null);
throw new ServletException
(sm.getString("standardWrapper.notClass", getName()));
}
// Acquire an instance of the class loader to be used
Loader loader = getLoader();
if (loader == null) {
unavailable(null);
throw new ServletException
(sm.getString("standardWrapper.missingLoader", getName()));
}
ClassLoader classLoader = loader.getClassLoader();
// Special case class loader for a container provided servlet
//
if (isContainerProvidedServlet(actualClass) &&
! ((Context)getParent()).getPrivileged() ) {
// If it is a priviledged context - using its own
// class loader will work, since it's a child of the container
// loader
classLoader = this.getClass().getClassLoader();
}
// Load the specified servlet class from the appropriate class loader
Class classClass = null;
try {
if (SecurityUtil.isPackageProtectionEnabled()){
final ClassLoader fclassLoader = classLoader;
final String factualClass = actualClass;
try{
classClass = (Class)AccessController.doPrivileged(
new PrivilegedExceptionAction(){
public Object run() throws Exception{
if (fclassLoader != null) {
return fclassLoader.loadClass(factualClass);
} else {
return Class.forName(factualClass);
}
}
});
} catch(PrivilegedActionException pax){
Exception ex = pax.getException();
if (ex instanceof ClassNotFoundException){
throw (ClassNotFoundException)ex;
} else {
getServletContext().log( "Error loading "
+ fclassLoader + " " + factualClass, ex );
}
}
} else {
if (classLoader != null) {
classClass = classLoader.loadClass(actualClass);
} else {
classClass = Class.forName(actualClass);
}
}
} catch (ClassNotFoundException e) {
unavailable(null);
getServletContext().log( "Error loading " + classLoader + " " + actualClass, e );
throw new ServletException
(sm.getString("standardWrapper.missingClass", actualClass),
e);
}
if (classClass == null) {
unavailable(null);
throw new ServletException
(sm.getString("standardWrapper.missingClass", actualClass));
}
// Instantiate and initialize an instance of the servlet class itself
try {
servlet = (Servlet) classClass.newInstance();
} catch (ClassCastException e) {
unavailable(null);
// Restore the context ClassLoader
throw new ServletException
(sm.getString("standardWrapper.notServlet", actualClass), e);
} catch (Throwable e) {
unavailable(null);
// Restore the context ClassLoader
throw new ServletException
(sm.getString("standardWrapper.instantiate", actualClass), e);
}
// Check if loading the servlet in this web application should be
// allowed
if (!isServletAllowed(servlet)) {
throw new SecurityException
(sm.getString("standardWrapper.privilegedServlet",
actualClass));
}
// Special handling for ContainerServlet instances
if ((servlet instanceof ContainerServlet) &&
(isContainerProvidedServlet(actualClass) ||
((Context)getParent()).getPrivileged() )) {
((ContainerServlet) servlet).setWrapper(this);
}
classLoadTime=(int) (System.currentTimeMillis() -t1);
// Call the initialization method of this servlet
try {
instanceSupport.fireInstanceEvent(InstanceEvent.BEFORE_INIT_EVENT,
servlet);
// START SJS WS 7.0 6236329
//if( System.getSecurityManager() != null) {
if ( SecurityUtil.executeUnderSubjectDoAs() ){
// END OF SJS WS 7.0 6236329
Object[] initType = new Object[1];
initType[0] = facade;
SecurityUtil.doAsPrivilege("init",
servlet,
classType,
initType);
initType = null;
} else {
servlet.init(facade);
}
// Invoke jspInit on JSP pages
if ((loadOnStartup >= 0) && (jspFile != null)) {
// Invoking jspInit
DummyRequest req = new DummyRequest();
req.setServletPath(jspFile);
req.setQueryString("jsp_precompile=true");
// START PWC 4707989
String allowedMethods = (String) parameters.get("httpMethods");
if (allowedMethods != null
&& allowedMethods.length() > 0) {
String[] s = allowedMethods.split(",");
if (s != null && s.length > 0) {
req.setMethod(s[0].trim());
}
}
// END PWC 4707989
DummyResponse res = new DummyResponse();
// START SJS WS 7.0 6236329
//if( System.getSecurityManager() != null) {
if ( SecurityUtil.executeUnderSubjectDoAs() ){
// END OF SJS WS 7.0 6236329
Object[] serviceType = new Object[2];
serviceType[0] = req;
serviceType[1] = res;
SecurityUtil.doAsPrivilege("service",
servlet,
classTypeUsedInService,
serviceType);
serviceType = null;
} else {
servlet.service(req, res);
}
}
instanceSupport.fireInstanceEvent(InstanceEvent.AFTER_INIT_EVENT,
servlet);
} catch (UnavailableException f) {
instanceSupport.fireInstanceEvent(InstanceEvent.AFTER_INIT_EVENT,
servlet, f);
unavailable(f);
throw f;
} catch (ServletException f) {
instanceSupport.fireInstanceEvent(InstanceEvent.AFTER_INIT_EVENT,
servlet, f);
// If the servlet wanted to be unavailable it would have
// said so, so do not call unavailable(null).
throw f;
} catch (Throwable f) {
getServletContext().log("StandardWrapper.Throwable", f );
instanceSupport.fireInstanceEvent(InstanceEvent.AFTER_INIT_EVENT,
servlet, f);
// If the servlet wanted to be unavailable it would have
// said so, so do not call unavailable(null).
throw new ServletException
(sm.getString("standardWrapper.initException", getName()), f);
}
// Register our newly initialized instance
singleThreadModel = servlet instanceof SingleThreadModel;
if (singleThreadModel) {
if (instancePool == null)
instancePool = new Stack();
}
if (notifyContainerListeners) {
fireContainerEvent("load", this);
}
loadTime=System.currentTimeMillis() -t1;
} finally {
if (swallowOutput) {
String log = SystemLogHandler.stopCapture();
if (log != null && log.length() > 0) {
if (getServletContext() != null) {
getServletContext().log(log);
} else {
out.println(log);
}
}
}
}
return servlet;
|
| protected java.lang.String | logName()Log the abbreviated name of this Container for logging messages.
StringBuffer sb = new StringBuffer("StandardWrapper[");
if (getParent() != null)
sb.append(getParent().getName());
else
sb.append("null");
sb.append(':");
sb.append(getName());
sb.append(']");
return (sb.toString());
|
| protected void | registerJMX(StandardContext ctx)
String parentName = ctx.getEncodedPath();
parentName = ("".equals(parentName)) ? "/" : parentName;
String hostName = ctx.getParent().getName();
hostName = (hostName==null) ? "DEFAULT" : hostName;
String domain = ctx.getDomain();
String webMod= "//" + hostName + parentName;
String onameStr = domain + ":j2eeType=Servlet,name=" + getName() +
",WebModule=" + webMod + ",J2EEApplication=" +
ctx.getJ2EEApplication() + ",J2EEServer=" +
ctx.getJ2EEServer();
try {
oname=new ObjectName(onameStr);
controller=oname;
Registry.getRegistry().registerComponent(this, oname, null );
// Send j2ee.object.created notification
if (this.getObjectName() != null) {
Notification notification = new Notification(
"j2ee.object.created",
this.getObjectName(),
sequenceNumber++);
broadcaster.sendNotification(notification);
}
} catch( Exception ex ) {
log.info("Error registering servlet with jmx " + this);
}
if (isJspServlet) {
// Register JSP monitoring mbean
onameStr = domain + ":type=JspMonitor,name=" + getName()
+ ",WebModule=" + webMod
+ ",J2EEApplication=" + ctx.getJ2EEApplication()
+ ",J2EEServer=" + ctx.getJ2EEServer();
try {
jspMonitorON = new ObjectName(onameStr);
Registry.getRegistry(null, null)
.registerComponent(instance, jspMonitorON, null);
} catch( Exception ex ) {
log.info("Error registering JSP monitoring with jmx " +
instance);
}
}
|
| public void | removeInitParameter(java.lang.String name)Remove the specified initialization parameter from this servlet.
synchronized (parameters) {
parameters.remove(name);
}
if (notifyContainerListeners) {
fireContainerEvent("removeInitParameter", name);
}
|
| public void | removeInstanceListener(org.apache.catalina.InstanceListener listener)Remove a listener no longer interested in InstanceEvents.
instanceSupport.removeInstanceListener(listener);
|
| public void | removeMapping(java.lang.String mapping)Remove a mapping associated with the wrapper.
synchronized (mappings) {
mappings.remove(mapping);
}
if (notifyContainerListeners) {
fireContainerEvent("removeMapping", mapping);
}
|
| public void | removeSecurityReference(java.lang.String name)Remove any security role reference for the specified role name.
synchronized (references) {
references.remove(name);
}
if (notifyContainerListeners) {
fireContainerEvent("removeSecurityReference", name);
}
|
| public void | setAvailable(long available)Set the available date/time for this servlet, in milliseconds since the
epoch. If this date/time is Long.MAX_VALUE, it is considered to mean
that unavailability is permanent and any request for this servlet will return
an SC_NOT_FOUND error. If this date/time is in the future, any request for
this servlet will return an SC_SERVICE_UNAVAILABLE error.
long oldAvailable = this.available;
if (available > System.currentTimeMillis())
this.available = available;
else
this.available = 0L;
support.firePropertyChange("available", Long.valueOf(oldAvailable),
Long.valueOf(this.available));
|
| public void | setDebug(int debug)Set the debugging detail level for this component.
int oldDebug = this.debug;
this.debug = debug;
support.firePropertyChange("debug", Integer.valueOf(oldDebug),
Long.valueOf(this.debug));
|
| public void | setErrorCount(int errorCount)
swValve.setErrorCount(errorCount);
|
| public void | setJspFile(java.lang.String jspFile)Set the context-relative URI of the JSP file for this servlet.
String oldJspFile = this.jspFile;
this.jspFile = jspFile;
support.firePropertyChange("jspFile", oldJspFile, this.jspFile);
// Each jsp-file needs to be represented by its own JspServlet and
// corresponding JspMonitoring mbean, because it may be initialized
// with its own init params
isJspServlet = true;
|
| public void | setLoadOnStartup(int value)Set the load-on-startup order value (negative value means
load on first call).
int oldLoadOnStartup = this.loadOnStartup;
this.loadOnStartup = value;
support.firePropertyChange("loadOnStartup",
Integer.valueOf(oldLoadOnStartup),
Integer.valueOf(this.loadOnStartup));
|
| public void | setLoadOnStartupString(java.lang.String value)Set the load-on-startup order value from a (possibly null) string.
Per the specification, any missing or non-numeric value is converted
to a zero, so that this servlet will still be loaded at startup
time, but in an arbitrary order.
try {
setLoadOnStartup(Integer.parseInt(value));
} catch (NumberFormatException e) {
setLoadOnStartup(0);
}
|
| public void | setLoadTime(long loadTime)
this.loadTime = loadTime;
|
| public void | setMaxInstances(int maxInstances)Set the maximum number of instances that will be allocated when a single
thread model servlet is used.
int oldMaxInstances = this.maxInstances;
this.maxInstances = maxInstances;
support.firePropertyChange("maxInstances", oldMaxInstances,
this.maxInstances);
|
| public void | setMaxTimeMillis(long maxTimeMillis)
swValve.setMaxTimeMillis(maxTimeMillis);
|
| public void | setMinTimeMillis(long minTimeMillis)
swValve.setMinTimeMillis(minTimeMillis);
|
| public void | setParent(org.apache.catalina.Container container)Set the parent Container of this Wrapper, but only if it is a Context.
if ((container != null) &&
!(container instanceof Context))
throw new IllegalArgumentException
(sm.getString("standardWrapper.notContext"));
if (container instanceof StandardContext) {
swallowOutput = ((StandardContext)container).getSwallowOutput();
notifyContainerListeners =
((StandardContext)container).isNotifyContainerListeners();
}
super.setParent(container);
|
| public void | setProcessingTimeMillis(long processingTimeMillis)
swValve.setProcessingTimeMillis(processingTimeMillis);
|
| public void | setRequestCount(int requestCount)
swValve.setRequestCount(requestCount);
|
| public void | setRunAs(java.lang.String runAs)Set the run-as identity for this servlet.
String oldRunAs = this.runAs;
this.runAs = runAs;
support.firePropertyChange("runAs", oldRunAs, this.runAs);
|
| public void | setServletClass(java.lang.String servletClass)Set the fully qualified servlet class name for this servlet.
String oldServletClass = this.servletClass;
this.servletClass = servletClass;
support.firePropertyChange("servletClass", oldServletClass,
this.servletClass);
if (Constants.JSP_SERVLET_CLASS.equals(servletClass)) {
isJspServlet = true;
}
|
| public void | setServletName(java.lang.String name)Set the name of this servlet. This is an alias for the normal
Container.setName() method, and complements the
getServletName() method required by the
ServletConfig interface.
setName(name);
|
| public void | start()Start this component, pre-loading the servlet if the load-on-startup
value is set appropriately.
// Send j2ee.state.starting notification
if (this.getObjectName() != null) {
Notification notification = new Notification("j2ee.state.starting",
this.getObjectName(),
sequenceNumber++);
broadcaster.sendNotification(notification);
}
// Start up this component
super.start();
if( oname != null )
registerJMX((StandardContext)getParent());
// Load and initialize an instance of this servlet if requested
// MOVED TO StandardContext START() METHOD
setAvailable(0L);
// Send j2ee.state.running notification
if (this.getObjectName() != null) {
Notification notification =
new Notification("j2ee.state.running", this.getObjectName(),
sequenceNumber++);
broadcaster.sendNotification(notification);
}
|
| public void | stop()Stop this component, gracefully shutting down the servlet if it has
been initialized.
setAvailable(Long.MAX_VALUE);
// Send j2ee.state.stopping notification
if (this.getObjectName() != null) {
Notification notification =
new Notification("j2ee.state.stopping", this.getObjectName(),
sequenceNumber++);
broadcaster.sendNotification(notification);
}
// Shut down our servlet instance (if it has been initialized)
try {
unload();
} catch (ServletException e) {
getServletContext().log(sm.getString
("standardWrapper.unloadException", getName()), e);
}
// Shut down this component
super.stop();
// Send j2ee.state.stoppped notification
if (this.getObjectName() != null) {
Notification notification =
new Notification("j2ee.state.stopped", this.getObjectName(),
sequenceNumber++);
broadcaster.sendNotification(notification);
}
if( oname != null ) {
Registry.getRegistry().unregisterComponent(oname);
// Send j2ee.object.deleted notification
Notification notification =
new Notification("j2ee.object.deleted", this.getObjectName(),
sequenceNumber++);
broadcaster.sendNotification(notification);
}
if (isJspServlet && jspMonitorON != null ) {
Registry.getRegistry(null, null).unregisterComponent(jspMonitorON);
}
|
| public java.lang.String | toString()Return a String representation of this component.
StringBuffer sb = new StringBuffer();
if (getParent() != null) {
sb.append(getParent().toString());
sb.append(".");
}
sb.append("StandardWrapper[");
sb.append(getName());
sb.append("]");
return (sb.toString());
|
| public void | unavailable(javax.servlet.UnavailableException unavailable)Process an UnavailableException, marking this servlet as unavailable
for the specified amount of time.
getServletContext().log(sm.getString("standardWrapper.unavailable", getName()));
if (unavailable == null)
setAvailable(Long.MAX_VALUE);
else if (unavailable.isPermanent())
setAvailable(Long.MAX_VALUE);
else {
int unavailableSeconds = unavailable.getUnavailableSeconds();
if (unavailableSeconds <= 0)
unavailableSeconds = 60; // Arbitrary default
setAvailable(System.currentTimeMillis() +
(unavailableSeconds * 1000L));
}
|
| public synchronized void | unload()Unload all initialized instances of this servlet, after calling the
destroy() method for each instance. This can be used,
for example, prior to shutting down the entire servlet engine, or
prior to reloading all of the classes from the Loader associated with
our Loader's repository.
// Nothing to do if we have never loaded the instance
if (!singleThreadModel && (instance == null))
return;
unloading = true;
// Loaf a while if the current instance is allocated
// (possibly more than once if non-STM)
if (countAllocated > 0) {
int nRetries = 0;
while ((nRetries < 21) && (countAllocated > 0)) {
if ((nRetries % 10) == 0) {
log.debug(sm.getString("standardWrapper.waiting",
Integer.valueOf(countAllocated),
instance.getClass().getName()));
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
;
}
nRetries++;
}
}
ClassLoader oldCtxClassLoader =
Thread.currentThread().getContextClassLoader();
ClassLoader classLoader = instance.getClass().getClassLoader();
PrintStream out = System.out;
if (swallowOutput) {
SystemLogHandler.startCapture();
}
// Call the servlet destroy() method
try {
instanceSupport.fireInstanceEvent
(InstanceEvent.BEFORE_DESTROY_EVENT, instance);
Thread.currentThread().setContextClassLoader(classLoader);
// START SJS WS 7.0 6236329
//if( System.getSecurityManager() != null) {
if ( SecurityUtil.executeUnderSubjectDoAs() ){
// END OF SJS WS 7.0 6236329
SecurityUtil.doAsPrivilege("destroy",
instance);
SecurityUtil.remove(instance);
} else {
instance.destroy();
}
instanceSupport.fireInstanceEvent
(InstanceEvent.AFTER_DESTROY_EVENT, instance);
} catch (Throwable t) {
instanceSupport.fireInstanceEvent
(InstanceEvent.AFTER_DESTROY_EVENT, instance, t);
instance = null;
instancePool = null;
nInstances = 0;
if (notifyContainerListeners) {
fireContainerEvent("unload", this);
}
unloading = false;
throw new ServletException
(sm.getString("standardWrapper.destroyException", getName()),
t);
} finally {
// restore the context ClassLoader
Thread.currentThread().setContextClassLoader(oldCtxClassLoader);
// Write captured output
if (swallowOutput) {
String log = SystemLogHandler.stopCapture();
if (log != null && log.length() > 0) {
if (getServletContext() != null) {
getServletContext().log(log);
} else {
out.println(log);
}
}
}
}
// Deregister the destroyed instance
instance = null;
if (singleThreadModel && (instancePool != null)) {
try {
Thread.currentThread().setContextClassLoader(classLoader);
while (!instancePool.isEmpty()) {
// START SJS WS 7.0 6236329
//if( System.getSecurityManager() != null) {
if ( SecurityUtil.executeUnderSubjectDoAs() ){
// END OF SJS WS 7.0 6236329
SecurityUtil.doAsPrivilege("destroy",
((Servlet) instancePool.pop()));
SecurityUtil.remove(instance);
} else {
((Servlet) instancePool.pop()).destroy();
}
}
} catch (Throwable t) {
instancePool = null;
nInstances = 0;
unloading = false;
if (notifyContainerListeners) {
fireContainerEvent("unload", this);
}
throw new ServletException
(sm.getString("standardWrapper.destroyException",
getName()), t);
} finally {
// restore the context ClassLoader
Thread.currentThread().setContextClassLoader
(oldCtxClassLoader);
}
instancePool = null;
nInstances = 0;
}
singleThreadModel = false;
unloading = false;
if (notifyContainerListeners) {
fireContainerEvent("unload", this);
}
|
