All Classes and Interfaces
Class
Description
Abstract push response handler.
Abstract asynchronous request consumer that makes use of
AsyncEntityConsumer
to process request message content.Abstract asynchronous response consumer that makes use of
AsyncEntityConsumer
to process response message content.Abstract asynchronous HTTP request filter that implements standard HTTP authentication handshake.
Abstract binary entity content consumer.
Abstract binary entity content producer.
Abstract binary data consumer.
Abstract text entity content consumer.
Abstract text entity content producer.
Abstract text data consumer.
AsyncEntityConsumer implementation that acts as a compatibility
layer for classic InputStream based interfaces.AsyncEntityProducer implementation that acts as a compatibility
layer for classic OutputStream based interfaces.AsyncServerExchangeHandler implementation that acts as a compatibility
layer for classic InputStream / OutputStream based interfaces.Abstract
ContentDecoder that serves as a base for all content
decoder implementations.Abstract
ContentEncoder that serves as a base for all content
encoder implementations.Iterator of HeaderElements.Abstract base class for mutable entities.
Abstract HTTP request filter that implements standard HTTP authentication handshake.
Abstract
HttpMessage builder.Abstract base class for HTTP message parsers that obtain input from
an instance of
SessionInputBuffer.Abstract
NHttpMessageParser that serves as a base for all message
parser implementations.Abstract
HttpMessage wrapper.Abstract base class for HTTP message writers that serialize output to
an instance of
SessionOutputBuffer.Abstract
NHttpMessageWriter that serves as a base for all message
writer implementations.Builder for
BasicHttpRequest instances.Builder for
BasicHttpRequest instances.Abstract server side message exchange handler.
Supported application protocols.
Client endpoint leased from a connection manager.
Abstract asynchronous client side message exchange handler that acts as a request producer
and a response consumer.
Abstract asynchronous data consumer.
Abstract asynchronous data exchange handler that acts as a data consumer
and a data producer.
Abstract asynchronous data producer.
Abstract asynchronous message entity consumer.
Abstract asynchronous message entity producer.
{AsyncEntityProducer} factory methods.
Base class for wrapping entity producers that delegates all calls to the wrapped producer.
AsyncFilterChain represents a single element in the server side request processing chain.
Response trigger that can be used to generate the final HTTP response
and terminate HTTP request processing.
AsyncFilterHandler represents a routine for handling all incoming requests
in the server side request processing chain.
Abstract asynchronous ping exchange handler.
Builder for
AsyncPushProducer instances.Abstract asynchronous push response consumer.
Abstract asynchronous push response producer.
Builder for
AsyncRequestProducer instances.Abstract asynchronous request consumer.
Protocol agnostic client side I/O session initiator.
HttpAsyncRequester bootstrap.Abstract asynchronous request producer.
Builder for
AsyncResponseProducer instances.Abstract asynchronous response consumer.
Abstract asynchronous response producer.
Protocol agnostic server side I/O session handler.
HttpAsyncServer bootstrap.Abstract asynchronous server side message exchange handler that acts as a request consumer
and a response producer.
An element in an asynchronous request processing chain.
Factory for
AsyncServerExchangeHandler instances that delegate request processing
to a AsyncServerFilterChainElement.AsyncServerRequestHandler represents a routine for processing of a specific group
of HTTP requests.
Response trigger that can be used to submit a final HTTP response
and terminate HTTP request processing.
Basic
AsyncEntityConsumer implementation
that processes the data stream content into a byte array.Basic
AsyncEntityProducer implementation that generates data stream
from content of a byte array.AsyncServerExchangeHandler implementation that adds support
for the Expect-Continue handshake to an existing
AsyncServerExchangeHandler.Basic implementation of
ClassicHttpRequest.Basic implementation of
ClassicHttpResponse.Basic
AsyncClientExchangeHandler implementation that makes use
of AsyncRequestProducer to generate request message
and AsyncResponseConsumer to process the response message returned by the server.Basic client-side implementation of
TlsStrategy that upgrades to TLS for all endpoints
with HTTPS scheme.Basic HTTP connection endpoint details.
Basic HTTP message entity details.
Basic implementation of the
Future interface.Default implementation of
H2TransportMetrics.Immutable
Header.Basic implementation of
HeaderElementIterator of HeaderElements.Default
HeaderValueFormatter implementation.Default
HeaderValueParser implementation.Default implementation of the
HttpConnectionMetrics interface.Default implementation of
HttpContext.A generic streamed, non-repeatable entity that obtains its content from an
InputStream.Basic implementation of
HttpRequest.Basic implementation of
HttpResponse.HttpServerRequestHandler implementation that adds support
for the Expect-Continue handshake to an existing
HttpServerRequestHandler.Basic
HttpServerRequestHandler implementation that makes use of
HttpRequestMapper to dispatch the request to a particular
HttpRequestHandler for processing.Default implementation of
HttpTransportMetrics.Default
LineFormatter implementation.Default
LineParser implementation.Basic implementation of
NameValuePair.Basic
AsyncPingHandler implementation.Basic implementation of
AsyncPushProducer that produces one fixed response
and relies on a AsyncEntityProducer to generate response entity stream.Builder for
BasicHttpRequest instances.Basic implementation of
AsyncRequestConsumer that represents the request message as
a Message and relies on a AsyncEntityConsumer to process request entity stream.Basic implementation of
AsyncRequestProducer that produces one fixed request
and relies on a AsyncEntityProducer to generate request entity stream.Builder for
BasicHttpResponse instances.Basic implementation of
AsyncResponseConsumer that represents response message as
a Message and relies on a AsyncEntityConsumer to process response entity
stream.Basic implementation of
AsyncResponseProducer that produces one fixed response
and relies on a AsyncEntityProducer to generate response entity stream.Basic
AbstractServerExchangeHandler implementation that delegates
request processing and response generation to a AsyncServerRequestHandler.Basic side-side implementation of
TlsStrategy that upgrades to TLS for endpoints
with the specified local ports.Abstract blocking HTTP connection interface.
A buffer that expand its capacity on demand.
This class represents a raw HTTP header whose content is parsed 'on demand'
only when the header value needs to be consumed.
A wrapping entity that buffers it content if necessary.
A resizable byte array.
A self contained, repeatable entity that obtains its content from a byte array.
An entity that delivers the contents of a
ByteBuffer.Abstract callback.
Convenience base class for
FutureCallbacks that contribute a result
of the operation to another FutureCallback.A
Cancellable represents a process or an operation that can be
canceled.This interface represents
Cancellable object dependent on another
ongoing process or operation.Abstract capacity update channel.
Builder class to build a linked list (chain) of unique class instances.
A resizable char array.
HTTP/1.1 char coding configuration.
Commons chars used by HTTP/1.1 protocol.
Implements chunked transfer decoding.
Implements chunked transfer coding.
Implements chunked transfer coding.
Implements chunked transfer coding.
'Classic'
HttpRequest message that can enclose HttpEntity.'Classic'
HttpResponse message that can enclose HttpEntity.Builder for
ClassicHttpRequest instances.Builder for
ClassicHttpResponse instances.IOEventHandler that implements
client side HTTP/2 messaging protocol with full support for
multiplexed message transmission.I/O event handler for events fired by
ProtocolIOSession that implements
client side of the HTTP/2 protocol negotiation handshake always forcing the choice
of HTTP/2.I/O event handler for events fired by
ProtocolIOSession that implements
client side HTTP/2 messaging protocol with full support for
multiplexed message transmission.ClientH2StreamMultiplexer factory.Protocol upgrade handler that upgrades the underlying
ProtocolIOSession
to HTTP/2 in case of a successful protocol negotiation.IOEventHandler that implements
client side HTTP/1.1 messaging protocol with full support for
duplexed message transmission and message pipelining.ClientHttp1IOEventHandler factory.I/O event handler for events fired by
ProtocolIOSession that implements
client side HTTP/1.1 messaging protocol with full support for
duplexed message transmission and message pipelining.ClientHttp1StreamDuplexer factory.Protocol upgrade handler that upgrades the underlying
ProtocolIOSession
to HTTP/1.1 in case of a successful protocol negotiation or as a default fall-back.Client I/O event starter that prepares I/O sessions for an initial protocol handshake.
This adapter expects a request to be made up of POJOs such as Maps and Lists.
Client endpoint that can be used to initiate HTTP message exchanges.
Close operation mode.
Closes resources.
Abstract command
IOSession can act upon.Command utility methods.Immutable, completed future.
Cancellable that has a dependency on another Cancellable
process or operation.Non-blocking connection acceptor.
Signals that the connection has been closed unexpectedly.
Non-blocking connection initiator.
Signals timeout requesting connection.
Interface for deciding whether a connection can be re-used for
subsequent requests and should be kept alive.
ConnPool represents a shared pool connections can be leased from
and released back to.Interface to control runtime properties of a
ConnPool such as
maximum total number of connections or maximum connections per route
allowed.Connection pool event listener.
Interface to obtain connection pool statistics.
Abstract HTTP content decoder.
Abstract HTTP content encoder.
Generic content input buffer.
InputStream adaptor for ContentInputBuffer.Input stream that cuts off after a defined number of bytes.
Output stream that cuts off after a defined number of bytes.
Represents a strategy to determine length of the enclosed content entity
based on properties of the HTTP message.
Generic content output buffer.
OutputStream adaptor for ContentOutputBuffer.Signals that HTTP entity content is too long.
Content type information consisting of a MIME type and an optional charset.
This annotation defines behavioral contract enforced at runtime by instances of annotated classes.
Abstract byte stream channel
A deadline based on a UNIX time, the elapsed since 00:00:00 Coordinated Universal Time (UTC), Thursday, 1 January
1970.
A specialization of
TimeoutException that carries a deadline and an actual value, both as UNIX times.Abstract decorator.
Default
HttpHost to InetSocketAddress resolver.Factory for
AsyncPushConsumer instances that make use
of HttpRequestMapper to dispatch
the request to a particular AsyncPushConsumer for processing.Factory for
AsyncServerExchangeHandler instances that make use
of HttpRequestMapper to dispatch
the request to a particular AsyncServerExchangeHandler for processing.Default implementation of
HttpClientConnection.Default factory for
HttpClientConnections.Builder for
DefaultBHttpClientConnectionFactory.Default implementation of
HttpServerConnection.Default factory for
HttpServerConnections.Builder for
DefaultBHttpServerConnectionFactory.Default factory for creating
ClassicHttpRequest objects.Default factory for creating
ClassicHttpResponse objects.Multi-core I/O reactor that can act as
ConnectionInitiator Internally
this I/O reactor distributes newly created I/O session equally across multiple
I/O worker threads for a more optimal resource utilization and a better
I/O performance.Default implementation of a strategy deciding about connection re-use.
The default implementation of the content length strategy.
Default implementation of
DisposalCallback.Default
FrameFactory implementation.HTTP/2 request converter.
HTTP/2 response converter.
Default immutable implementation of
HttpProcessor.Default factory for creating
HttpRequest objects.HTTP request parser that obtain its input from an instance
of
SessionInputBuffer.Default
NHttpMessageParser implementation for HttpRequests.Default factory for request message parsers.
Default factory for request message parsers.
HTTP request writer that serializes its output to an instance of
SessionOutputBuffer.Default
NHttpMessageWriter implementation for HttpRequests.Default factory for request message writers.
Default factory for request message writers.
Default factory for creating
HttpResponse objects.HTTP response parser that obtain its input from an instance
of
SessionInputBuffer.Default
NHttpMessageParser implementation for HttpResponses.Default factory for response message parsers.
Default factory for response message parsers.
HTTP response writer that serializes its output to an instance of
SessionOutputBuffer.Default
NHttpMessageWriter implementation for HttpResponses.Default factory for response message writers.
Default factory for response message writers.
Multi-core I/O reactor that can act as both
ConnectionInitiator
and ConnectionAcceptor.Default
ThreadFactory implementation.Default TLS session setup handler.
AsyncEntityConsumer decorator that calculates a digest hash from
the data stream content and keeps the list of trailers received with
the data stream.AsyncEntityProducer decorator that calculates a digest hash from
the data stream content and appends its value to the list of trailers.No-op
AsyncEntityConsumer that discards all data from the data stream.Represents a customizable disposal strategy for
ModalCloseable instances.Deprecated.
HTTP connection endpoint details.
Endpoint initialization parameters
English reason phrases for HTTP status codes.
Details of an entity transmitted by a message.
Entity that delegates the process of content generation to a
IOCallback
with OutputStream as output sink.Support methods for
HttpEntity.A stream wrapper that triggers actions on
close() and EOF.A watcher for
EofSensorInputStream.Type of I/O event notifications I/O sessions can declare interest in.
Abstract executable command that may need to do some cleaning up
in case of an failure and also optionally may want to cancel
the associated HTTP message exchange through
CancellableDependency.A buffer that expand its capacity on demand.
The field or method to which this annotation is applied is marked as experimental.
Abstract object factory.
A content decoder capable of transferring data directly to a
FileChannelA content encoder capable of transferring data directly from a
FileChannelA self contained, repeatable entity that obtains its content from a file.
AsyncEntityProducer implementation that generates data stream
from content of a File.Deprecated.
Use configuration parameters provided by connection listeners.
An HTTP header which is already formatted.
Abstract HTTP/2 data frame.
Values used by HTTP/2 protocol.
Standard HTTP/2 frame flags.
Frame input buffer for HTTP/2 blocking connections.
Frame input buffer for HTTP/2 non-blocking connections.
Frame output buffer for HTTP/2 blocking connections.
Frame output buffer for HTTP/2 non-blocking connections.
Standard HTTP/2 frame types.
A callback interface that gets invoked upon completion of
a
Future.Convenience base class for
FutureCallbacks that contribute a result
of the operation to another BasicFuture.Client side message exchange initiator capable of negotiating
HTTP/2 or HTTP/1.1 compatible connections.
Basic client-side implementation of
TlsStrategy that upgrades to TLS for all endpoints
with HTTPS scheme.HTTP/2 protocol configuration.
Signals fatal HTTP/2 protocol violation that renders the actual
HTTP/2 connection unreliable.
Pool of HTTP/2 message multiplexing capable connections.
Signals corrupt HTTP/2 frame.
Errors codes defined by HTTP/2 specification.
Abstract message converter intended to convert from a list of HTTP/2 headers to object
representing an HTTP message and from an object representing an HTTP message to a list
of HTTP/2 headers.
HTTP/2 multiplexing client side message exchange initiator.
H2MultiplexingRequester bootstrap.HTTP/2 protocol parameters.
Request pseudo HTTP headers defined by the HTTP/2 specification.
Response pseudo HTTP headers defined by the HTTP/2 specification.
HTTP/2 compatible extension of
RequestConnControl.HTTP/2 compatible extension of
RequestContent.H2AsyncRequester bootstrap.HTTP/2 compatible extension of
RequestTargetHost.HTTP/2 compatible extension of
RequestValidateHost.HTTP/2 compatible extension of
ResponseConnControl.HTTP/2 compatible extension of
ResponseContent.HTTP/2 capable
HttpAsyncServer bootstrap.Basic side-side implementation of
TlsStrategy that upgrades to TLS for endpoints
with the specified local ports.HTTP/2 protocol settings.
HTTP/2 stream event listener.
Signals HTTP/2 protocol error that renders the actual HTTP/2 data stream
unreliable.
HTTP/2 TLS support methods
The point of access to connection statistics.
Abstract handler factory.
Represents an HTTP header field consisting of a field name and a field
value.
Represents an element of an HTTP
header value consisting of
a name / value pair and a number of optional name / value parameters.Constants for frequently used Header elements.
A class for combining a set of headers.
Signals a header list constraint violation.
Interface for formatting elements of a header value.
Interface for parsing header values into elements.
Component that holds all details needed to describe a network connection
to a host.
HPACK decoder.
HPACK encoder.
Signals HPACK protocol violation.
Internal HPack header representation that also contains binary length of
header name and header value.
HTTP/1.1 protocol parameters.
HTTP/1.1 stream event listener.
HTTP/1.1 client side message exchange initiator.
HTTP/1.1 server side message exchange handler.
Main program of the HTTP benchmark.
A client-side HTTP connection, which can be used for sending
requests and receiving responses.
Handler that encapsulates the process of generating a response object
from a
ClassicHttpResponse.A generic HTTP connection, useful on client and server side.
IOEventHandler that also exposes HttpConnection properties.Factory for
HttpConnection instances.The point of access to the statistics of an
HttpConnection.HttpContext represents execution state of an HTTP process.
Implementation of
HttpContext that provides convenience
setters for user assignable attributes and getter for readable attributes.Generates a date in the format required by the HTTP protocol.
{HttpEntity} factory methods.
An entity that can be sent or received with an HTTP message.
Contains an
HttpEntity.Base class for wrapping entities that delegates all calls to the wrapped entity.
Signals that an HTTP exception has occurred.
HttpFilterChain represents a single element in the server side request processing chain.
Response trigger that can be used to generate the final HTTP response
and terminate HTTP request processing.
HttpFilterHandler represents a routine for handling all incoming requests
in the server side request processing chain.
Constants enumerating standard and common HTTP headers.
Component that holds all details needed to describe an HTTP connection
to a host.
HTTP messages consist of requests from client to server and responses
from server to client.
Message parser intended to build HTTP message head from an input stream.
Factory for
HttpMessageParser instances.Message writer intended to serialize HTTP message head to an output stream.
Factory for
HttpMessageWriter instances.HTTP protocol processor is a collection of protocol interceptors that
implements the 'Chain of Responsibility' pattern, where each individual
protocol interceptor is expected to work on a particular aspect of the HTTP
protocol the interceptor is responsible for.
Builder for
HttpProcessor instances.Factory class for standard
HttpProcessor instances.A request message from a client to a server includes, within the
first line of that message, the method to be applied to the resource,
the identifier of the resource, and the protocol version in use.
HTTP/1.1 client side message exchange initiator.
HttpRequestExecutor is a client side HTTP protocol handler based
on the blocking (classic) I/O model.Builder for
HttpRequestExecutor.A factory for
HttpRequest objects.HttpRequestHandler represents a routine for processing of a specific group
of HTTP requests.
HTTP protocol interceptor is a routine that implements a specific aspect of
the HTTP protocol.
This class can be used to resolve an object matching a particular
HttpRequest.Wraps an
HttpRequest.After receiving and interpreting a request message, a server responds
with an HTTP response message.
A factory for
HttpResponse objects.Informational (1xx) HTTP response callback.
HTTP protocol interceptor is a routine that implements a specific aspect of
the HTTP protocol.
Wraps an
HttpResponse.HTTP/1.1 server side message exchange handler.
A server-side HTTP connection, which can be used for receiving
requests and sending responses.
HttpServerExpectationFilter add support for the Expect-Continue handshake
to the request processing pipeline.
An element in a request processing chain.
HttpServerRequestHandler implementation that delegates request processing
to a HttpServerFilterChainElement.HttpServerRequestHandler represents a routine for processing of a specific group
of HTTP requests.
Response trigger that can be used to submit a final HTTP response
and terminate HTTP request processing.
HttpService is a server side HTTP protocol handler based on
the classic (blocking) I/O model.Builder for
HttpService.Constants enumerating the HTTP status codes.
Signals HTTP protocol error that renders the actual HTTP data stream unreliable.
Transport level metrics.
Represents an HTTP version.
HTTP protocol version policy.
This Huffman codec implementation has been derived from Twitter HPack project
(https://github.com/twitter/hpack)
This Huffman codec implementation has been derived from Twitter HPack project
(https://github.com/twitter/hpack)
This Huffman codec implementation has been derived from Twitter HPack project
(https://github.com/twitter/hpack)
This Huffman codec implementation has been derived from Twitter HPack project
(https://github.com/twitter/hpack)
Object with a unique identifier.
Content decoder that reads data without any transformation.
Content encoder that writes data without any transformation.
Input stream that reads data without any transformation.
Output stream that writes data without any transformation.
AsyncServerExchangeHandler implementation that immediately responds
with a predefined response generated by a AsyncResponseProducer and
ignores any entity content enclosed in the request message.HTTP message entity details.
A collection of utilities relating to InetAddresses.
A streamed, non-repeatable entity that obtains its content from an
InputStream.The package, class or method to which this annotation is applied is marked as internal
and its use ought to be avoided.
Abstract I/O callback.
IOEventHandler interface is used by I/O reactors to handle I/O events for individual
I/O sessions.
Factory interface to create
IOEventHandler instances for the given connected endpoints.HttpCore NIO is based on the Reactor pattern as described by Doug Lea.
I/O reactor configuration parameters.
IOReactor running as a service.Signals the I/O reactor has been shut down or is in the process of shutting down.
IOReactorStatus represents an internal status of an I/O reactor.
IOSession interface represents a sequence of logically related data exchanges
between two end points.
This enum represents a set of states I/O session transitions through
during its life-span.
IOSession event listener.Connection pool with higher concurrency but with lax connection limit guarantees.
Extension of
BasicLineParser that defers parsing of
header values.Extension of
BasicLineParser that defers parsing of
header values.Content decoder that cuts off after a defined number of bytes.
Content encoder that cuts off after a defined number of bytes.
Signals message rejection due to missing content length.
Interface for formatting elements of the HEAD section of an HTTP message.
Interface for parsing lines in the HEAD section of an HTTP message.
ListenerEndpoint interface represents an endpoint used by an I/O reactor
to listen for incoming connection from remote clients.
Generic lookup by low-case string ID.
A lookup registry.
Signals a malformed chunked stream.
Generic message consisting of a message head and a message body.
Signals a message constraint violation.
Messages head consisting of multiple message headers.
Support methods for HTTP message processing.
Common HTTP methods defined by the HTTP spec.
Signals that an HTTP method is not supported.
Signals a misdirected request (the server is not authoritative to handle the request).
Process or endpoint that can be closed either immediately or gracefully.
A
ResponseOutOfOrderStrategy implementation which checks for premature responses every MonitoringResponseOutOfOrderStrategy.chunkSize
bytes.Chain of doubly linked elements.
Endpoint identified by name (usually a fully qualified domain name) and port.
A name-value pair parameter used as an element of HTTP messages.
Message parser intended to build HTTP message head from a session input buffer..
Factory for
NHttpMessageParser instances.Message writer intended to serialize HTTP message head to a session buffer.
Factory for
NHttpMessageWriter instances.Signals that the target server failed to respond with a valid HTTP response.
Deprecated.
An implementation of
ResponseOutOfOrderStrategy which does not check for early responses.Signals an unsupported / unimplemented feature of the HTTP protocol.
An empty entity with no content-type.
The field or method to which this annotation is applied is marked as implementing
requirements of the HTTP protocol or a related protocol that are now obsolete.
Signals a protocol exception due to failure to parse a message element.
This class represents a context of a parsing operation:
the current position the parsing operation is expected to start at
the bounds limiting the scope of the parsing operation
A self contained, repeatable entity that obtains its content from a path.
AsyncEntityProducer implementation that generates a data stream from the content at a Path.Percent-encoding mechanism defined in RFC 3986
HTTP/2 ping command.
Enumeration of pool concurrency policies
Pool entry containing a pool connection object along with its route.
Enumeration of pooled connection re-use policies
Pool statistics.
Port helper methods.
Private key details.
A strategy allowing for a choice of an alias during SSL authentication.
Signals that an HTTP protocol violation has occurred.
TLS capable, protocol upgradable
IOSession.Signals a protocol error in HTTP protocol negotiation.
Application protocol upgrade handler.
Represents a protocol version.
HTTP/2 stream frame.
An asynchronous data consumer that supports Reactive Streams.
An asynchronous data producer that supports Reactive Streams.
An
AsyncEntityProducer that subscribes to a Publisher
instance, as defined by the Reactive Streams specification.An
AsyncResponseConsumer that publishes the response body through
a Publisher, as defined by the Reactive Streams specification.An implementation of
AsyncServerExchangeHandler designed to work with reactive streams.Interface for obtaining reason phrases for HTTP status codes.
Generic registry of items keyed by low-case string ID.
Builder for
Registry instances.Abstract request channel.
RequestConnControl is responsible for adding
Connection header
to the outgoing requests, which is essential for managing persistence of
HTTP/1.0 connections.RequestContent is the most important interceptor for outgoing requests.
RequestDate interceptor is responsible for adding
Date header
to the outgoing requests This interceptor is optional for client side
protocol processors.HttpRequester bootstrap.Request execution command.
RequestExpectContinue is responsible for enabling the 'expect-continue'
handshake by adding
Expect header.Generic registry of request handlers that can be resolved by properties of request messages.
Signals request header field length or total field size violation.
HTTP/1.1 request line.
ConnectionClosedException subclass that signals requests cannot not be executed
due to the connection being closed.RequestHostOutgoing is responsible for adding
Host header to the outgoing message.RequestUserAgent is responsible for adding
User-Agent header.RequestTargetHost is responsible for copying
Host header value to
HttpRequest.setAuthority(URIAuthority) of the incoming message.Abstract resolver from input to output.
Abstract resource holder.
Abstract response / response promise channel.
ResponseConnControl is responsible for adding
Connection header
to the outgoing responses, which is essential for managing persistence of
HTTP/1.0 connections.ResponseContent is the most important interceptor for outgoing responses.
ResponseDate is responsible for adding
Date header to the
outgoing responses.Signals an early (out of order) response.
Represents a strategy to determine how frequently the client should check for an out of order response.
ResponseServer is responsible for adding
Server header.Benchmark results
Deprecated.
Use configuration parameters provided by connection listeners.
A streamed entity that obtains its content from a
Serializable.HttpServer bootstrap.IOEventHandler that implements
server side HTTP/2 messaging protocol with full support for
multiplexed message transmission.I/O event handler for events fired by
ProtocolIOSession that implements
server side of the HTTP/2 protocol negotiation handshake.I/O event handler for events fired by
ProtocolIOSession that implements
server side HTTP/2 messaging protocol with full support for
multiplexed message transmission.ServerH2StreamMultiplexer factory.Protocol upgrade handler that upgrades the underlying
ProtocolIOSession
to HTTP/2 in case of a successful protocol negotiation.IOEventHandler that implements
server side HTTP/1.1 messaging protocol with full support for
duplexed message transmission and message pipelining.ServerHttp1IOEventHandler factory.I/O event handler for events fired by
ProtocolIOSession that implements
server side HTTP/1.1 messaging protocol with full support for
duplexed message transmission and message pipelining.ServerHttp1StreamDuplexer factory.Protocol upgrade handler that upgrades the underlying
ProtocolIOSession
to HTTP/1.1 in case of a successful protocol negotiation or as a default fall-back.Server I/O event starter that prepares I/O sessions for an initial protocol handshake.
HTTP Server support methods.
Session input buffer for HTTP/1.1 blocking connections.
Session input buffer for HTTP/1.1 non-blocking connections.
Abstract base class for session input buffers that stream data from
an arbitrary
InputStream.Session output buffer for blocking HTTP/1.1 connections.
Session output buffer for non-blocking HTTP/1.1 connections.
Abstract base class for session output buffers that stream data to
an arbitrary
OutputStream.Shutdown command.
Classic I/O network socket configuration.
A generic
ModalCloseable backed by a network socket.Creates
SocketTimeoutException instances.Cheap and nasty SOCKS protocol version 5 proxy, recommended for use in unit tests only so we can test our SOCKS client code.
Implements the client side of SOCKS protocol version 5 as per https://tools.ietf.org/html/rfc1928.
Deprecated.
Use
IOReactorConfig.Builder for
SSLContext instances.SSLContext factory methods.SSLIOSession is a decorator class intended to transparently extend
an IOSession with transport layer security capabilities based on
the SSL/TLS protocol.Callback interface that can be used to customize TLS/SSL session initialization.
Callback interface that can be used to customize TLS/SSL session verification.
Callback interface that can be used to customize TLS/SSL session verification.
Filters supported by async and classic server implementations
Statistics for an
HttpBenchmark.HTTP/1.1 status line.
Standard classes of HTTP status codes, plus
OTHER for non-standard codes.Abstract data stream channel.
Signals that data stream has already been closed.
HTTP/2 stream ID generator.
Connection pool with strict connection limit guarantees.
Basic
AsyncEntityConsumer implementation
that processes the data stream content into a string.Basic
AsyncDataProducer implementation that
generates data stream from content of a string.A self contained, repeatable entity that obtains its content from a
String.Represents a supplier of results.
AsyncFilterHandler implementation represents a terminal handler
in an asynchronous request processing pipeline that makes use of HandlerFactory
to dispatch the request to a particular AsyncServerExchangeHandler.HttpFilterHandler implementation represents a terminal handler
in a request processing pipeline that makes use of HttpRequestMapper
to dispatch the request to a particular HttpRequestHandler.Defines types of threading behavior enforced at runtime.
Represents a timeout value as a non-negative
long time and TimeUnit.A specialization of
TimeoutException that carries a Timeout deadline and the actual value.Represents a time value as a
long time and a TimeUnit.Supported
TLS protocol versions.TLS cipher suite support methods
Represents details of a fully established TLS session.
TLS protocol upgrade strategy for non-blocking
TransportSecurityLayer sessions.HTTP/1.1 TLS support methods
Capability to upgrade to TLS.
Tokenizer that can be used as a foundation for more complex parsing routines.
Deprecated.
Use
TokenizerTLS capable session layer interface.
Signals a truncated chunk in a chunked stream.
A strategy to establish trustworthiness of certificates without consulting the trust manager
configured in the actual SSL context.
Signals an unsupported version of the HTTP protocol.
Represents authority component of request
URI.Builder for
URI instances.Maintains a map of objects keyed by a request URI pattern.
Maintains a map of objects keyed by a request URI pattern.
Maintains a map of objects keyed by a request URI regular expression.
Enumerates supported URI schemes.
Deprecated.
Use
URIBuilder to parse and format URIs and
WWWFormCodec to parse and format application/x-www-form-urlencoded forms.Provides access to version information for HTTP components.
application/x-www-form-urlencoded codec.
EmptyInputStream