All Classes and Interfaces
Class
Description
Configuration settings for abandoned object removal.
Tracks db connection usage for recovering and reporting abandoned db connections.
Title: Membership - Absolute Order
Abstract implementation of the Valve interface that generates a web
server access log with the detailed line contents matching a configurable
pattern.
AccessLogElement writes the partial message into the buffer.
write bytes sent, excluding HTTP headers - %b, %B
Marks an AccessLogElement as needing to be have the value cached at the
start of the request rather than just recorded at the end as the source
data for the element may not be available at the end of the request.
Write connection status when response is completed - %X
write a specific cookie - %{xxx}c
Cache structure for formatted timestamps based on seconds.
write time taken to process the request - %D, %T
write time until first byte is written (commit time) in millis - %F
write incoming headers - %{xxx}i
write HTTP status code of the response - %s
write local IP address - %A
write remote logical username from identd (always returns '-') - %l
write request method (GET, POST, etc.) - %m
write Query string (prepended with a '?'
write an attribute in the ServletRequest - %{xxx}r
write first line of the request (method and request URI) - %r
write requested URL path - %U
write a specific response header - %{xxx}o
write an attribute in the HttpSession - %{xxx}s
write user session ID - %S
write any string
write thread name - %I
write remote user that was authenticated (if any), else '-' - %u
The is the base implementation for the AJP protocol handlers.
Abstract base class for Ant tasks that interact with the Manager web
application for dynamically deploying and undeploying applications.
Base class for the *Chunk implementation to reduce duplication.
Abstraction interceptor.
Different types of socket states to react upon.
Convenience base class for
Group implementations.Base implementation of Jar for implementations that use a JarInputStream to
access the JAR file.
Abstract base class for
ObjectCreationFactory
implementations.Provides functionality and attributes common to all supported protocols
(currently HTTP and AJP) for processing a single request/response.
This is a light-weight abstract processor implementation that is intended as
a basis for all Processor implementations from the light-weight upgrade
processors to the HTTP/AJP processors.
Abstract class that wraps statements and intercepts query executions.
Convenience base class for
Role implementations.Base class for a
WebResourceSet based on a
single, rather than nested, archive.Convenience base class for
User implementations.A helper class that wraps several AccessLog instances.
This is a concrete implementation of
AbstractAccessLogValve that
outputs the access log to a file.ActionCodes represent callbacks from the servlet container to the coyote
connector.
Action hook.
Adapter.
Filter that explicitly sets the default character set for media subtypes of
the "text" type to ISO-8859-1, or another user defined character set.
Wrapper that adds a character set for text media types if no character
set is specified.
Address
This the APR/native based protocol handler implementation for AJP.
A single packet for communication between the web server and the
container.
This the NIO2 based protocol handler implementation for AJP.
This the NIO based protocol handler implementation for AJP.
AJP Processor implementation.
represents one annotation in the annotation table
base class for annotations
Main JSP compiler class.
Callback interface to be able to expand buffers when buffer overflow
exceptions happen or to replace buffers
Standard implementation of
ServletContext that represents
a web application's execution environment.Facade object which masks the internal
ApplicationContext
object from the web application.Implementation of
javax.servlet.FilterChain used to manage
the execution of a set of filters for a particular request.Implementation of a
javax.servlet.FilterConfig useful in
managing the filter instances instantiated when a web application
is first started.Factory for the creation and caching of Filters and creation
of Filter Chains.
Representation of a context initialization parameter that is configured
in the server configuration file, rather than the application deployment
descriptor.
APR tailored thread pool, providing the following services:
Socket acceptor thread
Socket poller thread
Sendfile thread
Worker threads pool
When switching to Java 5, there's an opportunity to use the virtual
machine's thread pool.
SendfileData class.
Implementation of
LifecycleListener that will init and
and destroy APR.Implementation of SSLSupport for APR.
Holds APR status.
Imported copy of the
ArrayStack class from
Commons Collections, which was the only direct dependency from Digester.This class implements some basic ASCII character handling functions.
This is a very basic ASN.1 parser that provides the limited functionality
required by Tomcat.
This is a utility class that enables multiple
WsWebSocketContainer
instances to share a single AsynchronousChannelGroup while ensuring
that the group is destroyed when no longer required.This is a wrapper for a
AsynchronousSocketChannel
that limits the methods available thereby simplifying the process of
implementing SSL/TLS support since there are fewer methods to intercept.Generally, just passes calls straight to the wrapped
AsynchronousSocketChannel.Wraps the
AsynchronousSocketChannel with SSL/TLS.Provides a mechanism for the Coyote connectors to communicate with the
AsyncContext.A
FileHandler implementation that uses a queue of log entries.Internal configuration information for an
Attribute
descriptor.Converts a JSP attribute value into the unquoted equivalent.
This Realm is intended for use with Authenticator implementations
(
SSLAuthenticator,
SpnegoAuthenticator) that
authenticate the user as well as obtain the user credentials.Exception thrown on authentication error connecting to a remote
websocket endpoint.
An Authenticator is a component (usually a Valve or Container) that
provides some sort of authentication service.
Base class for the authentication methods used by the websocket client.
Basic implementation of the Valve interface that enforces the
<security-constraint> elements in the web application
deployment descriptor.Utility method to return the appropriate authenticator according to
the scheme that the server uses.
Parser for an "Authorization" header.
NIO based character decoder.
Provides a background processing mechanism that triggers roughly once a
second.
Base class providing common implementation for back-port utilities.
Generates a set of English property files to back-port updates to a previous
version.
Generates a set of translated property files to back-port updates to a
previous version.
Provides Base64 encoding and decoding as defined by RFC 2045.
Implementation of
NotificationFilter for attribute change
notifications.Base class that provides common functionality for
GenericObjectPool
and GenericKeyedObjectPool.A base implementation of
KeyedPooledObjectFactory.Basic implementation of the
DynamicMBean interface, which
supports the minimal requirements of the interface contract.Abstract superclass for Base-N encoders and decoders.
Implementation of
NotificationBroadcaster for attribute
change notifications.A base class for common functionality.
A simple base implementation of
ObjectPool.Provides the implementation for the common attributes shared by the
sub-classes.
A base implementation of
PoolableObjectFactory.Abstract base class to add output redirection support for Catalina Ant tasks.
Comparator which permits to compare on a session's content.
An Authenticator and Valve implementation of HTTP BASIC
Authentication, as outlined in RFC 2617: "HTTP Authentication: Basic
and Digest Access Authentication."
Authenticator supporting the BASIC auth method.
Parser for an HTTP Authorization header for BASIC authentication
as per RFC 2617 section 2, and the Base64 encoded credentials as
per RFC 2045 section 6.8.
Basic implementation of
javax.sql.DataSource that is configured via JavaBeans properties.
JNDI object factory that creates an instance of
BasicDataSource that has been configured based on the
RefAddr values of the specified Reference, which must match the names and data types of the
BasicDataSource bean properties with the following exceptions:Defines the methods that will be made available via JMX.
BasicManagedDataSource is an extension of BasicDataSource which creates ManagedConnections.
Object factory for any Resource conforming to the JavaBean spec.
Repository of {page, request, session, application}-scoped beans
Open SSL BIO Callback Interface
Deprecated.
This will be removed in Tomcat 10
Deprecated.
This will be removed in Tomcat 10
Deprecated.
This will be removed in Tomcat 10
Write text to a character-output stream, buffering characters so as
to provide for the efficient writing of single characters, arrays,
and strings.
Bootstrap loader for Catalina.
Buffer
Input filter responsible for reading and buffering the request body, so that
it does not interfere with client SSL handshake messages.
This class implements an output stream in which the data is
written into a byte array.
Class that extends ServletOutputStream, used as a wrapper from within
SsiIncludeSimple wrapper for a
ByteBuffer that remembers if the buffer has been
flipped or not.This class is used to represent a chunk of bytes, and utilities to manipulate
byte[].
Input interface, used when the buffer is empty.
When we need more space we'll either grow the buffer ( up to the limit )
or send it to a channel.
A byte message is not serialized and deserialized by the channel
instead it is sent as a byte array
By default Tribes uses java serialization when it receives an object to be sent over the wire.
By default Tribes uses java serialization when it receives an object to be sent over the wire.
NIO based character encoder.
This class is designed to wrap a 'raw' WebResource and providing caching for
expensive operations.
Default implementation of a JASPIC CallbackHandler.
Rule implementation that calls a method on an object on the stack
(normally the top/parent object), passing arguments collected from
subsequent
CallParamRule rules or from the body of this
element.Rule implementation that saves a parameter for use by a surrounding
CallMethodRule.Strategy for obtaining and printing the current call stack.
Utility methods for
CallStack.A Map implementation that uses case-insensitive (using
Locale.ENGLISH) strings as keys.Startup/Shutdown shell program for Catalina.
A CatalinaCluster interface allows to plug in and out the
different cluster implementations
Generate Cluster Element with Membership,Sender,Receiver,Deployer and
ReplicationValve
Utility class to read the bootstrap Catalina configuration.
Rule implementation that creates an SSLHostConfigCertificate.
Store the Certificate attributes.
Is called during handshake and hooked into openssl via
SSL_CTX_set_cert_verify_callback.CGI-invoking servlet for web applications, used to execute scripts which
comply to the Common Gateway Interface (CGI) specification and are named
in the path-info used to invoke this servlet.
This is an input stream specifically for reading HTTP headers.
Channel interface
A channel is a representation of a group of nodes all participating in some sort of communication with each other.
The channel is the main API class for Tribes, this is essentially the only class that an application needs to be aware of.
A channel is a representation of a group of nodes all participating in some sort of communication with each other.
The channel is the main API class for Tribes, this is essentially the only class that an application needs to be aware of.
The channel coordinator object coordinates the membership service,
the sender and the receiver.
The
ChannelData object is used to transfer a message through the
channel interceptor stack and eventually out on a transport to be sent
to another node.Channel Exception
A channel exception is thrown when an internal error happens somewhere in the channel.
A channel exception is thrown when an internal error happens somewhere in the channel.
Title: FaultyMember class
A ChannelInterceptor is an interceptor that intercepts
messages and membership messages in the channel stack.
Abstract class for the interceptor base class.
Title: ChannelListener
Message that is passed through the interceptor stack after the
data serialized in the Channel object and then passed down to the
interceptor and eventually down to the ChannelSender component
ChannelReceiver Interface
The
The
ChannelReceiver interface is the data receiver component
at the bottom layer, the IO layer (for layers see the javadoc for the Channel interface).ChannelReceiver Interface
The
The channel sender must support "silent" members, ie, be able to send a message to a member that is not in the membership, but is part of the destination parameter
The
ChannelSender interface is the data sender component
at the bottom layer, the IO layer (for layers see the javadoc for the Channel interface).The channel sender must support "silent" members, ie, be able to send a message to a member that is not in the membership, but is part of the destination parameter
Generate Channel Element
Utilities to manipulate char chunks.
Input interface, used when the buffer is empty.
When we need more space we'll either grow the buffer ( up to the limit )
or send it to a channel.
Utility class that attempts to map from a Locale to the corresponding
character set to be used for interpreting input text (or generating
output text) when the Content-Type header does not include one.
Ant task that checks that all the files in the given fileset have end-of-line
delimiters that are appropriate.
Chunked input filter.
Chunked output filter.
All the standard cipher suites for SSL/TSL.
Thrown when the BCEL attempts to read a class file and determines
that the file is malformed or otherwise cannot be interpreted as a
class file.
Utility class for building class loaders for Catalina.
Per classloader LogManager implementation.
This class is needed to instantiate the root of each per classloader
hierarchy.
A convenience base class for ModelMBean implementations
where the underlying base class (and therefore the set of supported
properties) is different for varying implementations of a standard
interface.
Wrapper class that parses a given Java .class file.
Extend IOException to identify it as being caused by an abort of a request by
a remote client.
Interface of an object, which may be closed.
This exception is thrown to signal to the Tomcat internals that an error has
occurred that requires the connection to be closed.
A
MembershipService that uses Kubernetes API(default) or DNS to retrieve
the members of a cluster.A Cluster works as a Cluster client/server for the local host
Different Cluster implementations can be used to support different
ways to communicate within the Cluster.
A ClusterDeployer interface allows to plug in and out the
different deployment implementations
Receive SessionID cluster change from other backup node after primary session
node is failed.
The common interface used by all cluster manager.
RuleSet for processing the contents of a
Cluster definition element.
Receive replicated SessionMessage form other cluster node.
A Valve that supports a "single sign on" user experience on
each nodes of a cluster, where the security identity of a user who successfully
authenticates to one web application is propagated to other web applications and
to other nodes cluster in the same security domain.
Cluster extension of
SingleSignOnListener that simply adds the marker
interface ReplicatedSessionListener which allows the listener to be
replicated across the cluster along with the session.Cluster valves are a simple extension to the Tomcat valve architecture
with a small addition of being able to reference the cluster component in the container it sits in.
Realm implementation that contains one or more realms.
Main JSP compiler class.
Deprecated.
Unused.
A thread safe wrapper around
SimpleDateFormat that does not make use
of ThreadLocal and - broadly - only creates enough SimpleDateFormat objects
to satisfy the concurrency requirements.A thread safe wrapper around
MessageDigest that does not make use
of ThreadLocal and - broadly - only creates enough MessageDigest objects
to satisfy the concurrency requirements.This class is used to obtain
InputStreams for configuration files
from a given location String.Abstracts configuration file storage.
Represents a resource: a stream to the resource associated with
its URI.
Abstract factory interface for creating
Connections.Implementation of simple connection pool.
Interceptor that keep track of connection state to avoid roundtrips to the database.
Implementation of a Coyote connector.
Rule implementation that creates a connector.
A ModelMBean implementation for the
org.apache.coyote.tomcat5.CoyoteConnector component.Store Connector and Listeners
Store the Connector attributes.
Constants for the project, mostly defined in the JVM specification.
Abstract superclass for classes to represent the different constant types
in the constant pool of a class file.
This class is derived from the abstract
Constant
and represents a reference to a (external) class.This class is derived from the abstract
Constant
and represents a reference to a Double object.This class is derived from the abstract
Constant
and represents a reference to a float object.This class is derived from the abstract
Constant
and represents a reference to an int object.This class is derived from the abstract
Constant
and represents a reference to a long object.This class represents the constant pool, i.e., a table of constants, of
a parsed classfile.
Manifest constants for this Java package.
Manifest constants for the
org.apache.catalina.ha.tcp
package.Static constants for this package.
Deprecated.
Manifest constants for the
org.apache.catalina.session
package.String constants for the startup package.
Manifest constants for the
org.apache.catalina.tribes.membership
package.Manifest constants for the
org.apache.catalina.tribes.transport
package.Manifest constants for this Java package.
Manifest constants for the
org.apache.catalina.valves
package.Constants.
Constants.
Constants.
Some constants and other global data that are used by the compiler and the runtime.
Static constants for this package.
Constants for use with JMX.
String constants for the scan package.
Static constants for this package.
Internal implementation constants.
Internal implementation constants.
Internal implementation constants.
This class is derived from the abstract
Constant class
and represents a reference to a Utf8 encoded string.
Decoupling interface which specifies that an implementing class is
associated with at most one Container instance.
A Container is an object that can execute requests received from
a client, and return responses based on those requests.
Abstract implementation of the Container interface, providing common
functionality required by nearly every implementation.
General event for notifying listeners of significant changes on a Container.
Interface defining a listener for significant Container generated events.
A ContainerServlet is a servlet that has access to Catalina
internal functionality, and is loaded from the Catalina class loader
instead of the web application class loader.
Used to mark threads that have been allocated by the container to process
data from an incoming connection.
Used to mark threads that have been allocated by the container to process
data from an incoming connection.
A Context is a Container that represents a servlet context, and
therefore an individual web application, in the Catalina servlet engine.
Handles the access control on the JNDI contexts.
Handles the associations :
Object with a NamingContext
Calling thread with a NamingContext
Calling thread with object bound to the same naming context
Thread context class loader with a NamingContext
Thread context class loader with object bound to the same
NamingContext
The objects are typically Catalina Server or Context objects.
Startup event listener for a Context that configures the properties
of that Context, and the associated defined servlets.
Representation of an EJB resource reference for a web application, as
represented in a
<ejb-ref> element in the
deployment descriptor.Representation of an application environment entry, as represented in
an
<env-entry> element in the deployment descriptor.A ModelMBean implementation for the
org.apache.tomcat.util.descriptor.web.ContextEnvironment component.Representation of a handler reference for a web service, as
represented in a
<handler> element in the
deployment descriptor.Representation of a local EJB resource reference for a web application, as
represented in a
<ejb-local-ref> element in the
deployment descriptor.Utility class to manage context names so there is one place where the
conversions between baseName, path and version take place.
Representation of a resource reference for a web application, as
represented in a
<resource-ref> element in the
deployment descriptor.Representation of an application resource reference, as represented in
an
<res-env-refy> element in the deployment descriptor.Representation of a resource link for a web application, as
represented in a
<ResourceLink> element in the
server configuration file.A ModelMBean implementation for the
org.apache.tomcat.util.descriptor.web.ContextResourceLink component.A ModelMBean implementation for the
org.apache.tomcat.util.descriptor.web.ContextResource component.RuleSet for processing the contents of a
Context definition element.
Representation of a web service reference for a web application, as
represented in a
<service-ref> element in the
deployment descriptor.Representation of an application resource reference, as represented in
an
<res-env-refy> element in the deployment descriptor.Defines timing options for responding to requests that contain a
'100-continue' expectations.
Cookie header parser based on RFC6265 and RFC2109.
Rule that copies the
parentClassLoader property from the
next-to-top item on the stack (which must be a Container)
to the top item on the stack (which must also be a
Container).
A
Filter that enable client-side cross-origin requests
by implementing W3C's CORS (Cross-Origin Resource
Sharing) specification for resources.Enumerates varies types of CORS requests.
Implementation of a request processor which delegates the processing to a
Coyote processor.
This class handles reading bytes.
Coyote implementation of the servlet output stream.
Generic implementation of java.security.Principal that
is used to represent principals authenticated at the protocol handler level.
Coyote implementation of the buffered reader.
Coyote implementation of the servlet writer.
Web crawlers can trigger the creation of many thousands of sessions as they
crawl a site which may result in significant memory consumption.
RuleSet for processing the contents of a
CredentialHandler definition element.
Store server.xml Element CredentialHandler
Provides basic CSRF protection for a web application.
Custom subclass of
ObjectInputStream that loads from the
class loader for this web application.A DataSource that can be instantiated through IoC and implements the DataSource interface
since the DataSourceProxy is used as a generic proxy.
A
DataSource-based implementation of ConnectionFactory.JNDI object factory that creates an instance of
BasicDataSource that has been configured based on the
RefAddr values of the specified Reference,
which must match the names and data types of the
BasicDataSource bean properties.Object factory for resource links for shared data sources.
Simple wrapper class that will allow a user to configure a ResourceLink for a data source
so that when
DataSource.getConnection() is called, it will invoke
DataSource.getConnection(String, String) with the preconfigured username and password.The DataSource proxy lets us implements methods that don't exist in the current
compiler JDK but might be methods that are part of a future JDK DataSource interface.
Implementation of Realm that works with any JDBC JNDI DataSource.
Implementation of the
Store
interface that stores serialized session objects in a database.An implementation of XAConnectionFactory which uses a real XADataSource to obtain connections and XAResources.
Cache structure for SimpleDateFormat formatted timestamps based on
seconds.
Provides the default implementation of
EvictionPolicy used by the
pools.This wrapper is used to track the additional information, such as state, for
the pooled objects.
Implementation of object that is used to provide information on pooled
objects via JMX.
The interface that defines the information about pooled objects that will be
exposed via JMX.
The default resource-serving servlet for most web applications,
used to serve static resources such as HTML pages and images.
An output stream which will retain data in memory until a specified
threshold is reached, and only then commit it to disk.
A base delegating implementation of
CallableStatement.A base delegating implementation of
Connection.
A base delegating implementation of
DatabaseMetaData.A base delegating implementation of
PreparedStatement.A base delegating implementation of
ResultSet.A base delegating implementation of
Statement.The DeltaManager manages replicated sessions by only replicating the deltas
in data.
Similar to the StandardSession except that this session will keep
track of deltas during a request.
Ant task that implements the
/deploy command, supported by the
Tomcat manager application.Grant this permission to a docBase to permit the web application to use any
META-INF/context.xml that might be present with in the
application when deployXML has been disabled at the Host level.Destroy context provided to object factories via destroyObject methods.
An Authenticator and Valve implementation of HTTP DIGEST
Authentication (see RFC 2069).
Authenticator supporting the DIGEST auth method.
Base implementation for the Tomcat provided
CredentialHandlers.A Digester processes an XML input stream by matching a
series of element nesting patterns to execute Rules that have been added
prior to the start of parsing.
Deprecated.
Use
EnvironmentPropertySource
This will be removed in Tomcat 10 onwards.Wrapper class around the Digester that hide Digester's initialization
details.
Byte array output stream that exposes the byte array directly
Directory
Represents a
WebResourceSet based on a directory. The default implementation of the
FileItem interface.The default
FileItemFactory
implementation.This enumeration lists the different types of dispatches that request
processing can trigger.
A DisposableConnectionFacade object is the top most interceptor that wraps an
object of type
PooledConnection.Interface implemented by session managers that do not keep a complete copy
of all sessions in memory but do know where every session is.
A
MembershipProvider that uses DNS to retrieve the members of a cluster.A collection of interfaces, one per property, that enables the object being
populated by the digester to signal to the digester that it supports the
given property and that the digester should populate that property if
available.
The character encoding used by the source XML document.
Title: Member domain filter interceptor
A DOM writer optimised for use by WebDAV.
An adapter for JDBC drivers that do not include an implementation of
ConnectionPoolDataSource, but
still include a DriverManager implementation.A
Driver-based implementation of ConnectionFactory.A
DriverManager-based implementation of ConnectionFactory.Object factory for EJBs.
Represents a reference address to an EJB.
A helper class of Arithmetic defined by the EL Specification
Implementation of ELContext
Simple ELContextWrapper for runtime evaluation of EL w/ dynamic FunctionMappers
an annotation's element value pair
This class generates functions mappers for the EL expressions in the page.
Defines the interface for the expression language interpreter.
Provides
ELInterpreter instances for JSP compilation.A non-specification compliant
ELInterpreter that optimizes a subset
of setters for tag attributes.This class implements a parser for EL expressions.
Deprecated.
A helper class that implements the EL Specification
A class to hold all init parameters specific to the JSP engine.
A
WebResourceSet implementation that is not backed by a file system
and behaves as if it has no resources available.Adds encryption using a pre-shared key.
An Engine is a Container that represents the entire Catalina servlet
engine.
Startup event listener for an Engine that configures the properties
of that Engine, and the associated defined contexts.
RuleSet for processing the contents of a
Engine definition element.
A
IntrospectionUtils.SecurePropertySource
that uses environment variables to resolve expressions.Error
Class responsible for dispatching JSP parse and javac compilation errors
to the configured error handler.
The
ErrorHandler class is used when sending messages
that are sent asynchronously and the application still needs to get
confirmation when the message was sent successfully or when a message errored out.Interface for handling JSP parse and javac compilation errors.
Representation of an error page element for a web application,
as represented in a
<error-page> element in the
deployment descriptor.Provides support for tracking per exception type and per HTTP status code
error pages.
Implementation of a Valve that outputs HTML error pages.
Provides utility methods to escape content for different contexts.
This class is used by pool implementations to pass configuration information
to
EvictionPolicy instances.To provide a custom eviction policy (i.e. something other than
DefaultEvictionPolicy for a pool, users must provide an implementation of
this interface that provides the required eviction policy.Utilities for handling Throwables and Exceptions.
Utilities for handling Throwables and Exceptions.
Utilities for handling Throwables and Exceptions.
Expand out a WAR in a Host's appBase.
ExpiresFilter is a Java Servlet API port of Apache
mod_expires to add '
Expires' and
'Cache-Control: max-age=' headers to HTTP response according to its
'Content-Type'.Duration composed of an
ExpiresFilter.Duration.amount and a ExpiresFilter.Duration.unitDuration unit
Main piece of configuration of the filter.
Expiration configuration starting point.
Deprecated.
Deprecated.
Represents a parsed expression.
Parses an expression string to return the individual tokens.
An implementation of the W3c Extended Log File Format.
write a specific response header - x-O(xxx)
Extension to the
RpcCallback interface.Utility class that represents either an available "Optional Package"
(formerly known as "Standard Extension") as described in the manifest
of a JAR file, or the requirement for such an optional package.
Ensures that all extension dependencies are resolved for a WEB application
are met.
If the main resources are packaged as a WAR file then any JARs will be
extracted to the work directory and used from there.
Abstract base class that provides common functionality required by
sub-classes.
Rule implementation that uses an
ObjectCreationFactory to create
a new object which it pushes onto the object stack.An implementation of
Context that is used as a place-holder for
deployed applications when their deployment fails and a Context instance
(usually StandardContext but may be any
Context implementation) cannot be created.Filter that will reject requests if there was a failure during parameter
parsing.
A simple implementation of a blocking queue with fairness waiting.
A farm war deployer is a class that is able to deploy/undeploy web
applications in WAR from within the cluster.
Utility class to generate HTTP dates.
The FastRemovalDequeue is a Dequeue that supports constant time removal of
entries.
Convenience base class for
AttributeInfo and
OperationInfo classes that will be used to collect configuration
information for the ModelMBean beans exposed for management.File
This exception is thrown if a request contains more files than the specified
limit.
Implementation of Handler that appends log messages to a file
named {prefix}{date}{suffix} in a configured directory.
Fileinfo
This class represents a file or form item that was received within a
multipart/form-data POST request.A factory interface for creating
FileItem instances. This class provides support for accessing the headers for a file or form
item that was received within a
multipart/form-data POST
request.Default implementation of the
FileItemHeaders interface.Interface that will indicate that
FileItem or FileItemStream
implementations will accept the headers read for the item.An iterator, as returned by
FileUploadBase.getItemIterator(RequestContext).The iterator, which is returned by
FileUploadBase.getItemIterator(RequestContext). This interface provides access to a file or form item that was
received within a
multipart/form-data POST request.This exception is thrown, if an attempt is made to read
data from the
InputStream, which has been returned
by FileItemStream.openStream(), after
Iterator.hasNext() has been invoked on the
iterator, which created the FileItemStream.Default implementation of
FileItemStream.Contains the data for a file being transferred over TCP, this is
essentially a fragment of a file, read and written by the FileMessageFactory
This factory is used to read files and write files by splitting them up into
smaller messages.
Represents a single resource (file or directory) that is located on a file
system.
Represents a
WebResourceSet based on a single
file.Thrown to indicate that A files size exceeds the configured maximum.
Concrete implementation of the Store interface that utilizes
a file per saved Session in a configured directory.
High level API for processing file uploads.
High level API for processing file uploads.
Exception for errors encountered while processing the request.
This exception is thrown for hiding an inner
FileUploadException in an IOException.General file manipulation utilities.
Base class for filters that provides generic initialisation and a simple
no-op destruction.
Representation of a filter definition for a web application, as represented
in a
<filter> element in the deployment descriptor.Representation of a filter mapping for a web application, as represented
in a
<filter-mapping> element in the deployment
descriptor.Ant task that implements the
/findleaks command, supported by
the Tomcat manager application.An Authenticator and Valve implementation of FORM BASED
Authentication, as described in the Servlet API Specification.
The fragmentation interceptor splits up large messages into smaller messages and assembles them on the other end.
Callback handling a web-fragment.xml descriptor.
This listener must be declared in server.xml as a Server listener, possibly optional.
Deprecated.
A configurable
KeyedObjectPool implementation.A simple "struct" encapsulating the configuration for a
GenericKeyedObjectPool.Defines the methods that will be made available via JMX.
Simple way of configuring generic resources by using reflection.
A configurable
ObjectPool implementation.A simple "struct" encapsulating the configuration for a
GenericObjectPool.Defines the methods that will be made available via JMX.
Generic implementation of java.security.Principal that
is available for use by
Realm implementations.Global
store server.xml GlobalNamingResource.
Implementation of
LifecycleListener that instantiates the
set of MBeans associated with global JNDI resources that are subject to
management.Global constants that are applicable to multiple packages within Catalina.
Abstract representation of a group of
Users in a
UserDatabase.The default implementation of a Channel.
The GroupChannel manages the replication channel.
The GroupChannel manages the replication channel.
Title: Interceptor Iterator
A ModelMBean implementation for the
org.apache.catalina.Group component.Gzip output filter.
Represents a reference handler for a web service.
Exception used to mark the specific error condition of the HTTP headers
exceeding the maximum permitted size.
Simple Valve that responds to cloud orchestrators health checks.
Can be implemented by the ChannelListener and Membership listeners to receive heartbeat
notifications from the Channel
Tables useful when converting byte arrays to and from strings of hexadecimal
digits.
Concrete implementation of the
UserDatabase interface
considers all directories in a directory whose pathname is specified
to our constructor to be "home" directories for those users.A Host is a Container that represents a virtual host in the
Catalina servlet engine.
Startup event listener for a Host that configures the properties
of that Host, and the associated defined contexts.
This class represents the state of a deployed application, as well as
the monitored resources.
Servlet that enables remote management of the virtual hosts installed
on the server.
RuleSet for processing the contents of a
Host definition element.
A decoder for HPACK.
Servlet that enables remote management of the virtual hosts deployed
on the server.
Servlet that enables remote management of the web applications deployed
within the same virtual host as this web application is.
Abstract the protocol implementation, including threading, etc.
InputBuffer for HTTP that provides request header parsing as well as transfer
encoding.
HTTP/1.1 protocol implementation using NIO2.
Abstract the protocol implementation, including threading, etc.
Provides buffering for the HTTP headers (allowing responses to be reset
before they have been committed) and the link to the Socket for writing the
headers (once committed) and the response body.
Provides a single configuration point for security measures that required the
addition of one or more HTTP headers to the response.
This is the super class of all JSP-generated servlets.
HTTP header value parser implementation.
Identity input filter.
Identity output filter.
RulesSet for digesting implicit.tld files.
The buffer used by Tomcat request.
This class is only for internal use in the protocol implementation.
Input filter interface.
The base class for
SharedPoolDataSource and PerUserPoolDataSource.Specifies a class loader capable of being decorated with
ClassFileTransformers.Generate Interceptor Element
This Tomcat specific interface is implemented by handlers that require direct
access to Tomcat's I/O layer rather than going through the Servlet API.
Provides introspection utilities that either require knowledge of Tomcat
internals or are solely used by Tomcat internals.
Utils for introspection and reflection
Thrown to indicate that the request is not a multipart request.
This exception is thrown in case of an invalid file name.
Thrown to indicate an IOException.
Contains commonly needed I/O-related methods
General IO stream manipulation utilities.
IPv6 utilities.
Implementation of the JAAS
CallbackHandler interface,
used to negotiate delivery of the username and credentials that were
specified to our constructor.Implementation of the JAAS LoginModule interface,
primarily for use in testing
JAASRealm.Implementation of Realm that authenticates users via the Java
Authentication and Authorization Service (JAAS).
Provides an abstraction for use by the various classes that need to scan
JARs.
This class represents the contents of a jar by determining whether a given
resource might be in the cache, based on a bloom filter.
Provide a mechanism to obtain objects that implement
Jar.Implementation of
Jar that is optimised for file based JAR URLs that
refer directly to a JAR file (e.g URLs of the form jar:file: ... .jar!Implementation of
Jar that is optimised for file
based JAR URLs that refer to a JAR file nested inside a WAR
(e.g URLs of the form jar:file: ... .war!Represents a single resource (file or directory) that is located within a
JAR.
Represents a
WebResourceSet based on a JAR file.Scans a web application and classloader hierarchy for JAR files.
This interface is implemented by clients of the
JarScanner to enable
them to receive notification of a discovered JAR.Provide a mechanism for Jasper to obtain a reference to the JarScanner
implementation.
Store server.xml Element JarScanner
Represents a single resource (file or directory) that is located within a
JAR that in turn is located in a WAR file.
Represents a
WebResourceSet based on a JAR file
that is nested inside a packed WAR file.Jasper-specific CompositeELResolver that optimizes certain functions to avoid
unnecessary resolver calls.
Base class for all exceptions generated by the JSP engine.
Initializer for the Jasper JSP Engine.
Class loader for loading servlet class files (corresponding to JSP files)
and tag handler class files (corresponding to tag files).
Class providing details about a javac compilation error.
Represents a Java class, i.e., the data structures, constant pool,
fields, methods and commands contained in a Java .class file.
Context factory for the "java:" namespace.
Defines bridge methods to JDBC 4.1 (Java 7) methods to allow call sites to operate safely (without
AbstractMethodError) when using a JDBC driver written for JDBC 4.0 (Java 6).
This Tomcat extension logs server access directly to a database, and can
be used instead of the regular file-based access log implemented in
AccessLogValve.
Abstract class that is to be extended for implementations of interceptors.
This class is loaded by
WebappClassLoaderBase to enable it to
deregister JDBC drivers forgotten by the web application.Deprecated.
Will be removed in Tomcat 10 onwards.
Deprecated.
Removed in Tomcat 10 and replaced by DataSourceStore
with removal of legacy JDBC code
A more compact formatter.
JDT class compiler.
Ant task that implements the
/status command, supported by the
mod_jk status (1.2.9) application.Definition:
Create new MBean at JMX JSR 160 MBeans Server.
Definition
Access JMX JSR 160 MBeans Server.
Access JMX JSR 160 MBeans Server.
Query for Mbeans.
Access JMX JSR 160 MBeans Server.
Access JMX JSR 160 MBeans Server.
unregister an MBean at JMX JSR 160 MBeans Server.
This interface is implemented by components that will be registered with an
MBean server when they are created and unregistered when they are destroyed.
Ant task that implements the JMX Get command (
/jmxproxy/?This servlet will dump JMX attributes in a simple format and implement proxy
services for modeler.
Ant task that implements the JMX Query command
(
/jmxproxy/?Deprecated.
The features provided by this listener are now available in the
remote JMX capability included with the JRE.
Ant task that implements the JMX Set command (
/jmxproxy/?Implementation of Realm that works with a directory
server accessed via the Java Naming and Directory Interface (JNDI) APIs.
Class holding the connection to the directory plus the associated
non thread safe message formats.
A protected class representing a User
An implementation of LifeCycleListener that loads a native library into the JVM.
This is the base implementation class for JRE compatibility and provides an
implementation based on Java 8.
Provide a workaround for known places where the Java Runtime environment can
cause a memory leak or lock files.
Implementation of a Valve that outputs error jsons.
Implementation of JspApplicationContext
Shell for the jspc compiler.
A place holder for various things that are used through out the JSP
engine.
Handles the jsp-config element in WEB_INF/web.xml.
Implementation of a JSP Context Wrapper.
Simple
ServletContext implementation without
HTTP-specific methods.Implementation of JspFactory.
Helper class from which all Jsp Fragment helper classes extend.
Helper JavaBean for JSPs, because JSTL 1.1/EL 2.0 is too dumb to
to what I need (call methods with parameters), or I am too dumb to use it correctly. :)
Representation of a jsp-property-group element in web.xml.
Class for tracking JSP compile time file dependencies when the
>%@include file="
Bunch of util methods that are used by code generated for useBean,
getProperty and setProperty.
The JSP engine (a.k.a Jasper).
The JSP engine (a.k.a Jasper).
Interface for tracking the source files dependencies, for the purpose
of compiling out of date pages.
The EL engine needs access to the imports used in the JSP page to configure
the ELContext.
This class has all the utility method(s).
Wrapper for providing context to ValueExpressions
Write text to a character-output stream, buffering characters so as
to provide for the efficient writing of single characters, arrays,
and strings.
X509KeyManager which allows selection of a specific keypair and certificate
chain (identified by their keystore alias name) to be used by the server to
authenticate itself to SSL clients.
JSSESupport
Concrete implementation class for JSSE
Support classes.
SSLUtil implementation for JSSE.
Valve to handle Tomcat jvmRoute takeover using mod_jk module after node
failure.
A "keyed" pooling interface.
An interface defining life-cycle methods for
instances to be served by a
KeyedObjectPool.A
MembershipProvider that uses Kubernetes API to retrieve the members of a cluster.A smart implementation of a stateful replicated map. uses primary/secondary backup strategy.
The legacy (up to early Tomcat 8 releases) cookie parser based on RFC6265,
RFC2109 and RFC2616.
Library
Common interface for component life cycle methods.
Marker interface used to indicate that the instance should only be used
once.
Base implementation of the
Lifecycle interface that implements the
state transition rules for Lifecycle.start() and
Lifecycle.stop()General event for notifying listeners of significant changes on a component
that implements the Lifecycle interface.
General purpose exception that is thrown to indicate a lifecycle related
problem.
Interface defining a listener for significant events (including "component
start" and "component stop" generated by a component that implements the
Lifecycle interface.
Rule that creates a new
LifecycleListener and associates it with the
top object on the stack which must implement Container.The list of valid states for components that implement
Lifecycle.An input stream, which limits its data size.
Shared latch that allows the latch to be acquired a limited number of times
after which all subsequent requests to acquire the latch will be placed in a
FIFO queue until one of the shares is returned.
Internal interface, similar to the MessageListener but used
at the IO base
The listen callback interface is used by the replication system
when data has been received.
Rule implementation that creates a server listener.
An exception wrapping a list of exceptions.
Ant task that implements the
/list command, supported by the
Tomcat manager application.A Valve to detect situations where a load-balanced node receiving a
request has been deactivated by the load balancer (JK_LB_ACTIVATION=DIS)
and the incoming request has no valid session.
A Loader represents a Java ClassLoader implementation that can
be used by a Container to load class files (within a repository associated
with the Loader) that are designed to be reloaded upon request, as well as
a mechanism to detect whether changes have occurred in the underlying
repository.
Store Loader Element.
Local socket.
Class responsible for converting error codes to corresponding localized
error messages.
A resolver for locally cached XML resources.
An implementation of XAConnectionFactory which manages non-XA connections in XA transactions.
LocalXAResource is a fake XAResource for non-XA connections.
Lock
This class extends the CombinedRealm (hence it can wrap other Realms) to
provide a user lock out mechanism if there are too many failed
authentication attempts in a given period of time.
A simple logging interface abstracting logging APIs.
An exception that is thrown only if a suitable
LogFactory
or Log instance cannot be created by the corresponding
factory methods.This is a modified LogFactory that uses a simple
ServiceLoader based
discovery mechanism with a default of using JDK based logging.Representation of a login configuration element for a web application,
as represented in a
<login-config> element in the
deployment descriptor.Simple class that holds references to global loggers
Object factory for lookups.
Represents a reference to lookup.
Factory class that creates a JNDI named JavaMail Session factory,
which can be used for managing inbound and outbound electronic mail
messages via JavaMail APIs.
Internal configuration information for a managed bean (MBean)
descriptor.
Channel interface
A managed channel interface gives you access to the components of the channels
such as senders, receivers, interceptors etc for configurations purposes
Concurrent hash map that holds its keys via weak references.
ManagedConnection is responsible for managing a database connection in a transactional environment (typically called
"Container Managed").
The ManagedDataSource is a PoolingDataSource that creates ManagedConnections.
A Manager manages the pool of Sessions that are associated with a
particular Context.
Minimal implementation of the Manager interface that supports
no session persistence or distributable capabilities.
Servlet that enables remote management of the web applications installed
within the same virtual host as this web application is.
Store server.xml Manager element
Representation of a Manifest file and its available extensions and
required extensions
Mapper, which implements the servlet API mapping rules (which are derived
from the HTTP rules).
Mapper listener.
Mapping data.
This is a utility class to match file globs.
General helper to dump MBean contents to the log.
Public utility methods in support of the server side MBeans implementation.
A membership implementation using simple multicast.
A membership implementation using simple multicast.
Encode an MD5 digest into a String.
Caches the results of parsing content-type headers.
The Member interface, defines a member in the group.
A membership implementation using simple multicast.
A membership implementation using simple multicast.
Inner class that represents a member entry
The MembershipListener interface is used as a callback to the
membership service.
MembershipService Interface
The
The
MembershipService interface is the membership component
at the bottom layer, the IO layer (for layers see the javadoc for the Channel interface).Simple implementation of Realm that reads an XML file to configure
the valid users, passwords, and roles.
RuleSet for recognizing the users defined in the
XML file processed by
MemoryRealm.Concrete implementation of
UserDatabase that loads all defined users,
groups, and roles into an in-memory data structure, and uses a specified XML
file for its persistent storage.JNDI object creation factory for
MemoryUserDatabase
instances.A ModelMBean implementation for the
org.apache.catalina.users.MemoryUserDatabase component.This class is used to represent a subarray of bytes in an HTTP message.
Representation of a message destination for a web application, as
represented in a
<message-destination> element
in the deployment descriptor.Representation of a message destination reference for a web application,
as represented in a
<message-destination-ref> element
in the deployment descriptor.This credential handler supports the following forms of stored passwords:
encodedCredential - a hex encoded digest of the password digested
using the configured digest
{MD5}encodedCredential - a Base64 encoded MD5 digest of the
password
{SHA}encodedCredential - a Base64 encoded SHA1 digest of the
password
{SSHA}encodedCredential - 20 byte Base64 encoded SHA1 digest
followed by variable length salt.
The message dispatcher is a way to enable asynchronous communication
through a channel.
Title: MessageListener
An
Expression that refers to a method on an object.Memory-efficient repository for Mime Headers.
Utility class to decode MIME texts.
Mmap
Source for descriptor data.
Multicast
EXPERIMENTAL AND NOT YET COMPLETE!
Representation of a the multipart configuration for a servlet.
Low level API for processing file uploads.
Thrown upon attempt of setting an invalid boundary token.
Thrown to indicate that the input stream fails to follow the
required syntax.
Internal class, which is used to invoke the
ProgressListener.Deprecated.
This will be removed in Tomcat 10
Wraps a list of throwables as a single throwable.
Parses names.
Catalina JNDI Context implementation.
Naming enumeration implementation.
Naming enumeration implementation.
Helper class used to initialize and populate the JNDI context associated
with each context and server.
Represents a binding in a NamingContext.
Defines an interface for the object that is added to the representation of a
JNDI resource in web.xml to enable it to also be the implementation of that
JNDI resource.
Holds and manages the naming resources defined in the J2EE Enterprise
Naming Context and their associated JNDI context.
A ModelMBean implementation for the
org.apache.catalina.deploy.NamingResourcesImpl component.Store server.xml elements Resources at context and GlobalNamingResources
RuleSet for processing the JNDI Enterprise Naming
Context resource declaration elements.
A class representing a CIDR netmask.
Base class for a SocketChannel wrapper used by the endpoint.
NIO2 endpoint.
SendfileData class.
Base class for a SocketChannel wrapper used by the endpoint.
NIO tailored thread pool, providing the following services:
Socket acceptor thread
Socket poller thread
Worker threads pool
When switching to Java 5, there's an opportunity to use the virtual
machine's thread pool.
PollerEvent, cacheable object for poller events to avoid GC
SendfileData class.
A worker thread class which can drain channels and echo-back the input.
Thread safe non blocking selector pool
This class is NOT thread safe and should never be used with more than one thread at a time
This is a state machine, handled by the process method
States are:
- NOT_CONNECTED -> connect() -> CONNECTED
- CONNECTED -> setMessage() -> READY TO WRITE
- READY_TO_WRITE -> write() -> READY TO WRITE | READY TO READ
- READY_TO_READ -> read() -> READY_TO_READ | TRANSFER_COMPLETE
- TRANSFER_COMPLETE -> CONNECTED
An implementation of the MBean registry that effectively disables MBean
registration.
Title: Auto merging leader election algorithm
When using a
JarInputStream with an XML parser, the stream will be
closed by the parser.An Authenticator and Valve implementation that checks
only security constraints not involving user authentication.
CallStack strategy using no-op implementations of all functionality.
Internal configuration information for a
Notification
descriptor.Minimal Realm implementation that always returns null when an attempt is made
to validate a user name and password.
Rule implementation that creates a new object and pushes it
onto the object stack.
Interface for use with
FactoryCreateRule.A pooling simple interface.
The object reader object is an object used in conjunction with
java.nio TCP messages.
Provides same information as default log format but on a single line to make
it easier to grep the logs.
Object factory for EJBs.
Class in charge with parsing openSSL expressions to define a list of ciphers.
Store OpenSSLConf
Implements a
SSLEngine using
OpenSSL
BIO abstractions.OpenSSL specific
SSLSessionContext implementation.Stats exposed by an OpenSSL session context.
Internal configuration information for an
Operation
descriptor.A class to hold all init parameters specific to the JSP engine.
The order interceptor guarantees that messages are received in the same order they were
sent.
OS
The buffer used by Tomcat response.
Output buffer.
Output filter.
Implementation of the PageContext class from the JSP spec.
Internal configuration information for a
Parameter
descriptor.Implementation of java.util.Map that includes a
locked property.A simple parser intended to parse sequences of name/value pairs.
Concrete implementation of the
UserDatabase interface
that processes the /etc/passwd file on a Unix system.PasswordCallback Interface
RFC 1421 PEM file containing X509 certificates or private keys.
This interface is implemented by components to enable privileged code to
check whether the component has a given permission.
Implementation of the Manager interface that makes use of
a Store to swap active Sessions to disk.
Extends the
ManagerBase class to implement most of the
functionality required by a Manager which supports any kind of
persistence, even if only for restarts.store server.xml PersistentManager element with nested "Store"
Utility class for the loading and saving of JASPIC persistent provider
registrations.
Valve that implements per-request session persistence.
A pooling
DataSource appropriate for deployment within J2EE environment.A JNDI ObjectFactory which creates
SharedPoolDataSourcesInterface describing a collection of Valves that should be executed
in sequence when the
invoke() method is invoked.Base implementation (client and server have different concrete
implementations) of the wrapper that converts a POJO instance into a
WebSocket endpoint instance.
Wrapper class for instances of POJOs annotated with
ClientEndpoint so they appear as standard
Endpoint instances.Wrapper class for instances of POJOs annotated with
ServerEndpoint so they appear as standard
Endpoint instances.Common implementation code for the POJO message handlers.
Common implementation code for the POJO partial message handlers.
ByteBuffer specific concrete implementation for handling partial messages.
Text specific concrete implementation for handling partial messages.
Common implementation code for the POJO whole message handlers.
ByteBuffer specific concrete implementation for handling whole messages.
PongMessage specific concrete implementation for handling whole messages.
Text specific concrete implementation for handling whole messages.
For a POJO class annotated with
ServerEndpoint, an instance of this class
creates and caches the method handler, method information and parameter
information for the onXXX calls.Stores the parameter type and name for a parameter that needs to be passed to
an onXxx method of
Endpoint.Poll
Pool
A
DelegatingCallableStatement that cooperates with PoolingConnection to implement a pool of
CallableStatements.A delegating connection that, rather than closing the underlying connection, returns itself to an
ObjectPool
when closed.A
PooledObjectFactory that creates PoolableConnections.Defines the attributes and methods that will be exposed via JMX for
PoolableConnection instances.PoolableConnection that unregisters from TransactionRegistry on Connection real destroy.
A
PoolableConnectionFactory that creates PoolableManagedConnections.A
DelegatingPreparedStatement that cooperates with PoolingConnection to implement a pool of
PreparedStatements.PoolCallback Interface
A list of properties that are configurable for a connection pool.
Represents a pooled connection
and holds a reference to the
Connection objectDeprecated.
This will be removed in Tomcat 10
Defines the wrapper that is used to track the additional information, such as
state, for the pooled objects.
An interface defining life-cycle methods for instances to be served by an
ObjectPool.Provides the possible states that a
PooledObject may be in.Extension of
DefaultPooledObject to wrap pooled soft references.A
DelegatingConnection that pools PreparedStatements.Statement types.
This class consists exclusively of static methods that operate on or return
ObjectPool or KeyedObjectPool related interfaces.
Proc
Procattr
ProcErrorCallback Interface
Common interface for processors of all protocols.
The
ProgressListener may be used to display a progress bar
or do stuff like that.Maps EL functions to their Java method counterparts.
Used when we need to indicate failure but the (Servlet) API doesn't declare
any appropriate exceptions.
Abstract the protocol implementation, including threading, etc.
A ProxyConnection object is the bottom most interceptor that wraps an object of type
PooledConnection.A key uniquely identifying
PreparedStatements.Deprecated.
Use
PStmtKey.A Realm is a read-only facade for an underlying security realm
used to authenticate individual users, and identify the security roles
associated with those users.
Simple implementation of Realm that reads an XML file to configure
the valid users, passwords, and roles.
RuleSet for processing the contents of a Realm definition
element.
Store server.xml Element Realm
Utilities for Managing Serialization and Reflection
Windows Registry support
Registry for modeler MBeans.
Interface for modeler MBeans.
Ant task that implements the
/reload command, supported by the
Tomcat manager application.Concrete implementation of
RequestFilter that filters
based on the string representation of the remote client's IP address.Concrete implementation of
RequestFilterValve that filters
based on the string representation of the remote client's IP address
optionally combined with the server connector port number.Concrete implementation of
RequestFilter that filters
based on the remote client's host name.Concrete implementation of
RequestFilterValve that filters
based on the remote client's host name optionally combined with the
server connector port number.
Servlet filter to integrate "X-Forwarded-For" and "X-Forwarded-Proto" HTTP headers.
Tomcat port of mod_remoteip, this valve replaces the apparent
client remote IP address and hostname for the request with the IP address list presented by a proxy or a load balancer via a request
headers (e.g.
Title: RemoteProcessException
All-to-all replication for a hash map implementation.
For smarter replication, an object can implement this interface to replicate diffs
The replication logic will call the methods in the following order:
The replication logic will call the methods in the following order:
1. if ( entry.isDirty() )
try {
2.This is a marker interface used to indicate an implementation of
SessionListener that should be replicated with the session across the
cluster.Custom subclass of
ObjectInputStream that loads from the
class loader for this web application.Transmit message to other cluster members
Actual senders are created based on the replicationMode
type
Implementation of a Valve that logs interesting contents from the
specified Request (before processing) and the corresponding Response
(after processing).
Wrapper object for the Coyote request.
This is a low-level, efficient representation of a server request.
Abstracts access to the request information needed for file uploads.
Implementation of a Filter that logs interesting contents from the
specified Request (before processing) and the corresponding Response
(after processing).
Facade class that wraps a Coyote request object.
Implementation of a Filter that performs filtering based on comparing the
appropriate request property (selected based on which subclass you choose
to configure into your Container's pipeline) against the regular expressions
configured for this Filter.
Implementation of a Valve that performs filtering based on comparing the
appropriate request property (selected based on which subclass you choose
to configure into your Container's pipeline) against the regular expressions
configured for this Valve.
This can be moved to top level ( eventually with a better name ).
Structure holding the Request and Response objects.
General purpose request parsing and encoding utility methods.
Class that resets the abandoned timer on any activity on the
Connection or any successful query executions.
Resolver abstract class.
Representation of an Context element
Resource entry.
Object factory for Resources env.
Represents a reference address to a resource environment.
Object factory for Resources.
Object factory for resource links.
Represents a reference address to a resource.
Represents a reference address to a resource.
Extended implementation of HashSet that includes a
locked property.Ant task that implements the
/resources command, supported by
the Tomcat manager application.Wrapper object for the Coyote response.
A response object holds a message from a responding partner.
Response object.
Facade class that wraps a Coyote response object.
An HttpServletResponseWrapper, used from
SSIServletExternalResolverProvides basic CSRF protection for REST APIs.
Interface for user defined lookup/replacement logic that can be defined in
a
rewrite.config file by a RewriteMap directive.Note: Extra caution should be used when adding a Rewrite Rule.
Utility class to decode/encode character set on HTTP Header fields based on RFC 2231.
Abstract representation of a security role, suitable for use in
environments like JAAS that want to deal with
Principals.A ModelMBean implementation for the
org.apache.catalina.Role component.The RpcCallback interface is an interface for the Tribes channel to request a
response object to a request that came in.
A channel to handle RPC messaging
Class that holds all response.
Concrete implementations of this class implement actions to be taken when
a corresponding nested pattern of XML elements has been matched.
Public interface defining a collection of Rule instances (and corresponding
matching patterns) plus an implementation of a matching policy that selects
the rules that match a particular pattern of nested elements discovered
during parsing.
Default implementation of the
Rules interface that supports
the standard rule matching behavior.Public interface defining a shorthand means of configuring a complete
set of related
Rule definitions, possibly associated with
a particular namespace URI, in one operation.A very simple thread pool class.
Provides a
ForkJoinPool.ForkJoinWorkerThreadFactory that provides ForkJoinWorkerThreads that won't trigger memory leaks due to retained
references to web application class loaders.Object that saves the critical information from a request so that
form-based authentication can reproduce it once the user has been
authenticated.
Input filter responsible for replaying the request body when restoring the
saved request after FORM authentication.
Class which wraps a ScheduledExecutorService, while preventing
lifecycle and configuration operations.
Implementation of a secure socket channel for NIO2.
Implementation of a secure socket channel
Static class used to preload java classes when using the
Java SecurityManager so that the defineClassInPackage
RuntimePermission does not trigger an AccessControlException.
Static class used to preload java classes when using the
Java SecurityManager so that the defineClassInPackage
RuntimePermission does not trigger an AccessControlException.
Representation of a web resource collection for a web application's security
constraint, as represented in a
<web-resource-collection>
element in the deployment descriptor.Util class to protect Catalina against package access and insertion.
Representation of a security constraint element for a web application,
as represented in a
<security-constraint> element in the
deployment descriptor.CallStack strategy using a
SecurityManager.Representation of a security role reference for a web application, as
represented in a
<security-role-ref> element
in the deployment descriptor.This utility class associates a
Subject to the current
AccessControlContext.Util class for Security related operations.
Catalina JNDI Context implementation.
Implementation of a Valve that limits concurrency.
Interface to send data to proxies.
Generate Sender Element
Factory class that creates a JNDI named javamail MimePartDataSource
object which can be used for sending email using SMTP.
A
Server element represents the entire Catalina
servlet container.Server-side cookie representation.
This class is not thread-safe.
Simple utility module to make it easy to plug in the server identifier
when integrating Tomcat.
Ant task that implements the
/serverinfo command
supported by the Tomcat manager application.A Service is a group of one or more
Connectors that share a single Container
to process their incoming requests.
Object proxy for Web Services.
Represents a reference web service.
Object factory for Web Services.
Representation of a servlet definition for a web application, as represented
in a
<servlet> element in the deployment descriptor.High level API for processing file uploads.
Provides access to the request information needed for a request made to
an HTTP servlet.
ServletResponseWrapper used by the JSP 'include' action.
This is what is used to generate servlets.
A Session is the Catalina-internal facade for an
HttpSession that is used to maintain state information
between requests for a particular user of a web application.Representation of a session configuration element for a web application,
as represented in a
<session-config> element in the
deployment descriptor.General event for notifying listeners of significant changes on a Session.
A
Filter that initializes the HttpSession for
the HttpServletRequest by calling its getSession() method.Interface defining a listener for significant Session generated events.
Class Description:
The SessionMessage class is a class that is used when a session has been created, modified, expired in a Tomcat cluster node.
The following events are currently available:
The SessionMessage class is a class that is used when a session has been created, modified, expired in a Tomcat cluster node.
The following events are currently available:
Session cluster message
Ant task that implements the
/sessions command
supported by the Tomcat manager application.Utility methods on HttpSessions...
Deprecated.
This will be removed in Tomcat 10
Example filter that sets the character encoding to be used in parsing the
incoming request, either unconditionally or only if the client did not
specify a character encoding.
Deprecated.
This will be removed in Tomcat 10
Rule implementation that calls a method on the (top-1) (parent)
object, passing the top object (child) as an argument.
Rule implementation that calls a method on the (top-1) (parent)
object, passing the top object (child) as an argument.
Rule implementation that sets properties on the object at the top of the
stack, based on attributes with corresponding names.
A pooling
DataSource appropriate for deployment within J2EE environment.A JNDI ObjectFactory which creates
SharedPoolDataSourcesShm
Basic implementation primarily intended for use when using third-party
ServerAuthModule implementations
that only provide the module.A dinky coordinator, just uses a sorted version of the member array.
SimpleInstanceManager
Implement the org.apache.tomcat.InstanceManager interface.
Basic implementation primarily intended for use when using third-party
ServerAuthModule implementations that only provide the module.Basic implementation primarily intended for use when using third-party
ServerAuthModule implementations that only provide the module.A Cluster implementation using simple multicast.
A Valve that supports a "single sign on" user experience,
where the security identity of a user who successfully authenticates to one
web application is propagated to other web applications in the same
security domain.
A class that represents entries in the cache of authenticated users.
Key used by SSO to identify a session.
This exception is thrown, if a requests permitted size
is exceeded.
Thrown to indicate that the request size exceeds the configured maximum.
Slow query report interceptor.
Compare QueryStats by their lastInvocation value.
Publishes data to JMX and provides notifications
when failures happen.
Represents the line and file mappings associated with a JSR-045
"stratum".
Contains static utilities for generating SMAP data based on the
current version of Jasper.
Sockaddr
Socket
Defines events that occur per socket that require further processing by the
container.
Properties that can be set in the <Connector> element
in server.xml.
A
SoftReference based
ObjectPool.A SPNEGO authenticator that uses the SPNEGO/Kerberos support built in to Java
6.
This class gets a gss credential via a privileged action.
This class implements a hack around an incompatibility between the
SPNEGO implementation in Windows and the SPNEGO implementation in Java 8
update 40 onwards.
An SQLException based on a list of Throwable causes.
The interface that all SSI commands ( SSIEcho, SSIInclude, ...) must
implement.
SSI command that handles all conditional directives.
Implements the Server-side #exec command
Return the result associated with the supplied Server Variable.
Implements the Server-side #exec command
Interface used by SSIMediator to talk to the 'outside world' ( usually a
servlet )
Filter to process SSI requests within a webpage.
Implements the Server-side #flastmod command
Implements the Server-side #fsize command
Implements the Server-side #include command
Allows the different SSICommand implementations to share data/talk to each
other
Implements the Server-side #printenv command
The entry point to SSI processing.
Servlet to process SSI requests within a webpage.
An implementation of SSIExternalResolver that is used with servlets.
Implements the Server-side #set command
Exception used to tell SSIProcessor that it should stop processing SSI
commands.
SSL
An Authenticator and Valve implementation of authentication
that utilizes SSL certificates to identify client users.
SSL Conf
Ant task that implements the
/sslConnectorCiphers command
supported by the Tomcat manager application.SSL Context
This interface is needed to override the default SSLContext class
to allow SSL implementation pluggability without having to use JCE.
Interface implemented by components that will receive the call back to
select an OpenSSL SSLContext based on the host name requested by the
client.
Represents the TLS configuration for a virtual host.
Store SSLHostConfig
Provides a factory and base implementation for the Tomcat specific mechanism
that allows alternative SSL/TLS implementations to be used without requiring
the implementation of a full JSSE provider.
Defines an interface used to manage SSL sessions.
SSL Socket
Defines an interface to interact with SSL sessions.
Provides a common interface for
SSLImplementations to create the
necessary JSSE implementation objects for TLS connections created via the
JSSE API.Optional interface that can be implemented by
SSLEngines to indicate that they support ALPN and
can provided the protocol agreed with the client.Common base class for
SSLUtil implementations.When using mod_proxy_http, the client SSL information is not included in the
protocol (unlike mod_jk and mod_proxy_ajp).
Standard implementation of the Context interface.
Store server.xml Context element with all children
Store all context at server.xml
Store existing app.xml context a conf/enginename/hostname/app.xml
Store with backup
Standard implementation of the Engine interface.
Store server.xml Element Engine
Standard implementation of the Host interface.
Store server.xml Element Host
The default
JarScanner implementation scans the WEB-INF/lib directory
followed by the provided classloader and then works up the classloader
hierarchy.Standard implementation of the Manager interface that provides
simple session persistence across restarts of this component (such as
when the entire server is shut down and restarted, or when a particular
web application is reloaded.
Standard implementation of a processing Pipeline that will invoke
a series of Valves that have been configured to be called in order.
Provides the resources implementation for a web application.
Standard implementation of the Server interface, available for use
(but not required) when deploying and starting Catalina.
Store server.xml Server element and children (
Listener,GlobalNamingResource,Service)
Standard implementation of the
Service interface.Store server.xml Element Service and all children
Standard implementation of the Session interface.
Facade for the StandardSession object.
Standard implementation of the Wrapper interface that represents
an individual servlet definition.
Facade for the StandardWrapper object.
Ant task that implements the
/start command, supported by the
Tomcat manager application.Interceptor that caches
PreparedStatement and/or
CallableStatement instances on a connection.Implementation of JdbcInterceptor that proxies resultSets and statements.
Keeps track of statements associated with a connection and invokes close upon
Connection.close()
Useful for applications that don't close the associated statements after being done with a connection.Status
This servlet will display a complete status of the HTTP/1.1 connector.
This is a refactoring of the servlet to externalize
the output into a simple class.
Stdlib
A custom
RuntimeException thrown by the ThreadPoolExecutor
to signal that the thread should be disposed of.Ant task that implements the
/stop command, supported by the
Tomcat manager application.A Store is the abstraction of a Catalina component that provides
persistent storage and loading of Sessions and their associated user data.
StoreAppends generate really the xml tag elements
Store Server/Service/Host/Context at file or PrintWriter.
Loads and registers a StoreConfig MBean with the name
Catalina:type=StoreConfig.
store StandardContext Attributes ...
Bean of a StoreDescription
StoreFactory saves special elements.
Rule that creates a new
IStoreFactory instance, and associates
it with the top object on the stack (which must implement
IStoreFactory).Move server.xml or context.xml as backup
TODO Get Encoding from Registry
XML Format
PersistentManager would have been a better name but that would have clashed
with the implementation name.
Central StoreRegistry for all server.xml elements
Utility class for working with streams.
Converts dates to strings using the same format specifiers as strftime
Note: This does not mimic strftime perfectly.
This class implements a String cache for ByteChunk and CharChunk.
Defines the interface for the String interpreter.
Provides an optimised conversion of string values to Enums.
Provides
StringInterpreter instances for JSP compilation.An internationalization / localization helper class which reduces
the bother of handling ResourceBundles and takes care of the
common cases of message formatting which otherwise require the
creation of Object arrays and such.
An internationalization / localization helper class which reduces
the bother of handling ResourceBundles and takes care of the
common cases of message formatting which otherwise require the
creation of Object arrays and such.
An internationalization / localization helper class which reduces
the bother of handling ResourceBundles and takes care of the
common cases of message formatting which otherwise require the
creation of Object arrays and such.
Utility methods to build a separated list from a given set (not
java.util.Set) of inputs and return that list as a string or append it to an
existing StringBuilder.
Converts String to and from bytes using the encodings required by the Java specification.
This valve allows to detect requests that take a long time to process, which
might indicate that the thread that is processing it is stuck.
Pools that unavoidably swallow exceptions may be configured with an instance
of this listener so the user may receive notification of when this happens.
Class for logging swallowed exceptions.
This is intended as a (mostly) GC-free alternative to
ConcurrentLinkedQueue when the requirement is to
create an unbounded queue with no requirement to shrink the queue.This is intended as a (mostly) GC-free alternative to
ConcurrentLinkedQueue when the requirement is to
create a pool of re-usable objects with no requirement to shrink the pool.This helper class may be used to do sophisticated redirection of
System.out and System.err on a per Thread basis.
Bare-bone model of a tag file loaded from a TLD.
Pool of tag handlers that can be reused.
Common representation of a Tag Library Descriptor (TLD) XML file.
This interface is to be implemented by the plugin author, to supply
an alternate implementation of the tag handlers.
This interface allows the plugin author to make inquiries about the
properties of the current tag, and to use Jasper resources to generate
direct Java codes in place of tag handler invocations.
Manages tag plugin optimizations.
Parser for Tag Plugin descriptors.
Model of a tag define in a tag library descriptor.
As task queue specifically designed to run with a thread pool executor.
A Thread implementation that records the time at which it was created.
Simple task thread factory to use to create threads for an executor
implementation.
ThreadFactory implementation that creates threads with the thread context
class loader set to the class loader that loaded this factory.
Title: A perfect failure detector
Sends a ping to all members.
Thread
Callback for establishing naming association when entering the application
scope.
Ant task that implements the
/threaddump command
supported by the Tomcat manager application.
A
LifecycleListener that triggers the renewal of threads in Executor
pools when a Context is being stopped to avoid thread-local related
memory leaks.Same as a java.util.concurrent.ThreadPoolExecutor but implements a much more efficient
ThreadPoolExecutor.getSubmittedCount() method, to be used to properly handle the work queue.An output stream which triggers an event when a specified number of bytes of
data have been written to it.
CallStack strategy that uses the stack trace from a
Throwable.Time
This class caches parsed instances of TLD files to remove the need for the
same TLD to be parsed for each JSP that references it.
Parses a Tag Library Descriptor.
A TLD Resource Path as defined in JSP 7.3.2.
RulesSet for digesting TLD files.
Scans for and loads Tag Library Descriptors contained in a web application.
Deprecated.
Unused.
This class extracts the SNI host name and ALPN protocols from a TLS
client-hello message.
Minimal tomcat starter for embedding/unit tests.
Fix reload - required if reloading and using programmatic configuration.
Helper class for wrapping existing servlets.
Fix startup sequence - required if you don't use web.xml.
The purpose of this sub-class is to obtain references to the JarEntry objects
for META-INF/ and META-INF/MANIFEST.MF that are otherwise swallowed by the
JarInputStream implementation.
General purpose wrapper for command line tools that should execute in an
environment with the common class loader environment set up by Catalina.
An exception that indicates the maximum number of active sessions has been
reached and the server is refusing to create any new sessions.
Utility class used to help generate return values for calls to
Object.toString().This interface allows pooled objects to make information available about when
and how they were used available to the object pool.
TransactionContext represents the association between a single XAConnectionFactory and a Transaction.
A listener for transaction completion events.
Object factory for User transactions.
Represents a reference address to a transaction.
TransactionRegistry tracks Connections and XAResources in a transacted environment for a single XAConnectionFactory.
The internal representation of the transformation that a WebSocket extension
performs on a message.
Interceptor that traps any unhandled exception types and throws an exception that has been declared by the method
called, or throw an SQLException if it is declared.
Ant task to convert a given set of files from Text to HTML.
All URL decoding happens here.
Efficient implementation of a UTF-8 encoder.
Ant task that implements the
/undeploy command, supported by
the Tomcat manager application.Wraps the default attributes implementation and ensures that each attribute
has a unique qname as required by the JSP specification.
Title: Represents a globally unique Id
This aggregates the data collected from each UpgradeInfo instance.
Structure to hold statistical information about connections that have been
established using the HTTP/1.1 upgrade mechanism.
Token used during the upgrade process.
Enhanced access to the request information needed for file uploads,
which fixes the Content Length data access in
RequestContext.Extracts path parameters from URIs used to create web socket connections
using the URI template defined for the associated Endpoint.
Utility class for working with URIs and URLs.
This class is very similar to the java.net.URLEncoder class.
Implementation of
Jar that is optimised for
non-file based JAR URLs.This interface may be implemented by an object pool to enable clients
(primarily those clients that wrap pools to provide pools with extended
features) to provide additional information to the pool relating to object
using allowing more informed decisions and reporting to be made regarding
abandoned objects.
Abstract representation of a user in a
UserDatabase.User
Startup event listener for a Host that configures Contexts (web
applications) for all defined "users" who have a web application in a
directory with the specified name in their home directories.
Abstraction of the set of users defined by the operating system on the
current server platform.
Implementation of
Realm that is based on an
implementation of UserDatabase made available through the JNDI
resources configured for this instance of Catalina.This helper class assists with the logging associated with invalid input
data.
Log mode for the next log message.
A ModelMBean implementation for the
org.apache.catalina.User component.Decodes bytes to UTF-8.
Encodes characters as bytes using UTF-8.
Util contains some often used consts, static methods and embedded class
to support the JSTL tag plugin.
Utility class for internal use only within the
org.apache.tomcat.websocket package.Wraps responses to allow us to retrieve results as Strings.
Utility methods.
simple generation of a UUID
Interface to be implemented by custom validator classes.
Task for validating a web application deployment descriptor, using XML
schema validation.
Model of a Tag Library Validator from the XML descriptor.
An
Expression that can get or set a value.A Valve is a request processing component associated with a
particular Container.
Convenience base class for implementations of the Valve interface.
Deprecated.
Deprecated.
Use
TokenList.Outputs the just the log message with no additional elements.
Logs version information on startup.
Ant task that implements the
/vminfo command
supported by the Tomcat manager application.Void input filter, which returns -1 when attempting a read.
Void output filter, which silently swallows bytes written.
Represents a single resource (file or directory) that is located within a
WAR.
Represents a
WebResourceSet based on a WAR file.The WarWatcher watches the deployDir for changes made to the
directory (adding new WAR files->deploy or remove WAR files->undeploy)
and notifies a listener of the changes made.
File name filter for war files
File information on existing WAR files
AnnotationSet for processing the annotations of the web
application classes (
/WEB-INF/classes and
/WEB-INF/lib).Specialized web application class loader.
Classloader implementation which is specialized for handling web
applications in the most efficient way, while being Catalina aware (all
accesses to resources are made through
WebResourceRoot).An interface intended for use by class loaders associated with a web
application that enables them to provide additional information to JULI about
the web application with which they are associated.
A variation of Java's JAR ServiceLoader that respects exclusion rules for
web applications.
Filter that attempts to force MS WebDAV clients connecting on port 80 to use
a WebDAV client that actually works.
Represents a file or directory within a web application.
Represents the complete set of resources for a web application.
Generate Resources element
Represents a set of resources that are part of a web application.
RuleSet for processing the contents of a web application
deployment descriptor (
/WEB-INF/web.xml) resource.Representation of common elements of web.xml and web-fragment.xml.
A Wrapper is a Container that represents an individual servlet
definition from the deployment descriptor of the web application.
Encapsulates information used to register a Wrapper mapping.
Provides an expandable set of buffers for writes.
Interface implemented by clients of the WriteBuffer to enable data to be
written back out from the buffer.
In normal usage, this
ServletContextListener does not need to be
explicitly configured as the WsSci performs all the necessary
bootstrap and installs this listener in the ServletContext.Handles the initial HTTP connection for WebSocket connections.
Takes the ServletInputStream, processes the WebSocket frames it contains and
extracts the messages.
WAITING - not suspended
Server case: waiting for a notification that data
is ready to be read from the socket, the socket is
registered to the poller
Client case: data has been read from the socket and
is waiting for data to be processed
PROCESSING - not suspended
Server case: reading from the socket and processing
the data
Client case: processing the data if such has
already been read and more data will be read from
the socket
SUSPENDING_WAIT - suspended, a call to suspend() was made while in
WAITING state.
Represents the request that this session was opened under.
Represents the response to a WebSocket handshake.
Servlet 3.1 HTTP upgrade handler for WebSocket connections.
Allows the WebSocket implementation to throw an
IOException that
includes a CloseReason specific to the error that can be passed back
to the client.This is the server side
RemoteEndpoint implementation
- i.e. what the server uses to send data to the client.Registers an interest in any class that is annotated with
ServerEndpoint so that Endpoint can be published via the WebSocket
server.Provides a per class loader (i.e. per web application) instance of a
ServerContainer.
Provides timeouts for asynchronous web socket writes.
An X509UsernameRetriever that returns a certificate's entire
SubjectDN as the username.
Provides an interface for retrieving a user name from an X509Certificate.
XAConnectionFactory is an extension of ConnectionFactory used to create connections in a transaction managed
environment.
The XByteBuffer provides a dual functionality.
Base class for those elements that need to track the encoding used in the
source XML.
Defines constants for well-known Public and System identifiers documented by
the Servlet and JSP specifications.
XMLWriter helper class.