dojo-pkg 1.111.0

data/data/dojo-release-1.1.1-src/dojox/cometd/_base.js

@@ -0,0 +1,946 @@
+dojo.provide("dojox.cometd._base");
+dojo.require("dojo.AdapterRegistry");
+dojo.require("dojo.io.script");
+
+
+/*
+ * 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.
+ *
+ * extensions modules may be loaded (eg "dojox.cometd.timestamp", that use
+ * the cometd._extendInList and cometd._extendOutList fields to provide functions
+ * that extend and handling incoming and outgoing messages.
+ */
+
+dojox.cometd = new function(){
+	
+	// cometd states:
+
+	// alex; OMG, these "constants" need to die. Java truly is a degenerative disease.
+ 	this.DISCONNECTED = "DISCONNECTED";		// _initialized==false 	&& _connected==false
+ 	this.CONNECTING = "CONNECTING";			// _initialized==true	&& _connected==false (handshake sent)
+ 	this.CONNECTED = "CONNECTED";			// _initialized==true	&& _connected==true (first successful connect)
+ 	this.DISCONNECTING = "DISCONNECING";	// _initialized==false 	&& _connected==true (disconnect sent)
+ 	
+	this._initialized = false;
+	this._connected = false;
+	this._polling = false;
+
+	this.expectedNetworkDelay = 5000; // expected max network delay
+	this.connectTimeout = 0;    // If set, used as ms to wait for a connect response and sent as the advised timeout
+
+	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._messageQ = [];
+	this.handleAs = "json-comment-optional";
+	this._advice = {};
+	this._backoffInterval = 0;
+	this._backoffIncrement = 1000;
+	this._backoffMax = 60000;
+	this._deferredSubscribes = {};
+	this._deferredUnsubscribes = {};
+	this._subscriptions = [];
+	this._extendInList = [];	// List of functions invoked before delivering messages
+	this._extendOutList = [];	// List of functions invoked before sending messages
+
+	this.state = function() {
+		return this._initialized ? 
+			(this._connected ? "CONNECTED" : "CONNECTING") : 
+			( this._connected ? "DISCONNECTING" : "DISCONNECTED");
+	}
+
+	this.init = function(	/*String*/	root,
+				/*Object?*/ props,
+				/*Object?*/ bargs){	// return: dojo.Deferred
+		//	summary:
+		//		Initialize the cometd implementation of the Bayeux protocol
+		//	description:
+		//		Initialize the cometd implementation of the Bayeux protocol by
+		//		sending a handshake message. The cometd state will be changed to CONNECTING
+		//		until a handshake response is received and the first successful connect message
+		//		has returned.
+		//		The protocol state changes may be monitored
+		//		by subscribing to the dojo topic "/cometd/meta" where events are
+		//		published in the form {cometd:this,action:"handshake",successful:true,state:this.state()}
+		//	root:
+		//		The URL of the cometd server. If the root is absolute, the host
+		//		is examined to determine if xd transport is needed. Otherwise the
+		//		same domain is assumed.
+		//	props:
+		//		An optional object that is used as the basis of the handshake message
+		//	bargs:
+		//		An optional object of bind args mixed in with the send of the handshake
+		//	example:
+		//	|	dojox.cometd.init("/cometd");
+		//	|	dojox.cometd.init("http://xdHost/cometd",{ext:{user:"fred",pwd:"secret"}});
+
+
+		// 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||dojo.config["cometdRoot"];
+		if(!this.url){
+			console.debug("no cometd root specified in djConfig and no root passed");
+			return null;
+		}
+
+		// Are we x-domain? borrowed from dojo.uri.Uri in lieu of fixed host and port properties
+		var regexp = "^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$";
+		var parts = (""+window.location).match(new RegExp(regexp));
+		if(parts[4]){
+			var tmp = parts[4].split(":");
+			var thisHost = tmp[0];
+			var thisPort = tmp[1]||"80"; // FIXME: match 443
+
+			parts = this.url.match(new RegExp(regexp));
+			if(parts[4]){
+				tmp = parts[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 };
+			}
+			props.supportedConnectionTypes = dojo.map(this.connectionTypes.pairs, "return item[0]");
+		}
+
+		props = this._extendOut(props);
+
+		var bindArgs = {
+			url: this.url,
+			handleAs: this.handleAs,
+			content: { "message": dojo.toJson([props]) },
+			load: dojo.hitch(this,function(msg){
+				this._backon();
+				this._finishInit(msg);
+			}),
+			error: dojo.hitch(this,function(e){
+				console.debug("handshake error!:",e);
+				this._backoff();
+				this._finishInit([{}]);
+			})
+		};
+
+		if(bargs){
+			dojo.mixin(bindArgs, bargs);
+		}
+		this._props = props;
+		for(var tname in this._subscriptions){
+			for(var sub in this._subscriptions[tname]){
+				if(this._subscriptions[tname][sub].topic){
+		 			dojo.unsubscribe(this._subscriptions[tname][sub].topic);
+				}
+			}
+		}
+		this._messageQ = [];
+		this._subscriptions = [];
+		this._initialized = true;
+		this.batch = 0;
+		this.startBatch();
+		
+		var r;
+		// if xdomain, then we assume jsonp for handshake
+		if(this._isXD){
+			bindArgs.callbackParamName = "jsonp";
+			r = dojo.io.script.get(bindArgs);
+		}else{
+			r = dojo.xhrPost(bindArgs);
+		}
+		dojo.publish("/cometd/meta", [
+			{
+				cometd: this,
+				action: "handshake",
+				successful: true,
+				state: this.state()
+			}
+		]);
+		return r;
+	}
+	
+	
+	this.publish = function(/*String*/ channel, /*Object*/ data, /*Object?*/ props){
+		// 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(props){
+			dojo.mixin(message, props);
+		}
+		this._sendMessage(message);
+	}
+
+	
+	this.subscribe = function(	/*String */	channel,
+					/*Object */	objOrFunc,
+					/*String */	funcName,
+					/*Object?*/ props){ // return: dojo.Deferred
+		//	summary:
+		//		inform the server of this client's interest in channel
+		//	description:
+		//		`dojox.cometd.subscribe()` handles all the hard work of telling
+		//		the server that we want to be notified when events are
+		//		published on a particular topic. `subscribe` accepts a function
+		//		to handle messages and returns a `dojo.Deferred` object which
+		//		has an extra property added to it which makes it suitable for
+		//		passing to `dojox.cometd.unsubscribe()` as a "subscription
+		//		handle" (much like the handle object that `dojo.connect()`
+		//		produces and which `dojo.disconnect()` expects).
+		//		
+		//		Note that of a subscription is registered before a connection
+		//		with the server is established, events sent before the
+		//		connection is established will not be delivered to this client.
+		//		The deferred object which `subscribe` returns will callback
+		//		when the server successfuly acknolwedges receipt of our
+		//		"subscribe" request.
+		//	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
+		//	example:
+		//		Simple subscribe use-case
+		//	|	dojox.cometd.init("http://myserver.com:8080/cometd");
+		//	|	// log out all incoming messages on /foo/bar
+		//	|	dojox.cometd.subscribe("/foo/bar", console, "debug");
+		//	example:
+		//		Subscribe before connection is initialized
+		//	|	dojox.cometd.subscribe("/foo/bar", console, "debug");
+		//	|	dojox.cometd.init("http://myserver.com:8080/cometd");
+		//	example:
+		//		Subscribe an unsubscribe
+		//	|	dojox.cometd.init("http://myserver.com:8080/cometd");
+		//	|	var h = dojox.cometd.subscribe("/foo/bar", console, "debug");
+		//	|	dojox.cometd.unsubscribe(h);
+		//	example:
+		//		Listen for successful subscription:
+		//	|	dojox.cometd.init("http://myserver.com:8080/cometd");
+		//	|	var h = dojox.cometd.subscribe("/foo/bar", console, "debug");
+		//	|	h.addCallback(function(){
+		//	|		console.debug("subscription to /foo/bar established");
+		//	|	});
+
+		props = props||{};
+		if(objOrFunc){
+			var tname = "/cometd"+channel;
+			var subs = this._subscriptions[tname];
+			if(!subs || subs.length==0){
+				subs = [];
+				props.channel = "/meta/subscribe";
+				props.subscription = channel;
+				this._sendMessage(props);
+				
+				var _ds = this._deferredSubscribes;
+				if(_ds[channel]){
+					_ds[channel].cancel();
+					delete _ds[channel];
+				}
+				_ds[channel] = new dojo.Deferred();
+			}
+			
+			for(var i in subs){
+				if( subs[i].objOrFunc === objOrFunc && (!subs[i].funcName&&!funcName||subs[i].funcName==funcName) ){
+					return null;
+				}
+			}
+			
+			var topic = dojo.subscribe(tname, objOrFunc, funcName);
+			subs.push({ 
+				topic: topic, 
+				objOrFunc: objOrFunc, 
+				funcName: funcName
+			});
+			this._subscriptions[tname] = subs;
+		}
+		var ret = this._deferredSubscribes[channel]||{};
+		ret.args = dojo._toArray(arguments);
+		return ret; // dojo.Deferred
+	}
+
+
+
+	this.unsubscribe = function(	/*String*/	channel,
+					/*Object?*/ objOrFunc,
+					/*String?*/ funcName,
+					/*Object?*/ props){
+		// summary:
+		//		inform the server of this client's disinterest in channel
+		// channel:
+		//		name of the cometd channel to unsubscribe from
+		// objOrFunc:
+		//		an object scope for funcName or the name or reference to a
+		//		function to be called when messages are delivered to the
+		//		channel. If null then all subscribers to the channel are unsubscribed.
+		// funcName:
+		//		the second half of the objOrFunc/funcName pair for identifying
+		//		a callback function to notifiy upon channel message delivery
+
+		if(
+			(arguments.length == 1) &&
+			(!dojo.isString(channel)) &&
+			(channel.args)
+		){
+			// it's a subscription handle, unroll
+			return this.unsubscribe.apply(this, channel.args);
+		}
+		
+		var tname = "/cometd"+channel;
+		var subs = this._subscriptions[tname];
+		if(!subs || subs.length==0){
+			return null;
+		}
+
+		var s=0;
+		for(var i in subs){
+			var sb = subs[i];
+			if( (!objOrFunc) ||
+				(
+					sb.objOrFunc===objOrFunc &&
+					(!sb.funcName && !funcName || sb.funcName==funcName)
+				)
+			){
+				dojo.unsubscribe(subs[i].topic);
+				delete subs[i];
+			}else{
+				s++;
+			}
+		}
+		
+		if(s==0){
+			props = props||{};
+			props.channel = "/meta/unsubscribe";
+			props.subscription = channel;
+			delete this._subscriptions[tname];
+			this._sendMessage(props);
+			this._deferredUnsubscribes[channel] = new dojo.Deferred();
+			if (this._deferredSubscribes[channel]){
+				this._deferredSubscribes[channel].cancel();
+				delete this._deferredSubscribes[channel];
+			}
+		}
+		return this._deferredUnsubscribes[channel]; // dojo.Deferred
+	}
+	
+	
+	this.disconnect = function(){
+		//	summary:
+		//		Disconnect from the server.
+		//	description:
+		//		Disconnect from the server by sending a disconnect message
+		//	example:
+		//	|	dojox.cometd.disconnect();
+
+		for(var tname in this._subscriptions){
+			for(var sub in this._subscriptions[tname]){
+				if(this._subscriptions[tname][sub].topic){
+					dojo.unsubscribe(this._subscriptions[tname][sub].topic);
+				}
+			}
+		}
+		this._subscriptions = [];
+		this._messageQ = [];
+		if(this._initialized && this.currentTransport){
+			this._initialized=false;
+			this.currentTransport.disconnect();
+		}
+		if(!this._polling) {
+			this._connected=false;
+			dojo.publish("/cometd/meta", [{cometd:this,action:"connect",successful:false,state:this.state()}]);
+		}
+		this._initialized=false;
+		dojo.publish("/cometd/meta", [{cometd:this,action:"disconnect",successful:true,state:this.state()}]);
+	}
+
+	
+	// public extension points
+	
+	this.subscribed = function(	/*String*/channel, /*Object*/message){ }
+
+	this.unsubscribed = function(/*String*/channel, /*Object*/message){ }
+
+
+	// private methods (TODO name all with leading _)
+
+	this.tunnelInit = function(childLocation, childDomain){
+		// placeholder - replaced by _finishInit
+	}
+	
+	this.tunnelCollapse = function(){
+		// placeholder - replaced by _finishInit
+	}
+	
+	this._backoff = function(){
+		if(!this._advice){
+			this._advice={reconnect:"retry",interval:0};
+		}
+		else if(!this._advice.interval){
+			this._advice.interval=0;
+		}
+		if(this._backoffInterval<this._backoffMax){
+			this._backoffInterval+=this._backoffIncrement;
+		}
+	}
+	
+	this._backon = function(){
+		this._backoffInterval=0;
+	}
+
+	this._interval = function(){
+		var i=this._backoffInterval+(this._advice?(this._advice.interval?this._advice.interval:0):0);
+		if (i>0)
+			console.debug("Retry in interval+backoff="+this._advice.interval+"+"+this._backoffInterval+"="+i+"ms");
+		return i;
+	}
+
+	this._finishInit = function(data){
+		//	summary:
+		//		Handle the handshake return from the server and initialize
+		//		connection if all is OK
+		data = data[0];
+		this.handshakeReturn = data;
+		
+		// remember any advice
+		if(data["advice"]){
+			this._advice = data.advice;
+		}
+
+		var successful=data.successful?data.successful:false;
+		
+		// check version
+		if(data.version < this.minimumVersion){
+			console.debug("cometd protocol version mismatch. We wanted", this.minimumVersion, "but got", data.version);
+			successful=false;
+			this._advice.reconnect="none";
+		}
+		
+		// If all OK
+		if(successful){
+			// pick a transport
+			this.currentTransport = this.connectionTypes.match(
+				data.supportedConnectionTypes,
+				data.version,
+				this._isXD
+			);
+			// initialize the transport
+			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);
+		}
+
+		dojo.publish("/cometd/meta", [{cometd:this,action:"handshook",successful:successful,state:this.state()}]);
+
+		// If there is a problem
+		if(!successful){
+			console.debug("cometd init failed");
+			// follow advice
+			if(this._advice && this._advice["reconnect"]=="none"){
+				console.debug("cometd reconnect: none");
+			}else{
+				setTimeout(dojo.hitch(this, "init", this.url, this._props),this._interval());
+			}
+		}
+	}
+
+	// fixme: lots of repeated code...why?
+
+	this._extendIn = function(message){
+		// Handle extensions for inbound messages
+		dojo.forEach(dojox.cometd._extendInList, function(f){
+			message = f(message)||message;
+		});
+		return message;
+	}
+
+	this._extendOut = function(message){
+		// Handle extensions for inbound messages
+		dojo.forEach(dojox.cometd._extendOutList, function(f){
+			message = f(message)||message;
+		});
+		return message;
+	}
+
+
+	this.deliver = function(messages){
+		dojo.forEach(messages, this._deliver, this);
+		return messages;
+	}
+
+	this._deliver = function(message){
+		// dipatch events along the specified path
+		
+		message=this._extendIn(message);
+
+		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
+		var deferred=null;
+		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
+					}
+					dojo.publish("/cometd/meta",[{cometd:this,action:"connect",successful:message.successful,state:this.state()}]);
+					break;
+				case "/meta/subscribe":
+					deferred = this._deferredSubscribes[message.subscription];
+					if(!message.successful){
+						if(deferred){
+							deferred.errback(new Error(message.error));
+						}
+						this.currentTransport.cancelConnect();
+						return;
+					}
+					dojox.cometd.subscribed(message.subscription, message);
+					if(deferred){
+						deferred.callback(true);
+					}
+					break;
+				case "/meta/unsubscribe":
+					deferred = this._deferredUnsubscribes[message.subscription];
+					if(!message.successful){
+						if(deferred){
+							deferred.errback(new Error(message.error));
+						}
+						this.currentTransport.cancelConnect();
+						return;
+					}
+					this.unsubscribed(message.subscription, message);
+					if(deferred){
+						deferred.callback(true);
+					}
+					break;
+				default:
+					if(message.successful && !message.successful){
+						this.currentTransport.cancelConnect();
+						return;
+					}
+			}
+		}
+		
+		// send the message down for processing by the transport
+		this.currentTransport.deliver(message);
+
+		if(message.data){
+			// dispatch the message to any locally subscribed listeners
+			try {
+                                var messages=[message];
+
+				// Determine target topic
+				var tname="/cometd"+message.channel;
+
+				// Deliver to globs that apply to target topic
+				var tnameParts=message.channel.split("/");
+				var tnameGlob="/cometd";
+				for (var i=1;i<tnameParts.length-1;i++) {
+					dojo.publish(tnameGlob+"/**",messages);
+					tnameGlob+="/"+tnameParts[i];
+				}
+				dojo.publish(tnameGlob+"/**",messages);
+				dojo.publish(tnameGlob+"/*",messages);
+	
+				// deliver to target topic
+				dojo.publish(tname,messages);
+			}catch(e){
+				console.debug(e);
+			}
+		}
+	}
+
+	this._sendMessage = function(/* object */ message){
+		// console.debug(this.currentTransport, this._connected, this.batch);
+		// if(this.currentTransport && this._connected && !this.batch){
+		if(this.currentTransport && !this.batch){
+			return this.currentTransport.sendMessages([message]);
+		}else{
+			this._messageQ.push(message);
+			return null;
+		}
+	}
+
+	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");
+	}
+
+	this._connectTimeout = function(){
+		// return the connect timeout in ms, calculated as the minimum of the advised timeout
+		// and the configured timeout.  Else 0 to indicate no client side timeout
+		var _advised=0;
+		if (this._advice && this._advice.timeout && this.expectedNetworkDelay>0)
+			_advised=this._advice.timeout + this.expectedNetworkDelay;
+		
+		if (this.connectTimeout>0 && this.connectTimeout<_advised)
+			return this.connectTimeout;
+		
+		return 0;
+	}
+}
+
+/*
+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){
+	}
+
+	this.disconnect = function(){
+		// send orderly disconnect message
+	}
+
+	this.cancelConnect = function(){
+		// cancel the current connection
+	}
+}
+cometd.connectionTypes.register("blah", cometd.blahTransport.check, cometd.blahTransport);
+*/
+
+dojox.cometd.longPollTransport = new function(){
+	this._connectionType="long-polling";
+	this._cometd=null;
+
+	this.check = function(types, version, xdomain){
+		return ((!xdomain)&&(dojo.indexOf(types, "long-polling") >= 0));
+	}
+
+	this.tunnelInit = function(){
+		var message = {
+			channel:	"/meta/connect",
+			clientId:	this._cometd.clientId,
+			connectionType: this._connectionType,
+			id:	""+this._cometd.messageId++
+		};
+		message=this._cometd._extendOut(message);
+		this.openTunnelWith({message: dojo.toJson([message])});
+	}
+
+	this.tunnelCollapse = function(){
+		// TODO handle transport specific advice
+		
+		if(!this._cometd._initialized){ return; }
+			
+		if(this._cometd._advice && this._cometd._advice["reconnect"]=="none"){
+			console.debug("cometd reconnect: none");
+			return;
+		}
+		setTimeout(dojo.hitch(this,function(){ this._connect(); }),this._cometd._interval());
+	}
+
+	this._connect = function(){
+		if(!this._cometd._initialized){ return; }
+		if(this._cometd._polling) {
+			console.debug("wait for poll to complete or fail");
+			return;
+		}
+			
+		if((this._cometd._advice) && (this._cometd._advice["reconnect"]=="handshake")){
+			this._cometd._connected=false;
+			this._initialized = false;
+			this._cometd.init(this._cometd.url,this._cometd._props);
+ 		}else if(this._cometd._connected){
+			var message={
+				channel:	"/meta/connect",
+				connectionType: this._connectionType,
+				clientId:	this._cometd.clientId,
+				id:	""+this._cometd.messageId++
+			};
+			if (this._cometd.connectTimeout>this._cometd.expectedNetworkDelay)
+				message.advice={timeout:(this._cometd.connectTimeout-this._cometd.expectedNetworkDelay)};
+			                    
+			message=this._cometd._extendOut(message);
+			this.openTunnelWith({message: dojo.toJson([message])});
+		}
+	}
+
+	this.deliver = function(message){
+		// Nothing to do
+	}
+
+	this.openTunnelWith = function(content, url){
+		this._cometd._polling = true;
+		var post = {
+			url: (url||this._cometd.url),
+			content: content,
+			handleAs: this._cometd.handleAs,
+			load: dojo.hitch(this, function(data){
+				this._cometd._polling=false;
+				this._cometd.deliver(data);
+				this._cometd._backon();
+				this.tunnelCollapse();
+			}),
+			error: dojo.hitch(this, function(err){
+				this._cometd._polling=false;
+				console.debug("tunnel opening failed:", err);
+				dojo.publish("/cometd/meta", [{cometd:this._cometd,action:"connect",successful:false,state:this._cometd.state()}]);
+				this._cometd._backoff();
+				this.tunnelCollapse();
+			})
+		};
+
+		var connectTimeout=this._cometd._connectTimeout();
+		if (connectTimeout>0)
+			post.timeout=connectTimeout;
+
+		this._poll = dojo.xhrPost(post);
+	}
+
+	this.sendMessages = function(messages){
+		for(var i=0; i<messages.length; i++){
+			messages[i].clientId = this._cometd.clientId;
+			messages[i].id = ""+this._cometd.messageId++;
+			messages[i]=this._cometd._extendOut(messages[i]);
+		}
+		return dojo.xhrPost({
+			url: this._cometd.url||dojo.config["cometdRoot"],
+			handleAs: this._cometd.handleAs,
+			load: dojo.hitch(this._cometd, "deliver"),
+			error: dojo.hitch(this, function(err){
+				console.debug('dropped messages: ',messages);
+			}),
+			content: {
+				message: dojo.toJson(messages)
+			}
+		});
+	}
+
+	this.startup = function(handshakeData){
+		if(this._cometd._connected){ return; }
+		this.tunnelInit();
+	}
+
+	this.disconnect = function(){
+		var message={
+			channel:	"/meta/disconnect",
+			clientId:	this._cometd.clientId,
+			id:	""+this._cometd.messageId++
+		};
+		message=this._cometd._extendOut(message);
+		dojo.xhrPost({
+			url: this._cometd.url||dojo.config["cometdRoot"],
+			handleAs: this._cometd.handleAs,
+			content: {
+				message: dojo.toJson([message])
+			}
+		});
+	}
+
+	this.cancelConnect = function(){
+		if (this._poll) {
+			this._poll.cancel();
+			this._cometd._polling=false;
+			dojo.debug("tunnel opening cancelled");
+			dojo.event.topic.publish("/cometd/meta", {cometd:this._cometd,action:"connect",successful:false,state:this._cometd.state(),cancel:true});
+			this._cometd._backoff();
+			this.disconnect();
+			this.tunnelCollapse();
+		}
+	}
+
+}
+
+dojox.cometd.callbackPollTransport = new function(){
+	this._connectionType = "callback-polling";
+	this._cometd = null;
+
+	this.check = function(types, version, xdomain){
+		// we handle x-domain!
+		return (dojo.indexOf(types, "callback-polling") >= 0);
+	}
+
+	this.tunnelInit = function(){
+		var message = {
+			channel:	"/meta/connect",
+			clientId:	this._cometd.clientId,
+			connectionType: this._connectionType,
+			id:	""+this._cometd.messageId++
+		};
+		message = this._cometd._extendOut(message);		
+		this.openTunnelWith({
+			message: dojo.toJson([message])
+		});
+	}
+
+	this.tunnelCollapse = dojox.cometd.longPollTransport.tunnelCollapse;
+	this._connect = dojox.cometd.longPollTransport._connect;
+	this.deliver = dojox.cometd.longPollTransport.deliver;
+
+	this.openTunnelWith = function(content, url){
+		this._cometd._polling = true;
+		var script = {
+			load: dojo.hitch(this, function(data){
+				this._cometd._polling=false;
+				this._cometd.deliver(data);
+				this._cometd._backon();
+				this.tunnelCollapse();
+			}),
+			error: dojo.hitch(this, function(err){
+				this._cometd._polling=false;
+				console.debug("tunnel opening failed:", err);
+				dojo.publish("/cometd/meta", [{cometd:this._cometd,action:"connect",successful:false,state:this._cometd.state()}]);
+				this._cometd._backoff();
+				this.tunnelCollapse();
+			}),
+			url: (url||this._cometd.url),
+			content: content,
+			callbackParamName: "jsonp"
+		};
+		var connectTimeout=this._cometd._connectTimeout();
+		if (connectTimeout>0)
+			script.timeout=connectTimeout;
+		dojo.io.script.get(script);
+	}
+
+	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++;
+			messages[i]=this._cometd._extendOut(messages[i]);
+		}
+		var bindArgs = {
+			url: this._cometd.url||dojo.config["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(){
+		var message={
+			channel:"/meta/disconnect",
+			clientId:this._cometd.clientId,
+			id:""+this._cometd.messageId++
+		};
+		message=this._cometd._extendOut(message);		
+		dojo.io.script.get({
+			url: this._cometd.url||dojo.config["cometdRoot"],
+			callbackParamName: "jsonp",
+			content: {
+				message: dojo.toJson([message])
+			}
+		});
+	}
+
+	this.cancelConnect = function(){}
+}
+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");