## org.mortbay.cometd
Class AbstractBayeux

    java.lang.Object
      org.mortbay.cometd.MessagePool
          org.mortbay.cometd.AbstractBayeux

All Implemented Interfaces:
  org.cometd.Bayeux

Direct Known Subclasses:
  ContinuationBayeux

    public abstract class AbstractBayeux

extends MessagePool
implements org.cometd.Bayeux

Author:
  gregw, aabeling: added JSONP transport

Nested Class Summary
`protected class` `AbstractBayeux.ConnectHandler`
`static class` `AbstractBayeux.DefaultPolicy`
`protected class` `AbstractBayeux.DisconnectHandler`
`protected class` `AbstractBayeux.Handler`
`protected class` `AbstractBayeux.HandshakeHandler`
`protected class` `AbstractBayeux.MetaPublishHandler`
`protected class` `AbstractBayeux.PingHandler`
`protected class` `AbstractBayeux.PublishHandler`
`protected class` `AbstractBayeux.ServiceChannel`
`protected class` `AbstractBayeux.SubscribeHandler`
`protected class` `AbstractBayeux.UnsubscribeHandler`

Field Summary
`protected JSON.Literal` `_advice`
`protected int` `_adviceVersion`
`protected java.util.concurrent.ConcurrentHashMap<java.lang.String,java.util.List<java.lang.String>>` `_browser2client`
`protected java.util.concurrent.ConcurrentHashMap<java.lang.String,ChannelId>` `_channelIdCache`
`protected java.util.List<org.cometd.ChannelBayeuxListener>` `_channelListeners`
`protected java.util.List<org.cometd.ClientBayeuxListener>` `_clientListeners`
`protected org.cometd.Extension[]` `_extensions`
`protected java.lang.Object` `_handshakeAdvice`
`protected boolean` `_initialized`
`protected long` `_interval`
`protected int` `_logLevel`
`protected int` `_maxClientQueue`
`protected long` `_maxInterval`
`protected int` `_maxLazyLatency`
`protected AbstractBayeux.Handler` `_metaPublishHandler`
`protected JSON.Literal` `_multiFrameAdvice`
`protected int` `_multiFrameInterval`
`protected AbstractBayeux.Handler` `_publishHandler`
`protected java.util.Random` `_random`
`protected java.lang.ThreadLocal<javax.servlet.http.HttpServletRequest>` `_request`
`protected boolean` `_requestAvailable`
`protected org.cometd.SecurityPolicy` `_securityPolicy`
`protected long` `_timeout`
`protected JSON.Literal` `_transports`
`static ChannelId` `META_CLIENT_ID`
`static ChannelId` `META_CONNECT_ID`
`static ChannelId` `META_DISCONNECT_ID`
`static ChannelId` `META_HANDSHAKE_ID`
`static ChannelId` `META_ID`
`static ChannelId` `META_PING_ID`
`static ChannelId` `META_STATUS_ID`
`static ChannelId` `META_SUBSCRIBE_ID`
`static ChannelId` `META_UNSUBSCRIBE_ID`

Fields inherited from interface org.cometd.Bayeux

`ADVICE_FIELD, ATTRIBUTE, CHANNEL_FIELD, CLIENT_FIELD, CONNECTION_TYPE_FIELD, DATA_FIELD, ERROR_FIELD, EXT_FIELD, HANDSHAKE_RESPONSE, ID_FIELD, INTERVAL_FIELD, JSON_COMMENT_FILTERED_FIELD, JSON_CONTENT_TYPE, JSONP_DEFAULT_NAME, JSONP_PARAMETER, MESSAGE_PARAMETER, META, META_CLIENT, META_CONNECT, META_DISCONNECT, META_HANDSHAKE, META_PING, META_SLASH, META_STATUS, META_SUBSCRIBE, META_UNSUBSCRIBE, MIN_VERSION_FIELD, NONE_RESPONSE, RECONNECT_FIELD, RETRY_RESPONSE, SERVICE, SERVICE_SLASH, SUBSCRIPTION_FIELD, SUCCESSFUL_FIELD, SUPPORTED_CONNECTION_TYPES_FIELD, TIMESTAMP_FIELD, TRANSPORT_CALLBACK_POLL, TRANSPORT_FIELD, TRANSPORT_FLASH, TRANSPORT_IFRAME, TRANSPORT_LONG_POLL, VERSION_FIELD`

