AbstractReplicatedMap (Apache Tomcat 7.0.67 API Documentation)

java.lang.Object
- org.apache.catalina.tribes.tipis.AbstractReplicatedMap<K,V>

All Implemented Interfaces:

java.io.Serializable, java.util.Map<K,V>, ChannelListener, RpcCallback, Heartbeat, MembershipListener

Direct Known Subclasses:

LazyReplicatedMap, ReplicatedMap
```
public abstract class AbstractReplicatedMap<K,V>
extends java.lang.Object
implements java.util.Map<K,V>, java.io.Serializable, RpcCallback, ChannelListener, MembershipListener, Heartbeat
```
Version:

1.0

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
java.util.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 java.lang.ClassLoader[]`	`externalLoaders` External class loaders if serialization and deserialization is to be performed successfully.
`protected java.util.concurrent.ConcurrentHashMap<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 java.util.HashMap<Member,java.lang.Long>`	`mapMembers` A list of members in our map
`protected java.lang.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 java.lang.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, java.lang.String mapContextName, int initialCapacity, float loadFactor, int channelSendOptions, java.lang.ClassLoader[] cls, boolean terminate)` Creates a new map

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`accept(java.io.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)`
`java.lang.Object`	`clone()`
`boolean`	`containsKey(java.lang.Object key)` Returns true if the key has an entry in the map.
`boolean`	`containsValue(java.lang.Object value)`
`java.util.Set<java.util.Map.Entry<K,V>>`	`entrySet()`
`java.util.Set<java.util.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(java.lang.Object o)`
`Member[]`	`excludeFromSet(Member[] mbrs, Member[] set)`
`void`	`finalize()`
`V`	`get(java.lang.Object key)`
`long`	`getAccessTimeout()`
`Channel`	`getChannel()`
`int`	`getChannelSendOptions()`
`java.lang.ClassLoader[]`	`getExternalLoaders()`
`AbstractReplicatedMap.MapEntry<K,V>`	`getInternal(java.lang.Object key)`
`byte[]`	`getMapContextName()`
`Member[]`	`getMapMembers()`
`Member[]`	`getMapMembers(java.util.HashMap<Member,java.lang.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()`
`java.lang.Object`	`getStateMutex()`
`int`	`hashCode()`
`void`	`heartbeat()` Heartbeat invocation for resources cleanup etc
`protected void`	`init(AbstractReplicatedMap.MapOwner owner, Channel channel, java.lang.String mapContextName, long timeout, int channelSendOptions, java.lang.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()`
`java.util.Set<K>`	`keySet()`
`java.util.Set<K>`	`keySetFull()`
`void`	`leftOver(java.io.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(java.io.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(java.lang.String header)`
`protected abstract Member[]`	`publishEntryInfo(java.lang.Object key, java.lang.Object value)`
`V`	`put(K key, V value)`
`V`	`put(K key, V value, boolean notify)`
`void`	`putAll(java.util.Map<? extends K,? extends V> m)` Copies all values from one map to this instance
`V`	`remove(java.lang.Object key)` Removes an object from this map, it will also remove it from
`V`	`remove(java.lang.Object key, boolean notify)`
`void`	`replicate(boolean complete)` This can be invoked by a periodic thread to replicate out any changes.
`void`	`replicate(java.lang.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
`java.io.Serializable`	`replyRequest(java.io.Serializable msg, Member sender)` TODO implement state transfer
`void`	`setAccessTimeout(long accessTimeout)`
`void`	`setChannelSendOptions(int channelSendOptions)`
`void`	`setExternalLoaders(java.lang.ClassLoader[] externalLoaders)`
`void`	`setMapOwner(AbstractReplicatedMap.MapOwner mapOwner)`
`int`	`size()`
`int`	`sizeFull()`
`void`	`transferState()`
`java.util.Collection<V>`	`values()`
`protected Member[]`	`wrap(Member m)` Helper methods, wraps a single member in an array

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - 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 java.util.concurrent.ConcurrentHashMap<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 java.lang.Object stateMutex
```
    Simple lock object for transfers
  - mapMembers
```
protected final transient java.util.HashMap<Member,java.lang.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 java.lang.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 java.lang.String mapname
```
    Readable string of the mapContextName value
- Constructor Detail
  - AbstractReplicatedMap
```
public AbstractReplicatedMap(AbstractReplicatedMap.MapOwner owner,
                     Channel channel,
                     long timeout,
                     java.lang.String mapContextName,
                     int initialCapacity,
                     float loadFactor,
                     int channelSendOptions,
                     java.lang.ClassLoader[] cls,
                     boolean terminate)
```
    Creates a new map
    
    Parameters:
    channel - The channel to use for communication
    timeout - long - timeout for RPC messags
    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
    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,
        java.lang.String mapContextName,
        long timeout,
        int channelSendOptions,
        java.lang.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
  - 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
  - breakdown
```
public void breakdown()
```
  - finalize
```
public void finalize()
              throws java.lang.Throwable
```
    Overrides:
    
    finalize in class java.lang.Object
    
    Throws:
    
    java.lang.Throwable
  - hashCode
```
public int hashCode()
```
    Specified by:
    
    hashCode in interface java.util.Map<K,V>
    
    Specified by:
    
    hashCode in interface ChannelListener
    
    Overrides:
    
    hashCode in class java.lang.Object
    
    Returns:
    int
    See Also:
    Object.hashCode()
  - equals
```
public boolean equals(java.lang.Object o)
```
    Specified by:
    
    equals in interface java.util.Map<K,V>
    
    Specified by:
    
    equals in interface ChannelListener
    
    Overrides:
    
    equals in class java.lang.Object
    
    Parameters:
    o - Object
    
    Returns:
    boolean
    See Also:
    Object.equals(Object)
  - getMapMembers
```
public Member[] getMapMembers(java.util.HashMap<Member,java.lang.Long> members)
```
  - getMapMembers
```
public Member[] getMapMembers()
```
  - getMapMembersExcl
```
public Member[] getMapMembersExcl(Member[] exclude)
```
  - replicate
```
public void replicate(java.lang.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:
    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 java.io.Serializable replyRequest(java.io.Serializable msg,
                                Member sender)
```
    TODO implement state transfer
    
    Specified by:
    
    replyRequest in interface RpcCallback
    
    Parameters:
    msg - Serializable
    
    Returns:
    Serializable - null if no reply should be sent
  - leftOver
```
public void leftOver(java.io.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(java.io.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(java.io.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(java.lang.Object key,
                        java.lang.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(java.lang.Object key)
```
    Removes an object from this map, it will also remove it from
    
    Specified by:
    
    remove in interface java.util.Map<K,V>
    
    Parameters:
    key - Object
    
    Returns:
    Object
  - remove
```
public V remove(java.lang.Object key,
       boolean notify)
```
  - getInternal
```
public AbstractReplicatedMap.MapEntry<K,V> getInternal(java.lang.Object key)
```
  - get
```
public V get(java.lang.Object key)
```
    Specified by:
    
    get in interface java.util.Map<K,V>
  - printMap
```
protected void printMap(java.lang.String header)
```
  - containsKey
```
public boolean containsKey(java.lang.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 java.util.Map<K,V>
    
    Parameters:
    key - Object
    
    Returns:
    boolean
  - put
```
public V put(K key,
    V value)
```
    Specified by:
    
    put in interface java.util.Map<K,V>
  - put
```
public V put(K key,
    V value,
    boolean notify)
```
  - putAll
```
public void putAll(java.util.Map<? extends K,? extends V> m)
```
    Copies all values from one map to this instance
    
    Specified by:
    
    putAll in interface java.util.Map<K,V>
    
    Parameters:
    m - Map
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface java.util.Map<K,V>
  - clear
```
public void clear(boolean notify)
```
  - containsValue
```
public boolean containsValue(java.lang.Object value)
```
    Specified by:
    
    containsValue in interface java.util.Map<K,V>
  - clone
```
public java.lang.Object clone()
```
    Overrides:
    
    clone in class java.lang.Object
  - entrySetFull
```
public java.util.Set<java.util.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 java.util.Set<K> keySetFull()
```
  - sizeFull
```
public int sizeFull()
```
  - entrySet
```
public java.util.Set<java.util.Map.Entry<K,V>> entrySet()
```
    Specified by:
    
    entrySet in interface java.util.Map<K,V>
  - keySet
```
public java.util.Set<K> keySet()
```
    Specified by:
    
    keySet in interface java.util.Map<K,V>
  - size
```
public int size()
```
    Specified by:
    
    size in interface java.util.Map<K,V>
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface java.util.Map<K,V>
  - values
```
public java.util.Collection<V> values()
```
    Specified by:
    
    values in interface java.util.Map<K,V>
  - getChannel
```
public Channel getChannel()
```
  - getMapContextName
```
public byte[] getMapContextName()
```
  - getRpcChannel
```
public RpcChannel getRpcChannel()
```
  - getRpcTimeout
```
public long getRpcTimeout()
```
  - getStateMutex
```
public java.lang.Object getStateMutex()
```
  - isStateTransferred
```
public boolean isStateTransferred()
```
  - getMapOwner
```
public AbstractReplicatedMap.MapOwner getMapOwner()
```
  - getExternalLoaders
```
public java.lang.ClassLoader[] getExternalLoaders()
```
  - getChannelSendOptions
```
public int getChannelSendOptions()
```
  - getAccessTimeout
```
public long getAccessTimeout()
```
  - setMapOwner
```
public void setMapOwner(AbstractReplicatedMap.MapOwner mapOwner)
```
  - setExternalLoaders
```
public void setExternalLoaders(java.lang.ClassLoader[] externalLoaders)
```
  - setChannelSendOptions
```
public void setChannelSendOptions(int channelSendOptions)
```
  - setAccessTimeout
```
public void setAccessTimeout(long accessTimeout)
```

Class AbstractReplicatedMap<K,V>

Nested Class Summary

Nested classes/interfaces inherited from interface java.util.Map

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DEFAULT_INITIAL_CAPACITY

DEFAULT_LOAD_FACTOR

innerMap

rpcTimeout

channel

rpcChannel

mapContextName

stateTransferred

stateMutex

mapMembers

channelSendOptions

mapOwner

externalLoaders

currentNode

accessTimeout

mapname

Constructor Detail

AbstractReplicatedMap

Method Detail

getStateMessageType

getReplicateMessageType

wrap

init

ping

memberAlive

broadcast

breakdown

finalize

hashCode

equals

getMapMembers

getMapMembers

getMapMembersExcl

replicate

replicate

transferState

replyRequest

leftOver

messageReceived

accept

mapMemberAdded

inSet

excludeFromSet

memberAdded

memberDisappeared

getNextBackupIndex

getNextBackupNode

publishEntryInfo

heartbeat

remove

remove

getInternal

get

printMap

containsKey

put

put

putAll

clear

clear

containsValue

clone

entrySetFull

keySetFull

sizeFull

entrySet

keySet

size

isEmpty

values

getChannel

getMapContextName