FileDocCategorySizeDatePackage
ContainerBase.javaAPI DocGlassfish v2 API56172Wed Jul 18 08:31:56 BST 2007org.apache.catalina.core

ContainerBase

public abstract class ContainerBase extends Object implements org.apache.catalina.Container, Serializable, org.apache.catalina.Lifecycle, org.apache.catalina.Pipeline, MBeanRegistration
Abstract implementation of the Container interface, providing common functionality required by nearly every implementation. Classes extending this base class must implement getInfo(), and may implement a replacement for invoke().

All subclasses of this abstract base class will include support for a Pipeline object that defines the processing to be performed for each request received by the invoke() method of this class, utilizing the "Chain of Responsibility" design pattern. A subclass should encapsulate its own processing functionality as a Valve, and configure this Valve into the pipeline by calling setBasic().

This implementation fires property change events, per the JavaBeans design pattern, for changes in singleton properties. In addition, it fires the following ContainerEvent events to listeners who register themselves with addContainerListener():
Type Data Description
addChild Container Child container added to this Container.
addValve Valve Valve added to this Container.
removeChild Container Child container removed from this Container.
removeValve Valve Valve removed from this Container.
start null Container was started.
stop null Container was stopped.
Subclasses that fire additional events should document them in the class comments of the implementation class.

author
Craig R. McClanahan

Fields Summary
private static com.sun.org.apache.commons.logging.Log
log
protected HashMap
children
The child Containers belonging to this Container, keyed by name.
protected int
debug
The debugging detail level for this component.
protected int
backgroundProcessorDelay
The processor delay for this component.
protected boolean
checkIfRequestIsSecure
Flag indicating whether a check to see if the request is secure is required before adding Pragma and Cache-Control headers when proxy caching has been disabled
protected org.apache.catalina.util.LifecycleSupport
lifecycle
The lifecycle event support for this component.
protected ArrayList
listeners
The container event listeners for this Container.
private org.apache.catalina.ContainerListener[]
listenersArray
protected org.apache.catalina.Loader
loader
The Loader implementation with which this Container is associated.
private ReadWriteLock
lock
private Lock
readLock
private Lock
writeLock
protected org.apache.catalina.Logger
logger
The Logger implementation with which this Container is associated.
protected org.apache.catalina.Manager
manager
The Manager implementation with which this Container is associated.
protected org.apache.catalina.Cluster
cluster
The cluster with which this Container is associated.
protected String
name
The human-readable name of this Container.
protected org.apache.catalina.Container
parent
The parent Container to which this Container is a child.
protected ClassLoader
parentClassLoader
The parent class loader to be configured when we install a Loader.
protected org.apache.catalina.Pipeline
pipeline
The Pipeline object with which this Container is associated.
protected org.apache.catalina.Realm
realm
The Realm with which this Container is associated.
protected DirContext
resources
The resources DirContext object with which this Container is associated.
protected static final org.apache.catalina.util.StringManager
sm
The string manager for this package.
protected boolean
started
Has this component been started?
protected boolean
initialized
protected PropertyChangeSupport
support
The property change support for this component.
private Thread
thread
The background thread.
private boolean
threadDone
The background thread completion semaphore.
protected boolean
notifyContainerListeners
Indicates whether ContainerListener instances need to be notified of a particular configuration event.
protected String
type
protected String
domain
protected String
suffix
protected ObjectName
oname
protected ObjectName
controller
protected transient MBeanServer
mserver
Constructors Summary
Methods Summary
public voidaddChild(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

param
child New child Container to be added
exception
IllegalArgumentException if this exception is thrown by the setParent() method of the child Container
exception
IllegalArgumentException if the new child does not have a name unique from that of existing children of this Container
exception
IllegalStateException if this Container does not support child Containers

        if (Globals.IS_SECURITY_ENABLED) {
            PrivilegedAction dp =
                new PrivilegedAddChild(child);
            AccessController.doPrivileged(dp);
        } else {
            addChildInternal(child);
        }
    
private voidaddChildInternal(org.apache.catalina.Container child)


        if( log.isTraceEnabled() )
            log.trace("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
            if (started && (child instanceof Lifecycle)) {
                try {
                    ((Lifecycle) child).start();
                } catch (LifecycleException e) {
                    log.error("ContainerBase.addChild: start: ", e);
                    throw new IllegalStateException
                        ("ContainerBase.addChild: start: " + e);
                }
            }
            children.put(child.getName(), child);

            if (notifyContainerListeners) {
                fireContainerEvent(ADD_CHILD_EVENT, child);
            }
        }

    
public voidaddContainerListener(org.apache.catalina.ContainerListener listener)
Add a container event listener to this component.

param
listener The listener to add


        synchronized (listeners) {
            listeners.add(listener);
            listenersArray = listeners.toArray(
                new ContainerListener[listeners.size()]);
        }

    
public voidaddLifecycleListener(org.apache.catalina.LifecycleListener listener)
Add a lifecycle event listener to this component.

param
listener The listener to add


        lifecycle.addLifecycleListener(listener);
    
public voidaddPropertyChangeListener(java.beans.PropertyChangeListener listener)
Add a property change listener to this component.

param
listener The listener to add


        support.addPropertyChangeListener(listener);

    
public synchronized voidaddValve(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.

param
valve Valve to be added
exception
IllegalArgumentException if this Container refused to accept the specified Valve
exception
IllegalArgumentException if the specifie Valve refuses to be associated with this Container
exception
IllegalStateException if the specified Valve is already associated with a different Container


        pipeline.addValve(valve);

        if (notifyContainerListeners) {
            fireContainerEvent(ADD_VALVE_EVENT, valve);
        }
    
public voidbackgroundProcess()
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.

    
public javax.management.ObjectNamecreateObjectName(java.lang.String domain, javax.management.ObjectName parent)

        if( log.isDebugEnabled())
            log.debug("Create ObjectName " + domain + " " + parent );
        return null;
    
public voiddestroy()

        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]);
        }

        // START SJSAS 6330332
        // Remove LifecycleListeners
        LifecycleListener[] tmpLifecycleListeners = findLifecycleListeners();
        if (tmpLifecycleListeners != null) {
            for (int i=0;i<tmpLifecycleListeners.length;i++) {
                removeLifecycleListener(tmpLifecycleListeners[i]);
            }
        }
 
        // Release realm
        setRealm(null);
        // END SJSAS 6330332                
    
