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 HeaderElement
s.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
HeaderElement
Iterator
of HeaderElement
s.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
FutureCallback
s 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
HttpClientConnection
s.Builder for
DefaultBHttpClientConnectionFactory
.Default implementation of
HttpServerConnection
.Default factory for
HttpServerConnection
s.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 HttpRequest
s.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 HttpRequest
s.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 HttpResponse
s.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 HttpResponse
s.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
FileChannel
A content encoder capable of transferring data directly from a
FileChannel
A 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
FutureCallback
s 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
Tokenizer
TLS 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 URI
s 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