cometd-rails 0.0.1

data/vendor/assets/javascripts/common/LongPollingTransport.js

@@ -0,0 +1,111 @@
+org.cometd.LongPollingTransport = function()
+{
+    var _super = new org.cometd.RequestTransport();
+    var _self = org.cometd.Transport.derive(_super);
+    // By default, support cross domain
+    var _supportsCrossDomain = true;
+
+    _self.accept = function(version, crossDomain, url)
+    {
+        return _supportsCrossDomain || !crossDomain;
+    };
+
+    _self.xhrSend = function(packet)
+    {
+        throw 'Abstract';
+    };
+
+    _self.transportSend = function(envelope, request)
+    {
+        this._debug('Transport', this.getType(), 'sending request', request.id, 'envelope', envelope);
+
+        var self = this;
+        try
+        {
+            var sameStack = true;
+            request.xhr = this.xhrSend({
+                transport: this,
+                url: envelope.url,
+                sync: envelope.sync,
+                headers: this.getConfiguration().requestHeaders,
+                body: org.cometd.JSON.toJSON(envelope.messages),
+                onSuccess: function(response)
+                {
+                    self._debug('Transport', self.getType(), 'received response', response);
+                    var success = false;
+                    try
+                    {
+                        var received = self.convertToMessages(response);
+                        if (received.length === 0)
+                        {
+                            _supportsCrossDomain = false;
+                            self.transportFailure(envelope, request, {
+                                httpCode: 204
+                            });
+                        }
+                        else
+                        {
+                            success = true;
+                            self.transportSuccess(envelope, request, received);
+                        }
+                    }
+                    catch(x)
+                    {
+                        self._debug(x);
+                        if (!success)
+                        {
+                            _supportsCrossDomain = false;
+                            var failure = {
+                                exception: x
+                            };
+                            failure.httpCode = self.xhrStatus(request.xhr);
+                            self.transportFailure(envelope, request, failure);
+                        }
+                    }
+                },
+                onError: function(reason, exception)
+                {
+                    self._debug('Transport', self.getType(), 'received error', reason, exception);
+                    _supportsCrossDomain = false;
+                    var failure = {
+                        reason: reason,
+                        exception: exception
+                    };
+                    failure.httpCode = self.xhrStatus(request.xhr);
+                    if (sameStack)
+                    {
+                        // Keep the semantic of calling response callbacks asynchronously after the request
+                        self.setTimeout(function()
+                        {
+                            self.transportFailure(envelope, request, failure);
+                        }, 0);
+                    }
+                    else
+                    {
+                        self.transportFailure(envelope, request, failure);
+                    }
+                }
+            });
+            sameStack = false;
+        }
+        catch (x)
+        {
+            _supportsCrossDomain = false;
+            // Keep the semantic of calling response callbacks asynchronously after the request
+            this.setTimeout(function()
+            {
+                self.transportFailure(envelope, request, {
+                    exception: x
+                });
+            }, 0);
+        }
+    };
+
+    _self.reset = function()
+    {
+        _super.reset();
+        _supportsCrossDomain = true;
+    };
+
+    return _self;
+};

data/vendor/assets/javascripts/common/ReloadExtension.js

