## 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 ConcurrentHashMap<String,List<String>>` `_browser2client`
`protected List<org.cometd.ChannelBayeuxListener>` `_channelListeners`
`protected List<org.cometd.ClientBayeuxListener>` `_clientListeners`
`protected boolean` `_directDeliver`
`protected List<org.cometd.Extension>` `_extensions`
`protected Object` `_handshakeAdvice`
`protected boolean` `_initialized`
`protected long` `_interval`
`protected boolean` `_JSONCommented`
`protected int` `_logLevel`
`protected int` `_maxClientQueue`
`protected long` `_maxInterval`
`protected AbstractBayeux.Handler` `_metaPublishHandler`
`protected JSON.Literal` `_multiFrameAdvice`
`protected int` `_multiFrameInterval`
`protected AbstractBayeux.Handler` `_publishHandler`
`protected ThreadLocal<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, CHANNEL_FIELD, CLIENT_FIELD, CONNECTION_TYPE_FIELD, DATA_FIELD, DOJOX_COMETD_BAYEUX, 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, SUPP_CONNECTION_TYPE_FIELD, TIMESTAMP_FIELD, TRANSPORT_CALLBACK_POLL, TRANSPORT_FIELD, TRANSPORT_FLASH, TRANSPORT_IFRAME, TRANSPORT_LONG_POLL, VERSION_FIELD`

Constructor Summary
`protected` `AbstractBayeux()`

Method Summary
`void` `addChannel(ChannelImpl channel)`
`protected void` `addClient(ClientImpl client, String idPrefix)`
`void` `addExtension(org.cometd.Extension ext)`
`void` `addListener(org.cometd.BayeuxListener listener)`
`protected void` `doPublish(ChannelId to, org.cometd.Client from, Object data, String msgId)` Publish data to a channel.
`JSON.Literal` `getAdvice()`
`ChannelImpl` `getChannel(ChannelId id)`
`ChannelImpl` `getChannel(String id)`
`org.cometd.Channel` `getChannel(String id, boolean create)`
`int` `getChannelCount()`
`ChannelId` `getChannelId(String id)`
`Collection<org.cometd.Channel>` `getChannels()`
`org.cometd.Client` `getClient(String client_id)`
`int` `getClientCount()`
`Set<String>` `getClientIDs()`
`Collection<org.cometd.Client>` `getClients()`
`HttpServletRequest` `getCurrentRequest()`
`List<org.cometd.Extension>` `getExtensions()`
`long` `getInterval()`
`int` `getLogLevel()`
`int` `getMaxClientQueue()`
`long` `getMaxInterval()`
`int` `getMultiFrameInterval()`
`org.cometd.SecurityPolicy` `getSecurityPolicy()`
`long` `getTimeout()`
`String` `handle(ClientImpl client, Transport transport, org.cometd.Message message)` Handle a Bayeux message.
`boolean` `hasChannel(String id)`
`boolean` `hasClient(String clientId)`
`protected void` `initialize(ServletContext context)`
`boolean` `isDirectDeliver()`
`boolean` `isInitialized()`
`boolean` `isJSONCommented()`
`boolean` `isLogDebug()`
`boolean` `isLogInfo()`
`boolean` `isRequestAvailable()`
`void` `logDebug(String message)`
`void` `logDebug(String message, Throwable th)`
`void` `logInfo(String message)`
`void` `logWarn(String message)`
`void` `logWarn(String message, Throwable th)`
`org.cometd.Client` `newClient(String idPrefix)`
`protected String` `newClientId(long variation, String idPrefix)`
`abstract ClientImpl` `newRemoteClient()`
`Transport` `newTransport(ClientImpl client, Map<?,?> message)` Create new transport object for a bayeux message
`boolean` `removeChannel(ChannelImpl channel)`
`org.cometd.Channel` `removeChannel(String channelId)`
`org.cometd.Client` `removeClient(String client_id)`
`void` `removeExtension(org.cometd.Extension ext)`
`void` `setAdvice(JSON.Literal advice)`
`void` `setDirectDeliver(boolean directDeliver)`
`void` `setInterval(long ms)`
`void` `setJSONCommented(boolean commented)`
`void` `setLogLevel(int logLevel)`
`void` `setMaxClientQueue(int size)`
`void` `setMaxInterval(long 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, recycleMessage, setBatchJSON, setJSON, setMsgJSON`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, 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

