org.jgroups.protocols

## Class SCOPE

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

-     public class SCOPE
      extends Protocol

  Implements https://jira.jboss.org/jira/browse/JGRP-822, which allows for concurrent delivery of messages from the same sender based on scopes. Similar to using OOB messages, but messages within the same scope are ordered.
  Since:
    2.10
  Author:
    Bela Ban

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `protected class` | `SCOPE.ExpiryTask`
    `protected static class` | `SCOPE.MessageQueue`
    `protected class` | `SCOPE.QueueThread`
    `static class` | `SCOPE.ScopeHeader`

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected java.lang.String` | `cluster_name`
    `protected long` | `expiration_interval`
    `protected long` | `expiration_time`
    `protected java.util.concurrent.Future<?>` | `expiry_task`
    `protected Address` | `local_addr`
    `protected java.util.concurrent.ConcurrentMap<Address,java.util.concurrent.ConcurrentMap<java.lang.Short,SCOPE.MessageQueue>>` | `queues` Used to find the correct AckReceiverWindow on message reception and deliver it in the right order
    `protected ThreadFactory` | `thread_factory`
    `protected java.lang.ThreadGroup` | `thread_group`
    `protected java.lang.String` | `thread_naming_pattern`
    `protected java.util.concurrent.Executor` | `thread_pool`
    `protected long` | `thread_pool_keep_alive_time`
    `protected int` | `thread_pool_max_threads`
    `protected int` | `thread_pool_min_threads`
    `protected TimeScheduler` | `timer`

    - ### Fields inherited from class org.jgroups.stack.Protocol

      `down_prot, ergonomics, id, log, name, stack, stats, up_prot`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `SCOPE()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `clearQueue(Address member)`
    `protected static java.util.concurrent.ExecutorService` | `createThreadPool(int min_threads, int max_threads, long keep_alive_time, ThreadFactory factory)`
    `java.lang.Object` | `down(Event evt)` An event is to be sent down the stack.
    `java.lang.String` | `dumpScopes()`
    `void` | `expire(short scope)` Multicasts an EXPIRE message to all members, and - on reception - each member removes the scope locally
    `int` | `getNumActiveThreads()`
    `int` | `getNumberOfMessages()`
    `int` | `getNumberOfReceiverScopes()`
    `protected SCOPE.MessageQueue` | `getOrCreateQueue(Address sender, short scope)`
    `long` | `getThreadPoolKeepAliveTime()`
    `int` | `getThreadPoolMaxThreads()`
    `int` | `getThreadPoolMinThreads()`
    `void` | `init()` Called after instance has been created (null constructor) and before protocol is started.
    `void` | `removeAllQueues()`
    `void` | `removeScope(Address member, short scope)`
    `void` | `setThreadPoolKeepAliveTime(long time)`
    `void` | `setThreadPoolMaxThreads(int size)`
    `void` | `setThreadPoolMinThreads(int size)`
    `protected static void` | `shutdownThreadPool(java.util.concurrent.Executor thread_pool)`
    `void` | `start()` This method is called on a `Channel.connect(String)`.
    `protected void` | `startExpiryTask()`
    `void` | `stop()` This method is called on a `Channel.disconnect()`.
    `protected void` | `stopExpiryTask()`
    `java.lang.Object` | `up(Event evt)` An event was received from the layer below.

    - ### Methods inherited from class org.jgroups.stack.Protocol

      `destroy, downThreadEnabled, dumpStats, enableStats, getConfigurableObjects, getDownProtocol, getId, getLevel, getName, getProperties, getProtocolStack, getSocketFactory, getThreadFactory, getTransport, getUpProtocol, getValue, isErgonomics, printStats, providedDownServices, providedUpServices, requiredDownServices, requiredUpServices, resetStats, setDownProtocol, setErgonomics, setId, setLevel, setProperties, setPropertiesInternal, setProperty, setProtocolStack, setSocketFactory, setUpProtocol, setValue, setValues, statsEnabled, upThreadEnabled`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### 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_naming_pattern

          protected java.lang.String thread_naming_pattern

    - #### expiration_time

          protected long expiration_time

    - #### expiration_interval

          protected long expiration_interval

    - #### expiry_task

          protected java.util.concurrent.Future<?> expiry_task

    - #### queues

          protected final java.util.concurrent.ConcurrentMap<Address,java.util.concurrent.ConcurrentMap<java.lang.Short,SCOPE.MessageQueue>> queues

      Used to find the correct AckReceiverWindow on message reception and deliver it in the right order

    - #### cluster_name

          protected java.lang.String cluster_name

    - #### local_addr

          protected Address local_addr

    - #### thread_pool

          protected java.util.concurrent.Executor thread_pool

    - #### thread_group

          protected java.lang.ThreadGroup thread_group

    - #### thread_factory

          protected ThreadFactory thread_factory

    - #### timer

          protected TimeScheduler timer

  - ### Constructor Detail

    - #### SCOPE

          public SCOPE()

  - ### Method Detail

    - #### getNumberOfReceiverScopes

          public int getNumberOfReceiverScopes()

    - #### getNumberOfMessages

          public int getNumberOfMessages()

    - #### 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()

    - #### removeAllQueues

          public void removeAllQueues()

    - #### expire

          public void expire(short scope)

      Multicasts an EXPIRE message to all members, and - on reception - each member removes the scope locally
      Parameters:
        `scope` -

    - #### removeScope

          public void removeScope(Address member,
                         short scope)

    - #### dumpScopes

          public java.lang.String dumpScopes()

    - #### getNumActiveThreads

          public int getNumActiveThreads()

    - #### 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

    - #### start

          public void start()
                     throws java.lang.Exception

      Description copied from class: `Protocol`
      This method is called on a `Channel.connect(String)`. Starts work. Protocols are connected and queues are ready to receive events. Will be called from bottom to top. This call will replace the START and START_OK events.
      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

    - #### 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`

    - #### down

          public java.lang.Object down(Event evt)

      Description copied from class: `Protocol`
      An event is to be sent down the stack. The layer may want to examine its type and perform some action on it, depending on the event's type. If the event is a message MSG, then the layer may need to add a header to it (or do nothing at all) before sending it down the stack using `down_prot.down()`. In case of a GET_ADDRESS event (which tries to retrieve the stack's address from one of the bottom layers), the layer may need to send a new response event back up the stack using `up_prot.up()`.
      Overrides:
        `down` in class `Protocol`

    - #### up

          public java.lang.Object up(Event evt)

      Description copied from class: `Protocol`
      An event was received from the layer below. Usually the current layer will want to examine the event type and - depending on its type - perform some computation (e.g. removing headers from a MSG event type, or updating the internal membership list when receiving a VIEW_CHANGE event). Finally the event is either a) discarded, or b) an event is sent down the stack using `down_prot.down()` or c) the event (or another event) is sent up the stack using `up_prot.up()`.
      Overrides:
        `up` in class `Protocol`

    - #### getOrCreateQueue

          protected SCOPE.MessageQueue getOrCreateQueue(Address sender,
                                            short scope)

    - #### startExpiryTask

          protected void startExpiryTask()

    - #### stopExpiryTask

          protected void stopExpiryTask()

    - #### createThreadPool

          protected static java.util.concurrent.ExecutorService createThreadPool(int min_threads,
                                                              int max_threads,
                                                              long keep_alive_time,
                                                              ThreadFactory factory)

    - #### shutdownThreadPool

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

    - #### clearQueue

          public void clearQueue(Address member)

Copyright © 1998-2009 Bela Ban / Red Hat. All Rights Reserved.