init
This commit is contained in:
474
java/org/apache/catalina/Container.java
Normal file
474
java/org/apache/catalina/Container.java
Normal file
@@ -0,0 +1,474 @@
|
||||
/*
|
||||
* 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();
|
||||
|
||||
|
||||
/**
|
||||
* 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 <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();
|
||||
}
|
||||
Reference in New Issue
Block a user