public org.apache.catalina.ContainerfindChild(java.lang.String name)
Return the child Container, associated with this Container, with the specified name (if any); otherwise, return null

param
name Name of the child Container to be retrieved


        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) {
            return listenersArray;
        }
    
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 voidfireContainerEvent(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.

param
type Event type
param
data Event data


        ContainerListener[] list = null;

        synchronized (listeners) {
            if (listeners.isEmpty()) {
                return;
            }
            list = listenersArray;
        }

        ContainerEvent event = new ContainerEvent(this, type, data);
        for (int i = 0; i < list.length; i++) {
            ((ContainerListener) list[i]).containerEvent(event);
        }
    
public intgetBackgroundProcessorDelay()
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.

        return backgroundProcessorDelay;
    
public org.apache.catalina.ValvegetBasic()

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.ClustergetCluster()
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.


        try {
            readLock.lock();
            if (cluster != null)
                return (cluster);
        } finally {
            readLock.unlock();
        }

        if (parent != null)
            return (parent.getCluster());

        return (null);
    
public java.lang.StringgetContainerSuffix()

        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).getEncodedPath();
            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 intgetDebug()
Return the debugging detail level for this component.


        return (this.debug);

    
public java.lang.StringgetDomain()

        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 java.lang.StringgetInfo()
Return descriptive information about this Container implementation and the corresponding version number, in the format <description>/<version>.

        return this.getClass().getName();
    
protected java.lang.StringgetJSR77Suffix()

        return suffix;
    
public javax.management.ObjectNamegetJmxName()

        return oname;
    
public org.apache.catalina.LoadergetLoader()
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.


        try {
            readLock.lock();
            if (loader != null)
                return (loader);
        } finally {
            readLock.unlock();
        }

        if (parent != null)
            return (parent.getLoader());

        return (null);
    
