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 Summary

Fields

Modifier and Type	Field and Description
static String	C2S_INFO_CACHE_NAME
static String	CM_CACHE_NAME
static String	COMPONENT_SESSION_CACHE_NAME
static String	ISS_CACHE_NAME
static int	NEVER_KICK

Constructor Summary

Constructors

Constructor and Description
SessionManager()

Method Summary

Modifier and Type	Method and Description
void	addDetached(LocalSession localSession) Record a session as being detached (ie, has no connection).
void	addSession(LocalClientSession session) Add a new session to be managed.
void	broadcast(org.xmpp.packet.Message packet) Broadcasts the given data to all connected sessions.
void	broadcastPresenceToOtherResources(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 (if any).
void	changePriority(LocalClientSession session, int oldPriority) Change the priority of a session, that was already available, associated with the sender.
HttpSession	createClientHttpSession(long rid, InetAddress address, StreamID id, HttpConnection connection, Locale language) Creates a new ClientSession with the specified streamID.
LocalClientSession	createClientSession(Connection conn, Locale language) Creates a new ClientSession.
LocalClientSession	createClientSession(Connection conn, StreamID id) Creates a new ClientSession with the specified streamID.
LocalClientSession	createClientSession(Connection conn, StreamID id, Locale language) Creates a new ClientSession with the specified streamID.
LocalComponentSession	createComponentSession(org.xmpp.packet.JID address, Connection conn)
LocalIncomingServerSession	createIncomingServerSession(Connection conn, StreamID id, String fromDomain) Creates a session for a remote server.
LocalConnectionMultiplexerSession	createMultiplexerSession(Connection conn, org.xmpp.packet.JID address) Creates a new ConnectionMultiplexerSession.
int	getActiveSessionCount(String username) Returns the number of sessions for a user that are available.
ComponentSession	getComponentSession(String domain) Returns the session of the component whose domain matches the specified domain.
Collection<ComponentSession>	getComponentSessions() Returns a collection with the established sessions from external components.
int	getConflictKickLimit()
ConnectionMultiplexerSession	getConnectionMultiplexerSession(org.xmpp.packet.JID address) Returns the session originated from the specified address or null if none was found.
List<ConnectionMultiplexerSession>	getConnectionMultiplexerSessions() Returns all sessions originated from connection managers.
List<ConnectionMultiplexerSession>	getConnectionMultiplexerSessions(String domain) Returns a collection with all the sessions originated from the connection manager whose domain matches the specified domain.
int	getConnectionsCount(boolean onlyLocal) Returns number of client sessions that are connected to the server.
Collection<String>	getIncomingServers() Returns a collection with the hostnames of the remote servers that currently have an incoming server connection to this server.
LocalIncomingServerSession	getIncomingServerSession(StreamID streamID) Returns the incoming server session hosted by this JVM that matches the specified stream ID.
List<IncomingServerSession>	getIncomingServerSessions(String hostname) Returns the list of sessions that were originated by a remote server.
int	getIncomingServerSessionsCount(boolean onlyLocal) Returns number of sessions coming from remote servers.
static SessionManager	getInstance() Returns the instance of SessionManagerImpl being used by the XMPPServer.
Collection<DomainPair>	getOutgoingDomainPairs()
Collection<String>	getOutgoingServers() Returns a collection with the hostnames of the remote servers that currently may receive packets sent from this server.
OutgoingServerSession	getOutgoingServerSession(DomainPair pair) Returns a session that was originated from this server to a remote server.
List<OutgoingServerSession>	getOutgoingServerSessions(String host)
Collection<String>	getPreAuthenticatedKeys() Returns the temporary keys used by the sessions that has not been authenticated yet.
int	getServerSessionIdleTime()
int	getServerSessionTimeout() Returns the number of milliseconds to elapse between clearing of idle server sessions.
ClientSession	getSession(org.xmpp.packet.JID from) Returns the session responsible for this JID data.
int	getSessionCount(String username)
int	getSessionDetachTime()
Cache<String,ClientSessionInfo>	getSessionInfoCache()
Collection<ClientSession>	getSessions() Returns a list that contains all authenticated client sessions connected to the server.
Collection<ClientSession>	getSessions(SessionResultFilter filter)
Collection<ClientSession>	getSessions(String username)
int	getUserSessionsCount(boolean onlyLocal) Returns number of client sessions that are authenticated with the server.
Collection<String>	getValidatedDomains(StreamID streamID) Returns a collection with all the domains, subdomains and virtual hosts that where validated.
void	initialize(XMPPServer server) Initializes the basic module.
boolean	isActiveRoute(String username, String resource)
boolean	isAnonymousRoute(org.xmpp.packet.JID address)
boolean	isAnonymousRoute(String username)
boolean	isMultipleServerConnectionsAllowed() Returns true if remote servers are allowed to have more than one connection to this server.
static boolean	isOtherResourcePresenceEnabled() Returns true if the session should broadcast presences to all other resources for the current client.
boolean	isPreAuthenticatedSession(org.xmpp.packet.JID address) Returns true if the specified address belongs to a preauthenticated session.
void	joinedCluster() Notification event indicating that this JVM is now part of a cluster.
void	joinedCluster(byte[] nodeID) Notification event indicating that another JVM is now part of a cluster.
void	leftCluster() Notification event indicating that this JVM is no longer part of the cluster.
void	leftCluster(byte[] nodeID) Notification event indicating that another JVM is no longer part of the cluster.
void	markedAsSeniorClusterMember() Notification event indicating that this JVM is now the senior cluster member.
StreamID	nextStreamID() Returns a randomly created ID to be used in a stream element.
void	outgoingServerSessionCreated(LocalOutgoingServerSession session) Notification message that a new OutgoingServerSession has been created.
void	registerIncomingServerSession(String hostname, LocalIncomingServerSession session) Registers that a server session originated by a remote server is hosting a given hostname.
void	removeDetached(LocalSession localSession) Remove a session as being detached.
boolean	removeSession(ClientSession session, org.xmpp.packet.JID fullJID, boolean anonymous, boolean forceUnavailable) Removes a session.
boolean	removeSession(LocalClientSession session) Removes a session.
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.
void	sendServerMessage(String subject, String body) Sends a message with a given subject and body to all the active user sessions in the server.
void	sessionAvailable(LocalClientSession session, org.xmpp.packet.Presence presence) Notification message sent when a client sent an available presence for the session.
void	sessionUnavailable(LocalClientSession session) Notification message sent when a client sent an unavailable presence for the session.
void	setConflictKickLimit(int limit)
void	setMultipleServerConnectionsAllowed(boolean allowed) Sets if remote servers are allowed to have more than one connection to this server.
void	setServerSessionIdleTime(int idleTime)
void	setServerSessionTimeout(int timeout) Sets the number of milliseconds to elapse between clearing of idle server sessions.
void	setSessionDetachTime(int idleTime)
void	start() Starts the basic module.
void	stop() Stops the basic module.
void	unregisterIncomingServerSession(String hostname, IncomingServerSession session) Unregisters the specified remote server session originiated by the specified remote server.
void	userBroadcast(String username, org.xmpp.packet.Packet packet) Broadcasts the given data to all connected sessions for a particular user.

Methods inherited from class org.jivesoftware.openfire.container.BasicModule

destroy, getName

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

COMPONENT_SESSION_CACHE_NAME

public static final String COMPONENT_SESSION_CACHE_NAME

See Also:

Constant Field Values

CM_CACHE_NAME

public static final String CM_CACHE_NAME

See Also:

Constant Field Values

ISS_CACHE_NAME

public static final String ISS_CACHE_NAME

See Also:

Constant Field Values

C2S_INFO_CACHE_NAME

public static final String C2S_INFO_CACHE_NAME

See Also:

Constant Field Values

NEVER_KICK

public static final int NEVER_KICK

See Also:

Constant Field Values

Constructor Detail

SessionManager

public SessionManager()

Method Detail

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.

removeDetached

public void 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(long rid,
                                           InetAddress address,
                                           StreamID id,
                                           HttpConnection connection,
                                           Locale language)
                                    throws UnauthorizedException

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.

Returns:

a newly created session.

Throws:

UnauthorizedException

createComponentSession

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

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.

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 hostname,
                                          LocalIncomingServerSession session)

