All Classes Interface Summary Class Summary Enum Summary Exception Summary Annotation Types Summary
| Class |
Description |
| ABP |
Deprecated.
|
| ABP.ABPHeader |
|
| ABP.Type |
|
| AckCollector |
Collects acks from a number of nodes, waits for all acks.
|
| AdditionalJmxObjects |
Allows objects to provide references to objects which also expose attributes or operations.
|
| Address |
Address identifies cluster member.
|
| 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 would be 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.jboss.org/browse/JGRP-2171
|
| AnycastAddress |
This type of address represents a subset of the cluster members in which the total order properties must be applied,
e.g.
|
| 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 |
|
| AsyncNoBundler |
Simple and stupid async version of NoBundler.
|
| 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 values.
|
| AverageMinMax |
Measures min and max in addition to average
|
| AwaitInfo |
|
| 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.
|
| BaseServer |
Abstract class for a server handling sending, receiving and connection management.
|
| BasicTCP |
Shared base class for TCP protocols
|
| 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 (and probably soon) FORWARD_TO_COORD
|
| BoundedList<T> |
A bounded subclass of LinkedList, oldest elements are removed once max capacity is exceeded.
|
| BPING |
Broadcast PING.
|
| Buffer |
Buffer with an offset and length.
|
| 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
|
| 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.
|
| Cache<K,V> |
Simple cache which maintains keys and value.
|
| Cache.ChangeListener |
|
| Cache.Value<V> |
|
| CENTRAL_EXECUTOR |
This is a central executor service where each request is sent to the coordinator
for either a task or a current waiting thread.
|
| CENTRAL_LOCK |
Implementation of a locking protocol which acquires locks by contacting the coordinator.
|
| CENTRAL_LOCK2 |
Implementation of a locking protocol which acquires locks by asking the coordinator.
Because the coordinator maintains all locks, no total ordering of requests is required.
CENTRAL_LOCK2 has all members send lock and unlock requests to the current coordinator.
|
| CertficateCNMatcher |
|
| Channel |
Deprecated.
|
| Channel.State |
|
| ChannelListener |
Allows a listener to be notified when an important channel lifecycle event occurs.
|
| Chat |
|
| CheckFDMonitor |
Rule which checks if the FD monitor is running when we have more than 1 member.
|
| 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 the given flags in the down direction for all messages
|
| Client |
Defines common operations for clients (TCP or NIO)
|
| ClientGmsImpl |
Client part of GMS.
|
| 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.
|
| Condition |
|
| 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 |
|
| COUNTER |
Protocol which is used by CounterService to provide a distributed atomic counter |
| COUNTER.AddAndGetRequest |
|
| COUNTER.BooleanResponse |
|
| COUNTER.CompareAndSetRequest |
|
| COUNTER.CounterHeader |
|
| COUNTER.DeleteRequest |
|
| COUNTER.ExceptionResponse |
|
| COUNTER.GetOrCreateRequest |
|
| COUNTER.GetOrCreateResponse |
|
| COUNTER.ReconcileRequest |
|
| COUNTER.ReconcileResponse |
|
| COUNTER.Request |
|
| COUNTER.RequestType |
|
| COUNTER.ResendPendingRequests |
|
| COUNTER.Response |
|
| COUNTER.ResponseType |
|
| COUNTER.SetRequest |
|
| COUNTER.SimpleRequest |
|
| COUNTER.SimpleResponse |
Response without data
|
| COUNTER.UpdateRequest |
|
| COUNTER.ValueResponse |
|
| COUNTER.VersionedValue |
|
| CounterService |
Provides a distributed counter (similar to AtomicLong) which can be atomically updated across a cluster.
|
| CounterServiceDemo |
|
| 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 |
|
| 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).
|
| DELIVERY_TIME |
Protocol measuring delivery times.
|
| DeliveryManager |
The interface that a delivery manager must implement.
|
| DeliveryManagerImpl |
The implementation of the Delivery Manager
|
| DeliveryManagerImpl.MessageInfo |
Keeps the state of a message
|
| DeliveryProtocol |
The interface that the Total Order Anycast protocol must implement.
|
| DeliveryThread |
The delivery thread.
|
| 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.
|
| DrawApplet |
|
| 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 |
|
| Encrypt<E extends java.security.KeyStore.Entry> |
|
| EncryptHeader |
|
| Event |
Event is a JGroups internal class used for inter-stack and intra-stack communication.
|
| EventHandler |
Interface which defines 2 callbacks: up() and down().
|
| EXAMPLE |
Example of a protocol layer.
|
| EXAMPLE.ExampleHeader |
|
| Executing |
This is the base protocol used for executions.
|
| Executing.ExecutorHeader |
|
| Executing.Owner |
|
| Executing.Request |
|
| Executing.RequestWithThread |
|
| Executing.Type |
|
| ExecutionCompletionService<V> |
|
| ExecutionRunner |
This class is to be used to pick up execution requests and actually run
them.
|
| ExecutionRunner.Holder<T> |
|
| Executions |
|
| Executions.StreamableCallable |
|
| ExecutionService |
This is a JGroups implementation of an ExecutorService, where the consumers
are running on any number of nodes.
|
| ExecutionService.DistributedFuture<V> |
This is basically a copy of the FutureTask in java.util.concurrent but
added serializable to it.
|
| ExecutionService.DistributedFuture.Sync<V> |
Synchronization control for FutureTask.
|
| ExecutionService.RunnableAdapter<T> |
This is copied from Executors class which
contains RunnableAdapter.
|
| ExecutionServiceDemo |
|
| ExecutionServiceDemo.ByteBufferStreamable |
|
| ExecutionServiceDemo.SortingByteCallable |
|
| ExecutionServiceDemo.SortingTwoByteCallable |
Sorts 2 byte arrys into a larger byte array
|
| ExecutorEvent |
Defines an event class for the execution of an entity.
|
| ExecutorNotification |
|
| 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 |
|
| FcHeader |
Header used by various flow control protocols
|
| FD |
Failure detection based on simple heartbeat protocol.
|
| 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.FdHeader |
|
| FILE_PING |
Simple discovery protocol which uses a file on shared storage such as an SMB share, NFS mount or S3.
|
| FileObserver |
FileObserver.
|
| FileWatchTask |
FileWatchTask.
|
| 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.
|
| FLUSH |
Flush, as it name implies, forces group members to flush their pending messages while blocking
them to send any additional messages.
|
| FLUSH.FlushHeader |
|
| FORK |
The FORK protocol; multiplexes messages to different forks in a stack (https://issues.jboss.org/browse/JGRP-1613).
|
| FORK.ForkHeader |
|
| ForkChannel |
Implementation of a ForkChannel, which is a light-weight channel.
|
| ForkConfig |
Parses the fork-stacks-4.2.xsd schema.
|
| ForkProtocol |
Acts as bottom protocol of a fork-stack.
|
| ForkProtocolStack |
Protocol stack which maintains the mapping between fork-channel IDs and ForkChannels
|
| FORWARD_TO_COORD |
Forwards a message to the current coordinator.
|
| FORWARD_TO_COORD.ForwardHeader |
|
| ForwardQueue |
Forwards messages in FIFO order to a destination.
|
| 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. |
| FRAG3.FragEntry |
Entry for a full message, received fragments are copied into buffer and set in the bitset of expected frags.
|
| Frag3Header |
|
| FragHeader |
|
| FutureListener<T> |
A listener that is called back when a future is done.
|
| 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 |
|
| GOOGLE_PING |
Deprecated.
|
| 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.Entry |
|
| GossipRouter.TLSClientAuth |
|
| GossipType |
Types of requests and responses exchanged between GossipRouter and RouterStubs
|
| GraphPanel |
|
| 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 |
|
| 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.
|
| ImmutableReference<T> |
Simple class that holds an immutable reference to another object (or to
null).
|
| INJECT_VIEW |
Simple protocol to inject an arbitrary view on one or more cluster nodes.
|
| InputStreamAdapter |
|
| IpAddress |
Network-dependent address (Internet).
|
| IpAddressUUID |
IpAddress with a 'semi'-UUID to prevent reincarnation when the port is fixed.
|
| 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.
|
| 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.
|
| LOCAL_PING |
Discovery protocol for finding members in the local process only.
|
| LocalAddress |
This is an assertion, checked at startup time.
|
| LockInfo |
|
| Locking |
Base locking protocol, handling most of the protocol communication with other instances.
|
| Locking.LockInfoResponse |
|
| Locking.LockingHeader |
|
| Locking.Request |
|
| Locking.Response |
A response to a request, to be sent back to the requester as a message
|
| Locking.Type |
|
| LockNotification |
|
| LockService |
LockService is the main class for to use for distributed locking functionality.
|
| LockServiceDemo |
Demos the LockService
|
| Log |
Simple logging wrapper for log4j or JDK logging.
|
| Log4J2LogImpl |
Logger that delivers messages to a Log4J2 logger
|
| LogFactory |
Factory that creates Log instances. |
| 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.
|
| Marshaller |
Performs serialization and de-serialization of RPC call arguments and return values (including exceptions)
|
| MatchingPromise<T> |
A promise which only sets the result if it matches the expected result
|
| 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.
|
| MD5Token |
Deprecated.
|
| 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.
|
| MembershipListener |
Allows a listener to be notified when group membership changes.
|
| MemcachedConnector |
Class which listens on a server socket for memcached clients, reads the requests, forwards them to an instance of
PartitionedHashMap and sends the response.
|
| MemcachedConnector.Request |
|
| MemcachedConnector.Request.Type |
|
| MemcachedServer |
Server process which listens for memcached requests and forwards them to an instance of PartitionedHashMap.
|
| 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 encapsulates data sent 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
|
| MessageDialog |
|
| MessageDispatcher |
Provides synchronous and asynchronous message sending with request-response
correlation; i.e., matching responses with the original request.
|
| MessageID |
The represents an unique identifier for the messages processed by the Total Order Anycast protocol
|
| MessageIterator |
|
| MessageListener |
MessageListener allows a listener to be notified when a Message or a state transfer
events arrives to a node. |
| 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 |
|
| MFC |
Simple flow control protocol based on a credit system.
|
| MFC_NB |
Non-blocking alternative to MFC.
JIRA: JIRA: https://issues.jboss.org/browse/JGRP-2172 |
| MockSocketChannel |
A mock SocketChannel for testing
|
| 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 (in TP)
|
| MULTI_PING |
Protocol to invoke multiple discovery protocols in the same stack.
|
| MutableDigest |
A mutable version of Digest.
|
| MyReceiver<T> |
Generic receiver for a JChannel
|
| NAKACK2 |
Negative AcKnowledgement layer (NAKs).
|
| NakAckHeader2 |
|
| NameCache |
Maintains the mappings between addresses and logical names (moved out of UUID.cache into a separate class)
|
| NAMING |
Maintains mappings between addresses and logical names.
|
| NAMING.Header |
|
| NAMING.Type |
|
| NioBaseServer |
|
| NioClient |
|
| NioConnection |
|
| NioConnection.State |
|
| 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.
|
| Node |
|
| 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.jboss.org/browse/JGRP-2172
|
| NonBlockingCreditMap |
|
| NonReflectiveProbeHandler |
|
| NoProgressException |
Exception raised when a threadpool rejects jobs but shows no progress.
|
| NotifyingFuture<T> |
A sub-interface of a Future, that allows for listeners to be attached so that observers can be notified when the
future completes.
|
| ObjectInputStreamWithClassloader |
Override ObjectInputStream.resolveClass(java.io.ObjectStreamClass) using the passed-in
classloader
|
| 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.
|
| ParticipantGmsImpl |
|
| PartitionedHashMap<K,V> |
Hashmap which distributes its keys and values across the cluster.
|
| PartitionedHashMap.ConsistentHashFunction<K> |
|
| PartitionedHashMap.HashFunction<K> |
|
| PartitionedHashMapDemo |
|
| PDC |
Persistent Discovery Cache.
|
| PDC.Mapping |
|
| 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
|
| Pool<T> |
Manages a fixed pool of resources (e.g.
|
| Pool.Element<T> |
|
| 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 |
|
| 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 |
|
| 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 |
| QuoteClient |
Used in conjunction with QuoteServer: a client is member of a group of quote servers which replicate
stock quotes among themselves.
|
| QuoteServer |
Example of a replicated quote server.
|
| RACKSPACE_PING |
Discovery protocol based on Rackspace Cloud Files storage solution
|
| RACKSPACE_PING.RackspaceClient |
A thread safe Rackspace ReST client
|
| Range |
|
| RATE |
Measures incoming and outgoing rates: messages/sec, bytes/sec.
|
| RATE_LIMITER |
Protocol which sends at most max_bytes in time_period milliseconds.
|
| Receiver |
Receiver interface to be used with BaseServer instances |
| Receiver |
Defines the callbacks that are invoked when messages, views etc are received on a channel
|
| ReceiverAdapter |
|
| ReceiverAdapter |
An adapter implementing the Receiver interface with no-op implementations.
|
| 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.
|
| RegexMembership |
Matches the IP address or logical name of a joiner against a regular expression and accepts or rejects based on
pattern matching
|
| RELAY |
Deprecated.
|
| RELAY.RelayHeader |
|
| RELAY.RelayHeader.Type |
|
| RELAY.ViewData |
Contains local and remote views, and UUID information
|
| RELAY2 |
Design: ./doc/design/RELAY2.txt and at https://github.com/belaban/JGroups/blob/master/doc/design/RELAY2.txt.
|
| RELAY2.Relay2Header |
|
| RelayConfig |
Parses and maintains the RELAY2 configuration (in memory)
|
| RelayConfig.BridgeConfig |
|
| RelayConfig.ForwardConfig |
|
| RelayConfig.ProgrammaticBridgeConfig |
|
| RelayConfig.PropertiesBridgeConfig |
|
| RelayConfig.SiteConfig |
|
| RelayDemo |
Demos RELAY.
|
| RelayDemoRpc |
Demos RELAY.
|
| Relayer |
Maintains bridges and routing table.
|
| 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.
|
| 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.
|
| RingBufferSeqno<T> |
Ring buffer, implemented with a circular array.
|
| RingBufferSeqnoLockless<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.
|
| RouterStubManager.Target |
|
| 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.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.jboss.org/browse/JGRP-1389).
|
| RSVP.Entry |
|
| RSVP.RsvpHeader |
|
| Rule |
A rule with a condition and (optional) action.
|
| Runner |
Runs a given function in a loop (in a separate thread) until it is stopped
|
| S3_PING |
Deprecated.
|
| SampleRule |
|
| SASL |
Deprecated.
|
| SaslClientCallbackHandler |
SaslClientCallbackHandler.
|
| SaslClientContext |
|
| SaslContext |
|
| SaslHeader |
|
| SaslHeader.Type |
|
| SaslServerContext |
|
| SaslUtils |
Utility methods for handling SASL authentication
|
| SendDialog |
|
| SenderManager |
Keeps track of all sent messages, until the final sequence number is known
|
| SenderSendsBundler |
|
| SeqnoList |
A bitset of missing messages with a fixed size.
|
| SequenceNumberManager |
Manages the messages sequence number (keeps it up-to-date)
|
| 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).
|
| SimpleAuthorizingCallbackHandler |
SimpleAuthorizingCallbackHandler.
|
| SimpleAuthorizingCallbackHandler.PropertiesReloadFileObserver |
|
| SimpleTCP |
Bare-bones thread-per-connection TCP-based transport.
|
| SimpleToken |
Deprecated.
|
| SimplifiedTransferQueueBundler |
This bundler uses the same logic as TransferQueueBundler but does not allocate
memory except for the buffer itself and does not use complex data structures. |
| SiteAddress |
Address with a site suffix
|
| 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). |
| 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.
|
| 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.
|
| StateListener |
Interface to provide state (state provider) and set state (state requester)
|
| 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
|
| StatsCollector |
This collects the stats and some profiling information
|
| STOMP |
Protocol which provides STOMP (http://stomp.codehaus.org/) 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.
|
| SUPERVISOR |
Deprecated.
|
| 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.
|
| 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.
|
| 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.
|
| ThreadFactory |
|
| TimeScheduler |
Timer-like interface which allows for execution of tasks.
|
| TimeScheduler.Task |
|
| TimeScheduler3 |
|
| TimeScheduler3.Task |
|
| TimeScheduler3.TaskType |
|
| TimeService |
Provides a coarse grained time service.
|
| TOA |
Total Order Anycast with three communication steps (based on Skeen's Algorithm).
|
| ToaHeader |
The header for the Total Order Anycast (TOA) protocol
|
| Topology |
Demonstrates the membership service.
|
| 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.jboss.org/browse/JGRP-2172 |
| UNICAST3 |
Reliable unicast protocol using a combination of positive and negative acks.
|
| UNICAST3.State |
|
| 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.
|
| UserInfoDialog |
|
| 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 |
|
| 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.
|
| ViewDemo |
Demos the reception of views using a PullPushAdapter.
|
| 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).
|
| Whiteboard |
Shared whiteboard: members are represented by rectangles that contain their names and the OS/arch of
the machine they are working on.
|
| 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.
|