TP

java.lang.Object
- org.jgroups.stack.Protocol
- - org.jgroups.protocols.TP

All Implemented Interfaces:

DiagnosticsHandler.ProbeHandler

Direct Known Subclasses:

BasicTCP, SHARED_LOOPBACK, TUNNEL, UDP
```
public abstract class TP
extends Protocol
implements DiagnosticsHandler.ProbeHandler
```
Generic transport - specific implementations should extend this abstract class. Features which are provided to the subclasses include
- version checking
- marshalling and unmarshalling
- message bundling (handling single messages, and message lists)
- incoming packet handler
A subclass has to override
- sendMulticast(org.jgroups.util.AsciiString, byte[], int, int)
- sendUnicast(org.jgroups.PhysicalAddress, byte[], int, int)
- init()
- start(): subclasses must call super.start() after they initialize themselves (e.g., created their sockets).
- stop(): subclasses must call super.stop() after they deinitialized themselves
- destroy()
The create() or start() method has to create a local address.
The receive(Address, byte[], int, int) method must be called by subclasses when a unicast or multicast message has been received.
Author:

Bela Ban

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected class`	`TP.BatchHandler`
`static class`	`TP.ProtocolAdapter` Used when the transport is shared (singleton_name != null).
`protected class`	`TP.SingleMessageHandler`
`protected class`	`TP.SingleMessageHandlerWithClusterName`

Field Summary

Fields
Modifier and Type	Field and Description
`protected Average`	`avg_batch_size`
`protected java.net.InetAddress`	`bind_addr`
`protected java.lang.String`	`bind_interface_str`
`protected int`	`bind_port` The port to which the transport binds.
`static java.lang.String`	`BUNDLE_MSG`
`protected Bundler`	`bundler`
`protected int`	`bundler_capacity`
`protected int`	`bundler_num_spins`
`protected java.lang.String`	`bundler_type`
`protected java.lang.String`	`bundler_wait_strategy`
`protected static boolean`	`can_bind_to_mcast_addr`
`protected AsciiString`	`cluster_name` The name of the group to which this member is connected.
`protected int`	`connect_count` Keeps track of connects and disconnects, in order to start and stop threads
`protected java.util.concurrent.locks.ReentrantLock`	`connectLock`
`protected ThreadFactory`	`default_thread_factory` Factory which is used by oob_thread_pool
`protected DiagnosticsHandler`	`diag_handler`
`protected java.net.InetAddress`	`diagnostics_addr`
`protected java.util.List<java.net.NetworkInterface>`	`diagnostics_bind_interfaces`
`protected java.lang.String`	`diagnostics_passcode`
`protected int`	`diagnostics_port`
`protected int`	`diagnostics_ttl`
`protected boolean`	`discard_incompatible_packets` Deprecated.
`protected boolean`	`enable_batching`
`protected boolean`	`enable_bundling` Deprecated.
`protected boolean`	`enable_diagnostics`
`protected boolean`	`enable_unicast_bundling` Deprecated.
`protected java.net.InetAddress`	`external_addr`
`protected int`	`external_port`
`protected static java.text.NumberFormat`	`f`
`protected ThreadFactory`	`global_thread_factory` Used by all threads created by JGroups outside of the thread pools
`protected TpHeader`	`header` The header including the cluster name, sent with each message.
`protected boolean`	`ignore_dont_bundle`
`protected ThreadFactory`	`internal_thread_factory` Factory which is used by internal_thread_pool
`protected java.util.concurrent.Executor`	`internal_thread_pool` The thread pool which handles JGroups internal messages (Flag.INTERNAL)
`protected boolean`	`internal_thread_pool_enabled` Deprecated.
`protected long`	`internal_thread_pool_keep_alive_time`
`protected int`	`internal_thread_pool_max_threads`
`protected int`	`internal_thread_pool_min_threads`
`protected java.util.concurrent.BlockingQueue<java.lang.Runnable>`	`internal_thread_pool_queue` Used if thread_pool is a ThreadPoolExecutor and thread_pool_queue_enabled is true
`protected boolean`	`internal_thread_pool_queue_enabled`
`protected int`	`internal_thread_pool_queue_max_size`
`protected java.lang.String`	`internal_thread_pool_rejection_policy`
`protected long`	`last_discovery_request`
`static byte`	`LIST`
`protected Address`	`local_addr` The address (host and port) of this member.
`protected PhysicalAddress`	`local_physical_addr`
`protected boolean`	`log_discard_msgs` Whether or not warnings about messages from different groups are logged - private flag, not for common use
`protected boolean`	`log_discard_msgs_version`
`protected LazyRemovalCache<Address,PhysicalAddress>`	`logical_addr_cache` Cache which maintains mappings between logical and physical addresses.
`protected long`	`logical_addr_cache_expiration`
`protected int`	`logical_addr_cache_max_size`
`protected long`	`logical_addr_cache_reaper_interval`
`protected boolean`	`loopback` Deprecated.
`protected boolean`	`loopback_copy`
`protected boolean`	`loopback_separate_thread`
`protected int`	`max_bundle_size` Maximum number of bytes for messages to be queued until they are sent.
`protected long`	`max_bundle_timeout` Deprecated.
`protected java.util.Set<Address>`	`members` The members of this group (updated when a member joins or leaves).
`protected static long`	`MIN_WAIT_BETWEEN_DISCOVERIES`
`static int`	`MSG_OVERHEAD`
`static byte`	`MULTICAST`
`protected int`	`no_bundler_initial_buf_size`
`protected int`	`no_bundler_pool_size`
`protected long`	`num_batches_received`
`protected long`	`num_batches_sent`
`protected long`	`num_bytes_received`
`protected long`	`num_bytes_sent`
`protected long`	`num_incoming_msgs_received`
`protected long`	`num_internal_msgs_received`
`protected long`	`num_msgs_received`
`protected long`	`num_msgs_sent`
`protected long`	`num_oob_msgs_received`
`protected int`	`num_rejected_msgs`
`protected long`	`num_single_msgs_received`
`protected long`	`num_single_msgs_sent`
`protected long`	`num_single_msgs_sent_instead_of_batch`
`protected ThreadFactory`	`oob_thread_factory` Factory which is used by oob_thread_pool
`protected java.util.concurrent.Executor`	`oob_thread_pool`
`protected boolean`	`oob_thread_pool_enabled` Deprecated.
`protected long`	`oob_thread_pool_keep_alive_time`
`protected int`	`oob_thread_pool_max_threads`
`protected int`	`oob_thread_pool_min_threads`
`protected java.util.concurrent.BlockingQueue<java.lang.Runnable>`	`oob_thread_pool_queue` Used if oob_thread_pool is a ThreadPoolExecutor and oob_thread_pool_queue_enabled is true
`protected boolean`	`oob_thread_pool_queue_enabled`
`protected int`	`oob_thread_pool_queue_max_size`
`protected java.lang.String`	`oob_thread_pool_rejection_policy`
`protected int`	`physical_addr_max_fetch_attempts`
`protected int`	`port_range`
`protected java.util.List<DiagnosticsHandler.ProbeHandler>`	`preregistered_probe_handlers`
`protected static LazyRemovalCache.Printable<Address,LazyRemovalCache.Entry<PhysicalAddress>>`	`print_function`
`protected java.util.List<java.net.NetworkInterface>`	`receive_interfaces` List of interfaces to receive multicasts on.
`protected boolean`	`receive_on_all_interfaces`
`protected java.lang.String`	`singleton_name` Deprecated.
`protected SocketFactory`	`socket_factory`
`protected SuppressLog<Address>`	`suppress_log_different_cluster` Log to suppress identical warnings for messages from members in different clusters
`protected SuppressLog<Address>`	`suppress_log_different_version` Log to suppress identical warnings for messages from members with different (incompatible) versions
`protected long`	`suppress_time_different_cluster_warnings`
`protected long`	`suppress_time_different_version_warnings`
`protected java.lang.String`	`thread_naming_pattern`
`protected java.util.concurrent.Executor`	`thread_pool` The thread pool which handles unmarshalling, version checks and dispatching of regular messages
`protected boolean`	`thread_pool_enabled` Deprecated.
`protected long`	`thread_pool_keep_alive_time`
`protected int`	`thread_pool_max_threads`
`protected int`	`thread_pool_min_threads`
`protected java.util.concurrent.BlockingQueue<java.lang.Runnable>`	`thread_pool_queue` Used if thread_pool is a ThreadPoolExecutor and thread_pool_queue_enabled is true
`protected boolean`	`thread_pool_queue_enabled`
`protected int`	`thread_pool_queue_max_size`
`protected java.lang.String`	`thread_pool_rejection_policy`
`protected long`	`tick_time`
`protected TimeService`	`time_service`
`protected long`	`time_service_interval`
`protected TimeScheduler`	`timer`
`protected long`	`timer_keep_alive_time`
`protected int`	`timer_max_threads`
`protected int`	`timer_min_threads`
`protected int`	`timer_queue_max_size`
`protected java.lang.String`	`timer_rejection_policy`
`protected ThreadFactory`	`timer_thread_factory`
`protected java.lang.String`	`timer_type`
`protected java.util.concurrent.ConcurrentMap<AsciiString,Protocol>`	`up_prots` If singleton_name is enabled, this map is used to de-multiplex incoming messages according to their cluster names (attached to the message by the transport anyway).
`protected View`	`view`
`protected int`	`wheel_size`
`protected ExpiryCache<Address>`	`who_has_cache` Cache keeping track of WHO_HAS requests for physical addresses (given a logical address) and expiring them after who_has_cache_timeout ms
`protected long`	`who_has_cache_timeout`

Fields inherited from class org.jgroups.stack.Protocol
after_creation_hook, down_prot, ergonomics, id, log, name, stack, stats, up_prot

Constructor Summary

Constructors
Modifier Constructor and Description

protected TP()
Creates the TP protocol, and initializes the state variables, does however not start any sockets or threads.

Constructors
Modifier	Constructor and Description
`protected`	`TP()` Creates the TP protocol, and initializes the state variables, does however not start any sockets or threads.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`protected void`	`_send(Message msg, Address dest)`
`protected boolean`	`addPhysicalAddressToCache(Address logical_addr, PhysicalAddress physical_addr)`
`protected static int`	`assertPositive(int value, java.lang.String message)`
`void`	`bundler(java.lang.String type)`
`int`	`bundlerNumSpins()`
`void`	`bundlerNumSpins(int spins)`
`java.lang.String`	`bundlerWaitStrategy()`
`void`	`bundlerWaitStrategy(java.lang.String strategy)`
`void`	`clearDifferentClusterCache()`
`void`	`clearDifferentVersionCache()`
`void`	`clearLogicalAddressCache()` Clears the cache.
`protected Bundler`	`createBundler(java.lang.String type)`
`protected static java.util.concurrent.ExecutorService`	`createThreadPool(int min_threads, int max_threads, long keep_alive_time, java.lang.String rejection_policy, java.util.concurrent.BlockingQueue<java.lang.Runnable> queue, ThreadFactory factory)`
`void`	`destroy()` This method is called on a `Channel.close()`.
`void`	`disableDiagnostics()`
`protected void`	`doSend(AsciiString cluster_name, byte[] buf, int offset, int length, Address dest)`
`java.lang.Object`	`down(Event evt)` Caller by the layer above this layer.
`java.lang.String`	`dumpTimerTasks()`
`void`	`enableDiagnostics()`
`void`	`evictLogicalAddressCache()`
`void`	`evictLogicalAddressCache(boolean force)`
`protected void`	`fetchLocalAddresses()` Grabs the local address (or addresses in the shared transport case) and registers them with the physical address in the transport's cache
`protected void`	`fetchPhysicalAddrs(java.util.List<Address> missing)`
`protected Responses`	`fetchResponsesFromDiscoveryProtocol(java.util.List<Address> missing)`
`protected java.util.Collection<PhysicalAddress>`	`getAllPhysicalAddressesFromCache()`
`double`	`getAvgBatchSize()`
`java.net.InetAddress`	`getBindAddress()`
`int`	`getBindPort()`
`Bundler`	`getBundler()`
`int`	`getBundlerBufferSize()`
`int`	`getBundlerCapacity()`
`java.lang.String`	`getBundlerClass()`
`java.lang.String`	`getClusterName()`
`protected AsciiString`	`getClusterName(Message msg)`
`AsciiString`	`getClusterNameAscii()`
`java.util.concurrent.Executor`	`getDefaultThreadPool()`
`ThreadFactory`	`getDefaultThreadPoolThreadFactory()`
`int`	`getDifferentClusterMessages()`
`int`	`getDifferentVersionMessages()`
`abstract java.lang.String`	`getInfo()`
`int`	`getInternalMaxQueueSize()`
`long`	`getInternalMessages()`
`int`	`getInternalPoolSize()`
`int`	`getInternalPoolSizeActive()`
`int`	`getInternalQueueSize()`
`java.util.concurrent.Executor`	`getInternalThreadPool()`
`ThreadFactory`	`getInternalThreadPoolThreadFactory()`
`java.lang.String`	`getLocalAddress()`
`java.lang.String`	`getLocalPhysicalAddress()`
`boolean`	`getLogDiscardMessages()`
`boolean`	`getLogDiscardMessagesVersion()`
`int`	`getMaxBundleSize()`
`long`	`getMaxBundleTimeout()`
`long`	`getNumBytesReceived()`
`long`	`getNumBytesSent()`
`long`	`getNumMessagesReceived()`
`long`	`getNumMessagesSent()`
`static int`	`getNumThreads()`
`int`	`getNumTimerTasks()`
`int`	`getOOBMaxQueueSize()`
`long`	`getOOBMessages()`
`int`	`getOOBPoolSize()`
`int`	`getOOBPoolSizeActive()`
`int`	`getOOBQueueSize()`
`java.util.concurrent.Executor`	`getOOBThreadPool()`
`long`	`getOOBThreadPoolKeepAliveTime()`
`int`	`getOOBThreadPoolMaxThreads()`
`int`	`getOOBThreadPoolMinThreads()`
`ThreadFactory`	`getOOBThreadPoolThreadFactory()`
`protected abstract PhysicalAddress`	`getPhysicalAddress()`
`protected PhysicalAddress`	`getPhysicalAddressFromCache(Address logical_addr)`
`int`	`getPortRange()`
`java.util.List<java.net.NetworkInterface>`	`getReceiveInterfaces()`
`int`	`getRegularMaxQueueSize()`
`long`	`getRegularMessages()`
`int`	`getRegularPoolSize()`
`int`	`getRegularPoolSizeActive()`
`int`	`getRegularQueueSize()`
`java.lang.String`	`getSingletonName()`
`SocketFactory`	`getSocketFactory()` Returns the SocketFactory associated with this protocol, if overridden in a subclass, or passes the call down
`ThreadFactory`	`getThreadFactory()` Supposed to be overwritten by subclasses.
`java.lang.String`	`getThreadNamingPattern()` Names the current thread.
`long`	`getThreadPoolKeepAliveTime()`
`int`	`getThreadPoolMaxThreads()`
`int`	`getThreadPoolMinThreads()`
`TimeScheduler`	`getTimer()`
`java.lang.String`	`getTimerClass()`
`long`	`getTimerKeepAliveTime()`
`int`	`getTimerMaxThreads()`
`int`	`getTimerMinThreads()`
`int`	`getTimerQueueSize()`
`ThreadFactory`	`getTimerThreadFactory()`
`int`	`getTimerThreads()`
`TimeService`	`getTimeService()`
`java.util.concurrent.ConcurrentMap<AsciiString,Protocol>`	`getUpProtocols()`
`protected void`	`handleConnect()`
`protected void`	`handleDisconnect()`
`protected java.lang.Object`	`handleDownEvent(Event evt)`
`protected void`	`handleMessageBatch(Address sender, byte[] data, int offset, int length)`
`java.util.Map<java.lang.String,java.lang.String>`	`handleProbe(java.lang.String... keys)` Handles a probe.
`protected void`	`handleSingleMessage(Address sender, byte[] data, int offset, int length)`
`void`	`incrBatchesSent()`
`void`	`incrBatchesSent(int delta)`
`void`	`incrSingleMsgsInsteadOfBatches()`
`void`	`init()` Called after instance has been created (null constructor) and before protocol is started.
`boolean`	`isDefaulThreadPoolEnabled()`
`boolean`	`isDiagnosticsHandlerRunning()`
`static boolean`	`isDiscardIncompatiblePackets()` Deprecated.
`static boolean`	`isEnableBundling()` Deprecated.
`static boolean`	`isEnableUnicastBundling()` Deprecated.
`boolean`	`isLogicalAddressCacheReaperRunning()`
`boolean`	`isLoopback()` Deprecated.
`boolean`	`isMulticastCapable()`
`boolean`	`isOOBThreadPoolEnabled()`
`boolean`	`isReceiveOnAllInterfaces()`
`boolean`	`isSingleton()`
`Address`	`localAddress()`
`static java.lang.String`	`loggerType()`
`protected void`	`loopback(Message msg, boolean multicast)`
`protected void`	`passBatchUp(MessageBatch batch, boolean perform_cluster_name_matching, boolean discard_own_mcast)`
`protected void`	`passMessageUp(Message msg, AsciiString cluster_name, boolean perform_cluster_name_matching, boolean multicast, boolean discard_own_mcast)`
`protected void`	`passToAllUpProtocols(Event evt)`
`protected java.util.concurrent.Executor`	`pickThreadPool(boolean oob, boolean internal)`
`java.lang.String`	`printLogicalAddressCache()`
`java.lang.String`	`printWhoHasCache()`
`static Message`	`readMessage(java.io.DataInput instream)`
`static MessageBatch[]`	`readMessageBatch(java.io.DataInput in, boolean multicast)` Reads a list of messages into 4 MessageBatches: regular OOB INTERNAL-OOB (INTERNAL and OOB) INTERNAL (INTERNAL)
`static java.util.List<Message>`	`readMessageList(java.io.DataInput in, short transport_id)`
`void`	`receive(Address sender, byte[] data, int offset, int length)` Subclasses must call this method when a unicast or multicast message has been received.
`protected void`	`registerLocalAddress(Address addr)` Associates the address with the physical address fetched from the cache
`void`	`registerProbeHandler(DiagnosticsHandler.ProbeHandler handler)`
`protected void`	`removeAndDispatchNonBundledMessages(MessageBatch... oob_batches)` Removes messages with flags DONT_BUNDLE and OOB set and executes them in the oob or internal thread pool.
`protected void`	`removeLogicalAddressFromCache(Address logical_addr)`
`void`	`resetStats()`
`protected void`	`send(Message msg, Address dest)` Serializes and sends a message.
`abstract void`	`sendMulticast(AsciiString cluster_name, byte[] data, int offset, int length)` Send to all members in the group.
`protected void`	`sendToMembers(java.util.Collection<Address> mbrs, byte[] buf, int offset, int length)` Fetches the physical addrs for mbrs and sends the msg to each physical address.
`protected void`	`sendToSingleMember(Address dest, byte[] buf, int offset, int length)`
`abstract void`	`sendUnicast(PhysicalAddress dest, byte[] data, int offset, int length)` Send a unicast to 1 member.
`TP`	`setBindAddress(java.net.InetAddress bind_addr)`
`void`	`setBindPort(int port)`
`void`	`setBindToAllInterfaces(boolean flag)`
`void`	`setBundler(Bundler bundler)` Installs a bundler.
`void`	`setDefaultThreadPool(java.util.concurrent.Executor thread_pool)`
`void`	`setDefaultThreadPoolThreadFactory(ThreadFactory factory)`
`void`	`setDiagnosticsHandler(DiagnosticsHandler handler)` Sets a `DiagnosticsHandler`.
`static void`	`setDiscardIncompatiblePackets(boolean flag)` Deprecated.
`void`	`setEnableBundling(boolean flag)` Deprecated.
`void`	`setEnableUnicastBundling(boolean enable_unicast_bundling)` Deprecated.
`protected void`	`setInAllThreadFactories(java.lang.String cluster_name, Address local_address, java.lang.String pattern)`
`void`	`setInternalThreadPool(java.util.concurrent.Executor internal_thread_pool)`
`void`	`setInternalThreadPoolThreadFactory(ThreadFactory factory)`
`void`	`setLogDiscardMessages(boolean flag)`
`void`	`setLogDiscardMessagesVersion(boolean flag)`
`void`	`setLoopback(boolean b)` Deprecated.
`void`	`setMaxBundleSize(int size)`
`void`	`setMaxBundleTimeout(long timeout)`
`void`	`setOOBRejectionPolicy(java.lang.String rejection_policy)`
`void`	`setOOBThreadPool(java.util.concurrent.Executor oob_thread_pool)`
`void`	`setOOBThreadPoolKeepAliveTime(long time)`
`void`	`setOOBThreadPoolMaxThreads(int size)`
`void`	`setOOBThreadPoolMinThreads(int size)`
`void`	`setOOBThreadPoolQueueEnabled(boolean flag)`
`void`	`setOOBThreadPoolThreadFactory(ThreadFactory factory)`
`protected void`	`setPingData(PingData data)`
`void`	`setPortRange(int range)`
`void`	`setRegularRejectionPolicy(java.lang.String rejection_policy)`
`void`	`setSocketFactory(SocketFactory factory)` Sets a SocketFactory.
`protected void`	`setSourceAddress(Message msg)` If the sender is null, set our own address.
`void`	`setThreadFactory(ThreadFactory factory)`
`protected void`	`setThreadNames()`
`void`	`setThreadPoolKeepAliveTime(long time)`
`void`	`setThreadPoolMaxThreads(int size)`
`void`	`setThreadPoolMinThreads(int size)`
`void`	`setThreadPoolQueueEnabled(boolean flag)`
`void`	`setTimer(TimeScheduler timer)` Sets a new timer.
`void`	`setTimerKeepAliveTime(long time)`
`void`	`setTimerMaxThreads(int size)`
`void`	`setTimerMinThreads(int size)`
`void`	`setTimerThreadFactory(ThreadFactory factory)`
`void`	`setTimeService(TimeService ts)`
`protected static void`	`shutdownThreadPool(java.util.concurrent.Executor thread_pool)`
`void`	`start()` Creates the unicast and multicast sockets and starts the unicast and multicast receiver threads
`protected void`	`startDiagnostics()`
`void`	`stop()` This method is called on a `Channel.disconnect()`.
`protected void`	`stopDiagnostics()`
`java.lang.String[]`	`supportedKeys()` Returns a list of supported keys
`abstract boolean`	`supportsMulticasting()` Whether or not hardware multicasting is supported
`java.lang.String`	`toString()`
`void`	`unregisterProbeHandler(DiagnosticsHandler.ProbeHandler handler)`
`protected void`	`unsetThreadNames()`
`java.lang.Object`	`up(Event evt)` handle the UP event.
`protected boolean`	`versionMatch(short version, Address sender)`
`View`	`view()`
`protected static void`	`writeMessage(Message msg, java.io.DataOutput dos, boolean multicast)` This method needs to be synchronized on out_stream when it is called
`static void`	`writeMessageList(Address dest, Address src, byte[] cluster_name, java.util.List<Message> msgs, java.io.DataOutput dos, boolean multicast, short transport_id)` Write a list of messages with the same destination and src addresses.
`static void`	`writeMessageListHeader(Address dest, Address src, byte[] cluster_name, int numMsgs, java.io.DataOutput dos, boolean multicast)`

Methods inherited from class org.jgroups.stack.Protocol
accept, afterCreationHook, dumpStats, enableStats, getConfigurableObjects, getDownProtocol, getDownServices, getId, getIdsAbove, getLevel, getLog, getName, getProtocolStack, getTransport, getUpProtocol, getUpServices, getValue, isErgonomics, level, parse, printStats, providedDownServices, providedUpServices, requiredDownServices, requiredUpServices, resetStatistics, setDownProtocol, setErgonomics, setId, setLevel, setProtocolStack, setUpProtocol, setValue, setValues, statsEnabled, up

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail
- LIST
```
public static final byte LIST
```
  See Also:
  
  Constant Field Values
- MULTICAST
```
public static final byte MULTICAST
```
  See Also:
  
  Constant Field Values
- MSG_OVERHEAD
```
public static final int MSG_OVERHEAD
```
  See Also:
  
  Constant Field Values
- BUNDLE_MSG
```
public static final java.lang.String BUNDLE_MSG
```
  See Also:
  
  Constant Field Values
- MIN_WAIT_BETWEEN_DISCOVERIES
```
protected static final long MIN_WAIT_BETWEEN_DISCOVERIES
```
- can_bind_to_mcast_addr
```
protected static final boolean can_bind_to_mcast_addr
```
- f
```
protected static java.text.NumberFormat f
```
- bind_addr
```
protected java.net.InetAddress bind_addr
```
- external_addr
```
protected java.net.InetAddress external_addr
```
- external_port
```
protected int external_port
```
- bind_interface_str
```
protected java.lang.String bind_interface_str
```
- receive_on_all_interfaces
```
protected boolean receive_on_all_interfaces
```
- receive_interfaces
```
protected java.util.List<java.net.NetworkInterface> receive_interfaces
```
  List of interfaces to receive multicasts on. The multicast receive socket will listen on all of these interfaces. This is a comma-separated list of IP addresses or interface names. E.g. "192.168.5.1,eth1,127.0.0.1". Duplicates are discarded; we only bind to an interface once. If this property is set, it overrides receive_on_all_interfaces.
- logical_addr_cache_max_size
```
protected int logical_addr_cache_max_size
```
- logical_addr_cache_expiration
```
protected long logical_addr_cache_expiration
```
- logical_addr_cache_reaper_interval
```
protected long logical_addr_cache_reaper_interval
```
- bind_port
```
protected int bind_port
```
  The port to which the transport binds. 0 means to bind to any (ephemeral) port. See also port_range
- port_range
```
protected int port_range
```
- loopback
```
@Deprecated
protected boolean loopback
```
  Deprecated.
  
  If true, messages sent to self are treated specially: unicast messages are looped back immediately, multicast messages get a local copy first and - when the real copy arrives - it will be discarded
- loopback_copy
```
protected boolean loopback_copy
```
- loopback_separate_thread
```
protected boolean loopback_separate_thread
```
- discard_incompatible_packets
```
@Deprecated
protected boolean discard_incompatible_packets
```
  Deprecated.
  
  Discard packets with a different version. Usually minor version differences are okay. Setting this property to true means that we expect the exact same version on all incoming packets
- thread_naming_pattern
```
protected java.lang.String thread_naming_pattern
```
- oob_thread_pool_enabled
```
@Deprecated
protected boolean oob_thread_pool_enabled
```
  Deprecated.
- oob_thread_pool_min_threads
```
protected int oob_thread_pool_min_threads
```
- oob_thread_pool_max_threads
```
protected int oob_thread_pool_max_threads
```
- oob_thread_pool_keep_alive_time
```
protected long oob_thread_pool_keep_alive_time
```
- oob_thread_pool_queue_enabled
```
protected boolean oob_thread_pool_queue_enabled
```
- oob_thread_pool_queue_max_size
```
protected int oob_thread_pool_queue_max_size
```
- oob_thread_pool_rejection_policy
```
protected java.lang.String oob_thread_pool_rejection_policy
```
- thread_pool_min_threads
```
protected int thread_pool_min_threads
```
- thread_pool_max_threads
```
protected int thread_pool_max_threads
```
- thread_pool_keep_alive_time
```
protected long thread_pool_keep_alive_time
```
- thread_pool_enabled
```
@Deprecated
protected boolean thread_pool_enabled
```
  Deprecated.
- thread_pool_queue_enabled
```
protected boolean thread_pool_queue_enabled
```
- thread_pool_queue_max_size
```
protected int thread_pool_queue_max_size
```
- thread_pool_rejection_policy
```
protected java.lang.String thread_pool_rejection_policy
```
- internal_thread_pool_enabled
```
@Deprecated
protected boolean internal_thread_pool_enabled
```
  Deprecated.
- internal_thread_pool_min_threads
```
protected int internal_thread_pool_min_threads
```
- internal_thread_pool_max_threads
```
protected int internal_thread_pool_max_threads
```
- internal_thread_pool_keep_alive_time
```
protected long internal_thread_pool_keep_alive_time
```
- internal_thread_pool_queue_enabled
```
protected boolean internal_thread_pool_queue_enabled
```
- internal_thread_pool_queue_max_size
```
protected int internal_thread_pool_queue_max_size
```
- internal_thread_pool_rejection_policy
```
protected java.lang.String internal_thread_pool_rejection_policy
```
- timer_type
```
protected java.lang.String timer_type
```
- timer_min_threads
```
protected int timer_min_threads
```
- timer_max_threads
```
protected int timer_max_threads
```
- timer_keep_alive_time
```
protected long timer_keep_alive_time
```
- timer_queue_max_size
```
protected int timer_queue_max_size
```
- timer_rejection_policy
```
protected java.lang.String timer_rejection_policy
```
- wheel_size
```
protected int wheel_size
```
- tick_time
```
protected long tick_time
```
- time_service_interval
```
protected long time_service_interval
```
- enable_bundling
```
@Deprecated
protected boolean enable_bundling
```
  Deprecated.
- enable_unicast_bundling
```
@Deprecated
protected boolean enable_unicast_bundling
```
  Deprecated.
  
  Enable bundling for unicast messages. Ignored if enable_bundling is off
- enable_batching
```
protected boolean enable_batching
```
- ignore_dont_bundle
```
protected boolean ignore_dont_bundle
```
- enable_diagnostics
```
protected boolean enable_diagnostics
```
- diagnostics_addr
```
protected java.net.InetAddress diagnostics_addr
```
- diagnostics_bind_interfaces
```
protected java.util.List<java.net.NetworkInterface> diagnostics_bind_interfaces
```
- diagnostics_port
```
protected int diagnostics_port
```
- diagnostics_ttl
```
protected int diagnostics_ttl
```
- diagnostics_passcode
```
protected java.lang.String diagnostics_passcode
```
- singleton_name
```
@Deprecated
protected java.lang.String singleton_name
```
  Deprecated.
- log_discard_msgs
```
protected boolean log_discard_msgs
```
  Whether or not warnings about messages from different groups are logged - private flag, not for common use
- log_discard_msgs_version
```
protected boolean log_discard_msgs_version
```
- who_has_cache_timeout
```
protected long who_has_cache_timeout
```
- physical_addr_max_fetch_attempts
```
protected int physical_addr_max_fetch_attempts
```
- suppress_time_different_version_warnings
```
protected long suppress_time_different_version_warnings
```
- suppress_time_different_cluster_warnings
```
protected long suppress_time_different_cluster_warnings
```
- max_bundle_size
```
protected int max_bundle_size
```
  Maximum number of bytes for messages to be queued until they are sent. This value needs to be smaller than the largest datagram packet size in case of UDP
- max_bundle_timeout
```
@Deprecated
protected long max_bundle_timeout
```
  Deprecated.
  
  Max number of milliseconds until queued messages are sent. Messages are sent when max_bundle_size or max_bundle_timeout has been exceeded (whichever occurs faster)
- bundler_type
```
protected java.lang.String bundler_type
```
- bundler_capacity
```
protected int bundler_capacity
```
- no_bundler_pool_size
```
protected int no_bundler_pool_size
```
- no_bundler_initial_buf_size
```
protected int no_bundler_initial_buf_size
```
- bundler_num_spins
```
protected int bundler_num_spins
```
- bundler_wait_strategy
```
protected java.lang.String bundler_wait_strategy
```
- num_msgs_sent
```
protected long num_msgs_sent
```
- num_msgs_received
```
protected long num_msgs_received
```
- num_single_msgs_received
```
protected long num_single_msgs_received
```
- num_single_msgs_sent
```
protected long num_single_msgs_sent
```
- num_single_msgs_sent_instead_of_batch
```
protected long num_single_msgs_sent_instead_of_batch
```
- num_batches_received
```
protected long num_batches_received
```
- num_batches_sent
```
protected long num_batches_sent
```
- num_bytes_sent
```
protected long num_bytes_sent
```
- num_bytes_received
```
protected long num_bytes_received
```
- num_rejected_msgs
```
protected int num_rejected_msgs
```
- cluster_name
```
protected AsciiString cluster_name
```
  The name of the group to which this member is connected. With a shared transport, the channel name is in TP.ProtocolAdapter (cluster_name), and this field is not used
- num_oob_msgs_received
```
protected long num_oob_msgs_received
```
- num_incoming_msgs_received
```
protected long num_incoming_msgs_received
```
- num_internal_msgs_received
```
protected long num_internal_msgs_received
```
- local_addr
```
protected Address local_addr
```
  The address (host and port) of this member. Null by default when a shared transport is used
- local_physical_addr
```
protected PhysicalAddress local_physical_addr
```
- view
```
protected volatile View view
```
- members
```
protected final java.util.Set<Address> members
```
  The members of this group (updated when a member joins or leaves). With a shared transport, members contains *all* members from all channels sitting on the shared transport
- connect_count
```
protected int connect_count
```
  Keeps track of connects and disconnects, in order to start and stop threads
- connectLock
```
protected final java.util.concurrent.locks.ReentrantLock connectLock
```
- oob_thread_pool
```
protected java.util.concurrent.Executor oob_thread_pool
```
- oob_thread_factory
```
protected ThreadFactory oob_thread_factory
```
  Factory which is used by oob_thread_pool
- oob_thread_pool_queue
```
protected java.util.concurrent.BlockingQueue<java.lang.Runnable> oob_thread_pool_queue
```
  Used if oob_thread_pool is a ThreadPoolExecutor and oob_thread_pool_queue_enabled is true
- thread_pool
```
protected java.util.concurrent.Executor thread_pool
```
  The thread pool which handles unmarshalling, version checks and dispatching of regular messages
- default_thread_factory
```
protected ThreadFactory default_thread_factory
```
  Factory which is used by oob_thread_pool
- thread_pool_queue
```
protected java.util.concurrent.BlockingQueue<java.lang.Runnable> thread_pool_queue
```
  Used if thread_pool is a ThreadPoolExecutor and thread_pool_queue_enabled is true
- internal_thread_pool
```
protected java.util.concurrent.Executor internal_thread_pool
```
  The thread pool which handles JGroups internal messages (Flag.INTERNAL)
- internal_thread_factory
```
protected ThreadFactory internal_thread_factory
```
  Factory which is used by internal_thread_pool
- internal_thread_pool_queue
```
protected java.util.concurrent.BlockingQueue<java.lang.Runnable> internal_thread_pool_queue
```
  Used if thread_pool is a ThreadPoolExecutor and thread_pool_queue_enabled is true
- timer
```
protected TimeScheduler timer
```
- timer_thread_factory
```
protected ThreadFactory timer_thread_factory
```
- time_service
```
protected TimeService time_service
```
- global_thread_factory
```
protected ThreadFactory global_thread_factory
```
  Used by all threads created by JGroups outside of the thread pools
- socket_factory
```
protected SocketFactory socket_factory
```
- bundler
```
protected volatile Bundler bundler
```
- diag_handler
```
protected DiagnosticsHandler diag_handler
```
- preregistered_probe_handlers
```
protected final java.util.List<DiagnosticsHandler.ProbeHandler> preregistered_probe_handlers
```
- up_prots
```
protected final java.util.concurrent.ConcurrentMap<AsciiString,Protocol> up_prots
```
  If singleton_name is enabled, this map is used to de-multiplex incoming messages according to their cluster names (attached to the message by the transport anyway). The values are the next protocols above the transports.
- header
```
protected TpHeader header
```
  The header including the cluster name, sent with each message. Not used with a shared transport (instead TP.ProtocolAdapter attaches the header to the message
- logical_addr_cache
```
protected LazyRemovalCache<Address,PhysicalAddress> logical_addr_cache
```
  Cache which maintains mappings between logical and physical addresses. When sending a message to a logical address, we look up the physical address from logical_addr_cache and send the message to the physical address
  The keys are logical addresses, the values physical addresses
- last_discovery_request
```
protected long last_discovery_request
```
- avg_batch_size
```
protected final Average avg_batch_size
```
- print_function
```
protected static final LazyRemovalCache.Printable<Address,LazyRemovalCache.Entry<PhysicalAddress>> print_function
```
- who_has_cache
```
protected ExpiryCache<Address> who_has_cache
```
  Cache keeping track of WHO_HAS requests for physical addresses (given a logical address) and expiring them after who_has_cache_timeout ms
- suppress_log_different_version
```
protected SuppressLog<Address> suppress_log_different_version
```
  Log to suppress identical warnings for messages from members with different (incompatible) versions
- suppress_log_different_cluster
```
protected SuppressLog<Address> suppress_log_different_cluster
```
  Log to suppress identical warnings for messages from members in different clusters

Constructor Detail
- TP
```
protected TP()
```
  Creates the TP protocol, and initializes the state variables, does however not start any sockets or threads.

Method Detail

getBundlerClass

public java.lang.String getBundlerClass()

setMaxBundleSize

public void setMaxBundleSize(int size)

getMaxBundleTimeout
```
public long getMaxBundleTimeout()
```

setMaxBundleTimeout

public void setMaxBundleTimeout(long timeout)

getMaxBundleSize
```
public int getMaxBundleSize()
```

getBundlerCapacity
```
public int getBundlerCapacity()
```

getBundlerBufferSize
```
public int getBundlerBufferSize()
```

bundlerWaitStrategy

public java.lang.String bundlerWaitStrategy()

bundlerWaitStrategy

public void bundlerWaitStrategy(java.lang.String strategy)

bundlerNumSpins
```
public int bundlerNumSpins()
```

bundlerNumSpins

public void bundlerNumSpins(int spins)

isLogicalAddressCacheReaperRunning

public boolean isLogicalAddressCacheReaperRunning()

getAvgBatchSize
```
public double getAvgBatchSize()
```

setOOBThreadPoolKeepAliveTime

public void setOOBThreadPoolKeepAliveTime(long time)

getOOBThreadPoolKeepAliveTime

public long getOOBThreadPoolKeepAliveTime()

setOOBThreadPoolMinThreads

public void setOOBThreadPoolMinThreads(int size)

getOOBThreadPoolMinThreads

public int getOOBThreadPoolMinThreads()

setOOBThreadPoolMaxThreads

public void setOOBThreadPoolMaxThreads(int size)

getOOBThreadPoolMaxThreads

public int getOOBThreadPoolMaxThreads()

setOOBThreadPoolQueueEnabled

public void setOOBThreadPoolQueueEnabled(boolean flag)

setThreadPoolMinThreads

public void setThreadPoolMinThreads(int size)

getThreadPoolMinThreads
```
public int getThreadPoolMinThreads()
```

setThreadPoolMaxThreads

public void setThreadPoolMaxThreads(int size)

getThreadPoolMaxThreads
```
public int getThreadPoolMaxThreads()
```

setThreadPoolKeepAliveTime

public void setThreadPoolKeepAliveTime(long time)

getThreadPoolKeepAliveTime

public long getThreadPoolKeepAliveTime()

setTimerMinThreads

public void setTimerMinThreads(int size)

getTimerMinThreads
```
public int getTimerMinThreads()
```

setTimerMaxThreads

public void setTimerMaxThreads(int size)

getTimerMaxThreads
```
public int getTimerMaxThreads()
```

setTimerKeepAliveTime

public void setTimerKeepAliveTime(long time)

getTimerKeepAliveTime
```
public long getTimerKeepAliveTime()
```

getTimerQueueSize
```
public int getTimerQueueSize()
```

getTimerClass

public java.lang.String getTimerClass()

getClusterName

public java.lang.String getClusterName()

getClusterNameAscii

public AsciiString getClusterNameAscii()

getDifferentClusterMessages

public int getDifferentClusterMessages()

getDifferentVersionMessages

public int getDifferentVersionMessages()

clearDifferentClusterCache

public void clearDifferentClusterCache()

clearDifferentVersionCache

public void clearDifferentVersionCache()

loggerType

public static java.lang.String loggerType()

supportsMulticasting
```
public abstract boolean supportsMulticasting()
```
Whether or not hardware multicasting is supported

isMulticastCapable
```
public boolean isMulticastCapable()
```

toString
```
public java.lang.String toString()
```
Overrides:

toString in class java.lang.Object

getLocalAddress

public java.lang.String getLocalAddress()

localAddress
```
public Address localAddress()
```

view
```
public View view()
```

getLocalPhysicalAddress

public java.lang.String getLocalPhysicalAddress()

resetStats
```
public void resetStats()
```
Overrides:

resetStats in class Protocol

registerProbeHandler

public void registerProbeHandler(DiagnosticsHandler.ProbeHandler handler)

unregisterProbeHandler

public void unregisterProbeHandler(DiagnosticsHandler.ProbeHandler handler)

setDiagnosticsHandler
```
public void setDiagnosticsHandler(DiagnosticsHandler handler)
```
Sets a DiagnosticsHandler. Should be set before the stack is started

Parameters:

handler -

getBundler
```
public Bundler getBundler()
```

setBundler
```
public void setBundler(Bundler bundler)
```
Installs a bundler. Needs to be done before the channel is connected

setThreadPoolQueueEnabled

public void setThreadPoolQueueEnabled(boolean flag)

getDefaultThreadPool

public java.util.concurrent.Executor getDefaultThreadPool()

setDefaultThreadPool

public void setDefaultThreadPool(java.util.concurrent.Executor thread_pool)

getDefaultThreadPoolThreadFactory

public ThreadFactory getDefaultThreadPoolThreadFactory()

setDefaultThreadPoolThreadFactory

public void setDefaultThreadPoolThreadFactory(ThreadFactory factory)

getOOBThreadPool

public java.util.concurrent.Executor getOOBThreadPool()

setOOBThreadPool

public void setOOBThreadPool(java.util.concurrent.Executor oob_thread_pool)

getOOBThreadPoolThreadFactory

public ThreadFactory getOOBThreadPoolThreadFactory()

setOOBThreadPoolThreadFactory

public void setOOBThreadPoolThreadFactory(ThreadFactory factory)

getInternalThreadPool

public java.util.concurrent.Executor getInternalThreadPool()

setInternalThreadPool

public void setInternalThreadPool(java.util.concurrent.Executor internal_thread_pool)

getInternalThreadPoolThreadFactory

public ThreadFactory getInternalThreadPoolThreadFactory()

setInternalThreadPoolThreadFactory

public void setInternalThreadPoolThreadFactory(ThreadFactory factory)

getTimerThreadFactory

public ThreadFactory getTimerThreadFactory()

setTimerThreadFactory

public void setTimerThreadFactory(ThreadFactory factory)

getTimer
```
public TimeScheduler getTimer()
```

setTimer
```
public void setTimer(TimeScheduler timer)
```
Sets a new timer. This should be done before the transport is initialized; be very careful, as replacing a running timer with tasks in it can wreak havoc !

Parameters:

timer -

getTimeService
```
public TimeService getTimeService()
```

setTimeService

public void setTimeService(TimeService ts)

getThreadFactory
```
public ThreadFactory getThreadFactory()
```
Description copied from class: Protocol

Supposed to be overwritten by subclasses. Usually the transport returns a valid non-null thread factory, but thread factories can also be created by individual protocols

Overrides:

getThreadFactory in class Protocol

Returns:

setThreadFactory

public void setThreadFactory(ThreadFactory factory)

getSocketFactory
```
public SocketFactory getSocketFactory()
```
Description copied from class: Protocol

Returns the SocketFactory associated with this protocol, if overridden in a subclass, or passes the call down

Overrides:

getSocketFactory in class Protocol

Returns:

SocketFactory

setSocketFactory
```
public void setSocketFactory(SocketFactory factory)
```
Description copied from class: Protocol

Sets a SocketFactory. Socket factories are typically provided by the transport (TP) or TP.ProtocolAdapter

Overrides:

setSocketFactory in class Protocol

getThreadNamingPattern
```
public java.lang.String getThreadNamingPattern()
```
Names the current thread. Valid values are "pcl": p: include the previous (original) name, e.g. "Incoming thread-1", "UDP ucast receiver" c: include the cluster name, e.g. "MyCluster" l: include the local address of the current member, e.g. "192.168.5.1:5678"

getNumMessagesSent
```
public long getNumMessagesSent()
```

getNumMessagesReceived
```
public long getNumMessagesReceived()
```

getNumBytesSent
```
public long getNumBytesSent()
```

getNumBytesReceived
```
public long getNumBytesReceived()
```

incrBatchesSent
```
public void incrBatchesSent()
```

incrBatchesSent

public void incrBatchesSent(int delta)

incrSingleMsgsInsteadOfBatches

public void incrSingleMsgsInsteadOfBatches()

getBindAddress

public java.net.InetAddress getBindAddress()

setBindAddress

public TP setBindAddress(java.net.InetAddress bind_addr)

getBindPort
```
public int getBindPort()
```

setBindPort
```
public void setBindPort(int port)
```

setBindToAllInterfaces

public void setBindToAllInterfaces(boolean flag)

isReceiveOnAllInterfaces

public boolean isReceiveOnAllInterfaces()

getReceiveInterfaces

public java.util.List<java.net.NetworkInterface> getReceiveInterfaces()

isDiscardIncompatiblePackets

@Deprecated
public static boolean isDiscardIncompatiblePackets()

Deprecated.

setDiscardIncompatiblePackets

@Deprecated
public static void setDiscardIncompatiblePackets(boolean flag)

Deprecated.

isEnableBundling

@Deprecated
public static boolean isEnableBundling()

Deprecated.

setEnableBundling

@Deprecated
public void setEnableBundling(boolean flag)

Deprecated.

isEnableUnicastBundling

@Deprecated
public static boolean isEnableUnicastBundling()

Deprecated.

setEnableUnicastBundling

@Deprecated
public void setEnableUnicastBundling(boolean enable_unicast_bundling)

Deprecated.

setPortRange
```
public void setPortRange(int range)
```

getPortRange
```
public int getPortRange()
```

isOOBThreadPoolEnabled

public boolean isOOBThreadPoolEnabled()

isDefaulThreadPoolEnabled

public boolean isDefaulThreadPoolEnabled()

isLoopback

@Deprecated
public boolean isLoopback()

Deprecated.

setLoopback

@Deprecated
public void setLoopback(boolean b)

Deprecated.

getUpProtocols

public java.util.concurrent.ConcurrentMap<AsciiString,Protocol> getUpProtocols()

getOOBPoolSize
```
public int getOOBPoolSize()
```

getOOBPoolSizeActive
```
public int getOOBPoolSizeActive()
```

getOOBMessages
```
public long getOOBMessages()
```

getOOBQueueSize
```
public int getOOBQueueSize()
```

getOOBMaxQueueSize
```
public int getOOBMaxQueueSize()
```

setOOBRejectionPolicy

public void setOOBRejectionPolicy(java.lang.String rejection_policy)

getRegularPoolSize
```
public int getRegularPoolSize()
```

getRegularPoolSizeActive
```
public int getRegularPoolSizeActive()
```

getRegularMessages
```
public long getRegularMessages()
```

getRegularQueueSize
```
public int getRegularQueueSize()
```

getRegularMaxQueueSize
```
public int getRegularMaxQueueSize()
```

getInternalPoolSize
```
public int getInternalPoolSize()
```

getInternalPoolSizeActive

public int getInternalPoolSizeActive()

getInternalMessages
```
public long getInternalMessages()
```

getInternalQueueSize
```
public int getInternalQueueSize()
```

getInternalMaxQueueSize
```
public int getInternalMaxQueueSize()
```

getNumTimerTasks
```
public int getNumTimerTasks()
```

dumpTimerTasks

public java.lang.String dumpTimerTasks()

getTimerThreads
```
public int getTimerThreads()
```

getNumThreads
```
public static int getNumThreads()
```

isDiagnosticsHandlerRunning

public boolean isDiagnosticsHandlerRunning()

setRegularRejectionPolicy

public void setRegularRejectionPolicy(java.lang.String rejection_policy)

setLogDiscardMessages

public void setLogDiscardMessages(boolean flag)

getLogDiscardMessages

public boolean getLogDiscardMessages()

setLogDiscardMessagesVersion

public void setLogDiscardMessagesVersion(boolean flag)

getLogDiscardMessagesVersion

public boolean getLogDiscardMessagesVersion()

printLogicalAddressCache

public java.lang.String printLogicalAddressCache()

printWhoHasCache

public java.lang.String printWhoHasCache()

evictLogicalAddressCache

public void evictLogicalAddressCache()

evictLogicalAddressCache

public void evictLogicalAddressCache(boolean force)

sendMulticast
```
public abstract void sendMulticast(AsciiString cluster_name,
                                   byte[] data,
                                   int offset,
                                   int length)
                            throws java.lang.Exception