Constructor Summary
`protected` `AbstractBayeux()`

Method Summary
`protected void` `addChannel(ChannelImpl channel)`
`protected void` `addClient(ClientImpl client, java.lang.String idPrefix)`
`void` `addExtension(org.cometd.Extension ext)`
`void` `addListener(org.cometd.BayeuxListener listener)`
`protected void` `doPublish(ChannelId to, org.cometd.Client from, java.lang.Object data, java.lang.String msgId, boolean lazy)` Publish data to a channel.
`protected org.cometd.Message` `extendRcv(ClientImpl from, org.cometd.Message message)`
`protected org.cometd.Message` `extendRcvMeta(ClientImpl from, org.cometd.Message message)`
`protected org.cometd.Message` `extendSendBayeux(org.cometd.Client from, org.cometd.Message message)`
`org.cometd.Message` `extendSendClient(org.cometd.Client from, ClientImpl to, org.cometd.Message message)`
`org.cometd.Message` `extendSendMeta(ClientImpl from, org.cometd.Message message)`
`JSON.Literal` `getAdvice()`
`ChannelImpl` `getChannel(ChannelId id)`
`ChannelImpl` `getChannel(java.lang.String id)`
`org.cometd.Channel` `getChannel(java.lang.String id, boolean create)`
`int` `getChannelCount()`
`ChannelId` `getChannelId(java.lang.String id)`
`int` `getChannelIdCacheLimit()`
`java.util.Collection<org.cometd.Channel>` `getChannels()`
`org.cometd.Client` `getClient(java.lang.String client_id)`
`int` `getClientCount()`
`java.util.Set<java.lang.String>` `getClientIDs()`
`java.util.Collection<org.cometd.Client>` `getClients()`
`javax.servlet.http.HttpServletRequest` `getCurrentRequest()`
`long` `getInterval()`
`int` `getLogLevel()`
`int` `getMaxClientQueue()`
`long` `getMaxInterval()`
`int` `getMaxLazyLatency()`
`int` `getMultiFrameInterval()`
`org.cometd.SecurityPolicy` `getSecurityPolicy()`
`long` `getTimeout()`
`java.lang.String` `handle(ClientImpl client, Transport transport, org.cometd.Message message)` Handle a Bayeux message.
`boolean` `hasChannel(java.lang.String id)`
`boolean` `hasClient(java.lang.String clientId)`
`protected void` `initialize(javax.servlet.ServletContext context)`
`boolean` `isDirectDeliver()`
`boolean` `isInitialized()`
`boolean` `isJSONCommented()` Deprecated.
`boolean` `isLogDebug()`
`boolean` `isLogInfo()`
`boolean` `isRequestAvailable()`
`void` `logDebug(java.lang.String message)`
`void` `logDebug(java.lang.String message, java.lang.Throwable th)`
`void` `logInfo(java.lang.String message)`
`void` `logWarn(java.lang.String message)`
`void` `logWarn(java.lang.String message, java.lang.Throwable th)`
`org.cometd.Client` `newClient(java.lang.String idPrefix)`
`protected java.lang.String` `newClientId(long variation, java.lang.String idPrefix)`
`abstract ClientImpl` `newRemoteClient()`
`Transport` `newTransport(ClientImpl client, java.util.Map<?,?> message)` Create new transport object for a bayeux message
`boolean` `removeChannel(ChannelImpl channel)`
`org.cometd.Channel` `removeChannel(java.lang.String channelId)`
`org.cometd.Client` `removeClient(java.lang.String client_id)`
`void` `removeExtension(org.cometd.Extension ext)`
`void` `removeListener(org.cometd.BayeuxListener listener)`
`void` `setAdvice(JSON.Literal advice)`
`void` `setChannelIdCacheLimit(int channelIdCacheLimit)` Sets the cache limit for `ChannelId`s: use -1 to disable the cache, 0 for an unlimited cache, and any positive value for the limit after which the cache is cleared.
`void` `setDirectDeliver(boolean directDeliver)` Deprecated.
`void` `setInterval(long ms)`
`void` `setJSONCommented(boolean commented)`
`void` `setLogLevel(int logLevel)`
`void` `setMaxClientQueue(int size)`
`void` `setMaxInterval(long ms)`
`void` `setMaxLazyLatency(int ms)`
`void` `setMultiFrameInterval(int multiFrameInterval)` The time a client should delay between reconnects when multiple connections from the same browser are detected.
`void` `setRequestAvailable(boolean requestAvailable)`
`void` `setSecurityPolicy(org.cometd.SecurityPolicy securityPolicy)`
`void` `setTimeout(long ms)`

