Ticket #6131: channels.diff

BaseChannels.js

@@ +1 @@
+dojo.provide("dojox.cometd.BaseChannels");
+dojo.require("dojox.rpc.Client");
+if(dojox.data && dojox.data.JsonRestStore){
+        dojo.require("dojox.data.restListener");
+}
+// Note that cometd _base is _not_ required, this can run standalone, but ifyou want 
+// cometd functionality, you must explicitly load/require it elsewhere, and cometd._base
+// MUST be loaded prior to Channels ifyou use it.
+
+/**
+        * BaseChannels is used by JsonChannels and HttpChannels
+        * 
+        */
+        
+
+dojox.cometd.BaseChannels = function(options){
+        var isOpera = navigator.userAgent.indexOf("Opera") >= 0;
+        
+        var Channels = {
+                absoluteUrl : function(relativeUrl){
+                        return new dojo._Url(location.href,relativeUrl)+'';
+                },
+                subscriptions : {},
+                subCallbacks : {},
+                autoReconnectTime : 30000,
+                url : '/channels',
+                open : function(){
+                        // summary:
+                        //              Startup the transport (connect to the "channels" resource to receive updates from the server).
+                        //
+                        // description:
+                        //              Note that if there is no connection open, this is automatically called when you do a subscription,
+                        //              it is often not necessary to call this
+                        //
+                        if(!this.connected){
+                                var xdr = dojox.cometd.useXDR && window.XDomainRequest;
+                                // we are currently directly using the XHR or XDR object, because Dojo's XHR wrapper is not architected for progress events. If that changes, we can use Dojo's XHR here.
+                                this.xhr = (window.XMLHttpRequest && new (xdr || XMLHttpRequest)) || new ActiveXObject("Microsoft.XMLHTTP");
+                                var xhr = this.xhr;
+                                this.connectionId = dojox._clientId;
+                                var clientIdHeader = this.started ? 'Client-Id' : 'Create-Client-Id';
+                                // post to our channel url
+                                if(xdr){
+                                        xhr.open("POST",this.absoluteUrl(this.url + "?Accept=" + this.acceptType + "&" + clientIdHeader + "=" + this.connectionId)); 
+                                }
+                                else {// xdr doesn't have setRequestHeader, and it must have an absolute url
+                                        xhr.open("POST",this.url,true);
+                                        xhr.setRequestHeader('X-' + clientIdHeader,this.connectionId); 
+                                        // let the server know what type of response we can accept
+                                        xhr.setRequestHeader('Accept',this.acceptType);
+                                }
+                                var self = this;
+                                this.lastIndex = 0; 
+                                var onstatechange = function(){ // get all the possible event handlers
+                                        var error,loaded,data;
+                                try{
+                                                if(!xhr.readyState || xhr.readyState > 2){// only if"OK" (xdr doesn't have a readyState)
+                                                        self.readyState = xhr.readyState;
+                                                        error = xhr.status > 300;               
+                                                        data = xhr.responseText.substring(self.lastIndex);
+                                                loaded = !error && typeof data=='string';//firefox can throw an exception right here
+                                                }
+                                } catch(e){
+                                        error = xhr.readyState == 4; // an error in ready state 3 is common with IE's old API. But in ready state 4, it is an indication of a real error in firefox 
+                                }
+                                if(loaded){
+                                        var contentType = xhr.contentType || xhr.getResponseHeader("Content-Type");
+                                        self.started = true;
+                                                try{                                    
+                                                error = self.onprogress(xhr,xdr,data,contentType);
+                                                }
+                                        finally {
+                                                        if(xhr.readyState==4){
+                                                        xhr = null;
+                                                        if(self.connected){
+                                                                self.connected = false;
+                                                                self.open();
+                                                        }
+                                                        }
+                                        }
+                                }
+                                if(error){ // an error has occurred
+                                
+                                        if(self.started){ // this means we need to reconnect
+                                                self.started = false;
+                                                        self.connected = false;
+                                                var subscriptions = self.subscriptions;
+                                                self.subscriptions = {};
+                                                        for(var i in subscriptions){
+                                                                self.subscribe(i,{since:subscriptions[i]});
+                                                        }
+                                        }
+                                        else {
+                                                self.disconnected();
+                                        }
+                                }
+                                };
+                                xhr.onreadystatechange = onstatechange;
+                                if(xdr){
+                                        xhr.onerror = function(){
+                                                xhr.readyState = 4;
+                                                xhr.status = 404; // this is so that we can restartup ifnecessary
+                                                onstatechange();
+                                        };
+                                        xhr.onload = function(){
+                                                xhr.readyState = 4;
+                                                onstatechange();
+                                        };
+                                        xhr.onprogress = onstatechange;
+                                }
+                                 
+                                xhr.send(null);
+                                if(window.attachEvent){// IE needs a little help with cleanup
+                                        attachEvent("onunload",function(){
+                                                self.connected= false;
+                                                if(xhr){
+                                                        xhr.abort();
+                                                }
+                                        });
+                                }
+                                
+                                this.connected = true;
+                        }
+                },
+                subscribe : function(channel,args){
+                        // summary:
+                        //              subscribe to a channel/uri
+                        //
+                        // channel: 
+                        //              the uri for the resource you want to monitor
+                        // 
+                        // args: 
+                        //              The follow properties can be defined in args:
+                        // since: 
+                        //              The time after which you want to receive modification notices/events for this uri/channel
+                        // 
+                        // headers:
+                        //              These are the headers to be applied to the channel subscription request
+                        //
+                        // callback:
+                        //              This will be called when a event occurs for the channel
+                        //              The callback will be called with a single argument:
+                        //      |       callback(message)
+                        //              where message is an object that follows the XHR API:
+                        //              status : Http status
+                        //              statusText : Http status text
+                        //              getAllResponseHeaders() : The response headers
+                        //              getResponseHeaders(headerName) : Retrieve a header by name
+                        //              responseText : The response body as text
+                        //                      with the following additional Bayeux properties 
+                        //              data : The response body as JSON
+                        //              channel : The channel/url of the response
+                        args = args || {};
+                        args.url = this.absoluteUrl(channel);
+                        var oldSince = this.subscriptions[channel];
+                        var method = args.method || "HEAD"; // HEAD is the default for a subscription
+                        var since = args.since;
+                        var callback = args.callback;
+                        var headers = args.headers || (args.headers = {});
+                        this.subscriptions[channel] = since || oldSince || 0;
+                        var oldCallback = this.subCallbacks[channel];
+                        if(callback){
+                                this.subCallbacks[channel] = oldCallback ? function(m){
+                                        oldCallback(m);
+                                        callback(m);
+                                } : callback;
+                        } 
+                        if(!this.connected){
+                                this.open();
+                        }
+                        if(oldSince === undefined || oldSince != since){
+                                headers["Cache-Control"] = "max-age=0";
+                                since = typeof since == 'number' ? new Date(since).toUTCString() : since;
+                                if(since){
+                                        headers["X-Subscribe-Since"] = since;
+                                }
+                                headers["X-Subscribe"] = args.unsubscribe ? 'none' : '*';
+/*                              var xhr = (window.XMLHttpRequest && new XMLHttpRequest) || new ActiveXObject("Microsoft.XMLHTTP");                              
+                                xhr.open("GET",url,true);
+                                for(var i in headers)
+                                        xhr.setRequestHeader(i,headers[i]);*/
+                                var dfd = dojo.xhr(method,args);
+                                
+                                var self = this;
+/*                              xhr.onreadystatechange = function(){
+                                        if(xhr.readyState == 4){*/
+                                dfd.addBoth(function(){
+                                        var xhr = dfd.ioArgs.xhr;
+                                        if(xhr.status < 400){
+                                                if(args.confirmation){
+                                                        args.confirmation();
+                                                }
+                                        }
+                                        if(xhr.getResponseHeader("X-Subscribed")  == "OK"){
+                                                var lastMod = xhr.getResponseHeader('Last-Modified');
+//                                                      log("lastMod " + lastMod);
+                                                
+                                                if(xhr.responseText){ 
+                                                        self.subscriptions[channel] = lastMod || new Date().toUTCString();
+                                                }
+                                                else {
+                                                        return; // don't process the response, the response will be received in the main channels response
+                                                }
+                                        }
+                                        else { // ifit is not a 202 response, that means it is did not accept the subscription
+                                                delete self.subscriptions[channel];
+                                        }
+                                        if(xhr.status < 300){
+                                                if('channel' in xhr){
+                                                        // firefox uses this property as internal property (and throws an exception on usage),
+                                                        xhr = {channel:channel,__proto__:xhr}; // so we create an instance to shadow this property
+                                                }
+                                                xhr.channel = channel; 
+                                                
+                                                try{
+                                                        xhr.data = dojo.fromJson(xhr.responseText);
+                                                }
+                                                catch (e){}
+                                                if(self.subCallbacks[channel]){
+                                                        self.subCallbacks[channel](xhr); // call with the actual xhr object
+                                                }
+                                        }
+                                });
+                                return dfd;
+                                //xhr.send(null);
+                        }
+                },
+                get : function(channel,args){
+                        // summary:
+                        //              get the initial value of the resource and subscribe to it  
+                        //              See subscribe for parameter values
+                        (args = args || {}).method = "GET"; 
+                        return this.subscribe(channel,args);
+                },
+                disconnected : function(){
+                        // summary:
+                        //              called when our channel gets disconnected
+                        var self = this;
+                        if(this.connected){ // ifwe are connected, we shall tryto reconnect 
+                                setTimeout(function(){ // auto reconnect
+                                        self.open();
+                                },this.autoReconnectTime);
+                        }
+                        this.connected = false;
+                },
+                unsubscribe : function(channel,args){
+                        // summary:
+                        //              unsubscribes from the resource  
+                        //              See subscribe for parameter values 
+                        
+                        args = args || {};
+                        args.unsubscribe = true;
+                        this.subscribe(channel,args); // change the time frame to after 5000AD 
+                },
+                deliver : function(message){ // nothing to do
+                },
+                disconnect : function(){
+                        // summary:
+                        //              disconnect from the server  
+                        this.connected = false;
+                        this.xhr.abort();
+                }
+        };
+        Channels = dojo.mixin(Channels,options);
+        if(dojox.cometd.connectionTypes){ // register as a dojox.cometd transport and wire everything for cometd handling
+                // below are the necessary adaptions for cometd
+                Channels.startup = function(data){ // must be able to handle objects or strings
+                        Channels.open();
+                        this.deliver({channel:"/meta/connect",successful:true}); // tell cometd we are connected so it can proceed to send subscriptions, even though we aren't yet 
+
+                };
+                Channels.check = function(types, version, xdomain){
+                        for(var i = 0; i< types.length; i++){
+                                if(types[i] == Channels._connectionType){
+                                        return !xdomain;
+                                }
+                        }
+                };
+                Channels.sendMessages = function(messages){
+                        for(var i = 0; i < messages.length; i++){
+                                var message = messages[i];
+                                var channel = message.channel;
+                                var args = {confirmation: function(){ // send a confirmation back to cometd
+                                                Channels.deliver({channel:channel,successful:true});
+                                        }};
+                                if(channel == '/meta/subscribe'){
+                                        this.subscribe(message.subscription,args);
+                                }
+                                else if(channel == '/meta/unsubscribe'){
+                                        this.unsubscribe(message.subscription,args);
+                                }
+                                else if(channel == '/meta/connect'){
+                                        args.confirmation();
+                                }
+                                else if(channel == '/meta/disconnect'){
+                                        Channels.disconnect();
+                                        args.confirmation();
+                                }
+                                else if(channel.substring(0,6) != '/meta/'){
+                                        this.publish(channel,message.data);
+                                }
+                        }
+                };
+                dojox.cometd.connectionTypes.register(Channels._connectionType, Channels.check, Channels,false,true);
+        }
+        var handleContent = function(xhr){
+                // automatically choose the right handler based on the returned content type
+                var handlers = dojo._contentHandlers;
+                var retContentType = xhr.getResponseHeader("Content-Type");
+                results = retContentType.match(/\/json/) ? handlers.json(xhr) : 
+                        retContentType.match(/\/javascript/) ? handlers.javascript(xhr) :
+                        retContentType.match(/\/xml/) ? handlers.xml(xhr) : handlers.text(xhr); 
+                return results;                                                                 
+        };
+        dojo.xhrGet = function(r){
+                var dfd = new dojo.Deferred();
+                r.callback = function(message){
+                        if(dfd.fired ==-1){
+                                dojox._newId = message.channel;
+                                dfd.callback(handleContent(message));
+                        }
+                };
+                dfd.ioArgs = Channels.get(r.url,r).ioArgs; // copy the ioArgs over, so others can access it
+                return dfd;                     
+        };
+        if(dojox.data && dojox.data.restListener){
+                dojo.connect(Channels,"deliver",null,dojox.data.restListener);
+        }
+        return Channels;
+};

