All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.apache.catalina.Container Maven / Gradle / Ivy

There is a newer version: 11.0.2
Show 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(); }




© 2015 - 2024 Weber Informatics LLC | Privacy Policy