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