```
Send to all members in the group. UDP would use an IP multicast message, whereas TCP would send N messages, one for each member

Parameters:

cluster_name - The name of the cluster. Null if not a shared transport

data - The data to be sent. This is not a copy, so don't modify it

offset -

length -

Throws:

java.lang.Exception

sendUnicast
```
public abstract void sendUnicast(PhysicalAddress dest,
                                 byte[] data,
                                 int offset,
                                 int length)
                          throws java.lang.Exception
```
Send a unicast to 1 member. Note that the destination address is a *physical*, not a logical address

Parameters:

dest - Must be a non-null unicast address

data - The data to be sent. This is not a copy, so don't modify it

offset -

length -

Throws:

java.lang.Exception

getInfo

public abstract java.lang.String getInfo()

init
```
public void init()
          throws java.lang.Exception
```
Description copied from class: Protocol

Called after instance has been created (null constructor) and before protocol is started. Properties are already set. Other protocols are not yet connected and events cannot yet be sent.

Overrides:

init in class Protocol

Throws:

java.lang.Exception - Thrown if protocol cannot be initialized successfully. This will cause the ProtocolStack to fail, so the channel constructor will throw an exception

destroy
```
public void destroy()
```
Description copied from class: Protocol

This method is called on a Channel.close(). Does some cleanup; after the call the VM will terminate

Overrides:

destroy in class Protocol

start
```
public void start()
           throws java.lang.Exception