Registers that a server session originated by a remote server is hosting a given hostname. Notice that the remote server may be hosting several subdomains as well as virtual hosts so the same IncomingServerSession may be associated with many keys. 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:

hostname - the hostname that is being served by the remote server.

session - the incoming server session to the remote server.

unregisterIncomingServerSession

public void unregisterIncomingServerSession(String hostname,
                                            IncomingServerSession session)

Unregisters the specified remote server session originiated by the specified remote server.

Parameters:

hostname - the hostname that is being served by the remote server.

session - the session to unregiser.

getValidatedDomains

public Collection<String> getValidatedDomains(StreamID streamID)

Returns a collection with all the domains, subdomains and virtual hosts that where validated. The remote server is allowed to send packets from any of these domains, subdomains and virtual hosts.

Content is stored in a clustered cache so that even in the case of the node hosting the sessions is lost we can still have access to this info to be able to perform proper clean up logic.

Parameters:

streamID - id that uniquely identifies the session.

Returns:

domains, subdomains and virtual hosts that where validated.

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

broadcastPresenceToOtherResources

public void broadcastPresenceToOtherResources(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 (if any).

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

isAnonymousRoute

public boolean isAnonymousRoute(String username)

isAnonymousRoute

public boolean isAnonymousRoute(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()

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

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:

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

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:

getConnectionsCount(boolean)

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 hostnames of the remote servers that currently have an incoming server connection to this server.

Returns:

a collection with the hostnames of the remote servers that currently have an incoming server connection to this server.

getOutgoingServers

public Collection<String> getOutgoingServers()

Returns a collection with the hostnames of the remote servers that currently may receive packets sent from this server.

Returns:

a collection with the hostnames of the remote servers that currently may receive packets sent from this server.

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

getPreAuthenticatedKeys

public Collection<String> getPreAuthenticatedKeys()

Returns the temporary keys used by the sessions that has not been authenticated yet. This is an utility method useful for debugging situations.

Returns:

the temporary keys used by the sessions that has not been authenticated yet.

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

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 requeted 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.

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.

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.

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