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