public org.apache.catalina.LoggergetLogger()
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.


        try {
            readLock.lock();
            if (logger != null)
                return (logger);
        } finally {
            readLock.unlock();
        }

        if (parent != null)
            return (parent.getLogger());

        return (null);
    
public org.apache.catalina.ManagergetManager()
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.


        try {
            readLock.lock();
            if (manager != null)
                return (manager);
        } finally {
            readLock.unlock();
        }

        if (parent != null)
            return (parent.getManager());

        return (null);
    
public java.lang.ObjectgetMappingObject()
Return an object which may be utilized for mapping to this component.

        return this;
    
public java.lang.StringgetName()
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.StringgetObjectName()

        if (oname != null) {
            return oname.toString();
        } else return null;
    
public org.apache.catalina.ContainergetParent()
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.ClassLoadergetParentClassLoader()
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.ObjectNamegetParentName()

        return null;
    
public org.apache.catalina.PipelinegetPipeline()
Return the Pipeline object that manages the Valves associated with this Container.


        return (this.pipeline);
    
public org.apache.catalina.RealmgetRealm()
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.

        try {
            readLock.lock();
            if (realm != null)
                return (realm);
        } finally {
            readLock.unlock();
        }

        if (parent != null)
            return (parent.getRealm());

        return (null);
    
public javax.naming.directory.DirContextgetResources()
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.


        try {
            readLock.lock();
            if (resources != null)
                return (resources);
        } finally {
            readLock.unlock();
        }

        if (parent != null)
            return (parent.getResources());

        return (null);
    
public java.lang.StringgetType()

        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 voidinit()
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.

throws
Exception


        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 voidinvoke(org.apache.catalina.Request request, org.apache.catalina.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.

param
request Request to be processed
param
response Response to be produced
exception
IllegalStateException if neither a pipeline or a basic Valve have been configured for this Container
exception
IOException if an input/output error occurred while processing
exception
ServletException if a ServletException was thrown while processing this request


        pipeline.invoke(request, response);
    
public booleanisCheckIfRequestIsSecure()
Indicates whether the request will be checked to see if it is secure before adding Pragma and Cache-control headers when proxy caching has been disabled.

return
true if the check is required; false otherwise.

        return checkIfRequestIsSecure;
    
booleanisNotifyContainerListeners()

return
true if ContainerListener instances need to be notified of a particular configuration event, and false otherwise



    // ------------------------------------------------------------- Properties

                          
      
        return notifyContainerListeners;
    
protected voidlog(java.lang.String message)
Log the specified message to our current Logger (if any).

param
message Message to be logged


//         Logger logger = getLogger();
//         if (logger != null)
//             logger.log(logName() + ": " + message);
//         else
            log.info(message);
    
protected voidlog(java.lang.String message, java.lang.Throwable throwable)
Log the specified message and exception to our current Logger (if any).

param
message Message to be logged
param
throwable Related exception


        Logger logger = getLogger();
        if (logger != null)
            logger.log(logName() + ": " + message, throwable);
        else {
            log.error( message, throwable );
        }

    
protected java.lang.StringlogName()
Return the abbreviated name of this container for logging messsages


        String className = this.getClass().getName();
        int period = className.lastIndexOf(".");
        if (period >= 0)
            className = className.substring(period + 1);
        return (className + "[" + getName() + "]");

    
public voidpostDeregister()

    
public voidpostRegister(java.lang.Boolean registrationDone)

    
public voidpreDeregister()

    
public javax.management.ObjectNamepreRegister(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 voidremoveChild(org.apache.catalina.Container child)
Remove an existing child Container from association with this parent Container.

param
child Existing child Container to be removed


        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);
            }
        }
        
        if (notifyContainerListeners) {
            fireContainerEvent(REMOVE_CHILD_EVENT, child);
        }
    
        // child.setParent(null);
    
public voidremoveContainerListener(org.apache.catalina.ContainerListener listener)
Remove a container event listener from this component.

param
listener The listener to remove


        synchronized (listeners) {
            listeners.remove(listener);
            listenersArray = listeners.toArray(
                new ContainerListener[listeners.size()]);
        }
    
public voidremoveLifecycleListener(org.apache.catalina.LifecycleListener listener)
Remove a lifecycle event listener from this component.

