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.
 
 
 
 
 
 
 
 
 
 
 
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.
 
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
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.
Iterator of Header tokens..
 
 
 
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.
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.
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.
 
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.
Future whose result depends on another Cancellable process or operation or another Future.
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.
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.
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.
Default implementation of HttpServerConnection.
Default factory for HttpServerConnections.
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.
Please use EmptyInputStream
 
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.
Abstract RawFrame factory that supports standard HTTP/2 FrameTypes.
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.
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.
 
 
 
 
 
A set of utility methods to help produce consistent equals and hashCode methods.
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.
ConnPool that also implements ConnPoolControl and AutoCloseable.
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.
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.
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.
 
 
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.
 
Utility class that holds a Socket along with copies of its InputStream and OutputStream.
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.
 
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.
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 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.