* Generic transport - specific implementations should extend this abstract class.

* Features which are provided to the subclasses include

* <ul>

* <li>version checking

* <li>marshalling and unmarshalling

* <li>message bundling (handling single messages, and message lists)

* <li>incoming packet handler

* <li>loopback

* </ul>

* A subclass has to override

* <ul>

* <li>{@link #sendMulticast(byte[], int, int)}

* <li>{@link #sendUnicast(org.jgroups.PhysicalAddress, byte[], int, int)}

* <li>{@link #init()}

* <li>{@link #start()}: subclasses <em>must</em> call super.start() <em>after</em> they initialize themselves

* (e.g., created their sockets).

* <li>{@link #stop()}: subclasses <em>must</em> call super.stop() after they deinitialized themselves

* <li>{@link #destroy()}

* </ul>

* The create() or start() method has to create a local address.<br>

* The {@link #receive(Address, byte[], int, int)} method must

* be called by subclasses when a unicast or multicast message has been received.

* @author Bela Ban

*/

        "use_concurrent_stack", "prevent_port_reuse", "persistent_ports", "pm_expiry_time", "persistent_ports_file",

        "start_port", "end_port", "use_local_host", "marshaller_pool_size", "num_timer_threads", "timer.num_threads"})

    protected static final byte LIST=1; // we have a list of messages rather than a single message when set

    protected static final byte MULTICAST=2; // message is a multicast (versus a unicast) message when set

    protected static final byte OOB=4; // message has OOB flag set (Message.OOB)

    protected static final boolean can_bind_to_mcast_addr; // are we running on Linux ?

    protected static NumberFormat f;

    static {

        can_bind_to_mcast_addr=Util.checkForLinux() || Util.checkForSolaris() || Util.checkForHp();

        f=NumberFormat.getNumberInstance();

        f.setGroupingUsed(false);

        f.setMaximumFractionDigits(2);

    }

    /* ------------------------------------------ JMX and Properties  ------------------------------------------ */

    @LocalAddress

    @Property(name="bind_addr",

              description="The bind address which should be used by this transport. The following special values " +

                      "are also recognized: GLOBAL, SITE_LOCAL, LINK_LOCAL and NON_LOOPBACK",

              defaultValueIPv4=Global.NON_LOOPBACK_ADDRESS, defaultValueIPv6=Global.NON_LOOPBACK_ADDRESS,

              systemProperty={Global.BIND_ADDR, Global.BIND_ADDR_OLD},writable=false)

    protected InetAddress bind_addr=null;

    @Property(name="bind_interface", converter=PropertyConverters.BindInterface.class,

        description="The interface (NIC) which should be used by this transport", dependsUpon="bind_addr",

            exposeAsManagedAttribute=false)

    protected String bind_interface_str=null;

   

    @Property(description="If true, the transport should use all available interfaces to receive multicast messages")

    protected boolean receive_on_all_interfaces=false;

    /**

     * List<NetworkInterface> 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.

     */

    @Property(converter=PropertyConverters.NetworkInterfaceList.class,

              description="Comma delimited list of interfaces (IP addresses or interface names) to receive multicasts on")

    protected List<NetworkInterface> receive_interfaces=null;

    @Property(description="Max number of elements in the logical address cache before eviction starts")

    protected int logical_addr_cache_max_size=200;

    @Property(description="Time (in ms) after which entries in the logical address cache marked as removable are removed")

    protected long logical_addr_cache_expiration=120000;

    /** The port to which the transport binds. 0 means to bind to any (ephemeral) port */

    @Property(description="The port to which the transport binds. Default of 0 binds to any (ephemeral) port",writable=false)

    protected int bind_port=0;

    @Property(description="The range of valid ports, from bind_port to end_port. Infinite if 0")

    protected int port_range=50; // 27-6-2003 bgooren, Only try one port by default

 

    /**

     * 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. Useful for

     * Window media (non)sense

     */

    @Property(description="Messages to self are looped back immediately if true")

    protected boolean loopback=true;

    /**

     * 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

     */

    @Property(description="Discard packets with a different version if true. Default is false")

    protected boolean discard_incompatible_packets=false;

    @Property(description="Thread naming pattern for threads in this channel. Default is cl")

    protected String thread_naming_pattern="cl";

    @Property(name="oob_thread_pool.enabled",description="Switch for enabling thread pool for OOB messages. " +

            "Default=true",writable=false)

    protected boolean oob_thread_pool_enabled=true;

    protected int oob_thread_pool_min_threads=2;

    protected int oob_thread_pool_max_threads=10;

    protected long oob_thread_pool_keep_alive_time=30000;

    @Property(name="oob_thread_pool.queue_enabled", description="Use queue to enqueue incoming OOB messages")

    protected boolean oob_thread_pool_queue_enabled=true;

    @Property(name="oob_thread_pool.queue_max_size",description="Maximum queue size for incoming OOB messages. Default is 500")

    protected int oob_thread_pool_queue_max_size=500;

    @Property(name="oob_thread_pool.rejection_policy",

              description="Thread rejection policy. Possible values are Abort, Discard, DiscardOldest and Run. Default is Discard")

    String oob_thread_pool_rejection_policy="discard";

    protected int thread_pool_min_threads=2;

    protected int thread_pool_max_threads=10;

    protected long thread_pool_keep_alive_time=30000;

    @Property(name="thread_pool.enabled",description="Switch for enabling thread pool for regular messages. Default true")

    protected boolean thread_pool_enabled=true;

    @Property(name="thread_pool.queue_enabled", description="Use queue to enqueue incoming regular messages. Default is true")

    protected boolean thread_pool_queue_enabled=true;

    @Property(name="thread_pool.queue_max_size", description="Maximum queue size for incoming OOB messages. Default is 500")

    protected int thread_pool_queue_max_size=500;

    @Property(name="thread_pool.rejection_policy",

              description="Thread rejection policy. Possible values are Abort, Discard, DiscardOldest and Run. Default is Discard")

    protected String thread_pool_rejection_policy="Discard";

    @Property(description="Type of timer to be used. Valid values are \"old\" (DefaultTimeScheduler, used up to 2.10), " +

            "\"new\" (TimeScheduler2) and \"wheel\". Note that this property might disappear " +

            "in future releases, if one of the 3 timers is chosen as default timer")

    protected String timer_type="new";

    protected int timer_min_threads=4;

    protected int timer_max_threads=10;

    protected long timer_keep_alive_time=5000;

    @Property(name="timer.queue_max_size", description="Max number of elements on a timer queue")

    protected int timer_queue_max_size=500;

    // hashed timing wheel specific props

    @Property(name="timer.wheel_size",

              description="Number of ticks in the HashedTimingWheel timer. Only applicable if timer_type is \"wheel\"")

    protected int wheel_size=200;

    @Property(name="timer.tick_time",

              description="Tick duration in the HashedTimingWheel timer. Only applicable if timer_type is \"wheel\"")

    protected long tick_time=50L;

    @Property(description="Enable bundling of smaller messages into bigger ones. Default is true")

    protected boolean enable_bundling=true;

    /** Enable bundling for unicast messages. Ignored if enable_bundling is off */

    @Property(description="Enable bundling of smaller messages into bigger ones for unicast messages. Default is false")

    protected boolean enable_unicast_bundling=false;

    @Property(description="Switch to enable diagnostic probing. Default is true")

    protected boolean enable_diagnostics=true;

    @Property(description="Address for diagnostic probing. Default is 224.0.75.75",

        defaultValueIPv4="224.0.75.75",defaultValueIPv6="ff0e::0:75:75")

    protected InetAddress diagnostics_addr=null;

    @Property(description="Port for diagnostic probing. Default is 7500")

    protected int diagnostics_port=7500;

    @Property(description="If assigned enable this transport to be a singleton (shared) transport")

    protected String singleton_name=null;

    /** Whether or not warnings about messages from different groups are logged - private flag, not for common use */

    @Property(description="whether or not warnings about messages from different groups are logged")

    protected boolean log_discard_msgs=true;

    /**

     * 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

     */

    protected int max_bundle_size=64000;

    /**

     * 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)

     */

    protected long max_bundle_timeout=20;

    @Property(description="The type of bundler used. Has to be \"old\" (default) or \"new\"")

    protected String bundler_type="new";

    @Experimental

    @Property(description="The max number of elements in a bundler if the bundler supports size limitations")

    protected int bundler_capacity=20000;

    @Property(name="max_bundle_size", description="Maximum number of bytes for messages to be queued until they are sent")

    public void setMaxBundleSize(int size) {

        if(size <= 0)

            throw new IllegalArgumentException("max_bundle_size (" + size + ") is <= 0");

        max_bundle_size=size;

    }

    public long getMaxBundleTimeout() {return max_bundle_timeout;}

   

    @Property(name="max_bundle_timeout", description="Max number of milliseconds until queued messages are sent")

    public void setMaxBundleTimeout(long timeout) {

        if(timeout <= 0) {

            throw new IllegalArgumentException("max_bundle_timeout of " + timeout + " is invalid");

        }

        max_bundle_timeout=timeout;

    }

    public int getMaxBundleSize() {return max_bundle_size;}

    @ManagedAttribute public int getBundlerBufferSize() {

        if(bundler instanceof TransferQueueBundler)

            return ((TransferQueueBundler)bundler).getBufferSize();

        return 0;

    }

    @Property(name="oob_thread_pool.keep_alive_time", description="Timeout in ms to remove idle threads from the OOB pool")

    public void setOOBThreadPoolKeepAliveTime(long time) {

        oob_thread_pool_keep_alive_time=time;

        if(oob_thread_pool instanceof ThreadPoolExecutor)

            ((ThreadPoolExecutor)oob_thread_pool).setKeepAliveTime(time, TimeUnit.MILLISECONDS);

    }

    public long getOOBThreadPoolKeepAliveTime() {return oob_thread_pool_keep_alive_time;}

    @Property(name="oob_thread_pool.min_threads",description="Minimum thread pool size for the OOB thread pool")

    public void setOOBThreadPoolMinThreads(int size) {

        oob_thread_pool_min_threads=size;

        if(oob_thread_pool instanceof ThreadPoolExecutor)

            ((ThreadPoolExecutor)oob_thread_pool).setCorePoolSize(size);

    }

    public int getOOBThreadPoolMinThreads() {return oob_thread_pool_min_threads;}

    @Property(name="oob_thread_pool.max_threads",description="Max thread pool size for the OOB thread pool")

    public void setOOBThreadPoolMaxThreads(int size) {

        oob_thread_pool_max_threads=size;

        if(oob_thread_pool instanceof ThreadPoolExecutor)

            ((ThreadPoolExecutor)oob_thread_pool).setMaximumPoolSize(size);

    }

    public int getOOBThreadPoolMaxThreads() {return oob_thread_pool_max_threads;}

    @Property(name="thread_pool.min_threads",description="Minimum thread pool size for the regular thread pool")

    public void setThreadPoolMinThreads(int size) {

        thread_pool_min_threads=size;

        if(thread_pool instanceof ThreadPoolExecutor)

            ((ThreadPoolExecutor)thread_pool).setCorePoolSize(size);

    }

    public int getThreadPoolMinThreads() {return thread_pool_min_threads;}

    @Property(name="thread_pool.max_threads",description="Maximum thread pool size for the regular thread pool")

    public void setThreadPoolMaxThreads(int size) {

        thread_pool_max_threads=size;

        if(thread_pool instanceof ThreadPoolExecutor)

            ((ThreadPoolExecutor)thread_pool).setMaximumPoolSize(size);

    }

    public int getThreadPoolMaxThreads() {return thread_pool_max_threads;}

    @Property(name="thread_pool.keep_alive_time",description="Timeout in milliseconds to remove idle thread from regular pool")

    public void setThreadPoolKeepAliveTime(long time) {

        thread_pool_keep_alive_time=time;

        if(thread_pool instanceof ThreadPoolExecutor)

            ((ThreadPoolExecutor)thread_pool).setKeepAliveTime(time, TimeUnit.MILLISECONDS);

    }

    public long getThreadPoolKeepAliveTime() {return thread_pool_keep_alive_time;}

    @Property(name="timer.min_threads",description="Minimum thread pool size for the timer thread pool")

    public void setTimerMinThreads(int size) {

        timer_min_threads=size;

        if(timer != null)

            timer.setMinThreads(size);

    }

    public int getTimerMinThreads() {return timer_min_threads;}

    @Property(name="timer.max_threads",description="Max thread pool size for the timer thread pool")

    public void setTimerMaxThreads(int size) {

        timer_max_threads=size;

        if(timer != null)

            timer.setMaxThreads(size);

    }

    public int getTimerMaxThreads() {return timer_max_threads;}

    @Property(name="timer.keep_alive_time", description="Timeout in ms to remove idle threads from the timer pool")

    public void setTimerKeepAliveTime(long time) {

        timer_keep_alive_time=time;

        if(timer != null)

            timer.setKeepAliveTime(time);

    }

    public long getTimerKeepAliveTime() {return timer_keep_alive_time;}

    @ManagedAttribute

    public int getTimerQueueSize() {

        if(timer instanceof TimeScheduler2)

            return ((TimeScheduler2)timer).getQueueSize();

        return 0;

    }

    /* --------------------------------------------- JMX  ---------------------------------------------- */

    @ManagedAttribute(description="Number of messages sent")

    protected long num_msgs_sent=0;

    @ManagedAttribute(description="Number of messages received")

    protected long num_msgs_received=0;

    @ManagedAttribute(description="Number of bytes sent")

    protected long num_bytes_sent=0;

    @ManagedAttribute(description="Number of bytes received")

    protected long num_bytes_received=0;

    /** 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 */

    @ManagedAttribute(description="Channel (cluster) name")

    protected String channel_name=null;

    @ManagedAttribute(description="Number of OOB messages received")

    protected long num_oob_msgs_received=0;

    @ManagedAttribute(description="Number of regular messages received")

    protected long num_incoming_msgs_received=0;

    @ManagedAttribute(description="Class of the timer implementation")

    public String getTimerClass() {

        return timer != null? timer.getClass().getSimpleName() : "null";

    }

    /* --------------------------------------------- Fields ------------------------------------------------------ */

    /** The address (host and port) of this member. Null by default when a shared transport is used */

    protected Address local_addr=null;

    /** 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 */

    protected final Set<Address> members=new CopyOnWriteArraySet<Address>();

    protected ThreadGroup pool_thread_group=new ThreadGroup(Util.getGlobalThreadGroup(), "Thread Pools");

    /** Keeps track of connects and disconnects, in order to start and stop threads */

    protected int connect_count=0;

    //http://jira.jboss.org/jira/browse/JGRP-849

    protected final ReentrantLock connectLock = new ReentrantLock();

   

    // ================================== OOB thread pool ========================

    protected Executor oob_thread_pool;

    /** Factory which is used by oob_thread_pool */

    protected ThreadFactory oob_thread_factory=null;

    /** Used if oob_thread_pool is a ThreadPoolExecutor and oob_thread_pool_queue_enabled is true */

    protected BlockingQueue<Runnable> oob_thread_pool_queue=null;

    // ================================== Regular thread pool ======================

    /** The thread pool which handles unmarshalling, version checks and dispatching of regular messages */

    protected Executor thread_pool;

    /** Factory which is used by oob_thread_pool */

    protected ThreadFactory default_thread_factory=null;

    /** Used if thread_pool is a ThreadPoolExecutor and thread_pool_queue_enabled is true */

    protected BlockingQueue<Runnable> thread_pool_queue=null;

    // ================================== Timer thread pool  =========================

    protected TimeScheduler timer=null;

    protected ThreadFactory timer_thread_factory;

    // ================================ Default thread factory ========================

    /** Used by all threads created by JGroups outside of the thread pools */

    protected ThreadFactory global_thread_factory=null;

    // ================================= Default SocketFactory ========================

    protected SocketFactory socket_factory=new DefaultSocketFactory();

    protected Bundler bundler=null;

    protected DiagnosticsHandler diag_handler=null;

    protected final List<ProbeHandler> preregistered_probe_handlers=new LinkedList<ProbeHandler>();

    /**

     * 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.

     */

    protected final ConcurrentMap<String,Protocol> up_prots=Util.createConcurrentMap(16, 0.75f, 16);

    /** 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 */

    protected TpHeader header;

    /**

     * 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

     * <br/>

     * The keys are logical addresses, the values physical addresses

     */

    protected LazyRemovalCache<Address,PhysicalAddress> logical_addr_cache=null;

    // last time we sent a discovery request

    protected long last_discovery_request=0;

    Future<?> logical_addr_cache_reaper=null;

    protected static final LazyRemovalCache.Printable<Address,PhysicalAddress> print_function=new LazyRemovalCache.Printable<Address,PhysicalAddress>() {

        public java.lang.String print(final Address logical_addr, final PhysicalAddress physical_addr) {

            StringBuilder sb=new StringBuilder();

            String tmp_logical_name=UUID.get(logical_addr);

            if(tmp_logical_name != null)

                sb.append(tmp_logical_name).append(": ");

            if(logical_addr instanceof UUID)

                sb.append(((UUID)logical_addr).toStringLong());

            else

                sb.append(logical_addr);

            sb.append(": ").append(physical_addr).append("\n");

            return sb.toString();

        }

    };

    /** Cache keeping track of WHO_HAS requests for physical addresses (given a logical address) and expiring

     * them after 5000ms */

    protected AgeOutCache<Address> who_has_cache=null;

    /**

     * Creates the TP protocol, and initializes the state variables, does

     * however not start any sockets or threads.

     */

    protected TP() {

    }

    /** Whether or not hardware multicasting is supported */

    public abstract boolean supportsMulticasting();

    public boolean isMulticastCapable() {return supportsMulticasting();}

    public String toString() {

        if(!isSingleton())

            return local_addr != null? name + "(local address: " + local_addr + ')' : name;

        else

            return name + " (singleton=" + singleton_name + ")";

    }

    public void resetStats() {

        num_msgs_sent=num_msgs_received=num_bytes_sent=num_bytes_received=0;

        num_oob_msgs_received=num_incoming_msgs_received=0;

    }

    public void registerProbeHandler(ProbeHandler handler) {

        if(diag_handler != null)

            diag_handler.registerProbeHandler(handler);

        else

            preregistered_probe_handlers.add(handler);

    }

    public void unregisterProbeHandler(ProbeHandler handler) {

        if(diag_handler != null)

            diag_handler.unregisterProbeHandler(handler);

    }

    public ThreadGroup getPoolThreadGroup() {

        return pool_thread_group;

    }

    public void setThreadPoolQueueEnabled(boolean flag) {thread_pool_queue_enabled=flag;}

    public Executor getDefaultThreadPool() {

        return thread_pool;

    }

    public void setDefaultThreadPool(Executor thread_pool) {

        if(this.thread_pool != null)

            shutdownThreadPool(this.thread_pool);

        this.thread_pool=thread_pool;

    }

    public ThreadFactory getDefaultThreadPoolThreadFactory() {

        return default_thread_factory;

    }

    public void setDefaultThreadPoolThreadFactory(ThreadFactory factory) {

        default_thread_factory=factory;

        if(thread_pool instanceof ThreadPoolExecutor)

            ((ThreadPoolExecutor)thread_pool).setThreadFactory(factory);

    }

    public Executor getOOBThreadPool() {

        return oob_thread_pool;

    }

    public void setOOBThreadPool(Executor oob_thread_pool) {

        if(this.oob_thread_pool != null) {

            shutdownThreadPool(this.oob_thread_pool);

        }

        this.oob_thread_pool=oob_thread_pool;

    }

    public ThreadFactory getOOBThreadPoolThreadFactory() {

        return oob_thread_factory;

    }

    public void setOOBThreadPoolThreadFactory(ThreadFactory factory) {

        oob_thread_factory=factory;

        if(oob_thread_pool instanceof ThreadPoolExecutor)

            ((ThreadPoolExecutor)oob_thread_pool).setThreadFactory(factory);

    }

    public ThreadFactory getTimerThreadFactory() {

        return timer_thread_factory;

    }

    public void setTimerThreadFactory(ThreadFactory factory) {

        timer_thread_factory=factory;

        timer.setThreadFactory(factory);

    }

    public TimeScheduler getTimer() {return timer;}

    public ThreadFactory getThreadFactory() {

        return global_thread_factory;

    }

    public void setThreadFactory(ThreadFactory factory) {

        global_thread_factory=factory;

    }

    public SocketFactory getSocketFactory() {

        return socket_factory;

    }

    public void setSocketFactory(SocketFactory factory) {

        if(factory != null)

            socket_factory=factory;

    }

    /**

     * 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"

     */

    public String getThreadNamingPattern() {return thread_naming_pattern;}

    public long getNumMessagesSent()     {return num_msgs_sent;}

    public long getNumMessagesReceived() {return num_msgs_received;}

    public long getNumBytesSent()        {return num_bytes_sent;}

    public long getNumBytesReceived()    {return num_bytes_received;}

    public String getBindAddress() {return bind_addr != null? bind_addr.toString() : "null";}

    public void setBindAddress(String bind_addr) throws UnknownHostException {

        this.bind_addr=InetAddress.getByName(bind_addr);

    }

    public InetAddress getBindAddressAsInetAddress() {return bind_addr;}

    public int getBindPort() {return bind_port;}

    public void setBindPort(int port) {this.bind_port=port;}

    /** @deprecated Use {@link #isReceiveOnAllInterfaces()} instead */

    public boolean getBindToAllInterfaces() {return receive_on_all_interfaces;}

    public void setBindToAllInterfaces(boolean flag) {this.receive_on_all_interfaces=flag;}

    public boolean isReceiveOnAllInterfaces() {return receive_on_all_interfaces;}

    public List<NetworkInterface> getReceiveInterfaces() {return receive_interfaces;}

    /** @deprecated This property was removed in 2.7*/

    public static boolean isSendOnAllInterfaces() {return false;}

    /** @deprecated This property was removed in 2.7*/

    public static List<NetworkInterface> getSendInterfaces() {return null;}

    public boolean isDiscardIncompatiblePackets() {return discard_incompatible_packets;}

    public void setDiscardIncompatiblePackets(boolean flag) {discard_incompatible_packets=flag;}

    public boolean isEnableBundling() {return enable_bundling;}

    public void setEnableBundling(boolean flag) {enable_bundling=flag;}

    public boolean isEnableUnicastBundling() {return enable_unicast_bundling;}

    public void setEnableUnicastBundling(boolean enable_unicast_bundling) {this.enable_unicast_bundling=enable_unicast_bundling;}

    public void setPortRange(int range) {this.port_range=range;}

    public int getPortRange() {return port_range ;}

    /** @deprecated the concurrent stack is used by default */

    @Deprecated

    public void setUseConcurrentStack(boolean flag) {}

    public boolean isOOBThreadPoolEnabled() { return oob_thread_pool_enabled; }

    public boolean isDefaulThreadPoolEnabled() { return thread_pool_enabled; }

    public boolean isLoopback() {return loopback;}

    public void setLoopback(boolean b) {loopback=b;}

    /** @deprecated With the concurrent stack being the default, this property is ignored */

    public static boolean isUseIncomingPacketHandler() {return false;}

    public ConcurrentMap<String,Protocol> getUpProtocols() {return up_prots;}

   

    @ManagedAttribute(description="Current number of threads in the OOB thread pool")

    public int getOOBPoolSize() {

        return oob_thread_pool instanceof ThreadPoolExecutor? ((ThreadPoolExecutor)oob_thread_pool).getPoolSize() : 0;

    }

    public long getOOBMessages() {

        return num_oob_msgs_received;

    }

    @ManagedAttribute(description="Number of messages in the OOB thread pool's queue")

    public int getOOBQueueSize() {

        return oob_thread_pool_queue != null? oob_thread_pool_queue.size() : 0;

    }

    public int getOOBMaxQueueSize() {

        return oob_thread_pool_queue_max_size;

    }

    public void setOOBRejectionPolicy(String rejection_policy) {

        RejectedExecutionHandler handler=parseRejectionPolicy(rejection_policy);

        if(oob_thread_pool instanceof ThreadPoolExecutor)

            ((ThreadPoolExecutor)oob_thread_pool).setRejectedExecutionHandler(new ShutdownRejectedExecutionHandler(handler));

    }

    @ManagedAttribute(description="Current number of threads in the default thread pool")

    public int getRegularPoolSize() {

        return thread_pool instanceof ThreadPoolExecutor? ((ThreadPoolExecutor)thread_pool).getPoolSize() : 0;

    }

    public long getRegularMessages() {

        return num_incoming_msgs_received;

    }

    @ManagedAttribute(description="Number of messages in the default thread pool's queue")

    public int getRegularQueueSize() {

        return thread_pool_queue != null? thread_pool_queue.size() : 0;

    }

    public int getRegularMaxQueueSize() {

        return thread_pool_queue_max_size;

    }

    @ManagedAttribute(name="TimerTasks",description="Number of timer tasks queued up for execution")

    public int getNumTimerTasks() {

        return timer != null? timer.size() : -1;

    }

    @ManagedOperation

    public String dumpTimerTasks() {

        return timer.dumpTimerTasks();

    }

    @ManagedAttribute(description="Number of threads currently in the pool")

    public int getTimerThreads() {

        return timer.getCurrentThreads();

    }

    public void setRegularRejectionPolicy(String rejection_policy) {

        RejectedExecutionHandler handler=parseRejectionPolicy(rejection_policy);

        if(thread_pool instanceof ThreadPoolExecutor)

            ((ThreadPoolExecutor)thread_pool).setRejectedExecutionHandler(new ShutdownRejectedExecutionHandler(handler));

    }

    public void setLogDiscardMessages(boolean flag) {

        log_discard_msgs=flag;

    }

    public boolean getLogDiscardMessages() {

        return log_discard_msgs;

    }

    @ManagedOperation(description="Dumps the contents of the logical address cache")

    public String printLogicalAddressCache() {

        return logical_addr_cache.printCache(print_function);

    }

    @ManagedOperation(description="Evicts elements in the logical address cache which have expired")

    public void evictLogicalAddressCache() {

        logical_addr_cache.removeMarkedElements();

        fetchLocalAddresses();

    }

    /**

     * Send to all members in the group. UDP would use an IP multicast message, whereas TCP would send N

     * messages, one for each member

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

     * @param offset

     * @param length

     * @throws Exception

     */

    public abstract void sendMulticast(byte[] data, int offset, int length) throws Exception;

    /**

     * Send a unicast to 1 member. Note that the destination address is a *physical*, not a logical address

     * @param dest Must be a non-null unicast address

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

     * @param offset

     * @param length

     * @throws Exception

     */

    public abstract void sendUnicast(PhysicalAddress dest, byte[] data, int offset, int length) throws Exception;

    public abstract String getInfo();

    /* ------------------------------------------------------------------------------- */

    /*------------------------------ Protocol interface ------------------------------ */

    public void init() throws Exception {

        super.init();

        // Create the default thread factory

        if(global_thread_factory == null)

            global_thread_factory=new DefaultThreadFactory(Util.getGlobalThreadGroup(), "", false);

        // Create the timer and the associated thread factory - depends on singleton_name

        if(timer_thread_factory == null)

            timer_thread_factory=new LazyThreadFactory(Util.getGlobalThreadGroup(), "Timer", true, true);

        if(isSingleton())

            timer_thread_factory.setIncludeClusterName(false);

        if(default_thread_factory == null)