Package org.cometd.server

Class LocalSessionImpl

java.lang.Object

org.cometd.common.AbstractClientSession

org.cometd.server.LocalSessionImpl

All Implemented Interfaces:

ClientSession, LocalSession, Session, org.eclipse.jetty.util.component.Dumpable

public class LocalSessionImpl
extends AbstractClientSession
implements LocalSession

A LocalSession implementation.

This LocalSession implementation communicates with its ServerSession counterpart without any serialization.

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
protected class	LocalSessionImpl.LocalChannel	A channel scoped to this LocalSession.

Nested classes/interfaces inherited from class org.cometd.common.AbstractClientSession

AbstractClientSession.AbstractSessionChannel

Nested classes/interfaces inherited from interface org.cometd.bayeux.client.ClientSession

ClientSession.Extension, ClientSession.MessageListener

Nested classes/interfaces inherited from interface org.eclipse.jetty.util.component.Dumpable

org.eclipse.jetty.util.component.Dumpable.DumpableContainer

Field Summary

Fields inherited from interface org.eclipse.jetty.util.component.Dumpable

KEY

Constructor Summary

Constructors

Constructor	Description
LocalSessionImpl(BayeuxServerImpl bayeux, String idHint)

Method Summary

Modifier and Type	Method	Description
void	disconnect(ClientSession.MessageListener callback)	Disconnects this session, ending the link between the client and the server peers.
String	getId()	The clientId of the session.
ServerSession	getServerSession()
void	handshake(Map<String,Object> template, ClientSession.MessageListener callback)	Initiates the bayeux protocol handshake with the server(s).
boolean	isConnected()	A connected session is a session where the link between the client and the server has been established.
boolean	isHandshook()	A handshook session is a session where the handshake has successfully completed
protected AbstractClientSession.AbstractSessionChannel	newChannel(ChannelId channelId)
protected ChannelId	newChannelId(String channelId)
protected ServerMessage.Mutable	newMessage()
void	receive(Message.Mutable message, Promise<Void> promise)	Receives a message (from the server) and process it.
protected void	send(Message.Mutable message)
protected void	send(ServerSessionImpl session, ServerMessage.Mutable message)	Enqueues or sends a message to the server.
protected void	sendBatch()
String	toString()

Methods inherited from class org.cometd.common.AbstractClientSession

addExtension, batch, dump, endBatch, extendIncoming, extendOutgoing, getAttribute, getAttributeNames, getChannel, getChannel, getChannels, getExtensions, isBatching, newMessageId, notifyCallback, notifyListeners, registerCallback, registerSubscriber, remoteCall, removeAttribute, removeExtension, resetSubscriptions, setAttribute, startBatch, unregisterCallback, unregisterSubscriber

Methods inherited from class java.lang.Object

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

Methods inherited from interface org.cometd.bayeux.client.ClientSession

addExtension, disconnect, disconnect, getChannel, getExtensions, handshake, handshake, handshake, remoteCall, removeExtension

Methods inherited from interface org.eclipse.jetty.util.component.Dumpable

dump, dumpSelf

Methods inherited from interface org.cometd.bayeux.Session

batch, endBatch, getAttribute, getAttributeNames, removeAttribute, setAttribute, startBatch

Constructor Detail

LocalSessionImpl

public LocalSessionImpl(BayeuxServerImpl bayeux,
                        String idHint)

Method Detail

receive

public void receive(Message.Mutable message,
                    Promise<Void> promise)

Description copied from class: AbstractClientSession

Receives a message (from the server) and process it.

Processing the message involves calling the receive extensions and the channel listeners.

Overrides:

receive in class AbstractClientSession

Parameters:

message - the message received.

promise - the promise notified of the receive processing

newChannel

protected AbstractClientSession.AbstractSessionChannel newChannel(ChannelId channelId)

Specified by:

newChannel in class AbstractClientSession

newChannelId

protected ChannelId newChannelId(String channelId)

Specified by:

newChannelId in class AbstractClientSession

sendBatch

protected void sendBatch()

Specified by:

sendBatch in class AbstractClientSession

getServerSession

public ServerSession getServerSession()

Specified by:

getServerSession in interface LocalSession

Returns:

the associated ServerSession

handshake

public void handshake(Map<String,Object> template,
                      ClientSession.MessageListener callback)

Description copied from interface: ClientSession

Initiates the bayeux protocol handshake with the server(s).

The handshake initiated by this method is asynchronous and does not wait for the handshake response.

Specified by:

handshake in interface ClientSession

Parameters:

template - additional fields to add to the handshake message.

callback - the message listener to notify of the handshake result

disconnect

public void disconnect(ClientSession.MessageListener callback)

Description copied from interface: ClientSession

Disconnects this session, ending the link between the client and the server peers.

Specified by:

disconnect in interface ClientSession

Parameters:

callback - the message listener to notify of the disconnect result

getId

public String getId()

Description copied from interface: Session

The clientId of the session.

This would more correctly be called a "sessionId", but for backwards compatibility with the Bayeux protocol, it is a field called "clientId" that identifies a session.

Specified by:

getId in interface Session

Returns:

the id of this session

isConnected

public boolean isConnected()

Description copied from interface: Session

A connected session is a session where the link between the client and the server has been established.

Specified by:

isConnected in interface Session

Returns:

whether the session is connected

See Also:

Session.disconnect()

isHandshook

public boolean isHandshook()

Description copied from interface: Session

A handshook session is a session where the handshake has successfully completed

Specified by:

isHandshook in interface Session

Returns:

whether the session is handshook

toString

public String toString()

Overrides:

toString in class Object

send

protected void send(Message.Mutable message)

Specified by:

send in class AbstractClientSession

send

protected void send(ServerSessionImpl session,
                    ServerMessage.Mutable message)

Enqueues or sends a message to the server.

This method will either enqueue the message, if this session is batching, or perform the send immediately.

Parameters:

session - The ServerSession to send as. This normally the current server session, but during handshake it is a proposed server session.

message - The message to send.

newMessage

protected ServerMessage.Mutable newMessage()

Overrides:

newMessage in class AbstractClientSession