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
An abstract replicated map implementation.
See Also:

  • Field Details

    • sm

      protected static final StringManager sm
      The string manager for packaging specific messages.

    • DEFAULT_INITIAL_CAPACITY

      public static final int DEFAULT_INITIAL_CAPACITY
      The default initial capacity - MUST be a power of two.
      See Also:

    • DEFAULT_LOAD_FACTOR

      public static final float DEFAULT_LOAD_FACTOR
      The load factor used when none specified in constructor.
      See Also:

    • innerMap

      protected final ConcurrentMap<K, AbstractReplicatedMap.MapEntry<K,V>> innerMap
      The underlying concurrent map storing entries.

    • 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()
      Gets the state message type.
      Returns:
      the state message type

    • getReplicateMessageType

      protected abstract int getReplicateMessageType()
      Gets the replicate message type.
      Returns:
      the replicate message type

    • 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()
      Breaks down the map, removing all entries and closing channels.

    • hashCode

      public int hashCode()
      Returns the hash code for this map based on the map context name.
      Specified by:
      hashCode in interface Map<K,V>
      Overrides:
      hashCode in class Object
      Returns:
      the hash code

    • equals

      public boolean equals(Object o)
      Checks if this map is equal to another object.
      Specified by:
      equals in interface Map<K,V>
      Overrides:
      equals in class Object
      Parameters:
      o - the object to compare
      Returns:
      true if the maps have the same context name

    • getMapMembers

      public Member[] getMapMembers(HashMap<Member,Long> members)
      Gets the map members from the given map.
      Parameters:
      members - The member map
      Returns:
      an array of members

    • getMapMembers

      public Member[] getMapMembers()
      Gets the current map members.
      Returns:
      an array of members

    • getMapMembersExcl

      public Member[] getMapMembersExcl(Member[] exclude)
      Gets the map members excluding the given members.
      Parameters:
      exclude - Members to exclude from the result
      Returns:
      an array of members excluding the specified ones

    • replicate

      public void replicate(K 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()
      Transfers the current state from another map in the cluster.

    • replyRequest

      public Serializable replyRequest(Serializable msg, Member sender)
      Handles a reply request message.
      Specified by:
      replyRequest in interface RpcCallback
      Parameters:
      msg - The message
      sender - The sender
      Returns:
      the reply message or null

    • leftOver

      public void leftOver(Serializable msg, Member sender)
      Handles a left over membership message.
      Specified by:
      leftOver in interface RpcCallback
      Parameters:
      msg - The message
      sender - The sender

    • messageReceived

      public void messageReceived(Serializable msg, Member sender)
      Handles a received message.
      Specified by:
      messageReceived in interface ChannelListener
      Parameters:
      msg - The message
      sender - The sender

    • accept

      public boolean accept(Serializable msg, Member sender)
      Accepts or rejects a message based on the map context.
      Specified by:
      accept in interface ChannelListener
      Parameters:
      msg - The message
      sender - The sender
      Returns:
      true if the message is accepted

    • mapMemberAdded

      public void mapMemberAdded(Member member)
      Adds a member to this map.
      Parameters:
      member - The member to add

    • inSet

      public boolean inSet(Member m, Member[] set)
      Checks if a member is in the given set.
      Parameters:
      m - The member to check
      set - The set to check against
      Returns:
      true if the member is in the set

    • excludeFromSet

      public Member[] excludeFromSet(Member[] mbrs, Member[] set)
      Excludes members from the given set.
      Parameters:
      mbrs - The members to exclude
      set - The set to exclude from
      Returns:
      The resulting set after exclusion

    • memberAdded

      public void memberAdded(Member member)
      Called when a member is added to the channel.
      Specified by:
      memberAdded in interface MembershipListener
      Parameters:
      member - The member that was added

    • memberDisappeared

      public void memberDisappeared(Member member)
      Called when a member disappears from the channel.
      Specified by:
      memberDisappeared in interface MembershipListener
      Parameters:
      member - The member that disappeared
      See Also:

    • getNextBackupIndex

      public int getNextBackupIndex()
      Gets the next backup index using round-robin rotation.
      Returns:
      The next backup index, or -1 if no members exist

    • getNextBackupNode

      public Member getNextBackupNode()
      Gets the next backup node using round-robin rotation.
      Returns:
      The next backup node, or null if no members exist

    • 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()
      Sends a heartbeat to all members in the cluster.
      Specified by:
      heartbeat in interface Heartbeat

    • remove

      public V remove(Object key)
      Removes the entry for the specified key from the map.
      Specified by:
      remove in interface Map<K,V>
      Parameters:
      key - The key to remove
      Returns:
      The previous value associated with the key, or null

    • remove

      public V remove(Object key, boolean notify)
      Removes the entry for the specified key from the map.
      Parameters:
      key - The key to remove
      notify - Whether to notify other members
      Returns:
      The previous value associated with the key, or null

    • getInternal

      public AbstractReplicatedMap.MapEntry<K,V> getInternal(Object key)
      Gets the internal map entry for a key.
      Parameters:
      key - The key
      Returns:
      the internal map entry, or null if not found

    • get

      public V get(Object key)
      Specified by:
      get in interface Map<K,V>

    • printMap

      protected void printMap(String header)
      Prints the contents of the map for debugging purposes.
      Parameters:
      header - Header string to print before the map contents

    • 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)
      Puts a key-value pair into the map.
      Specified by:
      put in interface Map<K,V>
      Parameters:
      key - The key
      value - The value
      Returns:
      The previous value associated with the key, or null

    • put

      public V put(K key, V value, boolean notify)
      Puts a key-value pair into the map.
      Parameters:
      key - The key
      value - The value
      notify - Whether to notify other members
      Returns:
      The previous value associated with the key, or null

    • putAll

      public void putAll(Map<? extends K, ? extends V> m)
      Copies all mappings from the specified map to this map.
      Specified by:
      putAll in interface Map<K,V>
      Parameters:
      m - The map whose mappings are to be copied

    • clear

      public void clear()
      Specified by:
      clear in interface Map<K,V>

    • clear

      public void clear(boolean notify)
      Clears entries from the map.
      Parameters:
      notify - Whether to notify other members

    • 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()
      Gets the complete set of keys in the map.
      Returns:
      The complete set of keys

    • sizeFull

      public int sizeFull()
      Gets the complete size of the map.
      Returns:
      The complete size of the map

    • entrySet

      public Set<Map.Entry<K,V>> entrySet()
      Returns a set view of the mappings contained in this map.
      Specified by:
      entrySet in interface Map<K,V>
      Returns:
      a set view of the mappings

    • keySet

      public Set<K> keySet()
      Returns a set view of the keys contained in this map.
      Specified by:
      keySet in interface Map<K,V>
      Returns:
      a set view of the keys

    • size

      public int size()
      Returns the number of active entries in this map.
      Specified by:
      size in interface Map<K,V>
      Returns:
      the number of active entries

    • isEmpty

      public boolean isEmpty()
      Checks if this map is empty.
      Specified by:
      isEmpty in interface Map<K,V>
      Returns:
      true if the map is empty

    • values

      public Collection<V> values()
      Returns a collection view of the values contained in this map.
      Specified by:
      values in interface Map<K,V>
      Returns:
      a collection view of the values

    • getChannel

      public Channel getChannel()
      Gets the channel used for communication.
      Returns:
      the channel

    • getMapContextName

      public byte[] getMapContextName()
      Gets the map context name.
      Returns:
      the map context name as bytes

    • getRpcChannel

      public RpcChannel getRpcChannel()
      Gets the RPC channel.
      Returns:
      the RPC channel

    • getRpcTimeout

      public long getRpcTimeout()
      Gets the RPC timeout.
      Returns:
      the RPC timeout in milliseconds

    • getStateMutex

      public Object getStateMutex()
      Gets the state mutex object.
      Returns:
      the state mutex

    • isStateTransferred

      public boolean isStateTransferred()
      Checks if state has been transferred.
      Returns:
      true if state has been transferred

    • getMapOwner

      public AbstractReplicatedMap.MapOwner getMapOwner()
      Gets the map owner.
      Returns:
      the map owner

    • getExternalLoaders

      public ClassLoader[] getExternalLoaders()
      Gets the external class loaders.
      Returns:
      the external class loaders

    • getChannelSendOptions

      public int getChannelSendOptions()
      Gets the channel send options.
      Returns:
      the channel send options

    • getAccessTimeout

      public long getAccessTimeout()
      Gets the access timeout.
      Returns:
      the access timeout in milliseconds

    • setMapOwner

      public void setMapOwner(AbstractReplicatedMap.MapOwner mapOwner)
      Sets the map owner.
      Parameters:
      mapOwner - The map owner

    • setExternalLoaders

      public void setExternalLoaders(ClassLoader[] externalLoaders)
      Sets the external class loaders.
      Parameters:
      externalLoaders - The external class loaders

    • setChannelSendOptions

      public void setChannelSendOptions(int channelSendOptions)
      Sets the channel send options.
      Parameters:
      channelSendOptions - The channel send options

    • setAccessTimeout

      public void setAccessTimeout(long accessTimeout)
      Sets the access timeout.
      Parameters:
      accessTimeout - The access timeout in milliseconds