@@ -0,0 +1,254 @@
+/*
+ * Copyright (c) 2010 the original author or authors.
+ *
+ * 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.
+ */
+
+(function()
+{
+    function bind(org_cometd)
+    {
+        if (!org_cometd.COOKIE)
+        {
+            org_cometd.COOKIE = {};
+            org_cometd.COOKIE.set = function(name, value, options)
+            {
+                throw 'Abstract';
+            };
+            org_cometd.COOKIE.get = function(name)
+            {
+                throw 'Abstract';
+            };
+        }
+
+        /**
+         * The reload extension allows a page to be loaded (or reloaded)
+         * without having to re-handshake in the new (or reloaded) page,
+         * therefore resuming the existing cometd connection.
+         *
+         * When the reload() method is called, the state of the cometd
+         * connection and of the cometd subscriptions is stored in a cookie
+         * with a short max-age.
+         * The reload() method must therefore be called by page unload
+         * handlers, often provided by JavaScript toolkits.
+         *
+         * When the page is (re)loaded, this extension checks the cookie
+         * and restores the cometd connection and the cometd subscriptions.
+         */
+        return org_cometd.ReloadExtension = function(configuration)
+        {
+            var _cometd;
+            var _debug;
+            var _state = null;
+            var _cookieName = 'org.cometd.reload';
+            var _cookiePath = '/';
+            var _cookieMaxAge = 5;
+            var _batch = false;
+
+            function _reload(config)
+            {
+                if (_state && _state.handshakeResponse !== null)
+                {
+                    _configure(config);
+                    _state.cookiePath = _cookiePath;
+                    var cookie = org_cometd.JSON.toJSON(_state);
+                    _debug('Reload extension saving cookie value', cookie);
+                    org_cometd.COOKIE.set(_cookieName, cookie, {
+                        'max-age': _cookieMaxAge,
+                        path: _cookiePath,
+                        expires: new Date(new Date().getTime() + _cookieMaxAge * 1000)
+                    });
+                }
+            }
+
+            function _similarState(oldState)
+            {
+                // We want to check here that the CometD object
+                // did not change much between reloads.
+                // We just check the URL for now, but in future
+                // further checks may involve the transport type
+                // and other configuration parameters.
+                return _state.url == oldState.url;
+            }
+
+            function _configure(config)
+            {
+                if (config)
+                {
+                    if (typeof config.cookieMaxAge === 'number')
+                    {
+                        _cookieMaxAge = config.cookieMaxAge;
+                    }
+                    if (typeof config.cookieName === 'string')
+                    {
+                        _cookieName = config.cookieName;
+                    }
+                    if (typeof config.cookiePath === 'string')
+                    {
+                        _cookiePath = config.cookiePath;
+                    }
+                }
+            }
+
+            this.configure = _configure;
+
+            this.registered = function(name, cometd)
+            {
+                _cometd = cometd;
+                _cometd.reload = _reload;
+                _debug = _cometd._debug;
+            };
+
+            this.unregistered = function()
+            {
+                delete _cometd.reload;
+                _cometd = null;
+            };
+
+            this.outgoing = function(message)
+            {
+                switch (message.channel)
+                {
+                    case '/meta/handshake':
+                    {
+                        _state = {};
+                        _state.url = _cometd.getURL();
+
+                        var cookie = org_cometd.COOKIE.get(_cookieName);
+                        _debug('Reload extension found cookie value', cookie);
+                        // Is there a saved handshake response from a prior load ?
+                        if (cookie)
+                        {
+                            try
+                            {
+                                var oldState = org_cometd.JSON.fromJSON(cookie);
+
+                                // Remove the cookie, not needed anymore
+                                org_cometd.COOKIE.set(_cookieName, '', {
+                                    'max-age': -1,
+                                    path: oldState.cookiePath,
+                                    expires: -1
+                                });
+
+                                if (oldState.handshakeResponse && _similarState(oldState))
+                                {
+                                    _debug('Reload extension restoring state', oldState);
+                                    setTimeout(function ()
+                                    {
+                                        _debug('Reload extension replaying handshake response', oldState.handshakeResponse);
+                                        _state.handshakeResponse = oldState.handshakeResponse;
+                                        _state.transportType = oldState.transportType;
+                                        _state.reloading = true;
+                                        var response = _cometd._mixin(true, {}, _state.handshakeResponse, {ext: {reload: true}});
+                                        response.supportedConnectionTypes = [_state.transportType];
+                                        _cometd.receive(response);
+                                        _debug('Reload extension replayed handshake response', response);
+                                    }, 0);
+
+                                    // delay any sends until first connect is complete.
+                                    if (!_batch)
+                                    {
+                                        _batch = true;
+                                        _cometd.startBatch();
+                                    }
+                                    // This handshake is aborted, as we will replay the prior handshake response
+                                    return null;
+                                }
+                                else
+                                {
+                                    _debug('Reload extension could not restore state', oldState);
+                                }
+                            }
+                            catch (x)
+                            {
+                                _debug('Reload extension error while trying to restore cookie', x);
+                            }
+                        }
+                        break;
+                    }
+                    case '/meta/connect':
+                    {
+                        if (!_state.transportType)
+                        {
+                            _state.transportType = message.connectionType;
+                            _debug('Reload extension tracked transport type', _state.transportType);
+                        }
+                        break;
+                    }
+                    case '/meta/disconnect':
+                    {
+                        _state = null;
+                        break;
+                    }
+                    default:
+                    {
+                        break;
+                    }
+                }
+                return message;
+            };
+
+            this.incoming = function(message)
+            {
+                if (message.successful)
+                {
+                    switch (message.channel)
+                    {
+                        case '/meta/handshake':
+                        {
+                            // If the handshake response is already present, then we're replaying it.
+                            // Since the replay may have modified the handshake response, do not record it here.
+                            if (!_state.handshakeResponse)
+                            {
+                                // Save successful handshake response
+                                _state.handshakeResponse = message;
+                                _debug('Reload extension tracked handshake response', message);
+                            }
+                            break;
+                        }
+                        case '/meta/disconnect':
+                        {
+                            _state = null;
+                            break;
+                        }
+                        case '/meta/connect':
+                        {
+                            if (_batch)
+                            {
+                                _cometd.endBatch();
+                                _batch = false;
+                            }
+                            break;
+                        }
+                        default:
+                        {
+                            break;
+                        }
+                    }
+                }
+                return message;
+            };
+
+            _configure(configuration);
+        };
+    }
+
+    if (typeof define === 'function' && define.amd)
+    {
+        define(['org/cometd'], bind);
+    }
+    else
+    {
+        bind(org.cometd);
+    }
+})();

