camel-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From davscl...@apache.org
Subject svn commit: r1087994 [8/8] - in /camel/trunk/components/camel-cometd/src: main/java/org/apache/camel/component/cometd/ test/java/org/apache/camel/component/cometd/ test/resources/webapp/ test/resources/webapp/dojo/dojo/ test/resources/webapp/dojo/dojo/...
Date Sat, 02 Apr 2011 10:31:38 GMT
Added: camel/trunk/components/camel-cometd/src/test/resources/webapp/dojo/org/cometd.js
URL: http://svn.apache.org/viewvc/camel/trunk/components/camel-cometd/src/test/resources/webapp/dojo/org/cometd.js?rev=1087994&view=auto
==============================================================================
--- camel/trunk/components/camel-cometd/src/test/resources/webapp/dojo/org/cometd.js (added)
+++ camel/trunk/components/camel-cometd/src/test/resources/webapp/dojo/org/cometd.js Sat Apr  2 10:31:37 2011
@@ -0,0 +1,2411 @@
+/**
+ * Dual licensed under the Apache License 2.0 and the MIT license.
+ * $Revision$ $Date: 2011-03-22 10:32:04 +0100 (Tue, 22 Mar 2011) $
+ */
+
+// Dojo loader support
+if (typeof dojo !== 'undefined')
+{
+    dojo.provide('org.cometd');
+}
+else
+{
+    // Namespaces for the cometd implementation
+    this.org = this.org || {};
+    org.cometd = {};
+}
+
+// Abstract APIs
+org.cometd.JSON = {};
+org.cometd.JSON.toJSON = org.cometd.JSON.fromJSON = function(object)
+{
+    throw 'Abstract';
+};
+
+
+/**
+ * A registry for transports used by the Cometd object.
+ */
+org.cometd.TransportRegistry = function()
+{
+    var _types = [];
+    var _transports = {};
+
+    this.getTransportTypes = function()
+    {
+        return _types.slice(0);
+    };
+
+    this.findTransportTypes = function(version, crossDomain)
+    {
+        var result = [];
+        for (var i = 0; i < _types.length; ++i)
+        {
+            var type = _types[i];
+            if (_transports[type].accept(version, crossDomain) === true)
+            {
+                result.push(type);
+            }
+        }
+        return result;
+    };
+
+    this.negotiateTransport = function(types, version, crossDomain)
+    {
+        for (var i = 0; i < _types.length; ++i)
+        {
+            var type = _types[i];
+            for (var j = 0; j < types.length; ++j)
+            {
+                if (type == types[j])
+                {
+                    var transport = _transports[type];
+                    if (transport.accept(version, crossDomain) === true)
+                    {
+                        return transport;
+                    }
+                }
+            }
+        }
+        return null;
+    };
+
+    this.add = function(type, transport, index)
+    {
+        var existing = false;
+        for (var i = 0; i < _types.length; ++i)
+        {
+            if (_types[i] == type)
+            {
+                existing = true;
+                break;
+            }
+        }
+
+        if (!existing)
+        {
+            if (typeof index !== 'number')
+            {
+                _types.push(type);
+            }
+            else
+            {
+                _types.splice(index, 0, type);
+            }
+            _transports[type] = transport;
+        }
+
+        return !existing;
+    };
+
+    this.remove = function(type)
+    {
+        for (var i = 0; i < _types.length; ++i)
+        {
+            if (_types[i] == type)
+            {
+                _types.splice(i, 1);
+                var transport = _transports[type];
+                delete _transports[type];
+                return transport;
+            }
+        }
+        return null;
+    };
+
+    this.reset = function()
+    {
+        for (var i = 0; i < _types.length; ++i)
+        {
+            _transports[_types[i]].reset();
+        }
+    };
+};
+
+
+/**
+ * The constructor for a Cometd object, identified by an optional name.
+ * The default name is the string 'default'.
+ * In the rare case a page needs more than one Bayeux conversation,
+ * a new instance can be created via:
+ * <pre>
+ * var bayeuxUrl2 = ...;
+ * var cometd2 = new $.Cometd();
+ * cometd2.init({url: bayeuxUrl2});
+ * </pre>
+ * @param name the optional name of this cometd object
+ */
+// IMPLEMENTATION NOTES:
+// Be very careful in not changing the function order and pass this file every time through JSLint (http://jslint.com)
+// The only implied globals must be "dojo", "org" and "window", and check that there are no "unused" warnings
+// Failing to pass JSLint may result in shrinkers/minifiers to create an unusable file.
+org.cometd.Cometd = function(name)
+{
+    var _cometd = this;
+    var _name = name || 'default';
+    var _logLevel; // 'warn','info','debug'
+    var _url;
+    var _maxConnections;
+    var _backoffIncrement;
+    var _maxBackoff;
+    var _reverseIncomingExtensions;
+    var _maxNetworkDelay;
+    var _requestHeaders;
+    var _appendMessageTypeToURL;
+    var _autoBatch;
+    var _crossDomain = false;
+    var _transports = new org.cometd.TransportRegistry();
+    var _transport;
+    var _status = 'disconnected';
+    var _messageId = 0;
+    var _clientId = null;
+    var _batch = 0;
+    var _messageQueue = [];
+    var _internalBatch = false;
+    var _listeners = {};
+    var _backoff = 0;
+    var _scheduledSend = null;
+    var _extensions = [];
+    var _advice = {};
+    var _handshakeProps;
+    var _reestablish = false;
+    var _connected = true;
+
+    /**
+     * Mixes in the given objects into the target object by copying the properties.
+     * @param deep if the copy must be deep
+     * @param target the target object
+     * @param objects the objects whose properties are copied into the target
+     */
+    function _mixin(deep, target, objects)
+    {
+        var result = target || {};
+
+        // Skip first 2 parameters (deep and target), and loop over the others
+        for (var i = 2; i < arguments.length; ++i)
+        {
+            var object = arguments[i];
+
+            if (object === undefined || object === null)
+            {
+                continue;
+            }
+
+            for (var propName in object)
+            {
+                var prop = object[propName];
+
+                // Avoid infinite loops
+                if (prop === target)
+                {
+                    continue;
+                }
+                // Do not mixin undefined values
+                if (prop === undefined)
+                {
+                    continue;
+                }
+
+                if (deep && typeof prop === 'object' && prop !== null)
+                {
+                    if (prop instanceof Array)
+                    {
+                        result[propName] = _mixin(deep, [], prop);
+                    }
+                    else
+                    {
+                        result[propName] = _mixin(deep, {}, prop);
+                    }
+                }
+                else
+                {
+                    result[propName] = prop;
+                }
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * This method is exposed as facility for extensions that may need to clone messages.
+     */
+    this._mixin = _mixin;
+
+    /**
+     * Returns whether the given element is contained into the given array.
+     * @param element the element to check presence for
+     * @param array the array to check for the element presence
+     * @return the index of the element, if present, or a negative index if the element is not present
+     */
+    function _inArray(element, array)
+    {
+        for (var i = 0; i < array.length; ++i)
+        {
+            if (element == array[i])
+            {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    function _isString(value)
+    {
+        if (value === undefined || value === null)
+        {
+            return false;
+        }
+        return typeof value === 'string' ||  value instanceof String;
+    }
+
+    function _isArray(value)
+    {
+        if (value === undefined || value === null)
+        {
+            return false;
+        }
+        return value instanceof Array;
+    }
+
+    function _isFunction(value)
+    {
+        if (value === undefined || value === null)
+        {
+            return false;
+        }
+        return typeof value === 'function';
+    }
+
+    function _log(level, args)
+    {
+        if (window.console)
+        {
+            var logger = window.console[level];
+            if (_isFunction(logger))
+            {
+                logger.apply(window.console, args);
+            }
+        }
+    }
+
+    function _warn()
+    {
+        _log('warn', arguments);
+    }
+    this._warn = _warn;
+
+    function _info()
+    {
+        if (_logLevel != 'warn')
+        {
+            _log('info', arguments);
+        }
+    }
+    this._info = _info;
+
+    function _debug()
+    {
+        if (_logLevel == 'debug')
+        {
+            _log('debug', arguments);
+        }
+    }
+    this._debug = _debug;
+
+    function _configure(configuration)
+    {
+        _debug('Configuring cometd object with', configuration);
+        // Support old style param, where only the Bayeux server URL was passed
+        if (_isString(configuration))
+        {
+            configuration = { url: configuration };
+        }
+        if (!configuration)
+        {
+            configuration = {};
+        }
+
+        _url = configuration.url;
+        if (!_url)
+        {
+            throw 'Missing required configuration parameter \'url\' specifying the Bayeux server URL';
+        }
+        _maxConnections = configuration.maxConnections || 2;
+        _backoffIncrement = configuration.backoffIncrement || 1000;
+        _maxBackoff = configuration.maxBackoff || 60000;
+        _logLevel = configuration.logLevel || 'info';
+        _reverseIncomingExtensions = configuration.reverseIncomingExtensions !== false;
+        _maxNetworkDelay = configuration.maxNetworkDelay || 10000;
+        _requestHeaders = configuration.requestHeaders || {};
+        _appendMessageTypeToURL = configuration.appendMessageTypeToURL !== false;
+        _autoBatch = configuration.autoBatch === true;
+
+        // Check if we're cross domain
+        // [1] = protocol:, [2] = //host:port, [3] = host:port, [4] = host, [5] = :port, [6] = port, [7] = uri, [8] = rest
+        var urlParts = /(^https?:)?(\/\/(([^:\/\?#]+)(:(\d+))?))?([^\?#]*)(.*)?/.exec(_url);
+        _crossDomain = urlParts[3] && urlParts[3] != window.location.host;
+
+        // Check if appending extra path is supported
+        if (_appendMessageTypeToURL)
+        {
+            if (urlParts[8] !== undefined)
+            {
+                _info('Appending message type to URI ' + urlParts[7] + urlParts[8] + ' is not supported, disabling \'appendMessageTypeToURL\' configuration');
+                _appendMessageTypeToURL = false;
+            }
+            else
+            {
+                var uriSegments = urlParts[7].split('/');
+                var lastSegmentIndex = uriSegments.length - 1;
+                if (urlParts[7].match(/\/$/))
+                {
+                    lastSegmentIndex -= 1;
+                }
+                if (uriSegments[lastSegmentIndex].indexOf('.') >= 0)
+                {
+                    // Very likely the CometD servlet's URL pattern is mapped to an extension, such as *.cometd
+                    // It will be difficult to add the extra path in this case
+                    _info('Appending message type to URI ' + urlParts[7] + ' is not supported, disabling \'appendMessageTypeToURL\' configuration');
+                    _appendMessageTypeToURL = false;
+                }
+            }
+        }
+    }
+
+    function _clearSubscriptions()
+    {
+        for (var channel in _listeners)
+        {
+            var subscriptions = _listeners[channel];
+            for (var i = 0; i < subscriptions.length; ++i)
+            {
+                var subscription = subscriptions[i];
+                if (subscription && !subscription.listener)
+                {
+                    delete subscriptions[i];
+                    _debug('Removed subscription', subscription, 'for channel', channel);
+                }
+            }
+        }
+    }
+
+    function _setStatus(newStatus)
+    {
+        if (_status != newStatus)
+        {
+            _debug('Status', _status, '->', newStatus);
+            _status = newStatus;
+        }
+    }
+
+    function _isDisconnected()
+    {
+        return _status == 'disconnecting' || _status == 'disconnected';
+    }
+
+    function _nextMessageId()
+    {
+        return ++_messageId;
+    }
+
+    function _applyExtension(scope, callback, name, message, outgoing)
+    {
+        try
+        {
+            return callback.call(scope, message);
+        }
+        catch (x)
+        {
+            _debug('Exception during execution of extension', name, x);
+            var exceptionCallback = _cometd.onExtensionException;
+            if (_isFunction(exceptionCallback))
+            {
+                _debug('Invoking extension exception callback', name, x);
+                try
+                {
+                    exceptionCallback.call(_cometd, x, name, outgoing, message);
+                }
+                catch(xx)
+                {
+                    _info('Exception during execution of exception callback in extension', name, xx);
+                }
+            }
+            return message;
+        }
+    }
+
+    function _applyIncomingExtensions(message)
+    {
+        for (var i = 0; i < _extensions.length; ++i)
+        {
+            if (message === undefined || message === null)
+            {
+                break;
+            }
+
+            var index = _reverseIncomingExtensions ? _extensions.length - 1 - i : i;
+            var extension = _extensions[index];
+            var callback = extension.extension.incoming;
+            if (_isFunction(callback))
+            {
+                var result = _applyExtension(extension.extension, callback, extension.name, message, false);
+                message = result === undefined ? message : result;
+            }
+        }
+        return message;
+    }
+
+    function _applyOutgoingExtensions(message)
+    {
+        for (var i = 0; i < _extensions.length; ++i)
+        {
+            if (message === undefined || message === null)
+            {
+                break;
+            }
+
+            var extension = _extensions[i];
+            var callback = extension.extension.outgoing;
+            if (_isFunction(callback))
+            {
+                var result = _applyExtension(extension.extension, callback, extension.name, message, true);
+                message = result === undefined ? message : result;
+            }
+        }
+        return message;
+    }
+
+    /**
+     * 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 (_isString(response))
+        {
+            try
+            {
+                return org.cometd.JSON.fromJSON(response);
+            }
+            catch(x)
+            {
+                _debug('Could not convert to JSON the following string', '"' + response + '"');
+                throw x;
+            }
+        }
+        if (_isArray(response))
+        {
+            return response;
+        }
+        if (response === undefined || response === null)
+        {
+            return [];
+        }
+        if (response instanceof Object)
+        {
+            return [response];
+        }
+        throw 'Conversion Error ' + response + ', typeof ' + (typeof response);
+    }
+
+    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
+                    {
+                        subscription.callback.call(subscription.scope, message);
+                    }
+                    catch (x)
+                    {
+                        _debug('Exception during notification', subscription, message, x);
+                        var listenerCallback = _cometd.onListenerException;
+                        if (_isFunction(listenerCallback))
+                        {
+                            _debug('Invoking listener exception callback', subscription, x);
+                            try
+                            {
+                                listenerCallback.call(_cometd, x, subscription.handle, subscription.listener, message);
+                            }
+                            catch (xx)
+                            {
+                                _info('Exception during execution of listener callback', subscription, xx);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    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 _setTimeout(funktion, delay)
+    {
+        return setTimeout(function()
+        {
+            try
+            {
+                funktion();
+            }
+            catch (x)
+            {
+                _debug('Exception invoking timed function', funktion, x);
+            }
+        }, delay);
+    }
+
+    function _cancelDelayedSend()
+    {
+        if (_scheduledSend !== null)
+        {
+            clearTimeout(_scheduledSend);
+        }
+        _scheduledSend = null;
+    }
+
+    function _delayedSend(operation)
+    {
+        _cancelDelayedSend();
+        var delay = _backoff;
+        if (_advice.interval && _advice.interval > 0)
+        {
+            delay += _advice.interval;
+        }
+        _scheduledSend = _setTimeout(operation, delay);
+    }
+
+    // Needed to break cyclic dependencies between function definitions
+    var _handleResponse;
+    var _handleFailure;
+
+    /**
+     * Delivers the messages to the CometD server
+     * @param messages the array of messages to send
+     * @param longpoll true if this send is a long poll
+     */
+    function _send(sync, messages, longpoll, extraPath)
+    {
+        // 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.
+        for (var i = 0; i < messages.length; ++i)
+        {
+            var message = messages[i];
+            message.id = '' + _nextMessageId();
+            if (_clientId)
+            {
+                message.clientId = _clientId;
+            }
+            message = _applyOutgoingExtensions(message);
+            if (message !== undefined && message !== null)
+            {
+                messages[i] = message;
+            }
+            else
+            {
+                messages.splice(i--, 1);
+            }
+        }
+        if (messages.length === 0)
+        {
+            return;
+        }
+
+        var url = _url;
+        if (_appendMessageTypeToURL)
+        {
+            // If url does not end with '/', then append it
+            if (!url.match(/\/$/))
+            {
+                url = url + '/';
+            }
+            if (extraPath)
+            {
+                url = url + extraPath;
+            }
+        }
+
+        var envelope = {
+            url: url,
+            sync: sync,
+            messages: messages,
+            onSuccess: function(request, response)
+            {
+                try
+                {
+                    _handleResponse.call(_cometd, request, response, longpoll);
+                }
+                catch (x)
+                {
+                    _debug('Exception during handling of response', x);
+                }
+            },
+            onFailure: function(request, reason, exception)
+            {
+                try
+                {
+                    _handleFailure.call(_cometd, request, messages, reason, exception, longpoll);
+                }
+                catch (x)
+                {
+                    _debug('Exception during handling of failure', x);
+                }
+            }
+        };
+        _debug('Send, sync=' + sync, envelope);
+        _transport.send(envelope, longpoll);
+    }
+
+    function _queueSend(message)
+    {
+        if (_batch > 0 || _internalBatch === true)
+        {
+            _messageQueue.push(message);
+        }
+        else
+        {
+            _send(false, [message], false);
+        }
+    }
+
+    /**
+     * Sends a complete bayeux message.
+     * This method is exposed as a public so that extensions may use it
+     * to send bayeux message directly, for example in case of re-sending
+     * messages that have already been sent but that for some reason must
+     * be resent.
+     */
+    this.send = _queueSend;
+
+    function _resetBackoff()
+    {
+        _backoff = 0;
+    }
+
+    function _increaseBackoff()
+    {
+        if (_backoff < _maxBackoff)
+        {
+            _backoff += _backoffIncrement;
+        }
+    }
+
+    /**
+     * Starts a the batch of messages to be sent in a single request.
+     * @see #_endBatch(sendMessages)
+     */
+    function _startBatch()
+    {
+        ++_batch;
+    }
+
+    function _flushBatch()
+    {
+        var messages = _messageQueue;
+        _messageQueue = [];
+        if (messages.length > 0)
+        {
+            _send(false, messages, false);
+        }
+    }
+
+    /**
+     * Ends the batch of messages to be sent in a single request,
+     * optionally sending messages present in the message queue depending
+     * on the given argument.
+     * @see #_startBatch()
+     */
+    function _endBatch()
+    {
+        --_batch;
+        if (_batch < 0)
+        {
+            throw 'Calls to startBatch() and endBatch() are not paired';
+        }
+
+        if (_batch === 0 && !_isDisconnected() && !_internalBatch)
+        {
+            _flushBatch();
+        }
+    }
+
+    /**
+     * Sends the connect message
+     */
+    function _connect()
+    {
+        if (!_isDisconnected())
+        {
+            var message = {
+                channel: '/meta/connect',
+                connectionType: _transport.getType()
+            };
+            if (!_connected)
+            {
+                _connected = true;
+                message.advice = { timeout: 0 };
+            }
+            _setStatus('connecting');
+            _debug('Connect sent', message);
+            _send(false, [message], true, 'connect');
+            _setStatus('connected');
+        }
+    }
+
+    function _delayedConnect()
+    {
+        _setStatus('connecting');
+        _delayedSend(function()
+        {
+            _connect();
+        });
+    }
+
+    /**
+     * Sends the initial handshake message
+     */
+    function _handshake(handshakeProps)
+    {
+        _clientId = null;
+
+        _clearSubscriptions();
+
+        // Reset the transports if we're not retrying the handshake
+        if (_isDisconnected())
+        {
+            _transports.reset();
+        }
+
+        _batch = 0;
+
+        // Mark the start of an internal 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 temporarily any message until
+        // the connection is fully established.
+        _internalBatch = true;
+
+        // Save the properties provided by the user, so that
+        // we can reuse them during automatic re-handshake
+        _handshakeProps = handshakeProps;
+
+        var version = '1.0';
+
+        // Figure out the transports to send to the server
+        var transportTypes = _transports.findTransportTypes(version, _crossDomain);
+
+        var bayeuxMessage = {
+            version: version,
+            minimumVersion: '0.9',
+            channel: '/meta/handshake',
+            supportedConnectionTypes: transportTypes
+        };
+        // Do not allow the user to mess with the required properties,
+        // so merge first the user properties and *then* the bayeux message
+        var message = _mixin(false, {}, _handshakeProps, bayeuxMessage);
+
+        // Pick up the first available transport as initial transport
+        // since we don't know if the server supports it
+        _transport = _transports.negotiateTransport(transportTypes, version, _crossDomain);
+        _debug('Initial transport is', _transport.getType());
+
+        // We started a batch to hold the application messages,
+        // so here we must bypass it and send immediately.
+        _setStatus('handshaking');
+        _debug('Handshake sent', message);
+        _send(false, [message], false, 'handshake');
+    }
+
+    function _delayedHandshake()
+    {
+        _setStatus('handshaking');
+
+        // We will call _handshake() which will reset _clientId, but we want to avoid
+        // that between the end of this method and the call to _handshake() someone may
+        // call publish() (or other methods that call _queueSend()).
+        _internalBatch = true;
+
+        _delayedSend(function()
+        {
+            _handshake(_handshakeProps);
+        });
+    }
+
+    function _handshakeResponse(message)
+    {
+        if (message.successful)
+        {
+            // Save clientId, figure out transport, then follow the advice to connect
+            _clientId = message.clientId;
+
+            var newTransport = _transports.negotiateTransport(message.supportedConnectionTypes, message.version, _crossDomain);
+            if (newTransport === null)
+            {
+                throw 'Could not negotiate transport with server; client ' +
+                      _transports.findTransportTypes(message.version, _crossDomain) +
+                      ', server ' + message.supportedConnectionTypes;
+            }
+            else if (_transport != newTransport)
+            {
+                _debug('Transport', _transport.getType(), '->', newTransport.getType());
+                _transport = newTransport;
+            }
+
+            // End the internal batch and allow held messages from the application
+            // to go to the server (see _handshake() where we start the internal batch).
+            _internalBatch = false;
+            _flushBatch();
+
+            // Here the new transport is in place, as well as the clientId, so
+            // the listeners can perform a publish() if they want.
+            // Notify the listeners before the connect below.
+            message.reestablish = _reestablish;
+            _reestablish = true;
+            _notifyListeners('/meta/handshake', message);
+
+            if (!_isDisconnected())
+            {
+                if (_advice.reconnect != 'none')
+                {
+                    _resetBackoff();
+                    _delayedConnect();
+                }
+                else
+                {
+                    _resetBackoff();
+                    _setStatus('disconnected');
+                }
+            }
+        }
+        else
+        {
+            _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 (!_isDisconnected())
+            {
+                if (_advice.reconnect != 'none')
+                {
+                    _increaseBackoff();
+                    _delayedHandshake();
+                }
+                else
+                {
+                    _resetBackoff();
+                    _setStatus('disconnected');
+                }
+            }
+        }
+    }
+
+    function _handshakeFailure(xhr, message)
+    {
+        // Notify listeners
+        var failureMessage = {
+            successful: false,
+            failure: true,
+            channel: '/meta/handshake',
+            request: message,
+            xhr: xhr,
+            advice: {
+                reconnect: 'retry',
+                interval: _backoff
+            }
+        };
+
+        _notifyListeners('/meta/handshake', failureMessage);
+        _notifyListeners('/meta/unsuccessful', failureMessage);
+
+        // Only try again if we haven't been disconnected and
+        // the advice permits us to retry the handshake
+        if (!_isDisconnected())
+        {
+            if (_advice.reconnect != 'none')
+            {
+                _increaseBackoff();
+                _delayedHandshake();
+            }
+            else
+            {
+                _resetBackoff();
+                _setStatus('disconnected');
+            }
+        }
+    }
+
+    function _connectResponse(message)
+    {
+        _connected = message.successful;
+        if (_connected)
+        {
+            // 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)
+            if (!_isDisconnected())
+            {
+                if (!_advice.reconnect || _advice.reconnect == 'retry')
+                {
+                    _resetBackoff();
+                    _delayedConnect();
+                }
+                else
+                {
+                    _resetBackoff();
+                    _setStatus('disconnected');
+                }
+            }
+        }
+        else
+        {
+            // Notify the listeners after the status change but before the next action
+            _info('Connect failed:', message.error);
+            _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
+            if (!_isDisconnected())
+            {
+                var action = _advice.reconnect ? _advice.reconnect : 'retry';
+                switch (action)
+                {
+                    case 'retry':
+                        _increaseBackoff();
+                        _delayedConnect();
+                        break;
+                    case 'handshake':
+                        _resetBackoff();
+                        _delayedHandshake();
+                        break;
+                    case 'none':
+                        _resetBackoff();
+                        _setStatus('disconnected');
+                        break;
+                    default:
+                        _info('Unrecognized advice action', action);
+                        break;
+                }
+            }
+        }
+    }
+
+    function _connectFailure(xhr, message)
+    {
+        _connected = false;
+
+        // Notify listeners
+        var failureMessage = {
+            successful: false,
+            failure: true,
+            channel: '/meta/connect',
+            request: message,
+            xhr: xhr,
+            advice: {
+                reconnect: '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();
+                    _delayedConnect();
+                    break;
+                case 'handshake':
+                    _resetBackoff();
+                    _delayedHandshake();
+                    break;
+                case 'none':
+                    _resetBackoff();
+                    _setStatus('disconnected');
+                    break;
+                default:
+                    _info('Unrecognized advice action', action);
+                    break;
+            }
+        }
+    }
+
+    function _disconnect(abort)
+    {
+        _cancelDelayedSend();
+        if (abort)
+        {
+            _transport.abort();
+        }
+        _clientId = null;
+        _setStatus('disconnected');
+        _batch = 0;
+        _messageQueue = [];
+        _resetBackoff();
+    }
+
+    function _disconnectResponse(message)
+    {
+        if (message.successful)
+        {
+            _disconnect(false);
+            _notifyListeners('/meta/disconnect', message);
+        }
+        else
+        {
+            _disconnect(true);
+            _notifyListeners('/meta/disconnect', message);
+            _notifyListeners('/meta/unsuccessful', message);
+        }
+    }
+
+    function _disconnectFailure(xhr, message)
+    {
+        _disconnect(true);
+
+        var failureMessage = {
+            successful: false,
+            failure: true,
+            channel: '/meta/disconnect',
+            request: message,
+            xhr: xhr,
+            advice: {
+                reconnect: 'none',
+                interval: 0
+            }
+        };
+        _notifyListeners('/meta/disconnect', failureMessage);
+        _notifyListeners('/meta/unsuccessful', failureMessage);
+    }
+
+    function _subscribeResponse(message)
+    {
+        if (message.successful)
+        {
+            _notifyListeners('/meta/subscribe', message);
+        }
+        else
+        {
+            _info('Subscription to', message.subscription, 'failed:', message.error);
+            _notifyListeners('/meta/subscribe', message);
+            _notifyListeners('/meta/unsuccessful', message);
+        }
+    }
+
+    function _subscribeFailure(xhr, message)
+    {
+        var failureMessage = {
+            successful: false,
+            failure: true,
+            channel: '/meta/subscribe',
+            request: message,
+            xhr: xhr,
+            advice: {
+                reconnect: 'none',
+                interval: 0
+            }
+        };
+        _notifyListeners('/meta/subscribe', failureMessage);
+        _notifyListeners('/meta/unsuccessful', failureMessage);
+    }
+
+    function _unsubscribeResponse(message)
+    {
+        if (message.successful)
+        {
+            _notifyListeners('/meta/unsubscribe', message);
+        }
+        else
+        {
+            _info('Unsubscription to', message.subscription, 'failed:', message.error);
+            _notifyListeners('/meta/unsubscribe', message);
+            _notifyListeners('/meta/unsuccessful', message);
+        }
+    }
+
+    function _unsubscribeFailure(xhr, message)
+    {
+        var failureMessage = {
+            successful: false,
+            failure: true,
+            channel: '/meta/unsubscribe',
+            request: message,
+            xhr: xhr,
+            advice: {
+                reconnect: 'none',
+                interval: 0
+            }
+        };
+        _notifyListeners('/meta/unsubscribe', failureMessage);
+        _notifyListeners('/meta/unsuccessful', failureMessage);
+    }
+
+    function _messageResponse(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', message);
+            }
+        }
+        else
+        {
+            if (message.successful)
+            {
+                _notifyListeners('/meta/publish', message);
+            }
+            else
+            {
+                _info('Publish failed:', message.error);
+                _notifyListeners('/meta/publish', message);
+                _notifyListeners('/meta/unsuccessful', message);
+            }
+        }
+    }
+
+    function _messageFailure(xhr, message)
+    {
+        var failureMessage = {
+            successful: false,
+            failure: true,
+            channel: message.channel,
+            request: message,
+            xhr: xhr,
+            advice: {
+                reconnect: 'none',
+                interval: 0
+            }
+        };
+        _notifyListeners('/meta/publish', failureMessage);
+        _notifyListeners('/meta/unsuccessful', failureMessage);
+    }
+
+    function _receive(message)
+    {
+        message = _applyIncomingExtensions(message);
+        if (message === undefined || message === null)
+        {
+            return;
+        }
+
+        if (message.advice)
+        {
+            _advice = message.advice;
+        }
+
+        var channel = message.channel;
+        switch (channel)
+        {
+            case '/meta/handshake':
+                _handshakeResponse(message);
+                break;
+            case '/meta/connect':
+                _connectResponse(message);
+                break;
+            case '/meta/disconnect':
+                _disconnectResponse(message);
+                break;
+            case '/meta/subscribe':
+                _subscribeResponse(message);
+                break;
+            case '/meta/unsubscribe':
+                _unsubscribeResponse(message);
+                break;
+            default:
+                _messageResponse(message);
+                break;
+        }
+    }
+
+    /**
+     * Receives a message.
+     * This method is exposed as a public so that extensions may inject
+     * messages simulating that they had been received.
+     */
+    this.receive = _receive;
+
+    _handleResponse = function _handleResponse(request, response, longpoll)
+    {
+        var messages = _convertToMessages(response);
+        _debug('Received', response, 'converted to', messages);
+
+        // Signal the transport it can send other queued requests
+        _transport.complete(request, true, longpoll);
+
+        for (var i = 0; i < messages.length; ++i)
+        {
+            var message = messages[i];
+            _receive(message);
+        }
+    };
+
+    _handleFailure = function _handleFailure(request, messages, reason, exception, longpoll)
+    {
+        var xhr = request.xhr;
+
+        _debug('Failed', messages);
+
+        // Signal the transport it can send other queued requests
+        _transport.complete(request, false, longpoll);
+
+        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 _hasSubscriptions(channel)
+    {
+        var subscriptions = _listeners[channel];
+        if (subscriptions)
+        {
+            for (var i = 0; i < subscriptions.length; ++i)
+            {
+                if (subscriptions[i])
+                {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    function _resolveScopedCallback(scope, callback)
+    {
+        var delegate = {
+            scope: scope,
+            method: callback
+        };
+        if (_isFunction(scope))
+        {
+            delegate.scope = undefined;
+            delegate.method = scope;
+        }
+        else
+        {
+            if (_isString(callback))
+            {
+                if (!scope)
+                {
+                    throw 'Invalid scope ' + scope;
+                }
+                delegate.method = scope[callback];
+                if (!_isFunction(delegate.method))
+                {
+                    throw 'Invalid callback ' + callback + ' for scope ' + scope;
+                }
+            }
+            else if (!_isFunction(callback))
+            {
+                throw 'Invalid callback ' + callback;
+            }
+        }
+        return delegate;
+    }
+
+    function _addListener(channel, scope, callback, isListener)
+    {
+        // The data structure is a map<channel, subscription[]>, where each subscription
+        // holds the callback to be called and its scope.
+
+        var delegate = _resolveScopedCallback(scope, callback);
+        _debug('Adding listener on', channel, 'with scope', delegate.scope, 'and callback', delegate.method);
+
+        var subscription = {
+            channel: channel,
+            scope: delegate.scope,
+            callback: delegate.method,
+            listener: isListener
+        };
+
+        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 subscriptionID = subscriptions.push(subscription) - 1;
+        subscription.id = subscriptionID;
+        subscription.handle = [channel, subscriptionID];
+
+        _debug('Added listener', subscription, 'for channel', channel, 'having id =', subscriptionID);
+
+        // The subscription to allow removal of the listener is made of the channel and the index
+        return subscription.handle;
+    }
+
+    function _removeListener(subscription)
+    {
+        var subscriptions = _listeners[subscription[0]];
+        if (subscriptions)
+        {
+            delete subscriptions[subscription[1]];
+            _debug('Removed listener', subscription);
+        }
+    }
+
+    //
+    // PUBLIC API
+    //
+
+    /**
+     * Registers the given transport under the given transport type.
+     * The optional index parameter specifies the "priority" at which the
+     * transport is registered (where 0 is the max priority).
+     * If a transport with the same type is already registered, this function
+     * does nothing and returns false.
+     * @param type the transport type
+     * @param transport the transport object
+     * @param index the index at which this transport is to be registered
+     * @return true if the transport has been registered, false otherwise
+     * @see #unregisterTransport(type)
+     */
+    this.registerTransport = function(type, transport, index)
+    {
+        var result = _transports.add(type, transport, index);
+        if (result)
+        {
+            _debug('Registered transport', type);
+
+            if (_isFunction(transport.registered))
+            {
+                transport.registered(type, this);
+            }
+        }
+        return result;
+    };
+
+    /**
+     * @return an array of all registered transport types
+     */
+    this.getTransportTypes = function()
+    {
+        return _transports.getTransportTypes();
+    };
+
+    /**
+     * Unregisters the transport with the given transport type.
+     * @param type the transport type to unregister
+     * @return the transport that has been unregistered,
+     * or null if no transport was previously registered under the given transport type
+     */
+    this.unregisterTransport = function(type)
+    {
+        var transport = _transports.remove(type);
+        if (transport !== null)
+        {
+            _debug('Unregistered transport', type);
+
+            if (_isFunction(transport.unregistered))
+            {
+                transport.unregistered();
+            }
+        }
+        return transport;
+    };
+
+    /**
+     * Configures the initial Bayeux communication with the Bayeux server.
+     * Configuration is passed via an object that must contain a mandatory field <code>url</code>
+     * of type string containing the URL of the Bayeux server.
+     * @param configuration the configuration object
+     */
+    this.configure = function(configuration)
+    {
+        _configure.call(this, configuration);
+    };
+
+    /**
+     * Configures and establishes the Bayeux communication with the Bayeux server
+     * via a handshake and a subsequent connect.
+     * @param configuration the configuration object
+     * @param handshakeProps an object to be merged with the handshake message
+     * @see #configure(configuration)
+     * @see #handshake(handshakeProps)
+     */
+    this.init = function(configuration, handshakeProps)
+    {
+        this.configure(configuration);
+        this.handshake(handshakeProps);
+    };
+
+    /**
+     * Establishes the Bayeux communication with the Bayeux server
+     * via a handshake and a subsequent connect.
+     * @param handshakeProps an object to be merged with the handshake message
+     */
+    this.handshake = function(handshakeProps)
+    {
+        _setStatus('disconnected');
+        _reestablish = false;
+        _handshake(handshakeProps);
+    };
+
+    /**
+     * Disconnects from the Bayeux server.
+     * It is possible to suggest to attempt a synchronous disconnect, but this feature
+     * may only be available in certain transports (for example, long-polling may support
+     * it, callback-polling certainly does not).
+     * @param sync whether attempt to perform a synchronous disconnect
+     * @param disconnectProps an object to be merged with the disconnect message
+     */
+    this.disconnect = function(sync, disconnectProps)
+    {
+        if (_isDisconnected())
+        {
+            return;
+        }
+
+        if (disconnectProps === undefined)
+        {
+            if (typeof sync !== 'boolean')
+            {
+                disconnectProps = sync;
+                sync = false;
+            }
+        }
+
+        var bayeuxMessage = {
+            channel: '/meta/disconnect'
+        };
+        var message = _mixin(false, {}, disconnectProps, bayeuxMessage);
+        _setStatus('disconnecting');
+        _send(sync === true, [message], false, 'disconnect');
+    };
+
+    /**
+     * 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();
+    };
+
+    /**
+     * Executes the given callback in the given scope, surrounded by a {@link #startBatch()}
+     * and {@link #endBatch()} calls.
+     * @param scope the scope of the callback, may be omitted
+     * @param callback the callback to be executed within {@link #startBatch()} and {@link #endBatch()} calls
+     */
+    this.batch = function(scope, callback)
+    {
+        var delegate = _resolveScopedCallback(scope, callback);
+        this.startBatch();
+        try
+        {
+            delegate.method.call(delegate.scope);
+            this.endBatch();
+        }
+        catch (x)
+        {
+            _debug('Exception during execution of batch', x);
+            this.endBatch();
+            throw x;
+        }
+    };
+
+    /**
+     * 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, may be omitted
+     * @param callback the callback to call when a message is sent to the channel
+     * @returns the subscription handle to be passed to {@link #removeListener(object)}
+     * @see #removeListener(subscription)
+     */
+    this.addListener = function(channel, scope, callback)
+    {
+        if (arguments.length < 2)
+        {
+            throw 'Illegal arguments number: required 2, got ' + arguments.length;
+        }
+        if (!_isString(channel))
+        {
+            throw 'Illegal argument type: channel must be a string';
+        }
+
+        return _addListener(channel, scope, callback, true);
+    };
+
+    /**
+     * Removes the subscription obtained with a call to {@link #addListener(string, object, function)}.
+     * @param subscription the subscription to unsubscribe.
+     * @see #addListener(channel, scope, callback)
+     */
+    this.removeListener = function(subscription)
+    {
+        if (!_isArray(subscription))
+        {
+            throw 'Invalid argument: expected subscription, not ' + subscription;
+        }
+
+        _removeListener(subscription);
+    };
+
+    /**
+     * Removes all listeners registered with {@link #addListener(channel, scope, callback)} or
+     * {@link #subscribe(channel, scope, callback)}.
+     */
+    this.clearListeners = function()
+    {
+        _listeners = {};
+    };
+
+    /**
+     * 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, may be omitted
+     * @param callback the callback to call when a message is sent 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)
+    {
+        if (arguments.length < 2)
+        {
+            throw 'Illegal arguments number: required 2, got ' + arguments.length;
+        }
+        if (!_isString(channel))
+        {
+            throw 'Illegal argument type: channel must be a string';
+        }
+        if (_isDisconnected())
+        {
+            throw 'Illegal state: already disconnected';
+        }
+
+        // Normalize arguments
+        if (_isFunction(scope))
+        {
+            subscribeProps = callback;
+            callback = scope;
+            scope = undefined;
+        }
+
+        // Only send the message to the server if this clientId has not yet subscribed to the channel
+        var send = !_hasSubscriptions(channel);
+
+        var subscription = _addListener(channel, scope, callback, false);
+
+        if (send)
+        {
+            // Send the subscription message after the subscription registration to avoid
+            // races where the server would send 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 = _mixin(false, {}, subscribeProps, bayeuxMessage);
+            _queueSend(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)
+    {
+        if (arguments.length < 1)
+        {
+            throw 'Illegal arguments number: required 1, got ' + arguments.length;
+        }
+        if (_isDisconnected())
+        {
+            throw 'Illegal state: already disconnected';
+        }
+
+        // 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 channel = subscription[0];
+        // Only send the message to the server if this clientId unsubscribes the last subscription
+        if (!_hasSubscriptions(channel))
+        {
+            var bayeuxMessage = {
+                channel: '/meta/unsubscribe',
+                subscription: channel
+            };
+            var message = _mixin(false, {}, unsubscribeProps, bayeuxMessage);
+            _queueSend(message);
+        }
+    };
+
+    /**
+     * Removes all subscriptions added via {@link #subscribe(channel, scope, callback, subscribeProps)},
+     * but does not remove the listeners added via {@link addListener(channel, scope, callback)}.
+     */
+    this.clearSubscriptions = function()
+    {
+        _clearSubscriptions();
+    };
+
+    /**
+     * 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)
+    {
+        if (arguments.length < 1)
+        {
+            throw 'Illegal arguments number: required 1, got ' + arguments.length;
+        }
+        if (!_isString(channel))
+        {
+            throw 'Illegal argument type: channel must be a string';
+        }
+        if (_isDisconnected())
+        {
+            throw 'Illegal state: already disconnected';
+        }
+
+        var bayeuxMessage = {
+            channel: channel,
+            data: content
+        };
+        var message = _mixin(false, {}, publishProps, bayeuxMessage);
+        _queueSend(message);
+    };
+
+    /**
+     * Returns a string representing the status of the bayeux communication with the Bayeux server.
+     */
+    this.getStatus = function()
+    {
+        return _status;
+    };
+
+    /**
+     * Returns whether this instance has been disconnected.
+     */
+    this.isDisconnected = _isDisconnected;
+
+    /**
+     * 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) { ... }
+     * }
+     * </pre>
+     * Both properties are optional, but if they are present they will be called
+     * respectively for each incoming message and for each outgoing message.
+     * @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)
+    {
+        if (arguments.length < 2)
+        {
+            throw 'Illegal arguments number: required 2, got ' + arguments.length;
+        }
+        if (!_isString(name))
+        {
+            throw 'Illegal argument type: extension name must be a string';
+        }
+
+        var existing = false;
+        for (var i = 0; i < _extensions.length; ++i)
+        {
+            var existingExtension = _extensions[i];
+            if (existingExtension.name == name)
+            {
+                existing = true;
+                break;
+            }
+        }
+        if (!existing)
+        {
+            _extensions.push({
+                name: name,
+                extension: extension
+            });
+            _debug('Registered extension', name);
+
+            // Callback for extensions
+            if (_isFunction(extension.registered))
+            {
+                extension.registered(name, this);
+            }
+
+            return true;
+        }
+        else
+        {
+            _info('Could not register extension with name', name, 'since 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)
+    {
+        if (!_isString(name))
+        {
+            throw 'Illegal argument type: extension name must be a string';
+        }
+
+        var unregistered = false;
+        for (var i = 0; i < _extensions.length; ++i)
+        {
+            var extension = _extensions[i];
+            if (extension.name == name)
+            {
+                _extensions.splice(i, 1);
+                unregistered = true;
+                _debug('Unregistered extension', name);
+
+                // Callback for extensions
+                var ext = extension.extension;
+                if (_isFunction(ext.unregistered))
+                {
+                    ext.unregistered();
+                }
+
+                break;
+            }
+        }
+        return unregistered;
+    };
+
+    /**
+     * Find the extension registered with the given name.
+     * @param name the name of the extension to find
+     * @return the extension found or null if no extension with the given name has been registered
+     */
+    this.getExtension = function(name)
+    {
+        for (var i = 0; i < _extensions.length; ++i)
+        {
+            var extension = _extensions[i];
+            if (extension.name == name)
+            {
+                return extension.extension;
+            }
+        }
+        return null;
+    };
+
+    /**
+     * Returns the name assigned to this Cometd object, or the string 'default'
+     * if no name has been explicitly passed as parameter to the constructor.
+     */
+    this.getName = function()
+    {
+        return _name;
+    };
+
+    /**
+     * Returns the clientId assigned by the Bayeux server during handshake.
+     */
+    this.getClientId = function()
+    {
+        return _clientId;
+    };
+
+    /**
+     * Returns the URL of the Bayeux server.
+     */
+    this.getURL = function()
+    {
+        return _url;
+    };
+
+    this.getTransport = function()
+    {
+        return _transport;
+    };
+
+    /**
+     * 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.
+     */
+    org.cometd.Transport = function()
+    {
+        var self = this;
+        var _type;
+        var _requestIds = 0;
+        var _longpollRequest = null;
+        var _requests = [];
+        var _envelopes = [];
+
+        /**
+         * Function invoked just after a transport has been successfully registered.
+         * @param type the type of transport (for example 'long-polling')
+         * @param cometd the cometd object this transport has been registered to
+         * @see #unregistered()
+         */
+        this.registered = function(type, cometd)
+        {
+            _type = type;
+        };
+
+        /**
+         * Function invoked just after a transport has been successfully unregistered.
+         * @see #registered(type, cometd)
+         */
+        this.unregistered = function()
+        {
+            _type = null;
+        };
+
+        /**
+         * Returns whether this transport can work for the given version and cross domain communication case.
+         * @param version a string indicating the transport version
+         * @param crossDomain a boolean indicating whether the communication is cross domain
+         * @return true if this transport can work for the given version and cross domain communication case,
+         * false otherwise
+         */
+        this.accept = function(version, crossDomain)
+        {
+            throw 'Abstract';
+        };
+
+        /**
+         * Performs the actual send depending on the transport type details.
+         * @param envelope the envelope to send
+         * @param request the request information
+         */
+        this.transportSend = function(envelope, request)
+        {
+            throw 'Abstract';
+        };
+
+        this.transportSuccess = function(envelope, request, response)
+        {
+            if (!request.expired)
+            {
+                clearTimeout(request.timeout);
+                if (response && response.length > 0)
+                {
+                    envelope.onSuccess(request, response);
+                }
+                else
+                {
+                    envelope.onFailure(request, 'Empty HTTP response');
+                }
+            }
+        };
+
+        this.transportFailure = function(envelope, request, reason, exception)
+        {
+            if (!request.expired)
+            {
+                clearTimeout(request.timeout);
+                envelope.onFailure(request, reason, exception);
+            }
+        };
+
+        function _transportSend(envelope, request)
+        {
+            request.expired = false;
+
+            this.transportSend(envelope, request);
+
+            if (!envelope.sync)
+            {
+                var delay = _maxNetworkDelay;
+                if (request.longpoll === true)
+                {
+                    delay +=_advice && typeof _advice.timeout === 'number' ? _advice.timeout : 0;
+                }
+                request.timeout = _setTimeout(function()
+                {
+                    request.expired = true;
+                    if (request.xhr)
+                    {
+                        request.xhr.abort();
+                    }
+                    var errorMessage = 'Transport ' + self.getType() + ' exceeded ' + delay +
+                            ' ms max network delay for request ' + request.id;
+                    _debug(errorMessage);
+                    envelope.onFailure(request, 'timeout', errorMessage);
+                }, delay);
+            }
+        }
+
+        function _longpollSend(envelope)
+        {
+            if (_longpollRequest !== null)
+            {
+                throw 'Concurrent longpoll requests not allowed, request ' + _longpollRequest.id + ' not yet completed';
+            }
+
+            var requestId = ++_requestIds;
+            var request = {
+                id: requestId,
+                longpoll: true
+            };
+            _transportSend.call(this, envelope, request);
+            _longpollRequest = request;
+        }
+
+        function _queueSend(envelope)
+        {
+            var requestId = ++_requestIds;
+            var request = {
+                id: requestId,
+                longpoll: false
+            };
+            // Consider the longpoll requests which should always be present
+            if (_requests.length < _maxConnections - 1)
+            {
+                _debug('Transport sending request', requestId, envelope);
+                _transportSend.call(this, envelope, request);
+                _requests.push(request);
+            }
+            else
+            {
+                _debug('Transport queueing request', requestId, envelope);
+                _envelopes.push([envelope, request]);
+            }
+        }
+
+        function _longpollComplete(request)
+        {
+            var requestId = request.id;
+            if (_longpollRequest !== null && _longpollRequest !== request)
+            {
+                throw 'Longpoll request mismatch, completing request ' + requestId;
+            }
+
+            // Reset longpoll request
+            _longpollRequest = null;
+        }
+
+        function _coalesceEnvelopes(envelope)
+        {
+            while (_envelopes.length > 0)
+            {
+                var envelopeAndRequest = _envelopes[0];
+                var newEnvelope = envelopeAndRequest[0];
+                var newRequest = envelopeAndRequest[1];
+                if (newEnvelope.url === envelope.url &&
+                        newEnvelope.sync === envelope.sync)
+                {
+                    _envelopes.shift();
+                    envelope.messages = envelope.messages.concat(newEnvelope.messages);
+                    _debug('Coalesced', newEnvelope.messages.length, 'messages from request', newRequest.id);
+                    continue;
+                }
+                break;
+            }
+        }
+
+        function _complete(request, success)
+        {
+            var index = _inArray(request, _requests);
+            // The index can be negative if the request has been aborted
+            if (index >= 0)
+            {
+                _requests.splice(index, 1);
+            }
+
+            if (_envelopes.length > 0)
+            {
+                var envelopeAndRequest = _envelopes.shift();
+                var nextEnvelope = envelopeAndRequest[0];
+                var nextRequest = envelopeAndRequest[1];
+                _debug('Transport dequeued request', nextRequest.id);
+                if (success)
+                {
+                    if (_autoBatch)
+                    {
+                        _coalesceEnvelopes(nextEnvelope);
+                    }
+                    _queueSend.call(this, nextEnvelope);
+                    _debug('Transport completed request', request.id, nextEnvelope);
+                }
+                else
+                {
+                    // Keep the semantic of calling response callbacks asynchronously after the request
+                    setTimeout(function() { nextEnvelope.onFailure(nextRequest, 'error'); }, 0);
+                }
+            }
+        }
+
+        /**
+         * Returns the type of this transport.
+         * @see #registered(type, cometd)
+         */
+        this.getType = function()
+        {
+            return _type;
+        };
+
+        this.send = function(envelope, longpoll)
+        {
+            if (longpoll)
+            {
+                _longpollSend.call(this, envelope);
+            }
+            else
+            {
+                _queueSend.call(this, envelope);
+            }
+        };
+
+        this.complete = function(request, success, longpoll)
+        {
+            if (longpoll)
+            {
+                _longpollComplete.call(this, request);
+            }
+            else
+            {
+                _complete.call(this, request, success);
+            }
+        };
+
+        this.abort = function()
+        {
+            for (var i = 0; i < _requests.length; ++i)
+            {
+                var request = _requests[i];
+                _debug('Aborting request', request);
+                if (request.xhr)
+                {
+                    request.xhr.abort();
+                }
+            }
+            if (_longpollRequest)
+            {
+                _debug('Aborting longpoll request', _longpollRequest);
+                if (_longpollRequest.xhr)
+                {
+                    _longpollRequest.xhr.abort();
+                }
+            }
+            this.reset();
+        };
+
+        this.reset = function()
+        {
+            _longpollRequest = null;
+            _requests = [];
+            _envelopes = [];
+        };
+
+        this.toString = function()
+        {
+            return this.getType();
+        };
+    };
+
+    org.cometd.LongPollingTransport = function()
+    {
+        var self = this;
+        // By default, support cross domain
+        var _supportsCrossDomain = true;
+
+        this.accept = function(version, crossDomain)
+        {
+            return _supportsCrossDomain || !crossDomain;
+        };
+
+        this.xhrSend = function(packet)
+        {
+            throw 'Abstract';
+        };
+
+        this.transportSend = function(envelope, request)
+        {
+            try
+            {
+                var sameStack = true;
+                request.xhr = this.xhrSend({
+                    transport: this,
+                    url: envelope.url,
+                    sync: envelope.sync,
+                    headers: _requestHeaders,
+                    body: org.cometd.JSON.toJSON(envelope.messages),
+                    onSuccess: function(response)
+                    {
+                        if (!response || response.length === 0)
+                        {
+                            _supportsCrossDomain = false;
+                        }
+                        self.transportSuccess(envelope, request, response);
+                    },
+                    onError: function(reason, exception)
+                    {
+                        _supportsCrossDomain = false;
+                        if (sameStack)
+                        {
+                            // Keep the semantic of calling response callbacks asynchronously after the request
+                            _setTimeout(function()
+                            {
+                                self.transportFailure(envelope, request, reason, exception);
+                            }, 0);
+                        }
+                        else
+                        {
+                            self.transportFailure(envelope, request, reason, exception);
+                        }
+                    }
+                });
+                sameStack = false;
+            }
+            catch (x)
+            {
+                _supportsCrossDomain = false;
+                // Keep the semantic of calling response callbacks asynchronously after the request
+                _setTimeout(function()
+                {
+                    self.transportFailure(envelope, request, 'error', x);
+                }, 0);
+            }
+        };
+
+        this.reset = function()
+        {
+            org.cometd.LongPollingTransport.prototype.reset();
+            _supportsCrossDomain = true;
+        };
+    };
+    org.cometd.LongPollingTransport.prototype = new org.cometd.Transport();
+    org.cometd.LongPollingTransport.prototype.constructor = org.cometd.LongPollingTransport;
+
+    org.cometd.CallbackPollingTransport = function()
+    {
+        var self = this;
+        var _maxLength = 2000;
+
+        this.accept = function(version, crossDomain)
+        {
+            return true;
+        };
+
+        this.jsonpSend = function(packet)
+        {
+            throw 'Abstract';
+        };
+
+        this.transportSend = function(envelope, request)
+        {
+            // Microsoft Internet Explorer has a 2083 URL max length
+            // We must ensure that we stay within that length
+            var messages = org.cometd.JSON.toJSON(envelope.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 = envelope.url.length + encodeURI(messages).length;
+
+            // 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 = envelope.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()
+                {
+                    self.transportFailure(envelope, request, 'error', x);
+                }, 0);
+            }
+            else
+            {
+                try
+                {
+                    var sameStack = true;
+                    this.jsonpSend({
+                        transport: this,
+                        url: envelope.url,
+                        sync: envelope.sync,
+                        headers: _requestHeaders,
+                        body: messages,
+                        onSuccess: function(response)
+                        {
+                            self.transportSuccess(envelope, request, response);
+                        },
+                        onError: function(reason, exception)
+                        {
+                            if (sameStack)
+                            {
+                                // Keep the semantic of calling response callbacks asynchronously after the request
+                                _setTimeout(function()
+                                {
+                                    self.transportFailure(envelope, request, reason, exception);
+                                }, 0);
+                            }
+                            else
+                            {
+                                self.transportFailure(envelope, request, reason, exception);
+                            }
+                        }
+                    });
+                    sameStack = false;
+                }
+                catch (xx)
+                {
+                    // Keep the semantic of calling response callbacks asynchronously after the request
+                    _setTimeout(function()
+                    {
+                        self.transportFailure(envelope, request, 'error', xx);
+                    }, 0);
+                }
+            }
+        };
+    };
+    org.cometd.CallbackPollingTransport.prototype = new org.cometd.Transport();
+    org.cometd.CallbackPollingTransport.prototype.constructor = org.cometd.CallbackPollingTransport;
+};

Propchange: camel/trunk/components/camel-cometd/src/test/resources/webapp/dojo/org/cometd.js
------------------------------------------------------------------------------
    svn:eol-style = native

Modified: camel/trunk/components/camel-cometd/src/test/resources/webapp/index.html
URL: http://svn.apache.org/viewvc/camel/trunk/components/camel-cometd/src/test/resources/webapp/index.html?rev=1087994&r1=1087993&r2=1087994&view=diff
==============================================================================
--- camel/trunk/components/camel-cometd/src/test/resources/webapp/index.html (original)
+++ camel/trunk/components/camel-cometd/src/test/resources/webapp/index.html Sat Apr  2 10:31:37 2011
@@ -4,9 +4,7 @@
 <head>
 <title>My Simple Ajax Example</title>
 
-<script type="text/javascript" src="dojo/dojo/dojo.js.uncompressed.js"></script>
-<script type="text/javascript"
-	src="dojo/dojox/cometd.js.uncompressed.js"></script>
+<script type="text/javascript" src="dojo/dojo/dojo.js"></script>
 <script type="text/javascript">
     
         dojo.require("dojox.cometd");
@@ -17,6 +15,7 @@
         }
            
         dojo.addOnLoad(setupComet);
+        dojo.addOnUnload(dojox.cometd, "disconnect");
         
         function callback(msg){      
         	dojo.byId("MSG").innerHTML += msg.data + "\n";              



Mime
View raw message