All Classes and Interfaces

Class
Description
 
Partial implementation of ClientSession.
 
 
HTTP ServerTransport base class, used by ServerTransports that use HTTP as transport or to initiate a transport connection.
A AbstractServerTransport.Scheduler for HTTP-based transports.
The base class of all server transports.
Performs server-to-client transport operations when a /meta/connect message is held and a server-side message is published.
A scheduler that does not perform any operation but remembers the /meta/connect cycle.
AbstractService provides convenience methods to assist with the creation of a CometD services.
 
 
 
 
 
This client-side extension enables the client to acknowledge to the server the messages that the client has received.
Installing this extension in a BayeuxServer provides support for server-to-client message acknowledgement if a client also supports it.
A listener for acknowledgement events.
Tracks the batch id of messages sent to a client.
Monitors the activity of ServerSessions and disconnects them after a period of inactivity.
The possible activity to monitor
Monitors the activity of a single ServerSession, disconnecting it when the max inactivity period is exceeded.
A specialized version of CometDServlet that can be configured with the init-parameter services to be a comma separated list of class names of annotated services, that will be processed by ServerAnnotationProcessor upon initialization.
Base class for common functionality in annotation processors
Processes asynchronously a sequence of elements, producing a result that is the reduction of the results produced by the processing of each element.
Controls the iteration over a sequence of elements, allowing to continue the iteration (with a result), break out of the iteration (with a result), or fail the iteration (with an exception).
The operation to invoke for each element.
Operations that are to be authorized on a channel
The result of an authentication request.
 
 
 
 
The Bayeux interface is the common API for both client-side and server-side configuration and usage of the Bayeux object.
The common base interface for Bayeux listeners.
Validates Bayeux protocol elements such as channel ids and message ids.
BayeuxClient is the implementation of a client for the Bayeux protocol.
A strategy to controls wait times of the retry attempts in case of heartbeat failures.
A back off strategy that always returns the same wait time.
A strategy that increases the wait time linearly up to a maximum.
 
The states that a BayeuxClient may assume.
The Bayeux Context provides information about the current context of a Bayeux message.
The server-side Bayeux interface.
Common base interface for all server-side Bayeux listeners.
Specialized listener for ServerChannel events.
Extension API for BayeuxServer.
Specialized listener for ServerSession events.
Specialized listener for ServerChannel subscription events.
 
 
Reified representation of binary data chunk contained in a message.
A client extension that encodes byte[] or ByteBuffer into a BinaryData object using the Z85 format for outgoing messages, and decodes BinaryData objects back into byte[] or ByteBuffer for incoming messages.
A server extension that encodes byte[] or ByteBuffer into a BinaryData object using the Z85 format for outgoing messages, and decodes BinaryData objects back into byte[] or ByteBuffer for incoming messages.
An extension that encodes/decodes binary data for a ServerSession.
A JSONContext.AsyncParser that parses an array of Bayeux messages.
A Bayeux channel is the primary message routing mechanism within Bayeux: both Bayeux clients and Bayeux server use channels to group listeners that are interested in receiving messages with that channel.
Reification of a channel id with methods to test properties and compare with other ChannelIds.
Processes annotations in client-side service objects.
This interface represents the client side Bayeux session.
Extension API for client session.
A listener for remote call messages.
A client side channel representation.
Represents a listener on a ClientSessionChannel.
A listener for messages on a ClientSessionChannel.
ClientTransports are used by BayeuxClient to send and receive Bayeux messages.
 
 
 
CometDHandler maps HTTP requests to the HTTP server transports of a BayeuxServer instance.
An abstraction over HTTP requests.
The source of the request body.
Request content bytes with the indication of whether they are the last.
An abstraction over HTTP responses.
The sink of the response body.
The CometD Servlet maps HTTP requests to the AbstractHttpTransport of a BayeuxServer instance.
A ConfigurableServerChannel offers an API that can be used to configure ServerChannels at creation time.
A listener interface by means of which listeners can atomically set the initial configuration of a channel.
Utility class that initializes channels to be persistent
Common interface for ServerChannel listeners.
Tag interface that marks ConfigurableServerChannel.ServerChannelListeners as "weak".
For server-side services, identifies channel configuration methods that are invoked when a message is processed on server-side.
A parser for "Cookie" headers.
A filter that can add, modify or remove fields from the message data.
Aborts the filtering of the message data.
A MessageListener that applies DataFilters to the received messages.
 