Methods inherited from class org.mortbay.cometd.MessagePool
`getBatchJSON, getJSON, getMsgJSON, newMessage, newMessage, parse, parse, parseTo, setBatchJSON, setJSON, setMsgJSON, toString`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

Field Detail

### META_ID

    public static final ChannelId META_ID

### META_CONNECT_ID

    public static final ChannelId META_CONNECT_ID

### META_CLIENT_ID

    public static final ChannelId META_CLIENT_ID

### META_DISCONNECT_ID

    public static final ChannelId META_DISCONNECT_ID

### META_HANDSHAKE_ID

    public static final ChannelId META_HANDSHAKE_ID

### META_PING_ID

    public static final ChannelId META_PING_ID

### META_STATUS_ID

    public static final ChannelId META_STATUS_ID

### META_SUBSCRIBE_ID

    public static final ChannelId META_SUBSCRIBE_ID

### META_UNSUBSCRIBE_ID

    public static final ChannelId META_UNSUBSCRIBE_ID

### _channelIdCache

    protected final java.util.concurrent.ConcurrentHashMap<java.lang.String,ChannelId> _channelIdCache

### _browser2client

    protected final java.util.concurrent.ConcurrentHashMap<java.lang.String,java.util.List<java.lang.String>> _browser2client

### _request

    protected final java.lang.ThreadLocal<javax.servlet.http.HttpServletRequest> _request

### _clientListeners

    protected final java.util.List<org.cometd.ClientBayeuxListener> _clientListeners

### _channelListeners

    protected final java.util.List<org.cometd.ChannelBayeuxListener> _channelListeners

### _publishHandler

    protected final AbstractBayeux.Handler _publishHandler

### _metaPublishHandler

    protected final AbstractBayeux.Handler _metaPublishHandler

### _securityPolicy

    protected org.cometd.SecurityPolicy _securityPolicy

### _advice

    protected JSON.Literal _advice

### _multiFrameAdvice

    protected JSON.Literal _multiFrameAdvice

### _adviceVersion

    protected int _adviceVersion

### _handshakeAdvice

    protected java.lang.Object _handshakeAdvice

### _logLevel

    protected int _logLevel

### _timeout

    protected long _timeout

### _interval

    protected long _interval

### _maxInterval

    protected long _maxInterval

### _initialized

    protected boolean _initialized

### _multiFrameInterval

    protected int _multiFrameInterval

### _requestAvailable

    protected boolean _requestAvailable

### _random

    protected java.util.Random _random

### _maxClientQueue

    protected int _maxClientQueue

### _extensions

    protected org.cometd.Extension[] _extensions

### _transports

    protected JSON.Literal _transports

### _maxLazyLatency

    protected int _maxLazyLatency

Constructor Detail

### AbstractBayeux

    protected AbstractBayeux()

Method Detail

### addExtension

    public void addExtension(org.cometd.Extension ext)

  Specified by:
    `addExtension` in interface `org.cometd.Bayeux`

### removeExtension

    public void removeExtension(org.cometd.Extension ext)

  Specified by:
    `removeExtension` in interface `org.cometd.Bayeux`

### getChannel

    public ChannelImpl getChannel(ChannelId id)

  Parameters:
    `id` - the channel id
  Returns:
    the ChannelImpl instance with the given id

### getChannel

    public ChannelImpl getChannel(java.lang.String id)

### getChannel

    public org.cometd.Channel getChannel(java.lang.String id,
                                         boolean create)

  Specified by:
    `getChannel` in interface `org.cometd.Bayeux`

### getChannelId

    public ChannelId getChannelId(java.lang.String id)

### getClient

    public org.cometd.Client getClient(java.lang.String client_id)

  Specified by:
    `getClient` in interface `org.cometd.Bayeux`

### getClientIDs

    public java.util.Set<java.lang.String> getClientIDs()