HttpChannels.js

@@ +1 @@
+dojo.provide("dojox.cometd.HttpChannels");
+dojo.require("dojox.cometd.BaseChannels");
+// Note that cometd _base is _not_ required, this can run standalone, but ifyou want 
+// cometd functionality, you must explicitly load/require it elsewhere, and cometd._base
+// MUST be loaded prior to HttpChannels ifyou use it.
+
+/**
+        * HTTP Channels - An HTTP Based approach to Comet transport with full HTTP messaging 
+        * semantics including REST
+        * HTTP Channels is a efficient, reliable duplex transport for Comet
+        * by Kris Zyp - www.sitepen.com
+
+        * This can be used:
+        * 1. As a cometd transport
+        * 2. As an enhancement for the REST RPC service, to enable "live" data (real-time updates directly alter the data in indexes)
+        * 2a. With the JsonRestStore (which is driven by the REST RPC service), so this dojo.data has real-time data. Updates can be heard through the dojo.data notification API.
+        * 3. As a standalone transport. To use it as a standalone transport looks like this:
+        * dojox.cometd.HttpChannels.open();
+        * dojox.cometd.HttpChannels.get("/myResource",{callback:function(){
+        *               // this is called when the resource is first retrieved and any time the 
+        *               // resource is changed in the future. This provides a means for retrieving a
+        *               // resource and subscribing to it in a single request
+        * });
+        * dojox.cometd.HttpChannels.subscribe("/anotherResource",{callback:function(){
+        *               // this is called when the resource is changed in the future
+        * });
+        * Channels HTTP can be configured to a different delays:
+        * dojox.cometd.HttpChannels.autoReconnectTime = 60000; // reconnect after one minute
+        */
+        
+dojox.cometd.HttpChannels = dojox.cometd.BaseChannels({
+        /*
+        absoluteUrl : function(baseUrl, relativeUrl){
+                // summary:
+                // This takes a base url and a relative url and resolves the target url.
+                // For example:
+                // resolveUrl("http://www.domain.com/path1/path2","../path3") ->"http://www.domain.com/path1/path3"  
+                //
+                if(relativeUrl.match(/\w+:\/\//))
+                        return relativeUrl;
+                if(relativeUrl.charAt(0)=='/'){
+                        baseUrl = baseUrl.match(/.*\/\/[^\/]+/)
+                        return (baseUrl ? baseUrl[0] : '') + relativeUrl;
+                }       
+                        //TODO: handle protocol relative urls:  ://www.domain.com
+                baseUrl = baseUrl.substring(0,baseUrl.length - baseUrl.match(/[^\/]*$/)[0].length);// clean off the trailing path
+                if(relativeUrl == '.')
+                        return baseUrl; 
+                while (relativeUrl.substring(0,3) == '../'){
+                        baseUrl = baseUrl.substring(0,baseUrl.length - baseUrl.match(/[^\/]*\/$/)[0].length);
+                        relativeUrl = relativeUrl.substring(3);
+                }
+                return baseUrl + relativeUrl;   
+        }*/
+        _connectionType : "http-channels",
+        acceptType : "application/http,*/*;q=0.8",
+        publish : function(channel,data){
+                // summary:
+                //              Publish an event.
+                // description:
+                //              This does a simple POST operation to the provided URL,
+                //              POST is the semantic equivalent of publishing a message within REST/Channels
+                // channel:
+                //              Channel/resource path to publish to
+                // data:
+                //              data to publish
+                headers={};
+                dojo.rawXhrPost({url:channel,postData:dojo.toJson(data),headers:headers,        contentType : 'application/json'});
+                
+/*              var xhr = new XMLHttpRequest();
+                xhr.open("POST",channel,true);
+                xhr.send(dojo.toJson(data)); // fire and forget*/
+        },
+        _processMessage: function(message) {
+                message.event = message.getResponseHeader('X-Event');
+                if(message.event=="connection-conflict"){
+                        return "conflict"; // indicate an error
+                }
+                try {
+                        message.data = dojo.fromJson(message.responseText);
+                }
+                catch (e){}
+                var self = this;        
+                message.channel = message.getResponseHeader('Content-Location');//for cometd
+                var loc = new dojo._Url(location.href,message.channel); // TODO: more robust URL matching
+                if(loc in this.subscriptions){
+                        this.subscriptions[loc] = message.getResponseHeader('Last-Modified'); 
+                }
+                if(this.subCallbacks[loc]){
+                        setTimeout(function(){ //give it it's own stack 
+                                self.subCallbacks[loc](message);
+                        },0);
+                }
+                this.deliver(message);
+                
+        },
+        onprogress : function(xhr,xdr,data,contentType){
+                // internal XHR progress handler
+                if (contentType.match(/application\/http/)) {
+                        // do tunneling
+                        var topHeaders = '';
+                        if(!xdr){
+                        topHeaders = xhr.getAllResponseHeaders();
+                        var topHeaderParts = topHeaders.match(/[^:\n]+:[^\n]+\n/g);
+                        }
+                        while(data){
+                                var headers = {};
+                                var httpParts = data.match(/(\n*[^\n]+)/);
+                                if(!httpParts){ 
+                                        return;
+                                }
+                                data = data.substring(httpParts[0].length+1);
+                                httpParts = httpParts[1];
+                                var headerParts = data.match(/([^\n]+\n)*/)[0];
+                                data = data.substring(headerParts.length+1);
+                                headerParts = topHeaders + headerParts;
+                                var headerStr = headerParts;
+                                headerParts = headerParts.match(/[^:\n]+:[^\n]+\n/g); // parse the containing and contained response headers with the contained taking precedence (by going last)
+                                for(var j = 0; j < headerParts.length; j++){
+                                        var colonIndex = headerParts[j].indexOf(':');
+                                        headers[headerParts[j].substring(0,colonIndex)] = headerParts[j].substring(colonIndex+1).replace(/(^[ \r\n]*)|([ \r\n]*)$/g,''); // trim
+                                }                                                                               
+
+                                httpParts = httpParts.split(' ');
+                                var message = { // make it look like an xhr object, at least for the response part of the API
+                                        status : parseInt(httpParts[1],10),
+                                        statusText : httpParts[2],
+                                        readyState : 4,
+                                        getAllResponseHeaders : function(){ return headerStr;},
+                                        getResponseHeader : function(name){ return headers[name];}}; 
+                                
+                                var contentLength = headers['Content-Length']; 
+                                if(contentLength){
+                                        if(contentLength <= data.length){
+                                                message.responseText = data.substring(0,contentLength);
+                                                data = data.substring(contentLength);
+                                                this.lastIndex = xhr.responseText.length - data.length; // need to pick up from where we left on streaming connections
+                                        }
+                                        else {
+                                                return; // the response not finished
+                                        }
+                                }
+                                else {// TODO: Need to check if the headers are complete before incrementing the last index
+                                        this.lastIndex = xhr.responseText.length - data.length; // need to pick up from where we left on streaming connections
+                                }
+                                if (this._processMessage(message))
+                                        return "conflict";
+                        }
+                        return;
+                }
+                if(xhr.readyState != 4){ // we only want finished responses here if we are not streaming 
+                        return;
+                }
+                
+                if(xhr.__proto__){// firefox uses this property, so we create an instance to shadow this property
+                        xhr = {channel:"channel",__proto__:xhr};
+                }
+                return this._processMessage(xhr);
+        
+        }
+});