Subversion Repositories Applications.papyrus

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");

}