1452 lines
53 KiB
JavaScript
1452 lines
53 KiB
JavaScript
/**
|
|
* Copyright 2008 Mort Bay Consulting Pty. Ltd.
|
|
* Dual licensed under the Apache License 2.0 and the MIT license.
|
|
* ----------------------------------------------------------------------------
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
* http: *www.apache.org/licenses/LICENSE-2.0
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
* ----------------------------------------------------------------------------
|
|
* Licensed under the MIT license;
|
|
* Permission is hereby granted, free of charge, to any person obtaining
|
|
* a copy of this software and associated documentation files (the
|
|
* "Software"), to deal in the Software without restriction, including
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
* distribute, sublicense, and/or sell copies of the Software, and to
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
* the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be
|
|
* included in all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
|
* LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
* ----------------------------------------------------------------------------
|
|
* $Revision$ $Date$
|
|
*/
|
|
(function($)
|
|
{
|
|
/**
|
|
* The constructor for a Comet object.
|
|
* There is a default Comet instance already created at the variable <code>$.cometd</code>,
|
|
* and hence that can be used to start a comet conversation with a server.
|
|
* In the rare case a page needs more than one comet conversation, a new instance can be
|
|
* created via:
|
|
* <pre>
|
|
* var url2 = ...;
|
|
* var cometd2 = new $.Cometd();
|
|
* cometd2.init(url2);
|
|
* </pre>
|
|
*/
|
|
$.Cometd = function(name)
|
|
{
|
|
var _name = name || 'default';
|
|
var _logPriorities = { debug: 1, info: 2, warn: 3, error: 4 };
|
|
var _logLevel = 'info';
|
|
var _url;
|
|
var _xd = false;
|
|
var _transport;
|
|
var _status = 'disconnected';
|
|
var _messageId = 0;
|
|
var _clientId = null;
|
|
var _batch = 0;
|
|
var _messageQueue = [];
|
|
var _listeners = {};
|
|
var _backoff = 0;
|
|
var _backoffIncrement = 1000;
|
|
var _maxBackoff = 60000;
|
|
var _scheduledSend = null;
|
|
var _extensions = [];
|
|
var _advice = {};
|
|
var _handshakeProps;
|
|
|
|
/**
|
|
* Returns the name assigned to this Comet object, or the string 'default'
|
|
* if no name has been explicitely passed as parameter to the constructor.
|
|
*/
|
|
this.getName = function()
|
|
{
|
|
return _name;
|
|
};
|
|
|
|
/**
|
|
* Configures the initial comet communication with the comet server.
|
|
* @param cometURL the URL of the comet server
|
|
*/
|
|
this.configure = function(cometURL)
|
|
{
|
|
_configure(cometURL);
|
|
};
|
|
|
|
function _configure(cometURL)
|
|
{
|
|
_url = cometURL;
|
|
_debug('Initializing comet with url: {}', _url);
|
|
|
|
// Check immediately if we're cross domain
|
|
// If cross domain, the handshake must not send the long polling transport type
|
|
var urlParts = /(^https?:)?(\/\/(([^:\/\?#]+)(:(\d+))?))?([^\?#]*)/.exec(cometURL);
|
|
if (urlParts[3]) _xd = urlParts[3] != location.host;
|
|
|
|
// Temporary setup a transport to send the initial handshake
|
|
// The transport may be changed as a result of handshake
|
|
if (_xd)
|
|
_transport = newCallbackPollingTransport();
|
|
else
|
|
_transport = newLongPollingTransport();
|
|
_debug('Initial transport is {}', _transport.getType());
|
|
};
|
|
|
|
/**
|
|
* Configures and establishes the comet communication with the comet server
|
|
* via a handshake and a subsequent connect.
|
|
* @param cometURL the URL of the comet server
|
|
* @param handshakeProps an object to be merged with the handshake message
|
|
* @see #configure(cometURL)
|
|
* @see #handshake(handshakeProps)
|
|
*/
|
|
this.init = function(cometURL, handshakeProps)
|
|
{
|
|
_configure(cometURL);
|
|
_handshake(handshakeProps);
|
|
};
|
|
|
|
/**
|
|
* Establishes the comet communication with the comet server
|
|
* via a handshake and a subsequent connect.
|
|
* @param handshakeProps an object to be merged with the handshake message
|
|
*/
|
|
this.handshake = function(handshakeProps)
|
|
{
|
|
_handshake(handshakeProps);
|
|
};
|
|
|
|
/**
|
|
* Disconnects from the comet server.
|
|
* @param disconnectProps an object to be merged with the disconnect message
|
|
*/
|
|
this.disconnect = function(disconnectProps)
|
|
{
|
|
var bayeuxMessage = {
|
|
channel: '/meta/disconnect'
|
|
};
|
|
var message = $.extend({}, disconnectProps, bayeuxMessage);
|
|
// Deliver immediately
|
|
// The handshake and connect mechanism make use of startBatch(), and in case
|
|
// of a failed handshake the disconnect would not be delivered if using _send().
|
|
_setStatus('disconnecting');
|
|
_deliver([message], false);
|
|
};
|
|
|
|
/**
|
|
* Marks the start of a batch of application messages to be sent to the server
|
|
* in a single request, obtaining a single response containing (possibly) many
|
|
* application reply messages.
|
|
* Messages are held in a queue and not sent until {@link #endBatch()} is called.
|
|
* If startBatch() is called multiple times, then an equal number of endBatch()
|
|
* calls must be made to close and send the batch of messages.
|
|
* @see #endBatch()
|
|
*/
|
|
this.startBatch = function()
|
|
{
|
|
_startBatch();
|
|
};
|
|
|
|
/**
|
|
* Marks the end of a batch of application messages to be sent to the server
|
|
* in a single request.
|
|
* @see #startBatch()
|
|
*/
|
|
this.endBatch = function()
|
|
{
|
|
_endBatch(true);
|
|
};
|
|
|
|
/**
|
|
* Subscribes to the given channel, performing the given callback in the given scope
|
|
* when a message for the channel arrives.
|
|
* @param channel the channel to subscribe to
|
|
* @param scope the scope of the callback
|
|
* @param callback the callback to call when a message is delivered to the channel
|
|
* @param subscribeProps an object to be merged with the subscribe message
|
|
* @return the subscription handle to be passed to {@link #unsubscribe(object)}
|
|
*/
|
|
this.subscribe = function(channel, scope, callback, subscribeProps)
|
|
{
|
|
var subscription = this.addListener(channel, scope, callback);
|
|
|
|
// Send the subscription message after the subscription registration to avoid
|
|
// races where the server would deliver a message to the subscribers, but here
|
|
// on the client the subscription has not been added yet to the data structures
|
|
var bayeuxMessage = {
|
|
channel: '/meta/subscribe',
|
|
subscription: channel
|
|
};
|
|
var message = $.extend({}, subscribeProps, bayeuxMessage);
|
|
_send(message);
|
|
|
|
return subscription;
|
|
};
|
|
|
|
/**
|
|
* Unsubscribes the subscription obtained with a call to {@link #subscribe(string, object, function)}.
|
|
* @param subscription the subscription to unsubscribe.
|
|
*/
|
|
this.unsubscribe = function(subscription, unsubscribeProps)
|
|
{
|
|
// Remove the local listener before sending the message
|
|
// This ensures that if the server fails, this client does not get notifications
|
|
this.removeListener(subscription);
|
|
var bayeuxMessage = {
|
|
channel: '/meta/unsubscribe',
|
|
subscription: subscription[0]
|
|
};
|
|
var message = $.extend({}, unsubscribeProps, bayeuxMessage);
|
|
_send(message);
|
|
};
|
|
|
|
/**
|
|
* Publishes a message on the given channel, containing the given content.
|
|
* @param channel the channel to publish the message to
|
|
* @param content the content of the message
|
|
* @param publishProps an object to be merged with the publish message
|
|
*/
|
|
this.publish = function(channel, content, publishProps)
|
|
{
|
|
var bayeuxMessage = {
|
|
channel: channel,
|
|
data: content
|
|
};
|
|
var message = $.extend({}, publishProps, bayeuxMessage);
|
|
_send(message);
|
|
};
|
|
|
|
/**
|
|
* Adds a listener for bayeux messages, performing the given callback in the given scope
|
|
* when a message for the given channel arrives.
|
|
* @param channel the channel the listener is interested to
|
|
* @param scope the scope of the callback
|
|
* @param callback the callback to call when a message is delivered to the channel
|
|
* @returns the subscription handle to be passed to {@link #removeListener(object)}
|
|
* @see #removeListener(object)
|
|
*/
|
|
this.addListener = function(channel, scope, callback)
|
|
{
|
|
// The data structure is a map<channel, subscription[]>, where each subscription
|
|
// holds the callback to be called and its scope.
|
|
|
|
// Normalize arguments
|
|
if (!callback)
|
|
{
|
|
callback = scope;
|
|
scope = undefined;
|
|
}
|
|
|
|
var subscription = {
|
|
scope: scope,
|
|
callback: callback
|
|
};
|
|
|
|
var subscriptions = _listeners[channel];
|
|
if (!subscriptions)
|
|
{
|
|
subscriptions = [];
|
|
_listeners[channel] = subscriptions;
|
|
}
|
|
// Pushing onto an array appends at the end and returns the id associated with the element increased by 1.
|
|
// Note that if:
|
|
// a.push('a'); var hb=a.push('b'); delete a[hb-1]; var hc=a.push('c');
|
|
// then:
|
|
// hc==3, a.join()=='a',,'c', a.length==3
|
|
var subscriptionIndex = subscriptions.push(subscription) - 1;
|
|
_debug('Added listener: channel \'{}\', callback \'{}\', index {}', channel, callback.name, subscriptionIndex);
|
|
|
|
// The subscription to allow removal of the listener is made of the channel and the index
|
|
return [channel, subscriptionIndex];
|
|
};
|
|
|
|
/**
|
|
* Removes the subscription obtained with a call to {@link #addListener(string, object, function)}.
|
|
* @param subscription the subscription to unsubscribe.
|
|
*/
|
|
this.removeListener = function(subscription)
|
|
{
|
|
var subscriptions = _listeners[subscription[0]];
|
|
if (subscriptions)
|
|
{
|
|
delete subscriptions[subscription[1]];
|
|
_debug('Removed listener: channel \'{}\', index {}', subscription[0], subscription[1]);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Removes all listeners registered with {@link #addListener(channel, scope, callback)} or
|
|
* {@link #subscribe(channel, scope, callback)}.
|
|
*/
|
|
this.clearListeners = function()
|
|
{
|
|
_listeners = {};
|
|
};
|
|
|
|
/**
|
|
* Returns a string representing the status of the bayeux communication with the comet server.
|
|
*/
|
|
this.getStatus = function()
|
|
{
|
|
return _status;
|
|
};
|
|
|
|
/**
|
|
* Sets the backoff period used to increase the backoff time when retrying an unsuccessful or failed message.
|
|
* Default value is 1 second, which means if there is a persistent failure the retries will happen
|
|
* after 1 second, then after 2 seconds, then after 3 seconds, etc. So for example with 15 seconds of
|
|
* elapsed time, there will be 5 retries (at 1, 3, 6, 10 and 15 seconds elapsed).
|
|
* @param period the backoff period to set
|
|
* @see #getBackoffIncrement()
|
|
*/
|
|
this.setBackoffIncrement = function(period)
|
|
{
|
|
_backoffIncrement = period;
|
|
};
|
|
|
|
/**
|
|
* Returns the backoff period used to increase the backoff time when retrying an unsuccessful or failed message.
|
|
* @see #setBackoffIncrement(period)
|
|
*/
|
|
this.getBackoffIncrement = function()
|
|
{
|
|
return _backoffIncrement;
|
|
};
|
|
|
|
/**
|
|
* Returns the backoff period to wait before retrying an unsuccessful or failed message.
|
|
*/
|
|
this.getBackoffPeriod = function()
|
|
{
|
|
return _backoff;
|
|
};
|
|
|
|
/**
|
|
* Sets the log level for console logging.
|
|
* Valid values are the strings 'error', 'warn', 'info' and 'debug', from
|
|
* less verbose to more verbose.
|
|
* @param level the log level string
|
|
*/
|
|
this.setLogLevel = function(level)
|
|
{
|
|
_logLevel = level;
|
|
};
|
|
|
|
/**
|
|
* Registers an extension whose callbacks are called for every incoming message
|
|
* (that comes from the server to this client implementation) and for every
|
|
* outgoing message (that originates from this client implementation for the
|
|
* server).
|
|
* The format of the extension object is the following:
|
|
* <pre>
|
|
* {
|
|
* incoming: function(message) { ... },
|
|
* outgoing: function(message) { ... }
|
|
* }
|
|
* Both properties are optional, but if they are present they will be called
|
|
* respectively for each incoming message and for each outgoing message.
|
|
* </pre>
|
|
* @param name the name of the extension
|
|
* @param extension the extension to register
|
|
* @return true if the extension was registered, false otherwise
|
|
* @see #unregisterExtension(name)
|
|
*/
|
|
this.registerExtension = function(name, extension)
|
|
{
|
|
var existing = false;
|
|
for (var i = 0; i < _extensions.length; ++i)
|
|
{
|
|
var existingExtension = _extensions[i];
|
|
if (existingExtension.name == name)
|
|
{
|
|
existing = true;
|
|
return false;
|
|
}
|
|
}
|
|
if (!existing)
|
|
{
|
|
_extensions.push({
|
|
name: name,
|
|
extension: extension
|
|
});
|
|
_debug('Registered extension \'{}\'', name);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
_info('Could not register extension with name \'{}\': another extension with the same name already exists');
|
|
return false;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Unregister an extension previously registered with
|
|
* {@link #registerExtension(name, extension)}.
|
|
* @param name the name of the extension to unregister.
|
|
* @return true if the extension was unregistered, false otherwise
|
|
*/
|
|
this.unregisterExtension = function(name)
|
|
{
|
|
var unregistered = false;
|
|
$.each(_extensions, function(index, extension)
|
|
{
|
|
if (extension.name == name)
|
|
{
|
|
_extensions.splice(index, 1);
|
|
unregistered = true;
|
|
_debug('Unregistered extension \'{}\'', name);
|
|
return false;
|
|
}
|
|
});
|
|
return unregistered;
|
|
};
|
|
|
|
/**
|
|
* Starts a the batch of messages to be sent in a single request.
|
|
* @see _endBatch(deliverMessages)
|
|
*/
|
|
function _startBatch()
|
|
{
|
|
++_batch;
|
|
};
|
|
|
|
/**
|
|
* Ends the batch of messages to be sent in a single request,
|
|
* optionally delivering messages present in the message queue depending
|
|
* on the given argument.
|
|
* @param deliverMessages whether to deliver the messages in the queue or not
|
|
* @see _startBatch()
|
|
*/
|
|
function _endBatch(deliverMessages)
|
|
{
|
|
--_batch;
|
|
if (_batch < 0) _batch = 0;
|
|
if (deliverMessages && _batch == 0 && !_isDisconnected())
|
|
{
|
|
var messages = _messageQueue;
|
|
_messageQueue = [];
|
|
if (messages.length > 0) _deliver(messages, false);
|
|
}
|
|
};
|
|
|
|
function _nextMessageId()
|
|
{
|
|
return ++_messageId;
|
|
};
|
|
|
|
/**
|
|
* Converts the given response into an array of bayeux messages
|
|
* @param response the response to convert
|
|
* @return an array of bayeux messages obtained by converting the response
|
|
*/
|
|
function _convertToMessages(response)
|
|
{
|
|
if (response === undefined) return [];
|
|
if (response instanceof Array) return response;
|
|
if (response instanceof String || typeof response == 'string') return eval('(' + response + ')');
|
|
if (response instanceof Object) return [response];
|
|
throw 'Conversion Error ' + response + ', typeof ' + (typeof response);
|
|
};
|
|
|
|
function _setStatus(newStatus)
|
|
{
|
|
_debug('{} -> {}', _status, newStatus);
|
|
_status = newStatus;
|
|
};
|
|
|
|
function _isDisconnected()
|
|
{
|
|
return _status == 'disconnecting' || _status == 'disconnected';
|
|
};
|
|
|
|
/**
|
|
* Sends the initial handshake message
|
|
*/
|
|
function _handshake(handshakeProps)
|
|
{
|
|
_debug('Starting handshake');
|
|
_clientId = null;
|
|
|
|
// Start a batch.
|
|
// This is needed because handshake and connect are async.
|
|
// It may happen that the application calls init() then subscribe()
|
|
// and the subscribe message is sent before the connect message, if
|
|
// the subscribe message is not held until the connect message is sent.
|
|
// So here we start a batch to hold temporarly any message until
|
|
// the connection is fully established.
|
|
_batch = 0;
|
|
_startBatch();
|
|
|
|
// Save the original properties provided by the user
|
|
// Deep copy to avoid the user to be able to change them later
|
|
_handshakeProps = $.extend(true, {}, handshakeProps);
|
|
|
|
var bayeuxMessage = {
|
|
version: '1.0',
|
|
minimumVersion: '0.9',
|
|
channel: '/meta/handshake',
|
|
supportedConnectionTypes: _xd ? ['callback-polling'] : ['long-polling', 'callback-polling']
|
|
};
|
|
// Do not allow the user to mess with the required properties,
|
|
// so merge first the user properties and *then* the bayeux message
|
|
var message = $.extend({}, handshakeProps, bayeuxMessage);
|
|
|
|
// We started a batch to hold the application messages,
|
|
// so here we must bypass it and deliver immediately.
|
|
_setStatus('handshaking');
|
|
_deliver([message], false);
|
|
};
|
|
|
|
function _findTransport(handshakeResponse)
|
|
{
|
|
var transportTypes = handshakeResponse.supportedConnectionTypes;
|
|
if (_xd)
|
|
{
|
|
// If we are cross domain, check if the server supports it, that's the only option
|
|
if ($.inArray('callback-polling', transportTypes) >= 0) return _transport;
|
|
}
|
|
else
|
|
{
|
|
// Check if we can keep long-polling
|
|
if ($.inArray('long-polling', transportTypes) >= 0) return _transport;
|
|
|
|
// The server does not support long-polling
|
|
if ($.inArray('callback-polling', transportTypes) >= 0) return newCallbackPollingTransport();
|
|
}
|
|
return null;
|
|
};
|
|
|
|
function _delayedHandshake()
|
|
{
|
|
_setStatus('handshaking');
|
|
_delayedSend(function()
|
|
{
|
|
_handshake(_handshakeProps);
|
|
});
|
|
};
|
|
|
|
function _delayedConnect()
|
|
{
|
|
_setStatus('connecting');
|
|
_delayedSend(function()
|
|
{
|
|
_connect();
|
|
});
|
|
};
|
|
|
|
function _delayedSend(operation)
|
|
{
|
|
_cancelDelayedSend();
|
|
var delay = _backoff;
|
|
_debug("Delayed send: backoff {}, interval {}", _backoff, _advice.interval);
|
|
if (_advice.interval && _advice.interval > 0)
|
|
delay += _advice.interval;
|
|
_scheduledSend = _setTimeout(operation, delay);
|
|
};
|
|
|
|
function _cancelDelayedSend()
|
|
{
|
|
if (_scheduledSend !== null) clearTimeout(_scheduledSend);
|
|
_scheduledSend = null;
|
|
};
|
|
|
|
function _setTimeout(funktion, delay)
|
|
{
|
|
return setTimeout(function()
|
|
{
|
|
try
|
|
{
|
|
funktion();
|
|
}
|
|
catch (x)
|
|
{
|
|
_debug('Exception during scheduled execution of function \'{}\': {}', funktion.name, x);
|
|
}
|
|
}, delay);
|
|
};
|
|
|
|
/**
|
|
* Sends the connect message
|
|
*/
|
|
function _connect()
|
|
{
|
|
_debug('Starting connect');
|
|
var message = {
|
|
channel: '/meta/connect',
|
|
connectionType: _transport.getType()
|
|
};
|
|
_setStatus('connecting');
|
|
_deliver([message], true);
|
|
_setStatus('connected');
|
|
};
|
|
|
|
function _send(message)
|
|
{
|
|
if (_batch > 0)
|
|
_messageQueue.push(message);
|
|
else
|
|
_deliver([message], false);
|
|
};
|
|
|
|
/**
|
|
* Delivers the messages to the comet server
|
|
* @param messages the array of messages to send
|
|
*/
|
|
function _deliver(messages, comet)
|
|
{
|
|
// We must be sure that the messages have a clientId.
|
|
// This is not guaranteed since the handshake may take time to return
|
|
// (and hence the clientId is not known yet) and the application
|
|
// may create other messages.
|
|
$.each(messages, function(index, message)
|
|
{
|
|
message['id'] = _nextMessageId();
|
|
if (_clientId) message['clientId'] = _clientId;
|
|
messages[index] = _applyOutgoingExtensions(message);
|
|
});
|
|
|
|
var self = this;
|
|
var envelope = {
|
|
url: _url,
|
|
messages: messages,
|
|
onSuccess: function(request, response)
|
|
{
|
|
try
|
|
{
|
|
_handleSuccess.call(self, request, response, comet);
|
|
}
|
|
catch (x)
|
|
{
|
|
_debug('Exception during execution of success callback: {}', x);
|
|
}
|
|
},
|
|
onFailure: function(request, reason, exception)
|
|
{
|
|
try
|
|
{
|
|
_handleFailure.call(self, request, messages, reason, exception, comet);
|
|
}
|
|
catch (x)
|
|
{
|
|
_debug('Exception during execution of failure callback: {}', x);
|
|
}
|
|
}
|
|
};
|
|
_debug('Sending request to {}, message(s): {}', envelope.url, JSON.stringify(envelope.messages));
|
|
_transport.send(envelope, comet);
|
|
};
|
|
|
|
function _applyIncomingExtensions(message)
|
|
{
|
|
for (var i = 0; i < _extensions.length; ++i)
|
|
{
|
|
var extension = _extensions[i];
|
|
var callback = extension.extension.incoming;
|
|
if (callback && typeof callback === 'function')
|
|
{
|
|
_debug('Calling incoming extension \'{}\', callback \'{}\'', extension.name, callback.name);
|
|
message = _applyExtension(extension.name, callback, message) || message;
|
|
}
|
|
}
|
|
return message;
|
|
};
|
|
|
|
function _applyOutgoingExtensions(message)
|
|
{
|
|
for (var i = 0; i < _extensions.length; ++i)
|
|
{
|
|
var extension = _extensions[i];
|
|
var callback = extension.extension.outgoing;
|
|
if (callback && typeof callback === 'function')
|
|
{
|
|
_debug('Calling outgoing extension \'{}\', callback \'{}\'', extension.name, callback.name);
|
|
message = _applyExtension(extension.name, callback, message) || message;
|
|
}
|
|
}
|
|
return message;
|
|
};
|
|
|
|
function _applyExtension(name, callback, message)
|
|
{
|
|
try
|
|
{
|
|
return callback(message);
|
|
}
|
|
catch (x)
|
|
{
|
|
_debug('Exception during execution of extension \'{}\': {}', name, x);
|
|
return message;
|
|
}
|
|
};
|
|
|
|
function _handleSuccess(request, response, comet)
|
|
{
|
|
var messages = _convertToMessages(response);
|
|
_debug('Received response {}', JSON.stringify(messages));
|
|
|
|
// Signal the transport it can deliver other queued requests
|
|
_transport.complete(request, true, comet);
|
|
|
|
for (var i = 0; i < messages.length; ++i)
|
|
{
|
|
var message = messages[i];
|
|
message = _applyIncomingExtensions(message);
|
|
|
|
if (message.advice) _advice = message.advice;
|
|
|
|
var channel = message.channel;
|
|
switch (channel)
|
|
{
|
|
case '/meta/handshake':
|
|
_handshakeSuccess(message);
|
|
break;
|
|
case '/meta/connect':
|
|
_connectSuccess(message);
|
|
break;
|
|
case '/meta/disconnect':
|
|
_disconnectSuccess(message);
|
|
break;
|
|
case '/meta/subscribe':
|
|
_subscribeSuccess(message);
|
|
break;
|
|
case '/meta/unsubscribe':
|
|
_unsubscribeSuccess(message);
|
|
break;
|
|
default:
|
|
_messageSuccess(message);
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
|
|
function _handleFailure(request, messages, reason, exception, comet)
|
|
{
|
|
var xhr = request.xhr;
|
|
_debug('Request failed, status: {}, reason: {}, exception: {}', xhr && xhr.status, reason, exception);
|
|
|
|
// Signal the transport it can deliver other queued requests
|
|
_transport.complete(request, false, comet);
|
|
|
|
for (var i = 0; i < messages.length; ++i)
|
|
{
|
|
var message = messages[i];
|
|
var channel = message.channel;
|
|
switch (channel)
|
|
{
|
|
case '/meta/handshake':
|
|
_handshakeFailure(xhr, message);
|
|
break;
|
|
case '/meta/connect':
|
|
_connectFailure(xhr, message);
|
|
break;
|
|
case '/meta/disconnect':
|
|
_disconnectFailure(xhr, message);
|
|
break;
|
|
case '/meta/subscribe':
|
|
_subscribeFailure(xhr, message);
|
|
break;
|
|
case '/meta/unsubscribe':
|
|
_unsubscribeFailure(xhr, message);
|
|
break;
|
|
default:
|
|
_messageFailure(xhr, message);
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
|
|
function _handshakeSuccess(message)
|
|
{
|
|
if (message.successful)
|
|
{
|
|
_debug('Handshake successful');
|
|
// Save clientId, figure out transport, then follow the advice to connect
|
|
_clientId = message.clientId;
|
|
|
|
var newTransport = _findTransport(message);
|
|
if (newTransport === null)
|
|
{
|
|
throw 'Could not agree on transport with server';
|
|
}
|
|
else
|
|
{
|
|
if (_transport.getType() != newTransport.getType())
|
|
{
|
|
_debug('Changing transport from {} to {}', _transport.getType(), newTransport.getType());
|
|
_transport = newTransport;
|
|
}
|
|
}
|
|
|
|
// Notify the listeners
|
|
// Here the new transport is in place, as well as the clientId, so
|
|
// the listener can perform a publish() if it wants, and the listeners
|
|
// are notified before the connect below.
|
|
_notifyListeners('/meta/handshake', message);
|
|
|
|
var action = _advice.reconnect ? _advice.reconnect : 'retry';
|
|
switch (action)
|
|
{
|
|
case 'retry':
|
|
_delayedConnect();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_debug('Handshake unsuccessful');
|
|
|
|
var retry = !_isDisconnected() && _advice.reconnect != 'none';
|
|
if (!retry) _setStatus('disconnected');
|
|
|
|
_notifyListeners('/meta/handshake', message);
|
|
_notifyListeners('/meta/unsuccessful', message);
|
|
|
|
// Only try again if we haven't been disconnected and
|
|
// the advice permits us to retry the handshake
|
|
if (retry)
|
|
{
|
|
_increaseBackoff();
|
|
_debug('Handshake failure, backing off and retrying in {} ms', _backoff);
|
|
_delayedHandshake();
|
|
}
|
|
}
|
|
};
|
|
|
|
function _handshakeFailure(xhr, message)
|
|
{
|
|
_debug('Handshake failure');
|
|
|
|
// Notify listeners
|
|
var failureMessage = {
|
|
successful: false,
|
|
failure: true,
|
|
channel: '/meta/handshake',
|
|
request: message,
|
|
xhr: xhr,
|
|
advice: {
|
|
action: 'retry',
|
|
interval: _backoff
|
|
}
|
|
};
|
|
|
|
var retry = !_isDisconnected() && _advice.reconnect != 'none';
|
|
if (!retry) _setStatus('disconnected');
|
|
|
|
_notifyListeners('/meta/handshake', failureMessage);
|
|
_notifyListeners('/meta/unsuccessful', failureMessage);
|
|
|
|
// Only try again if we haven't been disconnected and the
|
|
// advice permits us to try again
|
|
if (retry)
|
|
{
|
|
_increaseBackoff();
|
|
_debug('Handshake failure, backing off and retrying in {} ms', _backoff);
|
|
_delayedHandshake();
|
|
}
|
|
};
|
|
|
|
function _connectSuccess(message)
|
|
{
|
|
var action = _isDisconnected() ? 'none' : (_advice.reconnect ? _advice.reconnect : 'retry');
|
|
if (!_isDisconnected()) _setStatus(action == 'retry' ? 'connecting' : 'disconnecting');
|
|
|
|
if (message.successful)
|
|
{
|
|
_debug('Connect successful');
|
|
|
|
// End the batch and allow held messages from the application
|
|
// to go to the server (see _handshake() where we start the batch).
|
|
// The batch is ended before notifying the listeners, so that
|
|
// listeners can batch other cometd operations
|
|
_endBatch(true);
|
|
|
|
// Notify the listeners after the status change but before the next connect
|
|
_notifyListeners('/meta/connect', message);
|
|
|
|
// Connect was successful.
|
|
// Normally, the advice will say "reconnect: 'retry', interval: 0"
|
|
// and the server will hold the request, so when a response returns
|
|
// we immediately call the server again (long polling)
|
|
switch (action)
|
|
{
|
|
case 'retry':
|
|
_resetBackoff();
|
|
_delayedConnect();
|
|
break;
|
|
default:
|
|
_resetBackoff();
|
|
_setStatus('disconnected');
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_debug('Connect unsuccessful');
|
|
|
|
// Notify the listeners after the status change but before the next action
|
|
_notifyListeners('/meta/connect', message);
|
|
_notifyListeners('/meta/unsuccessful', message);
|
|
|
|
// Connect was not successful.
|
|
// This may happen when the server crashed, the current clientId
|
|
// will be invalid, and the server will ask to handshake again
|
|
switch (action)
|
|
{
|
|
case 'retry':
|
|
_increaseBackoff();
|
|
_delayedConnect();
|
|
break;
|
|
case 'handshake':
|
|
// End the batch but do not deliver the messages until we connect successfully
|
|
_endBatch(false);
|
|
_resetBackoff();
|
|
_delayedHandshake();
|
|
break;
|
|
case 'none':
|
|
_resetBackoff();
|
|
_setStatus('disconnected');
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
|
|
function _connectFailure(xhr, message)
|
|
{
|
|
_debug('Connect failure');
|
|
|
|
// Notify listeners
|
|
var failureMessage = {
|
|
successful: false,
|
|
failure: true,
|
|
channel: '/meta/connect',
|
|
request: message,
|
|
xhr: xhr,
|
|
advice: {
|
|
action: 'retry',
|
|
interval: _backoff
|
|
}
|
|
};
|
|
_notifyListeners('/meta/connect', failureMessage);
|
|
_notifyListeners('/meta/unsuccessful', failureMessage);
|
|
|
|
if (!_isDisconnected())
|
|
{
|
|
var action = _advice.reconnect ? _advice.reconnect : 'retry';
|
|
switch (action)
|
|
{
|
|
case 'retry':
|
|
_increaseBackoff();
|
|
_debug('Connect failure, backing off and retrying in {} ms', _backoff);
|
|
_delayedConnect();
|
|
break;
|
|
case 'handshake':
|
|
_resetBackoff();
|
|
_delayedHandshake();
|
|
break;
|
|
case 'none':
|
|
_resetBackoff();
|
|
break;
|
|
default:
|
|
_debug('Unrecognized reconnect value: {}', action);
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
|
|
function _disconnectSuccess(message)
|
|
{
|
|
if (message.successful)
|
|
{
|
|
_debug('Disconnect successful');
|
|
_disconnect(false);
|
|
_notifyListeners('/meta/disconnect', message);
|
|
}
|
|
else
|
|
{
|
|
_debug('Disconnect unsuccessful');
|
|
_disconnect(true);
|
|
_notifyListeners('/meta/disconnect', message);
|
|
_notifyListeners('/meta/usuccessful', message);
|
|
}
|
|
};
|
|
|
|
function _disconnect(abort)
|
|
{
|
|
_cancelDelayedSend();
|
|
if (abort) _transport.abort();
|
|
_clientId = null;
|
|
_setStatus('disconnected');
|
|
_batch = 0;
|
|
_messageQueue = [];
|
|
_resetBackoff();
|
|
};
|
|
|
|
function _disconnectFailure(xhr, message)
|
|
{
|
|
_debug('Disconnect failure');
|
|
_disconnect(true);
|
|
|
|
var failureMessage = {
|
|
successful: false,
|
|
failure: true,
|
|
channel: '/meta/disconnect',
|
|
request: message,
|
|
xhr: xhr,
|
|
advice: {
|
|
action: 'none',
|
|
interval: 0
|
|
}
|
|
};
|
|
_notifyListeners('/meta/disconnect', failureMessage);
|
|
_notifyListeners('/meta/unsuccessful', failureMessage);
|
|
};
|
|
|
|
function _subscribeSuccess(message)
|
|
{
|
|
if (message.successful)
|
|
{
|
|
_debug('Subscribe successful');
|
|
_notifyListeners('/meta/subscribe', message);
|
|
}
|
|
else
|
|
{
|
|
_debug('Subscribe unsuccessful');
|
|
_notifyListeners('/meta/subscribe', message);
|
|
_notifyListeners('/meta/unsuccessful', message);
|
|
}
|
|
};
|
|
|
|
function _subscribeFailure(xhr, message)
|
|
{
|
|
_debug('Subscribe failure');
|
|
|
|
var failureMessage = {
|
|
successful: false,
|
|
failure: true,
|
|
channel: '/meta/subscribe',
|
|
request: message,
|
|
xhr: xhr,
|
|
advice: {
|
|
action: 'none',
|
|
interval: 0
|
|
}
|
|
};
|
|
_notifyListeners('/meta/subscribe', failureMessage);
|
|
_notifyListeners('/meta/unsuccessful', failureMessage);
|
|
};
|
|
|
|
function _unsubscribeSuccess(message)
|
|
{
|
|
if (message.successful)
|
|
{
|
|
_debug('Unsubscribe successful');
|
|
_notifyListeners('/meta/unsubscribe', message);
|
|
}
|
|
else
|
|
{
|
|
_debug('Unsubscribe unsuccessful');
|
|
_notifyListeners('/meta/unsubscribe', message);
|
|
_notifyListeners('/meta/unsuccessful', message);
|
|
}
|
|
};
|
|
|
|
function _unsubscribeFailure(xhr, message)
|
|
{
|
|
_debug('Unsubscribe failure');
|
|
|
|
var failureMessage = {
|
|
successful: false,
|
|
failure: true,
|
|
channel: '/meta/unsubscribe',
|
|
request: message,
|
|
xhr: xhr,
|
|
advice: {
|
|
action: 'none',
|
|
interval: 0
|
|
}
|
|
};
|
|
_notifyListeners('/meta/unsubscribe', failureMessage);
|
|
_notifyListeners('/meta/unsuccessful', failureMessage);
|
|
};
|
|
|
|
function _messageSuccess(message)
|
|
{
|
|
if (message.successful === undefined)
|
|
{
|
|
if (message.data)
|
|
{
|
|
// It is a plain message, and not a bayeux meta message
|
|
_notifyListeners(message.channel, message);
|
|
}
|
|
else
|
|
{
|
|
_debug('Unknown message {}', JSON.stringify(message));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (message.successful)
|
|
{
|
|
_debug('Publish successful');
|
|
_notifyListeners('/meta/publish', message);
|
|
}
|
|
else
|
|
{
|
|
_debug('Publish unsuccessful');
|
|
_notifyListeners('/meta/publish', message);
|
|
_notifyListeners('/meta/unsuccessful', message);
|
|
}
|
|
}
|
|
};
|
|
|
|
function _messageFailure(xhr, message)
|
|
{
|
|
_debug('Publish failure');
|
|
|
|
var failureMessage = {
|
|
successful: false,
|
|
failure: true,
|
|
channel: message.channel,
|
|
request: message,
|
|
xhr: xhr,
|
|
advice: {
|
|
action: 'none',
|
|
interval: 0
|
|
}
|
|
};
|
|
_notifyListeners('/meta/publish', failureMessage);
|
|
_notifyListeners('/meta/unsuccessful', failureMessage);
|
|
};
|
|
|
|
function _notifyListeners(channel, message)
|
|
{
|
|
// Notify direct listeners
|
|
_notify(channel, message);
|
|
|
|
// Notify the globbing listeners
|
|
var channelParts = channel.split("/");
|
|
var last = channelParts.length - 1;
|
|
for (var i = last; i > 0; --i)
|
|
{
|
|
var channelPart = channelParts.slice(0, i).join('/') + '/*';
|
|
// We don't want to notify /foo/* if the channel is /foo/bar/baz,
|
|
// so we stop at the first non recursive globbing
|
|
if (i == last) _notify(channelPart, message);
|
|
// Add the recursive globber and notify
|
|
channelPart += '*';
|
|
_notify(channelPart, message);
|
|
}
|
|
};
|
|
|
|
function _notify(channel, message)
|
|
{
|
|
var subscriptions = _listeners[channel];
|
|
if (subscriptions && subscriptions.length > 0)
|
|
{
|
|
for (var i = 0; i < subscriptions.length; ++i)
|
|
{
|
|
var subscription = subscriptions[i];
|
|
// Subscriptions may come and go, so the array may have 'holes'
|
|
if (subscription)
|
|
{
|
|
try
|
|
{
|
|
_debug('Notifying subscription: channel \'{}\', callback \'{}\'', channel, subscription.callback.name);
|
|
subscription.callback.call(subscription.scope, message);
|
|
}
|
|
catch (x)
|
|
{
|
|
// Ignore exceptions from callbacks
|
|
_warn('Exception during execution of callback \'{}\' on channel \'{}\' for message {}, exception: {}', subscription.callback.name, channel, JSON.stringify(message), x);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
function _resetBackoff()
|
|
{
|
|
_backoff = 0;
|
|
};
|
|
|
|
function _increaseBackoff()
|
|
{
|
|
if (_backoff < _maxBackoff) _backoff += _backoffIncrement;
|
|
};
|
|
|
|
var _error = this._error = function(text, args)
|
|
{
|
|
_log('error', _format.apply(this, arguments));
|
|
};
|
|
|
|
var _warn = this._warn = function(text, args)
|
|
{
|
|
_log('warn', _format.apply(this, arguments));
|
|
};
|
|
|
|
var _info = this._info = function(text, args)
|
|
{
|
|
_log('info', _format.apply(this, arguments));
|
|
};
|
|
|
|
var _debug = this._debug = function(text, args)
|
|
{
|
|
_log('debug', _format.apply(this, arguments));
|
|
};
|
|
|
|
function _log(level, text)
|
|
{
|
|
var priority = _logPriorities[level];
|
|
var configPriority = _logPriorities[_logLevel];
|
|
if (!configPriority) configPriority = _logPriorities['info'];
|
|
if (priority >= configPriority)
|
|
{
|
|
if (window.console) window.console.log(text);
|
|
}
|
|
};
|
|
|
|
function _format(text)
|
|
{
|
|
var braces = /\{\}/g;
|
|
var result = '';
|
|
var start = 0;
|
|
var count = 0;
|
|
while (braces.test(text))
|
|
{
|
|
result += text.substr(start, braces.lastIndex - start - 2);
|
|
var arg = arguments[++count];
|
|
result += arg !== undefined ? arg : '{}';
|
|
start = braces.lastIndex;
|
|
}
|
|
result += text.substr(start, text.length - start);
|
|
return result;
|
|
};
|
|
|
|
function newLongPollingTransport()
|
|
{
|
|
return $.extend({}, new Transport('long-polling'), new LongPollingTransport());
|
|
};
|
|
|
|
function newCallbackPollingTransport()
|
|
{
|
|
return $.extend({}, new Transport('callback-polling'), new CallbackPollingTransport());
|
|
};
|
|
|
|
/**
|
|
* Base object with the common functionality for transports.
|
|
* The key responsibility is to allow at most 2 outstanding requests to the server,
|
|
* to avoid that requests are sent behind a long poll.
|
|
* To achieve this, we have one reserved request for the long poll, and all other
|
|
* requests are serialized one after the other.
|
|
*/
|
|
var Transport = function(type)
|
|
{
|
|
var _maxRequests = 2;
|
|
var _requestIds = 0;
|
|
var _cometRequest = null;
|
|
var _requests = [];
|
|
var _packets = [];
|
|
|
|
this.getType = function()
|
|
{
|
|
return type;
|
|
};
|
|
|
|
this.send = function(packet, comet)
|
|
{
|
|
if (comet)
|
|
_cometSend(this, packet);
|
|
else
|
|
_send(this, packet);
|
|
};
|
|
|
|
function _cometSend(self, packet)
|
|
{
|
|
if (_cometRequest !== null) throw 'Concurrent comet requests not allowed, request ' + _cometRequest.id + ' not yet completed';
|
|
|
|
var requestId = ++_requestIds;
|
|
_debug('Beginning comet request {}', requestId);
|
|
|
|
var request = {id: requestId};
|
|
_debug('Delivering comet request {}', requestId);
|
|
self.deliver(packet, request);
|
|
_cometRequest = request;
|
|
};
|
|
|
|
function _send(self, packet)
|
|
{
|
|
var requestId = ++_requestIds;
|
|
_debug('Beginning request {}, {} other requests, {} queued requests', requestId, _requests.length, _packets.length);
|
|
|
|
var request = {id: requestId};
|
|
// Consider the comet request which should always be present
|
|
if (_requests.length < _maxRequests - 1)
|
|
{
|
|
_debug('Delivering request {}', requestId);
|
|
self.deliver(packet, request);
|
|
_requests.push(request);
|
|
}
|
|
else
|
|
{
|
|
_packets.push([packet, request]);
|
|
_debug('Queued request {}, {} queued requests', requestId, _packets.length);
|
|
}
|
|
};
|
|
|
|
this.complete = function(request, success, comet)
|
|
{
|
|
if (comet)
|
|
_cometComplete(request);
|
|
else
|
|
_complete(this, request, success);
|
|
};
|
|
|
|
function _cometComplete(request)
|
|
{
|
|
var requestId = request.id;
|
|
if (_cometRequest !== request) throw 'Comet request mismatch, completing request ' + requestId;
|
|
|
|
// Reset comet request
|
|
_cometRequest = null;
|
|
_debug('Ended comet request {}', requestId);
|
|
};
|
|
|
|
function _complete(self, request, success)
|
|
{
|
|
var requestId = request.id;
|
|
var index = $.inArray(request, _requests);
|
|
// The index can be negative the request has been aborted
|
|
if (index >= 0) _requests.splice(index, 1);
|
|
_debug('Ended request {}, {} other requests, {} queued requests', requestId, _requests.length, _packets.length);
|
|
|
|
if (_packets.length > 0)
|
|
{
|
|
var packet = _packets.shift();
|
|
if (success)
|
|
{
|
|
_debug('Dequeueing and sending request {}, {} queued requests', packet[1].id, _packets.length);
|
|
_send(self, packet[0]);
|
|
}
|
|
else
|
|
{
|
|
_debug('Dequeueing and failing request {}, {} queued requests', packet[1].id, _packets.length);
|
|
// Keep the semantic of calling response callbacks asynchronously after the request
|
|
setTimeout(function() { packet[0].onFailure(packet[1], 'error'); }, 0);
|
|
}
|
|
}
|
|
};
|
|
|
|
this.abort = function()
|
|
{
|
|
for (var i = 0; i < _requests.length; ++i)
|
|
{
|
|
var request = _requests[i];
|
|
_debug('Aborting request {}', request.id);
|
|
if (request.xhr) request.xhr.abort();
|
|
}
|
|
if (_cometRequest)
|
|
{
|
|
_debug('Aborting comet request {}', _cometRequest.id);
|
|
if (_cometRequest.xhr) _cometRequest.xhr.abort();
|
|
}
|
|
_cometRequest = null;
|
|
_requests = [];
|
|
_packets = [];
|
|
};
|
|
};
|
|
|
|
var LongPollingTransport = function()
|
|
{
|
|
this.deliver = function(packet, request)
|
|
{
|
|
request.xhr = $.ajax({
|
|
url: packet.url,
|
|
type: 'POST',
|
|
contentType: 'text/json;charset=UTF-8',
|
|
beforeSend: function(xhr)
|
|
{
|
|
xhr.setRequestHeader('Connection', 'Keep-Alive');
|
|
return true;
|
|
},
|
|
data: JSON.stringify(packet.messages),
|
|
success: function(response) { packet.onSuccess(request, response); },
|
|
error: function(xhr, reason, exception) { packet.onFailure(request, reason, exception); }
|
|
});
|
|
};
|
|
};
|
|
|
|
var CallbackPollingTransport = function()
|
|
{
|
|
var _maxLength = 2000;
|
|
this.deliver = function(packet, request)
|
|
{
|
|
// Microsoft Internet Explorer has a 2083 URL max length
|
|
// We must ensure that we stay within that length
|
|
var messages = JSON.stringify(packet.messages);
|
|
// Encode the messages because all brackets, quotes, commas, colons, etc
|
|
// present in the JSON will be URL encoded, taking many more characters
|
|
var urlLength = packet.url.length + encodeURI(messages).length;
|
|
_debug('URL length: {}', urlLength);
|
|
// Let's stay on the safe side and use 2000 instead of 2083
|
|
// also because we did not count few characters among which
|
|
// the parameter name 'message' and the parameter 'jsonp',
|
|
// which sum up to about 50 chars
|
|
if (urlLength > _maxLength)
|
|
{
|
|
var x = packet.messages.length > 1 ?
|
|
'Too many bayeux messages in the same batch resulting in message too big ' +
|
|
'(' + urlLength + ' bytes, max is ' + _maxLength + ') for transport ' + this.getType() :
|
|
'Bayeux message too big (' + urlLength + ' bytes, max is ' + _maxLength + ') ' +
|
|
'for transport ' + this.getType();
|
|
// Keep the semantic of calling response callbacks asynchronously after the request
|
|
_setTimeout(function() { packet.onFailure(request, 'error', x); }, 0);
|
|
}
|
|
else
|
|
{
|
|
$.ajax({
|
|
url: packet.url,
|
|
type: 'GET',
|
|
dataType: 'jsonp',
|
|
jsonp: 'jsonp',
|
|
beforeSend: function(xhr)
|
|
{
|
|
xhr.setRequestHeader('Connection', 'Keep-Alive');
|
|
return true;
|
|
},
|
|
data:
|
|
{
|
|
// In callback-polling, the content must be sent via the 'message' parameter
|
|
message: messages
|
|
},
|
|
success: function(response) { packet.onSuccess(request, response); },
|
|
error: function(xhr, reason, exception) { packet.onFailure(request, reason, exception); }
|
|
});
|
|
}
|
|
};
|
|
};
|
|
};
|
|
|
|
/**
|
|
* The JS object that exposes the comet API to applications
|
|
*/
|
|
$.cometd = new $.Cometd(); // The default instance
|
|
|
|
})(jQuery);
|