/*

* Licensed to the Apache Software Foundation (ASF) under one or more

* contributor license agreements. See the NOTICE file distributed with

* this work for additional information regarding copyright ownership.

* The ASF licenses this file to You under the Apache License, Version 2.0

* (the "License"); you may not use this file except in compliance with

* the License. You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

package org.apache.catalina;

import java.beans.PropertyChangeListener;

import java.io.File;

import javax.management.ObjectName;

import org.apache.catalina.connector.Request;

import org.apache.catalina.connector.Response;

import org.apache.juli.logging.Log;

/**

* A <b>Container</b> is an object that can execute requests received from

* a client, and return responses based on those requests. A Container may

* optionally support a pipeline of Valves that process the request in an

* order configured at runtime, by implementing the <b>Pipeline</b> interface

* as well.

* <p>

* Containers will exist at several conceptual levels within Catalina. The

* following examples represent common cases:

* <ul>

* <li><b>Engine</b> - Representation of the entire Catalina servlet engine,

* most likely containing one or more subcontainers that are either Host

* or Context implementations, or other custom groups.

* <li><b>Host</b> - Representation of a virtual host containing a number

* of Contexts.

* <li><b>Context</b> - Representation of a single ServletContext, which will

* typically contain one or more Wrappers for the supported servlets.

* <li><b>Wrapper</b> - Representation of an individual servlet definition

* (which may support multiple servlet instances if the servlet itself

* implements SingleThreadModel).

* </ul>

* A given deployment of Catalina need not include Containers at all of the

* levels described above. For example, an administration application

* embedded within a network device (such as a router) might only contain

* a single Context and a few Wrappers, or even a single Wrapper if the

* application is relatively small. Therefore, Container implementations

* need to be designed so that they will operate correctly in the absence

* of parent Containers in a given deployment.

* <p>

* A Container may also be associated with a number of support components

* that provide functionality which might be shared (by attaching it to a

* parent Container) or individually customized. The following support

* components are currently recognized:

* <ul>

* <li><b>Loader</b> - Class loader to use for integrating new Java classes

* for this Container into the JVM in which Catalina is running.

* <li><b>Logger</b> - Implementation of the <code>log()</code> method

* signatures of the <code>ServletContext</code> interface.

* <li><b>Manager</b> - Manager for the pool of Sessions associated with

* this Container.

* <li><b>Realm</b> - Read-only interface to a security domain, for

* authenticating user identities and their corresponding roles.

* <li><b>Resources</b> - JNDI directory context enabling access to static

* resources, enabling custom linkages to existing server components when

* Catalina is embedded in a larger server.

* </ul>

*

* @author Craig R. McClanahan

* @author Remy Maucherat

*/