data/vendor/assets/javascripts/common/RequestTransport.js

@@ -0,0 +1,297 @@
+/**
+ * Base object with the common functionality for transports based on requests.
+ * 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.RequestTransport = function()
+{
+    var _super = new org.cometd.Transport();
+    var _self = org.cometd.Transport.derive(_super);
+    var _requestIds = 0;
+    var _metaConnectRequest = null;
+    var _requests = [];
+    var _envelopes = [];
+
+    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);
+                this._debug('Coalesced', newEnvelope.messages.length, 'messages from request', newRequest.id);
+                continue;
+            }
+            break;
+        }
+    }
+
+    function _transportSend(envelope, request)
+    {
+        this.transportSend(envelope, request);
+        request.expired = false;
+
+        if (!envelope.sync)
+        {
+            var maxDelay = this.getConfiguration().maxNetworkDelay;
+            var delay = maxDelay;
+            if (request.metaConnect === true)
+            {
+                delay += this.getAdvice().timeout;
+            }
+
+            this._debug('Transport', this.getType(), 'waiting at most', delay, 'ms for the response, maxNetworkDelay', maxDelay);
+
+            var self = this;
+            request.timeout = this.setTimeout(function()
+            {
+                request.expired = true;
+                var errorMessage = 'Request ' + request.id + ' of transport ' + self.getType() + ' exceeded ' + delay + ' ms max network delay';
+                var failure = {
+                    reason: errorMessage
+                };
+                var xhr = request.xhr;
+                failure.httpCode = self.xhrStatus(xhr);
+                self.abortXHR(xhr);
+                self._debug(errorMessage);
+                self.complete(request, false, request.metaConnect);
+                envelope.onFailure(xhr, envelope.messages, failure);
+            }, delay);
+        }
+    }
+
+    function _queueSend(envelope)
+    {
+        var requestId = ++_requestIds;
+        var request = {
+            id: requestId,
+            metaConnect: false,
+            envelope: envelope
+        };
+
+        // Consider the metaConnect requests which should always be present
+        if (_requests.length < this.getConfiguration().maxConnections - 1)
+        {
+            _requests.push(request);
+            _transportSend.call(this, envelope, request);
+        }
+        else
+        {
+            this._debug('Transport', this.getType(), 'queueing request', requestId, 'envelope', envelope);
+            _envelopes.push([envelope, request]);
+        }
+    }
+
+    function _metaConnectComplete(request)
+    {
+        var requestId = request.id;
+        this._debug('Transport', this.getType(), 'metaConnect complete, request', requestId);
+        if (_metaConnectRequest !== null && _metaConnectRequest.id !== requestId)
+        {
+            throw 'Longpoll request mismatch, completing request ' + requestId;
+        }
+
+        // Reset metaConnect request
+        _metaConnectRequest = null;
+    }
+
+    function _complete(request, success)
+    {
+        var index = org.cometd.Utils.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];
+            this._debug('Transport dequeued request', nextRequest.id);
+            if (success)
+            {
+                if (this.getConfiguration().autoBatch)
+                {
+                    _coalesceEnvelopes.call(this, nextEnvelope);
+                }
+                _queueSend.call(this, nextEnvelope);
+                this._debug('Transport completed request', request.id, nextEnvelope);
+            }
+            else
+            {
+                // Keep the semantic of calling response callbacks asynchronously after the request
+                var self = this;
+                this.setTimeout(function()
+                {
+                    self.complete(nextRequest, false, nextRequest.metaConnect);
+                    var failure = {
+                        reason: 'Previous request failed'
+                    };
+                    var xhr = nextRequest.xhr;
+                    failure.httpCode = self.xhrStatus(xhr);
+                    nextEnvelope.onFailure(xhr, nextEnvelope.messages, failure);
+                }, 0);
+            }
+        }
+    }
+
+    _self.complete = function(request, success, metaConnect)
+    {
+        if (metaConnect)
+        {
+            _metaConnectComplete.call(this, request);
+        }
+        else
+        {
+            _complete.call(this, request, success);
+        }
+    };
+
+    /**
+     * Performs the actual send depending on the transport type details.
+     * @param envelope the envelope to send
+     * @param request the request information
+     */
+    _self.transportSend = function(envelope, request)
+    {
+        throw 'Abstract';
+    };
+
+    _self.transportSuccess = function(envelope, request, responses)
+    {
+        if (!request.expired)
+        {
+            this.clearTimeout(request.timeout);
+            this.complete(request, true, request.metaConnect);
+            if (responses && responses.length > 0)
+            {
+                envelope.onSuccess(responses);
+            }
+            else
+            {
+                envelope.onFailure(request.xhr, envelope.messages, {
+                    httpCode: 204
+                });
+            }
+        }
+    };
+
+    _self.transportFailure = function(envelope, request, failure)
+    {
+        if (!request.expired)
+        {
+            this.clearTimeout(request.timeout);
+            this.complete(request, false, request.metaConnect);
+            envelope.onFailure(request.xhr, envelope.messages, failure);
+        }
+    };
+
+    function _metaConnectSend(envelope)
+    {
+        if (_metaConnectRequest !== null)
+        {
+            throw 'Concurrent metaConnect requests not allowed, request id=' + _metaConnectRequest.id + ' not yet completed';
+        }
+
+        var requestId = ++_requestIds;
+        this._debug('Transport', this.getType(), 'metaConnect send, request', requestId, 'envelope', envelope);
+        var request = {
+            id: requestId,
+            metaConnect: true,
+            envelope: envelope
+        };
+        _transportSend.call(this, envelope, request);
+        _metaConnectRequest = request;
+    }
+
+    _self.send = function(envelope, metaConnect)
+    {
+        if (metaConnect)
+        {
+            _metaConnectSend.call(this, envelope);
+        }
+        else
+        {
+            _queueSend.call(this, envelope);
+        }
+    };
+
+    _self.abort = function()
+    {
+        _super.abort();
+        for (var i = 0; i < _requests.length; ++i)
+        {
+            var request = _requests[i];
+            if (request)
+            {
+                this._debug('Aborting request', request);
+                if (!this.abortXHR(request.xhr))
+                {
+                    this.transportFailure(request.envelope, request, {reason: 'abort'});
+                }
+            }
+        }
+        if (_metaConnectRequest)
+        {
+            this._debug('Aborting metaConnect request', _metaConnectRequest);
+            if (!this.abortXHR(_metaConnectRequest.xhr))
+            {
+                this.transportFailure(_metaConnectRequest.envelope, _metaConnectRequest, {reason: 'abort'});
+            }
+        }
+        this.reset();
+    };
+
+    _self.reset = function()
+    {
+        _super.reset();
+        _metaConnectRequest = null;
+        _requests = [];
+        _envelopes = [];
+    };
+
+    _self.abortXHR = function(xhr)
+    {
+        if (xhr)
+        {
+            try
+            {
+                var state = xhr.readyState;
+                xhr.abort();
+                return state !== XMLHttpRequest.UNSENT;
+            }
+            catch (x)
+            {
+                this._debug(x);
+            }
+        }
+        return false;
+    };
+
+    _self.xhrStatus = function(xhr)
+    {
+        if (xhr)
+        {
+            try
+            {
+                return xhr.status;
+            }
+            catch (x)
+            {
+                this._debug(x);
+            }
+        }
+        return -1;
+    };
+
+    return _self;
+};

data/vendor/assets/javascripts/common/TimeStampExtension.js

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2010 the original author or authors.
+ *
+ * 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.
+ */
+
+(function()
+{
+    function bind(org_cometd)
+    {
+        /**
+         * The timestamp extension adds the optional timestamp field to all outgoing messages.
+         */
+        return org_cometd.TimeStampExtension = function()
+        {
+            this.outgoing = function(message)
+            {
+                message.timestamp = new Date().toUTCString();
+                return message;
+            };
+        };
+    }
+
+    if (typeof define === 'function' && define.amd)
+    {
+        define(['org/cometd'], bind);
+    }
+    else
+    {
+        bind(org.cometd);
+    }
+}());