Package org.jivesoftware.openfire

Class SessionManager

java.lang.Object
org.jivesoftware.openfire.container.BasicModule
org.jivesoftware.openfire.SessionManager
All Implemented Interfaces:
ClusterEventListener, Module
public class SessionManager extends BasicModule implements ClusterEventListener
Manages the sessions associated with an account. The information maintained by the Session manager is entirely transient and does not need to be preserved between server restarts.
Author:
Derek DeMoro

  • Field Details

  • Constructor Details

    • SessionManager

      public SessionManager()

  • Method Details

    • getInstance

      public static SessionManager getInstance()
      Returns the instance of SessionManagerImpl being used by the XMPPServer.
      Returns:
      the instance of SessionManagerImpl being used by the XMPPServer.

    • addDetached

      public void addDetached(LocalSession localSession)
      Record a session as being detached (ie, has no connection). This is idempotent. This should really only be called by the LocalSession itself when it detaches.
      Parameters:
      localSession - the LocalSession (this) to mark as detached.

    • isDetached

      public boolean isDetached(LocalSession localSession)
      Checks if a session is currently in the detached state (ie, has no connection, but has not been formally closed yet either).
      Parameters:
      localSession - A session
      Returns:
      true if the session is currently in 'detached' state, otherwise 'false'.

    • terminateDetached

      public void terminateDetached(LocalSession session)
      Terminate a session that is detached. A presence 'unavailable' is broadcast for the session that's being terminated. The session will be removed from the routing table. When the provided session is not recognized as a detached session (on this cluster node), then this method will log a message but not apply any changes.
      Parameters:
      session - The (detached) session to be terminated.

    • removeDetached

      public boolean removeDetached(LocalSession localSession)
      Remove a session as being detached. This is idempotent. This should be called by the LocalSession itself either when resumed or when closed.
      Parameters:
      localSession - the LocalSession (this) which has been resumed or closed.

    • getConnectionMultiplexerSession

      public ConnectionMultiplexerSession getConnectionMultiplexerSession(org.xmpp.packet.JID address)
      Returns the session originated from the specified address or null if none was found. The specified address MUST contain a resource that uniquely identifies the session. A single connection manager should connect to the same node.
      Parameters:
      address - the address of the connection manager (including resource that identifies specific socket)
      Returns:
      the session originated from the specified address.

    • getConnectionMultiplexerSessions

      public List<ConnectionMultiplexerSession> getConnectionMultiplexerSessions()
      Returns all sessions originated from connection managers.
      Returns:
      all sessions originated from connection managers.

    • getConnectionMultiplexerSessions

      public List<ConnectionMultiplexerSession> getConnectionMultiplexerSessions(String domain)
      Returns a collection with all the sessions originated from the connection manager whose domain matches the specified domain. If there is no connection manager with the specified domain then an empty list is going to be returned.
      Parameters:
      domain - the domain of the connection manager.
      Returns:
      a collection with all the sessions originated from the connection manager whose domain matches the specified domain.

    • createMultiplexerSession

      public LocalConnectionMultiplexerSession createMultiplexerSession(Connection conn, org.xmpp.packet.JID address)
      Creates a new ConnectionMultiplexerSession.
      Parameters:
      conn - the connection to create the session from.
      address - the JID (may include a resource) of the connection manager's session.
      Returns:
      a newly created session.

    • nextStreamID

      public StreamID nextStreamID()
      Returns a randomly created ID to be used in a stream element.
      Returns:
      a randomly created ID to be used in a stream element.

    • createClientSession

      public LocalClientSession createClientSession(Connection conn, Locale language)
      Creates a new ClientSession. The new Client session will have a newly created stream ID.
      Parameters:
      conn - the connection to create the session from.
      language - The language to use for the new session.
      Returns:
      a newly created session.

    • createClientSession

      public LocalClientSession createClientSession(Connection conn, StreamID id)
      Creates a new ClientSession with the specified streamID.
      Parameters:
      conn - the connection to create the session from.
      id - the streamID to use for the new session.
      Returns:
      a newly created session.

    • createClientSession

      public LocalClientSession createClientSession(Connection conn, StreamID id, Locale language)
      Creates a new ClientSession with the specified streamID.
      Parameters:
      conn - the connection to create the session from.
      id - the streamID to use for the new session.
      language - The language to use for the new session.
      Returns:
      a newly created session.

    • createClientHttpSession

      public HttpSession createClientHttpSession(StreamID id, HttpConnection connection, Locale language, Duration wait, int hold, boolean isEncrypted, Duration maxPollingInterval, int maxRequests, Duration maxPause, Duration defaultInactivityTimeout, int majorVersion, int minorVersion) throws UnauthorizedException, UnknownHostException
      Creates a new ClientSession with the specified streamID.
      Parameters:
      connection - the connection to create the session from.
      id - the streamID to use for the new session.
      language - The language to use for the session
      wait - The longest time it is permissible to wait for a response.
      hold - The maximum number of simultaneous waiting requests.
      isEncrypted - True if all connections on this session should be encrypted, and false if they should not.
      maxPollingInterval - The max interval within which a client can send polling requests.
      maxRequests - The max number of requests it is permissible for the session to have open at any one time.
      maxPause - The maximum length of a temporary session pause (in seconds) that the client MAY request.
      defaultInactivityTimeout - The default inactivity timeout of this session.
      majorVersion - the major version of BOSH specification which this session utilizes.
      minorVersion - the minor version of BOSH specification which this session utilizes.
      Returns:
      a newly created session.
      Throws:
      UnauthorizedException - if the server has not been initialised
      UnknownHostException - if no IP address for the peer could be found,

    • createComponentSession

      public LocalComponentSession createComponentSession(org.xmpp.packet.JID address, Connection conn)

    • removeComponentSession

      public void removeComponentSession(LocalComponentSession session)

    • createIncomingServerSession

      public LocalIncomingServerSession createIncomingServerSession(Connection conn, StreamID id, String fromDomain) throws UnauthorizedException
      Creates a session for a remote server. The session should be created only after the remote server has been authenticated either using "server dialback" or SASL.
      Parameters:
      conn - the connection to the remote server.
      id - the stream ID used in the stream element when authenticating the server.
      fromDomain - The originating domain
      Returns:
      the newly created IncomingServerSession.
      Throws:
      UnauthorizedException - if the local server has not been initialized yet.

    • outgoingServerSessionCreated

      public void outgoingServerSessionCreated(LocalOutgoingServerSession session)
      Notification message that a new OutgoingServerSession has been created. Register a listener that will react when the connection gets closed.
      Parameters:
      session - the newly created OutgoingServerSession.

    • registerIncomingServerSession

      public void registerIncomingServerSession(String domain, LocalIncomingServerSession session)
      Registers that a server session originated by a remote server is hosting a given domain. Notice that the remote server may be hosting several subdomains as well as virtual hosts so the same IncomingServerSession may be associated with many domains. If the remote server creates many sessions to this server (eg. one for each subdomain) then associate all the sessions with the originating server that created all the sessions.
      Parameters:
      domain - the domain that is being served by the remote server.
      session - the incoming server session to the remote server.

    • unregisterIncomingServerSession

      public void unregisterIncomingServerSession(@Nonnull String domain, @Nonnull LocalIncomingServerSession session)
      Unregisters the specified remote domain that previously originated from the specified session of a remote server. This will retain a cache entry for the session as long as there is one or more validated domains remain associated with the session.
      Parameters:
      domain - the domain that is no longer being served by the remote server.
      session - the session from which to unregister the domain.

    • unregisterIncomingServerSession

      public void unregisterIncomingServerSession(@Nonnull StreamID streamID)
      Unregisters a remote server session identified by a stream ID, and disassociates all associated domains.
      Parameters:
      streamID - identifier for the session to unregister.

    • addSession

      public void addSession(LocalClientSession session)
      Add a new session to be managed. The session has been authenticated and resource binding has been done.
      Parameters:
      session - the session that was authenticated.

    • sessionAvailable

      public void sessionAvailable(LocalClientSession session, org.xmpp.packet.Presence presence)
      Notification message sent when a client sent an available presence for the session. Making the session available means that the session is now eligible for receiving messages from other clients. Sessions whose presence is not available may only receive packets (IQ packets) from the server. Therefore, an unavailable session remains invisible to other clients.
      Parameters:
      session - the session that receieved an available presence.
      presence - the presence for the session.

    • isOtherResourcePresenceEnabled

      public static boolean isOtherResourcePresenceEnabled()
      Returns true if the session should broadcast presences to all other resources for the current client. When disabled it is not possible to broadcast presence packets to another resource of the connected user. This is desirable if you have a use case where you have many resources attached to the same user account.
      Returns:
      true if presence should be broadcast to other resources of the same account

    • broadcastPresenceToResources

      public void broadcastPresenceToResources(org.xmpp.packet.JID originatingResource, org.xmpp.packet.Presence presence)
      Broadcasts presence updates from the originating user's resource to any of the user's existing available resources (including the resource from where the update originates).
      Parameters:
      originatingResource - the full JID of the session that sent the presence update.
      presence - the presence.

    • sessionUnavailable

      public void sessionUnavailable(LocalClientSession session)
      Notification message sent when a client sent an unavailable presence for the session. Making the session unavailable means that the session is not eligible for receiving messages from other clients.
      Parameters:
      session - the session that received an unavailable presence.

    • changePriority

      public void changePriority(LocalClientSession session, int oldPriority)
      Change the priority of a session, that was already available, associated with the sender.
      Parameters:
      session - The session whose presence priority has been modified
      oldPriority - The old priority for the session

    • isAnonymousClientSession

      public boolean isAnonymousClientSession(@Nonnull String username)

    • isAnonymousClientSession

      public boolean isAnonymousClientSession(@Nonnull org.xmpp.packet.JID address)

    • isActiveRoute

      public boolean isActiveRoute(String username, String resource)

    • getSession

      public ClientSession getSession(org.xmpp.packet.JID from)
      Returns the session responsible for this JID data. The returned Session may have never sent an available presence (thus not have a route) or could be a Session that hasn't authenticated yet (i.e. preAuthenticatedSessions).
      Parameters:
      from - the sender of the packet.
      Returns:
      the Session associated with the JID.

    • getSessions

      public Collection<ClientSession> getSessions(org.xmpp.packet.JID from)
      Returns all sessions responsible for this JID. The returned Sessions may have never sent an available presence (thus not have a route) or could be a Session that hasn't authenticated yet (i.e. preAuthenticatedSessions). If the provided JID is a full JID, this method behaves exactly like getSession(JID), but returns the singular result (if any) in a collection of one element. If that method returned null, this method returns an empty collection.
      Parameters:
      from - the sender of the packet.
      Returns:
      the Session associated with the JID.
      See Also:

    • getSessions

      public Collection<ClientSession> getSessions()
      Returns a list that contains all authenticated client sessions connected to the server. The list contains sessions of anonymous and non-anonymous users.
      Returns:
      a list that contains all client sessions connected to the server.

    • getSessions

      public Collection<ClientSession> getSessions(SessionResultFilter filter)

    • getIncomingServerSession

      public LocalIncomingServerSession getIncomingServerSession(StreamID streamID)
      Returns the incoming server session hosted by this JVM that matches the specified stream ID.
      Parameters:
      streamID - the stream ID that identifies the incoming server session hosted by this JVM.
      Returns:
      the incoming server session hosted by this JVM or null if none was found.

    • getIncomingServerSessions

      public List<IncomingServerSession> getIncomingServerSessions(String domain)
      Returns the list of sessions that were originated by a remote server. The list will be ordered chronologically. IncomingServerSession can only receive packets from the remote server but are not capable of sending packets to the remote server.
      Parameters:
      domain - the name of the remote server.
      Returns:
      the sessions that were originated by a remote server.

    • getOutgoingServerSession

      public OutgoingServerSession getOutgoingServerSession(DomainPair pair)
      Returns a session that was originated from this server to a remote server. OutgoingServerSession an only send packets to the remote server but are not capable of receiving packets from the remote server.
      Parameters:
      pair - DomainPair describing the local and remote servers.
      Returns:
      a session that was originated from this server to a remote server.

    • getOutgoingServerSessions

      public List<OutgoingServerSession> getOutgoingServerSessions(String host)

    • getSessions

      public Collection<ClientSession> getSessions(String username)
      Return all user sessions that match the definition of RoutingTable#getRoutes (notably, the sessions are 'available' / have sent initial presence).
      Parameters:
      username - The user for which to return sessions
      Returns:
      sessions for the user
      See Also:

    • getConnectionsCount

      public int getConnectionsCount(boolean onlyLocal)
      Returns number of client sessions that are connected to the server. Sessions that are authenticated and not authenticated will be included
      Parameters:
      onlyLocal - true if only sessions connected to this JVM will be considered. Otherwise count cluster wise.
      Returns:
      number of client sessions that are connected to the server.

    • getUserSessionsCount

      public int getUserSessionsCount(boolean onlyLocal)
      Returns number of client sessions that are authenticated with the server. This includes anonymous and non-anoymous users.
      Parameters:
      onlyLocal - true if only sessions connected to this JVM will be considered. Otherwise count cluster wise.
      Returns:
      number of client sessions that are authenticated with the server.

    • getIncomingServerSessionsCount

      public int getIncomingServerSessionsCount(boolean onlyLocal)
      Returns number of sessions coming from remote servers. Current implementation is only counting sessions connected to this JVM and not adding up sessions connected to other cluster nodes.
      Parameters:
      onlyLocal - true if only sessions connected to this JVM will be considered. Otherwise count cluster wise.
      Returns:
      number of sessions coming from remote servers.

    • getActiveSessionCount

      public int getActiveSessionCount(String username)
      Returns the number of sessions for a user that are available. For the count of all sessions for the user, including sessions that are just starting or closed.
      Parameters:
      username - the user.
      Returns:
      number of available sessions for a user.
      See Also:

    • getSessionCount

      public int getSessionCount(String username)

    • getComponentSessions

      public Collection<ComponentSession> getComponentSessions()
      Returns a collection with the established sessions from external components.
      Returns:
      a collection with the established sessions from external components.

    • getComponentSession

      public ComponentSession getComponentSession(String domain)
      Returns the session of the component whose domain matches the specified domain.
      Parameters:
      domain - the domain of the component session to look for.
      Returns:
      the session of the component whose domain matches the specified domain.

    • getIncomingServers

      public Collection<String> getIncomingServers()
      Returns a collection with the domain names of the remote servers that currently have an incoming server connection to this server.
      Returns:
      a collection with the domains of the remote servers that currently have an incoming server connection to this server.

    • getOutgoingServers

      public Collection<String> getOutgoingServers()
      Returns a collection with the domain names of the remote servers that currently may receive packets sent from this server.
      Returns:
      a collection with the domains of the remote servers that currently may receive packets sent from this server.

    • getFailedServers

      public Collection<String> getFailedServers()
      Returns remote domains for which the latest outgoing server-to-server connection establishment attempt failed. Entries are cleared when a subsequent outgoing attempt to the same remote domain succeeds.
      Returns:
      a collection of remote server domains.

    • getOutgoingDomainPairs

      public Collection<DomainPair> getOutgoingDomainPairs()

    • broadcast

      public void broadcast(org.xmpp.packet.Message packet)
      Broadcasts the given data to all connected sessions. Excellent for server administration messages.
      Parameters:
      packet - the packet to be broadcast.

    • userBroadcast

      public void userBroadcast(String username, org.xmpp.packet.Packet packet) throws PacketException
      Broadcasts the given data to all connected sessions for a particular user. Excellent for updating all connected resources for users such as roster pushes.
      Parameters:
      username - the user to send the boradcast to.
      packet - the packet to be broadcast.
      Throws:
      PacketException - if a packet exception occurs.

    • removeSession

      public boolean removeSession(LocalClientSession session)
      Removes a session.
      Parameters:
      session - the session.
      Returns:
      true if the requested session was successfully removed.

    • removeSession

      public boolean removeSession(ClientSession session, org.xmpp.packet.JID fullJID, boolean anonymous, boolean forceUnavailable)
      Removes a session.
      Parameters:
      session - the session or null when session is derived from fullJID.
      fullJID - the address of the session.
      anonymous - true if the authenticated user is anonymous.
      forceUnavailable - true if an unavailable presence must be created and routed.
      Returns:
      true if the requested session was successfully removed.

    • getConflictKickLimit

      public int getConflictKickLimit()

    • isPreAuthenticatedSession

      public boolean isPreAuthenticatedSession(org.xmpp.packet.JID address)
      Returns true if the specified address belongs to a preauthenticated session. Preauthenticated sessions are only available to the local cluster node when running inside a cluster.
      Parameters:
      address - the address of the session.
      Returns:
      true if the specified address belongs to a preauthenticated session.

    • setConflictKickLimit

      public void setConflictKickLimit(int limit)

    • getLocaleForSession

      public Locale getLocaleForSession(org.xmpp.packet.JID address)

    • initialize

      public void initialize(XMPPServer server)
      Description copied from class: BasicModule

      Initializes the basic module.

      Inheriting classes that choose to override this method MUST call this initialize() method before accessing BasicModule resources.

      Specified by:
      initialize in interface Module
      Overrides:
      initialize in class BasicModule
      Parameters:
      server - the server hosting this module.

    • sendServerMessage

      public void sendServerMessage(String subject, String body)
      Sends a message with a given subject and body to all the active user sessions in the server.
      Parameters:
      subject - the subject to broadcast.
      body - the body to broadcast.

    • sendServerMessage

      public void sendServerMessage(org.xmpp.packet.JID address, String subject, String body)
      Sends a message with a given subject and body to one or more user sessions related to the specified address. If address is null or the address's node is null then the message will be sent to all the user sessions. But if the address includes a node but no resource then the message will be sent to all the user sessions of the requested user (defined by the node). Finally, if the address is a full JID then the message will be sent to the session associated to the full JID. If no session is found then the message is not sent.
      Parameters:
      address - the address that defines the sessions that will receive the message.
      subject - the subject to broadcast.
      body - the body to broadcast.

    • start

      public void start() throws IllegalStateException
      Description copied from class: BasicModule

      Starts the basic module.

      Inheriting classes that choose to override this method MUST call this start() method before accessing BasicModule resources.

      Specified by:
      start in interface Module
      Overrides:
      start in class BasicModule
      Throws:
      IllegalStateException - If start is called before initialize successfully returns

    • stop

      public void stop()
      Description copied from class: BasicModule

      Stops the basic module.

      Inheriting classes that choose to override this method MUST call this stop() method before accessing BasicModule resources.

      Specified by:
      stop in interface Module
      Overrides:
      stop in class BasicModule

    • isMultipleServerConnectionsAllowed

      public boolean isMultipleServerConnectionsAllowed()
      Returns true if remote servers are allowed to have more than one connection to this server. Having more than one connection may improve number of packets that can be transfered per second. This setting only used by the server dialback mehod.

      It is highly recommended that getServerSessionTimeout() is enabled so that dead connections to this server can be easily discarded.

      Returns:
      true if remote servers are allowed to have more than one connection to this server.

    • setMultipleServerConnectionsAllowed

      public void setMultipleServerConnectionsAllowed(boolean allowed)
      Sets if remote servers are allowed to have more than one connection to this server. Having more than one connection may improve number of packets that can be transfered per second. This setting only used by the server dialback mehod.

      It is highly recommended that getServerSessionTimeout() is enabled so that dead connections to this server can be easily discarded.

      Parameters:
      allowed - true if remote servers are allowed to have more than one connection to this server.

    • setServerSessionTimeout

      public void setServerSessionTimeout(int timeout)
      Sets the number of milliseconds to elapse between clearing of idle server sessions.
      Parameters:
      timeout - the number of milliseconds to elapse between clearings.

    • getServerSessionTimeout

      public int getServerSessionTimeout()
      Returns the number of milliseconds to elapse between clearing of idle server sessions.
      Returns:
      the number of milliseconds to elapse between clearing of idle server sessions.

    • setServerSessionIdleTime

      public void setServerSessionIdleTime(int idleTime)

    • getServerSessionIdleTime

      public int getServerSessionIdleTime()

    • setSessionDetachTime

      public void setSessionDetachTime(int idleTime)

    • getSessionDetachTime

      public int getSessionDetachTime()

    • getSessionInfoCache

      public Cache<String,ClientSessionInfo> getSessionInfoCache()

    • joinedCluster

      public void joinedCluster()
      Description copied from interface: ClusterEventListener
      Notification event indicating that this JVM is now part of a cluster. At this point the XMPPServer.getNodeID() holds the new nodeID value.

      When joining the cluster as the senior cluster member the ClusterEventListener.markedAsSeniorClusterMember() event will be sent right after this event.

      At this point the CacheFactory holds clustered caches. That means that modifications to the caches will be reflected in the cluster. The clustered caches were just obtained from the cluster and no local cached data was automatically moved.

      It is generally advisable that implementations of this method:
      • enrich clustered cache data, by (re)adding data from this JVM/cluster node to relevant caches
      • invoke applicable event listeners, to reflect changes in availability of data on other cluster nodes.
      Specified by:
      joinedCluster in interface ClusterEventListener

    • joinedCluster

      public void joinedCluster(byte[] nodeID)
      Description copied from interface: ClusterEventListener
      Notification event indicating that another JVM is now part of a cluster.

      At this point the CacheFactory of the new node holds clustered caches. That means that modifications to the caches of this JVM will be reflected in the cluster and in particular in the new node.

      Specified by:
      joinedCluster in interface ClusterEventListener
      Parameters:
      nodeID - ID of the node that joined the cluster.

    • leftCluster

      public void leftCluster()
      Description copied from interface: ClusterEventListener
      Notification event indicating that this JVM is no longer part of the cluster. This could happen when disabling clustering support, removing the enterprise plugin that provides clustering support or connection to cluster got lost.

      Moreover, if we were in a "split brain" scenario (ie. separated cluster islands) and the island were this JVM belonged was marked as "old" then all nodes of that island will get the left cluster event and joined cluster events. That means that caches will be reset and thus will need to be repopulated again with fresh data from this JVM. This also includes the case where this JVM was the senior cluster member and when the islands met again then this JVM stopped being the senior member.

      At this point the CacheFactory holds local caches. That means that modifications to the caches will only affect this JVM. It is generally advisable that implementations of this method:

      • restore relevant caches content, by repopulating the caches with data from this JVM/cluster node
      • invoke applicable event listeners, to reflect changes in availability of data on other cluster nodes.
      Specified by:
      leftCluster in interface ClusterEventListener

    • leftCluster

      public void leftCluster(byte[] nodeID)
      Description copied from interface: ClusterEventListener
      Notification event indicating that another JVM is no longer part of the cluster. This could happen when disabling clustering support, removing the enterprise plugin that provides clustering support or connection to cluster got lost.

      Moreover, if we were in a "split brain" scenario (ie. separated cluster islands) and the island were the other JVM belonged was marked as "old" then all nodes of that island will get the left cluster event and joined cluster events. That means that caches will be reset and thus will need to be repopulated again with fresh data from this JVM. This also includes the case where the other JVM was the senior cluster member and when the islands met again then the other JVM stopped being the senior member.

      At this point the CacheFactory of the leaving node holds local caches. That means that modifications to the caches of this JVM will not affect the leaving node but other cluster members. It is generally advisable that implementations of this method invoke applicable event listeners, to reflect changes in availability of data (related to the node that left). Often, this action is orchestrated by only one of the remaining cluster nodes: the senior member.

      Specified by:
      leftCluster in interface ClusterEventListener
      Parameters:
      nodeID - ID of the node that is left the cluster.

    • markedAsSeniorClusterMember

      public void markedAsSeniorClusterMember()
      Description copied from interface: ClusterEventListener
      Notification event indicating that this JVM is now the senior cluster member. This could either happen when initially joining the cluster or when the senior cluster member node left the cluster and this JVM was marked as the new senior cluster member.

      Moreover, in the case of a "split brain" scenario (ie. separated cluster islands) each island will have its own senior cluster member. However, when the islands meet again there could only be one senior cluster member so one of the senior cluster members will stop playing that role. When that happens the JVM no longer playing that role will receive the ClusterEventListener.leftCluster() and ClusterEventListener.joinedCluster() events.

      Specified by:
      markedAsSeniorClusterMember in interface ClusterEventListener

    • clusteringStateConsistencyReportForIncomingServerSessionInfos

      public com.google.common.collect.Multimap<String,String> clusteringStateConsistencyReportForIncomingServerSessionInfos()
      Verifies that incomingServerSessionInfoCache, {@link #localSessionManager#getIncomingServerSessions()} and incomingServerSessionInfoByClusterNode are in a consistent state. Note that this operation can be costly in terms of resource usage. Use with caution in large / busy systems. The returned multi-map can contain up to four keys: info, fail, pass, data. All entry values are a human readable description of a checked characteristic. When the state is consistent, no 'fail' entries will be returned.
      Returns:
      A consistency state report.
      See Also:
      • which is the cache that is used tho share data with other cluster nodes.
      • which holds content added to the caches by the local cluster node.
      • which holds content added to the caches by cluster nodes other than the local node.

    • clusteringStateConsistencyReportForSessionInfos

      public com.google.common.collect.Multimap<String,String> clusteringStateConsistencyReportForSessionInfos()
      Verifies that sessionInfoCache, {@link #routingTable#getClientsRoutes(boolean)} and sessionInfoKeysByClusterNode are in a consistent state. Note that this operation can be costly in terms of resource usage. Use with caution in large / busy systems. The returned multi-map can contain up to four keys: info, fail, pass, data. All entry values are a human readable description of a checked characteristic. When the state is consistent, no 'fail' entries will be returned.
      Returns:
      A consistency state report.
      See Also: