Package org.apache.catalina.tribes.tipis

## Class AbstractReplicatedMap<K,​V>

- java.lang.Object
- - org.apache.catalina.tribes.tipis.AbstractReplicatedMap<K,​V>

- Type Parameters:
    `K` - The type of Key
    `V` - The type of Value
  All Implemented Interfaces:
    `Serializable`, `Map<K,​V>`, `ChannelListener`, `RpcCallback`, `Heartbeat`, `MembershipListener`
  Direct Known Subclasses:
    `LazyReplicatedMap`, `ReplicatedMap`

      public abstract class AbstractReplicatedMap<K,​V>
      extends Object
      implements Map<K,​V>, Serializable, RpcCallback, ChannelListener, MembershipListener, Heartbeat

  See Also:
    Serialized Form

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class | Description
    --- | --- | ---
    `static class` | `AbstractReplicatedMap.MapEntry<K,​V>` |
    `static class` | `AbstractReplicatedMap.MapMessage` |
    `static interface` | `AbstractReplicatedMap.MapOwner` |

    - ### Nested classes/interfaces inherited from interface java.util.Map

      `Map.Entry<K extends Object,​V extends Object>`

  - ### Field Summary

    Fields
    Modifier and Type | Field | Description
    --- | --- | ---
    `protected long` | `accessTimeout` | Since the map keeps internal membership this is the timeout for a ping message to be responded to If a remote map doesn't respond within this timeframe, its considered dead.
    `protected Channel` | `channel` | Reference to the channel for sending messages
    `protected int` | `channelSendOptions` | Our default send options
    `protected int` | `currentNode` | The node we are currently backing up data to, this index will rotate on a round robin basis
    `static int` | `DEFAULT_INITIAL_CAPACITY` | The default initial capacity - MUST be a power of two.
    `static float` | `DEFAULT_LOAD_FACTOR` | The load factor used when none specified in constructor.
    `protected ClassLoader[]` | `externalLoaders` | External class loaders if serialization and deserialization is to be performed successfully.
    `protected ConcurrentMap<K,​AbstractReplicatedMap.MapEntry<K,​V>>` | `innerMap` |
    `protected byte[]` | `mapContextName` | The Map context name makes this map unique, this allows us to have more than one map shared through one channel
    `protected HashMap<Member,​Long>` | `mapMembers` | A list of members in our map
    `protected String` | `mapname` | Readable string of the mapContextName value
    `protected AbstractReplicatedMap.MapOwner` | `mapOwner` | The owner of this map, ala a SessionManager for example
    `protected RpcChannel` | `rpcChannel` | The RpcChannel to send RPC messages through
    `protected long` | `rpcTimeout` | Timeout for RPC messages, how long we will wait for a reply
    `protected static StringManager` | `sm` |
    `protected Object` | `stateMutex` | Simple lock object for transfers
    `protected boolean` | `stateTransferred` | Has the state been transferred

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `AbstractReplicatedMap​(AbstractReplicatedMap.MapOwner owner, Channel channel, long timeout, String mapContextName, int initialCapacity, float loadFactor, int channelSendOptions, ClassLoader[] cls, boolean terminate)` | Creates a new map.

  - ### Method Summary

    All Methods Instance Methods Abstract Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `boolean` | `accept​(Serializable msg, Member sender)` | Invoked by the channel to determine if the listener will process this message or not.
    `void` | `breakdown()` |
    `protected void` | `broadcast​(int msgtype, boolean rpc)` | Helper method to broadcast a message to all members in a channel
    `void` | `clear()` |
    `void` | `clear​(boolean notify)` |
    `boolean` | `containsKey​(Object key)` | Returns true if the key has an entry in the map.
    `boolean` | `containsValue​(Object value)` |
    `Set<Map.Entry<K,​V>>` | `entrySet()` |
    `Set<Map.Entry<K,​AbstractReplicatedMap.MapEntry<K,​V>>>` | `entrySetFull()` | Returns the entire contents of the map Map.Entry.getValue() will return a LazyReplicatedMap.MapEntry object containing all the information about the object.
    `boolean` | `equals​(Object o)` |
    `Member[]` | `excludeFromSet​(Member[] mbrs, Member[] set)` |
    `V` | `get​(Object key)` |
    `long` | `getAccessTimeout()` |
    `Channel` | `getChannel()` |
    `int` | `getChannelSendOptions()` |
    `ClassLoader[]` | `getExternalLoaders()` |
    `AbstractReplicatedMap.MapEntry<K,​V>` | `getInternal​(Object key)` |
    `byte[]` | `getMapContextName()` |
    `Member[]` | `getMapMembers()` |
    `Member[]` | `getMapMembers​(HashMap<Member,​Long> members)` |
    `Member[]` | `getMapMembersExcl​(Member[] exclude)` |
    `AbstractReplicatedMap.MapOwner` | `getMapOwner()` |
    `int` | `getNextBackupIndex()` |
    `Member` | `getNextBackupNode()` |
    `protected abstract int` | `getReplicateMessageType()` |
    `RpcChannel` | `getRpcChannel()` |
    `long` | `getRpcTimeout()` |
    `protected abstract int` | `getStateMessageType()` |
    `Object` | `getStateMutex()` |
    `int` | `hashCode()` |
    `void` | `heartbeat()` | Heartbeat invocation for resources cleanup etc
    `protected void` | `init​(AbstractReplicatedMap.MapOwner owner, Channel channel, String mapContextName, long timeout, int channelSendOptions, ClassLoader[] cls, boolean terminate)` | Initializes the map by creating the RPC channel, registering itself as a channel listener This method is also responsible for initiating the state transfer
    `boolean` | `inSet​(Member m, Member[] set)` |
    `boolean` | `isEmpty()` |
    `boolean` | `isStateTransferred()` |
    `Set<K>` | `keySet()` |
    `Set<K>` | `keySetFull()` |
    `void` | `leftOver​(Serializable msg, Member sender)` | If the reply has already been sent to the requesting thread, the rpc callback can handle any data that comes in after the fact.
    `void` | `mapMemberAdded​(Member member)` |
    `void` | `memberAdded​(Member member)` | A member was added to the group
    `protected void` | `memberAlive​(Member member)` | We have received a member alive notification
    `void` | `memberDisappeared​(Member member)` | A member was removed from the group If the member left voluntarily, the Member.getCommand will contain the Member.SHUTDOWN_PAYLOAD data
    `void` | `messageReceived​(Serializable msg, Member sender)` | Receive a message from the channel
    `protected void` | `ping​(long timeout)` | Sends a ping out to all the members in the cluster, not just map members that this map is alive.
    `protected void` | `printMap​(String header)` |
    `protected abstract Member[]` | `publishEntryInfo​(Object key, Object value)` |
    `V` | `put​(K key, V value)` |
    `V` | `put​(K key, V value, boolean notify)` |
    `void` | `putAll​(Map<? extends K,​? extends V> m)` | Copies all values from one map to this instance
    `V` | `remove​(Object key)` | Removes an object from this map, it will also remove it from
    `V` | `remove​(Object key, boolean notify)` |
    `void` | `replicate​(boolean complete)` | This can be invoked by a periodic thread to replicate out any changes.
    `void` | `replicate​(Object key, boolean complete)` | Replicates any changes to the object since the last time The object has to be primary, ie, if the object is a proxy or a backup, it will not be replicated
    `Serializable` | `replyRequest​(Serializable msg, Member sender)` | Allows sending a response to a received message.
    `void` | `setAccessTimeout​(long accessTimeout)` |
    `void` | `setChannelSendOptions​(int channelSendOptions)` |
    `void` | `setExternalLoaders​(ClassLoader[] externalLoaders)` |
    `void` | `setMapOwner​(AbstractReplicatedMap.MapOwner mapOwner)` |
    `int` | `size()` |
    `int` | `sizeFull()` |
    `void` | `transferState()` |
    `Collection<V>` | `values()` |
    `protected Member[]` | `wrap​(Member m)` | Helper methods, wraps a single member in an array

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

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

    - ### Methods inherited from interface java.util.Map

      `compute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, merge, putIfAbsent, remove, replace, replace, replaceAll`