### _securityPolicy

    protected org.cometd.SecurityPolicy _securityPolicy

### _advice

    protected JSON.Literal _advice

### _multiFrameAdvice

    protected JSON.Literal _multiFrameAdvice

### _adviceVersion

    protected int _adviceVersion

### _handshakeAdvice

    protected Object _handshakeAdvice

### _logLevel

    protected int _logLevel

### _timeout

    protected long _timeout

### _interval

    protected long _interval

### _maxInterval

    protected long _maxInterval

### _JSONCommented

    protected boolean _JSONCommented

### _initialized

    protected boolean _initialized

### _browser2client

    protected ConcurrentHashMap<String,List<String>> _browser2client

### _multiFrameInterval

    protected int _multiFrameInterval

### _directDeliver

    protected boolean _directDeliver

### _requestAvailable

    protected boolean _requestAvailable

### _request

    protected ThreadLocal<HttpServletRequest> _request

### _publishHandler

    protected AbstractBayeux.Handler _publishHandler

### _metaPublishHandler

    protected AbstractBayeux.Handler _metaPublishHandler

### _maxClientQueue

    protected int _maxClientQueue

### _extensions

    protected List<org.cometd.Extension> _extensions

### _transports

    protected JSON.Literal _transports

### _clientListeners

    protected List<org.cometd.ClientBayeuxListener> _clientListeners

### _channelListeners

    protected List<org.cometd.ChannelBayeuxListener> _channelListeners

Constructor Detail

### AbstractBayeux

    protected AbstractBayeux()

Parameters:
  `context.` - The logLevel init parameter is used to set the logging to 0=none, 1=info, 2=debug

Method Detail

### addExtension

    public void addExtension(org.cometd.Extension ext)

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

### getExtensions

    public List<org.cometd.Extension> getExtensions()

### removeExtension

    public void removeExtension(org.cometd.Extension ext)

### getChannel

    public ChannelImpl getChannel(ChannelId id)

  Parameters:
    `id` -
  Returns:

### getChannel

    public ChannelImpl getChannel(String id)

### getChannel

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

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

### getChannelId

    public ChannelId getChannelId(String id)

### getClient

    public org.cometd.Client getClient(String client_id)

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

### getClientIDs

    public Set<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)

  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 String handle(ClientImpl client,
                         Transport transport,
                         org.cometd.Message message)
                  throws 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.
  Throws:
    `IOException`

### hasChannel

    public boolean hasChannel(String id)

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

### isInitialized

    public boolean isInitialized()

### isJSONCommented

    public boolean isJSONCommented()

  Returns:
    the commented

### isLogDebug

    public boolean isLogDebug()

### isLogInfo

    public boolean isLogInfo()

### logDebug

    public void logDebug(String message)

### logDebug

    public void logDebug(String message,
                         Throwable th)

### logWarn

    public void logWarn(String message,
                        Throwable th)

### logWarn

    public void logWarn(String message)

### logInfo

    public void logInfo(String message)

### newClient

    public org.cometd.Client newClient(String idPrefix)

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

### newRemoteClient

    public abstract ClientImpl newRemoteClient()

### newTransport

    public Transport newTransport(ClientImpl client,
                                  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,
                             Object data,
                             String msgId)

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

  Parameters:
    `to` -
    `from` -
    `data` -
    `msgId` -

### removeChannel

    public boolean removeChannel(ChannelImpl channel)

### addChannel

    public void addChannel(ChannelImpl channel)

### newClientId

    protected String newClientId(long variation,
                                 String idPrefix)

### addClient

    protected void addClient(ClientImpl client,
                             String idPrefix)

### removeClient

    public org.cometd.Client removeClient(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

### 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 HttpServletRequest getCurrentRequest()

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

### getChannels

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

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

### getChannelCount

    public int getChannelCount()

  Returns:

### getClients

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

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

### getClientCount

    public int getClientCount()

  Returns:

### hasClient

    public boolean hasClient(String clientId)

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

### removeChannel

    public org.cometd.Channel removeChannel(String channelId)

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

### initialize

    protected void initialize(ServletContext context)

### addListener

    public void addListener(org.cometd.BayeuxListener listener)

  Specified by:
    `addListener` 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`

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