All Classes and Interfaces
Class
Description
A skeletal
AddressResolver
implementation.Decoder for both
BinaryMemcacheRequest
and BinaryMemcacheResponse
.Contains all states this decoder can possibly be in.
A
MessageToByteEncoder
that encodes binary memcache messages into bytes.Default implementation of a
BinaryMemcacheMessage
.AbstractBootstrap
is a helper class that makes it easy to bootstrap a Channel
.Exposes the configuration of an
AbstractBootstrap
.A skeletal implementation of a buffer.
Skeletal
ByteBufAllocator
implementation to extend.A skeletal
Channel
implementation.A skeletal
ChannelPoolHandler
implementation.A skeletal
ChannelPoolMap
implementation.Base implementation of
Constant
.Deprecated.
Do not use.
Abstract Disk HttpData implementation
A skeletal implementation of
DnsMessage
.An OPT RR record.
A skeletal implementation of
DnsRecord
.Abstract base class for
EventExecutor
implementations.Deprecated.
override
SingleThreadEventExecutor.wakesUpForTask(java.lang.Runnable)
to re-create this behaviourAbstract base class for
EventExecutorGroup
implementations.Skeletal implementation of
EventLoop
.Skeletal implementation of
EventLoopGroup
.Abstract
Future
implementation which does not allow for cancellation.Abstract base class which defines commonly used features required to build
Http2ConnectionHandler
instances.Returns the flow-control size for DATA frames, and 9 for all other frames.
ChannelConfig
so that the high and low writebuffer watermarks can reflect the outbound flow control
window, without having to create a new WriteBufferWaterMark
object whenever the flow control window
changes.The current status of the read-processing for a
AbstractHttp2StreamChannel
.Http2FrameStreamVisitor
that fires the user event for every active stream pipeline.Abstract implementation of
Http2StreamFrame
.Abstract HttpData implementation
A skeletal builder implementation of
InboundHttp2ToHttpAdapter
and its subtypes.A skeletal implementation of
InternalLogger
.The default
MemcacheObject
implementation.A
ChannelHandler
that aggregates an MemcacheMessage
and its following MemcacheContent
s into a single MemcacheMessage
with
no following MemcacheContent
s.Abstract super class for both ascii and binary decoders.
A general purpose
AbstractMemcacheObjectEncoder
that encodes MemcacheMessage
s.Abstract Memory HttpData implementation
Base class for precomputed factories that create
MultiSearchProcessor
s.AbstractNioChannel
base class for Channel
s that operate on bytes.Abstract base class for
Channel
implementations which use a Selector based approach.Special
Channel.Unsafe
sub-type which allows to access the underlying SelectableChannel
AbstractNioChannel
base class for Channel
s that operate on messages.Deprecated.
use NIO / EPOLL / KQUEUE transport.
Deprecated.
use NIO / EPOLL / KQUEUE transport.
Deprecated.
use NIO / EPOLL / KQUEUE transport.
Abstract base class for derived
ByteBuf
implementations.Abstract base class for classes wants to implement
ReferenceCounted
.Abstract base class for
ByteBuf
implementations that count references.This class provides the functionality to either accept or reject new
Channel
s
based on their IP address.Abstract base class for
EventExecutor
s that want to support scheduling.Base class for precomputed factories that create
SearchProcessor
s.A skeletal server-side
Channel
implementation.Enables SNI
(Server Name Indication) extension for server side SSL.
An abstract
Socks4Message
.An abstract
Socks5Message
.An abstract
SocksMessage
.Abstract class for Simple Strings or Errors.
AbstractTrafficShapingHandler allows to limit the global bandwidth
(see
GlobalTrafficShapingHandler
) or per session
bandwidth (see ChannelTrafficShapingHandler
), as traffic shaping.Class to implement setReadable at fix time
Special
SwappedByteBuf
for ByteBuf
s that is using unsafe.An auto-tuning pooling
ByteBufAllocator
, that follows an anti-generational hypothesis.An auto-tuning pooling allocator, that follows an anti-generational hypothesis.
The strategy for how
AdaptivePoolingAllocator
should allocate chunk buffers.The
RecvByteBufAllocator
that automatically increases and
decreases the predicted buffer size on feed back.A message that wraps another message with a sender address and a recipient address.
Resolves a possibility unresolved
SocketAddress
.Creates and manages
NameResolver
s so that each EventExecutor
has its own resolver instance.Implements Aho–Corasick
string search algorithm.
Provides a way to get the application-level protocol name from ALPN or NPN.
Provides an
SSLEngine
agnostic way to configure a ApplicationProtocolNegotiator
.Defines which application level protocol negotiation to use.
Defines the most common behaviors for the peer which is notified of the selected protocol.
Defines the most common behaviors for the peer that selects the application protocol.
Provides a set of protocol names used in ALPN and NPN.
Configures a
ChannelPipeline
depending on the application-level protocol negotiation result of
SslHandler
.Deprecated.
Utility class for application protocol common operations.
Header of Redis Array Message.
Arrays of RESP.
The newline characters to insert between header entries.
The separator characters to insert between a header name and a header value.
A string which has been encoded into a character encoding whose character always takes a single byte, similarly to
ASCII.
A collection of utility methods that is related with handling
AsciiString
.Attribute interface
An attribute which allows to store a value reference.
Key which can be used to access
Attribute
out of the AttributeMap
.Holds
Attribute
s which can be accessed via AttributeKey
.Cache which stores the nameservers that should be used to resolve a specific hostname.
AuthoritativeDnsServerCache
implementation which delegates all operations to a wrapped DnsCache
.Enumeration of supported Base64 dialects.
Combines two
DnsQueryLifecycleObserver
into a single DnsQueryLifecycleObserver
.Combines two
DnsQueryLifecycleObserverFactory
into a single DnsQueryLifecycleObserverFactory
.The client codec that combines the proper encoder and decoder.
An interface that defines a binary Memcache message, providing common properties for
BinaryMemcacheRequest
and BinaryMemcacheResponse
.An object aggregator for the memcache binary protocol.
Represents all Opcodes that can occur in a
BinaryMemcacheMessage
.Represents a full
BinaryMemcacheRequest
, which contains the header and optional key and extras.The decoder part which takes care of decoding the request-specific headers.
The encoder part which takes care of encoding the request headers.
Represents a full
BinaryMemcacheResponse
, which contains the header and optional key and extras.The decoder which takes care of decoding the response headers.
The encoder which takes care of encoding the response headers.
Contains all possible status values a
BinaryMemcacheResponse
can return.The full server codec that combines the correct encoder and decoder.
Web Socket frame containing binary data.
Implements Bitap string search algorithm.
An
IllegalStateException
which is raised when a user performed a blocking operation
when the user is in an event loop thread.Represents a supplier of
boolean
-valued results.Exposes the configuration of a
Bootstrap
.Contains methods that can be used to detect if BouncyCastle is usable.
Generates a self-signed certificate using Bouncy Castle.
A socket which provides access BSD native methods.
The header of Bulk Strings in RESP.
A chunk of bulk strings which is used for Redis chunked transfer-encoding.
Decodes a received
ByteBuf
into an array of bytes.Encodes the requested array of bytes into a
ByteBuf
.A random and sequential accessible sequence of zero or more bytes (octets).
Implementations are responsible to allocate buffers.
on OpenJDK Adler32 and CRC32 both calls ZipUtils.loadLibrary on class init.
An interface that can be implemented by any object that know how to turn itself into a
ByteBuf
.Used to control the format and verbosity of logging for
ByteBuf
s and ByteBufHolder
s.A packet which is send or receive.
An
InputStream
which reads data from a ByteBuf
.An
OutputStream
which writes data to a ByteBuf
.Deprecated.
Use
ByteProcessor
.A collection of utility methods that is related with handling
ByteBuf
,
such as the generation of hex dump and swapping an integer's byte order.Utilities for byte-based primitive collections.
An empty map.
An unmodifiable wrapper around a
ByteObjectMap
.A hash map implementation of
ByteObjectMap
that uses open addressing for keys.Interface for a primitive map that uses
byte
s as keys.A primitive entry in the map, provided by the iterator from
ByteObjectMap.entries()
Provides a mechanism to iterate over a collection of bytes.
A
ByteProcessor
which finds the first appearance which is not of a specific byte.A
ByteProcessor
which finds the first appearance of a specific byte.A Codec for on-the-fly encoding/decoding of bytes to messages and vise-versa.
ChannelInboundHandlerAdapter
which decodes bytes in a stream-like fashion from one ByteBuf
to an
other Message type.Cumulate
ByteBuf
s.An bit reader that allows the reading of single bit booleans, bit strings of
arbitrary length (up to 32 bits), and bit aligned 32-bit integers.
A bit writer that allows the writing of single bit booleans, unary numbers, bit strings
of arbitrary length (up to 32 bits), and bit aligned 32-bit integers.
Compresses and writes a single Bzip2 block.
Block encoding consists of the following stages:
1.
Block encoding consists of the following stages:
1.
Reads and decompresses a single Bzip2 block.
Block decoding consists of the following stages:
1.
Block decoding consists of the following stages:
1.
Constants for both the
Bzip2Encoder
and the Bzip2Decoder
.Uncompresses a
ByteBuf
encoded with the Bzip2 format.Current state of stream.
DivSufSort suffix array generator.
Based on libdivsufsort 1.2.3 patched to support Bzip2.
This is a simple conversion of the original C with two minor bugfixes applied (see "BUGFIX" comments within the class).
Based on libdivsufsort 1.2.3 patched to support Bzip2.
This is a simple conversion of the original C with two minor bugfixes applied (see "BUGFIX" comments within the class).
Compresses a
ByteBuf
using the Bzip2 algorithm.Current state of stream.
An in-place, length restricted Canonical Huffman code length allocator.
Based on the algorithm proposed by R.
Based on the algorithm proposed by R.
A decoder for the Bzip2 Huffman coding stage.
An encoder for the Bzip2 Huffman encoding stage.
A 256 entry Move To Front transform.
An encoder for the Bzip2 Move To Front Transform and Run-Length Encoding[2] stages.
Although conceptually these two stages are separate, it is computationally efficient to perform them in one pass.
Although conceptually these two stages are separate, it is computationally efficient to perform them in one pass.
Random numbers for decompress Bzip2 blocks.
Abstract cache that automatically removes entries for a hostname once the TTL for an entry is reached.
A nexus to a network socket or a component which is capable of I/O
operations such as read, write, connect, and bind.
Unsafe operations that should never be called from user-code.
A set of configuration properties of a
Channel
.ChannelHandler
implementation which represents a combination out of a ChannelInboundHandler
and
the ChannelOutboundHandler
.A
RuntimeException
which is thrown when an I/O operation fails.Deprecated.
Use
ChannelFactory
instead.Creates a new
Channel
.This implementation allows to register
ChannelFuture
instances which will get notified once some amount of
data was written and so a checkpoint was reached.The result of an asynchronous
Channel
I/O operation.Listens to the result of a
ChannelFuture
.ChannelException
which holds ChannelFuture
s that failed because of an error.The result of an asynchronous
ChannelGroup
operation.Listens to the result of a
ChannelGroupFuture
.Handles an I/O event or intercepts an I/O operation, and forwards it to its next handler in
its
ChannelPipeline
.Indicates that the same instance of the annotated
ChannelHandler
can be added to one or more ChannelPipeline
s multiple times
without a race condition.Skeleton implementation of a
ChannelHandler
.Enables a
ChannelHandler
to interact with its ChannelPipeline
and other handlers.Indicates that the annotated event handler method in
ChannelHandler
will not be invoked by
ChannelPipeline
and so MUST only be used when the ChannelHandler
method does nothing except forward to the next ChannelHandler
in the pipeline.Represents the globally unique identifier of a
Channel
.ChannelHandler
which adds callbacks for state changes.Abstract base class for
ChannelInboundHandler
implementations which provide
implementations of all of their methods.A special
ChannelInboundHandler
which offers an easy way to initialize a Channel
once it was
registered to its EventLoop
.A channel initializer extension make it possible to enforce rules and apply modifications across multiple,
disconnected uses of Netty within the same JVM process.
The configurable facade that decides what
ChannelInitializerExtension
s to load and where to find them.Special event which will be fired and passed to the
ChannelInboundHandler.userEventTriggered(ChannelHandlerContext, Object)
methods once the input of
a SocketChannel
was shutdown and the DuplexChannelConfig.isAllowHalfClosure()
method returns
true
.User event that signifies the channel's input side is shutdown, and we tried to shut it down again.
Allows to only match some
Channel
's for operations in ChannelGroup
.Helper class which provides often used
ChannelMatcher
implementations.Represents the properties of a
Channel
implementation.A
ChannelOption
allows to configure a ChannelConfig
in a type-safe
way.(Transport implementors only) an internal data structure used by
AbstractChannel
to store its pending
outbound write requests.ChannelHandler
which will get notified for IO-outbound-operations.Skeleton implementation of a
ChannelOutboundHandler
.Special event which will be fired and passed to the
ChannelInboundHandler.userEventTriggered(ChannelHandlerContext, Object)
methods once the output of
a SocketChannel
was shutdown.Used to fail pending writes when a channel's output has been shutdown.
A list of
ChannelHandler
s which handles or intercepts inbound events and outbound operations of a
Channel
.A
ChannelException
which is thrown when a ChannelPipeline
failed to execute an operation.Allows to acquire and release
Channel
and so act as a pool of these.Handler which is called for various actions done by the
ChannelPool
.Allows to map
ChannelPool
implementations to a specific key.An special
ChannelFuture
which is used to indicate the FileRegion
transfer progressAn
EventListener
listener which will be called once the sending task associated with future is
being transferred.Special
ChannelPromise
which will be notified once the associated bytes is transferring.Special
ChannelFuture
which is writable.Deprecated.
Use
PromiseCombiner
Class which is used to consolidate multiple channel futures into one, by
listening to the individual futures and producing an aggregated result
(success/failure) when all futures have completed.Deprecated.
use
PromiseNotifier
.This implementation of the
AbstractTrafficShapingHandler
is for channel
traffic shaping, that is to say a per channel limitation of the bandwidth.Utilities for char-based primitive collections.
An empty map.
An unmodifiable wrapper around a
CharObjectMap
.A hash map implementation of
CharObjectMap
that uses open addressing for keys.Interface for a primitive map that uses
char
s as keys.A primitive entry in the map, provided by the iterator from
CharObjectMap.entries()
Internal use only!
Converts to/from native types, general
Object
, and CharSequence
s.A utility class that provides various common operations and constants
related with
Charset
and its relevant classes.A
ChunkedInput
that fetches data from a file chunk by chunk.A data stream of indefinite length which is consumed by
ChunkedWriteHandler
.A
ChunkedInput
that fetches data from a file chunk by chunk using
NIO FileChannel
.A
ChunkedInput
that fetches data from a ReadableByteChannel
chunk by chunk.A
ChunkedInput
that fetches data from an InputStream
chunk by
chunk.A
ChannelHandler
that adds support for writing a large data stream
asynchronously neither spending a lot of memory nor getting
OutOfMemoryError
.Cipher suites
Converts a Java cipher suite string to an OpenSSL cipher suite string and vice versa.
Used to store nullable values in a CHM
Provides a means to filter the supplied cipher suite based upon the supported and default cipher suites.
Utility which ensures that classes are loaded by the
ClassLoader
.Deprecated.
This class has been deprecated with no replacement,
because serialization can be a security liability
Deprecated.
This class has been deprecated with no replacement,
because serialization can be a security liability
Allows to free direct
ByteBuffer
s.Allows to free direct
ByteBuffer
by using Cleaner.Provide a way to clean a ByteBuffer on Java9+.
Performing cleartext upgrade, by h2c HTTP upgrade or Prior Knowledge.
User event that is fired to notify about HTTP/2 protocol is started.
Indicates the state of the
SSLEngine
with respect to client authentication.A RFC6265 compliant cookie decoder to be used client side.
Deprecated.
A RFC6265 compliant cookie encoder to be used client side, so
only name=value pairs are sent.
Web Socket Frame for closing the connection.
A FIFO queue of bytes where producers add bytes by repeatedly adding
ByteBuf
and consumers take bytes in
arbitrary lengths.An
Exception
which is thrown by a codec.Special
AbstractList
implementation which is used within our codec base classes.Will add multiple values for the same header as single header with a comma separated list of values.
Escapes comma separated values (CSV).
Deprecated.
Deprecated.
Deprecated.
This class has been deprecated with no replacement,
because serialization can be a security liability
A skeletal
ChannelFuture
implementation which represents a
ChannelFuture
which has been completed already.A virtual buffer which shows multiple buffers as a single merged buffer.
A composite
SimpleNameResolver
that resolves a host name against a sequence of NameResolver
s.Compression Encoder Factory for create
MessageToByteEncoder
used to compress http contentAn
EncoderException
that is raised when compression failed.CompressionOptions
provides compression options for
various types of compressor types, like Brotli.A decorating HTTP2 encoder that will compress data frames according to the
content-encoding
header for each
stream.Deprecated.
For removal in Netty 4.2.
ConnectException
which will be thrown if a connection could
not be established because of a connection timeout.A singleton which is safe to compare via the
==
operator.A pool of
Constant
s.Web Socket continuation frame containing continuation text or binary data.
Deprecated.
Use
Cookie
instead.An interface defining an
HTTP cookie.
Parent of Client and Server side cookie decoders
Deprecated.
Use
ClientCookieDecoder
or ServerCookieDecoder
instead.Parent of Client and Server side cookie encoders
Possible values for the SameSite attribute.
Deprecated.
Duplicate of package private $
CookieUtil
An
DecoderException
which is thrown when the received frame data could not be decoded by
an inbound handler.An
DecoderException
which is thrown when the received WebSocketFrame
data could not be decoded by
an inbound handler.Configuration for Cross-Origin Resource Sharing (CORS).
Deprecated.
Use
CorsConfigBuilder
instead.Deprecated.
Removed without alternatives.
Builder used to configure and build a
CorsConfig
instance.This class is used for preflight HTTP response values that do not need to be
generated, but instead the value is "static" in that the same value will be returned
for each call.
This callable is used for the DATE preflight HTTP response HTTP header.
Handles Cross Origin Resource Sharing (CORS) requests.
A CRC32 calculator.
Implements CRC32-C as defined in:
"Optimization of Cyclic Redundancy-CHeck Codes with 24 and 32 Parity Bits",
IEEE Transactions on Communications 41(6): 883-892 (1993).
A UDP/IP
Channel
.A
ChannelConfig
for a DatagramChannel
.A
DnsQuery
implementation for UDP/IP.Decodes a
DatagramPacket
into a DatagramDnsQuery
.A
DnsResponse
implementation for UDP/IP.Decodes a
DatagramPacket
into a DatagramDnsResponse
.The message container that is used for
DatagramChannel
to communicate with the remote peer.A decoder that decodes the content of the received
DatagramPacket
using
the specified ByteBuf
decoder.An encoder that encodes the content in
AddressedEnvelope
to DatagramPacket
using
the specified message encoder.Act as special
InetSocketAddress
to be able to easily pass all needed data from JNI without the need
to create more objects then needed.A formatter for HTTP header dates, such as "Expires" and "Date" headers, or "expires" field in "Set-Cookie".
An
CodecException
which is thrown by a decoder.Provides the accessor methods for the
DecoderResult
property of a decoded message.A
DecoderException
that is raised when decompression failed.Decorator around another
Http2ConnectionDecoder
instance.A decorator around another
Http2ConnectionEncoder
instance.Decorator around another
Http2FrameWriter
instance.The default
AddressedEnvelope
implementation.Default
Attributes lookup and remove exibit
AttributeMap
implementation which not exibit any blocking behaviour on attribute lookup while using a
copy-on-write approach on the modify path.Attributes lookup and remove exibit
O(logn)
time worst-case
complexity, hence attribute::set(null)
is to be preferred to remove
.Default implementation of
AuthoritativeDnsServerCache
, backed by a ConcurrentMap
.The default implementation of the
BinaryMemcacheRequest
.The default implementation of the
BinaryMemcacheResponse
.A default implementation of
BulkStringRedisContent
.Default implementation of a
ByteBufHolder
that holds it's data in a ByteBuf
.The default
ChannelConfig
implementation.The default
ChannelGroup
implementation.The default
ChannelGroupFuture
implementation.The default
ChannelId
implementation.The default
ChannelPipeline
implementation.The default
ChannelProgressivePromise
implementation.The default
ChannelPromise
implementation.The default
Cookie
implementation.Deprecated.
Use
DefaultCookie
instead.The default
DatagramChannelConfig
implementation.Default implementation of
DnsCache
, backed by a ConcurrentMap
.Default implementation of a
DnsCnameCache
.Default
DnsOptEcsRecord
implementation.The default
DnsQuery
implementation.The default
DnsQuestion
implementation.The default
DnsRawRecord
implementation.The default
DnsRecordDecoder
implementation.The default
DnsRecordEncoder
implementation.The default
DnsResponse
implementation.A
DnsServerAddressStreamProvider
which will use predefined default DNS servers to use for DNS resolution.Default
SingleThreadEventExecutor
implementation which just execute all submitted task in a
serial fashion.Default implementation which uses simple round-robin to choose next
EventExecutor
.Default implementation of
MultithreadEventExecutorGroup
which will use DefaultEventExecutor
instances
to handle the tasks.MultithreadEventLoopGroup
which must be used for the local transport.The default implementation of a
FullBinaryMemcacheRequest
.The default implementation of a
FullBinaryMemcacheResponse
.Default implementation of
FullHttpRequest
.Default implementation of a
FullHttpResponse
.Default implementation of
Headers
;A concrete implementation of
DefaultHeaders
that allows for direct instantiation.Default
HostsFileEntriesResolver
that resolves hosts file entries only once.Simple implementation of
Http2Connection
.Allows events which would modify the collection of active streams to be queued while iterating via
DefaultHttp2Connection.forEachActiveStream(Http2StreamVisitor)
.Provides the default implementation for processing inbound frame events and delegates to a
Http2FrameListener
Default implementation of
Http2ConnectionEncoder
.The default
Http2DataFrame
implementation.A
Http2FrameReader
that supports all frame types defined by the HTTP/2 specification.A
Http2FrameWriter
that supports all frame types defined by the HTTP/2 specification.The default
Http2GoAwayFrame
implementation.The default
Http2HeadersFrame
implementation.Basic implementation of
Http2LocalFlowController
.An abstraction which provides specific extensions used by local flow control.
The default
Http2PingFrame
implementation.Default implementation of Http2PriorityFrame
Default implementation of
Http2PushPromiseFrame
Basic implementation of
Http2RemoteFlowController
.The default
Http2ResetFrame
implementation.The default
Http2SettingsAckFrame
implementation.The default
Http2SettingsFrame
implementation.The default
Http2WindowUpdateFrame
implementation.The default
HttpContent
implementation.Default factory giving
Attribute
and FileUpload
according to constructor.Default implementation of
HttpHeaders
.A builder of
HttpHeadersFactory
instances, that itself implements HttpHeadersFactory
.The default
HttpMessage
implementation.The default
HttpRequest
implementation.The default
HttpResponse
implementation.A default implementation for
LastBulkStringRedisContent
.The default
LastHttpContent
implementation.The default implementation for the
LastMemcacheContent
.Default implementation of
LastSmtpContent
that does no validation of the raw data passed in.The default implementation for the
LastStompContentSubframe
.The
RecvByteBufAllocator
that yields a buffer size prediction based upon decrementing the value from
the max bytes per read.Default implementation of
MaxMessagesRecvByteBufAllocator
which respects ChannelConfig.isAutoRead()
and also prevents overflow.The default
MemcacheContent
implementation.Default
MessageSizeEstimator
implementation which supports the estimation of the size of
ByteBuf
, ByteBufHolder
and FileRegion
.A
InetNameResolver
that resolves using JDK's built-in domain name lookup mechanism.Deprecated.
use NIO / EPOLL / KQUEUE transport.
Deprecated.
use NIO / EPOLL / KQUEUE transport.
A priority queue which uses natural ordering of elements.
The default
SctpChannelConfig
implementation for SCTP.The default
SctpServerChannelConfig
implementation for SCTP.Default select strategy.
Factory which uses the default select strategy.
The default
ServerSocketChannelConfig
implementation.Default implementation of
SmtpContent
that does no validation of the raw data passed in.Default
SmtpRequest
implementation.Default
SmtpResponse
implementation.The default
SocketChannelConfig
implementation.The default
Socks4CommandRequest
.The default
Socks4CommandResponse
.The default
Socks5CommandRequest
.The default
Socks5CommandResponse
.The default
Socks5InitialRequest
.The default
Socks5InitialResponse
.The default
Socks5PasswordAuthRequest
.The default
Socks5PasswordAuthResponse
.The default
SpdyDataFrame
implementation.The default
SpdyGoAwayFrame
implementation.The default
SpdyHeadersFrame
implementation.The default
SpdyPingFrame
implementation.The default
SpdyRstStreamFrame
implementation.The default
SpdySettingsFrame
implementation.The default
SpdyStreamFrame
implementation.The default
SpdySynReplyFrame
implementation.The default
SpdySynStreamFrame
implementation.The default
SpdyWindowUpdateFrame
implementation.The default
StompContentSubframe
implementation.Default implementation of
StompFrame
.Default implementation of
StompHeadersSubframe
.A
ThreadFactory
implementation with a simple naming rule.Deflate implementation of a payload decompressor for
io.netty.handler.codec.http.websocketx.WebSocketFrame.
Deflate implementation of a payload compressor for
io.netty.handler.codec.http.websocketx.WebSocketFrame.
perframe-deflate
handshake implementation.
perframe-deflate
handshake implementation.
DeflateOptions
holds DeflateOptions.compressionLevel()
,
DeflateOptions.memLevel()
and DeflateOptions.windowBits()
for Deflate compression.An HTTP2 frame listener that will decompress data frames according to the
content-encoding
header for each
stream.Provides the state for stream
DATA
frame decompression.Adapter class which allows to wrap another
SslContext
and init SSLEngine
instances.DeleteFileOnExitHook.
A decoder that splits the received
ByteBuf
s by one or more
delimiters.A set of commonly used delimiters for
DelimiterBasedFrameDecoder
.Disk implementation of Attributes
Disk FileUpload implementation that stores file into real files
Decodes an
InetAddress
from an A or AAAA DnsRawRecord
.A cache for DNS resolution entries.
Represents the results from a previous DNS query which can be cached.
A cache for
CNAME
s.A metadata carrier exception, to propagate
DnsResponseCode
information as an enrichment
within the UnknownHostException
cause.The superclass which contains core information concerning a
DnsQuery
and a DnsResponse
.Provides some utility methods for DNS message implementations.
A DNS-based
InetNameResolver
.A
DnsNameResolver
builder.Strategy that influence how
Channel
s are used during queries.A
RuntimeException
raised when DnsNameResolver
failed to perform a successful query.A
DnsNameResolverException
raised when DnsNameResolver
failed to perform a successful query because
of an timeout.The DNS
OpCode
as defined in RFC2929.An ECS record as defined in Client Subnet in DNS Queries.
An OPT RR record.
A DNS query message.
Special data-structure that will allow to retrieve the next query id to use, while still guarantee some sort
of randomness.
Provides a query if from a range of possible ids.
This interface provides visibility into individual DNS queries.
Used to generate new instances of
DnsQueryLifecycleObserver
.A DNS question.
A generic
DnsRecord
that contains an undecoded RDATA
.A DNS resource record.
Decodes a DNS record into its object representation.
Encodes a
DnsRecord
into binary representation.Represents a DNS record type.
Holds the closed DNS Servers for a domain.
Represent the
dns_resolver_t
struct.A DNS response message.
The DNS
RCODE
, as defined in RFC2929.Represents a section of a
DnsMessage
.Provides an infinite sequence of DNS server addresses to
DnsNameResolver
.An infinite stream of DNS server addresses.
Provides an opportunity to override which
DnsServerAddressStream
is used to resolve a specific hostname.Utility methods related to
DnsServerAddressStreamProvider
.An infinite stream of DNS server addresses, that requests feedback to be returned to it.
A
UnixChannel
that supports communication via
UNIX domain datagram sockets.A
ChannelConfig
for a DomainDatagramChannel
.The message container that is used for
DomainDatagramChannel
to communicate with the remote peer.Act as special
DomainSocketAddress
to be able to easily pass all needed data from JNI without the need
to create more objects then needed.Deprecated.
Use
DomainWildcardMappingBuilder
instead.Deprecated.
Deprecated.
Immutable mapping from domain name pattern to its associated value object.
A address for a
Unix Domain Socket.
A
UnixChannel
that supports communication via
Unix Domain Socket.Special
ChannelConfig
for DomainSocketChannel
s.Different modes of reading from a
DomainSocketChannel
.Builder that allows to build
Mapping
s that support
DNS wildcard matching.A duplex
Channel
that has two sides that can be shutdown independently.A
ChannelConfig
for a DuplexChannel
.Deprecated.
Do not use.
ChannelOutboundHandler
implementation which allows to dynamically replace the used
remoteAddress
and / or localAddress
when making a connection attempt.Base class for
Channel
implementations that are used in an embedded fashion.A dummy
ChannelId
implementation.An empty
ByteBuf
whose capacity and maximum capacity are all 0
.Deprecated.
An
CodecException
which is thrown by an encoder.Wraps an existing
X509ExtendedTrustManager
and enhances the CertificateException
that is thrown
because of hostname validation.Tells if
netty-transport-native-epoll
is
supported.DatagramChannel
implementation that uses linux EPOLL Edge-Triggered Mode for
maximal performance.This is an internal datastructure which can be directly passed to epoll_wait to reduce the overhead.
EventLoop
which uses epoll under the covers.EventLoopGroup
which uses epoll under the covers.The epoll mode to use.
ServerSocketChannel
implementation that uses linux EPOLL Edge-Triggered Mode for
maximal performance.SocketChannel
implementation that uses linux EPOLL Edge-Triggered Mode for
maximal performance.
struct tcp_info
{
__u8 tcpi_state;
__u8 tcpi_ca_state;
__u8 tcpi_retransmits;
__u8 tcpi_probes;
__u8 tcpi_backoff;
__u8 tcpi_options;
__u8 tcpi_snd_wscale : 4, tcpi_rcv_wscale : 4;
__u32 tcpi_rto;
__u32 tcpi_ato;
__u32 tcpi_snd_mss;
__u32 tcpi_rcv_mss;
__u32 tcpi_unacked;
__u32 tcpi_sacked;
__u32 tcpi_lost;
__u32 tcpi_retrans;
__u32 tcpi_fackets;
__u32 tcpi_last_data_sent;
__u32 tcpi_last_ack_sent;
__u32 tcpi_last_data_recv;
__u32 tcpi_last_ack_recv;
__u32 tcpi_pmtu;
__u32 tcpi_rcv_ssthresh;
__u32 tcpi_rtt;
__u32 tcpi_rttvar;
__u32 tcpi_snd_ssthresh;
__u32 tcpi_snd_cwnd;
__u32 tcpi_advmss;
__u32 tcpi_reordering;
__u32 tcpi_rcv_rtt;
__u32 tcpi_rcv_space;
__u32 tcpi_total_retrans;
};
Errors of RESP.
Internal usage only!
Internal usage only!
This class is necessary to break the following cyclic dependency:
JNI_OnLoad
JNI Calls FindClass because RegisterNatives (used to register JNI methods) requires a class
FindClass loads the class, but static members variables of that class attempt to call a JNI method which has not
yet been registered.
java.lang.UnsatisfiedLinkError is thrown because native method has not yet been registered.
Static members which call JNI methods must not be declared in this class!
The
EventExecutor
is a special EventExecutorGroup
which comes
with some handy methods to see if a Thread
is executed in a event loop.Factory that creates new
EventExecutorChooserFactory.EventExecutorChooser
s.Chooses the next
EventExecutor
to use.The
EventExecutorGroup
is responsible for providing the EventExecutor
's to use
via its EventExecutorGroup.next()
method.Will handle all the I/O operations for a
Channel
once registered.Special
ChannelException
which will be thrown by EventLoop
and EventLoopGroup
implementations when an error occurs.Special
EventExecutorGroup
which allows registering Channel
s that get
processed for later selection during the event loop.Delegates all operations to a wrapped
OpenSslInternalSession
except the methods defined by
ExtendedSSLSession
itself.The
CompleteChannelFuture
which is failed already.The
CompleteFuture
which is failed already.Core of FastLZ compression algorithm.
Uncompresses a
ByteBuf
encoded by FastLzFrameEncoder
using the FastLZ algorithm.Current state of decompression.
Compresses a
ByteBuf
using the FastLZ algorithm.A special variant of
ThreadLocal
that yields higher access performance when accessed from a
FastThreadLocalThread
.A special
Thread
that provides fast access to FastThreadLocal
variables.Native
FileDescriptor
implementation which allows to wrap an int
and provide a
FileDescriptor
for it.A region of a file that is sent via a
Channel
which supports
zero-copy file transfer.FileUpload interface that could be in memory, on temporary file or any other implementations.
An
TrustManagerFactory
that trusts an X.509 certificate whose hash matches.A builder for creating
FingerprintTrustManagerFactory
.ChannelPool
implementation that takes another ChannelPool
implementation and enforce a maximum
number of concurrent connections.A decoder that splits the received
ByteBuf
s by the fixed number
of bytes.The
RecvByteBufAllocator
that always yields the same buffer
size prediction.A default fixed redis message pool.
The
FlowControlHandler
ensures that only one message per read()
is sent downstream.A recyclable
ArrayDeque
.ChannelDuplexHandler
which consolidates Channel.flush()
/ ChannelHandlerContext.flush()
operations (which also includes
ChannelOutboundInvoker.writeAndFlush(Object)
/ ChannelOutboundInvoker.writeAndFlush(Object, ChannelPromise)
and
ChannelOutboundInvoker.writeAndFlush(Object)
/
ChannelOutboundInvoker.writeAndFlush(Object, ChannelPromise)
).Holds the results of formatting done by
MessageFormatter
.A
BinaryMemcacheRequest
that also includes the content.A
BinaryMemcacheResponse
that also includes the content.An aggregated bulk string of RESP.
Combines
HttpMessage
and LastHttpContent
into one
message.Combine the
HttpRequest
and FullHttpMessage
, so the request is a complete HTTP
request.Combination of a
HttpResponse
and FullHttpMessage
.Combines
MemcacheMessage
and LastMemcacheContent
into one
message.The result of an asynchronous operation.
A subtype of
GenericFutureListener
that hides type parameter for convenience.Listens to the result of a
Future
.A generic socket option.
Version for
GlobalChannelTrafficShapingHandler
.Class to implement monitoring at fix delay.
This implementation of the
This version shall not be in the same pipeline than other TrafficShapingHandler.
The general use should be as follow:
Create your unique GlobalChannelTrafficShapingHandler like:
GlobalChannelTrafficShapingHandler myHandler = new GlobalChannelTrafficShapingHandler(executor);
The executor could be the underlying IO worker pool
pipeline.addLast(myHandler);
Note that this handler has a Pipeline Coverage of "all" which means only one such handler must be created and shared among all channels as the counter must be shared among all channels.
Other arguments can be passed like write or read limitation (in bytes/s where 0 means no limitation) or the check interval (in millisecond) that represents the delay between two computations of the bandwidth and so the call back of the doAccounting method (0 means no accounting at all).
Note that as this is a fusion of both Global and Channel Traffic Shaping, limits are in 2 sets, respectively Global and Channel.
A value of 0 means no accounting for checkInterval.
AbstractTrafficShapingHandler
is for global
and per channel traffic shaping, that is to say a global limitation of the bandwidth, whatever
the number of opened channels and a per channel limitation of the bandwidth.This version shall not be in the same pipeline than other TrafficShapingHandler.
The general use should be as follow:
Create your unique GlobalChannelTrafficShapingHandler like:
GlobalChannelTrafficShapingHandler myHandler = new GlobalChannelTrafficShapingHandler(executor);
The executor could be the underlying IO worker pool
pipeline.addLast(myHandler);
Note that this handler has a Pipeline Coverage of "all" which means only one such handler must be created and shared among all channels as the counter must be shared among all channels.
Other arguments can be passed like write or read limitation (in bytes/s where 0 means no limitation) or the check interval (in millisecond) that represents the delay between two computations of the bandwidth and so the call back of the doAccounting method (0 means no accounting at all).
Note that as this is a fusion of both Global and Channel Traffic Shaping, limits are in 2 sets, respectively Global and Channel.
A value of 0 means no accounting for checkInterval.
Single-thread singleton
EventExecutor
.This implementation of the
AbstractTrafficShapingHandler
is for global
traffic shaping, that is to say a global limitation of the bandwidth, whatever
the number of opened channels.Convert java naming to OpenSSL naming if possible and if not return the original name.
GzipOptions
holds DeflateOptions.compressionLevel()
,
DeflateOptions.memLevel()
and DeflateOptions.windowBits()
for Gzip compression.The command of an HAProxy proxy protocol header
Message container for decoded HAProxy proxy protocol parameters
Decodes an HAProxy proxy protocol header
Encodes an HAProxy proxy protocol message
A
DecoderException
which is thrown when an invalid HAProxy proxy protocol header is encounteredThe HAProxy proxy protocol specification version.
A protocol proxied by HAProxy which is represented by its transport protocol and address family.
The address family of an HAProxy proxy protocol header.
The transport protocol of an HAProxy proxy protocol header
Represents a
HAProxyTLV
of the type HAProxyTLV.Type.PP2_TYPE_SSL
.A Type-Length Value (TLV vector) that can be added to the PROXY protocol
to include additional information like SSL information.
The registered types a TLV can have regarding the PROXY protocol 1.5 spec
A
Timer
optimized for approximated I/O timeout scheduling.Bucket that stores HashedWheelTimeouts.
Abstraction for hash code generation and equality comparison.
Common interface for
Headers
which represents a mapping of key to value.Provides utility methods related to
Headers
.Utility class for heap buffers.
A container of hosts file entries.
A container of hosts file entries
Resolves a hostname against the hosts file entries.
A parser for hosts files.
HTTP/2 header types.
An HPACK encoder.
A
ChannelDuplexHandler
providing additional functionality for HTTP/2.Client-side cleartext upgrade codec from HTTP to HTTP/2.
Constants and utility method used for encoding/decoding HTTP2 frames.
Provides the ability to associate the outcome of multiple
ChannelPromise
objects into a single ChannelPromise
object.Manager for the state of an HTTP/2 connection with the remote end-point.
A view of the connection from one endpoint (local or remote).
Listener for life-cycle events for streams in this connection.
A key to be used for associating application-defined properties with streams within this connection.
Provides empty implementations of all
Http2Connection.Listener
methods.Handler for inbound traffic on behalf of
Http2ConnectionHandler
.Handler for outbound HTTP/2 traffic.
Provides the default implementation for processing inbound frame events and delegates to a
Http2FrameListener
Closes the channel when the future completes.
Builder which builds
Http2ConnectionHandler
objects.Signifies that the connection preface and
the initial SETTINGS frame have been sent.
DecoratingHttp2ConnectionEncoder
which guards against a remote peer that will trigger a massive amount
of control frames but will not consume our responses to these.A
ChunkedInput
that fetches data chunk by chunk for use with HTTP/2 Data Frames.HTTP/2 DATA frame.
Interface that defines an object capable of producing HTTP/2 data frames.
Enforce a limit on the maximum number of consecutive empty DATA frames (without end_of_stream flag) that are allowed
before the connection will be closed.
Enforce a limit on the maximum number of consecutive empty DATA frames (without end_of_stream flag) that are allowed
before the connection will be closed.
All error codes identified by the HTTP/2 spec.
This class brings
Http2Connection.Listener
and Http2FrameListener
together to provide
NOOP implementation so inheriting classes can selectively choose which methods to override.Exception thrown when an HTTP/2 error was encountered.
Used when a stream creation attempt fails but may be because the stream was previously closed.
Provides the ability to handle multiple stream exceptions with one throw statement.
Provides a hint as to if shutdown is justified, what type of shutdown should be executed.
Represents an exception that can be isolated to a single stream (as opposed to the entire connection).
Provides utility methods for accessing specific flags as defined by the HTTP/2 spec.
Base interface for all HTTP/2 flow controllers.
An HTTP/2 frame.
Convenience class that provides no-op implementations for all methods of
Http2FrameListener
.This API is very immature. The Http2Connection-based API is currently preferred over this API.
Http2FrameStream
implementation.Builder for the
Http2FrameCodec
.An listener of HTTP/2 frames.
Provides a decorator around a
Http2FrameListener
and delegates all method callsLogs HTTP2 frames for debugging purposes.
Reads HTTP/2 frames from an input
ByteBuf
and notifies the specified
Http2FrameListener
when frames are complete.Configuration specific to
Http2FrameReader
A single stream within an HTTP/2 connection.
An HTTP/2 exception for a specific
Http2FrameStream
.A visitor that allows to iterate over a collection of
Http2FrameStream
s.Registry of all standard frame types defined by the HTTP/2 specification.
A writer responsible for marshaling HTTP/2 frames to the channel.
Configuration specific to
Http2FrameWriter
HTTP/2 GOAWAY frame.
A collection of headers sent or received via HTTP/2.
HTTP/2 pseudo-headers names.
Decodes HPACK-encoded headers blocks into
Http2Headers
.Configuration related elements for the
Http2HeadersDecoder
interfaceEncodes
Http2Headers
into HPACK-encoded headers blocks.Configuration related elements for the
Http2HeadersEncoder
interfaceDetermine if a header name/value pair is treated as
sensitive.
HTTP/2 HEADERS frame.
Decorator around a
Http2FrameReader
that logs all inbound frames before calling
back the listener.Manager for the life cycle of the HTTP/2 connection.
A
Http2FlowController
for controlling the inbound flow of DATA
frames from the remote endpoint.Enforce a limit on the maximum number of RST frames that are allowed per a window
before the connection will be closed with a GO_AWAY frame.
Deprecated.
use
Http2FrameCodecBuilder
together with Http2MultiplexHandler
.Deprecated.
use
Http2FrameCodecBuilder
together with Http2MultiplexHandler
.An HTTP/2 handler that creates child channels for each stream.
This exception is thrown when there are no more stream IDs available for the current connection
Decorator around a
Http2FrameWriter
that logs all outbound frames before calling the
writer.HTTP/2 PING Frame.
HTTP/2 Priority Frame
Provides an extensibility point for users to define the validity of push requests.
HTTP/2 Push Promise Frame
A
Http2FlowController
for controlling the flow of outbound DATA
frames to the remote
endpoint.Implementations of this interface are used to progressively write chunks of the underlying
payload to the stream.
Listener to the number of flow-controlled bytes written per stream.
HTTP/2 RST_STREAM frame.
Provides utilities related to security requirements specific to HTTP/2.
Server-side codec for performing a cleartext upgrade from HTTP/1.x to HTTP/2.
Settings for one endpoint in an HTTP/2 connection.
An ack for a previously received
Http2SettingsFrame
.HTTP/2 SETTINGS frame.
Provides a Consumer like interface to consume remote settings received but not yet ACKed.
A single stream within an HTTP2 connection.
The allowed states of an HTTP2 stream.
ChannelId implementation which is used by our
Http2StreamChannel
implementation.ChannelOption
s that are specific to Http2StreamChannel
s.A frame whose meaning may apply to a particular stream, instead of the entire connection.
This handler converts from
Http2StreamFrame
to HttpObject
,
and back.A visitor that allows iteration over a collection of streams.
HTTP/2 WINDOW_UPDATE frame.
A
ChunkedInput
that fetches data chunk by chunk for use with HTTP chunked transfers.A combination of
HttpRequestEncoder
and HttpResponseDecoder
which enables easier client side HTTP implementation.Client-side handler for handling an HTTP upgrade handshake to another protocol.
The source codec that is used in the pipeline initially.
A codec that the source can be upgraded to.
User events that are fired to notify about upgrade status.
An HTTP chunk which is used for HTTP chunked transfer-encoding.
Compresses an
HttpMessage
and an HttpContent
in gzip
or
deflate
encoding while respecting the "Accept-Encoding"
header.Decodes the content of the received
HttpRequest
and HttpContent
.Encodes the content of the outbound
HttpResponse
and HttpContent
.Provides utility methods and constants for the HTTP/2 to HTTP conversion
Provides the HTTP header extensions used to carry HTTP/2 information in HTTP objects
Utility which translates HTTP/2 headers to HTTP/1 headers.
Extended interface for InterfaceHttpData
Interface to enable creation of InterfaceHttpData objects
A configuration object for specifying the behaviour of
HttpObjectDecoder
and its subclasses.A user event designed to communicate that a expectation has failed and there should be no expectation that a
body will follow.
Deprecated.
Use
DateFormatter
insteadFirst obsolete format
Second obsolete format
Standard HTTP header names.
Provides the constants for the standard HTTP header names and values and
commonly used utility methods that accesses an
HttpMessage
.Deprecated.
Use
HttpHeaderNames
instead.Deprecated.
Use
HttpHeaderValues
instead.An interface for creating
HttpHeaders
instances.Functions used to perform various validations of HTTP header names and values.
Standard HTTP header values.
An interface that defines an HTTP message, providing common properties for
HttpRequest
and HttpResponse
.Provides some utility methods for HTTP message implementations.
A
ChannelHandler
that aggregates an HttpMessage
and its following HttpContent
s into a single FullHttpRequest
or FullHttpResponse
(depending on if it used to handle requests or responses)
with no following HttpContent
s.The internal state of
HttpObjectDecoder
.Shared Static object between HttpMessageDecoder, HttpPostRequestDecoder and HttpPostRequestEncoder
This class intends to decrease the CPU in seeking ahead some bytes in
HttpPostRequestDecoder
Allowed mechanism for multipart
mechanism := "7bit"
/ "8bit"
/ "binary"
Not allowed: "quoted-printable"
/ "base64"
This decoder will decode Body and can handle POST BODY.
This decoder will decode Body and can handle POST BODY.
Exception when the body is fully decoded, even if there is still data
Exception when an error occurs while decoding
states follow NOTSTARTED PREAMBLE ( (HEADERDELIMITER DISPOSITION (FIELD |
FILEUPLOAD))* (HEADERDELIMITER DISPOSITION MIXEDPREAMBLE (MIXEDDELIMITER
MIXEDDISPOSITION MIXEDFILEUPLOAD)+ MIXEDCLOSEDELIMITER)* CLOSEDELIMITER)+
EPILOGUE
First getStatus is: NOSTARTED
Content-type: multipart/form-data, boundary=AaB03x => PREAMBLE in Header
--AaB03x => HEADERDELIMITER content-disposition: form-data; name="field1"
=> DISPOSITION
Joe Blow => FIELD --AaB03x => HEADERDELIMITER content-disposition:
form-data; name="pics" => DISPOSITION Content-type: multipart/mixed,
boundary=BbC04y
--BbC04y => MIXEDDELIMITER Content-disposition: attachment;
filename="file1.txt" => MIXEDDISPOSITION Content-Type: text/plain
...
Exception when try reading data from request in chunked format, and not
enough data are available (need more chunks)
Exception when a field content is too long
Exception when the maximum number of fields for a given form is reached
This encoder will help to encode Request for a FORM as POST.
Different modes to use to encode form data.
Exception when an error occurs while encoding
This decoder will decode Body and can handle POST BODY.
Handler that establishes a blind forwarding proxy tunnel using
HTTP/1.1 CONNECT request.
Specific case of a connection failure, which may include headers from the proxy.
An HTTP request.
An HTTP response.
Defines the common schemes used for the HTTP protocol as defined by
rfc7230.
A combination of
HttpRequestDecoder
and HttpResponseEncoder
which enables easier server side HTTP implementation.HttpServerKeepAliveHandler helps close persistent connections when appropriate.
A server-side handler that receives HTTP requests and optionally performs a protocol switch if
the requested protocol is supported.
The source codec that is used in the pipeline initially.
A codec that the source can be upgraded to.
Creates a new
HttpServerUpgradeHandler.UpgradeCodec
for the requested protocol name.User event that is fired to notify about the completion of an HTTP upgrade
to another protocol.
The class of HTTP status.
Translates HTTP/1.x object writes into HTTP/2 frames.
Builder which builds
HttpToHttp2ConnectionHandler
objects.Utility methods useful in the HTTP context.
This class will not do any filtering of ciphers suites.
A user event triggered by
IdleStateHandler
when a Channel
is idle.Triggers an
IdleStateEvent
when a Channel
has not performed
read, write, or both operation for a while.An
IllegalStateException
which is raised when a user attempts to access a ReferenceCounted
whose
reference count has been decreased to 0 (and consequently freed).Executes
Runnable
objects in the caller's thread.Executor
which execute tasks in the callers thread.This adapter provides just header/data events from the HTTP message flow defined
in [RFC 7540], Section 8.1.
Allows messages to be sent up the pipeline before the next phase in the
HTTP message flow is detected.
Builds an
InboundHttp2ToHttpAdapter
.Translates HTTP/1.x object reads into HTTP/2 frames.
A skeletal
NameResolver
implementation that resolves InetAddress
.A
AbstractAddressResolver
that resolves InetSocketAddress
.Inline commands of RESP.
An insecure
TrustManagerFactory
that trusts all X.509 certificates without any verification.Utilities for int-based primitive collections.
An empty map.
An unmodifiable wrapper around a
IntObjectMap
.Deprecated.
For removal in netty 4.2
Integers of RESP.
Interface for all Objects that could be encoded/decoded using HttpPostRequestEncoder/Decoder
This decoder will decode Body and can handle POST BODY.
This Attribute is only for Encoder use to insert special command between object if needed
(like Multipart Mixed mode)
Internal-use-only logger used by Netty.
Creates an
InternalLogger
or changes the default factory
implementation.The log level that
InternalLogger
can log at.The internal data structure that stores the thread-local variables for Netty and all
FastThreadLocal
s.Internet Protocol (IP) families used by the
DatagramChannel
A hash map implementation of
IntObjectMap
that uses open addressing for keys.Interface for a primitive map that uses
int
s as keys.A primitive entry in the map, provided by the iterator from
IntObjectMap.entries()
Internal primitive priority queue, used by
PoolChunk
.Represents a supplier of
int
-valued results.Represent an array of struct array and so can be passed directly over via JNI without the need to do any more
array copies.
Implement this interface to create new rules.
Used in
IpFilterRule
to decide if a matching IP Address should be allowed or denied to connect.
This class allows one to filter new
Channel
s based on the
IpSubnetFilter
s passed to its constructor.Use this class to create rules for
RuleBasedIpFilter
that group IP addresses into subnets.This comparator is only used for searching.
Deprecated.
Deprecated.
A listener to be notified by which protocol was select by its peer.
Factory interface for
JdkApplicationProtocolNegotiator.ProtocolSelectionListener
objects.Interface to define the role of an application protocol selector in the SSL handshake process.
Factory interface for
JdkApplicationProtocolNegotiator.ProtocolSelector
objects.Abstract factory pattern for wrapping an
SSLEngine
object.Common base class for
JdkApplicationProtocolNegotiator
classes to inherit from.The
JdkApplicationProtocolNegotiator
to use if you do not care about NPN or ALPN and are using
SslProvider.JDK
.java.util.logging
logger.
Logger factory which creates a
java.util.logging
logger.
Deprecated.
Deprecated.
An
SslContext
which uses JDK's SSL/TLS implementation.Deprecated.
Decompress a
ByteBuf
using the inflate algorithm.Compresses a
ByteBuf
using the deflate algorithm.Splits a byte stream of JSON objects and arrays into individual objects/arrays and passes them up the
ChannelPipeline
.Compresses a
ByteBuf
using the deflate algorithm.Implements
Knuth-Morris-Pratt
string search algorithm.
If KQueue is available the JNI resources will be loaded when this class loads.
Represents an array of kevent structures, backed by offheap memory.
EventLoop
which uses kqueue under the covers.This class is necessary to break the following cyclic dependency:
JNI_OnLoad
JNI Calls FindClass because RegisterNatives (used to register JNI methods) requires a class
FindClass loads the class, but static members variables of that class attempt to call a JNI method which has not
yet been registered.
java.lang.UnsatisfiedLinkError is thrown because native method has not yet been registered.
Static members which call JNI methods must not be declared in this class!
A last chunk of Bulk Strings.
The last
HttpContent
which has trailing headers.The
MemcacheContent
which signals the end of the content batch.The last part of a sequence of
SmtpContent
s that are sent after a DATA
request.The last
StompContentSubframe
which signals the end of the content batchA decoder that splits the received
ByteBuf
s dynamically by the
value of the length field in the message.An encoder that prepends the length of the message.
This class is necessary to break the following cyclic dependency:
JNI_OnLoad
JNI Calls FindClass because RegisterNatives (used to register JNI methods) requires a class
FindClass loads the class, but static members variables of that class attempt to call a JNI method which has not
yet been registered.
java.lang.UnsatisfiedLinkError is thrown because native method has not yet been registered.
Static members which call JNI methods must not be declared in this class!
A decoder that splits the received
ByteBuf
s on line endings.A class to represent line separators in different environments.
A socket which provides access Linux native methods.
An endpoint in the local transport.
A
Channel
for the local transport.Deprecated.
Use
DefaultEventLoopGroup
instead.A
ServerChannel
for the local transport which allows in VM communication.SLF4J logger which is location aware and so will log the correct origin of the
logging event by filter out the wrapper itself.
Apache Log4J
logger.
Logger factory which creates an
Apache Log4J
logger.
A
DnsQueryLifecycleObserverFactory
that enables detailed logging in the DnsNameResolver
.A
ChannelHandler
that logs all events using a logging framework.Maps the regular
LogLevel
s with the InternalLogLevel
ones.Utilities for long-based primitive collections.
An empty map.
An unmodifiable wrapper around a
LongObjectMap
.Counter for long.
Internal primitive map implementation that is specifically optimised for the runs availability map use case in
PoolChunk
.A hash map implementation of
LongObjectMap
that uses open addressing for keys.Interface for a primitive map that uses
long
s as keys.A primitive entry in the map, provided by the iterator from
LongObjectMap.entries()
DnsServerAddressStreamProvider
implementation which makes use of the same mechanism as
Apple's open source mDNSResponder to retrieve the
current nameserver configuration of the system.Maintains the mapping from the objects of one type to the objects of the other type.
Math utility methods.
RecvByteBufAllocator
that limits a read operation based upon a maximum value per individual read
and a maximum amount when a read operation is attempted by the event loop.RecvByteBufAllocator
that limits the number of read operations that will be attempted when a read operation
is attempted by the event loop.An Memcache content chunk.
Marker interface for both ascii and binary messages.
Defines a common interface for all
MemcacheObject
implementations.Memory implementation of Attributes
Default FileUpload implementation that stores file into memory.
Warning: be aware of the memory limitation.
Warning: be aware of the memory limitation.
Raised by
MessageAggregator
when aggregation fails due to an unexpected message sequence.An abstract
ChannelHandler
that aggregates a series of message objects into a single aggregated message.Formats messages according to very simple substitution rules.
Responsible to estimate the size of a message.
ChannelOutboundHandlerAdapter
which encodes message in a stream-like fashion from one message to an
ByteBuf
.A Codec for on-the-fly encoding/decoding of message.
ChannelInboundHandlerAdapter
which decodes from one message to an other message.ChannelOutboundHandlerAdapter
which encodes from one message to an other message
For example here is an implementation which decodes an Integer
to an String
.Mixed implementation using both in Memory and in File with a limit of size
Mixed implementation using both in Memory and in File with a limit of size
See MQTTV3.1/connack
Variable header of
MqttConnectMessage
See MQTTV3.1/connect
Payload of
MqttConnectMessage
Return Code of
MqttConnAckMessage
Variable Header for the
MqttConnectMessage
States of the decoder.
A
MqttIdentifierRejectedException
which is thrown when a CONNECT request contains invalid client identifier.Base class for all MQTT message types.
Utility class with factory methods to create different types of MQTT messages.
Variable Header containing, Packet Id and Properties as in MQTT v5 spec.
Variable Header containing only Message Id
See MQTTV3.1/msg-id
MQTT Message Types.
MQTT Properties container
MQTT property base class
See MQTTV3.1/puback
See MQTTV3.1/publish
Variable Header of the
MqttPublishMessage
Variable Header containing Packet Id, reason code and Properties as in MQTT v5 spec.
Variable Header for AUTH and DISCONNECT messages represented by
MqttMessage
Provides a set of enumeration that exposes standard MQTT 5 reason codes used by various messages.
Reason codes for MQTT Auth message.
Reason codes for MQTT Disconnect message.
Reason codes for MQTT PubAck message.
Reason codes for MQTT PubComp message.
Reason codes for MQTT PubRec message.
Reason codes for MQTT PubRel message.
Reason codes for MQTT SubAck message.
Reason codes for MQTT UnsubAck message.
See MQTTV3.1/suback
Payload of the
MqttSubAckMessage
Payload of the
MqttSubscribeMessage
Model the SubscriptionOption used in Subscribe MQTT v5 packet
Contains a topic name and Qos Level.
A
MqttUnacceptableProtocolVersionException
which is thrown when
a CONNECT request contains unacceptable protocol version.Payload for MQTT unsuback message as in V5.
Payload of the
MqttUnsubscribeMessage
Mqtt version specific constant values used by multiple classes in mqtt-codec.
A
DnsServerAddressStreamProvider
which iterates through a collection of
DnsServerAddressStreamProvider
until the first non-null
result is found.Interface for
SearchProcessor
that implements simultaneous search for multiple strings.Abstract base class for
EventExecutorGroup
implementations that handles their tasks with multiple threads at
the same time.Abstract base class for
EventLoopGroup
implementations that handles their tasks with multiple threads at
the same time.Resolves an arbitrary string that represents the name of an endpoint into an address.
Special
Comparator
implementation to sort the nameservers to use when follow redirects.Native helper methods
Native helper methods
Support sendmmsg(...) on linux with GLIBC 2.14+
Internal usage only!
Helper class to load JNI resources.
A Utility to Call the
System.load(String)
or System.loadLibrary(String)
.This class is necessary to break the following cyclic dependency:
JNI_OnLoad
JNI Calls FindClass because RegisterNatives (used to register JNI methods) requires a class
FindClass loads the class, but static members variables of that class attempt to call a JNI method which has not
yet been registered.
java.lang.UnsatisfiedLinkError is thrown because native method has not yet been registered.
Static members which call JNI methods must not be declared in this class!
A utility class for wrapping calls to
Runtime
.Holder class for available processors to enable testing.
A class that holds a number of network-related constants.
Provides
ChannelOption
over a given SocketOption
which is then passed through the underlying
NetworkChannel
.An NIO datagram
Channel
that sends and receives an
AddressedEnvelopeinvalid input: '<'ByteBuf, SocketAddress>
.The default
NioDatagramChannelConfig
implementation.DuplexChannel
which uses NIO selector based implementation to support
UNIX Domain Sockets.SingleThreadEventLoop
implementation which register the Channel
's to a
Selector
and so does the multi-plexing of these in the event loop.SctpChannel
implementation which use non-blocking mode and allows to read /
write SctpMessage
s to the underlying SctpChannel
.SctpServerChannel
implementation which use non-blocking mode to accept new
connections and create the NioSctpChannel
for them.A
ServerChannel
implementation which uses
NIO selector based implementation to support UNIX Domain Sockets.A
ServerSocketChannel
implementation which uses
NIO selector based implementation to accept new connections.SocketChannel
which uses NIO selector based implementation.An arbitrary task that can be executed by
NioEventLoop
when a SelectableChannel
becomes ready.EventExecutorGroup
which will preserve Runnable
execution order but makes no guarantees about what
EventExecutor
(and therefore Thread
) will be used to execute the Runnable
s.A
AddressResolver
that does not perform any resolution but always reports successful resolution.A noop
AuthoritativeDnsServerCache
that actually never caches anything.A noop DNS cache that actually never caches anything.
Special
SSLException
which will get thrown if a packet is
received that not looks like a TLS/SSL record.Deprecated.
This class has been deprecated with no replacement,
because serialization can be a security liability
Deprecated.
This class has been deprecated with no replacement,
because serialization can be a security liability
Deprecated.
This class has been deprecated with no replacement,
because serialization can be a security liability
Deprecated.
This class has been deprecated with no replacement,
because serialization can be a security liability
Light-weight object pool.
Handle for an pooled
Object
that will be used to notify the ObjectPool
once it can
reuse the pooled Object
again.Creates a new Object which references the given
ObjectPool.Handle
and calls ObjectPool.Handle.recycle(Object)
once
it can be re-used.A grab-bag of useful utility methods.
A handler for SSL clients to handle and act upon stapled OCSP responses.
OcspServerCertificateValidator
validates incoming server's certificate
using OCSP.Deprecated.
use NIO / EPOLL / KQUEUE transport.
Deprecated.
use NIO / EPOLL / KQUEUE transport.
Deprecated.
use NIO / EPOLL / KQUEUE transport.
Deprecated.
use NIO / EPOLL / KQUEUE transport.
Deprecated.
use
NioSctpChannel
.Deprecated.
use
NioSctpServerChannel
.Deprecated.
use NIO / EPOLL / KQUEUE transport.
Deprecated.
use NIO / EPOLL / KQUEUE transport.
Deprecated.
use NIO / EPOLL / KQUEUE transport.
Deprecated.
use NIO / EPOLL / KQUEUE transport.
Generates a self-signed certificate using
sun.security.x509
package provided by OpenJDK.Tells if
netty-tcnative
and its OpenSSL support
are available.Deprecated.
OpenSslKeyMaterialProvider
that will cache the OpenSslKeyMaterial
to reduce the overhead
of parsing the chain and the key for generation of the material.Wraps another
KeyManagerFactory
and caches its chains / certs for an alias for better performance when using
SslProvider.OPENSSL
or SslProvider.OPENSSL_REFCNT
.Provides compression and decompression implementations for TLS Certificate Compression
(RFC 8879).
Configuration for TLS1.3 certificate compression extension.
The configuration for algorithm.
The usage mode of the
OpenSslCertificateCompressionAlgorithm
.Builder for an
OpenSslCertificateCompressionAlgorithm
.A special
CertificateException
which allows to specify which error code is included in the
SSL Record.A client-side
SslContext
which uses OpenSSL's SSL/TLS implementation.OpenSslSessionCache
that is used by the client-side.Host / Port tuple used to find a
OpenSslInternalSession
in the cache.This class will use a finalizer to ensure native resources are automatically cleaned up.
Deprecated.
Implements a
SSLEngine
using
OpenSSL BIO abstractions.SSLSession
that is specific to our native implementation.Holds references to the native key-material that is used by OpenSSL.
Provides
OpenSslKeyMaterial
for a given alias.Deprecated.
Allow to customize private key signing / decrypting (when using RSA).
A server-side
SslContext
which uses OpenSSL's SSL/TLS implementation.OpenSslSessionContext
implementation which offers extra methods which are only useful for the server-side.SSLSession
sub-type that is used by our native implementation.SSLSessionCache
implementation for our native SSL implementation.OpenSslInternalSession
implementation which wraps the native SSL_SESSION* while in cache.OpenSSL specific
SSLSessionContext
implementation.Represent the session ID used by an
OpenSslInternalSession
.Stats exposed by an OpenSSL session context.
Session Ticket Key
Special
KeyManagerFactory
that pre-compute the keymaterial used when SslProvider.OPENSSL
or
SslProvider.OPENSSL_REFCNT
is used and so will improve handshake times and its performance.OpenSslKeyMaterialProvider
implementation that pre-compute the OpenSslKeyMaterial
for
all aliases.Utility which allows to wrap
X509TrustManager
implementations with the internal implementation used by
SSLContextImpl
that provides extended verification.OptionalSslHandler
is a utility decoder to support both SSL and non-SSL handlers
based on the first message received.Marker interface for
EventExecutor
s that will process all submitted tasks in an ordered / serial fashion.OutOfMemoryError
that is throws if PlatformDependent.allocateDirectNoCleaner(int)
can not allocate
a new ByteBuffer
due memory restrictions.PcapWriteHandler
captures ByteBuf
from SocketChannel
/ ServerChannel
or DatagramPacket
and writes it into Pcap OutputStream
.Builder for
PcapWriteHandler
User credentials discovered for the peer unix domain socket.
A marker interface for PEM encoded values.
This is a special purpose implementation of a
PrivateKey
which allows the
user to pass PEM/PKCS#8 encoded key material straight into OpenSslContext
without having to parse and re-encode bytes in Java land.Reads a PEM file and converts it into a list of DERs so that they are imported into a
KeyStore
easily.A PEM encoded value.
This is a special purpose implementation of a
X509Certificate
which allows
the user to pass PEM/PKCS#8 encoded data straight into OpenSslContext
without
having to parse and re-encode bytes in Java land.Some pending write which should be picked up later.
A queue of write operations which are pending for later execution.
Holds all meta-data and construct the linked-list structure.
Per-frame implementation of deflate decompressor.
Per-frame implementation of deflate compressor.
permessage-deflate
handshake implementation.
Per-message implementation of deflate decompressor.
Per-message implementation of deflate compressor.
permessage-deflate
handshake implementation.
Web Socket frame containing binary data.
Utility that detects various properties specific to the current runtime
environment, such as Java version and the availability of the
sun.misc.Unsafe
object.The
PlatformDependent
operations which requires access to sun.misc.*
.Web Socket frame containing binary data.
Expose metrics for an arena.
Description of algorithm for PageRun/PoolSubpage allocation from PoolChunk
Notation: The following terms are important to understand the code
> page - a page is the smallest unit of memory chunk that can be allocated
> run - a run is a collection of pages
> chunk - a chunk is a collection of runs
> in this code chunkSize = maxPages * pageSize
To begin we allocate a byte array of size = chunkSize
Whenever a ByteBuf of given size needs to be created we search for the first position
in the byte array that has enough empty space to accommodate the requested size and
return a (long) handle that encodes this offset information, (this memory segment is then
marked as reserved so it is always used by exactly one ByteBuf and no more)
For simplicity all sizes are normalized according to
} method.
invalid @link
{@link PoolArena#sizeClass#size2SizeIdx(int)
Metrics for a list of chunks.
Metrics for a chunk.
Exposed metric for
PooledByteBufAllocator
.Metrics for a sub-page.
Acts a Thread cache for allocations.
Cache used for buffers which are backed by NORMAL size.
Cache used for buffers which are backed by TINY or SMALL size.
Wraps another
ByteBufAllocator
and use heapbuffers everywhere except when a direct buffer is explicit
requested.A
CodecException
which is thrown when a Channel
is closed unexpectedly before
the codec finishes handling the current message, such as missing response while waiting for a
request.Provides methods for
DefaultPriorityQueue
to maintain internal state.A
Future
which is used to indicate the progress of an operation.Special
ProgressiveFuture
which is writable.Special
Future
which is writable.Deprecated.
A promise combiner monitors the outcome of a number of discrete futures, then notifies a final, aggregate promise
when all of the combined futures are finished.
Internal utilities to notify
Promise
s.GenericFutureListener
implementation which takes other Promise
s
and notifies them on completion.Result of detecting a protocol.
The state of the current detection.
Helper class which convert the
InternetProtocolFamily
.A common abstraction for protocols that establish blind forwarding proxy tunnels.
This pseudorandom function (PRF) takes as input a secret, a seed, and
an identifying label and produces an output of arbitrary length.
Splits an HTTP query string into a path string and key-value parameter pairs.
Creates a URL-encoded URI from a path string and key-value parameter pairs.
Deprecated.
Do not use.
Read-only ByteBuf which wraps a read-only ByteBuffer.
A variant of
Http2Headers
which only supports read-only methods.A variant of
HttpHeaders
which only supports read-only methods.Read-only ByteBuf which wraps a read-only direct ByteBuffer and use unsafe for best performance.
A
TimeoutException
raised by ReadTimeoutHandler
when no data
was read within a certain period of time.Raises a
ReadTimeoutException
when no data was read within a certain
period of time.Allocates a new receive buffer whose capacity is probably large enough to read all inbound data and small enough
not to waste its space.
A
RecvByteBufAllocator.Handle
which delegates all call to some other RecvByteBufAllocator.Handle
.Deprecated.
A simple list which is recyclable.
Light-weight object pool based on a thread-local stack.
This is an implementation of
MessagePassingQueue
, similar to what might be returned from
PlatformDependent.newMpscQueue(int)
, but intended to be used for debugging purpose.Aggregates
RedisMessage
parts into ArrayRedisMessage
.A
ChannelHandler
that aggregates an BulkStringHeaderRedisMessage
and its following BulkStringRedisContent
s into a single FullBulkStringRedisMessage
with no following BulkStringRedisContent
s.Utilities for codec-redis.
Constant values for Redis encoder/decoder.
Decodes the Redis protocol into
RedisMessage
objects following
RESP (REdis Serialization Protocol).Encodes
RedisMessage
into bytes following
RESP (REdis Serialization Protocol).RedisMessage is base interface for codec-redis.
A strategy interface for caching
RedisMessage
s.Type of RESP (REdis Serialization Protocol).
A reference-counted object that requires explicit deallocation.
A client-side
SslContext
which uses OpenSSL's SSL/TLS implementation.An implementation of
SslContext
which works with libraries that support the
OpenSsl C library API.Implements a
SSLEngine
using
OpenSSL BIO abstractions.A server-side
SslContext
which uses OpenSSL's SSL/TLS implementation.Common logic for
ReferenceCounted
implementationsCollection of method to handle objects that may implement
ReferenceCounted
.Releases the objects when the thread that called
ReferenceCountUtil.releaseLater(Object)
has been terminated.A
ChannelFactory
that instantiates a new Channel
by invoking its default constructor reflectively.Similar to
RejectedExecutionHandler
but specific to SingleThreadEventExecutor
.Expose helper methods which create different
RejectedExecutionHandler
s.A specialized variation of
ByteToMessageDecoder
which enables implementation
of a non-blocking decoder in the blocking I/O paradigm.Special
ByteBuf
implementation which is used by the ReplayingDecoder
Looks up the
nameserver
s from the /etc/resolv.conf
file, intended for Linux and macOS.ChannelOutboundHandlerAdapter
which will resolve the SocketAddress
that is passed to
ResolveAddressHandler.connect(ChannelHandlerContext, SocketAddress, SocketAddress, ChannelPromise)
if it is not already resolved
and the AddressResolver
supports the type of SocketAddress
.Defined resolved address types.
Deprecated.
please use
ResourceLeakTracker
as it may lead to false-positives.Represents the level of resource leak detection.
This static factory should be used to load
ResourceLeakDetector
s as neededDefault implementation that loads custom leak detector via system property
Deprecated.
This class will be removed in the future version.
A hint object that provides human-readable message for easier resource leak tracking.
A utility class that provides various common operations and constants
related to loading resources
An interface that
TrustManager
instances can implement, to be notified of resumed SSL sessions.A
AddressResolverGroup
of DnsNameResolver
s that supports random selection of destination addresses if
multiple are provided by the nameserver.A
NameResolver
that resolves InetAddress
and force Round Robin by choosing a single address
randomly in SimpleNameResolver.resolve(String)
and SimpleNameResolver.resolve(String, Promise)
if multiple are returned by the NameResolver
.Decodes
ByteBuf
s into RTSP messages represented in
HttpMessage
s.Standard RTSP header names.
Deprecated.
Use
RtspHeaderNames
or RtspHeaderValues
instead.Deprecated.
Use
RtspHeaderNames
instead.Deprecated.
Use
RtspHeaderValues
instead.Standard RTSP header names.
The request getMethod of RTSP.
Deprecated.
Use
RtspDecoder
instead.Deprecated.
Use
RtspEncoder
instead.Deprecated.
Use
RtspDecoder
directly insteadDeprecated.
Use
RtspEncoder
directly insteadDeprecated.
Use
RtspDecoder
directly insteadDeprecated.
Use
RtspEncoder
directly insteadThe getStatus code and its description of a RTSP response.
The version of RTSP.
This class allows one to filter new
Channel
s based on the
IpFilterRule
s passed to its constructor.The result of a scheduled asynchronous operation.
A SCTP/IP
Channel
interface for single SCTP association.A
ChannelConfig
for a SctpChannel
.Option for configuring the SCTP transport
A ChannelHandler which receives
SctpMessage
s which belong to a application protocol form a specific
SCTP Stream and decode it as ByteBuf
.Representation of SCTP Data Chunk
MessageToMessageDecoder
which will take care of handle fragmented SctpMessage
s, so
only complete SctpMessage
s will be forwarded to the next
ChannelInboundHandler
.AbstractNotificationHandler
implementation which will handle all Notification
s by trigger a
Notification
user event in the ChannelPipeline
of a SctpChannel
.A ChannelHandler which transform
ByteBuf
to SctpMessage
and send it through a specific stream
with given protocol identifier.A SCTP/IP
ServerChannel
which accepts incoming SCTP/IP associations.A
ChannelConfig
for a SctpServerChannelConfig
.Interface for
ByteProcessor
that implements string search.Deprecated.
Allows to use GSO
if the underlying OS supports it.
Select strategy interface.
Factory that creates a new
SelectStrategy
every time.Generates a temporary self-signed certificate for testing purposes.
A
DnsServerAddressStreamProvider
which is backed by a sequential list of DNS servers.Bootstrap
sub-class which allows easy bootstrap of ServerChannel
Exposes the configuration of a
ServerBootstrapConfig
.MaxMessagesRecvByteBufAllocator
implementation which should be used for ServerChannel
s.A RFC6265 compliant cookie decoder to be used server side.
A RFC6265 compliant cookie encoder to be used server side,
so some fields are sent (Version is typically ignored).
Deprecated.
Use
ServerCookieEncoder
insteadA TCP/IP
ServerChannel
which accepts incoming TCP/IP connections.A
ChannelConfig
for a ServerSocketChannel
.Utilities for short-based primitive collections.
An empty map.
An unmodifiable wrapper around a
ShortObjectMap
.A hash map implementation of
ShortObjectMap
that uses open addressing for keys.Interface for a primitive map that uses
short
s as keys.A primitive entry in the map, provided by the iterator from
ShortObjectMap.entries()
A special
Error
which is used to signal some state or request by throwing it.Converts OpenSSL signature Algorithm names to
Java signature Algorithm names.
ChannelInboundHandlerAdapter
which allows to explicit only handle a specific type of messages.Simple
ChannelPool
implementation which will create new Channel
s if someone tries to acquire
a Channel
but none is in the pool atm.Helps to implement a custom
KeyManagerFactory
.A skeletal
NameResolver
implementation.Simple Strings of RESP.
Helps to implement a custom
TrustManagerFactory
.ChannelInboundHandlerAdapter
which allows to conveniently only handle a specific type of user events.Abstract base class for
OrderedEventExecutor
's that execute all its submitted tasks in a single thread.Deprecated.
override
SingleThreadEventExecutor.wakesUpForTask(java.lang.Runnable)
to re-create this behaviourAbstract base class for
EventLoop
s that execute all its submitted tasks in a single thread.A
DnsServerAddressStreamProvider
which always uses a single DNS server for resolution.SizeClasses requires
pageShifts
to be defined prior to inclusion,
and it in turn defines:Expose metrics for an SizeClasses.
SLF4J logger.
Logger factory which creates a SLF4J
logger.
Deprecated.
Do not use.
The command part of a
SmtpRequest
.Content that is sent after the
DATA
request.An SMTP request.
Encoder for SMTP requests.
Provides utility methods to create
SmtpRequest
s.A SMTP response
Decoder for SMTP responses.
Deprecated.
Use
SnappyFrameDecoder
instead.Uncompresses a
ByteBuf
encoded with the Snappy framing format.Deprecated.
Use
SnappyFrameEncoder
instead.Compresses a
ByteBuf
using the Snappy framing format.SnappyOptions
holds config for
Snappy compression.Event that is fired once we did a selection of a
SslContext
based on the SNI hostname
,
which may be because it was successful or there was an error.Enables SNI
(Server Name Indication) extension for server side SSL.
Provides a JNI bridge to native socket operations.
A TCP/IP socket
Channel
.A
ChannelConfig
for a SocketChannel
.Provides socket operations with privileges enabled.
Decodes a single
Socks4CommandResponse
from the inbound ByteBuf
s.Encodes a
Socks4CommandRequest
into a ByteBuf
.A SOCKS4a
CONNECT
or BIND
request.A SOCKS4a response.
The status of
Socks4CommandResponse
.The type of
Socks4CommandRequest
.A tag interface that all SOCKS4a protocol messages implement.
Handler that establishes a blind forwarding proxy tunnel using
SOCKS4 protocol.
Decodes a single
Socks4CommandRequest
from the inbound ByteBuf
s.Encodes a
Socks4CommandResponse
into a ByteBuf
.Decodes a SOCKS5 address field into its string representation.
Encodes a SOCKS5 address into binary representation.
The type of address in
Socks5CommandRequest
and Socks5CommandResponse
.The authentication method of SOCKS5.
Encodes a client-side
Socks5Message
into a ByteBuf
.A SOCKS5 request detail message, as defined in
the section 4, RFC1928.
Decodes a single
Socks5CommandRequest
from the inbound ByteBuf
s.A response to a SOCKS5 request detail message, as defined in
the section 6, RFC1928.
Decodes a single
Socks5CommandResponse
from the inbound ByteBuf
s.The status of
Socks5CommandResponse
.The type of
Socks5CommandRequest
.An initial SOCKS5 authentication method selection request, as defined in
the section 3, RFC1928.
Decodes a single
Socks5InitialRequest
from the inbound ByteBuf
s.An initial SOCKS5 authentication method selection request, as defined in
the section 3, RFC1928.
Decodes a single
Socks5InitialResponse
from the inbound ByteBuf
s.A tag interface that all SOCKS5 protocol messages implement.
A SOCKS5 subnegotiation request for username-password authentication, as defined in
the section 2, RFC1929.
Decodes a single
Socks5PasswordAuthRequest
from the inbound ByteBuf
s.A SOCKS5 subnegotiation response for username-password authentication, as defined in
the section 2, RFC1929.
Decodes a single
Socks5PasswordAuthResponse
from the inbound ByteBuf
s.The status of
Socks5PasswordAuthResponse
.Handler that establishes a blind forwarding proxy tunnel using
SOCKS Protocol Version 5.
Encodes a server-side
Socks5Message
into a ByteBuf
.An socks auth request.
Decodes
ByteBuf
s into SocksAuthRequest
.An socks auth response.
Decodes
ByteBuf
s into SocksAuthResponse
.An socks cmd request.
Decodes
ByteBuf
s into SocksCmdRequest
.A socks cmd response.
Decodes
ByteBuf
s into SocksCmdResponse
.An socks init request.
Decodes
ByteBuf
s into SocksInitRequest
.An socks init response.
Decodes
ByteBuf
s into SocksInitResponse
.An abstract class that defines a SocksMessage, providing common properties for
SocksRequest
and SocksResponse
.An interface that all SOCKS protocol messages implement.
Encodes an
SocksMessage
into a ByteBuf
.Detects the version of the current SOCKS connection and initializes the pipeline with
Socks4ServerDecoder
or Socks5InitialRequestDecoder
.An abstract class that defines a SocksRequest, providing common properties for
SocksInitRequest
, SocksAuthRequest
, SocksCmdRequest
and UnknownSocksRequest
.Type of socks request
An abstract class that defines a SocksResponse, providing common properties for
SocksInitResponse
, SocksAuthResponse
, SocksCmdResponse
and UnknownSocksResponse
.Type of socks response
The version of SOCKS protocol.
A SPDY Protocol DATA Frame
A SPDY Protocol Frame
A
ChannelHandler
that encodes and decodes SPDY Frames.Decodes
ByteBuf
s into SPDY Frames.Callback interface for
SpdyFrameDecoder
.SpdyFrameDecoderDelegate
that also supports unknown frames.Encodes a SPDY Frame into a
ByteBuf
.A SPDY Protocol GOAWAY Frame
Super-class for SPDY header-block decoders.
Super-class for SPDY header-block encoders.
Provides the constants for the standard SPDY HTTP header names and commonly
used utility methods that access a
SpdyHeadersFrame
.SPDY HTTP header names
A SPDY Protocol HEADERS Frame
A combination of
SpdyHttpDecoder
and SpdyHttpEncoder
Decodes
SpdySynStreamFrame
s, SpdySynReplyFrame
s,
and SpdyDataFrame
s into FullHttpRequest
s and FullHttpResponse
s.Encodes
HttpRequest
s, HttpResponse
s, and HttpContent
s
into SpdySynStreamFrame
s and SpdySynReplyFrame
s.Provides the constants for the header names and the utility methods
used by the
SpdyHttpDecoder
and SpdyHttpEncoder
.SPDY HTTP header names
MessageToMessageCodec
that takes care of adding the right SpdyHttpHeaders.Names.STREAM_ID
to the
HttpMessage
if one is not present.A SPDY Protocol PING Frame
A SPDY Protocol RST_STREAM Frame
Manages streams within a SPDY session.
The SPDY session status code and its description.
A SPDY Protocol SETTINGS Frame
A SPDY Protocol Frame that is associated with an individual SPDY Stream
The SPDY stream status code and its description.
A SPDY Protocol SYN_REPLY Frame
A SPDY Protocol SYN_STREAM Frame
A SPDY Control frame.
A SPDY Protocol WINDOW_UPDATE Frame
ByteToMessageDecoder
which allows to be notified once a full ClientHello
was received.Event that is fired once the close_notify was received or if an failure happens before it was received.
SSLException
which signals that the exception was caused by an SSLEngine
which was
closed already.A secure socket protocol implementation which acts as a factory for
SSLEngine
and SslHandler
.Builder for configuring a new SslContext for creation.
A
SslContextOption
allows to configure a SslContext
in a type-safe
way.Each call to SSL_write will introduce about ~100 bytes of overhead.
Event that is fired once the SSL handshake is complete, which may be because it was successful or there
was an error.
SSLHandshakeException
that is used when a handshake failed due a configured timeout.The
SslMasterKeyHandler
is a channel-handler you can include in your pipeline to consume the master key
invalid input: '&' session identifier for a TLS session.Record the session identifier and master key to the
InternalLogger
named io.netty.wireshark
.SSL/TLS protocols
An enumeration of SSL/TLS protocol providers.
Constants for SSL packets.
Cheap
ClosedChannelException
that does not fill in the stacktrace.A
SSLHandshakeException
that does not fill in the stack trace.Standard Compression Options for
GzipOptions
and DeflateOptions
The state of the
PcapWriteHandler
.STOMP command
An STOMP chunk which is used for STOMP chunked transfer-encoding.
Combines
StompHeadersSubframe
and LastStompContentSubframe
into one
frame.The multimap data structure for the STOMP header names and values.
An interface that defines a
StompFrame
's command and headers.Defines a common interface for all
StompSubframe
implementations.A
ChannelHandler
that aggregates an StompHeadersSubframe
and its following StompContentSubframe
s into a single StompFrame
.Deprecated.
this should never be used by an user!
Implementation of a
Http2ConnectionEncoder
that dispatches all method call to another
Http2ConnectionEncoder
, until SETTINGS_MAX_CONCURRENT_STREAMS
is reached.Thrown if buffered streams are terminated due to this encoder being closed.
Thrown by
StreamBufferingEncoder
if buffered streams are terminated due to
receipt of a GOAWAY
.An object (used by remote flow control) that is responsible for distributing the bytes to be
written across the streams in the connection.
State information for the stream, indicating the number of bytes that are currently
streamable.
Object that performs the writing of the bytes that have been allocated for a stream.
String utility class.
The
CompleteChannelFuture
which is succeeded already.The
CompleteFuture
which is succeeded already.This class will filter all requested ciphers out that are not supported by the current
SSLEngine
.Annotation to suppress forbidden-apis errors inside a whole class, a method, or a field.
Annotation to suppress the Java 6 source code requirement checks for a method.
Deprecated.
use the Little Endian accessors, e.g.
Utility class for SWAR (SIMD within a register) operations.
A collection of utility methods to retrieve and parse the values of the Java system properties.
Web Socket text frame.
Deprecated.
will be removed in the next major release
Allow to retrieve the
EventExecutor
for the calling Thread
.Insecure
SecureRandom
which relies on PlatformDependent.threadLocalRandom()
for random number
generation.A thread local based address stream for a specific hostname.
A random number generator isolated to the current thread.
Deprecated.
this will be remove in the next-major release.
Deprecated.
this will be remove in the next-major release.
Expose details for a
Thread
.A
TimeoutException
when no data was either read or written within a
certain period of time.Schedules
TimerTask
s for one-time future execution in a background
thread.A task which is executed after the delay specified with
Timer.newTimeout(TimerTask, long, TimeUnit)
.An
DecoderException
which is thrown when the length of the frame
decoded is greater than the allowed maximum.An
TooLongFrameException
which is thrown when the length of the
content decoded is greater than the allowed maximum.An
TooLongFrameException
which is thrown when the length of the
header decoded is greater than the allowed maximum.An
TooLongFrameException
which is thrown when the length of the
line decoded is greater than the allowed maximum.Counts the number of read and written bytes for rate-limiting traffic.
Deprecated.
Represents a supplier of
boolean
-valued results which doesn't throw any checked exceptions.A
StreamByteDistributor
that ignores stream priority and uniformly allocates bytes to all
streams.This class allows one to ensure that at all times for every IP address there is at most one
Channel
connected to the server.A
DnsServerAddressStreamProvider
which is backed by a single DnsServerAddresses
.Tells if
netty-transport-native-unix
is
supported.Channel
that expose operations that are only present on UNIX
like systems.Able to parse files such as /etc/resolv.conf and
/etc/resolver to respect the system default domain servers.
Represents options defined in a file of the format etc/resolv.conf.
An unknown socks request.
An unknown socks response.
EventExecutor
implementation which makes no guarantees about the ordering of task execution that
are submitted because there may be multiple threads executing these tasks.Deprecated.
This class will be removed in the future.
Creates a new
ByteBuf
by allocating new space or by wrapping
or copying existing byte arrays, byte buffers and a string.Simplistic
ByteBufAllocator
implementation that does not pool anything.A NIO
ByteBuffer
based buffer.DuplicatedByteBuf
implementation that can do optimizations because it knows the duplicated buffer
is of type AbstractByteBuf
.Big endian Java heap buffer implementation.
A special
AbstractUnpooledSlicedByteBuf
that can make optimizations because it knows the sliced buffer is of
type AbstractByteBuf
.A NIO
ByteBuffer
based buffer.Big endian Java heap buffer implementation.
A
ByteBuf
implementation that wraps another buffer to prevent a user from increasing or decreasing the
wrapped buffer's reference count.All operations get and set as
ByteOrder.BIG_ENDIAN
.Special
SwappedByteBuf
for ByteBuf
s that use unsafe to access the byte array.Indicates a public API that can change at any time (even in minor/bugfix releases).
Thrown if an unsupported message is received by an codec.
UnsupportedOperationException
will be thrown from all ValueConverter
methods.Checks UTF8 bytes for validity
Converts to/from a generic object to the type.
Retrieves the version information of available Netty artifacts.
A address for a
VM sockets (Linux VSOCK address family).
Decodes
ByteBuf
s into WebSocketFrame
s.Encodes a
WebSocketFrame
into a ByteBuf
.Decodes a web socket frame from wire protocol version 7 format.
Encodes a web socket frame into wire protocol version 7 format.
Decodes a web socket frame from wire protocol version 8 format.
Encodes a web socket frame into wire protocol version 8 format.
Decodes a web socket frame from wire protocol version 13 format.
Encodes a web socket frame into wire protocol version 13 format.
A
ChunkedInput
that fetches data chunk by chunk for use with WebSocket chunked transfers.Extends io.netty.handler.codec.http.websocketx.extensions.compression.WebSocketClientExtensionHandler
to handle the most common WebSocket Compression Extensions.
Created once the handshake phase is done.
This handler negotiates and initializes the WebSocket Extensions.
Handshakes a client extension with the server.
Client exception during handshaking process.
Base class for web socket client handshake implementations
Performs client side opening and closing handshakes for web socket specification version draft-ietf-hybi-thewebsocketprotocol-
00
Performs client side opening and closing handshakes for web socket specification version draft-ietf-hybi-thewebsocketprotocol-
10
Performs client side opening and closing handshakes for web socket specification version draft-ietf-hybi-thewebsocketprotocol-
10
Performs client side opening and closing handshakes for web socket specification version draft-ietf-hybi-thewebsocketprotocol-
17
Creates a new
WebSocketClientHandshaker
of desired protocol version.WebSocket server configuration.
This handler does all the heavy lifting for you to run a websocket client.
Events that are fired to notify about handshake status
WebSocket status codes specified in RFC-6455.
Frames decoder configuration.
Created once the handshake phase is done.
A WebSocket Extension data from the Sec-WebSocket-Extensions header.
Convenient class for io.netty.handler.codec.http.websocketx.extensions.WebSocketExtension decoder.
Convenient class for io.netty.handler.codec.http.websocketx.extensions.WebSocketExtension encoder.
Filter that is responsible to skip the evaluation of a certain extension
according to standard.
Extension filter provider that is responsible to provide filters for a certain
WebSocketExtension
extension.Base class for web socket frames.
Handler that aggregate fragmented WebSocketFrame's.
Marker interface which all WebSocketFrame decoders need to implement.
Marker interface which all WebSocketFrame encoders need to implement.
Exception during handshaking process
Defines the common schemes used for the WebSocket protocol as defined by
rfc6455.
Extends io.netty.handler.codec.http.websocketx.extensions.compression.WebSocketServerExtensionHandler
to handle the most common WebSocket Compression Extensions.
Created once the handshake phase is done.
This handler negotiates and initializes the WebSocket Extensions.
Handshakes a client extension based on this server capabilities.
Server exception during handshaking process.
Base class for server side web socket opening and closing handshakes
Performs server side opening and closing handshakes for web socket specification version draft-ietf-hybi-thewebsocketprotocol-
00
Performs server side opening and closing handshakes for web socket specification version draft-ietf-hybi-thewebsocketprotocol-
10
Performs server side opening and closing handshakes for web socket specification version draft-ietf-hybi-thewebsocketprotocol-
10
Performs server side opening and closing handshakes for RFC 6455
(originally web socket specification draft-ietf-hybi-thewebsocketprotocol-17).
Auto-detects the version of the Web Socket protocol in use and creates a new proper
WebSocketServerHandshaker
.WebSocket server configuration.
This handler does all the heavy lifting for you to run a websocket server.
The Handshake was completed successfully and the channel was upgraded to websockets.
Events that are fired to notify about handshake status
Handles the HTTP handshake (the HTTP Upgrade request) for
WebSocketServerProtocolHandler
.A utility class mainly for use by web sockets
Versions of the web socket specification.
A
StreamByteDistributor
that is sensitive to stream priority and uses
Weighted Fair Queueing approach for distributing
bytes.Allows a correlation to be made between a stream and its old parent before a parent change occurs.
A comparator for
WeightedFairQueueByteDistributor.State
which has no associated Http2Stream
object.Wraps another
ByteBuf
.WriteBufferWaterMark is used to set low water mark and high water mark for the write buffer.
A
TimeoutException
raised by WriteTimeoutHandler
when a write operation
cannot finish in a certain period of time.Raises a
WriteTimeoutException
when a write operation cannot finish in a certain period of time.XML attributes, it is part of
XmlElement
XML CDATA ...
XML characters, e.g.
XML Comment
XML Content is base class for XML CDATA, Comments, Characters and Space
Async XML decoder based on Aalto XML parser.
End of XML document
Beginning of the XML document ...
DTD (Document Type Definition)
Generic XML element in document,
XmlElementStart
represents open element and provides access to attributes,
XmlElementEnd
represents closing element.Specific
XmlElement
representing end of element.Specific
XmlElement
representing beginning of element.XML entity reference ...
A frame decoder for single separate XML based message streams.
XML namespace is part of XML element.
XML processing instruction
White space characters
Creates a new
ZlibEncoder
and a new ZlibDecoder
.Decompresses a
ByteBuf
using the deflate algorithm.Compresses a
ByteBuf
using the deflate algorithm.Utility methods used by
JZlibEncoder
and JZlibDecoder
.The container file formats that wrap the stream compressed by the DEFLATE
algorithm.