- - ### Field Detail

    - #### sm

          protected static final StringManager sm

    - #### DEFAULT_INITIAL_CAPACITY

          public static final int DEFAULT_INITIAL_CAPACITY

      The default initial capacity - MUST be a power of two.
      See Also:
        Constant Field Values

    - #### DEFAULT_LOAD_FACTOR

          public static final float DEFAULT_LOAD_FACTOR

      The load factor used when none specified in constructor.
      See Also:
        Constant Field Values

    - #### innerMap

          protected final ConcurrentMap<K,​AbstractReplicatedMap.MapEntry<K,​V>> innerMap

    - #### rpcTimeout

          protected transient long rpcTimeout

      Timeout for RPC messages, how long we will wait for a reply

    - #### channel

          protected transient Channel channel

      Reference to the channel for sending messages

    - #### rpcChannel

          protected transient RpcChannel rpcChannel

      The RpcChannel to send RPC messages through

    - #### mapContextName

          protected transient byte[] mapContextName

      The Map context name makes this map unique, this allows us to have more than one map shared through one channel

    - #### stateTransferred

          protected transient boolean stateTransferred

      Has the state been transferred

    - #### stateMutex

          protected final transient Object stateMutex

      Simple lock object for transfers

    - #### mapMembers

          protected final transient HashMap<Member,​Long> mapMembers

      A list of members in our map

    - #### channelSendOptions

          protected transient int channelSendOptions

      Our default send options

    - #### mapOwner

          protected transient AbstractReplicatedMap.MapOwner mapOwner

      The owner of this map, ala a SessionManager for example

    - #### externalLoaders

          protected transient ClassLoader[] externalLoaders

      External class loaders if serialization and deserialization is to be performed successfully.

    - #### currentNode

          protected transient int currentNode

      The node we are currently backing up data to, this index will rotate on a round robin basis

    - #### accessTimeout

          protected transient long accessTimeout

      Since the map keeps internal membership this is the timeout for a ping message to be responded to If a remote map doesn't respond within this timeframe, its considered dead.

    - #### mapname

          protected transient String mapname

      Readable string of the mapContextName value

  - ### Constructor Detail

    - #### AbstractReplicatedMap

          public AbstractReplicatedMap​(AbstractReplicatedMap.MapOwner owner,
                                       Channel channel,
                                       long timeout,
                                       String mapContextName,
                                       int initialCapacity,
                                       float loadFactor,
                                       int channelSendOptions,
                                       ClassLoader[] cls,
                                       boolean terminate)

      Creates a new map.
      Parameters:
        `owner` - The map owner
        `channel` - The channel to use for communication
        `timeout` - long - timeout for RPC messages
        `mapContextName` - String - unique name for this map, to allow multiple maps per channel
        `initialCapacity` - int - the size of this map, see HashMap
        `loadFactor` - float - load factor, see HashMap
        `channelSendOptions` - Send options
        `cls` - - a list of classloaders to be used for deserialization of objects.
        `terminate` - - Flag for whether to terminate this map that failed to start.

  - ### Method Detail

    - #### getStateMessageType

          protected abstract int getStateMessageType()

    - #### getReplicateMessageType

          protected abstract int getReplicateMessageType()

    - #### wrap

          protected Member[] wrap​(Member m)

      Helper methods, wraps a single member in an array
      Parameters:
        `m` - Member
      Returns:
        Member[]

    - #### init

          protected void init​(AbstractReplicatedMap.MapOwner owner,
                              Channel channel,
                              String mapContextName,
                              long timeout,
                              int channelSendOptions,
                              ClassLoader[] cls,
                              boolean terminate)

      Initializes the map by creating the RPC channel, registering itself as a channel listener This method is also responsible for initiating the state transfer
      Parameters:
        `owner` - Object
        `channel` - Channel
        `mapContextName` - String
        `timeout` - long
        `channelSendOptions` - int
        `cls` - ClassLoader[]
        `terminate` - - Flag for whether to terminate this map that failed to start.

    - #### ping

          protected void ping​(long timeout)
                       throws ChannelException

      Sends a ping out to all the members in the cluster, not just map members that this map is alive.
      Parameters:
        `timeout` - long
      Throws:
        `ChannelException` - Send error

    - #### memberAlive

          protected void memberAlive​(Member member)

      We have received a member alive notification
      Parameters:
        `member` - Member

    - #### broadcast

          protected void broadcast​(int msgtype,
                                   boolean rpc)
                            throws ChannelException

      Helper method to broadcast a message to all members in a channel
      Parameters:
        `msgtype` - int
        `rpc` - boolean
      Throws:
        `ChannelException` - Send error

    - #### breakdown

          public void breakdown()

    - #### hashCode

          public int hashCode()

      Specified by:
        `hashCode` in interface `ChannelListener`
      Specified by:
        `hashCode` in interface `Map<K,​V>`
      Overrides:
        `hashCode` in class `Object`
      Returns:
        int
      See Also:
        `Object.hashCode()`

    - #### equals

          public boolean equals​(Object o)

      Specified by:
        `equals` in interface `ChannelListener`
      Specified by:
        `equals` in interface `Map<K,​V>`
      Overrides:
        `equals` in class `Object`
      Parameters:
        `o` - Object
      Returns:
        boolean
      See Also:
        `Object.equals(Object)`

    - #### getMapMembers

          public Member[] getMapMembers​(HashMap<Member,​Long> members)

    - #### getMapMembers

          public Member[] getMapMembers()

    - #### getMapMembersExcl

          public Member[] getMapMembersExcl​(Member[] exclude)

    - #### replicate

          public void replicate​(Object key,
                                boolean complete)

      Replicates any changes to the object since the last time The object has to be primary, ie, if the object is a proxy or a backup, it will not be replicated
      Parameters:
        `key` - The object to replicate
        `complete` - - if set to true, the object is replicated to its backup if set to false, only objects that implement ReplicatedMapEntry and the isDirty() returns true will be replicated

    - #### replicate

          public void replicate​(boolean complete)

      This can be invoked by a periodic thread to replicate out any changes. For maps that don't store objects that implement ReplicatedMapEntry, this method should be used infrequently to avoid large amounts of data transfer
      Parameters:
        `complete` - boolean

    - #### transferState

          public void transferState()

    - #### replyRequest

          public Serializable replyRequest​(Serializable msg,
                                           Member sender)

      Description copied from interface: `RpcCallback`
      Allows sending a response to a received message.
      Specified by:
        `replyRequest` in interface `RpcCallback`
      Parameters:
        `msg` - Serializable
        `sender` - Member
      Returns:
        Serializable - null if no reply should be sent

    - #### leftOver

          public void leftOver​(Serializable msg,
                               Member sender)

      If the reply has already been sent to the requesting thread, the rpc callback can handle any data that comes in after the fact.
      Specified by:
        `leftOver` in interface `RpcCallback`
      Parameters:
        `msg` - Serializable
        `sender` - Member

    - #### messageReceived

          public void messageReceived​(Serializable msg,
                                      Member sender)

      Description copied from interface: `ChannelListener`
      Receive a message from the channel
      Specified by:
        `messageReceived` in interface `ChannelListener`
      Parameters:
        `msg` - Serializable
        `sender` - - the source of the message

    - #### accept

          public boolean accept​(Serializable msg,
                                Member sender)

      Description copied from interface: `ChannelListener`
      Invoked by the channel to determine if the listener will process this message or not.
      Specified by:
        `accept` in interface `ChannelListener`
      Parameters:
        `msg` - Serializable
        `sender` - Member
      Returns:
        boolean

    - #### mapMemberAdded

          public void mapMemberAdded​(Member member)

    - #### inSet

          public boolean inSet​(Member m,
                               Member[] set)

    - #### excludeFromSet

          public Member[] excludeFromSet​(Member[] mbrs,
                                         Member[] set)

    - #### memberAdded

          public void memberAdded​(Member member)

      Description copied from interface: `MembershipListener`
      A member was added to the group
      Specified by:
        `memberAdded` in interface `MembershipListener`
      Parameters:
        `member` - Member - the member that was added

    - #### memberDisappeared

          public void memberDisappeared​(Member member)

      Description copied from interface: `MembershipListener`
      A member was removed from the group
      If the member left voluntarily, the Member.getCommand will contain the Member.SHUTDOWN_PAYLOAD data
      Specified by:
        `memberDisappeared` in interface `MembershipListener`
      Parameters:
        `member` - Member
      See Also:
        `Member.SHUTDOWN_PAYLOAD`

    - #### getNextBackupIndex

          public int getNextBackupIndex()

    - #### getNextBackupNode

          public Member getNextBackupNode()

    - #### publishEntryInfo

          protected abstract Member[] publishEntryInfo​(Object key,
                                                       Object value)
                                                throws ChannelException

      Throws:
        `ChannelException`

    - #### heartbeat

          public void heartbeat()

      Description copied from interface: `Heartbeat`
      Heartbeat invocation for resources cleanup etc
      Specified by:
        `heartbeat` in interface `Heartbeat`

    - #### remove

          public V remove​(Object key)

      Removes an object from this map, it will also remove it from
      Specified by:
        `remove` in interface `Map<K,​V>`
      Parameters:
        `key` - Object
      Returns:
        Object

    - #### remove

          public V remove​(Object key,
                          boolean notify)

    - #### getInternal

          public AbstractReplicatedMap.MapEntry<K,​V> getInternal​(Object key)

    - #### get

          public V get​(Object key)

      Specified by:
        `get` in interface `Map<K,​V>`

    - #### printMap

          protected void printMap​(String header)

    - #### containsKey

          public boolean containsKey​(Object key)

      Returns true if the key has an entry in the map. The entry can be a proxy or a backup entry, invoking `get(key)` will make this entry primary for the group
      Specified by:
        `containsKey` in interface `Map<K,​V>`
      Parameters:
        `key` - Object
      Returns:
        boolean

    - #### put

          public V put​(K key,
                       V value)

      Specified by:
        `put` in interface `Map<K,​V>`

    - #### put

          public V put​(K key,
                       V value,
                       boolean notify)

    - #### putAll

          public void putAll​(Map<? extends K,​? extends V> m)

      Copies all values from one map to this instance
      Specified by:
        `putAll` in interface `Map<K,​V>`
      Parameters:
        `m` - Map

    - #### clear

          public void clear()

      Specified by:
        `clear` in interface `Map<K,​V>`

    - #### clear

          public void clear​(boolean notify)

    - #### containsValue

          public boolean containsValue​(Object value)

      Specified by:
        `containsValue` in interface `Map<K,​V>`

    - #### entrySetFull

          public Set<Map.Entry<K,​AbstractReplicatedMap.MapEntry<K,​V>>> entrySetFull()

      Returns the entire contents of the map Map.Entry.getValue() will return a LazyReplicatedMap.MapEntry object containing all the information about the object.
      Returns:
        Set

    - #### keySetFull

          public Set<K> keySetFull()

    - #### sizeFull

          public int sizeFull()

    - #### entrySet

          public Set<Map.Entry<K,​V>> entrySet()

      Specified by:
        `entrySet` in interface `Map<K,​V>`

    - #### keySet

          public Set<K> keySet()

      Specified by:
        `keySet` in interface `Map<K,​V>`

    - #### size

          public int size()

      Specified by:
        `size` in interface `Map<K,​V>`

    - #### isEmpty

          public boolean isEmpty()

      Specified by:
        `isEmpty` in interface `Map<K,​V>`

    - #### values

          public Collection<V> values()

      Specified by:
        `values` in interface `Map<K,​V>`

    - #### getChannel

          public Channel getChannel()

    - #### getMapContextName

          public byte[] getMapContextName()

    - #### getRpcChannel

          public RpcChannel getRpcChannel()

    - #### getRpcTimeout

          public long getRpcTimeout()

    - #### getStateMutex

          public Object getStateMutex()

    - #### isStateTransferred

          public boolean isStateTransferred()

    - #### getMapOwner

          public AbstractReplicatedMap.MapOwner getMapOwner()

    - #### getExternalLoaders

          public ClassLoader[] getExternalLoaders()

    - #### getChannelSendOptions

          public int getChannelSendOptions()

    - #### getAccessTimeout

          public long getAccessTimeout()

    - #### setMapOwner

          public void setMapOwner​(AbstractReplicatedMap.MapOwner mapOwner)

    - #### setExternalLoaders

          public void setExternalLoaders​(ClassLoader[] externalLoaders)

    - #### setChannelSendOptions

          public void setChannelSendOptions​(int channelSendOptions)

    - #### setAccessTimeout

          public void setAccessTimeout​(long accessTimeout)