All Classes and Interfaces
Class
Description
A convenience base implementation of
Connection.Partial implementation of EndPoint that uses
FillInterest and WriteFlusher.Abstract implementation of
RetainableByteBuffer with
reference counting.Client-side interface used by ServiceLoader.
Server-side interface used by ServiceLoader.
A
RetainableByteBuffer pool where RetainableByteBuffers are held in Pools that are
held in array elements.A variant of the
ArrayByteBufferPool that
uses buckets of buffers that increase in size by a power of
2 (e.g.A variant of
ArrayByteBufferPool that tracks buffer
acquires/releases, useful to identify buffer leaks.A
Content.Source that is also a Content.Sink.A
Content.Sink backed by another Content.Sink.ByteArrayEndPoint.
Accumulates data into a list of ByteBuffers which can then be combined into a single buffer or written to an OutputStream.
Aggregates data into a single ByteBuffer of a specified maximum size.
This class can be used to accumulate pairs of
ByteBuffer and Callback, and eventually copy
these into a single ByteBuffer or byte array and succeed the callbacks.A
Content.Source backed by one or more ByteBuffers.Present a ByteBuffer as an InputStream.
Simple wrapper of a ByteBuffer as an OutputStream.
This class implements an output stream in which the data is written into a list of ByteBuffer,
the buffer list automatically grows as data is written to it, the buffers are taken from the
supplied
ByteBufferPool or freshly allocated if one is not supplied.A pool for
RetainableByteBuffer instances.Accumulates a sequence of
RetainableByteBuffer that
are typically created during the generation of protocol bytes.A
ByteBufferPool that does not pool its
RetainableByteBuffers.A ByteBufferPool with an additional no-args
ByteBufferPool.Sized.acquire() method to obtain a buffer of a
preconfigured specific size and type.A wrapper for
ByteBufferPool instances.An accumulator of
Content.Chunks used to facilitate minimal copy
aggregation of multiple chunks.A
Content.Source backed by one or more Content.Chunks.Factory for client-side
Connection instances.Wraps another ClientConnectionFactory.
A holder for a list of protocol strings identifiers
(for example
["h2", "h2-17", "h2-16"]) and a
ClientConnectionFactory that creates connections
that speak an application protocol such as HTTP.The client-side component that connects to server sockets.
Deprecated, for removal: This API element is subject to removal in a future version.
Deprecated, for removal: This API element is subject to removal in a future version.
replaced by
TransportA
Connection is associated to an EndPoint so that I/O events
happening on the EndPoint can be processed by the Connection.A Listener for connection events.
Connection implementations implement this interface when they
can upgrade from the protocol they speak (for example HTTP/1.1)
to a different protocol (e.g.Connection implementations implement this interface when they
can be upgraded to the protocol they speak (e.g.A
Connection.Listener that tracks connection statistics.Namespace class that contains the definitions of a
content source,
a content sink and a content chunk.A chunk of content indicating whether it is the last chunk.
Implementations of this interface may process
Content.Chunks being copied by the
Content.copy(Source, Sink, Processor, Callback) method, so that
Content.Chunks of unknown types can be copied.A content sink that writes the content to its implementation (a socket, a file, etc.).
A source of content that can be read with a read/demand model.
An
OutputStream backed by a Content.Sink.A
Flow.Subscriber that wraps a Content.Sink.A utility class to convert content from a
Content.Source to an instance
available via a CompletableFuture.An
InputStream that is backed by a Content.Source.Wraps a
Content.Source as a Flow.Publisher.This abstract
Content.Source wraps another Content.Source and implementers need only
to implement the ContentSourceTransformer.transform(Content.Chunk) method, which is used to transform Content.Chunk
read from the wrapped source.An abstract implementation of a timeout.
An implementation of a timeout that manages many
expirable entities whose
timeouts are mostly cancelled or re-scheduled.An entity that may expire.
An
EndPoint implementation based on DatagramChannel.EndPoint is the abstraction for I/O communication using bytes.
A communication conduit between two peers.
Interface representing bundle of SSLSession associated data.
Marks an
EndPoint that wraps another EndPoint.A Jetty specialization of EOFException.
A Utility class to help implement
EndPoint.fillInterested(Callback)
by keeping state and calling the context and callback objects.An Abstract implementation of an Idle Timeout.
A
Content.Source that is backed by an InputStream.Common IO operations for
Resource content.ManagedSelector wraps a Selector simplifying non-blocking operations on channels.A
ManagedSelector.Selectable is an EndPoint that wish to be
notified of non-blocking events by the ManagedSelector.A selector update to be done when the selector has been woken.
Memory-based implementation of
EndPoint.Pipe.A listener for raw network traffic within Jetty.
A specialized version of
SocketChannelEndPoint that supports NetworkTrafficListeners.A
Content.Source that provides content asynchronously through an OutputStream.A
Content.Source that provides the file content of the passed Path.A Quiet Exception.
A reference counted resource, for example one that is borrowed from a pool,
that may be retained an additional number of times, and released a correspondent
number of times, over its lifecycle.
A reference count implementation for a
Retainable resource.A wrapper of
Retainable instances.A pooled
ByteBuffer which maintains a reference count that is
incremented with Retainable.retain() and decremented with Retainable.release().A wrapper for
RetainableByteBuffer instancesSubclass of
RuntimeException used to signal that there
was an IOException thrown by underlying WriterA partial
EndPoint implementation based on SelectableChannel.SelectorManager manages a number of ManagedSelectors that
simplify the non-blocking primitives provided by the JVM via the java.nio package.A listener for accept events.
An
EndPoint implementation based on SocketChannel.A ClientConnectionFactory that creates client-side
SslConnection instances.A factory for
SSLEngine objects.A Connection that acts as an interceptor between an EndPoint providing SSL encrypted data
and another consumer of an EndPoint (typically an
Connection like HttpConnection) that
wants unencrypted data.Implementations of this interface are notified of TLS handshake events.
The event object carrying information about TLS handshake events.
The low-level transport used by clients.
Abstract implementation of
Transport based on IP.Abstract implementation of
Transport based on sockets.The TCP/IP
Transport.The stream Unix-Domain socket
Transport.The UDP/IP
Transport.The datagram Unix-Domain socket
Transport.Abstract implementation of
Transport based on Unix-Domain sockets.A wrapper for
Transport instances to allow layering of Transports.A Utility class to help implement
EndPoint.write(Callback, ByteBuffer...) by calling
EndPoint.flush(ByteBuffer...) until all content is written.Deprecated, for removal: This API element is subject to removal in a future version.
functionality removed, no replacement
Wrap a Writer as an OutputStream.
An alternate to
OutputStreamWriter that supports
several optimized implementation for well known Charsets,
specifically StandardCharsets.UTF_8 and StandardCharsets.ISO_8859_1.
Transport