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

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