Overview | Package | Class | Tree | Deprecated | Index | Help
| Openfire 3.4.3 Javadoc
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## 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
`static String` | `CM_CACHE_NAME`
`static String` | `COMPONENT_SESSION_CACHE_NAME`
`static String` | `ISS_CACHE_NAME`
`static int` | `NEVER_KICK`

Constructor Summary
`SessionManager()`

Method Summary
`void` | `addSession(LocalClientSession session)` Add a new session to be managed.
`void` | `broadcast(Message packet)` Broadcasts the given data to all connected sessions.
`void` | `broadcastPresenceToOtherResources(JID originatingResource, 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)`
`LocalClientSession` | `createClientSession(Connection conn)` Creates a new `ClientSession`.
`LocalClientSession` | `createClientSession(Connection conn, StreamID id)` Creates a new `ClientSession` with the specified streamID.
`LocalComponentSession` | `createComponentSession(JID address, Connection conn)`
`LocalIncomingServerSession` | `createIncomingServerSession(Connection conn, StreamID id)` Creates a session for a remote server.
`LocalConnectionMultiplexerSession` | `createMultiplexerSession(Connection conn, 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(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(String 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<String>` | `getOutgoingServers()` Returns a collection with the hostnames of the remote servers that currently may receive packets sent from this server.
`OutgoingServerSession` | `getOutgoingServerSession(String hostname)` Returns a session that was originated from this server to a remote server.
`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(JID from)` Returns the session responsible for this JID data.
`int` | `getSessionCount(String username)`
`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(String 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(JID address)`
`boolean` | `isAnonymousRoute(String username)`
`boolean` | `isMultipleServerConnectionsAllowed()` Returns true if remote servers are allowed to have more than one connection to this server.
`boolean` | `isPreAuthenticatedSession(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.
`boolean` | `removeSession(ClientSession session, JID fullJID, boolean anonymous, boolean forceUnavailable)` Removes a session.
`boolean` | `removeSession(LocalClientSession session)` Removes a session.
`void` | `sendServerMessage(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)` 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` | `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, 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

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

### getConnectionMultiplexerSession

    public ConnectionMultiplexerSession getConnectionMultiplexerSession(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,
                                                                      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)

  Creates a new `ClientSession`. The new Client session will have a newly created stream ID.

  Parameters:
    `conn` - the connection to create the session from.
  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.

### createClientHttpSession

    public HttpSession createClientHttpSession(long rid,
                                               InetAddress address,
                                               StreamID id)
                                        throws UnauthorizedException

  Throws:
    `UnauthorizedException`

### createComponentSession

    public LocalComponentSession createComponentSession(JID address,
                                                        Connection conn)
                                                 throws UnauthorizedException

  Throws:
    `UnauthorizedException`

### createIncomingServerSession

    public LocalIncomingServerSession createIncomingServerSession(Connection conn,
                                                                  StreamID id)
                                                           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(String 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)

  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.

### broadcastPresenceToOtherResources

    public void broadcastPresenceToOtherResources(JID originatingResource,
                                                  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 receieved 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(JID address)

### isActiveRoute

    public boolean isActiveRoute(String username,
                                 String resource)

### getSession

    public ClientSession getSession(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(String 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(String hostname)

  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:
    `hostname` - the name of the remote server.
  Returns:
    a session that was originated from this server to a remote server.

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

### broadcast

    public void broadcast(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,
                              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,
                                 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(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(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()

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

Overview | Package | Class | Tree | Deprecated | Index | Help
| Openfire 3.4.3 Javadoc
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2003-2007 Jive Software.