All Classes and Interfaces
Class
Description
AbstractCoordinator implements group management for a single group member by interacting with
a designated Kafka broker (the coordinator).
AbstractFetch represents the basic state and logic for record fetching processing.Defines the contract for handling fetch responses from brokers.
Base class for
MetricsCollector.Abstract assignor implementation which does some common grunt work (in particular collecting
partition counts which are always needed in assignors).
Sticky assignment implementation used by
StickyAssignor and
CooperativeStickyAssignor.A representation of network addresses, i.e.
Strategy interface to get the potential servers to connect to.
The administrative client for Kafka, which supports managing and inspecting topics, brokers, configurations and ACLs.
The `KafkaAdminClient`'s internal `Call` primitive is not a good fit for multi-stage
request workflows such as we see with the group coordinator APIs or any request which
needs to be sent to a partition leader.
This is a helper class which helps us to map requests that need to be sent
to the internal `Call` implementation that is used internally in
KafkaAdminClient.This class can be used when the set of keys is known ahead of time.
An
AdminApiHandler that will group multiple keys into a single request when possible.An
AdminApiHandler that will create one request per key, not performing any grouping based
on the targeted broker.The base class for in-built admin clients.
The AdminClient configuration class, which also contains constants for configuration entry names.
Manages the metadata for KafkaAdminClient.
This class is used for use cases which require requests to be sent to all
brokers in the cluster.
Thrown when application tries to perform an action on connection/channel
which was already closed
The result of the
Admin.alterClientQuotas(Collection, AlterClientQuotasOptions) call.A class representing a alter configuration entry containing name, value and operation type.
Options for
Admin.incrementalAlterConfigs(Map) and Admin.alterConfigs(Map).The result of the
Admin.alterConfigs(Map) call.Options for the
Admin.alterConsumerGroupOffsets(String, Map, AlterConsumerGroupOffsetsOptions) call.The result of the
Admin.alterConsumerGroupOffsets(String, Map) call.Options for
Admin.alterPartitionReassignments(Map, AlterPartitionReassignmentsOptions)
The API of this class is evolving.The result of
Admin.alterReplicaLogDirs(Map, AlterReplicaLogDirsOptions).Options for
Admin.alterUserScramCredentials(List, AlterUserScramCredentialsOptions)
The API of this class is evolving.The result of the
Admin.alterUserScramCredentials(List) call.Base class modelling an AMQ channel.
AMQP 0-9-1-specific implementation of
Command which accumulates
method, header and body from a series of frames, unless these are
supplied at construction time.Concrete class representing and managing an AMQP connection to a broker.
Implementation of ContentHeader - specialized by autogenerated code in AMQP.java.
This interface is used by
AdminApiDriver to bridge the gap
to the internal `NodeProvider` defined in
KafkaAdminClient.Set of annotations which can be used to specify status of API Element.
Indicates that the annotated element firstly appeared in the specified version of the library, so the code using that element
won't be compatible with older versions of the library.
Indicates that a public API of the annotated element (class, method or field) is not in stable state yet.
Indicates that the annotated element (class, method, field, etc) must not be considered as a public API.
Indicates that the annotated API class, interface or method must not be extended, implemented or overridden.
Indicates that a public API of the annotated element (class, method or field) is subject to deprecation in a future version.
Indicates that the annotated method is part of SPI (Service Provider Interface), which is intended to be
only implemented or overridden but not called by clients of the declaring library.
Indicates that a public API of the annotated element (class, method or field) is subject to removal in a future version.
This is the abstract definition of the events created by the KafkaConsumer API
An event handler that receives
application events from the application thread which
are then readable from the ApplicationEventProcessor in the network thread.An
EventProcessor that is created and executes in the network thread
which processes application events generated by the application thread.Helper annotations for asynchronous computation.
Indicates that the marked method executes async computation.
Indicates that the marked method schedules async computation.
Asynchronous iterator
This
Consumer implementation uses an event handler to process
application events so that the network I/O can be processed in a dedicated
network thread.Thrown when the broker refuses access due to an authentication failure.
Result object for autoClaim request.
Channel implementation that is automatically
recovered during connection recovery.Connection implementation that performs automatic recovery when
connection shutdown is not initiated by the application (e.g.
This is the abstract definition of the events created by the
network thread.An event handler that receives
.
background events from the
network thread which are then made available to the application thread
via the
invalid reference
BackgroundEventProcessorBackoff policy for topology recovery retry attempts.
Base status listener for Redis PubSub channel status changes
Base Redis nodes API interface
Base status listener for Redis PubSub channel status changes
Configuration for Batch object.
Deprecated.
Implement this interface in order to be notified of connection block events.
Implement this interface in order to be notified of connection block and
unblock events.
Indicates that the annotated method is inherently blocking and should not be executed in a non-blocking context.
Indicates that the annotated executor (CoroutineContext, Scheduler)
allows blocking methods execution.
Bridge between
NioQueue and JDK's BlockingQueue.This exception is thrown if the producer cannot allocate memory for a record within max.block.ms due to the buffer
being too full.
A pool of ByteBuffers kept under a given memory limit.
Enum for built-in exchange types.
Built-in default partitioner.
Info for the current sticky partition.
Contract to create
ByteBuffers.Bridge between the byte buffer and stream worlds.
ByteBufferSerializer always rewinds the position of the input buffer to zero for
serialization.Asynchronous interface for JCache
Simple
Supplier that caches the initial creation of the object and stores it for later calls
to CachedSupplier.get().Reactive interface for JCache
RxJava2 interface for JCache
A callback interface that the user can implement to allow code to execute when the request is complete.
Callback interface to be notified of the cancellation of a consumer.
Interface to a channel.
Exception thrown when a channel times out on a continuation during a RPC call.
Manages a set of channels, indexed by channel number (
1.._channelMax).Main interface to AMQP protocol functionality.
Specifies that the method is impure and that its return value must be used.
Publicly available Client Version information
Deprecated.
Deprecated.
Redis codec interface.
Interface to a container for an AMQP method-and-arguments, with optional content header and body.
Redis protocol command decoder
Redis protocol command encoder
Maps Redis command names.
Redis Publish Subscribe protocol decoder
This exception is raised when an offset commit with
KafkaConsumer.commitSync() fails
with an unrecoverable error.Object instance options
Application event with a result in the form of a future, that can be retrieved within a
timeout based on completion.
Background event with a result in the form of a future, that can be retrieved within a
timeout based on completion.
Interface for conditional object
Conditions factory to search for Live Objects by fields.
A configuration object containing the configuration entries for a resource.
Redisson configuration
A class representing a configuration entry containing name, value and additional metadata.
Source of configuration entries.
Class representing a configuration synonym of a
ConfigEntry.Data type of configuration entry.
Implement this interface in order to be notified of Confirm events.
Implement this interface in order to be notified of Confirm events.
Public API: Interface to an AMQ connection.
Convenience factory class to facilitate opening a
Connection to a RabbitMQ node.Helper class to load
ConnectionFactory settings from a property file.Exception thrown when a connector connection fails to initialize.
Enumerates the supported connection types managed by the Connector library.
Static service locator for accessing connector services on the Velocity platform.
Interface for application callback objects to receive notifications and messages from
a queue by subscription.
The consumer configuration keys
This class manages the coordination process with the consumer coordinator.
This extension interface provides a handful of methods to expose internals of the
Consumer for
various tests.ConsumerDelegateCreator implements a quasi-factory pattern to allow the caller to remain unaware of the
underlying Consumer implementation that is created.A detailed description of a single consumer group in the cluster.
A listing of a consumer group in the cluster.
A metadata struct containing the consumer group information.
A plugin interface that allows you to intercept (and possibly mutate) records received by the consumer.
A container that holds the list
ConsumerInterceptor
and wraps calls to the chain of custom interceptors.Higher level consumer access to the network layer with basic support for request futures.
When invoking poll from a multi-threaded environment, it is possible that the condition that
the caller is awaiting has already been satisfied prior to the invocation of poll.
Background thread runnable that consumes
ApplicationEvent and produces BackgroundEvent.This interface is used to define custom partition assignment for use in
KafkaConsumer.The rebalance protocol defines partition assignment and revocation semantics.
ConsumerProtocol contains the schemas for consumer subscriptions and assignments for use with
Kafka's generalized group management protocol.
A callback interface that the user can implement to trigger custom actions when the set of partitions assigned to the
consumer changes.
Event that signifies that the application thread has executed the
ConsumerRebalanceListener callback.Event that signifies that the network I/O thread wants to invoke one of the callback methods on the
ConsumerRebalanceListener.This class encapsulates the invocation of the callback methods defined in the
ConsumerRebalanceListener
interface.This class just provides a static name for the methods in the
ConsumerRebalanceListener interface
for a bit more compile time assurance.A key/value pair to be received from Kafka.
A container that holds the list
ConsumerRecord per partition for a
particular topic.Not part of the public API.
Callback interface to be notified when either the consumer channel
or the underlying connection has been shut down.
Public API for abstract AMQP content header objects.
Parses an AMQP wire-protocol
ContentHeader from a
DataInputStream.Generates an AMQP wire-protocol packet from a
ContentHeader.Specifies some aspects of the method behavior depending on the arguments.
A cooperative version of the
AbstractStickyAssignor.This is responsible for timing to send the next
FindCoordinatorRequest based on the following criteria:Provides equivalent security to PLAIN but demos use of Connection.Secure(Ok)
START-OK: Username
SECURE: "Please tell me your password"
SECURE-OK: Password
Options for
Admin.createAcls(Collection).The result of the
Admin.createAcls(Collection) call.The result of the
KafkaAdminClient.createDelegationToken(CreateDelegationTokenOptions) call.Options for
Admin.createPartitions(Map).The result of the
Admin.createPartitions(Map) call.Options for
Admin.createTopics(Collection).The result of
Admin.createTopics(Collection).Credentials object with username and password used for Redis connection.
Provider interface for establishing credentials for connecting to the broker.
Provider interface to refresh credentials when appropriate
and perform an operation once the credentials have been
renewed.
Credentials resolver object which is invoked during connection/reconnection process.
Cron expression object used in
RScheduledExecutorService.Represents a managed database connection backed by HikariCP.
Implementation of
DatabaseConnection that uses HikariCP for connection pooling.Service interface for managing multiple named database connections.
Default implementation of
DatabaseConnectorService that discovers and manages
database connections from environment variables.Allows to change the presentation of an object in debuggers
Default
ByteBufferFactory that creates heap-based ByteBuffers.Convenience class providing a default implementation of
Consumer.Default implementation of a CredentialsProvider which simply holds a static
username and password.
Scheduling-based implementation of
CredentialsRefreshService.Builder to create instances of
DefaultCredentialsRefreshService.DefaultCredentialsRefreshServiceBuilder.Default implementation of
ExceptionHandler
used by AMQConnection.Deprecated.
Composable topology recovery retry handler.
Default SASL configuration.
Options for the
Admin.deleteAcls(Collection) call.The result of the
Admin.deleteAcls(Collection) call.A class containing either the deleted ACL binding or an exception if the delete failed.
A class containing the results of the delete ACLs operation.
Options for the
Admin.deleteConsumerGroupOffsets(String, Set) call.The result of the
Admin.deleteConsumerGroupOffsets(String, Set) call.Options for the
Admin.deleteConsumerGroups(Collection) call.The result of the
Admin.deleteConsumerGroups(Collection) call.Redisson Object Event listener for deleted event published by Redis.
Represents information about deleted records
The API for this class is still evolving and we may break compatibility in minor releases, if necessary.
Options for
Admin.deleteRecords(Map, DeleteRecordsOptions).The result of the
Admin.deleteRecords(Map) call.Options for
Admin.deleteTopics(Collection).The result of the
Admin.deleteTopics(Collection) call.Callback interface to be notified when a message is delivered.
Encapsulates an arbitrary message - simple "bean" holder structure.
Arguments object for deque move method.
Arguments object for deque move method.
Options for
Admin.describeAcls(AclBindingFilter).The result of the
Admin.describeAcls(AclBindingFilter) call.The result of the
Admin.describeClientQuotas(ClientQuotaFilter, DescribeClientQuotasOptions) call.Options for
Admin.describeCluster().The result of the
Admin.describeCluster() call.Options for
Admin.describeConfigs(Collection).The result of the
Admin.describeConfigs(Collection) call.The result of the
KafkaAdminClient.describeConsumerGroups(Collection, DescribeConsumerGroupsOptions)} call.The result of the
KafkaAdminClient.describeDelegationToken(DescribeDelegationTokenOptions) call.Options for
Admin.describeFeatures(DescribeFeaturesOptions).The result of the
Admin.describeFeatures(DescribeFeaturesOptions) call.Options for
Admin.describeLogDirs(Collection)
The API of this class is evolving, see Admin for details.The result of the
Admin.describeLogDirs(Collection) call.Options for
Admin.describeProducers(Collection).Options for
Admin.describeReplicaLogDirs(Collection).The result of
Admin.describeReplicaLogDirs(Collection).Options for
Admin.describeTopics(Collection).The result of the
Admin.describeTopics(Collection) call.Options for
Admin.describeTransactions(Collection).Options for
Admin.describeUserScramCredentials(List, DescribeUserScramCredentialsOptions)
The API of this class is evolving.The result of the
Admin.describeUserScramCredentials() call.An interface for converting bytes to objects.
AddressResolver that resolves DNS record IPs.AddressResolver that resolves addresses against a DNS SRV request.MariaDB Driver
The result of
Admin.electLeaders(ElectionType, Set, ElectLeadersOptions)
The API of this class is evolving, see Admin for details.Identifies the endpoint type, as specified by KIP-919.
Encapsulates a group of parameters used for AMQP's Basic methods
Infers information about the execution environment, e.g.
Utility class for reading connector configuration from environment variables.
Listener called when a connection gets an IO error trying to write on the socket.
An
EventProcessor is the means by which events produced by thread A are
processed by thread B.Interface to an exception-handling object.
Deprecated.
RExecutorService instance optionsThe result of the
KafkaAdminClient.expireDelegationToken(byte[], ExpireDelegationTokenOptions) call.Redisson Object Event listener for expired event published by Redis.
Expression that is applied on properties
The EXTERNAL auth mechanism
Detects failed Redis node if it has certain amount of command execution errors
failedCommandsLimit in checkInterval time interval.Detects failed Redis node if it has certain amount of command execution timeout errors
failedCommandsLimit in checkInterval time interval.Detects failed Redis node if it has ongoing connection errors in
checkInterval time interval.Detects failed Redis node depending
on
FailedNodeDetector.isNodeFailed() method implementation.Result object for autoClaim request.
Encapsulates details about finalized as well as supported features.
Encapsulates details about an update to a finalized feature.
Options for
Admin.fenceProducers(Collection, FenceProducersOptions)
The API of this class is evolving.The result of the
Admin.fenceProducers(Collection) call.FetchBuffer buffers up the results from the broker responses as they are received.FetchConfig represents the static configuration for fetching records from Kafka.This class manages the fetching process with the brokers.
The
FetchMetricsManager class provides wrapper methods to record lag, lead, latency, and fetch metrics.FetchRequestManager is responsible for generating FetchRequest that represent the
SubscriptionState.fetchablePartitions(Predicate) based on the user's topic subscription/partition
assignment.FetchUtils provides a place for disparate parts of the fetch logic to live.Field index for
RSearch.createIndex(String, IndexOptions, FieldIndex...) methodFile-related utility methods.
Represents a range of version levels supported by every broker in a cluster for some feature.
Options object for vector field index which uses FLAT indexing method.
Optional options object for vector field index which uses FLAT indexing method.
Redisson Object Event listener for flush event published by Redis.
An implementation of
ExceptionHandler that does not
close channels on unhandled consumer and listener exception.ForwardingAdmin is the default value of forwarding.admin.class in MirrorMaker.Represents an AMQP wire-protocol frame, with frame type, channel number, and payload bytes.
Class to create AMQP frames from a
ReadableByteChannel.Interface to a frame handler.
Encapsulates information about Redis functions library.
Function execution mode.
Function result type.
Encapsulates information about currently running
Redis function and available execution engines.
The future result of a record send
Geo filter for
QueryOptions.filters(QueryFilter...) methodGeo field index options.
Arguments object for RGeo search method.
Encapsulates the response from a
Channel.basicGet(java.lang.String, boolean) message-retrieval method call
- essentially a static bean "holder" with message response data.This event is sent by the
consumer's network thread to the application thread
so that when the user calls the Consumer.groupMetadata() API, the information is up-to-date.A helper class for managing the heartbeat to the coordinator
Manages the request creation and response handling for the heartbeat.
The HikariCP pooled DataSource.
Options object for vector field index which uses HNSW indexing method.
Optional options object for vector field index which uses HNSW indexing method.
Maps host of RedisURI object using map defined in
hostsMap setting.Maps host and port of RedisURI object using map defined in
hostsMap setting.Identifier generator
Redisson Object Event listener for incrby event published by Redis.
Thrown when the offset for a set of partitions is invalid (either undefined or out of range),
and no reset policy has been configured.
Implementation of SaslConfig that uses the JDK SASL implementation.
RJsonBucket instance optionsJson codec based on Jackson implementation.
Extended Jackson codec for Redisson that registers support for Java 8+ types.
Json data type
Json data type convertor
The default implementation of
Admin.Represents a managed Kafka connection that exposes the loaded configuration properties
and provides factory methods for creating Kafka clients.
Implementation of
KafkaConnection that loads Kafka properties from a file,
provides factory methods for creating clients, and tracks them for graceful shutdown.Service interface for managing multiple named Kafka connections.
Default implementation of
KafkaConnectorService that discovers and manages
Kafka connections from environment variables.A client that consumes records from a Kafka cluster.
A Kafka client that publishes records to the Kafka cluster.
RKeys instance optionsA client that consumes records from a Kafka cluster using the
classic group protocol.Redisson Object Event listener for rpush event published by Redis.
Simple implementation of
AddressResolver that returns a fixed list.Options for
Admin.listClientMetricsResources().The result of the
Admin.listClientMetricsResources() call.The result of the
Admin.listConsumerGroupOffsets(Map) and
Admin.listConsumerGroupOffsets(String) call.Specification of consumer group offsets to list using
Admin.listConsumerGroupOffsets(java.util.Map).Options for
Admin.listConsumerGroups().The result of the
Admin.listConsumerGroups() call.Redisson Object Event listener for linsert event published by Redis.
Event for retrieving partition offsets by performing a
ListOffsetsRequest.Options for
Admin.listOffsets(Map).The result of the
Admin.listOffsets(Map) call.Options for
Admin.listPartitionReassignments(ListPartitionReassignmentsOptions)
The API of this class is evolving.Redisson Object Event listener for lrem event published by Redis.
Redisson Object Event listener for lset event published by Redis.
Options for
Admin.listTopics().The result of the
Admin.listTopics() call.Options for
Admin.listTransactions().The result of the
Admin.listTransactions() call.Redisson Object Event listener for ltrim event published by Redis.
RLiveObjectService instance optionsDeprecated.
RLocalCachedMap instance options.Various strategies to avoid stale objects in local cache.
Various strategies to avoid stale objects in local cache.
Configuration for LocalCachedMap object.
Redisson Object Event listener for local cache invalidation event published by Redis.
Redisson Object Event listener for local cache update event published by Redis.
Configuration for Lock object.
Factory for LockOptions.BackOffPolicy class.
Generator of sleep period values for RedissonSpinLock back off
Back off algorithm, where sleep period is constant and is defined by LockOptions.ConstantBackOff.delay.
Back off algorithm, where sleep period starts with LockOptions.ExponentialBackOff.initialDelay, each time increases
LockOptions.ExponentialBackOff.multiplier times but doesn't exceed LockOptions.ExponentialBackOff.maxDelay
A description of a log directory on a particular broker.
In the event of an unclean leader election, the log will be truncated,
previously committed data will be lost, and new data will be written
over these offsets.
An object providing access to a LongString.
Utility for working with
LongStrings.Encapsulates a frame format error at the wire level.
Configuration for RMapCache object.
RMapCache instance options.Map loader used for read-through operations or during
RMap.loadAll(boolean, int) execution.Map loader used for read-through operations or during
RMap.loadAll(boolean, int) execution.Deprecated.
RMap instance options.Redisson Object Event listener for hset event published by Redis.
Redisson Object Event listener for hdel event published by Redis.
Subclass of RpcServer which uses AMQP wire-format encoded tables as
requests and replies.
Map writer used for write-through operations.
Asynchronous Map writer used for write-through operations.
MariaDB basic datasource
A description of the assignments of a specific group member.
A detailed description of a single group instance in the cluster.
A stateful object tracking the state of a single member in relationship to a consumer group:
Group manager for a single consumer that has a group id defined in the config
ConsumerConfig.GROUP_ID_CONFIG, to use the Kafka-based offset management capability,
and the consumer group protocol to get automatically assigned partitions when calling the
subscribe API.Listener for getting notified of member ID and epoch changes.
A struct containing information about the member to be removed.
Listener for Redis messages published via RTopic Redisson object
Constant holder class with useful static instances of
AMQContentHeader.Base class for AMQP method objects, specialized by autogenerated
code in AMQP.java.
Public interface to objects representing an AMQP 0-9-1 method
Parses AMQP wire-protocol
Method arguments from a
DataInputStream.Generates AMQP wire-protocol encoded arguments.
Interface to gather execution data of the client.
Encapsulates an exception indicating that the connection has missed too many heartbeats
and is being shut down.
A mock of the
Consumer interface you can use for testing code that uses Kafka.A mock of the producer interface you can use for testing code that uses Kafka.
The annotation should be applied to overridable non-abstract method
and indicates that all the overriders must invoke this method via
superclass method invocation expression.
Maps Redisson object name.
Maps RedisURI object.
This interface allows to create hooks applied
after Netty Bootstrap and Channel object initialization.
A wrapper around the
NetworkClient to handle network poll and send operations.Redisson Object Event listener for new object event published by Redis.
A new partition reassignment, which can be applied via
Admin.alterPartitionReassignments(Map, AlterPartitionReassignmentsOptions).Describes new partitions for a particular topic in a call to
Admin.createPartitions(Map).A new topic to be created via
Admin.createTopics(Collection).Context when creating resources for a NIO-based connection.
Logic of the NIO loop.
Parameters used to configure the NIO mode of a
ConnectionFactory.Contract to exchange frame between application threads and NIO thread.
Specifies that an element of the program is a user-visible string which needs to be localized.
No brokers were available to complete a request.
Deprecated.
Deprecated.
Deprecated.
Indicates that the annotated method is inherently non-blocking and can be executed in a non-blocking context.
Indicates that the annotated executor (CoroutineContext, Scheduler)
does not allow blocking methods execution.
Specifies that an element of the program is not a user-visible string which needs to be localized,
or does not contain such strings.
Indicates that there is no stored offset for a partition and no defined offset
reset policy.
An element annotated with NotNull claims
null value is forbidden
to return (for methods), pass to (parameters) and hold (local variables and fields).An element annotated with
Nullable claims null value is perfectly valid
to return (for methods), pass to (parameters) or hold in (local variables and fields).Numeric filter for
QueryOptions.filters(QueryFilter...) methodNumeric field index options.
A
CredentialsProvider that performs an
OAuth 2 Client Credentials flow
to retrieve a token.Helper to create
OAuth2ClientCredentialsGrantCredentialsProvider instances.TLS configuration for a
OAuth2ClientCredentialsGrantCredentialsProvider.Redisson Object Event listener for Expired or Deleted event.
The Kafka offset commit API allows users to provide additional metadata (in the form of a string)
when an offset is committed.
A container class for offset and timestamp.
A callback interface that the user can implement to trigger custom actions when a commit request completes.
OffsetFetcher is responsible for fetching the offsets for
a given set of topic and partition pairs and for validation and resetting of positions,
as needed.No reset policy has been defined, and the offsets for these partitions are either larger or smaller
than the range of offsets the server has for the given partition.
Convenience class for making asynchronous requests to the OffsetsForLeaderEpoch API
Utility methods for preparing requests to the OffsetsForLeaderEpoch API and handling responses.
This class allows to specify the desired offsets when using
KafkaAdminClient.listOffsets(Map, ListOffsetsOptions)Manager responsible for building the following requests to retrieve partition offsets, and
processing its responses.
Arguments object for RGeo search method.
Object instances options
Partitioner Interface
Base driver implementation for APIs which target partition leaders.
A partition reassignment, which has been listed via
Admin.listPartitionReassignments().Listener for Redis messages published via RTopic Redisson object
Listener for Redis PubSub channel status changes
RPatternTopic instance options.Entry object for pending messages request.
Result object for pending messages request.
The PLAIN auth mechanism
Object instance options.
A pooled RabbitMQ channel wrapper that implements
AutoCloseable to automatically
return the channel to the pool when closed.Thrown when the likely cause is an authentication failure.
The interface for the
KafkaProducerA batch of records that is or will be sent.
Configuration for the Kafka Producer.
A class that models the future completion of a produce request for a single partition.
A plugin interface that allows you to intercept (and possibly mutate) the records received by the producer before
they are published to the Kafka cluster.
A container that holds the list
ProducerInterceptor
and wraps calls to the chain of custom interceptors.A key/value pair to be sent to Kafka.
Specifies that a method parameter, local variable, field or a method return value
must be a valid property key in a specific resource bundle.
Redis protocol version
Thrown to indicate that the server does not support the wire protocol version
we requested immediately after opening the TCP socket.
Query filter for
RSearch.search(String, String, QueryOptions) methodSearch query options for
RSearch.search(String, String, QueryOptions) methodNot part of the public API.
This class is used to describe the state of the quorum received in DescribeQuorumResponse.
Represents a managed RabbitMQ connection with channel pooling support.
Implementation of
RabbitMQConnection that manages a RabbitMQ connection
and a fixed-size channel pool.Service interface for managing multiple named RabbitMQ connections.
Default implementation of
RabbitMQConnectorService that discovers and manages
RabbitMQ connections from environment variables.Random identifier
An annotation which allows to specify for integral type (byte, char, short, int, long) an allowed values range.
The range assignor works on a per-topic basis.
Distributed implementation to the AtomicDouble
Distributed implementation to the AtomicDouble
Reactive interface for AtomicDouble object
Reactive interface for AtomicDouble object
Distributed implementation of
AtomicLongDistributed async implementation of
AtomicLongReactive interface for AtomicLong object
RxJava2 interface for AtomicLong object
Interface for using Redis pipeline feature.
Reactive interface for Redis pipeline feature.
RxJava2 interface for Redis pipeline feature.
Binary stream holder stores a sequence of bytes.
Binary stream holder stores a sequence of bytes.
Binary stream holder stores a sequence of bytes.
Vector of bits that grows as needed.
Vector of bits that grows as needed.
Reactive interface for BitSet object
RxJava2 interface for BitSet object
BlockingDeque backed by RedisDistributed async implementation of
BlockingDequeReactive interface for Redis based BlockingDeque object
RxJava2 interface for Redis based BlockingDeque object
Distributed implementation of
BlockingQueueDistributed async implementation of
BlockingQueueReactive interface for BlockingQueue object
RxJava2 interface for BlockingQueue
Distributed implementation of Bloom filter based on Highway 128-bit hash.
Distributed implementation of bounded
BlockingQueueDistributed async implementation of bounded
BlockingQueueObject holder.
Async implementation of object holder.
Reactive implementation of object holder.
Reactive implementation of object holder.
Operations over multiple Bucket objects.
Operations over multiple Bucket objects.
Operations over multiple Bucket objects.
Operations over multiple Bucket objects.
Specifies that the defined cascade types are applied to the object/objects contained in Live Object field.
Live Object cascade type.
Collates result from
RReducer tasks and produces a single result object.Common async interface for collection object
Mapper task invoked during map phase of MapReduce process and launched across Redisson Nodes.
MapReduce allows to process large amount of data stored in
RSet, RList, RSetCache, RScoredSortedSet, RSortedSet and others
using Mapper, Reducer and/or Collator tasks launched across Redisson Nodes.Common reactive interface for collection object
Common RxJava2 interface for collection object
Stores each key/value mapping during map phase of MapReduce process.
Redis based implementation of
CountDownLatch
It has an advantage over CountDownLatch --
count can be set via RCountDownLatch.trySetCount(long) method.Async interface of Redis based
CountDownLatch
It has an advantage over CountDownLatch --
count can be set via RCountDownLatchAsync.trySetCountAsync(long) method.Reactive interface of Redis based
CountDownLatch
It has an advantage over CountDownLatch --
count can be set via RCountDownLatchReactive.trySetCount(long) method.RxJava2 interface of Redis based
CountDownLatch
It has an advantage over CountDownLatch --
count can be set via RCountDownLatchRx.trySetCount(long) method.Distributed implementation of delayed queue.
Distributed implementation of
DequeDistributed async implementation of
DequeReactive interface for Deque object
RxJava2 interface for Deque object
All objects that implement this interface
should be destroyed via
RDestroyable.destroy() method.Distributed implementation of
DoubleAdderThis class acts as a queue that accumulates records into
MemoryRecords
instances to be sent to the server.Node latency stats for each node that are used for adaptive partition distribution
Visible for testing
Partitioner config for built-in partitioner
The metadata for a record that has been acknowledged by the server
Describe records to delete in a call to
Admin.deleteRecords(Map)
The API of this class is evolving, see Admin for details.Provides a way to register (network, AMQP 0-9-1) connection recovery
callbacks.
Convenient interface when working against auto-recovery channels.
Convenient interface when working against auto-recovery connections.
Functional callback interface that can be used to rename a queue during topology recovery.
AMQConnection modification that uses RecoveryAwareChannelNChannelN modification that keeps track of delivery
tags and avoids sendingUsed internally to indicate when connection recovery can
begin.
A RecoveryDelayHandler is used to tell automatic recovery how long to sleep between reconnect attempts.
Basic implementation of
RecoveryDelayHandler that returns the network recovery interval each time.Backoff implementation of
RecoveryDelayHandler that uses the Fibonacci sequence (by default) to increase the recovery delay time after each failed attempt.A RecoveryListener receives notifications about completed automatic connection
recovery.
This error occurs when Redis requires authentication.
This error occurs when Redis server is busy.
Redis Cluster nodes API interface
This error occurs when Redis Cluster is down.
Redis Cluster Master node API interface
Redis Cluster Master node API interface
Base Redis Cluster node API interface
Base Redis Cluster node API interface
Redis Cluster Salve node API interface
Represents a managed Redis connection backed by Redisson.
Implementation of
RedisConnection that loads Redisson configuration
from a YAML file and manages the Redisson client lifecycle.Service interface for managing multiple named Redis connections.
Default implementation of
RedisConnectorService that discovers and manages
Redis connections from environment variables.Redis Master node API interface
Redis Master node API interface
Redis Master Slave nodes API interface
Base Redis node API interface
Base Redis node API interface
This error occurs in case when Redis server free memory exhausted.
This error occurs when username password pair is incorrect.
Redis Sentinel node API interface
Redis Sentinel node API interface
Redis Sentinel Master Slave nodes API interface
Redis Single node API interface
Redis Slave node API interface
Redis Slave node API interface
Main Redisson interface for access
to all redisson objects with sync/async interface.
Redisson Node file configuration
Node initializer callback interface.
Main Redisson interface for access
to all redisson objects with Reactive interface.
Main Redisson interface for access
to all redisson objects with RxJava2 interface.
This error occurs when Redis server is busy.
This error occurs when username password pair is incorrect.
Reducer object for
RSearch.aggregate(String, String, AggregationOptions) methodAn abstract
CredentialsProvider that does not let token refresh happen concurrently.RRemoteService invocation options.
The result of the
Admin.removeMembersFromConsumerGroup(String, RemoveMembersFromConsumerGroupOptions) call.The result of the
KafkaAdminClient.expireDelegationToken(byte[], ExpireDelegationTokenOptions) call.Specifies that the class is a Live Object.
A description of a replica on a particular broker.
Configuration for an Azure Redis Cache or AWS ElastiCache servers.
Result of an asynchronous request from
ConsumerNetworkClient.Adapt from a request future of one type to another.
Listener interface to hook into RequestFuture completion.
PollResult consist of UnsentRequest if there are requests to send; otherwise, return the time till
the next poll event.RequestManagers provides a means to pass around the set of RequestManager instances in the system.Event for resetting offsets for all assigned partitions that require it.
The context of a topology recovery retry operation.
Contract to retry failed operations during topology recovery.
The retry of a retried topology recovery operation.
Implement this interface in order to be notified of failed
deliveries when basicPublish is called with "mandatory" or
"immediate" flags set.
Implement this interface in order to be notified of failed
deliveries when basicPublish is called with "mandatory" or
"immediate" flags set.
Future object for submitted tasks in a batch
Future object for submitted task
Distributed implementation of
ExecutorServiceDistributed async implementation of
ExecutorServiceBase interface for all Redisson objects
which support expiration or TTL
Base async interface for all Redisson objects
which supports expiration (TTL)
Base interface for all Redisson objects
which support expiration or TTL
Base interface for all Redisson objects
which support expiration or TTL
Redis based implementation of Fenced Lock with reentrancy support.
Async interface for Redis based implementation of Fenced Lock with reentrancy support.
Redis based implementation of Fenced Lock with reentrancy support.
Redis based implementation of Fenced Lock with reentrancy support.
Specifies that the method is a field accessor for Live Object.
Interface for Redis Function feature
Interface for Redis Function feature
Interface for Redis Function feature
Interface for Redis Function feature
Represents the result of an asynchronous computation
Geospatial items holder.
Geospatial items holder.
Geospatial items holder.
Geospatial items holder.
Probabilistic data structure that lets you maintain counts of millions of items with extreme space efficiency.
Probabilistic data structure that lets you maintain counts of millions of items with extreme space efficiency.
Probabilistic data structure that lets you maintain counts of millions of items with extreme space efficiency.
Probabilistic data structure that lets you maintain counts of millions of items with extreme space efficiency.
Specifies that the field is a Live Object's id field.
Id generator of
Long type numbers.Id generator of
Long type numbers.Id generator of
Long type numbers.Id generator of
Long type numbers.Specifies that the field is used in search index.
Specifies that the field value is filled up with RedissonClient instance.
Redis JSON datatype holder.
Redis JSON datatype interface.
Redis JSON datatype holder.
Redis JSON datatype holder.
Sorted set contained values of String type
Async interface for sorted set contained values of String type.
Reactive interface for sorted set contained values of String type.
RxJava2 interface for sorted set contained values of String type.
Distributed and concurrent implementation of
ListAsync list functions
List based Multimap.
List based Multimap.
Reactive interface for
RListMultimapCache object.Rx-ified version of
RListMultimapCache.Reactive interface for List based Multimap object
RxJava2 interface for List based Multimap object
list functions
list functions
The pre-registration of each entity class is not necessary.
Map object with local entry cache support.
Map object with local entry cache support.
Map object with local entry cache support.
Redis based implementation of
Lock
Implements re-entrant lock.Async interface for Lock object
Reactive interface for Lock object
RxJava2 interface for Lock object
Distributed implementation of
LongAdderRedis based implementation of
ConcurrentMap
and MapAsync interface for Redis based implementation
of
ConcurrentMap and MapMap-based cache with ability to set TTL for each entry via
RMapCache.put(Object, Object, long, TimeUnit) or RMapCache.putIfAbsent(Object, Object, long, TimeUnit)
And therefore has an complex lua-scripts inside.Map-based cache with ability to set TTL for each entry via
RMapCache.put(Object, Object, long, TimeUnit) or RMapCache.putIfAbsent(Object, Object, long, TimeUnit)
And therefore has an complex lua-scripts inside.Map-based cache with ability to set TTL for each entry via
RMapCacheReactive.put(Object, Object, long, TimeUnit) or RMapCacheReactive.putIfAbsent(Object, Object, long, TimeUnit) method.Map-based cache with ability to set TTL for each entry via
RMapCacheRx.put(Object, Object, long, TimeUnit) or RMapCacheRx.putIfAbsent(Object, Object, long, TimeUnit) method.Mapper task invoked during map phase of MapReduce process and launched across Redisson Nodes.
Reactive interface for Redis based implementation
of
ConcurrentMap and MapMapReduce allows to process large amount of data stored in Redis map
using Mapper, Reducer and/or Collator tasks launched across Redisson Nodes.
Contains methods for MapReduce process execution.
RxJava2 interface for Redis based implementation
of
ConcurrentMap and MapBase Multimap interface.
Base asynchronous MultiMap interface.
Base Multimap interface.
Base asynchronous Multimap interface.
Reactive interface of
RMultimapCache object.Rx-ified version of
RMultimapCache.Base Reactive interface for Multimap object
Base RxJava2 interface for Multimap object
Base interface for all Redisson objects
Base asynchronous interface for all Redisson objects
By default
namingScheme and/or codec parameters specified in REntity
are applied for each Live Object field.Base Reactive interface for all Redisson objects
Base RxJava2 interface for all Redisson objects
The round robin assignor lays out all the available partitions and all the available consumers.
The "Round-Robin" partitioner
This partitioning strategy can be used when user wants
to distribute the writes to all partitions equally.
Pattern based observer for Publish Subscribe object.
Reactive interface for Pattern based observer for Publish Subscribe object.
RxJava2 interface for Pattern based observer for Publish Subscribe object.
Convenience class which manages simple RPC-style communication.
The response object is an envelope that contains all of the data provided to the `handleDelivery` consumer
Holder class to configure a
RpcClient.Class which manages a request queue for a simple RPC-style service.
Semaphore object with lease time parameter support for each acquired permit.
Asynchronous interface for Semaphore object with lease time parameter support for each acquired permit.
Reactive interface for Semaphore object with lease time parameter support for each acquired permit.
RxJava2 interface for Semaphore object with lease time parameter support for each acquired permit.
RPriorityBlockingDeque backed by Redis
PriorityBlockingQueue backed by Redis
Redis based priority deque.
Redis based priority deque.
Queue backed by RedisQueue backed by RedisReactive interface for Queue object
RxJava2 interface for Queue object
Redis based Rate Limiter object.
Asynchronous interface for Redis based Rate Limiter object.
Reactive interface for Redis based Rate Limiter object.
Reactive interface for Redis based Rate Limiter object.
A
ReadWriteLock maintains a pair of associated locks, one for read-only operations and one for writing.A
ReadWriteLock maintains a pair of associated locks, one for read-only operations and one for writing.A
ReadWriteLock maintains a pair of associated locks, one for read-only operations and one for writing.Reduces values mapped by key into single value.
Reliable topic based on Redis Stream object.
Asynchronous interface for Reliable topic based on Redis Stream object.
Reactive interface for Reliable topic based on Redis Stream object.
RxJava2 interface for Reliable topic based on Redis Stream object.
Annotation used to mark interface as asynchronous
client interface for remote service interface.
Annotation used to mark interface as Reactive
client interface for remote service interface.
Annotation used to mark interface as RxJava2
client interface for remote service interface.
Allows to execute object methods remotely between Redisson instances (Server side and Client side instances in terms of remote invocation).
RingBuffer based queue evicts elements from the head if queue capacity became full.
RingBuffer based queue evicts elements from the head if queue capacity became full.
RingBuffer based queue evicts elements from the head if queue capacity became full.
RingBuffer based queue evicts elements from the head if queue capacity became full.
Redis based implementation of
ScheduledExecutorServiceRedis based implementation of
ScheduledExecutorServiceSet containing elements sorted by score.
Reactive interface for SortedSet object
RxJava2 interface for scored sorted set data structure.
Interface for Redis Script feature
Async interface for Redis Script feature
Reactive interface for Redis Script feature
RxJava2 interface for Redis Script feature
API for RediSearch module
Asynchronous API for RediSearch module
Reactive API for RediSearch module
RxJava3 API for RediSearch module
Redis based implementation of
Semaphore.Async interface of Redis based
Semaphore.Reactive interface of Redis based
Semaphore.RxJava2 interface of Redis based
Semaphore.Redis based implementation of
SetAsync set functions
Set-based cache with ability to set TTL for each object.
Async set functions
Reactive interface for RSetCache object
RxJava2 interface for RSetCache object
Set based Multimap.
Reactive interface for
RSetMultimapCache object.Rx-ified version of
RSetMultimapCache.Reactive interface for Set based Multimap
RxJava2 interface for Set based Multimap
Reactive interface for Redis based implementation of
SetRxJava2 interface for Redis based implementation of
SetSharded Topic for Redis Cluster.
Sharded Topic for Redis Cluster.
Reactive interface for Sharded Topic.
RxJava3 interface for Sharded Topic.
Interface for Redis Stream object.
Async interface for Redis Stream object.
Reactive interface for Redis Stream object.
Reactive interface for Redis Stream object.
Redis based time-series collection.
Async interface for Redis based time-series collection.
Reactive interface for Redis based time-series collection.
Rx interface for Redis based time-series collection.
Distributed topic.
Distributed topic.
Reactive interface for Publish Subscribe object.
RxJava3 interface for Publish Subscribe object.
Transaction object allows to execute transactions over Redisson objects.
Reactive interface for transaction object allows to execute transactions over Redisson objects.
RxJava2 interface for transaction object allows to execute transactions over Redisson objects.
Redis based implementation of
TransferQueueAsync interface for Redis based implementation of
TransferQueueReactive interface of Redis based implementation of
TransferQueueRxJava2 interface of Redis based implementation of
TransferQueueThis interface represents a hook to allow you to control how exactly
a sasl client is selected during authentication.
Our own view of a SASL authentication mechanism, introduced to remove a
dependency on javax.security.sasl.
Redisson Object Event listener for add event published by RScoredSortedSet object.
Redisson Object Event listener for zrem event published by Redis.
Mechanism and iterations for a SASL/SCRAM credential associated with a user.
Representation of a SASL/SCRAM Mechanism.
Search result object returned by
RSearch.search(String, String, QueryOptions) methodThe background thread that handles the sending of produce requests to the Kafka cluster.
SensorBuilder takes a bit of the boilerplate out of creating sensors for recording
metrics.The interface for wrapping a serializer and deserializer for the given data type.
Factory for creating serializers / deserializers.
An interface for converting objects to bytes.
Redisson Object Event listener for sadd event published by Redis.
Redisson Object Event listener for set event published by Redis.
A generic queue-like implementation (supporting operations
addIfNotPresent,
poll, contains, and isEmpty)
which restricts a queue element to appear at most once.Redisson Object Event listener for srem event published by Redis.
Redisson Object Event listener for spop event published by Redis.
Arguments object for RGeo search method.
A ShutdownListener receives information about the shutdown of connections and
channels.
Interface for components that are shutdown capable and
that allow listeners to be added for shutdown signals
A class that manages
ShutdownListeners and remembers the reason for a shutdown.Encapsulates a shutdown condition for a connection to an AMQP broker.
Ready-to-use instances and builder for
SocketChannelConfigurator.Ready-to-use instances and builder for
SocketConfigurator.A socket-based frame handler.
Spellcheck options for
RSearch.spellcheck(String, String, SpellcheckOptions) methodA factory to create
SSLContexts.Bridge between the byte buffer and stream worlds.
Ready-to-use instances and builder for
SslEngineConfigurators.Sub-class of
FrameBuilder that unwraps crypted data from the network.This lookup strategy is used when we already know the destination broker ID
and we have no need for an explicit lookup.
Listener for Redis PubSub channel status changes
The sticky assignor serves two purposes.
An internal class that implements a cache used for sticky partitioning behavior.
Arguments object for RStream.add() method.
Redisson Object Event listener for xadd event
published by Redis when an element added into Stream.
Object containing details about Stream Consumer
Redisson Object Event listener for xgroup-createconsumer event
published by Redis when a Stream Consumer is created.
Arguments object for
RStream.createGroup(StreamCreateGroupArgs) method.Redisson Object Event listener for xgroup-create event
published by Redis when a Stream Group is created.
Object containing details about Stream Group
Object containing details about Stream
Stream Message ID object
Arguments object for RStream.read() methods.
Arguments object for RStream.readGroup() methods.
Arguments object for RStream.read() methods.
Arguments object for RStream.readGroup() methods.
Redisson Object Event listener for xgroup-delconsumer event
published by Redis when a Stream Consumer is removed.
Redisson Object Event listener for xgroup-destroy event
published by Redis when a Stream Group is removed.
Redisson Object Event listener for srem event
published by Redis when an element removed from Stream.
Arguments object for Stream trim method.
Arguments object for Stream trim method.
Redisson Object Event listener for ltrim event
published by Redis when trim operation is executed for Stream.
Arguments object for Stream trim method.
An implementation of
ExceptionHandler that does
close channels on unhandled consumer exception.String encoding defaults to UTF8 and can be customized by setting the property key.deserializer.encoding,
value.deserializer.encoding or deserializer.encoding.
Subclass of RpcServer which accepts UTF-8 string requests.
String encoding defaults to UTF8 and can be customized by setting the property key.serializer.encoding,
value.serializer.encoding or serializer.encoding.
Application event indicating that the subscription state has changed, triggered when a user
calls the subscribe API.
A class for tracking the topics, partitions, and offsets for the consumer.
Represents the position of a partition subscription.
Represents a range of versions that a particular broker supports for some feature.
Tag field index options.
Task listener invoked when task was failed during execution
Task listener invoked when task was finished
Base task listener interface
Task listener invoked when task was started
Task listener invoked when task was succeeded
A member or type annotated with TestOnly claims that it should be used from testing code only.
Text field index options.
Time-series collection entry
Utility to extract information from X509 certificates.
A detailed description of a single topic in the cluster.
A listing of a topic in the cluster.
TopicMetadataFetcher is responsible for fetching the PartitionInfo for a given set of topics.
Manages the state of topic metadata requests.
Indicates an exception thrown during topology recovery.
Filter to know whether entities should be recovered or not.
Builder to ease creation of
DefaultRetryHandler instances.Useful ready-to-use conditions and operations for
DefaultRetryHandler.Redisson Object Event listener for client tracking event published by Redis.
Contract to log outbound and inbound
Commands.A class which maintains state for transactions.
Configuration for Transaction.
Utility stream: proxies another stream, making it appear to be no
longer than a preset limit.
Convenience class providing a default implementation of
X509TrustManager.Implement this interface in order to be notified of connection unblock events.
Thrown when the command parser hits an unexpected frame type.
Indicates that a
Method object was supplied that was not
expected.Deprecated.
Thrown when the protocol handlers detect an unknown class number or
method number.
An element annotated with
UnknownNullability claims that no specific nullability
should be assumed by static analyzer.An annotation which marks a
Collection or Map type
as unmodifiable.An annotation which marks a
Collection or Map type
as unmodifiable view.Options for
Admin.unregisterBroker(int, UnregisterBrokerOptions).The result of the
Admin.unregisterBroker(int, UnregisterBrokerOptions) call.Exception thrown when a RPC request isn't routed to any queue.
Application event triggered when a user calls the unsubscribe API.
Options for
Admin.updateFeatures(Map, UpdateFeaturesOptions).The result of the
Admin.updateFeatures(Map, UpdateFeaturesOptions) call.A request to alter a user's SASL/SCRAM credentials.
A request to delete a SASL/SCRAM credential for a user.
Representation of all SASL/SCRAM credentials associated with a user that can be retrieved, or an exception indicating
why credentials could not be retrieved.
A request to update/insert a SASL/SCRAM credential for a user.
We are converting the byte array to String before deserializing to UUID.
We are converting UUID to String before serializing.
Event for validating offsets for all assigned partitions for which a leader change has been
detected.
Helper class to read AMQP wire-protocol encoded values.
Helper class to generate AMQP wire-protocol encoded values.
A clone of LinkedBlockingQueue
with the addition of a
VariableLinkedBlockingQueue.setCapacity(int) method, allowing us to
change the capacity of the queue while it is in use.Encapsulation of AMQP protocol version
A member or type annotated with VisibleForTesting claims that its visibility is higher than necessary,
only for testing purposes.
Ensures blocking APIs can be woken up by the consumer.wakeup().
This is a generic implementation of the channels specification
in Channeling Work, Nov 2010 (channels.pdf).
Exception thrown when
WorkPool enqueueing times out.This error occurs when write operation over Redis connection can't be executed.
partitioner.classconfiguration setting and setpartitioner.ignore.keys=true.