This Authorizer implementation grants permission for a set of operations defined at construction time.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Abstraction for JSON parsing and generation.
A non-blocking JSON parser.
Client specific JSONContext that binds to Message.Mutable.
A JSON stringifier.
A blocking JSON parser.
Server specific JSONContext that binds to ServerMessage.Mutable.
 
 
For server-side services, identifies callback methods that are invoked when a message is processed on server-side.
A LocalSession is a ClientSession within the server.
A LocalSession implementation.
Immutable, non-volatile, non-atomic version of AtomicMarkableReference.
The Bayeux protocol exchange information by means of messages.
The mutable version of a Message
Classes implementing MessageClientTransport indicate that the transport they provide receives messages without the need of a previous request, like it happens in HTTP long poll.
 
 
 
 
 
 
Oort is the cluster manager that links one CometD server to a set of other CometD servers.
Listener interface that gets notified of comet events, that is when a new comet joins the cloud or when a comet leaves the cloud.
Comet event object delivered to Oort.CometListener methods.
The Oort comet client connects a local Oort comet server to a remote Oort comet server.
This servlet serves as a base class for initializing and configuring an instance of the Oort CometD cluster manager.
 
A specialized oort object whose entity is a List.
An implementation of OortObject.Listener that converts whole list events into OortList.ElementListener events.
Listener for element events that update the entity list, either locally or remotely.
A shared atomic long made of an internal AtomicLong and of an internal OortObject<Long>.
The equivalent of an OortMap&lt;Long,V&gt;.
A specialized oort object whose entity is a ConcurrentMap.
An implementation of OortObject.Listener that converts whole map events into OortMap.EntryListener events.
A triple that holds the key, the previous value and the new value, used to notify entry updates:
Listener for entry events that update the entity map, either locally or remotely.
 
This servlet initializes and configures an instance of the Oort CometD cluster manager via autodiscovery of other Oort comets using UDP multicast.
 
An OortObject represents a named composite entity that is distributed in an Oort cluster.
 
Factory that creates objects stored by OortObjects.
The oort object part holding the object and the metadata associated with it.
Listener for events that update the value of a OortObject.Info, either local or remote.
A merge strategy for object values.
An asynchronous result.
Implementation of OortObject.Result that allows applications to block, waiting for the result, via OortObject.Result.Deferred.get(long, TimeUnit).
 
 
 
A distributed counter service to be deployed on a Oort cluster that modifies a long value hosted in a "primary" node.
Callback invoked when the result of the operation on the counter is available, or when the operation failed.
 
OortPrimaryService extends OortService to allow applications to perform actions on entities that always live in a "primary" node.
An OortService allows applications to forward actions to Oort nodes that own the entity onto which the action should be applied.
Encapsulates a forwarded request.
Encapsulates the result of a forwarded request returned by OortService.onForward(Request).
Utility context that stores the ServerSession and the ServerMessage.
This servlet initializes and configures an instance of the Oort CometD cluster manager with a static list of other Oort comet URLs.
The equivalent of an OortMap<String, V>.
For methods annotated with Listener or Subscription whose value is a channel template such as /game/{gameId}, this annotation binds parameters of those methods with the value obtained matching the actual channel with the channel template.
The future result of an operation, either a value if the operation succeeded, or a failure if the operation failed.
A CompletableFuture that is also a Promise.
A wrapper for Promise instances.
 
Identifies callback methods on server-side services that are invoked when the client is performing a remote call.
Objects implementing this interface represent remote clients that performed remote calls.
A SecurityPolicy defines the broad authorization constraints that must be enforced by a BayeuxServer.
Processes annotations in server-side service objects.
Server side representation of a Bayeux channel.
Listeners objects that implement this interface will be notified of message publish.
Listener objects that implement this interface will be notified of subscription events.
 
Representation of a server side message.
The mutable version of a ServerMessage
 
Objects implementing this interface are the server-side representation of remote Bayeux clients.
Listener objects that implement this interface will be notified of session addition.
Listeners objects that implement this interface will be notified when the session queue is being drained to actually deliver the messages.
Extension API for ServerSession.
Listeners objects that implement this interface will be notified when a /meta/connect message is suspended by the server, and when it is subsequently resumed.
Listeners objects that implement this interface will be notified of message sending.
Listener objects that implement this interface will be notified when a message is queued in the session queue.
Listeners objects that implement this interface will be notified when the session queue is full.
Listeners objects that implement this interface will be notified of session removal.
Common interface for ServerSession listeners.
 
Server side extension of a Bayeux transport.
Identifies classes whose instances are services that interact with the Bayeux API.
Identifies fields and methods that can be injected with org.cometd.bayeux.Session sessions objects scoped to the service instance.
A Bayeux session represents a connection between a bayeux client and a bayeux server.
The component that Searches for Extra Terrestrial Intelligence or, in this case, just searches for a user logged onto a comet in an Oort cloud.
The representation of where a user is.
Listener interface that gets notified of remote Seti presence events.
Seti presence event object, delivered to Seti.PresenceListener methods.
This servlet initializes and configures and instance of the Seti user mapper.
For server-side services, identifies callback methods that are invoked when a message is processed on local-side.
 
 
 
Timesync extension (server side).
A transport abstract the details of the protocol used to send Bayeux messages over the network, for example using HTTP or using WebSocket.
 
 
Abstracts the communication between BayeuxClient and ClientTransport.
 
 
 
 
 
An implementation of Z85, a format for representing binary data as printable text defined at ZeroMQ Z85.