Uses of Interface
org.jgroups.Lifecycle

Packages that use Lifecycle

Package	Description
org.jgroups.admin
org.jgroups.blocks	Provides building blocks that are layered on top of channels.
org.jgroups.fork
org.jgroups.protocols	Provides implementations of transport protocols which are responsible for sending and receiving messages to/from the network.
org.jgroups.protocols.dns
org.jgroups.protocols.pbcast
org.jgroups.protocols.relay
org.jgroups.stack	Support for managing protocol stacks.
org.jgroups.util	Provides useful functionality which cannot be assigned to any particular other package.

Uses of Lifecycle in org.jgroups.admin

Classes in org.jgroups.admin that implement Lifecycle

Modifier and Type	Class	Description
class	Admin	Class to manage JGroups-internal cluster wide requests and responses (https://redhat.atlassian.net/browse/JGRP-3043).

Uses of Lifecycle in org.jgroups.blocks

Classes in org.jgroups.blocks that implement Lifecycle

Modifier and Type	Class	Description
protected class	MessageDispatcher.ProtocolAdapter

Uses of Lifecycle in org.jgroups.fork

Classes in org.jgroups.fork that implement Lifecycle

Modifier and Type	Class	Description
class	ForkProtocol	Acts as bottom protocol of a fork-stack.
class	ForkProtocolStack	Protocol stack which maintains the mapping between fork-channel IDs and ForkChannels

Uses of Lifecycle in org.jgroups.protocols

Classes in org.jgroups.protocols that implement Lifecycle

Modifier and Type	Class	Description
class	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.
class	AUTH	The AUTH protocol adds a layer of authentication to JGroups.
class	BARRIER	All messages up the stack have to go through a barrier (read lock, RL).
class	BasicTCP	Shared base class for TCP protocols
class	BATCH2	Batches messages near the top of the stack.
class	BPING	Broadcast PING.
class	CLEAR_FLAGS	Protocol which clears a set of flags in the down or up direction for all messages
class	COMPRESS	Compresses the payload of a message.
class	COUNTER	Protocol which is used by CounterService to provide a distributed atomic counter
class	DAISYCHAIN	Implementation of daisy chaining.
class	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).
class	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.
class	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.
class	DISCARD_PAYLOAD	Discards a message whose sequence number (in the payload, as a Long) matches seqno 2 times, before passing it down.
class	Discovery	The Discovery protocol retrieves the initial membership (used by GMS and MERGE3) by sending discovery requests.
class	DROP	Protocol which drops up or down messages according to user-defined filters
class	DUPL	Duplicates outgoing or incoming messages by copying them
class	Encrypt<E extends KeyStore.Entry>	Super class of symmetric (SYM_ENCRYPT) and asymmetric (ASYM_ENCRYPT) encryption protocols.
class	EXAMPLE	Example of a protocol layer.
class	FailureDetection	Base class for all failure detection protocols
class	FD_ALL	Failure detection based on simple heartbeat protocol.
class	FD_ALL2	Failure detection based on simple heartbeat protocol.
class	FD_ALL3	Failure detection based on simple heartbeat protocol.
class	FD_HOST	Failure detection protocol which detects the crash or hanging of entire hosts and suspects all cluster members on those hosts.
class	FD_SOCK	Failure detection protocol based on sockets.
class	FD_SOCK2	Failure detection protocol based on TCP connections, successor to FD_SOCK.
class	FILE_PING	Simple discovery protocol which uses a file on shared storage such as an SMB share, NFS mount or S3.
class	FlowControl	Simple flow control protocol based on a credit system.
class	FORK	The FORK protocol; multiplexes messages to different forks in a stack (https://issues.redhat.com/browse/JGRP-1613).
class	FRAG	Fragmentation layer.
class	FRAG2	Fragmentation layer.
class	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.
class	FRAG4	Fragmentation layer.
class	Fragmentation	Base class for all fragmentation protocols.
class	HDRS	Prints the headers of all sent or received messages
class	INJECT_VIEW	Simple protocol to inject an arbitrary view on one or more cluster nodes.
class	JDBC_PING	Discovery protocol using a JDBC connection to a shared database.
class	JDBC_PING2	New version of JDBC_PING.
class	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.
class	LOCAL_PING	Discovery protocol for finding members in the local process only.
class	MAKE_BATCH	Intercepts individual up messages and creates batches from them, passing the batches up.
class	MERGE3	Protocol to discover subgroups; e.g., existing due to a network partition (that healed).
class	MFC	Simple flow control protocol based on a credit system.
class	MPING	Uses its own IP multicast socket to send and receive discovery requests/responses.
class	NAKACK3	Negative AcKnowledgement layer (NAKs).
class	NAKACK4	New multicast protocol based on fixed-size xmit windows and message ACKs Details: https://issues.redhat.com/browse/JGRP-2780
class	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
class	PDC	Persistent Discovery Cache.
class	PERF	Protocol measuring latency between stacks.
class	PING	The PING protocol retrieves the initial membership by mcasting a discovery request (via the multicast capable transport) to all current cluster members
class	RACKSPACE_PING	Discovery protocol based on Rackspace Cloud Files storage solution
class	RATE	Measures incoming and outgoing rates: messages/sec, bytes/sec.
class	RATE_LIMITER	Protocol which sends at most max_bytes in time_period milliseconds.
class	RATE_LIMITER2	Rate limiter based credits (max_bytes).
class	RED	Deprecated, for removal: This API element is subject to removal in a future version. Functionality replaced by PerDestinationBundler, see https://redhat.atlassian.net/browse/JGRP-3027
class	ReliableMulticast	Base class for reliable multicast protocols
class	ReliableUnicast	Base class for reliable unicast protocols
class	REVERSE	Reverses the next N messages that are received.
class	REVERSE2
class	RSVP	Protocol which implements synchronous messages (https://issues.redhat.com/browse/JGRP-1389).
class	SEQUENCER	Implementation of total order protocol using a sequencer.
class	SEQUENCER2	Implementation of total order protocol using a sequencer_uum.
class	SERIALIZE	Serializes the entire message (including payload, headers, flags and destination and src) into the payload of another message that's then sent.
class	SHARED_LOOPBACK	Loopback transport shared by all channels within the same VM.
class	SHARED_LOOPBACK_PING	Discovery protocol running over SHARED_LOOPBACK only.
class	SHUFFLE	Reorders messages by buffering them and shuffling the result after TIMEOUT ms.
class	SIZE	Protocol which lists how many messages have been received by size: https://issues.redhat.com/browse/JGRP-2893 Don't use this layer in a production stack since the costs are high; only use for debugging/diagnosis.
class	SIZE2	Records number of messages sent/received based on size
class	SNIFF	Protocol trying to print message payloads as strings
class	SOS	Periodically fetches some attributes and writes them to a file (https://issues.redhat.com/browse/JGRP-2402)
class	SSL_KEY_EXCHANGE	Key exchange based on SSL sockets.
class	STATS	Provides various stats
class	STOMP	Protocol which provides STOMP (https://stomp.github.io/) support.
class	SWIFT_PING	Discovery protocol based on Openstack Swift (object storage).
class	SYM_ENCRYPT	Encrypts and decrypts communication in JGroups by using a secret key shared by all cluster members.
class	TCP	TCP based protocol.
class	TCP_NIO2	Protocol using TCP/IP to send and receive messages.
class	TCPGOSSIP	The TCPGOSSIP protocol layer retrieves the initial membership (used by GMS when started by sending event FIND_INITIAL_MBRS down the stack).
class	TCPPING	The TCPPING protocol defines a static cluster membership.
class	THREAD_COUNT	Maintains averages of up- and down-threads
class	TIME	Protocol measuring delivery times.
class	TP	Generic transport - specific implementations should extend this class.
class	TPConfig	Base class for TP which captures fields and accessors.
class	TRACE
class	TUNNEL	Replacement for UDP.
class	UDP	IP multicast transport based on UDP.
class	UFC	Simple flow control protocol based on a credit system.
class	UNBATCH	Intercepts Protocol.up(MessageBatch) and passes up each message of a message batch as a single message.
class	UNBATCH_OOB	Unbatches OOB batches when enabled and virtual threads are available. https://issues.redhat.com/browse/JGRP-2888
class	UNICAST3	Reliable unicast protocol using a combination of positive and negative acks.
class	UNICAST4	New unicast protocol based on fixed-size xmit windows and message ACKs Details: https://issues.redhat.com/browse/JGRP-2843
class	VERIFY_SUSPECT	Catches SUSPECT events traveling up the stack.
class	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
class	VERSION	Maintains a version number and adds it to all outbound messages.

Uses of Lifecycle in org.jgroups.protocols.dns

Classes in org.jgroups.protocols.dns that implement Lifecycle

Modifier and Type	Class	Description
class	DNS_PING

Uses of Lifecycle in org.jgroups.protocols.pbcast

Classes in org.jgroups.protocols.pbcast that implement Lifecycle

Modifier and Type	Class	Description
class	GMS	Group membership protocol.
class	NAKACK2	Negative AcKnowledgement layer (NAKs).
class	STABLE	Computes the broadcast messages that are stable; i.e., have been delivered by all members.
class	STATE	STATE streams the state (written to an OutputStream) to the state requester in chunks (defined by chunk_size).
class	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.
class	STATE_TRANSFER	STATE_TRANSFER protocol based on byte array transfer.
class	StreamingStateTransfer	Base class for state transfer protocols which use streaming (or chunking) to transfer state between two members.

Uses of Lifecycle in org.jgroups.protocols.relay

Classes in org.jgroups.protocols.relay that implement Lifecycle

Modifier and Type	Class	Description
class	RELAY	Common superclass for RELAY2 and RELAY3
class	RELAY2	Design: ./doc/design/RELAY2.txt and at https://github.com/belaban/JGroups/blob/master/doc/design/RELAY2.txt.
class	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

Uses of Lifecycle in org.jgroups.stack

Subinterfaces of Lifecycle in org.jgroups.stack

Modifier and Type	Interface	Description
interface	MessageProcessingPolicy	Policy which decides how to process a received message or message batch.

Classes in org.jgroups.stack that implement Lifecycle

Modifier and Type	Class	Description
class	Protocol	The Protocol class provides a set of common services for protocol layers.
class	ProtocolStack	A ProtocolStack manages a number of protocols layered above each other.

Uses of Lifecycle in org.jgroups.util

Classes in org.jgroups.util that implement Lifecycle

Modifier and Type	Class	Description
class	AsyncExecutor<T>	Used to execute asynchronous tasks, e.g.
class	MaxOneThreadPerSender	MessageProcessingPolicy which processes regular messages and message batches by assigning a max of 1 thread per message from the same sender.
class	MockTransport	A dummy implementation of TP
class	PassAllMessagesUpDirectly	MessageProcessingPolicy which passes all messages and message batches up directly (on the same thread).
class	PassRegularMessagesUpDirectly	MessageProcessingPolicy which passes regular messages and message batches up directly (on the same thread), but passes OOB messages to the thread pool.
class	SubmitToThreadPool	Default message processing policy.
class	ThreadPool	Thread pool based on ThreadPoolExecutor
class	TLS	Component to configure TLS in protocols (TCP and TUNNEL).
class	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).