| New file |
|---|
| 0,0 → 1,684 |
|---|
| if(!dojo._hasResource["dojox._cometd.cometd"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. |
| dojo._hasResource["dojox._cometd.cometd"] = true; |
| dojo.provide("dojox._cometd.cometd"); |
| dojo.require("dojo.AdapterRegistry"); |
| dojo.require("dojo.io.script"); |
| |
| // FIXME: need to add local topic support to advise about: |
| // successful handshake |
| // network failure of channel |
| // graceful disconnect |
| |
| /* |
| * this file defines Comet protocol client. Actual message transport is |
| * deferred to one of several connection type implementations. The default is a |
| * long-polling implementation. A single global object named "dojox.cometd" is |
| * used to mediate for these connection types in order to provide a stable |
| * interface. |
| */ |
| |
| dojox.cometd = new function(){ |
| |
| /* cometd states: |
| * DISCONNECTED: _initialized==false && _connected==false |
| * CONNECTING: _initialized==true && _connected==false (handshake sent) |
| * CONNECTED: _initialized==true && _connected==true (first successful connect) |
| * DISCONNECTING: _initialized==false && _connected==true (disconnect sent) |
| */ |
| this._initialized = false; |
| this._connected = false; |
| this._polling = false; |
| |
| this.connectionTypes = new dojo.AdapterRegistry(true); |
| |
| this.version = "1.0"; |
| this.minimumVersion = "0.9"; |
| this.clientId = null; |
| this.messageId = 0; |
| this.batch=0; |
| |
| this._isXD = false; |
| this.handshakeReturn = null; |
| this.currentTransport = null; |
| this.url = null; |
| this.lastMessage = null; |
| this.topics = {}; |
| this._messageQ = []; |
| this.handleAs="json-comment-optional"; |
| this.advice; |
| this.pendingSubscriptions = {} |
| this.pendingUnsubscriptions = {} |
| |
| this._subscriptions = []; |
| |
| this.tunnelInit = function(childLocation, childDomain){ |
| // placeholder |
| } |
| |
| this.tunnelCollapse = function(){ |
| console.debug("tunnel collapsed!"); |
| // placeholder |
| } |
| |
| this.init = function(root, props, bargs){ |
| // FIXME: if the root isn't from the same host, we should automatically |
| // try to select an XD-capable transport |
| props = props||{}; |
| // go ask the short bus server what we can support |
| props.version = this.version; |
| props.minimumVersion = this.minimumVersion; |
| props.channel = "/meta/handshake"; |
| props.id = ""+this.messageId++; |
| |
| this.url = root||djConfig["cometdRoot"]; |
| if(!this.url){ |
| console.debug("no cometd root specified in djConfig and no root passed"); |
| return; |
| } |
| |
| // Are we x-domain? borrowed from dojo.uri.Uri in lieu of fixed host and port properties |
| var regexp = "^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$"; |
| var r = (""+window.location).match(new RegExp(regexp)); |
| if(r[4]){ |
| var tmp = r[4].split(":"); |
| var thisHost = tmp[0]; |
| var thisPort = tmp[1]||"80"; // FIXME: match 443 |
| |
| r = this.url.match(new RegExp(regexp)); |
| if(r[4]){ |
| tmp = r[4].split(":"); |
| var urlHost = tmp[0]; |
| var urlPort = tmp[1]||"80"; |
| this._isXD = ((urlHost != thisHost)||(urlPort != thisPort)); |
| } |
| } |
| |
| if(!this._isXD){ |
| if(props.ext){ |
| if(props.ext["json-comment-filtered"]!==true && props.ext["json-comment-filtered"]!==false){ |
| props.ext["json-comment-filtered"] = true; |
| } |
| }else{ |
| props.ext = { "json-comment-filtered": true }; |
| } |
| } |
| |
| var bindArgs = { |
| url: this.url, |
| handleAs: this.handleAs, |
| content: { "message": dojo.toJson([props]) }, |
| load: dojo.hitch(this, "finishInit"), |
| error: function(e){ console.debug("handshake error!:", e); } |
| }; |
| |
| if(bargs){ |
| dojo.mixin(bindArgs, bargs); |
| } |
| this._props=props; |
| this._initialized=true; |
| this.batch=0; |
| this.startBatch(); |
| |
| // if xdomain, then we assume jsonp for handshake |
| if(this._isXD){ |
| bindArgs.callbackParamName="jsonp"; |
| return dojo.io.script.get(bindArgs); |
| } |
| return dojo.xhrPost(bindArgs); |
| } |
| |
| this.finishInit = function(data){ |
| data = data[0]; |
| this.handshakeReturn = data; |
| |
| // pick a transport |
| if(data["advice"]){ |
| this.advice = data.advice; |
| } |
| |
| if(!data.successful){ |
| console.debug("cometd init failed"); |
| if(this.advice && this.advice["reconnect"]=="none"){ |
| return; |
| } |
| |
| if( this.advice && this.advice["interval"] && this.advice.interval>0 ){ |
| var cometd=this; |
| setTimeout(function(){ cometd.init(cometd.url,cometd._props); }, this.advice.interval); |
| }else{ |
| this.init(this.url,this._props); |
| } |
| |
| return; |
| } |
| if(data.version < this.minimumVersion){ |
| console.debug("cometd protocol version mismatch. We wanted", this.minimumVersion, "but got", data.version); |
| return; |
| } |
| this.currentTransport = this.connectionTypes.match( |
| data.supportedConnectionTypes, |
| data.version, |
| this._isXD |
| ); |
| this.currentTransport._cometd = this; |
| this.currentTransport.version = data.version; |
| this.clientId = data.clientId; |
| this.tunnelInit = dojo.hitch(this.currentTransport, "tunnelInit"); |
| this.tunnelCollapse = dojo.hitch(this.currentTransport, "tunnelCollapse"); |
| |
| this.currentTransport.startup(data); |
| } |
| |
| // public API functions called by cometd or by the transport classes |
| this.deliver = function(messages){ |
| // console.debug(messages); |
| dojo.forEach(messages, this._deliver, this); |
| return messages; |
| } |
| |
| this._deliver = function(message){ |
| // dipatch events along the specified path |
| |
| if(!message["channel"]){ |
| if(message["success"] !== true){ |
| console.debug("cometd error: no channel for message!", message); |
| return; |
| } |
| } |
| this.lastMessage = message; |
| |
| if(message.advice){ |
| this.advice = message.advice; // TODO maybe merge? |
| } |
| |
| // check to see if we got a /meta channel message that we care about |
| if( (message["channel"]) && |
| (message.channel.length > 5)&& |
| (message.channel.substr(0, 5) == "/meta")){ |
| // check for various meta topic actions that we need to respond to |
| switch(message.channel){ |
| case "/meta/connect": |
| if(message.successful && !this._connected){ |
| this._connected = this._initialized; |
| this.endBatch(); |
| } else if(!this._initialized){ |
| this._connected = false; // finish disconnect |
| } |
| break; |
| case "/meta/subscribe": |
| var pendingDef = this.pendingSubscriptions[message.subscription]; |
| if(!message.successful){ |
| if(pendingDef){ |
| pendingDef.errback(new Error(message.error)); |
| delete this.pendingSubscriptions[message.subscription]; |
| } |
| return; |
| } |
| dojox.cometd.subscribed(message.subscription, message); |
| if(pendingDef){ |
| pendingDef.callback(true); |
| delete this.pendingSubscriptions[message.subscription]; |
| } |
| break; |
| case "/meta/unsubscribe": |
| var pendingDef = this.pendingUnsubscriptions[message.subscription]; |
| if(!message.successful){ |
| if(pendingDef){ |
| pendingDef.errback(new Error(message.error)); |
| delete this.pendingUnsubscriptions[message.subscription]; |
| } |
| return; |
| } |
| this.unsubscribed(message.subscription, message); |
| if(pendingDef){ |
| pendingDef.callback(true); |
| delete this.pendingUnsubscriptions[message.subscription]; |
| } |
| break; |
| } |
| } |
| |
| // send the message down for processing by the transport |
| this.currentTransport.deliver(message); |
| |
| if(message.data){ |
| // dispatch the message to any locally subscribed listeners |
| var tname = "/cometd"+message.channel; |
| dojo.publish(tname, [ message ]); |
| } |
| } |
| |
| this.disconnect = function(){ |
| dojo.forEach(this._subscriptions, dojo.unsubscribe); |
| this._subscriptions = []; |
| this._messageQ = []; |
| if(this._initialized && this.currentTransport){ |
| this._initialized=false; |
| this.currentTransport.disconnect(); |
| } |
| this._initialized=false; |
| if(!this._polling) |
| this._connected=false; |
| } |
| |
| // public API functions called by end users |
| this.publish = function(/*string*/channel, /*object*/data, /*object*/properties){ |
| // summary: |
| // publishes the passed message to the cometd server for delivery |
| // on the specified topic |
| // channel: |
| // the destination channel for the message |
| // data: |
| // a JSON object containing the message "payload" |
| // properties: |
| // Optional. Other meta-data to be mixed into the top-level of the |
| // message |
| var message = { |
| data: data, |
| channel: channel |
| }; |
| if(properties){ |
| dojo.mixin(message, properties); |
| } |
| this._sendMessage(message); |
| } |
| |
| this._sendMessage = function(/* object */ message){ |
| if(this.currentTransport && this._connected && this.batch==0){ |
| return this.currentTransport.sendMessages([message]); |
| } |
| else{ |
| this._messageQ.push(message); |
| } |
| } |
| |
| this.subscribe = function( /*string */ channel, |
| /*object, optional*/ objOrFunc, |
| /*string, optional*/ funcName){ // return: boolean |
| // summary: |
| // inform the server of this client's interest in channel |
| // channel: |
| // name of the cometd channel to subscribe to |
| // objOrFunc: |
| // an object scope for funcName or the name or reference to a |
| // function to be called when messages are delivered to the |
| // channel |
| // funcName: |
| // the second half of the objOrFunc/funcName pair for identifying |
| // a callback function to notifiy upon channel message delivery |
| |
| if(this.pendingSubscriptions[channel]){ |
| // We already asked to subscribe to this channel, and |
| // haven't heard back yet. Fail the previous attempt. |
| var oldDef = this.pendingSubscriptions[channel]; |
| oldDef.cancel(); |
| delete this.pendingSubscriptions[channel]; |
| } |
| |
| var pendingDef = new dojo.Deferred(); |
| this.pendingSubscriptions[channel] = pendingDef; |
| |
| if(objOrFunc){ |
| var tname = "/cometd"+channel; |
| if(this.topics[tname]){ |
| dojo.unsubscribe(this.topics[tname]); |
| } |
| var topic = dojo.subscribe(tname, objOrFunc, funcName); |
| this.topics[tname] = topic; |
| } |
| |
| this._sendMessage({ |
| channel: "/meta/subscribe", |
| subscription: channel |
| }); |
| |
| return pendingDef; |
| |
| } |
| |
| this.subscribed = function( /*string*/ channel, |
| /*obj*/ message){ |
| } |
| |
| |
| this.unsubscribe = function(/*string*/ channel){ // return: boolean |
| // summary: |
| // inform the server of this client's disinterest in channel |
| // channel: |
| // name of the cometd channel to unsubscribe from |
| |
| if(this.pendingUnsubscriptions[channel]){ |
| // We already asked to unsubscribe from this channel, and |
| // haven't heard back yet. Fail the previous attempt. |
| var oldDef = this.pendingUnsubscriptions[channel]; |
| oldDef.cancel(); |
| delete this.pendingUnsubscriptions[channel]; |
| } |
| |
| var pendingDef = new dojo.Deferred(); |
| this.pendingUnsubscriptions[channel] = pendingDef; |
| |
| var tname = "/cometd"+channel; |
| if(this.topics[tname]){ |
| dojo.unsubscribe(this.topics[tname]); |
| } |
| |
| this._sendMessage({ |
| channel: "/meta/unsubscribe", |
| subscription: channel |
| }); |
| |
| return pendingDef; |
| |
| } |
| |
| this.unsubscribed = function( /*string*/ channel, |
| /*obj*/ message){ |
| } |
| |
| this.startBatch = function(){ |
| this.batch++; |
| } |
| |
| this.endBatch = function(){ |
| if(--this.batch <= 0 && this.currentTransport && this._connected){ |
| this.batch=0; |
| |
| var messages=this._messageQ; |
| this._messageQ=[]; |
| if(messages.length>0){ |
| this.currentTransport.sendMessages(messages); |
| } |
| } |
| } |
| |
| this._onUnload = function(){ |
| // make this the last of the onUnload method |
| dojo.addOnUnload(dojox.cometd,"disconnect"); |
| } |
| } |
| |
| /* |
| transport objects MUST expose the following methods: |
| - check |
| - startup |
| - sendMessages |
| - deliver |
| - disconnect |
| optional, standard but transport dependent methods are: |
| - tunnelCollapse |
| - tunnelInit |
| |
| Transports SHOULD be namespaced under the cometd object and transports MUST |
| register themselves with cometd.connectionTypes |
| |
| here's a stub transport defintion: |
| |
| cometd.blahTransport = new function(){ |
| this._connectionType="my-polling"; |
| this._cometd=null; |
| this.lastTimestamp = null; |
| |
| this.check = function(types, version, xdomain){ |
| // summary: |
| // determines whether or not this transport is suitable given a |
| // list of transport types that the server supports |
| return dojo.lang.inArray(types, "blah"); |
| } |
| |
| this.startup = function(){ |
| if(dojox.cometd._polling){ return; } |
| // FIXME: fill in startup routine here |
| dojox.cometd._polling = true; |
| } |
| |
| this.sendMessages = function(message){ |
| // FIXME: fill in message array sending logic |
| } |
| |
| this.deliver = function(message){ |
| if(message["timestamp"]){ |
| this.lastTimestamp = message.timestamp; |
| } |
| if( (message.channel.length > 5)&& |
| (message.channel.substr(0, 5) == "/meta")){ |
| // check for various meta topic actions that we need to respond to |
| // switch(message.channel){ |
| // case "/meta/connect": |
| // // FIXME: fill in logic here |
| // break; |
| // // case ...: ... |
| // } |
| } |
| } |
| |
| this.disconnect = function(){ |
| } |
| } |
| cometd.connectionTypes.register("blah", cometd.blahTransport.check, cometd.blahTransport); |
| */ |
| |
| dojox.cometd.longPollTransport = new function(){ |
| this._connectionType="long-polling"; |
| this._cometd=null; |
| this.lastTimestamp = null; |
| |
| this.check = function(types, version, xdomain){ |
| return ((!xdomain)&&(dojo.indexOf(types, "long-polling") >= 0)); |
| } |
| |
| this.tunnelInit = function(){ |
| if(this._cometd._polling){ return; } |
| this.openTunnelWith({ |
| message: dojo.toJson([ |
| { |
| channel: "/meta/connect", |
| clientId: this._cometd.clientId, |
| connectionType: this._connectionType, |
| id: ""+this._cometd.messageId++ |
| } |
| ]) |
| }); |
| } |
| |
| this.tunnelCollapse = function(){ |
| if(!this._cometd._polling){ |
| // try to restart the tunnel |
| this._cometd._polling = false; |
| |
| // TODO handle transport specific advice |
| |
| if(this._cometd["advice"]){ |
| if(this._cometd.advice["reconnect"]=="none"){ |
| return; |
| } |
| |
| if( (this._cometd.advice["interval"])&& |
| (this._cometd.advice.interval>0) ){ |
| var transport = this; |
| setTimeout(function(){ transport._connect(); }, |
| this._cometd.advice.interval); |
| }else{ |
| this._connect(); |
| } |
| }else{ |
| this._connect(); |
| } |
| } |
| } |
| |
| this._connect = function(){ |
| if( (this._cometd["advice"])&& |
| (this._cometd.advice["reconnect"]=="handshake") |
| ){ |
| this._cometd.init(this._cometd.url,this._cometd._props); |
| }else if(this._cometd._connected){ |
| this.openTunnelWith({ |
| message: dojo.toJson([ |
| { |
| channel: "/meta/connect", |
| connectionType: this._connectionType, |
| clientId: this._cometd.clientId, |
| timestamp: this.lastTimestamp, |
| id: ""+this._cometd.messageId++ |
| } |
| ]) |
| }); |
| } |
| } |
| |
| this.deliver = function(message){ |
| // console.debug(message); |
| if(message["timestamp"]){ |
| this.lastTimestamp = message.timestamp; |
| } |
| } |
| |
| this.openTunnelWith = function(content, url){ |
| // console.debug("openTunnelWith:", content, (url||cometd.url)); |
| var d = dojo.xhrPost({ |
| url: (url||this._cometd.url), |
| content: content, |
| handleAs: this._cometd.handleAs, |
| load: dojo.hitch(this, function(data){ |
| // console.debug(evt.responseText); |
| // console.debug(data); |
| this._cometd._polling = false; |
| this._cometd.deliver(data); |
| this.tunnelCollapse(); |
| }), |
| error: function(err){ |
| console.debug("tunnel opening failed:", err); |
| dojo.cometd._polling = false; |
| |
| // TODO - follow advice to reconnect or rehandshake? |
| } |
| }); |
| this._cometd._polling = true; |
| } |
| |
| this.sendMessages = function(messages){ |
| for(var i=0; i<messages.length; i++){ |
| messages[i].clientId = this._cometd.clientId; |
| messages[i].id = ""+this._cometd.messageId++; |
| } |
| return dojo.xhrPost({ |
| url: this._cometd.url||djConfig["cometdRoot"], |
| handleAs: this._cometd.handleAs, |
| load: dojo.hitch(this._cometd, "deliver"), |
| content: { |
| message: dojo.toJson(messages) |
| } |
| }); |
| } |
| |
| this.startup = function(handshakeData){ |
| if(this._cometd._connected){ return; } |
| this.tunnelInit(); |
| } |
| |
| this.disconnect = function(){ |
| dojo.xhrPost({ |
| url: this._cometd.url||djConfig["cometdRoot"], |
| handleAs: this._cometd.handleAs, |
| content: { |
| message: dojo.toJson([{ |
| channel: "/meta/disconnect", |
| clientId: this._cometd.clientId, |
| id: ""+this._cometd.messageId++ |
| }]) |
| } |
| }); |
| } |
| } |
| |
| dojox.cometd.callbackPollTransport = new function(){ |
| this._connectionType = "callback-polling"; |
| this._cometd = null; |
| this.lastTimestamp = null; |
| |
| this.check = function(types, version, xdomain){ |
| // we handle x-domain! |
| return (dojo.indexOf(types, "callback-polling") >= 0); |
| } |
| |
| this.tunnelInit = function(){ |
| if(this._cometd._polling){ return; } |
| this.openTunnelWith({ |
| message: dojo.toJson([ |
| { |
| channel: "/meta/connect", |
| clientId: this._cometd.clientId, |
| connectionType: this._connectionType, |
| id: ""+this._cometd.messageId++ |
| } |
| ]) |
| }); |
| } |
| |
| this.tunnelCollapse = dojox.cometd.longPollTransport.tunnelCollapse; |
| this._connect = dojox.cometd.longPollTransport._connect; |
| this.deliver = dojox.cometd.longPollTransport.deliver; |
| |
| this.openTunnelWith = function(content, url){ |
| // create a <script> element to generate the request |
| dojo.io.script.get({ |
| load: dojo.hitch(this, function(data){ |
| this._cometd._polling = false; |
| this._cometd.deliver(data); |
| this.tunnelCollapse(); |
| }), |
| error: function(){ |
| this._cometd._polling = false; |
| console.debug("tunnel opening failed"); |
| }, |
| url: (url||this._cometd.url), |
| content: content, |
| callbackParamName: "jsonp" |
| }); |
| this._cometd._polling = true; |
| } |
| |
| this.sendMessages = function(/*array*/ messages){ |
| for(var i=0; i<messages.length; i++){ |
| messages[i].clientId = this._cometd.clientId; |
| messages[i].id = ""+this._cometd.messageId++; |
| } |
| var bindArgs = { |
| url: this._cometd.url||djConfig["cometdRoot"], |
| load: dojo.hitch(this._cometd, "deliver"), |
| callbackParamName: "jsonp", |
| content: { message: dojo.toJson( messages ) } |
| }; |
| return dojo.io.script.get(bindArgs); |
| } |
| |
| this.startup = function(handshakeData){ |
| if(this._cometd._connected){ return; } |
| this.tunnelInit(); |
| } |
| |
| this.disconnect = dojox.cometd.longPollTransport.disconnect; |
| |
| |
| this.disconnect = function(){ |
| dojo.io.script.get({ |
| url: this._cometd.url||djConfig["cometdRoot"], |
| callbackParamName: "jsonp", |
| content: { |
| message: dojo.toJson([{ |
| channel: "/meta/disconnect", |
| clientId: this._cometd.clientId, |
| id: ""+this._cometd.messageId++ |
| }]) |
| } |
| }); |
| } |
| } |
| dojox.cometd.connectionTypes.register("long-polling", dojox.cometd.longPollTransport.check, dojox.cometd.longPollTransport); |
| dojox.cometd.connectionTypes.register("callback-polling", dojox.cometd.callbackPollTransport.check, dojox.cometd.callbackPollTransport); |
| |
| dojo.addOnUnload(dojox.cometd,"_onUnload"); |
| |
| |
| } |