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 and 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,V>`

  - ### Field Summary

    Fields
    Modifier and Type | Field and 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 and 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

    Methods
    Modifier and Type | Method and 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)`
    `void` | `finalize()`
    `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, getClass, notify, notifyAll, toString, wait, wait, wait`

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

    - #### finalize

          public void finalize()
                        throws Throwable

      Overrides:
        `finalize` in class `Object`
      Throws:
        `Throwable`

    - #### hashCode

          public int hashCode()

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

    - #### equals

          public boolean equals(Object o)

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

Copyright © 2000-2021 Apache Software Foundation. All Rights Reserved.