All Classes Interface Summary Class Summary Enum Summary Exception Summary Annotation Types Summary
| Class |
Description |
| AckCollector |
Collects acks from a number of nodes, waits for all acks.
|
| AckTable |
Manages ACKs from receivers in NAKACK4 |
| Address |
Address identifies cluster member.
|
| AddressedDNSResolver |
|
| AddressGenerator |
Callback to provide custom addresses.
|
| AgeOutCache<K> |
Cache which removes its elements after a certain time
|
| AgeOutCache.Handler<K> |
|
| AlternatingBundler |
Bundler implementation which sends message batches (or single messages) as soon as the target destination changes
(or max_bundler_size is exceeded).
Messages are removed from the main queue one by one and processed as follows:
A B B C C A causes the following sends: A -> {CC} -> {BB} -> A
Note that null is also a valid destination (send-to-all).
JIRA: https://issues.redhat.com/browse/JGRP-2171
|
| ArrayIterator<T> |
Iterator over an array of elements of type T.
|
| AsciiString |
Simple string implemented as a byte[] array.
|
| ASYM_ENCRYPT |
Encrypts and decrypts communication in JGroups by using a secret key distributed to all cluster members by the
key server (coordinator) using asymmetric (public/private key) encryption.
The secret key is identical for all cluster members and is used to encrypt messages when sending and decrypt them
when receiving messages.
|
| ASYM_ENCRYPT.Processing |
|
| AsyncCounter |
An asynchronous counter interface.
|
| AsyncExecutor<T> |
Used to execute asynchronous tasks, e.g.
|
| AsyncExecutor.Task<T> |
|
| AttributeType |
|
| AUTH |
The AUTH protocol adds a layer of authentication to JGroups.
|
| AuthHeader |
AuthHeader is a holder object for the token that is passed from the joiner to the coordinator
|
| AuthToken |
Abstract AuthToken class used by implementations of AUTH, e.g.
|
| Average |
Maintains an approximation of an average of positive values by keeping a number of values and overwriting values
when new values are added.
This class uses lockless algorithms and is thread-safe
|
| AverageMinMax |
Measures min and max in addition to average
|
| BARRIER |
All messages up the stack have to go through a barrier (read lock, RL).
|
| Base64 |
Encodes and decodes to and from Base64 notation.
|
| Base64.InputStream |
A Base64.InputStream will read data from another
java.io.InputStream, given in the constructor,
and encode/decode to/from Base64 notation on the fly. |
| Base64.OutputStream |
A Base64.OutputStream will write data to another
java.io.OutputStream, given in the constructor,
and encode/decode to/from Base64 notation on the fly. |
| BaseBundler |
Implements storing of messages in a hashmap and sending of single messages and message batches.
|
| BaseCounter |
Base interface for all counters
|
| BaseDataOutputStream |
Implements DataOutput in a generic manner, so that subclasses can implement specific behavior.
|
| BaseMessage |
A common superclass for all Message implementations. |
| BaseServer |
Abstract class for a server handling sending, receiving and connection management.
|
| BasicTCP |
Shared base class for TCP protocols
|
| BATCH |
Batches messages near the top of the stack.
|
| BATCH.BatchHeader |
|
| BATCH2 |
Batches messages near the top of the stack.
|
| BATCH2.Batch2Header |
|
| BatchBundler |
|
| BatchMessage |
A message that contains a batch of messages.
|
| Bits |
Class (similar to (and partly copied from) java.nio.Bits) containing helper methods to encode variables
(e.g.
|
| BlockingInputStream |
Bounded input stream.
|
| BoundedHashMap<K,V> |
Bounded linked hashmap; used by SEQUENCER
|
| BoundedList<T> |
A bounded subclass of LinkedList, oldest elements are removed once max capacity is exceeded.
|
| BPING |
Broadcast PING.
|
| Bridge |
Class which joins the bridge cluster and send and receives messages to/from other sites.
|
| Buffer<T> |
Base class for message buffers.
|
| Buffer.Options |
|
| Buffer.Visitor<T> |
|
| Buffers |
Class to do scattering reads or gathering writes on a sequence of ByteBuffer instances.
|
| Bundler |
Pluggable way to collect messages and send them as batches
|
| ByteArray |
Byte array with an offset and length.
Note that the underlying byte array must not be changed as long as this instance is in use !
|
| ByteArrayDataInputStream |
Implements DataInput over a byte[] buffer.
|
| ByteArrayDataOutputStream |
Implements DataOutput over a byte[] buffer.
|
| ByteBufferInputStream |
Class using ByteBuffer and implementing DataInput.
|
| ByteBufferOutputStream |
Class using ByteBuffer and implementing DataOutput.
|
| BytesMessage |
A Message containing a byte array as payload. |
| Cache<K,V> |
Simple cache which maintains keys and value.
|
| Cache.ChangeListener |
|
| Cache.Value<V> |
|
| CertficateCNMatcher |
|
| ChannelListener |
Allows a listener to be notified when an important channel lifecycle event occurs.
|
| Chat |
|
| CheckCallerRunsPolicy |
If either UNICAST3 or NAKACK2 are missing, then
this policy checks that the thread pool has a rejection policy of
ThreadPoolExecutor.CallerRunsPolicy.
Issues a warning and changes the rejection policy to ThreadPoolExecutor.CallerRunsPolicy
if not. |
| CheckForAbsenceOfRED |
If either UNICAST3 or NAKACK2 are missing, then
this policy checks that RED is not in the protocol stack. |
| ClassConfigurator |
Maintains a mapping between magic IDs and classes (defined in jg-magic-map.xml), and between protocol IDs and
protocol classes (defined in jg-protocol-ids.xml).
|
| CLEAR_FLAGS |
Protocol which clears a set of flags in the down or up direction for all messages
|
| Client |
Defines common operations for clients (TCP or NIO)
|
| ClientGmsImpl |
Client part of GMS.
|
| CompletableFutures |
Utility class with CompletableFuture and CompletionStage useful methods.
|
| Component |
Tags components inside of protocols.
|
| CompositeMessage |
A message composed of multiple messages.
|
| COMPRESS |
Compresses the payload of a message.
|
| COMPRESS.CompressHeader |
|
| ConcurrentLinkedBlockingQueue<T> |
Attempt at writing a fast transfer queue, which is bounded.
|
| ConcurrentLinkedBlockingQueue2<T> |
Attempt at writing a fast transfer queue, which is bounded.
|
| CondVar |
A condition variable with methods for (timed) waiting and signalling
|
| Configurator |
The task if this class is to setup and configure the protocol stack.
|
| Configurator.InetAddressInfo |
|
| ConfiguratorFactory |
The ConfigurationFactory is a factory that returns a protocol stack configurator.
|
| Connection |
Represents a connection to a peer
|
| ConnectionListener |
|
| Constructable<T> |
Interface returning a supplier which can be called to create an instance
|
| CoordGmsImpl |
Coordinator role of the Group MemberShip (GMS) protocol.
|
| Counter |
Deprecated.
|
| COUNTER |
Protocol which is used by CounterService to provide a distributed atomic counter |
| COUNTER.AddAndGetRequest |
|
| COUNTER.CompareAndSetRequest |
|
| COUNTER.CounterHeader |
|
| COUNTER.DeleteRequest |
|
| COUNTER.ExceptionResponse |
|
| COUNTER.GetOrCreateRequest |
|
| COUNTER.ReconcileRequest |
|
| COUNTER.ReconcileResponse |
|
| COUNTER.Request |
|
| COUNTER.RequestType |
|
| COUNTER.ResendPendingRequests |
|
| COUNTER.ResponseType |
|
| COUNTER.SetRequest |
|
| COUNTER.SimpleRequest |
|
| COUNTER.UpdateRequest |
|
| COUNTER.ValueResponse |
|
| COUNTER.VersionedValue |
|
| CounterFunction<T extends Streamable> |
|
| CounterService |
Provides a distributed counter (similar to AtomicLong) which can be atomically updated across a cluster.
|
| CounterServiceDemo |
|
| CounterView |
A view representing the counter's state.
|
| Credit |
Maintains credits for a unicast destination.
|
| CreditMap |
Maintains credits for senders, when credits fall below 0, a sender blocks until new credits have been received.
|
| CustomLogFactory |
An extension interface allowing to plug in a custom log provider.
|
| CustomRejectionPolicy |
// TODO: Document this
|
| DAISYCHAIN |
Implementation of daisy chaining.
|
| DAISYCHAIN.DaisyHeader |
|
| DefaultDNSResolver |
|
| DefaultRouteStatusListener |
|
| DefaultSocketFactory |
Default implementation, ignores service names
|
| DefaultThreadFactory |
Thread factory mainly responsible for naming of threads.
|
| DELAY |
Delays incoming/outgoing messages by a random number of milliseconds (range between 0 and n
where n is determined by the user) and nanoseconds (constant amount).
|
| Delayer<T> |
Collects actions by key and executes them - if a predicate is true - every N ms.
|
| DeltaView |
Subclass of View with a null members field. |
| DETECT_LOOPBACKS |
Detects unicast loopbacks: messages where dest == local address
|
| DH_KEY_EXCHANGE |
Key exchange based on Diffie-Hellman-Merkle (https://en.wikipedia.org/wiki/Diffie%E2%80%93Hellman_key_exchange).
Diffie-Hellman is used between a member and a key server (the coordinator) to obtain a session key
(only known to the key server and the joiner) which is used by the key server to encrypt the shared secret symmetric
(group) key and by the requester to decrypt the group key it gets in the response of the key server.
|
| DH_KEY_EXCHANGE.DhHeader |
|
| DH_KEY_EXCHANGE.Type |
|
| DiagnosticsHandler |
|
| DiagnosticsHandler.ProbeHandler |
|
| Digest |
A message digest containing - for each member - the highest seqno delivered (hd) and the highest seqno received (hr).
|
| Digest.Entry |
Keeps track of one members plus its highest delivered and received seqnos
|
| DirectExecutor |
|
| DISCARD |
Discards up or down messages based on a percentage; e.g., setting property 'up' to 0.1 causes 10%
of all up messages to be discarded.
|
| DISCARD_PAYLOAD |
Discards a message whose sequence number (in the payload, as a Long) matches seqno 2 times,
before passing it down.
|
| Discovery |
The Discovery protocol retrieves the initial membership (used by GMS and MERGE3) by sending discovery requests.
|
| DNS_PING |
|
| DNSResolver |
|
| DNSResolver.DNSRecordType |
|
| Draw |
Shared whiteboard, each new instance joins the same group.
|
| DrawCommand |
Encapsulates information about a draw command.
|
| DROP |
Protocol which drops up or down messages according to user-defined filters
|
| DUPL |
Duplicates outgoing or incoming messages by copying them
|
| DUPL.Direction |
|
| DynamicBuffer<T> |
|
| EchoServer |
Simple TCP server replying back to client with connection information (peer address etc)
|
| EmptyMessage |
A Message without a payload; optimized for sending only headers (e.g. |
| Encrypt<E extends java.security.KeyStore.Entry> |
|
| EncryptHeader |
|
| Event |
Event is a JGroups internal class used for inter-stack and intra-stack communication.
|
| EXAMPLE |
Example of a protocol layer.
|
| EXAMPLE.ExampleHeader |
|
| Experimental |
Elements annotated with this annotation are experimental and may get removed from the distribution at any time
|
| ExpiryCache<K> |
Cache which maintains timestamps for keys, and methods to remove/replace expired keys.
|
| ExtendedUUID |
Subclass of UUID accommodating additional data such as a flag and a small hashmap. |
| FailureDetection |
|
| FailureDetection.HeartbeatHeader |
|
| FastArray<T> |
Simple
|
| FcHeader |
Header used by various flow control protocols
|
| FD_ALL |
Failure detection based on simple heartbeat protocol.
|
| FD_ALL2 |
Failure detection based on simple heartbeat protocol.
|
| FD_ALL3 |
Failure detection based on simple heartbeat protocol.
|
| FD_ALL3.Bitmap |
|
| FD_HOST |
Failure detection protocol which detects the crash or hanging of entire hosts and suspects all cluster members
on those hosts.
|
| FD_HOST.CommandExecutor2 |
|
| FD_HOST.ExternalPingCommand |
|
| FD_HOST.IsReachablePingCommand |
|
| FD_HOST.PingCommand |
Command used to check whether a given host is alive, periodically called
|
| FD_SOCK |
Failure detection protocol based on sockets.
|
| FD_SOCK.ClientConnectionHandler |
Handles a client connection; multiple client can connect at the same time
|
| FD_SOCK.FdHeader |
|
| FD_SOCK2 |
Failure detection protocol based on TCP connections, successor to FD_SOCK. |
| FD_SOCK2.FdHeader |
|
| FD_SOCK2.PingDest |
|
| FD_SOCK2.Request |
|
| FD_SOCK2.Request.Type |
|
| FD_SOCK2.State |
|
| FILE_PING |
Simple discovery protocol which uses a file on shared storage such as an SMB share, NFS mount or S3.
|
| FileWatcher |
|
| FixedBuffer<T> |
Ring buffer of fixed capacity.
|
| FixedMembershipToken |
The FixedMemberShipToken object predefines a list of IP addresses and ports that can join the group.
|
| FixedSizeBitSet |
Class copied from BitSet.
|
| FlagsUUID |
Subclass of UUID accommodating additional data such as a flag. |
| FlowControl |
Simple flow control protocol based on a credit system.
|
| FORK |
The FORK protocol; multiplexes messages to different forks in a stack (https://issues.redhat.com/browse/JGRP-1613).
|
| FORK.ForkHeader |
|
| ForkChannel |
Implementation of a ForkChannel, which is a light-weight channel.
|
| ForkConfig |
Parses the fork-stacks.xsd schema.
|
| ForkProtocol |
Acts as bottom protocol of a fork-stack.
|
| ForkProtocolStack |
Protocol stack which maintains the mapping between fork-channel IDs and ForkChannels
|
| ForwardingRoute |
Route which forwards all messages to a given site via a given route.
Example: if site HF is reachable via NET1, and NET2 is not directly connected to HF, it needs to have a
ForwardConfig with to="HF" and gateway="NET1".
|
| FRAG |
Fragmentation layer.
|
| FRAG2 |
Fragmentation layer.
|
| FRAG2.FragEntry |
Class represents an entry for a message.
|
| FRAG3 |
Fragmentation protocol which uses less memory to store fragments than FRAG2.
When a message is fragmented, all fragments carry the size of the original message, their offset and
length with respect to the original message and a fragment ID (to identify the fragment).
When the first fragment is received, the full message is created and each fragment copies its data into the full
message at its offset and length. |
| Frag3Header |
|
| FRAG4 |
Fragmentation layer.
|
| FragHeader |
|
| Fragmentation |
Base class for all fragmentation protocols.
|
| FragmentedMessage |
|
| GenerateGettersAndSetters |
Given a class, generates code for getters and setters for all attributes and writes it to stdout
|
| GenerateProfilingScript |
Takes a list of methods to profile and generates the Byteman script from them.
|
| GetNetworkInterfaces |
Lists all network interfaces on a system
|
| Global |
Global is a JGroups internal class defining global variables.
|
| GMS |
Group membership protocol.
|
| GMS.DefaultMembershipPolicy |
|
| GMS.GmsHeader |
|
| GmsImpl |
|
| GmsImpl.Request |
|
| GossipData |
Encapsulates data sent between GossipRouter and RouterStub (TCPGOSSIP and TUNNEL)
|
| GossipRouter |
Router for TCP based group comunication (using layer TCP instead of UDP).
|
| GossipRouter.DumpMessages |
|
| GossipRouter.Entry |
|
| GossipType |
Types of requests and responses exchanged between GossipRouter and RouterStubs
|
| GridFile |
Subclass of File to iterate through directories and files in a grid
|
| GridFile.Metadata |
|
| GridFilesystem |
Entry point for GridFile and GridInputStream / GridOutputStream
|
| GridInputStream |
|
| GridOutputStream |
|
| GroupRequest<T> |
Sends a message to all members of the group and waits for all responses (or timeout).
|
| GuardedBy |
Copyright (c) 2005 Brian Goetz and Tim Peierls
Released under the Creative Commons Attribution License
(http://creativecommons.org/licenses/by/2.5)
Official home: http://www.jcip.net
Adopted from Java Concurrency in Practice.
|
| HDRS |
Prints the headers of all sent or received messages
|
| Header |
Header is a JGroups internal base class for all JGroups headers.
|
| Headers |
Helper class providing functions to manipulate the headers array in BaseMessage. |
| Immutable |
Copyright (c) 2005 Brian Goetz and Tim Peierls
Released under the Creative Commons Attribution License
(http://creativecommons.org/licenses/by/2.5)
Official home: http://www.jcip.net
Adopted from Java Concurrency in Practice.
|
| INJECT_VIEW |
Simple protocol to inject an arbitrary view on one or more cluster nodes.
|
| InputStreamAdapter |
|
| IntHashMap<T> |
A hashmap where keys have to be ints.
|
| IpAddress |
Network-dependent address (Internet).
|
| JChannel |
A channel represents a group communication endpoint (like a socket).
|
| JChannel.State |
|
| JChannelProbeHandler |
|
| JChannelProbeHandler.ThreadEntry |
|
| JDBC_PING |
Discovery protocol using a JDBC connection to a shared database.
|
| JDBC_PING2 |
|
| JDKLogImpl |
Logger that delivers messages to a JDK logger
|
| JmxConfigurator |
|
| JmxDemo |
Shows how annotations can be used to expose attributes and operations
|
| JmxDemo.MyNotification |
|
| JoinRsp |
Result of a JOIN request (sent by the GMS client).
|
| KeyExchange |
Base class for protocols implementing key exchange: a secret key to be used for encryption is exchanged between
2 parties (usually the key server and a new cluster member) securely; ie.
|
| KeyStoreGenerator |
Generates a keystore file that has a SecretKey in it.
|
| Krb5Token |
JGroups AuthToken Class to for Kerberos v5 authentication.
|
| Krb5TokenUtils |
Support class that implements all the low level Kerberos security calls
|
| Krb5TokenUtils.LoginCallbackHandler |
|
| LargestWinningPolicy |
Policy which picks the new coordinator in a merge from the largest subview.
|
| LazyRemovalCache<K,V> |
Cache which doesn't remove elements on remove(), removeAll() or retainAll(), but only removes elements when a
configurable size limit has been exceeded.
|
| LazyRemovalCache.Entry<V> |
|
| LazyRemovalCache.Printable<K,V> |
|
| LazyThreadFactory |
Lazily names threads: whenever the address or cluster name is changed, all threads are renamed
|
| Leaver |
Handles the leaving of a member from a group.
|
| Lifecycle |
Interface that defines lifecycle methods.
|
| LOCAL_PING |
Discovery protocol for finding members in the local process only.
|
| LocalAddress |
This is an assertion, checked at startup time.
|
| LocalTransport |
A local transport is used for sending messages only to single (or all) members of the same host.
|
| Log |
Simple logging wrapper for log4j or JDK logging.
|
| Log4J2LogImpl |
Logger that delivers messages to a Log4J2 logger
|
| LogFactory |
Factory that creates Log instances. |
| LongMessage |
Message with a long as payload.
|
| LongSizeStreamable |
Utility class that implements SizeStreamable and LongSupplier to store a long value. |
| LongTuple<V> |
A tuple with a long (primitive) first value
|
| MAKE_BATCH |
Intercepts individual up messages and creates batches from them, passing the batches up.
|
| ManagedAttribute |
Indicates that a public method or a field (any visibility) in
an MBean class defines an MBean attribute.
|
| ManagedOperation |
Indicates that a method in an MBean class defines an MBean
operation.
|
| MaxOneThreadPerSender |
MessageProcessingPolicy which processes regular messages and message batches by
assigning a max of 1 thread per message from the same sender. |
| MBean |
Optional annotation that exposes all public methods in the class hierarchy (excluding Object) as MBean operations.
|
| Membership |
Represents a membership of a cluster group.
|
| MembershipChangePolicy |
Policy used to determine the new membership after a membership change (join, leave) or a merge.
|
| MERGE3 |
Protocol to discover subgroups; e.g., existing due to a network partition (that healed).
|
| MERGE3.MergeHeader |
|
| MERGE3.MergeHeader.Type |
|
| MergeData |
Encapsulates data sent with a MERGE_RSP (handleMergeResponse()) and INSTALL_MERGE_VIEW (handleMergeView()).
|
| MergeId |
ID to uniquely identify a merge
|
| Merger |
Handles merging.
|
| MergeView |
A view that is sent as a result of a cluster merge.
|
| Message |
A Message is used to send data to members of a group.
|
| Message.Flag |
|
| Message.TransientFlag |
|
| MessageBatch |
Represents a message batch; multiple messages from the same sender to the same receiver(s).
|
| MessageBatch.Mode |
|
| MessageCache |
A cache associating members and messages
|
| MessageDispatcher |
Provides synchronous and asynchronous message sending with request-response
correlation; i.e., matching responses with the original request.
|
| MessageFactory |
Factory to create messages.
|
| MessageProcessingPolicy |
Policy which decides how to process a received message or message batch.
|
| MethodCall |
A method call is the JGroups representation of a remote method.
|
| MethodInvoker |
|
| MethodLookup |
|
| Metrics |
Extracts all attributes and methods annotated with ManagedAttribute and returns them
as a map of names associated with [getter-method/description tuples]. |
| Metrics.Entry<T> |
|
| MFC |
Simple flow control protocol based on a credit system.
|
| MFC_NB |
Non-blocking alternative to MFC.
JIRA: JIRA: https://issues.redhat.com/browse/JGRP-2172 |
| MockSocketChannel |
A mock SocketChannel for testing
|
| MockTransport |
A dummy implementation of TP |
| MPING |
Uses its own IP multicast socket to send and receive discovery requests/responses.
|
| MsgStats |
Class which has all the stats about received/sent messages etc.
|
| MutableDigest |
A mutable version of Digest.
|
| MyReceiver<T> |
Generic receiver for a JChannel
|
| NAKACK2 |
Negative AcKnowledgement layer (NAKs).
|
| NAKACK3 |
Negative AcKnowledgement layer (NAKs).
|
| NAKACK4 |
New multicast protocol based on fixed-size xmit windows and message ACKs
Details: https://issues.redhat.com/browse/JGRP-2780
|
| NakAckHeader |
|
| NakAckHeader2 |
|
| NameCache |
Maintains the mappings between addresses and logical names (moved out of UUID.cache into a separate class)
|
| NioBaseServer |
|
| NioClient |
|
| NioConnection |
|
| NioMessage |
A Message with a (heap-based or direct) ByteBuffer as payload.
Note that the payload of an NioMessage must not be modified after sending it (ie. |
| NioServer |
Server for sending and receiving messages via NIO channels.
|
| NoBundler |
Bundler which doesn't bundle :-) Can be used to measure the diff between bundling and non-bundling (e.g.
|
| NON_BLOCKING_SENDS |
Detects sends during processing of incoming messages and sets flag
Message.TransientFlag.DONT_BLOCK to prevent blocking the incoming thread on a send.
JIRA: https://issues.redhat.com/browse/JGRP-2772 |
| NonBlockingCredit |
Non-blocking credit for a unicast destination.
Instead of blocking when insufficient credits are available for sending a message, this class queues the
message and sends it at a later time when enough credits have been received to send it.
JIRA: https://issues.redhat.com/browse/JGRP-2172
|
| NonBlockingCreditMap |
|
| NonReflectiveProbeHandler |
|
| NoProgressException |
Exception raised when a threadpool rejects jobs but shows no progress.
|
| NullAddress |
|
| ObjectInputStreamWithClassloader |
Override ObjectInputStream.resolveClass(java.io.ObjectStreamClass) using the passed-in
classloader
|
| ObjectMessage |
A Message with an object as payload. |
| ObjectWrapperPrimitive |
Wraps a primitive object (e.g.
|
| ObjectWrapperSerializable |
Wraps an object and its serialized form.
|
| OneTimeAddressGenerator |
Implementation of AddressGenerator which is configured with an initial value, and
after that random values are generated. |
| OutputStreamAdapter |
|
| Owner |
Represents an 'owner', which is an address and thread ID
|
| PaddedAtomicBoolean |
|
| PaddedAtomicInteger |
|
| PaddedAtomicLong |
Copied from http://mechanical-sympathy.blogspot.ch/2011/08/false-sharing-java-7.html.
|
| PartialOutputStream |
Decorates an output stream (DataOutput) and writes only a subset [start..end] (both indices
inclusive) of the original data to the underlying output stream.
Example:
|
| ParticipantGmsImpl |
|
| PassRegularMessagesUpDirectly |
MessageProcessingPolicy which passes regular messages and message batches up directly
(on the same thread), but passes OOB messages to the thread pool. |
| PDC |
Persistent Discovery Cache.
|
| PDC.Mapping |
|
| PerDestinationBundler |
Queues messages per destination ('null' is a special destination), sending when the last sender thread to the same
destination returns or max_size has been reached.
|
| PERF |
Protocol measuring latency between stacks.
|
| PERF.PerfHeader |
|
| PhysicalAddress |
Represents a physical (as opposed to logical) address
|
| PING |
The PING protocol retrieves the initial membership by mcasting a discovery request (via the multicast capable
transport) to all current cluster members
|
| PingData |
Encapsulates information about a cluster node, e.g.
|
| PingHeader |
Used to send discovery requests and responses
|
| Policy |
A policy implementation checks that a condition is met or throws an exception if not.
|
| ProcessingQueue<T> |
A queue with many producers and consumers.
|
| ProcessingQueue.Handler<T> |
|
| Profiler |
|
| ProgrammaticChat |
|
| ProgressCheckRejectionPolicy |
Detects
|
| Promise<T> |
Allows a thread to submit an asynchronous request and to wait for the result.
|
| PropertiesToAsciidoc |
Iterates over all concrete Protocol classes and creates tables with Protocol's properties.
|
| Property |
Represents a Protocol property assigned from corresponding field in JGroups
properties file.
|
| PropertyConverter |
Represents a property converter that takes an input from corresponding field
in JGroups properties file as a String and converts it to a matching Java
type.
|
| PropertyConverters |
Groups a set of standard PropertyConverter(s) supplied by JGroups.
|
| PropertyConverters.BindInterface |
|
| PropertyConverters.Default |
|
| PropertyConverters.InitialHosts |
|
| PropertyConverters.InitialHosts2 |
|
| PropertyConverters.NetworkInterfaceList |
|
| PropertyConverters.PolicyConverter |
Creates a list of Policy objects from a comma-separated list of classnames
|
| PropertyHelper |
|
| Protocol |
The Protocol class provides a set of common services for protocol layers.
|
| ProtocolConfiguration |
Parses and encapsulates the specification for 1 protocol of the protocol stack, e.g.
|
| ProtocolHook |
Provides hook(s) that are called when a protocol has been created
|
| ProtocolStack |
A ProtocolStack manages a number of protocols layered above each other.
|
| ProtocolStack.Position |
|
| ProtocolStackConfigurator |
|
| ProtPerfHeader |
|
| PubClient |
Demo of a client which connects to a server ( PubServer) and sends it messages which are forwarded to all
connected clients |
| PubServer |
Demo which starts an NioServer that accepts messages from clients ( PubClient) and forwards them to
all connected clients |
| RACKSPACE_PING |
Discovery protocol based on Rackspace Cloud Files storage solution
|
| RACKSPACE_PING.RackspaceClient |
A thread safe Rackspace ReST client
|
| RandomSiteMasterPicker |
Implementation of SiteMasterPicker which picks random site masters / routes to site masters |
| Range |
|
| RATE |
Measures incoming and outgoing rates: messages/sec, bytes/sec.
|
| RATE_LIMITER |
Protocol which sends at most max_bytes in time_period milliseconds.
|
| RATE_LIMITER2 |
Rate limiter based credits (max_bytes).
|
| Receiver |
Receiver interface to be used with BaseServer instances |
| Receiver |
Defines the callbacks that are invoked when messages, views etc are received
|
| ReceiverAdapter |
|
| RecommendedForUpgrade |
Protocols annotated with this annotation should upgrade to a newer version (e.g.
|
| RED |
Implementation of Random Early Drop: messages are discarded when the bundler's queue in the transport nears exhaustion.
|
| Ref<T> |
Keeps a reference to another object
|
| ReflectUtils |
Methods to get/set attributes and invoke operations of a given instance.
|
| RegexMembership |
Matches the IP address or logical name of a joiner against a regular expression and accepts or rejects based on
pattern matching
|
| RELAY |
|
| RELAY2 |
Design: ./doc/design/RELAY2.txt and at https://github.com/belaban/JGroups/blob/master/doc/design/RELAY2.txt.
|
| RELAY3 |
Provides relaying of messages between autonomous sites.
Design: ./doc/design/RELAY2.txt and at https://github.com/belaban/JGroups/blob/master/doc/design/RELAY2.txt.
JIRA: https://issues.redhat.com/browse/JGRP-1433
|
| RelayConfig |
Parses and maintains the RELAY2 configuration (in memory)
|
| RelayConfig.BridgeConfig |
|
| RelayConfig.ForwardConfig |
Forwards to site 'to' via route 'gateway'.
|
| RelayConfig.ProgrammaticBridgeConfig |
|
| RelayConfig.PropertiesBridgeConfig |
|
| RelayConfig.SiteConfig |
|
| RelayDemo |
Demos RELAY.
|
| RelayDemoRpc |
Demos RELAY.
|
| Relayer |
Base class for all relayers
|
| Relayer2 |
Maintains bridges and routing table.
|
| Relayer3 |
Maintains bridges and routing table.
|
| RelayHeader |
|
| ReliableMulticast |
Base class for reliable multicast protocols
|
| ReliableMulticast.Entry |
|
| ReliableUnicast |
Base class for reliable unicast protocols
|
| ReliableUnicast.State |
|
| ReloadingX509KeyManager |
A X509ExtendedKeyManager which uses a @ FileWatcher to check for changes. |
| ReloadingX509TrustManager |
A X509ExtendedTrustManager which uses a @ FileWatcher to check for changes. |
| RemoveQueueBundler |
Bundler implementation which sends message batches (or single messages) as soon as the remove queue is full
(or max_bundler_size would be exceeded).
Messages are removed from the main queue and processed as follows (assuming they all fit into the remove queue):
A B B C C A causes the following sends: {AA} -> {CC} -> {BB}
Note that null is also a valid destination (send-to-all).
Contrary to TransferQueueBundler, this bundler uses a RingBuffer rather than an ArrayBlockingQueue
and the size of the remove queue is fixed. |
| ReplCache<K,V> |
Cache which allows for replication factors per data items; the factor determines how many replicas
of a key/value we create across the cluster.
See doc/design/ReplCache.txt for details.
|
| ReplCache.ChangeListener |
|
| ReplCache.ConsistentHashFunction<K> |
|
| ReplCache.HashFunction<K> |
|
| ReplCache.HashFunctionFactory<K> |
|
| ReplCache.Value<V> |
|
| ReplCacheDemo |
GUI demo of ReplCache
|
| ReplicatedHashMap<K,V> |
Implementation of a ConcurrentMap with replication of the contents across a cluster.
|
| ReplicatedHashMap.Notification<K,V> |
|
| ReplicatedHashMapDemo |
Uses the ReplicatedHashMap building block, which subclasses java.util.HashMap and overrides
the methods that modify the hashmap (e.g.
|
| ReplicatedMap<K,V> |
|
| ReplicatedTree |
A tree-like structure that is replicated across several members.
|
| ReplicatedTree.Node |
|
| ReplicatedTree.ReplicatedTreeListener |
|
| Request<T> |
Abstract class for a unicast or multicast request
|
| RequestCorrelator |
Framework to send requests and receive matching responses (on request ID).
|
| RequestCorrelator.Header |
The header for RequestCorrelator messages
|
| RequestCorrelator.MultiDestinationHeader |
|
| RequestHandler |
|
| RequestOptions |
Class which captures a bunch of options relevant to remote method invocation or message sending
|
| RequestTable<T> |
Table for storing requests associated with monotonically increasing sequence numbers (seqnos).
|
| RequestTable.Visitor<T> |
|
| ResourceDMBean |
A DynamicMBean wrapping an annotated object instance and exposing attributes annotated with @ManagedAttribute and
operations annotated with @ManagedOperation.
|
| ResourceDMBean.Accessor |
|
| ResourceDMBean.AttributeEntry |
|
| ResourceDMBean.FieldAccessor |
|
| ResourceDMBean.MethodAccessor |
|
| ResourceDMBean.NoopAccessor |
|
| ResourceManager |
Manages resources such as multicast addresses and multicast ports, and TCP
ports.
|
| ResourceManager.IpAddressRep |
|
| Response |
|
| ResponseCollector<T> |
Similar to AckCollector, but collects responses from cluster members, not just acks.
|
| ResponseCollectorTask<T> |
Task which is seeded with an initial membership.
|
| ResponseMode |
Enum capturing the various response modes for RPCs
|
| Responses |
Manages responses for the discovery protocol.
|
| Responses.PingDataIterator |
|
| REVERSE |
Reverses the next N messages that are received.
|
| REVERSE2 |
|
| RingBuffer<T> |
Ring buffer of fixed capacity designed for multiple writers but only a single reader.
|
| RingBufferBundler |
|
| RingBufferBundlerLockless |
Bundler which doesn't use locks but relies on CAS.
|
| RingBufferBundlerLockless2 |
Lockless bundler using a reader thread which is unparked by (exactly one) writer thread.
|
| RingBufferSeqnoLockless<T> |
Ring buffer, implemented with a circular array.
|
| RingBufferSeqnoOld<T> |
Ring buffer, implemented with a circular array.
|
| Route |
Class which maintains the destination address for sending messages to a given site, and the bridge channel to do so.
|
| RouterStub |
Client stub that talks to a remote GossipRouter via blocking or non-blocking TCP
|
| RouterStub.CloseListener |
|
| RouterStub.MembersNotification |
|
| RouterStub.StubReceiver |
|
| RouterStubManager |
Manages a list of RouterStubs (e.g.
|
| RouteStatusListener |
Gets notified when a site comes up or goes down
|
| RpcDispatcher |
This class allows a programmer to invoke remote methods in all (or single) group members and optionally wait for
the return value(s).
|
| RpcStats |
Keeps track of stats for sync and async unicasts and multicasts
|
| RpcStats.Result |
|
| RpcStats.RTTStat |
|
| RpcStats.Type |
|
| Rsp<T> |
Class that represents a response from a communication
|
| RspFilter |
Interface defining when a group request is done.
|
| RspList<T> |
Contains responses from all members.
|
| RSVP |
Protocol which implements synchronous messages (https://issues.redhat.com/browse/JGRP-1389).
|
| RSVP.Entry |
|
| RSVP.RsvpHeader |
|
| RTT |
Measures round-trip times (RTT) between nodes
|
| RTTHeader |
Header to measure round-trip times (in nanoseconds) for sync RPCs (https://issues.redhat.com/browse/JGRP-2604)
|
| Runner |
Runs a given function in a loop (in a separate thread) until it is stopped
|
| SenderSendsBundler |
|
| SeqnoList |
A bitset of missing messages with a fixed size.
|
| SEQUENCER |
Implementation of total order protocol using a sequencer.
|
| SEQUENCER.SequencerHeader |
|
| SEQUENCER2 |
Implementation of total order protocol using a sequencer_uum.
|
| SEQUENCER2.SequencerHeader |
|
| SERIALIZE |
Serializes the entire message (including payload, headers, flags and destination and src) into the payload of
another message that's then sent.
|
| ServerGmsImpl |
Common super class for CoordGmsImpl and ParticipantGmsImpl
|
| SHARED_LOOPBACK |
Loopback transport shared by all channels within the same VM.
|
| SHARED_LOOPBACK_PING |
|
| SHUFFLE |
Reorders messages by buffering them and shuffling the result after TIMEOUT ms.
|
| ShutdownRejectedExecutionHandler |
ShutdownRejectedExecutionHandler is a decorator RejectedExecutionHandler used
in all JGroups ThreadPoolExecutor(s).
|
| SimpleTCP |
Bare-bones thread-per-connection TCP-based transport.
|
| SiteAddress |
Address with a site suffix
|
| SiteAddress.Type |
|
| SiteMaster |
Special address with the UUID part being 0: identifies the current (relay) coordinator of a given site.
|
| SiteMasterPicker |
Allows an implementation to pick a SiteMaster or a Route from a list (if multiple site masters are
enabled). |
| SiteStatus |
Maintains the status of sites (up, down, undefined).
|
| SiteStatus.Status |
|
| SiteUUID |
Implementation of SiteAddress
|
| SIZE |
Protocol which prints out the real size of a message.
|
| SizeBoundedQueue<T> |
Blocking FIFO queue bounded by the max number of bytes of all elements.
|
| SizeBoundedQueue.El<T> |
|
| SizeStreamable |
Interface implementing Streamable and returning the size of the marshalled object.
|
| Slf4jLogImpl |
Logger that delivers messages to a SLF4J logger
|
| SNIFF |
Protocol trying to print message payloads as strings
|
| SocketFactory |
Factory to create various types of sockets.
|
| SOS |
Periodically fetches some attributes and writes them to a file (https://issues.redhat.com/browse/JGRP-2402)
|
| SSL_KEY_EXCHANGE |
Key exchange based on SSL sockets.
|
| SSL_KEY_EXCHANGE.SessionVerifier |
|
| SSL_KEY_EXCHANGE.Type |
|
| SslContextFactory |
SslContextFactory.
|
| SslContextFactory.Context |
|
| STABLE |
Computes the broadcast messages that are stable; i.e., have been delivered by all members.
|
| STABLE.StableHeader |
|
| StackType |
|
| STATE |
STATE streams the state (written to an OutputStream) to the state requester in chunks (defined by
chunk_size).
|
| STATE_SOCK |
STATE_SOCK has the state provider create a server socket to which the state
requester connects and from which the latter reads the state.
|
| STATE_TRANSFER |
STATE_TRANSFER protocol based on byte array transfer.
|
| STATE_TRANSFER.StateHeader |
Wraps data for a state request/response.
|
| StateTransferException |
StateTransferException is thrown to indicate a failure of a state transfer between
cluster members.
|
| StateTransferInfo |
Contains parameters for state transfer.
|
| StateTransferResult |
Encapsulates the result of a state transfer.
|
| STATS |
Provides various stats
|
| StickySiteMasterPicker |
Picks a local site master or a route based on the sender and caches the decision.
|
| STOMP |
Protocol which provides STOMP (https://stomp.github.io/) support.
|
| STOMP.ClientVerb |
|
| STOMP.Frame |
|
| STOMP.ServerVerb |
|
| STOMP.StompHeader |
|
| STOMP.StompHeader.Type |
|
| StompChat |
Chat client using STOMP to talk to other clients
|
| StompConnection |
STOMP client to access the STOMP [1] protocol.
|
| StompConnection.ConnectionCallback |
|
| StompConnection.Listener |
|
| StompDraw |
Simple STOMP demo client.
|
| Streamable |
Implementations of Streamable can add their state directly to the output stream, enabling them to bypass costly
serialization
|
| StreamingStateTransfer |
Base class for state transfer protocols which use streaming (or chunking) to transfer state between two members.
|
| StreamingStateTransfer.StateHeader |
|
| SubmitToThreadPool |
Default message processing policy.
|
| SuppressCache<T> |
Cache which keeps a timestamp and counter for every key.
|
| SuppressCache.Value |
|
| SuppressLog<T> |
Log (using SuppressCache) which suppresses (certain) messages from the same member for a given time |
| SuppressLog.Level |
|
| SuspectedException |
Thrown if a message is sent to a suspected member.
|
| SWIFT_PING |
Discovery protocol based on Openstack Swift (object storage).
|
| SWIFT_PING.SwiftClient |
A thread safe Swift client
|
| SYM_ENCRYPT |
Encrypts and decrypts communication in JGroups by using a secret key shared by all cluster members.
|
| SyncCounter |
A synchronous counter interface
|
| Table<T> |
A store for elements (typically messages) to be retransmitted or delivered.
|
| Table.Visitor<T> |
|
| TCP |
TCP based protocol.
|
| TCP_NIO2 |
Protocol using TCP/IP to send and receive messages.
|
| TcpBaseServer |
Common base class for TCP based clients and servers
|
| TcpClient |
|
| TcpConnection |
Blocking IO (BIO) connection.
|
| TcpConnectionNonBlocking |
TCP connection which (despite the fancy name) blocks only a single thread at most.
|
| TCPGOSSIP |
The TCPGOSSIP protocol layer retrieves the initial membership (used by GMS when started by sending event
FIND_INITIAL_MBRS down the stack).
|
| TCPPING |
The TCPPING protocol defines a static cluster membership.
|
| TcpServer |
Class that manages allows to send and receive messages via TCP sockets.
|
| Tests |
Common functions for all tests
|
| THREAD_COUNT |
Maintains averages of up- and down-threads
|
| ThreadCreator |
|
| ThreadFactory |
|
| ThreadPool |
Thread pool based on ThreadPoolExecutor
|
| TIME |
Protocol measuring delivery times.
|
| TimeScheduler |
Timer-like interface which allows for execution of tasks.
|
| TimeScheduler.Task |
|
| TimeScheduler3 |
|
| TimeScheduler3.Task |
|
| TimeScheduler3.TaskType |
|
| TimeService |
Provides a coarse grained time service.
|
| TLS |
Component to configure TLS in protocols ( TCP and TUNNEL). |
| TLS.SniMatcherConverter |
|
| TLSClientAuth |
|
| Topology |
Demonstrates the membership service.
|
| Topology |
Provides a cache of all sites and their members (addresses, IP addresses, site masters etc) in a network of
autonomous sites.
|
| TotalOrder |
Originally written to be a demo for TOTAL order (code to be written by a student).
|
| TP |
Generic transport - specific implementations should extend this abstract class.
|
| TpHeader |
Generic transport header, used by TP.
|
| TRACE |
|
| TransferQueueBundler |
This bundler adds all (unicast or multicast) messages to a queue until max size has been exceeded, but does send
messages immediately when no other messages are available.
|
| Triple<V1,V2,V3> |
Holds 3 values, useful when we have a map with a key, but more than 1 value and we don't want to create a separate
holder object for the values, and don't want to pass the values as a list or array.
|
| TUNNEL |
Replacement for UDP.
|
| TUNNEL.TUNNELPolicy |
|
| Tuple<V1,V2> |
Holds 2 values, useful when we have a map with a key, but more than 1 value and we don't want to create a separate
holder object for the values, and don't want to pass the values as a list or array.
|
| UDP |
IP multicast transport based on UDP.
|
| UFC |
Simple flow control protocol based on a credit system.
|
| UFC_NB |
Non-blocking alternative to UFC.
JIRA: https://issues.redhat.com/browse/JGRP-2172 |
| UNBATCH |
|
| UnbatchOOBBatches |
Same as MaxOneThreadPerSender, but for OOB message batches, every message of the batch is passed to the
thread pool separately (https://issues.redhat.com/browse/JGRP-2800). |
| UNICAST3 |
Reliable unicast protocol using a combination of positive and negative acks.
|
| UNICAST3.State |
|
| UNICAST4 |
New unicast protocol based on fixed-size xmit windows and message ACKs
Details: https://issues.redhat.com/browse/JGRP-2843
|
| UnicastHeader |
|
| UnicastHeader3 |
Moved out of UNICAST3 into separate class. |
| UnicastRequest<T> |
Sends a request to a single target destination
|
| UnknownForkHandler |
Allows a user of fork to define the handling of a message for which no fork stack or fork channel exists.
|
| UnreachableException |
Thrown if member in different site cannot be contacted; used by RELAY2
|
| Unsupported |
Elements annotated with this annotation are unsupported and may get removed from the distribution at any time
|
| UpHandler |
Provides a hook to hijack all events received by a certain channel which has installed this UpHandler.
|
| Util |
Collection of various utility routines that can not be assigned to other classes.
|
| Util.AddressScope |
|
| UUID |
Logical address which is unique over space and time.
|
| VERIFY_SUSPECT |
Catches SUSPECT events traveling up the stack.
|
| VERIFY_SUSPECT.Entry |
|
| VERIFY_SUSPECT.VerifyHeader |
|
| VERIFY_SUSPECT2 |
Double-checks that a suspected member is really dead.
Details: https://issues.redhat.com/browse/JGRP-2558
Design: https://github.com/belaban/JGroups/blob/master/doc/design/VERIFY_SUSPECT2.txt
|
| VERIFY_SUSPECT2.Entry |
|
| VERIFY_SUSPECT2.VerifyHeader |
|
| Version |
We're using the scheme described at http://www.jboss.com/index.html?module=bb&op=viewtopic&t=77231
for major, minor and micro version numbers.
|
| View |
A view is a local representation of the current membership of a group.
|
| ViewHandler<R> |
Responsible for dispatching JOIN/LEAVE/MERGE requests to the GMS protocol.
|
| ViewId |
ViewIds are used for ordering views (each view has a ViewId and a list of members).
|
| WriteVersionTo |
Extracts version and codename from pom.xml and writes them to ./classes/JGROUPS_VERSION.properties
|
| X509Token |
This is an example of using a preshared token that is encrypted using an X509 certificate for
authentication purposes.
|
| XmlAttribute |
|
| XmlConfigurator |
Uses XML to configure a protocol stack
|
| XmlConfigurator.ElementType |
|
| XmlElement |
|
| XmlInclude |
|
| XmlInclude.Type |
|
| XmlNode |
A simple replacement for a W3C DOM node.
|
| XMLSchemaGenerator |
Iterates over all concrete Protocol classes and creates XML schema used for validation of configuration files.
|