```
Creates the unicast and multicast sockets and starts the unicast and multicast receiver threads

Overrides:

start in class Protocol

Throws:

java.lang.Exception - Thrown if protocol cannot be started successfully. This will cause the ProtocolStack to fail, so Channel.connect(String) will throw an exception

bundler

public void bundler(java.lang.String type)

stop
```
public void stop()
```
Description copied from class: Protocol

This method is called on a Channel.disconnect(). Stops work (e.g. by closing multicast socket). Will be called from top to bottom. This means that at the time of the method invocation the neighbor protocol below is still working. This method will replace the STOP, STOP_OK, CLEANUP and CLEANUP_OK events. The ProtocolStack guarantees that when this method is called all messages in the down queue will have been flushed

Overrides:

stop in class Protocol

enableDiagnostics
```
public void enableDiagnostics()
```

disableDiagnostics
```
public void disableDiagnostics()
```

startDiagnostics

protected void startDiagnostics()
                         throws java.lang.Exception

Throws:: java.lang.Exception

stopDiagnostics
```
protected void stopDiagnostics()
```

handleProbe
```
public java.util.Map<java.lang.String,java.lang.String> handleProbe(java.lang.String... keys)
```
Description copied from interface: DiagnosticsHandler.ProbeHandler

Handles a probe. For each key that is handled, the key and its result should be in the returned map.

Specified by:

handleProbe in interface DiagnosticsHandler.ProbeHandler

Returns:

Map. A map of keys and values. A null return value is permissible.

supportedKeys
```
public java.lang.String[] supportedKeys()
```
Description copied from interface: DiagnosticsHandler.ProbeHandler

Returns a list of supported keys

Specified by:

supportedKeys in interface DiagnosticsHandler.ProbeHandler

handleConnect

protected void handleConnect()
                      throws java.lang.Exception

Throws:: java.lang.Exception

handleDisconnect
```
protected void handleDisconnect()
```

getSingletonName

public java.lang.String getSingletonName()

isSingleton
```
public boolean isSingleton()
```

up
```
public java.lang.Object up(Event evt)
```
handle the UP event.

Overrides:

up in class Protocol

Parameters:

evt - - the event being send from the stack

down
```
public java.lang.Object down(Event evt)
```
Caller by the layer above this layer. Usually we just put this Message into the send queue and let one or more worker threads handle it. A worker thread then removes the Message from the send queue, performs a conversion and adds the modified Message to the send queue of the layer below it, by calling down()).

Overrides:

down in class Protocol

createBundler

protected Bundler createBundler(java.lang.String type)

loopback

protected void loopback(Message msg,
                        boolean multicast)

_send

protected void _send(Message msg,
                     Address dest)

setSourceAddress
```
protected void setSourceAddress(Message msg)
```
If the sender is null, set our own address. We cannot just go ahead and set the address anyway, as we might be sending a message on behalf of someone else ! E.g. in case of retransmission, when the original sender has crashed, or in a FLUSH protocol when we have to return all unstable messages with the FLUSH_OK response.

passMessageUp

protected void passMessageUp(Message msg,
                             AsciiString cluster_name,
                             boolean perform_cluster_name_matching,
                             boolean multicast,
                             boolean discard_own_mcast)

passBatchUp

protected void passBatchUp(MessageBatch batch,
                           boolean perform_cluster_name_matching,
                           boolean discard_own_mcast)

receive

public void receive(Address sender,
                    byte[] data,
                    int offset,
                    int length)

Subclasses must call this method when a unicast or multicast message has been received.

handleMessageBatch

protected void handleMessageBatch(Address sender,
                                  byte[] data,
                                  int offset,
                                  int length)

handleSingleMessage

protected void handleSingleMessage(Address sender,
                                   byte[] data,
                                   int offset,
                                   int length)

removeAndDispatchNonBundledMessages
```
protected void removeAndDispatchNonBundledMessages(MessageBatch... oob_batches)
```
Removes messages with flags DONT_BUNDLE and OOB set and executes them in the oob or internal thread pool. JGRP-1737

pickThreadPool

protected java.util.concurrent.Executor pickThreadPool(boolean oob,
                                                       boolean internal)

versionMatch

protected boolean versionMatch(short version,
                               Address sender)

send

protected void send(Message msg,
                    Address dest)
             throws java.lang.Exception

Serializes and sends a message. This method is not reentrant

Throws:: java.lang.Exception

doSend

protected void doSend(AsciiString cluster_name,
                      byte[] buf,
                      int offset,
                      int length,
                      Address dest)
               throws java.lang.Exception

Throws:: java.lang.Exception

sendToSingleMember

protected void sendToSingleMember(Address dest,
                                  byte[] buf,
                                  int offset,
                                  int length)
                           throws java.lang.Exception

Throws:: java.lang.Exception

sendToMembers

protected void sendToMembers(java.util.Collection<Address> mbrs,
                             byte[] buf,
                             int offset,
                             int length)
                      throws java.lang.Exception

Fetches the physical addrs for mbrs and sends the msg to each physical address. Asks discovery for missing members' physical addresses if needed

Throws:: java.lang.Exception

fetchPhysicalAddrs

protected void fetchPhysicalAddrs(java.util.List<Address> missing)

fetchResponsesFromDiscoveryProtocol

protected Responses fetchResponsesFromDiscoveryProtocol(java.util.List<Address> missing)

getClusterName

protected AsciiString getClusterName(Message msg)

setPingData

protected void setPingData(PingData data)

writeMessage

protected static void writeMessage(Message msg,
                                   java.io.DataOutput dos,
                                   boolean multicast)
                            throws java.lang.Exception

This method needs to be synchronized on out_stream when it is called

Parameters:: msg -
Throws:: java.io.IOException; java.lang.Exception

readMessage

public static Message readMessage(java.io.DataInput instream)
                           throws java.lang.Exception

Throws:: java.lang.Exception

writeMessageList

public static void writeMessageList(Address dest,
                                    Address src,
                                    byte[] cluster_name,
                                    java.util.List<Message> msgs,
                                    java.io.DataOutput dos,
                                    boolean multicast,
                                    short transport_id)
                             throws java.lang.Exception

Write a list of messages with the *same* destination and src addresses. The message list is marshalled as follows (see doc/design/MarshallingFormat.txt for details):

 List: * | version | flags | dest | src | cluster-name | [Message*] |

 Message:  | presence | leading | flags | [src] | length | [buffer] | size | [Headers*] |

Parameters:: dest -; src -; msgs -; dos -; multicast -
Throws:: java.lang.Exception

writeMessageListHeader

public static void writeMessageListHeader(Address dest,
                                          Address src,
                                          byte[] cluster_name,
                                          int numMsgs,
                                          java.io.DataOutput dos,
                                          boolean multicast)
                                   throws java.lang.Exception

Throws:: java.lang.Exception

readMessageList

public static java.util.List<Message> readMessageList(java.io.DataInput in,
                                                      short transport_id)
                                               throws java.lang.Exception

Throws:: java.lang.Exception

readMessageBatch
```
public static MessageBatch[] readMessageBatch(java.io.DataInput in,
                                              boolean multicast)
                                       throws java.lang.Exception