### getMaxInterval

    public long getMaxInterval()

  Returns:
    The maximum time in ms to wait between polls before timing out a client

### getLogLevel

    public int getLogLevel()

  Returns:
    the logLevel. 0=none, 1=info, 2=debug

### getSecurityPolicy

    public org.cometd.SecurityPolicy getSecurityPolicy()

  Specified by:
    `getSecurityPolicy` in interface `org.cometd.Bayeux`

### getTimeout

    public long getTimeout()

### getInterval

    public long getInterval()

### isDirectDeliver

    public boolean isDirectDeliver()

  Returns:
    true if published messages are directly delivered to subscribers. False if a new message is to be created that holds only supported fields.

### setDirectDeliver

    public void setDirectDeliver(boolean directDeliver)

  Deprecated.

  Parameters:
    `directDeliver` - true if published messages are directly delivered to subscribers. False if a new message is to be created that holds only supported fields.

### handle

    public java.lang.String handle(ClientImpl client,
                                   Transport transport,
                                   org.cometd.Message message)
                            throws java.io.IOException

  Handle a Bayeux message. This is normally only called by the bayeux servlet or a test harness.

  Parameters:
    `client` - The client if known
    `transport` - The transport to use for the message
    `message` - The bayeux message.
  Returns:
    the channel id
  Throws:
    `java.io.IOException` - if the handle fails

### hasChannel

    public boolean hasChannel(java.lang.String id)

  Specified by:
    `hasChannel` in interface `org.cometd.Bayeux`

### isInitialized

    public boolean isInitialized()

### isJSONCommented

    public boolean isJSONCommented()

  Deprecated.

  Returns:
    the commented

### isLogDebug

    public boolean isLogDebug()

### isLogInfo

    public boolean isLogInfo()

### logDebug

    public void logDebug(java.lang.String message)

### logDebug

    public void logDebug(java.lang.String message,
                         java.lang.Throwable th)

### logWarn

    public void logWarn(java.lang.String message,
                        java.lang.Throwable th)

### logWarn

    public void logWarn(java.lang.String message)

### logInfo

    public void logInfo(java.lang.String message)

### newClient

    public org.cometd.Client newClient(java.lang.String idPrefix)

  Specified by:
    `newClient` in interface `org.cometd.Bayeux`

### newRemoteClient

    public abstract ClientImpl newRemoteClient()

### newTransport

    public Transport newTransport(ClientImpl client,
                                  java.util.Map<?,?> message)

  Create new transport object for a bayeux message

  Parameters:
    `client` - The client
    `message` - the bayeux message
  Returns:
    the negotiated transport.

### doPublish

    protected void doPublish(ChannelId to,
                             org.cometd.Client from,
                             java.lang.Object data,
                             java.lang.String msgId,
                             boolean lazy)

  Publish data to a channel. Creates a message and delivers it to the root channel.

  Parameters:
    `to` - the channel id to publish to
    `from` - the client that publishes
    `data` - the data to publish
    `msgId` - the message id
    `lazy` - whether the message is published lazily

### removeChannel

    public boolean removeChannel(ChannelImpl channel)

### addChannel

    protected void addChannel(ChannelImpl channel)

### newClientId

    protected java.lang.String newClientId(long variation,
                                           java.lang.String idPrefix)

### addClient

    protected void addClient(ClientImpl client,
                             java.lang.String idPrefix)

### removeClient

    public org.cometd.Client removeClient(java.lang.String client_id)

  Specified by:
    `removeClient` in interface `org.cometd.Bayeux`

### setMaxInterval

    public void setMaxInterval(long ms)

  Parameters:
    `ms` - The maximum time in ms to wait between polls before timing out a client

### setJSONCommented

    public void setJSONCommented(boolean commented)

  Parameters:
    `commented` - the commented to set

### setLogLevel

    public void setLogLevel(int logLevel)

  Parameters:
    `logLevel` - the logLevel: 0=none, 1=info, 2=debug

### setSecurityPolicy

    public void setSecurityPolicy(org.cometd.SecurityPolicy securityPolicy)

  Specified by:
    `setSecurityPolicy` in interface `org.cometd.Bayeux`

### setTimeout

    public void setTimeout(long ms)

### setInterval

    public void setInterval(long ms)