param
listener The listener to remove


        lifecycle.removeLifecycleListener(listener);
    
public voidremovePropertyChangeListener(java.beans.PropertyChangeListener listener)
Remove a property change listener from this component.

param
listener The listener to remove


        support.removePropertyChangeListener(listener);
    
public synchronized voidremoveValve(org.apache.catalina.Valve valve)
Remove the specified Valve from the pipeline associated with this Container, if it is found; otherwise, do nothing.

param
valve Valve to be removed


        pipeline.removeValve(valve);
 
        if (notifyContainerListeners) {
            fireContainerEvent(REMOVE_VALVE_EVENT, valve);
        }
    
public voidsetBackgroundProcessorDelay(int delay)
Set the delay between the invocation of the execute method on this container and its children.

param
delay The delay in seconds between the invocation of backgroundProcess methods

        backgroundProcessorDelay = delay;
    
public voidsetBasic(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.

param
valve Valve to be distinguished as the basic Valve


        pipeline.setBasic(valve);

    
public voidsetCheckIfRequestIsSecure(boolean checkIfRequestIsSecure)
Sets the checkIfRequestIsSecure property of this Container. Setting this property to true will check if the request is secure before adding Pragma and Cache-Control headers when proxy caching has been disabled.

param
checkIfRequestIsSecure true if check is required, false otherwise

        this.checkIfRequestIsSecure = checkIfRequestIsSecure;
    
public voidsetCluster(org.apache.catalina.Cluster cluster)
Set the Cluster with which this Container is associated.

param
cluster The newly associated Cluster


        Cluster oldCluster;

        try {
            writeLock.lock();
            // Change components if necessary
            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);
                }
            }
        } finally {
            writeLock.unlock();
        }

        // Report this property change to interested listeners
        support.firePropertyChange("cluster", oldCluster, this.cluster);
    
public voidsetDebug(int debug)
Set the debugging detail level for this component.

param
debug The new debugging detail level


        int oldDebug = this.debug;
        this.debug = debug;
        support.firePropertyChange("debug", Integer.valueOf(oldDebug),
                                   Integer.valueOf(this.debug));

    
public voidsetDomain(java.lang.String domain)

        this.domain=domain;
    
public voidsetLoader(org.apache.catalina.Loader loader)
Set the Loader with which this Container is associated.

param
loader The newly associated loader


        Loader oldLoader;

        try {
	    writeLock.lock();

            // Change components if necessary
            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);
                }
            }
        } finally {
	    writeLock.unlock();
        }

        // Report this property change to interested listeners
        support.firePropertyChange("loader", oldLoader, this.loader);

    
public voidsetLogger(org.apache.catalina.Logger logger)
Set the Logger with which this Container is associated.

param
logger The newly associated Logger


        Logger oldLogger;

        try {
            writeLock.lock();
            // Change components if necessary
            oldLogger = this.logger;
            if (oldLogger == logger)
                return;
            this.logger = logger;

            // Stop the old component if necessary
            if (started && (oldLogger != null) &&
                    (oldLogger instanceof Lifecycle)) {
                try {
                    ((Lifecycle) oldLogger).stop();
                } catch (LifecycleException e) {
                    log.error("ContainerBase.setLogger: stop: ", e);
                }
            }

        
            // Start the new component if necessary
            if (logger != null)
                logger.setContainer(this);
            if (started && (logger != null) &&
                (logger instanceof Lifecycle)) {
                try {
                    ((Lifecycle) logger).start();
                } catch (LifecycleException e) {
                    log.error("ContainerBase.setLogger: start: ", e);
                }
            }
        } finally {
            writeLock.unlock();
        }

        // Report this property change to interested listeners
        support.firePropertyChange("logger", oldLogger, this.logger);

    
public voidsetManager(org.apache.catalina.Manager manager)
Set the Manager with which this Container is associated.

param
manager The newly associated Manager


        Manager oldManager;

        try {
            writeLock.lock();
            // Change components if necessary
            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);
                }
            }
        } finally {
            writeLock.unlock();
        }

        // Report this property change to interested listeners
        support.firePropertyChange("manager", oldManager, this.manager);
    