```
Reads a list of messages into 4 MessageBatches:
1. regular
2. OOB
3. INTERNAL-OOB (INTERNAL and OOB)
4. INTERNAL (INTERNAL)
Parameters:

in -

Returns:

an array of 4 MessageBatches in the order above, the first batch is at index 0

Throws:

java.lang.Exception

handleDownEvent

protected java.lang.Object handleDownEvent(Event evt)

registerLocalAddress
```
protected void registerLocalAddress(Address addr)
```
Associates the address with the physical address fetched from the cache

Parameters:

addr -

fetchLocalAddresses
```
protected void fetchLocalAddresses()
```
Grabs the local address (or addresses in the shared transport case) and registers them with the physical address in the transport's cache

setThreadNames
```
protected void setThreadNames()
```

unsetThreadNames
```
protected void unsetThreadNames()
```

setInAllThreadFactories

protected void setInAllThreadFactories(java.lang.String cluster_name,
                                       Address local_address,
                                       java.lang.String pattern)

createThreadPool

protected static java.util.concurrent.ExecutorService createThreadPool(int min_threads,
                                                                       int max_threads,
                                                                       long keep_alive_time,
                                                                       java.lang.String rejection_policy,
                                                                       java.util.concurrent.BlockingQueue<java.lang.Runnable> queue,
                                                                       ThreadFactory factory)

shutdownThreadPool

protected static void shutdownThreadPool(java.util.concurrent.Executor thread_pool)

passToAllUpProtocols

protected void passToAllUpProtocols(Event evt)

addPhysicalAddressToCache

protected boolean addPhysicalAddressToCache(Address logical_addr,
                                            PhysicalAddress physical_addr)

getPhysicalAddressFromCache

protected PhysicalAddress getPhysicalAddressFromCache(Address logical_addr)

getAllPhysicalAddressesFromCache

protected java.util.Collection<PhysicalAddress> getAllPhysicalAddressesFromCache()

removeLogicalAddressFromCache

protected void removeLogicalAddressFromCache(Address logical_addr)

clearLogicalAddressCache
```
public void clearLogicalAddressCache()
```
Clears the cache. Do not use, this is only for unit testing !

getPhysicalAddress

protected abstract PhysicalAddress getPhysicalAddress()

assertPositive

protected static int assertPositive(int value,
                                    java.lang.String message)

Class TP

Nested Class Summary

Field Summary

Fields inherited from class org.jgroups.stack.Protocol

Constructor Summary

Method Summary

Methods inherited from class org.jgroups.stack.Protocol

Methods inherited from class java.lang.Object

Field Detail

LIST

MULTICAST

MSG_OVERHEAD

BUNDLE_MSG

MIN_WAIT_BETWEEN_DISCOVERIES

can_bind_to_mcast_addr

f

bind_addr

external_addr

external_port

bind_interface_str

receive_on_all_interfaces

receive_interfaces

logical_addr_cache_max_size

logical_addr_cache_expiration

logical_addr_cache_reaper_interval

bind_port

port_range

loopback

loopback_copy

loopback_separate_thread

discard_incompatible_packets

thread_naming_pattern

oob_thread_pool_enabled

oob_thread_pool_min_threads

oob_thread_pool_max_threads

oob_thread_pool_keep_alive_time

oob_thread_pool_queue_enabled

oob_thread_pool_queue_max_size

oob_thread_pool_rejection_policy

thread_pool_min_threads

thread_pool_max_threads

thread_pool_keep_alive_time

thread_pool_enabled

thread_pool_queue_enabled

thread_pool_queue_max_size

thread_pool_rejection_policy

internal_thread_pool_enabled

internal_thread_pool_min_threads

internal_thread_pool_max_threads

internal_thread_pool_keep_alive_time

internal_thread_pool_queue_enabled

internal_thread_pool_queue_max_size

internal_thread_pool_rejection_policy

timer_type

timer_min_threads

timer_max_threads

timer_keep_alive_time

timer_queue_max_size

timer_rejection_policy

wheel_size

tick_time

time_service_interval

enable_bundling

enable_unicast_bundling

enable_batching

ignore_dont_bundle

enable_diagnostics

diagnostics_addr

diagnostics_bind_interfaces

diagnostics_port

diagnostics_ttl

diagnostics_passcode

singleton_name

log_discard_msgs

log_discard_msgs_version

who_has_cache_timeout

physical_addr_max_fetch_attempts

suppress_time_different_version_warnings

suppress_time_different_cluster_warnings

max_bundle_size