### setMultiFrameInterval

    public void setMultiFrameInterval(int multiFrameInterval)

  The time a client should delay between reconnects when multiple connections from the same browser are detected. This effectively produces traditional polling.

  Parameters:
    `multiFrameInterval` - the multiFrameInterval to set

### getMultiFrameInterval

    public int getMultiFrameInterval()

  Returns:
    the multiFrameInterval in milliseconds

### getChannelIdCacheLimit

    public int getChannelIdCacheLimit()

  Returns:
    the limit of the `ChannelId` cache
  See Also:
    `setChannelIdCacheLimit(int)`

### setChannelIdCacheLimit

    public void setChannelIdCacheLimit(int channelIdCacheLimit)

  Sets the cache limit for `ChannelId`s: use -1 to disable the cache, 0 for an unlimited cache, and any positive value for the limit after which the cache is cleared.

  Parameters:
    `channelIdCacheLimit` - the limit of the `ChannelId` cache
  See Also:
    `getChannelIdCacheLimit()`

### setAdvice

    public void setAdvice(JSON.Literal advice)

### getAdvice

    public JSON.Literal getAdvice()

### isRequestAvailable

    public boolean isRequestAvailable()

  Returns:
    TRUE if `getCurrentRequest()` will return the current request

### setRequestAvailable

    public void setRequestAvailable(boolean requestAvailable)

  Parameters:
    `requestAvailable` - TRUE if `getCurrentRequest()` will return the current request

### getCurrentRequest

    public javax.servlet.http.HttpServletRequest getCurrentRequest()

  Specified by:
    `getCurrentRequest` in interface `org.cometd.Bayeux`
  Returns:
    the current request if `isRequestAvailable()` is true, else null

### getChannels

    public java.util.Collection<org.cometd.Channel> getChannels()

  Specified by:
    `getChannels` in interface `org.cometd.Bayeux`

### getChannelCount

    public int getChannelCount()

  Returns:
    the number of channels

### getClients

    public java.util.Collection<org.cometd.Client> getClients()

  Specified by:
    `getClients` in interface `org.cometd.Bayeux`

### getClientCount

    public int getClientCount()

  Returns:
    the number of clients

### hasClient

    public boolean hasClient(java.lang.String clientId)

  Specified by:
    `hasClient` in interface `org.cometd.Bayeux`

### removeChannel

    public org.cometd.Channel removeChannel(java.lang.String channelId)

  Specified by:
    `removeChannel` in interface `org.cometd.Bayeux`

### initialize

    protected void initialize(javax.servlet.ServletContext context)

### addListener

    public void addListener(org.cometd.BayeuxListener listener)

  Specified by:
    `addListener` in interface `org.cometd.Bayeux`

### removeListener

    public void removeListener(org.cometd.BayeuxListener listener)

  Specified by:
    `removeListener` in interface `org.cometd.Bayeux`

### getMaxClientQueue

    public int getMaxClientQueue()

  Specified by:
    `getMaxClientQueue` in interface `org.cometd.Bayeux`

### setMaxClientQueue

    public void setMaxClientQueue(int size)

  Specified by:
    `setMaxClientQueue` in interface `org.cometd.Bayeux`

### extendRcv

    protected org.cometd.Message extendRcv(ClientImpl from,
                                           org.cometd.Message message)

### extendRcvMeta

    protected org.cometd.Message extendRcvMeta(ClientImpl from,
                                               org.cometd.Message message)

### extendSendBayeux

    protected org.cometd.Message extendSendBayeux(org.cometd.Client from,
                                                  org.cometd.Message message)

### extendSendClient

    public org.cometd.Message extendSendClient(org.cometd.Client from,
                                               ClientImpl to,
                                               org.cometd.Message message)

### extendSendMeta

    public org.cometd.Message extendSendMeta(ClientImpl from,
                                             org.cometd.Message message)

### getMaxLazyLatency

    public int getMaxLazyLatency()

  Returns:
    the maximum ms that a lazy message will wait before resuming waiting client

### setMaxLazyLatency

    public void setMaxLazyLatency(int ms)

  Parameters:
    `ms` - the maximum ms that a lazy message will wait before resuming waiting client

Copyright © 1995-2010 Mort Bay Consulting. All Rights Reserved.