public voidsetName(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.

param
name New name of this container
exception
IllegalStateException if this Container has already been added to the children of a parent Container (after which the name may not be changed)


        String oldName = this.name;
        this.name = name;
        support.firePropertyChange("name", oldName, this.name);
    
public voidsetParent(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.

param
container Container to which this Container is being added as a child
exception
IllegalArgumentException if this Container refuses to become attached to the specified Container


        Container oldParent = this.parent;
        this.parent = container;
        support.firePropertyChange("parent", oldParent, this.parent);
    
public voidsetParentClassLoader(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.

param
parent The new parent class loader

        ClassLoader oldParentClassLoader = this.parentClassLoader;
        this.parentClassLoader = parent;
        support.firePropertyChange("parentClassLoader", oldParentClassLoader,
                                   this.parentClassLoader);
    
public voidsetRealm(org.apache.catalina.Realm realm)
Set the Realm with which this Container is associated.

param
realm The newly associated Realm


        Realm oldRealm;

        try {
            writeLock.lock();
            // Change components if necessary
            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);
                }
            }
        } finally {
            writeLock.unlock();
        }

        // Report this property change to interested listeners
        support.firePropertyChange("realm", oldRealm, this.realm);
    
public voidsetResources(javax.naming.directory.DirContext resources)
Set the resources DirContext object with which this Container is associated.

param
resources The newly associated DirContext

        // Called from StandardContext.setResources()
        //              <- StandardContext.start() 
        //              <- ContainerBase.addChildInternal() 

        // Change components if necessary
        DirContext oldResources;

        try {
            writeLock.lock();
            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
        } finally {
            writeLock.unlock();
        }

        support.firePropertyChange("resources", oldResources,
                                   this.resources);
    
public synchronized voidstart()
Prepare for active use of the public methods of this Component.

exception
LifecycleException if this component detects a fatal error that prevents it from being started


        // Validate and update our current component state
        if (started) {
            if (log.isInfoEnabled()) {
                log.info(sm.getString("containerBase.alreadyStarted",
                                      logName()));
            }
            return;
        }
        
        if( logger instanceof LoggerBase ) {
            LoggerBase lb=(LoggerBase)logger;
            if( lb.getObjectName()==null ) {
                ObjectName lname=lb.createObjectName();
                try {
                    Registry.getRegistry().registerComponent(lb, lname,
                                                             null);
                } catch( Exception ex ) {
                    log.error( "Can't register logger " + lname, ex);
                }
            }
        }
        
        // 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();
        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
        startChildren();

        // 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);
    
protected voidstartChildren()
Starts the children of this container.


        Container children[] = findChildren();
        for (int i = 0; i < children.length; i++) {
            if (children[i] instanceof Lifecycle) {
                try {
                    ((Lifecycle) children[i]).start();
                } catch (Throwable t) {
                    log.error(sm.getString("containerBase.notStarted",
                                           children[i]), t);
                    if (children[i] instanceof Context) {
                        ((Context) children[i]).setAvailable(false);
                    } else if (children[i] instanceof Wrapper) {
                        ((Wrapper) children[i]).setAvailable(Long.MAX_VALUE);
                    }
                }
            }
        }
    
public synchronized voidstop()
Gracefully shut down active use of the public methods of this Component.

exception
LifecycleException if this component detects a fatal error that needs to be reported


        // 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) {
                try {
                    ((Lifecycle) children[i]).stop();
                } catch (Throwable t) {
                    log.error(sm.getString("containerBase.errorStopping",
                                           children[i]), t);
                }
            }
        }

        // 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();
        }

        if( logger instanceof LoggerBase ) {
            LoggerBase lb=(LoggerBase)logger;
            if( lb.getObjectName()!=null ) {
                try {
                    Registry.getRegistry().unregisterComponent(lb.getObjectName());
                } catch( Exception ex ) {
                    log.error("Can't unregister logger "
                              + lb.getObjectName(), ex);
                }
            }
        }

        // Notify our interested LifecycleListeners
        lifecycle.fireLifecycleEvent(AFTER_STOP_EVENT, null);
    
protected voidthreadStart()
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 voidthreadStop()
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;