| Methods Summary |
|---|
| public void | addChild(org.apache.catalina.Container child)Add a new child Container to those associated with this Container,
if supported. Prior to adding this Container to the set of children,
the child's setParent() method must be called, with this
Container as an argument. This method may thrown an
IllegalArgumentException if this Container chooses not
to be attached to the specified Container, in which case it is not added
if (Globals.IS_SECURITY_ENABLED) {
PrivilegedAction dp =
new PrivilegedAddChild(child);
AccessController.doPrivileged(dp);
} else {
addChildInternal(child);
}
|
| private void | addChildInternal(org.apache.catalina.Container child)
if( log.isDebugEnabled() )
log.debug("Add child " + child + " " + this);
synchronized(children) {
if (children.get(child.getName()) != null)
throw new IllegalArgumentException("addChild: Child name '" +
child.getName() +
"' is not unique");
child.setParent(this); // May throw IAE
children.put(child.getName(), child);
// Start child
if (started && startChildren && (child instanceof Lifecycle)) {
boolean success = false;
try {
((Lifecycle) child).start();
success = true;
} catch (LifecycleException e) {
log.error("ContainerBase.addChild: start: ", e);
throw new IllegalStateException
("ContainerBase.addChild: start: " + e);
} finally {
if (!success) {
children.remove(child.getName());
}
}
}
fireContainerEvent(ADD_CHILD_EVENT, child);
}
|
| public void | addContainerListener(org.apache.catalina.ContainerListener listener)Add a container event listener to this component.
synchronized (listeners) {
listeners.add(listener);
}
|
| public void | addLifecycleListener(org.apache.catalina.LifecycleListener listener)Add a lifecycle event listener to this component.
lifecycle.addLifecycleListener(listener);
|
| public void | addPropertyChangeListener(java.beans.PropertyChangeListener listener)Add a property change listener to this component.
support.addPropertyChangeListener(listener);
|
| public synchronized void | addValve(org.apache.catalina.Valve valve)Add a new Valve to the end of the pipeline associated with this
Container. Prior to adding the Valve, the Valve's
setContainer method must be called, with this Container
as an argument. The method may throw an
IllegalArgumentException if this Valve chooses not to
be associated with this Container, or IllegalStateException
if it is already associated with a different Container.
pipeline.addValve(valve);
fireContainerEvent(ADD_VALVE_EVENT, valve);
|
| public void | backgroundProcess()Execute a periodic task, such as reloading, etc. This method will be
invoked inside the classloading context of this container. Unexpected
throwables will be caught and logged.
if (!started)
return;
if (cluster != null) {
try {
cluster.backgroundProcess();
} catch (Exception e) {
log.warn(sm.getString("containerBase.backgroundProcess.cluster", cluster), e);
}
}
if (loader != null) {
try {
loader.backgroundProcess();
} catch (Exception e) {
log.warn(sm.getString("containerBase.backgroundProcess.loader", loader), e);
}
}
if (manager != null) {
try {
manager.backgroundProcess();
} catch (Exception e) {
log.warn(sm.getString("containerBase.backgroundProcess.manager", manager), e);
}
}
if (realm != null) {
try {
realm.backgroundProcess();
} catch (Exception e) {
log.warn(sm.getString("containerBase.backgroundProcess.realm", realm), e);
}
}
Valve current = pipeline.getFirst();
while (current != null) {
try {
current.backgroundProcess();
} catch (Exception e) {
log.warn(sm.getString("containerBase.backgroundProcess.valve", current), e);
}
current = current.getNext();
}
lifecycle.fireLifecycleEvent(Lifecycle.PERIODIC_EVENT, null);
|
| public javax.management.ObjectName | createObjectName(java.lang.String domain, javax.management.ObjectName parent)
if( log.isDebugEnabled())
log.debug("Create ObjectName " + domain + " " + parent );
return null;
|
| public void | destroy()
if( started ) {
stop();
}
initialized=false;
// unregister this component
if ( oname != null ) {
try {
if( controller == oname ) {
Registry.getRegistry(null, null)
.unregisterComponent(oname);
if(log.isDebugEnabled())
log.debug("unregistering " + oname);
}
} catch( Throwable t ) {
log.error("Error unregistering ", t );
}
}
if (parent != null) {
parent.removeChild(this);
}
// Stop our child containers, if any
Container children[] = findChildren();
for (int i = 0; i < children.length; i++) {
removeChild(children[i]);
}
|
| public org.apache.catalina.Container | findChild(java.lang.String name)Return the child Container, associated with this Container, with
the specified name (if any); otherwise, return null
if (name == null)
return (null);
synchronized (children) { // Required by post-start changes
return ((Container) children.get(name));
}
|
| public org.apache.catalina.Container[] | findChildren()Return the set of children Containers associated with this Container.
If this Container has no children, a zero-length array is returned.
synchronized (children) {
Container results[] = new Container[children.size()];
return ((Container[]) children.values().toArray(results));
}
|
| public org.apache.catalina.ContainerListener[] | findContainerListeners()Return the set of container listeners associated with this Container.
If this Container has no registered container listeners, a zero-length
array is returned.
synchronized (listeners) {
ContainerListener[] results =
new ContainerListener[listeners.size()];
return ((ContainerListener[]) listeners.toArray(results));
}
|
| public org.apache.catalina.LifecycleListener[] | findLifecycleListeners()Get the lifecycle listeners associated with this lifecycle. If this
Lifecycle has no listeners registered, a zero-length array is returned.
return lifecycle.findLifecycleListeners();
|
| public void | fireContainerEvent(java.lang.String type, java.lang.Object data)Notify all container event listeners that a particular event has
occurred for this Container. The default implementation performs
this notification synchronously using the calling thread.
if (listeners.size() < 1)
return;
ContainerEvent event = new ContainerEvent(this, type, data);
ContainerListener list[] = new ContainerListener[0];
synchronized (listeners) {
list = (ContainerListener[]) listeners.toArray(list);
}
for (int i = 0; i < list.length; i++)
((ContainerListener) list[i]).containerEvent(event);
|
| public int | getBackgroundProcessorDelay()Get the delay between the invocation of the backgroundProcess method on
this container and its children. Child containers will not be invoked
if their delay value is not negative (which would mean they are using
their own thread). Setting this to a positive value will cause
a thread to be spawn. After waiting the specified amount of time,
the thread will invoke the executePeriodic method on this container
and all its children.
// ------------------------------------------------------------- Properties
return backgroundProcessorDelay;
|
| public org.apache.catalina.Valve | getBasic()Return the Valve instance that has been distinguished as the basic
Valve for this Pipeline (if any).
return (pipeline.getBasic());
|
| public javax.management.ObjectName[] | getChildren()
ObjectName result[]=new ObjectName[children.size()];
Iterator it=children.values().iterator();
int i=0;
while( it.hasNext() ) {
Object next=it.next();
if( next instanceof ContainerBase ) {
result[i++]=((ContainerBase)next).getJmxName();
}
}
return result;
|
| public org.apache.catalina.Cluster | getCluster()Return the Cluster with which this Container is associated. If there is
no associated Cluster, return the Cluster associated with our parent
Container (if any); otherwise return null.
if (cluster != null)
return (cluster);
if (parent != null)
return (parent.getCluster());
return (null);
|
| public java.lang.String | getContainerSuffix()
Container container=this;
Container context=null;
Container host=null;
Container servlet=null;
StringBuffer suffix=new StringBuffer();
if( container instanceof StandardHost ) {
host=container;
} else if( container instanceof StandardContext ) {
host=container.getParent();
context=container;
} else if( container instanceof StandardWrapper ) {
context=container.getParent();
host=context.getParent();
servlet=container;
}
if( context!=null ) {
String path=((StandardContext)context).getPath();
suffix.append(",path=").append((path.equals("")) ? "/" : path);
}
if( host!=null ) suffix.append(",host=").append( host.getName() );
if( servlet != null ) {
String name=container.getName();
suffix.append(",servlet=");
suffix.append((name=="") ? "/" : name);
}
return suffix.toString();
|
| public java.lang.String | getDomain()
if( domain==null ) {
Container parent=this;
while( parent != null &&
!( parent instanceof StandardEngine) ) {
parent=parent.getParent();
}
if( parent instanceof StandardEngine ) {
domain=((StandardEngine)parent).getDomain();
}
}
return domain;
|
| public org.apache.catalina.Valve | getFirst()Return the first valve in the pipeline.
return (pipeline.getFirst());
|
| public java.lang.String | getInfo()Return descriptive information about this Container implementation and
the corresponding version number, in the format
<description>/<version>.
return this.getClass().getName();
|
| protected java.lang.String | getJSR77Suffix()
return suffix;
|
| public javax.management.ObjectName | getJmxName()
return oname;
|
| public org.apache.catalina.Loader | getLoader()Return the Loader with which this Container is associated. If there is
no associated Loader, return the Loader associated with our parent
Container (if any); otherwise, return null.
if (loader != null)
return (loader);
if (parent != null)
return (parent.getLoader());
return (null);
|
| public org.apache.juli.logging.Log | getLogger()Return the Logger with which this Container is associated. If there is
no associated Logger, return the Logger associated with our parent
Container (if any); otherwise return null.
if (logger != null)
return (logger);
logger = LogFactory.getLog(logName());
return (logger);
|
| public org.apache.catalina.Manager | getManager()Return the Manager with which this Container is associated. If there is
no associated Manager, return the Manager associated with our parent
Container (if any); otherwise return null.
if (manager != null)
return (manager);
if (parent != null)
return (parent.getManager());
return (null);
|
| public java.lang.Object | getMappingObject()Return an object which may be utilized for mapping to this component.
return this;
|
| public java.lang.String | getName()Return a name string (suitable for use by humans) that describes this
Container. Within the set of child containers belonging to a particular
parent, Container names must be unique.
return (name);
|
| public java.lang.String | getObjectName()
if (oname != null) {
return oname.toString();
} else return null;
|
| public org.apache.catalina.Container | getParent()Return the Container for which this Container is a child, if there is
one. If there is no defined parent, return null.
return (parent);
|
| public java.lang.ClassLoader | getParentClassLoader()Return the parent class loader (if any) for this web application.
This call is meaningful only after a Loader has
been configured.
if (parentClassLoader != null)
return (parentClassLoader);
if (parent != null) {
return (parent.getParentClassLoader());
}
return (ClassLoader.getSystemClassLoader());
|
| public javax.management.ObjectName | getParentName()
return null;
|
| public org.apache.catalina.Pipeline | getPipeline()Return the Pipeline object that manages the Valves associated with
this Container.
return (this.pipeline);
|
| public org.apache.catalina.Realm | getRealm()Return the Realm with which this Container is associated. If there is
no associated Realm, return the Realm associated with our parent
Container (if any); otherwise return null.
if (realm != null)
return (realm);
if (parent != null)
return (parent.getRealm());
return (null);
|
| public javax.naming.directory.DirContext | getResources()Return the resources DirContext object with which this Container is
associated. If there is no associated resources object, return the
resources associated with our parent Container (if any); otherwise
return null.
if (resources != null)
return (resources);
if (parent != null)
return (parent.getResources());
return (null);
|
| public boolean | getStartChildren()Return if children of this container will be started automatically when
they are added to this container.
return (startChildren);
|
| public java.lang.String | getType()
return type;
|
| public javax.management.ObjectName[] | getValveObjectNames()
return ((StandardPipeline)pipeline).getValveObjectNames();
|
| public org.apache.catalina.Valve[] | getValves()Return the set of Valves in the pipeline associated with this
Container, including the basic Valve (if any). If there are no
such Valves, a zero-length array is returned.
return (pipeline.getValves());
|
| public void | init()Init method, part of the MBean lifecycle.
If the container was added via JMX, it'll register itself with the
parent, using the ObjectName conventions to locate the parent.
If the container was added directly and it doesn't have an ObjectName,
it'll create a name and register itself with the JMX console. On destroy(),
the object will unregister.
if( this.getParent() == null ) {
// "Life" update
ObjectName parentName=getParentName();
//log.info("Register " + parentName );
if( parentName != null &&
mserver.isRegistered(parentName))
{
mserver.invoke(parentName, "addChild", new Object[] { this },
new String[] {"org.apache.catalina.Container"});
}
}
initialized=true;
|
| public void | invoke(org.apache.catalina.connector.Request request, org.apache.catalina.connector.Response response)Process the specified Request, to produce the corresponding Response,
by invoking the first Valve in our pipeline (if any), or the basic
Valve otherwise.
pipeline.getFirst().invoke(request, response);
|
| protected java.lang.String | logName()Return the abbreviated name of this container for logging messsages
if (logName != null) {
return logName;
}
String loggerName = null;
Container current = this;
while (current != null) {
String name = current.getName();
if ((name == null) || (name.equals(""))) {
name = "/";
}
loggerName = "[" + name + "]"
+ ((loggerName != null) ? ("." + loggerName) : "");
current = current.getParent();
}
logName = ContainerBase.class.getName() + "." + loggerName;
return logName;
|
| public void | postDeregister()
|
| public void | postRegister(java.lang.Boolean registrationDone)
|
| public void | preDeregister()
|
| public javax.management.ObjectName | preRegister(javax.management.MBeanServer server, javax.management.ObjectName name)
oname=name;
mserver=server;
if (name == null ){
return null;
}
domain=name.getDomain();
type=name.getKeyProperty("type");
if( type==null ) {
type=name.getKeyProperty("j2eeType");
}
String j2eeApp=name.getKeyProperty("J2EEApplication");
String j2eeServer=name.getKeyProperty("J2EEServer");
if( j2eeApp==null ) {
j2eeApp="none";
}
if( j2eeServer==null ) {
j2eeServer="none";
}
suffix=",J2EEApplication=" + j2eeApp + ",J2EEServer=" + j2eeServer;
return name;
|
| public void | removeChild(org.apache.catalina.Container child)Remove an existing child Container from association with this parent
Container.
synchronized(children) {
if (children.get(child.getName()) == null)
return;
children.remove(child.getName());
}
if (started && (child instanceof Lifecycle)) {
try {
if( child instanceof ContainerBase ) {
if( ((ContainerBase)child).started ) {
((Lifecycle) child).stop();
}
} else {
((Lifecycle) child).stop();
}
} catch (LifecycleException e) {
log.error("ContainerBase.removeChild: stop: ", e);
}
}
fireContainerEvent(REMOVE_CHILD_EVENT, child);
// child.setParent(null);
|
| public void | removeContainerListener(org.apache.catalina.ContainerListener listener)Remove a container event listener from this component.
synchronized (listeners) {
listeners.remove(listener);
}
|
| public void | removeLifecycleListener(org.apache.catalina.LifecycleListener listener)Remove a lifecycle event listener from this component.
lifecycle.removeLifecycleListener(listener);
|
| public void | removePropertyChangeListener(java.beans.PropertyChangeListener listener)Remove a property change listener from this component.
support.removePropertyChangeListener(listener);
|
| public synchronized void | removeValve(org.apache.catalina.Valve valve)Remove the specified Valve from the pipeline associated with this
Container, if it is found; otherwise, do nothing.
pipeline.removeValve(valve);
fireContainerEvent(REMOVE_VALVE_EVENT, valve);
|
| public void | setBackgroundProcessorDelay(int delay)Set the delay between the invocation of the execute method on this
container and its children.
backgroundProcessorDelay = delay;
|
| public void | setBasic(org.apache.catalina.Valve valve)Set the Valve instance that has been distinguished as the basic
Valve for this Pipeline (if any). Prioer to setting the basic Valve,
the Valve's setContainer() will be called, if it
implements Contained, with the owning Container as an
argument. The method may throw an IllegalArgumentException
if this Valve chooses not to be associated with this Container, or
IllegalStateException if it is already associated with
a different Container.
pipeline.setBasic(valve);
|
| public synchronized void | setCluster(org.apache.catalina.Cluster cluster)Set the Cluster with which this Container is associated.
// Change components if necessary
Cluster oldCluster = this.cluster;
if (oldCluster == cluster)
return;
this.cluster = cluster;
// Stop the old component if necessary
if (started && (oldCluster != null) &&
(oldCluster instanceof Lifecycle)) {
try {
((Lifecycle) oldCluster).stop();
} catch (LifecycleException e) {
log.error("ContainerBase.setCluster: stop: ", e);
}
}
// Start the new component if necessary
if (cluster != null)
cluster.setContainer(this);
if (started && (cluster != null) &&
(cluster instanceof Lifecycle)) {
try {
((Lifecycle) cluster).start();
} catch (LifecycleException e) {
log.error("ContainerBase.setCluster: start: ", e);
}
}
// Report this property change to interested listeners
support.firePropertyChange("cluster", oldCluster, this.cluster);
|
| public void | setDomain(java.lang.String domain)
this.domain=domain;
|
| public synchronized void | setLoader(org.apache.catalina.Loader loader)Set the Loader with which this Container is associated.
// Change components if necessary
Loader oldLoader = this.loader;
if (oldLoader == loader)
return;
this.loader = loader;
// Stop the old component if necessary
if (started && (oldLoader != null) &&
(oldLoader instanceof Lifecycle)) {
try {
((Lifecycle) oldLoader).stop();
} catch (LifecycleException e) {
log.error("ContainerBase.setLoader: stop: ", e);
}
}
// Start the new component if necessary
if (loader != null)
loader.setContainer(this);
if (started && (loader != null) &&
(loader instanceof Lifecycle)) {
try {
((Lifecycle) loader).start();
} catch (LifecycleException e) {
log.error("ContainerBase.setLoader: start: ", e);
}
}
// Report this property change to interested listeners
support.firePropertyChange("loader", oldLoader, this.loader);
|
| public synchronized void | setManager(org.apache.catalina.Manager manager)Set the Manager with which this Container is associated.
// Change components if necessary
Manager oldManager = this.manager;
if (oldManager == manager)
return;
this.manager = manager;
// Stop the old component if necessary
if (started && (oldManager != null) &&
(oldManager instanceof Lifecycle)) {
try {
((Lifecycle) oldManager).stop();
} catch (LifecycleException e) {
log.error("ContainerBase.setManager: stop: ", e);
}
}
// Start the new component if necessary
if (manager != null)
manager.setContainer(this);
if (started && (manager != null) &&
(manager instanceof Lifecycle)) {
try {
((Lifecycle) manager).start();
} catch (LifecycleException e) {
log.error("ContainerBase.setManager: start: ", e);
}
}
// Report this property change to interested listeners
support.firePropertyChange("manager", oldManager, this.manager);
|
| public void | setName(java.lang.String name)Set a name string (suitable for use by humans) that describes this
Container. Within the set of child containers belonging to a particular
parent, Container names must be unique.
String oldName = this.name;
this.name = name;
support.firePropertyChange("name", oldName, this.name);
|
| public void | setParent(org.apache.catalina.Container container)Set the parent Container to which this Container is being added as a
child. This Container may refuse to become attached to the specified
Container by throwing an exception.
Container oldParent = this.parent;
this.parent = container;
support.firePropertyChange("parent", oldParent, this.parent);
|
| public void | setParentClassLoader(java.lang.ClassLoader parent)Set the parent class loader (if any) for this web application.
This call is meaningful only before a Loader has
been configured, and the specified value (if non-null) should be
passed as an argument to the class loader constructor.
ClassLoader oldParentClassLoader = this.parentClassLoader;
this.parentClassLoader = parent;
support.firePropertyChange("parentClassLoader", oldParentClassLoader,
this.parentClassLoader);
|
| public synchronized void | setRealm(org.apache.catalina.Realm realm)Set the Realm with which this Container is associated.
// Change components if necessary
Realm oldRealm = this.realm;
if (oldRealm == realm)
return;
this.realm = realm;
// Stop the old component if necessary
if (started && (oldRealm != null) &&
(oldRealm instanceof Lifecycle)) {
try {
((Lifecycle) oldRealm).stop();
} catch (LifecycleException e) {
log.error("ContainerBase.setRealm: stop: ", e);
}
}
// Start the new component if necessary
if (realm != null)
realm.setContainer(this);
if (started && (realm != null) &&
(realm instanceof Lifecycle)) {
try {
((Lifecycle) realm).start();
} catch (LifecycleException e) {
log.error("ContainerBase.setRealm: start: ", e);
}
}
// Report this property change to interested listeners
support.firePropertyChange("realm", oldRealm, this.realm);
|
| public synchronized void | setResources(javax.naming.directory.DirContext resources)Set the resources DirContext object with which this Container is
associated.
// Called from StandardContext.setResources()
// <- StandardContext.start()
// <- ContainerBase.addChildInternal()
// Change components if necessary
DirContext oldResources = this.resources;
if (oldResources == resources)
return;
Hashtable env = new Hashtable();
if (getParent() != null)
env.put(ProxyDirContext.HOST, getParent().getName());
env.put(ProxyDirContext.CONTEXT, getName());
this.resources = new ProxyDirContext(env, resources);
// Report this property change to interested listeners
support.firePropertyChange("resources", oldResources, this.resources);
|
| public void | setStartChildren(boolean startChildren)Set if children of this container will be started automatically when
they are added to this container.
boolean oldStartChildren = this.startChildren;
this.startChildren = startChildren;
support.firePropertyChange("startChildren", oldStartChildren, this.startChildren);
|
| public synchronized void | start()Prepare for active use of the public methods of this Component.
// Validate and update our current component state
if (started) {
if(log.isInfoEnabled())
log.info(sm.getString("containerBase.alreadyStarted", logName()));
return;
}
// Notify our interested LifecycleListeners
lifecycle.fireLifecycleEvent(BEFORE_START_EVENT, null);
started = true;
// Start our subordinate components, if any
if ((loader != null) && (loader instanceof Lifecycle))
((Lifecycle) loader).start();
logger = null;
getLogger();
if ((logger != null) && (logger instanceof Lifecycle))
((Lifecycle) logger).start();
if ((manager != null) && (manager instanceof Lifecycle))
((Lifecycle) manager).start();
if ((cluster != null) && (cluster instanceof Lifecycle))
((Lifecycle) cluster).start();
if ((realm != null) && (realm instanceof Lifecycle))
((Lifecycle) realm).start();
if ((resources != null) && (resources instanceof Lifecycle))
((Lifecycle) resources).start();
// Start our child containers, if any
Container children[] = findChildren();
for (int i = 0; i < children.length; i++) {
if (children[i] instanceof Lifecycle)
((Lifecycle) children[i]).start();
}
// Start the Valves in our pipeline (including the basic), if any
if (pipeline instanceof Lifecycle)
((Lifecycle) pipeline).start();
// Notify our interested LifecycleListeners
lifecycle.fireLifecycleEvent(START_EVENT, null);
// Start our thread
threadStart();
// Notify our interested LifecycleListeners
lifecycle.fireLifecycleEvent(AFTER_START_EVENT, null);
|
| public synchronized void | stop()Gracefully shut down active use of the public methods of this Component.
// Validate and update our current component state
if (!started) {
if(log.isInfoEnabled())
log.info(sm.getString("containerBase.notStarted", logName()));
return;
}
// Notify our interested LifecycleListeners
lifecycle.fireLifecycleEvent(BEFORE_STOP_EVENT, null);
// Stop our thread
threadStop();
// Notify our interested LifecycleListeners
lifecycle.fireLifecycleEvent(STOP_EVENT, null);
started = false;
// Stop the Valves in our pipeline (including the basic), if any
if (pipeline instanceof Lifecycle) {
((Lifecycle) pipeline).stop();
}
// Stop our child containers, if any
Container children[] = findChildren();
for (int i = 0; i < children.length; i++) {
if (children[i] instanceof Lifecycle)
((Lifecycle) children[i]).stop();
}
// Remove children - so next start can work
children = findChildren();
for (int i = 0; i < children.length; i++) {
removeChild(children[i]);
}
// Stop our subordinate components, if any
if ((resources != null) && (resources instanceof Lifecycle)) {
((Lifecycle) resources).stop();
}
if ((realm != null) && (realm instanceof Lifecycle)) {
((Lifecycle) realm).stop();
}
if ((cluster != null) && (cluster instanceof Lifecycle)) {
((Lifecycle) cluster).stop();
}
if ((manager != null) && (manager instanceof Lifecycle)) {
((Lifecycle) manager).stop();
}
if ((logger != null) && (logger instanceof Lifecycle)) {
((Lifecycle) logger).stop();
}
if ((loader != null) && (loader instanceof Lifecycle)) {
((Lifecycle) loader).stop();
}
// Notify our interested LifecycleListeners
lifecycle.fireLifecycleEvent(AFTER_STOP_EVENT, null);
|
| protected void | threadStart()Start the background thread that will periodically check for
session timeouts.
if (thread != null)
return;
if (backgroundProcessorDelay <= 0)
return;
threadDone = false;
String threadName = "ContainerBackgroundProcessor[" + toString() + "]";
thread = new Thread(new ContainerBackgroundProcessor(), threadName);
thread.setDaemon(true);
thread.start();
|
| protected void | threadStop()Stop the background thread that is periodically checking for
session timeouts.
if (thread == null)
return;
threadDone = true;
thread.interrupt();
try {
thread.join();
} catch (InterruptedException e) {
;
}
thread = null;
|
