org.apache.catalina.Container Maven / Gradle / Ivy
The newest version!
/*
* 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 Container 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 Pipeline interface
* as well.
*
* Containers will exist at several conceptual levels within Catalina. The
* following examples represent common cases:
*
* - Engine - 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.
*
- Host - Representation of a virtual host containing a number
* of Contexts.
*
- Context - Representation of a single ServletContext, which will
* typically contain one or more Wrappers for the supported servlets.
*
- Wrapper - Representation of an individual servlet definition
* (which may support multiple servlet instances if the servlet itself
* implements SingleThreadModel).
*
* 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.
*
* 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:
*
* - Loader - Class loader to use for integrating new Java classes
* for this Container into the JVM in which Catalina is running.
*
- Logger - Implementation of the
log() method
* signatures of the ServletContext interface.
* - Manager - Manager for the pool of Sessions associated with
* this Container.
*
- Realm - Read-only interface to a security domain, for
* authenticating user identities and their corresponding roles.
*
- Resources - JNDI directory context enabling access to static
* resources, enabling custom linkages to existing server components when
* Catalina is embedded in a larger server.
*
*
* @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 addChild().
*/
public static final String ADD_CHILD_EVENT = "addChild";
/**
* The ContainerEvent event type sent when a valve is added
* by addValve(), 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 removeChild().
*/
public static final String REMOVE_CHILD_EVENT = "removeChild";
/**
* The ContainerEvent event type sent when a valve is removed
* by removeValve(), 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 null.
*/
public Log getLogger();
/**
* Return the logger name that the container will use.
* @return the abbreviated name of this container for logging messages
*/
public String getLogName();
/**
* 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 null.
*/
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
* null.
*/
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 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
*/
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 null.
*/
public Realm getRealm();
/**
* Set the Realm with which this Container is associated.
*
* @param realm The newly associated Realm
*/
public void setRealm(Realm realm);
/**
* Find the configuration path where a configuration resource
* is located.
* @param container The container
* @param resourceName The resource file name
* @return the configuration path
*/
public static String getConfigPath(Container container, String resourceName) {
StringBuilder result = new StringBuilder();
Container host = null;
Container engine = null;
while (container != null) {
if (container instanceof Host) {
host = container;
} else if (container instanceof Engine) {
engine = container;
}
container = container.getParent();
}
if (host != null && ((Host) host).getXmlBase() != null) {
result.append(((Host) host).getXmlBase()).append('/');
} else {
result.append("conf/");
if (engine != null) {
result.append(engine.getName()).append('/');
}
if (host != null) {
result.append(host.getName()).append('/');
}
}
result.append(resourceName);
return result.toString();
}
/**
* Return the Service to which this container belongs.
* @param container The container to start from
* @return the Service, or null if not found
*/
public static Service getService(Container container) {
while (container != null && !(container instanceof Engine)) {
container = container.getParent();
}
if (container == null) {
return null;
}
return ((Engine) container).getService();
}
// --------------------------------------------------------- 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 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
*/
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 null 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();
}