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 final int`
  `DEFAULT_INITIAL_CAPACITY`
  The default initial capacity - MUST be a power of two.
  `static final 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 final 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 final 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 final StringManager`
  `sm`
  `protected final 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

  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)`
  Publish info about a map pair (key/value) to other nodes in the cluster.
  `V`
  `put(K key, V value)`
  `V`
  `put(K key, V value, boolean notify)`
  `void`
  `putAll(Map<? extends K,? extends V> m)`
  `V`
  `remove(Object key)`
  `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 Details

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

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

  - ### 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 `Map<K,V>`
    Overrides:
      `hashCode` in class `Object`

  - ### equals

    public boolean equals(Object o)
    Specified by:
      `equals` in interface `Map<K,V>`
    Overrides:
      `equals` in class `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` - The message
      `sender` - Member
    Returns:
      Serializable object, `null` if no reply should be sent

  - ### leftOver

    public void leftOver(Serializable msg, Member sender)
    Description copied from interface: `RpcCallback`
    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` - The message
      `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
    Publish info about a map pair (key/value) to other nodes in the cluster.
    Parameters:
      `key` - Object
      `value` - Object
    Returns:
      Member - the backup node
    Throws:
      `ChannelException` - Cluster error

  - ### 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)
    Specified by:
      `remove` in interface `Map<K,V>`

  - ### 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)
    Specified by:
      `putAll` in interface `Map<K,V>`

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