public interface Container extends Lifecycle {

// ----------------------------------------------------- Manifest Constants

/**

* The ContainerEvent event type sent when a child container is added

* by <code>addChild()</code>.

*/

public static final String ADD_CHILD_EVENT = "addChild";

/**

* The ContainerEvent event type sent when a valve is added

* by <code>addValve()</code>, if this Container supports pipelines.

*/

public static final String ADD_VALVE_EVENT = "addValve";

/**

* The ContainerEvent event type sent when a child container is removed

* by <code>removeChild()</code>.

*/

public static final String REMOVE_CHILD_EVENT = "removeChild";

/**

* The ContainerEvent event type sent when a valve is removed

* by <code>removeValve()</code>, if this Container supports pipelines.

*/

public static final String REMOVE_VALVE_EVENT = "removeValve";

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

/**

* Obtain the log to which events for this container should be logged.

*

* @return The Logger with which this Container is associated. If there is

* no associated Logger, return the Logger associated with the

* parent Container (if any); otherwise return <code>null</code>.

*/

public Log getLogger();

/**

* Obtain the JMX name for this container.

*

* @return the JMX name associated with this container.

*/

public ObjectName getObjectName();

/**

* Obtain the JMX domain under which this container will be / has been

* registered.

*

* @return The JMX domain name

*/

public String getDomain();

/**

* Calculate the key properties string to be added to an object's

* {@link ObjectName} to indicate that it is associated with this container.

*

* @return A string suitable for appending to the ObjectName

*

*/

public String getMBeanKeyProperties();

/**

* Return the Pipeline object that manages the Valves associated with

* this Container.

*

* @return The Pipeline

*/

public Pipeline getPipeline();

/**

* Get the Cluster for this container.

*

* @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 <code>null</code>.

*/

public Cluster getCluster();

/**

* Set the Cluster with which this Container is associated.

*

* @param cluster the Cluster with which this Container is associated.

*/

public void setCluster(Cluster cluster);

/**

* 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 positive (which would mean they are using their own

* thread). Setting this to a positive value will cause a thread to be

* spawned. After waiting the specified amount of time, the thread will

* invoke the {@link #backgroundProcess()} method on this container and all

* children with non-positive delay values.

*

* @return The delay between the invocation of the backgroundProcess method

* on this container and its children. A non-positive value

* indicates that background processing will be managed by the

* parent.

*/

public int getBackgroundProcessorDelay();

/**

* 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

*/

public void setBackgroundProcessorDelay(int delay);

/**

* 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 The human readable name of this container.

*/

public String getName();

/**

* 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)

*/

public void setName(String name);

/**

* Get the parent container.

*

* @return Return the Container for which this Container is a child, if

* there is one. If there is no defined parent, return

* <code>null</code>.

*/

public Container getParent();

/**

* 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

*/

public void setParent(Container container);

/**

* Get the parent class loader.

*

* @return the parent class loader for this component. If not set, return

* {@link #getParent()}.{@link #getParentClassLoader()}. If no

* parent has been set, return the system class loader.

*/

public ClassLoader getParentClassLoader();

/**

* Set the parent class loader for this component. For {@link Context}s

* this call is meaningful only <strong>before</strong> 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

*/

public void setParentClassLoader(ClassLoader parent);

/**

* Obtain the Realm with which this Container is associated.

*

* @return The associated Realm; if there is no associated Realm, the

* Realm associated with the parent Container (if any); otherwise

* return <code>null</code>.

*/

public Realm getRealm();

/**

* Set the Realm with which this Container is associated.

*

* @param realm The newly associated Realm

*/

public void setRealm(Realm realm);

// --------------------------------------------------------- Public Methods

/**

* 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 void backgroundProcess();

/**

* 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 <code>setParent()</code> method must be called, with this

* Container as an argument. This method may thrown an

* <code>IllegalArgumentException</code> 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 <code>setParent()</code> 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

*/

public void addChild(Container child);

/**

* Add a container event listener to this component.

*

* @param listener The listener to add

*/

public void addContainerListener(ContainerListener listener);

/**

* Add a property change listener to this component.

*

* @param listener The listener to add

*/

public void addPropertyChangeListener(PropertyChangeListener listener);

/**

* Obtain a child Container by name.

*

* @param name Name of the child Container to be retrieved

*

* @return The child Container with the given name or <code>null</code> if

* no such child exists.

*/

public Container findChild(String name);

/**

* Obtain the child Containers associated with this Container.

*

* @return An array containing all children of this container. If this

* Container has no children, a zero-length array is returned.

*/

public Container[] findChildren();

/**

* Obtain the container listeners associated with this Container.

*

* @return An array containing the container listeners associated with this

* Container. If this Container has no registered container

* listeners, a zero-length array is returned.

*/

public ContainerListener[] findContainerListeners();

/**

* Remove an existing child Container from association with this parent

* Container.

*

* @param child Existing child Container to be removed

*/

public void removeChild(Container child);

/**

* Remove a container event listener from this component.

*

* @param listener The listener to remove

*/

public void removeContainerListener(ContainerListener listener);

/**

* Remove a property change listener from this component.

*

* @param listener The listener to remove

*/

public void removePropertyChangeListener(PropertyChangeListener listener);

/**

* 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

*/

public void fireContainerEvent(String type, Object data);

/**

* Log a request/response that was destined for this container but has been

* handled earlier in the processing chain so that the request/response

* still appears in the correct access logs.

* @param request Request (associated with the response) to log

* @param response Response (associated with the request) to log

* @param time Time taken to process the request/response in

* milliseconds (use 0 if not known)

* @param useDefault Flag that indicates that the request/response should

* be logged in the engine's default access log

*/

public void logAccess(Request request, Response response, long time,

boolean useDefault);

/**

* Obtain the AccessLog to use to log a request/response that is destined

* for this container. This is typically used when the request/response was

* handled (and rejected) earlier in the processing chain so that the

* request/response still appears in the correct access logs.

*

* @return The AccessLog to use for a request/response destined for this

* container

*/

public AccessLog getAccessLog();

/**

* Obtain the number of threads available for starting and stopping any

* children associated with this container. This allows start/stop calls to

* children to be processed in parallel.

*

* @return The currently configured number of threads used to start/stop

* children associated with this container

*/

public int getStartStopThreads();

/**

* Sets the number of threads available for starting and stopping any

* children associated with this container. This allows start/stop calls to

* children to be processed in parallel.

* @param startStopThreads The new number of threads to be used

*/

public void setStartStopThreads(int startStopThreads);

/**

* Obtain the location of CATALINA_BASE.

*

* @return The location of CATALINA_BASE.

*/

public File getCatalinaBase();

/**

* Obtain the location of CATALINA_HOME.

*

* @return The location of CATALINA_HOME.

*/

public File getCatalinaHome();

}