@jayesol/jayeson.lib.delivery 2.0.6 → 2.0.7

package/lib/DeliveryStack.js

@@ -1 +1,1212 @@
-var _=require("underscore"),util=require("./util"),_c=util._c,_abstract=util._abstract,EventEmitter=require("eventemitter3"),random=require("secure-random"),node_jquery=require("jquery"),node_ws=require("websocket"),W3CWebSocket=node_ws.w3cwebsocket;function isEmpty(e){return _.isEmpty(e)}function generateUUID(){return"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g,function(e){var t=random(1)[0]%16|0;return("x"==e?t:3&t|8).toString(16)})}var Util={_nodeId:function(e){return e.serviceId},_streamId:function(e){return e.group+"_"+e.stream},_streamIdFromNames:function(e,t){return e+"_"+t},_newPromise:function(){var s={},e=new Promise(function(e,t){s.resolve=e,s.reject=t});return e.m=s,e.resolve=function(){this.m.resolve.apply(this,arguments)},e.reject=function(){this.m.reject.apply(this,arguments)},e},_treeMap:function(){return{_map:{},_keys:[],isEmpty:function(){return isEmpty(this._keys)},size:function(){return this._keys.length},higherEntry:function(e){for(var t=-1,s=0;s<this._keys.length;s++)if(this._keys[s]==e){t=s;break}if(-1==t)return null;var i=t+1;return i==this._keys.length?null:{key:this._keys[i],value:this._map[i]}},lowerEntry:function(e){for(var t=-1,s=0;s<this._keys.length;s++)if(this._keys[s]==e){t=s;break}if(-1==t)return null;var i=t-1;return-1==i?null:{key:this._keys[i],value:this._map[i]}},firstEntry:function(){return this.getEntryByIndex(0)},lastEntry:function(){return this.getEntryByIndex(this._keys.length-1)},get:function(e){return this._map[e]},getEntryByIndex:function(e){var t=this._keys[e];return null==t?null:{key:t,value:this._map[t]}},put:function(e,t){for(var s=-1,i=0;i<this._keys.length;i++)if(this._keys[i]>e){s=i;break}-1!=s?this._keys.splice(s,0,e):this._keys.push(e),this._map[e]=t},remove:function(e){for(var t=-1,s=null,i=0;i<this._keys.length;i++)if(this._keys[i]==e){t=i;break}if(-1!=t){this._keys.splice(t,1);s=this._map[e];delete this._map[e]}return s},keys:function(){return this._keys},values:function(){for(var e=[],t=0;t<this._keys.length;t++)e.push(this._map[this._keys[t]]);return e},entrySet:function(){for(var e=[],t=0;t<this._keys.length;t++)e.push({key:this._keys[t],value:this._map[this._keys[t]]});return e}}}};function IEndPointEventSource(){this.eventDispatcher=new EventEmitter,this.listeners=[],this.listenerMethods=[]}function IEndPoint(){EndPoint.super(this)}function IMessageClass(e,t,s){this._group=e,this._id=t,this._iClass=s}function IMessageGroup(e){this._id=e,this._classes=[]}function IMessageGroupProcessor(e){this.msgGroup=e}function IPreparsingHook(e){IMessageGroupProcessor.call(this,e)}function EPEvent(e){this.endPoint=e}function IClient(e){this.config=e}function MetaInformationCode(e){this._code=e}function StreamNameCode(){StreamNameCode.super(this,0)}function MessageIdCode(){MessageIdCode.super(this,1)}function MessageWrapper(e,t,s){this.message=e,this.messageClass=t,this.metaInfo=s}function EPConnectedEvent(e){EPConnectedEvent.super(this,e)}function EPDisconnectedEvent(e){EPDisconnectedEvent.super(this,e)}function EPConnectionError(){}function GroupRegistry(){this.processors={},this.processingGroups={},this.preparsingHooks={},this.preHookGroups={}}function EndPoint(e){GroupRegistry.call(this),this.metaCodeMap={},this.streamNameCode=new StreamNameCode,this.metaCodeMap[this.streamNameCode.code()]=this.streamNameCode,this.messageIdCode=new MessageIdCode,this.metaCodeMap[this.messageIdCode.code()]=this.messageIdCode,this.ws=e,this.ws.onmessage=_.bind(this.onMessage,this),this.waiters={},this.currentTimeout=0,this.timeOutRequestsSchedule=new Util._treeMap,this.requestTimeoutChecker=null,this.isTimeoutTaskRunning=!1}function DefaultClient(e,t){return DefaultClient.super(this,e),IEndPointEventSource.call(this),GroupRegistry.call(this),this._ep=void 0,this.config={url:"",keepAliveInterval:3e4,msgClass:null,msgGroup:null},_.extend(this.config,e),this.keepAlive=!1,this._keepAliveMsgGrp=t,this.registerPreparsingHook(t,this),this}_c(IEndPointEventSource,{attachListener:function(e){this.listeners.push(e),this.listenerMethods.push(_.bind(e.onEvent,e)),this.eventDispatcher.on("EPEvent",this.listenerMethods[this.listenerMethods.length-1])},detachListener:function(e){for(var t=0;t<this.listeners.length;t++)this.listeners[t]===e&&this.eventDispatcher.off("EPEvent",this.listenerMethods[t])},clearListeners:function(){delete this.listeners,delete this.listenersMethods,this.eventDispatcher.removeAllListeners("EPEvent")},dispatch:function(e){e instanceof EPEvent&&this.eventDispatcher.emit("EPEvent",e)}}),_c(IEndPoint,{registerGroup:_abstract,deregisterGroup:_abstract,registerPreparsingHook:_abstract,deregisterPreparsingHook:_abstract},IEndPointEventSource),_c(IMessageClass,{id:function(){return this._id},group:function(){return this._group},inHandlers:function(){return[]},outHandlers:function(){return[]},instanceClass:function(){return this._iClass}}),_c(IMessageGroup,{id:function(){return this._id},classById:function(e){return this._classes[e]},allClasses:function(){return this._classes}}),_c(IMessageGroupProcessor,{group:function(){return this.msgGroup},onRegistered:void 0,onDeregistered:void 0,process:function(e){_abstract()}}),_c(IPreparsingHook,{processUnparsedMessage:function(e){_abstract()},process:function(e){_abstract()}},IMessageGroupProcessor),_c(IClient,{connect:_abstract}),_c(MetaInformationCode,{code:function(){return this._code}}),_c(StreamNameCode,{},MetaInformationCode),_c(MessageIdCode,{},MetaInformationCode),_c(MessageWrapper,{hasMetaInfo:function(){return null!=this.metaInfo},containsMetaInfo:function(e){return 0!=this.hasMetaInfo()&&null!=this.metaInfo[e]},getMetaInfo:function(e){return 0==this.hasMetaInfo()?null:this.metaInfo[e]},addMetaInfo:function(e,t){this.hasMetaInfo()||(this.metaInfo={}),this.metaInfo[e]=t}}),_c(EPConnectedEvent,{},EPEvent),_c(EPDisconnectedEvent,{},EPEvent),_c(EPConnectionError,{},EPEvent),_c(GroupRegistry,{registerGroup:function(e,t){void 0!==this.processors[e.id()]&&void 0!==this.processors[e.id()].onDeregistered&&this.processors[e.id()].onDeregistered(this),this.processors[e.id()]=t,this.processingGroups[e.id()]=e,void 0!==t.onRegistered&&t.onRegistered(this)},deregisterGroup:function(e){if(void 0!==this.processors[e.id()]){var t=this.processors[e.id()];delete this.processors[e.id()],delete this.processingGroups[e.id()],void 0!==t.onDeregistered&&t.onDeregistered(this)}},registerPreparsingHook:function(e,t){void 0!==this.preparsingHooks[e.id()]&&void 0!==this.preparsingHooks[e.id()].onDeregistered&&this.preparsingHooks[e.id()].onDeregistered(this),this.preparsingHooks[e.id()]=t,this.preHookGroups[e.id()]=e,void 0!==t.onRegistered&&t.onRegistered(this)},deregisterPreparsingHook:function(e){if(void 0!==this.preparsingHooks[e.id()]){var t=this.preparsingHooks[e.id()];delete this.preparsingHooks[e.id()],delete this.preHookGroups[e.id()],void 0!==t.onDeregistered&&t.onDeregistered(this)}},hasPreHook:function(e){return void 0!==this.preparsingHooks[e]},hasProcessor:function(e){return void 0!==this.processors[e]},copyGroupRegistry:function(e){this.processors=e.processors,this.processingGroups=e.processingGroups,this.preparsingHooks=e.preparsingHooks,this.preHookGroups=e.preHookGroups}}),_c(EndPoint,{_extract:function(e){var t,s={},i=0==(128&e[0])?0:127&(e[0]<<8|e[1]);0<i&&(t=e.subarray(2,i+2));for(var n=0;n<i;){var r=t[n];n++;var o=r>>2,a=3&r,u=t.subarray(n,a+n);n+=a;for(var h=0,c=0;c<a;c++){var l=8*(a-1-c);h|=(255&u[c])<<l}var d=t.subarray(n,h+n);n+=h,s[o]=String.fromCharCode.apply(String,d)}for(var p in e=0<i?e.subarray(i+2):e.subarray(1),s){if(s.hasOwnProperty(p))if(null==this.metaCodeMap[p])throw"Code "+p+" is not defined."}if(e.byteLength<2)throw"Corrupted Message Format!";return{meta:s,gid:e[0],cid:e[1],pl:e.subarray(2)}},onMessage:function(e){var t=this._extract(new Uint8Array(e.data));if(this.hasPreHook(t.gid)){var s=this.preparsingHooks[t.gid],i=this.preHookGroups[t.gid].classById(t.cid),n=new MessageWrapper(t.pl,i,t.meta);if(!s.processUnparsedMessage(n,e.origin)&&!n.containsMetaInfo(this.messageIdCode.code()))return}if(!this.hasProcessor(t.gid))return console.log("Received a message with id "+t.gid+" not registered!"),null;var r=this.processors[t.gid];i=this.processingGroups[t.gid].classById(t.cid),n=new MessageWrapper(t.pl,i,t.meta);if(null==i)return console.log("Message class id "+t.cid+" is not supported."),null;_.each(i.inHandlers(),function(e){e.unpack(n)});var o=n.getMetaInfo(this.messageIdCode.code());if(null!=o){var a=this.clearRequest(o);if(void 0!==a){a.waiter.resolve(n);var u=a.stopTime;if(0<u){var h=this.timeOutRequestsSchedule.get(u);if(null!=h){for(var c=-1,l=0;l<h.length;l++)if(h[l]==o){c=l;break}-1!=c&&h.splice(c,1),isEmpty(h)&&this.timeOutRequestsSchedule.remove(u)}}return}}r.process(n)},request:function(e,t){var s=this.storeRequest(e,t);try{this.send(e)}catch(e){console.error("Cannot send message ",e);var i=s.stopTime,n=s.messageId;if(this.clearRequest(n),0<i){var r=this.timeOutRequestsSchedule.get(i);if(null!=r){for(var o=-1,a=0;a<r.length;a++)if(r[a]==n){o=a;break}-1!=o&&r.splice(o,1),isEmpty(r)&&this.timeOutRequestsSchedule.remove(i)}}return null}return s},reply:function(e,t){var s=this.createReply(e,t);this.send(s)},createReply:function(e,t){var s=this.messageIdCode.code();if(!e.hasMetaInfo(s))throw"Trying to reply to a non-request message!";return t.addMetaInfo(s,e.getMetaInfo(s)),t},storeRequest:function(e,t){var s=generateUUID();console.log(s),e.addMetaInfo(this.messageIdCode.code(),s);var i=Util._newPromise(),n=0;if(0<t){n=(new Date).getTime()+t;var r=this.timeOutRequestsSchedule.get(n);null==r&&(r=[],this.timeOutRequestsSchedule.put(n,r)),r.push(s),this.waitRequestTimeOut()}var o={waiter:i,stopTime:n,messageId:s};return this.waiters[s]=o},waitRequestTimeOut:function(){var e=(new Date).getTime();if(null!=this.requestTimeoutChecker){if(!this.timeOutRequestsSchedule.isEmpty()){var t=this.timeOutRequestsSchedule.firstEntry().key;if(t<this.currentTimeout&&(this.cancelRequestTimeout(),null==this.requestTimeoutChecker)){i=t-e;this.requestTimeoutChecker=setTimeout(_.bind(this.rejectRequestsAndRepeatWaitingNextTimeout,this,t),i),console.log("re-run new task with stop time "+t),this.currentTimeout=t}}}else if(!this.timeOutRequestsSchedule.isEmpty()){var s=this.timeOutRequestsSchedule.firstEntry().key,i=s-e;this.requestTimeoutChecker=setTimeout(_.bind(this.rejectRequestsAndRepeatWaitingNextTimeout,this,s),i),console.log("Run new task with stoptime "+s),this.currentTimeout=s}},cancelRequestTimeout:function(){this.isTimeoutTaskRunning||(clearTimeout(this.requestTimeoutChecker),this.requestTimeoutChecker=null)},rejectRequestsAndRepeatWaitingNextTimeout:function(e){this.isTimeoutTaskRunning=!0,this._rejectTimeoutRequest(e);for(var t=e,s=null;null!=(s=this.timeOutRequestsSchedule.lowerEntry(t));)this._rejectTimeoutRequest(t),t=s.key;this.requestTimeoutChecker=null,this.currentTimeout=0,this.isTimeoutTaskRunning=!1,setTimeout(_.bind(this.waitRequestTimeOut,this),0)},_rejectTimeoutRequest:function(e){var t=this.timeOutRequestsSchedule.remove(e);if(null!=t)for(var s=0;s<t.length;s++){var i=t[s],n=this.clearRequest(i);null!=n&&n.waiter.reject("Request timeout")}},clearRequest:function(e){var t=this.waiters[e];return delete this.waiters[e],t},send:function(t){if(null==this.ws)throw"Invalid socket Exception. Cannot send message.";if(_.each(t.messageClass.outHandlers(),function(e){e.pack(t)}),!(t.message instanceof Array))throw"Output pipeline doesn't encod message to byte array successfully!";for(var e=this._encodeMetaInfo(t.metaInfo),s=e.length,i=new Uint8Array(t.message.length+s+2),n=0;n<e.length;n++)i[n]=e[n];i[s]=t.messageClass.group().id(),i[s+1]=t.messageClass.id();for(n=0;n<t.message.length;n++)i[s+2+n]=t.message[n];if(null!=i&&3<=i.length)return this.ws.send(i),i;throw"Endpoint sends invalid frame!!"},_encodeMetaInfo:function(e){if(isEmpty(e))return[0];var t=[];for(var s in e)if(e.hasOwnProperty(s)){for(var i=[],n=0;n<e[s].length;n++)i.push(e[s].charCodeAt(n));var r=i.length,o=new Uint8Array([(4278190080&r)>>24,(16711680&r)>>16,(65280&r)>>8,255&r]),a=[],u=!1;for(n=0;n<o.length;n++)0!=o[n]&&(u=!0),u&&a.push(o[n]);var h=a.length;if(3<h|h<0)return[0];var c=s<<2|3&h;t.push(c);for(n=0;n<a.length;n++)t.push(a[n]);for(var l=0;l<i.length;l++)t.push(i[l])}var d=t.length,p=32768|d,g=new Uint8Array([(65280&p)>>8,255&p]),f=new Uint8Array(g.length+d);f[0]=g[0],f[1]=g[1];for(l=0;l<d;l++)f[2+l]=t[l];return f}},IEndPoint,GroupRegistry),_c(DefaultClient,{connect:function(){this.websocket=null;var e="",t=this._generateConnectionParams();if("WebSocket"in window||!W3CWebSocket||(WebSocket=W3CWebSocket),"undefined"==typeof jQuery&&(jQuery=node_jquery),!WebSocket||!jQuery)throw alert("PLEASE UPGRADE YOUR BROWSER TO SUPPORT WEBSOCKET!"),"Please upgrade your browser to support WEBSOCKET!";null!=t&&(e="?"+jQuery.param(t));var s=this.config.url+e,i=new WebSocket(s);i.binaryType="arraybuffer",i.onopen=_.bind(this.onConnected,this),i.onclose=_.bind(this.onDisconnected,this),i.onerror=_.bind(this.onConnectionError,this),console.log("Created websocket: "+s),this.websocket=i},disconnect:function(){null!=this.websocket&&(this.websocket.close(),this.keepAlive&&this.disableKeepAlive(),delete this._ep)},_generateConnectionParams:function(){var e={};if(void 0!==this.config.params&&(e=_.clone(this.config.params)),void 0!==this.config.msgGroup&&""!==this.config.msgGroup&&null!==this.config.msgGroup&&(this.config.msgGroup instanceof IMessageGroup?e.MessageGroup=this.config.msgGroup.id():e.MessageGroup=this.config.msgGroup),void 0!==this.config.msgClass&&""!==this.config.msgClass&&null!==this.config.msgClass)if(this.config.msgClass instanceof IMessageClass){if(void 0!==e.MessageGroup&&this.config.msgClass.group().id()!=e.MessageGroup)throw"Cannot generate connection params! Group ID "+e.MessageClass+" doesn't match with what defined in accompanied message class!";e.MessageClass=this.config.msgClass.id(),e.MessageGroup=this.config.msgClass.group().id()}else e.MessageClass=this.config.msgClass;return _.isEmpty(e)?null:e},enableKeepAlive:function(){0==this.keepAlive&&(this.keepAliveTimeout=setInterval(_.bind(this.sendKeepAlive,this),this.config.keepAliveInterval)),this.keepAlive=!0},disableKeepAlive:function(){1==this.keepAlive&&clearInterval(this.keepAliveTimeout),this.keepAlive=!1},sendKeepAlive:function(){if(null!=this._ep){var e=new MessageWrapper("",this._keepAliveMsgGrp.classById(0));this._ep.send(e)}},send:function(e){this._ep.send(e)},onConnected:function(e){this._ep=new EndPoint(this.websocket),this._ep.copyGroupRegistry(this),this.dispatch(new EPConnectedEvent(this._ep))},onDisconnected:function(e){void 0!==this._ep&&(this.dispatch(new EPDisconnectedEvent(this._ep)),this._ep=void 0)},onConnectionError:function(e){this.dispatch(new EPConnectionError)},processUnparsedMessage:function(e,t){if(4==e.messageClass.group().id())return console.debug("Receive keep alive message from",t),!1}},IClient,IEndPointEventSource,GroupRegistry),module.exports=exports={DefaultClient:DefaultClient,IMessageClass:IMessageClass,IMessageGroup:IMessageGroup,IMessageGroupProcessor:IMessageGroupProcessor,MetaInformationCode:MetaInformationCode,StreamNameCode:StreamNameCode,MessageIdCode:MessageIdCode,IEndPoint:IEndPoint,IEndPointEventSource:IEndPointEventSource,IPreparsingHook:IPreparsingHook,IClient:IClient,EndPoint:EndPoint,EPEvent:EPEvent,EPConnectedEvent:EPConnectedEvent,EPConnectionError:EPConnectionError,EPDisconnectedEvent:EPDisconnectedEvent,MessageWrapper:MessageWrapper,Util:Util,generateUUID:generateUUID};
+var _ = require("underscore");
+var util = require("./util");
+var _c = util._c;
+var _abstract = util._abstract;
+var EventEmitter = require("eventemitter3");
+var random = require('secure-random');
+
+var node_jquery = require("jquery");
+var node_ws = require("websocket");
+var W3CWebSocket = node_ws.w3cwebsocket;
+
+
+/**
+ * @author Ryan
+ * 
+ * This depends on underscorejs, eventemitter
+ * Kee
+ * The DeliveryStack mimick the implementation on Java
+ * to give a user an API to interact with th delivery system.
+ * 
+ * Basically it expose:
+ * - Base implementation for IClient, IEndPoint, EPEvent
+ * - Base implementation for IMessageClass and IMessageGroup
+ * - Base implementation for IPreparsingHook and IMessageGroupProcessor
+ * - DefaultClient implementation which allow user to set the URL and listen
+ * to connected / disconnected event, register group processor to any new connected
+ * end point.
+ * - DefaultClient also handle keep alive by default
+ * - 
+ * - EndPoint implementation which allow user to listen to connected / disconnected 
+ * event.
+ * 
+ */
+
+/**
+ * Check if object is empty
+ * @param object
+ * @returns {Boolean}
+ */
+function isEmpty(object) {
+	//	for(var key in object){
+	//		if(object.hasOwnProperty(key)){
+	//			return false;
+	//		}
+	//	}
+	//	return true;
+	return _.isEmpty(object);
+}
+
+/**
+ * Generate uuid string
+ */
+function generateUUID() {
+
+	return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+
+		var r = random(1)[0] % 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
+
+		return v.toString(16);
+
+	});
+
+}
+
+
+/**
+ * Generate the stream id from the stream information returned
+ * from stream finder.
+ * 
+ * Stream information is a JSON has the following format:
+ * 
+ * 	{
+ *		"group": "<groupId>",
+ *		"stream": "<streamName>",
+ *		"level": <level>,
+ *		"serviceId": <serviceId>,
+ *		"connection": {
+ *   		"protocol": "<protocol>",
+ *   		"hostname": "<hostname>",
+ *   		"port": <port>
+ * 		}
+ *	}
+ */
+var Util = {
+	/**
+	 * get the id of the connection. Currently identified by service id.
+	 */
+	_nodeId: function (source) {
+		return source.serviceId;
+	},
+
+	_streamId: function (streamInfo) {
+		return streamInfo.group + "_" + streamInfo.stream;
+	},
+
+	_streamIdFromNames: function (group, stream) {
+		return group + "_" + stream;
+	},
+
+	// return a promise that can be resolve in a different place
+	_newPromise: function () {
+
+		var methodWrapper = {};
+
+		var p = new Promise(function (resolve, reject) {
+			methodWrapper["resolve"] = resolve;
+			methodWrapper["reject"] = reject;
+		});
+
+		p.m = methodWrapper;
+		p.resolve = function () {
+			this.m.resolve.apply(this, arguments);
+		};
+		p.reject = function () {
+			this.m.reject.apply(this, arguments);
+		};
+
+		return p;
+	},
+
+	_treeMap: function () {
+		return {
+			_map: {},
+			_keys: [],
+
+			isEmpty: function () {
+				return isEmpty(this._keys);
+			},
+
+			size: function () {
+				return this._keys.length;
+			},
+
+			higherEntry: function (key) {
+				var index = -1;
+				for (var i = 0; i < this._keys.length; i++) {
+					if (this._keys[i] == key) {
+						index = i;
+						break;
+					}
+				}
+				if (index != -1) {
+					var higherIndex = index + 1;
+					if (higherIndex == this._keys.length) {
+						return null;
+					} else {
+						return {
+							key: this._keys[higherIndex],
+							value: this._map[higherIndex]
+						}
+					}
+				} else {
+					return null;
+				}
+			},
+
+			lowerEntry: function (key) {
+				var index = -1;
+				for (var i = 0; i < this._keys.length; i++) {
+					if (this._keys[i] == key) {
+						index = i;
+						break;
+					}
+				}
+				if (index != -1) {
+					var lowerIndex = index - 1;
+					if (lowerIndex == -1) {
+						return null;
+					} else {
+						return {
+							key: this._keys[lowerIndex],
+							value: this._map[lowerIndex]
+						}
+					}
+				} else {
+					return null;
+				}
+			},
+
+			firstEntry: function () {
+				return this.getEntryByIndex(0);
+			},
+
+			lastEntry: function () {
+				return this.getEntryByIndex(this._keys.length - 1);
+			},
+
+			get: function (key) {
+				return this._map[key];
+			},
+
+			getEntryByIndex: function (index) {
+				var _key = this._keys[index];
+
+				if (_key == null) {
+					return null;
+				} else {
+					return {
+						key: _key,
+						value: this._map[_key]
+					}
+				}
+			},
+
+			put: function (key, value) {
+				var index = -1;
+				for (var i = 0; i < this._keys.length; i++) {
+					if (this._keys[i] > key) {
+						index = i;
+						break;
+					}
+				}
+				if (index != -1) {
+					this._keys.splice(index, 0, key);
+				} else {
+					this._keys.push(key);
+				}
+				this._map[key] = value;
+			},
+
+			remove: function (key) {
+				var index = -1;
+				var value = null;
+				for (var i = 0; i < this._keys.length; i++) {
+					if (this._keys[i] == key) {
+						index = i;
+						break;
+					}
+				}
+				if (index != -1) {
+					this._keys.splice(index, 1);
+					var value = this._map[key];
+					delete this._map[key];
+				}
+				return value;
+			},
+
+			keys: function () {
+				return this._keys;
+			},
+
+			values: function () {
+				var valueSet = [];
+				for (var i = 0; i < this._keys.length; i++) {
+					valueSet.push(this._map[this._keys[i]]);
+				}
+				return valueSet;
+			},
+
+			entrySet: function () {
+				var entries = [];
+				for (var i = 0; i < this._keys.length; i++) {
+					entries.push({
+						key: this._keys[i],
+						value: this._map[this._keys[i]],
+					});
+				}
+				return entries;
+			}
+		}
+	}
+}
+
+
+
+/************END UTILITY ********************************/
+
+/************* INTERFACE DEFINITION *********************/
+
+function IEndPointEventSource() {
+	// initialize the dispatcher
+	this.eventDispatcher = new EventEmitter();
+
+	// event submitter store method but not the object so
+	// so we can't call the listener method with the object it belongs to.
+	// Hence, needs to store the _.bind instead of the original method.
+	this.listeners = [];
+	this.listenerMethods = [];
+
+}
+_c(IEndPointEventSource, {
+
+	attachListener: function (listener) {
+		this.listeners.push(listener);
+		this.listenerMethods.push(_.bind(listener.onEvent, listener));
+		this.eventDispatcher.on("EPEvent", this.listenerMethods[this.listenerMethods.length - 1]);
+	},
+
+	detachListener: function (listener) {
+		for (var i = 0; i < this.listeners.length; i++)
+			if (this.listeners[i] === listener) {
+				this.eventDispatcher.off("EPEvent", this.listenerMethods[i]);
+			}
+	},
+
+	clearListeners: function () {
+		delete this.listeners;
+		delete this.listenersMethods;
+		this.eventDispatcher.removeAllListeners("EPEvent");
+	},
+
+	dispatch: function (event) {
+		if (event instanceof EPEvent) {
+			this.eventDispatcher.emit("EPEvent", event);
+		}
+	}
+});
+
+function IEndPoint() {
+	EndPoint.super(this);	// Initialize properties related to IEndPointEventSource
+}
+_c(IEndPoint, {
+	registerGroup: _abstract,
+	deregisterGroup: _abstract,
+	registerPreparsingHook: _abstract,
+	deregisterPreparsingHook: _abstract
+}, IEndPointEventSource);	// extends EndPoint from IEndPointEventSource
+
+function IMessageClass(msgGroup, id, instanceClass) {
+	this._group = msgGroup;
+	this._id = id;
+	this._iClass = instanceClass;
+}
+_c(IMessageClass, {
+
+	/**
+	 * Return the id of the message class which should be unique within the group
+	 * containing it.
+	 */
+	id: function () { return this._id; },
+	/**
+	 * Return the message group that this class belongs to
+	 */
+	group: function () { return this._group; },
+	/**
+	 * Define the list of in handlers for the message class. 
+	 * Each handler should have a handling method that accept a message wrapper.
+	 * It transforms the original message wrapper and pass to the next handler
+	 * Passing through all handler should provide the final message in the form 
+	 * the processor can process.
+	 */
+	inHandlers: function () { return []; },
+	/**
+	 * Define the list of out handlers for the message class. 
+	 * Each handler should have a handling method that accept a message wrapper.
+	 * It transforms the original message wrapper and pass to the next handler
+	 * Passing through all out handlers should provide the final message in the form 
+	 * can be written to the web socket.
+	 */
+	outHandlers: function () { return []; },	// define the out handlers for the message class
+	/**
+	 * The instance class of the message content.
+	 */
+	instanceClass: function () { return this._iClass; }
+})
+
+function IMessageGroup(id) {
+	this._id = id;		// id of the message group
+	this._classes = [];	// store all the message classes
+}
+_c(IMessageGroup, {
+	id: function () { return this._id; },
+	classById: function (idByte) { return this._classes[idByte]; },			// return the message class from its id
+	allClasses: function () { return this._classes; }				// return all message classes
+});
+
+function IMessageGroupProcessor(msgGroup) {
+	this.msgGroup = msgGroup;
+}
+_c(IMessageGroupProcessor, {
+	group: function () { return this.msgGroup; },						// return the message group that the processor is in charged of
+	onRegistered: undefined,			// triggered when the processor is registered on an EndPoint
+	onDeregistered: undefined,		// triggered when the processor is deregistered from an EndPoint
+	process: function (messageWrapper) { _abstract(); }			// called whenever a message is received for the group
+});
+
+function IPreparsingHook(msgGroup) {
+	IMessageGroupProcessor.call(this, msgGroup);
+}
+_c(IPreparsingHook, {
+	/**
+	 * called whenever an unparsed message is received for the group
+	 * This method return true or false.
+	 * True if the message should continue through the pipeline for parsing and handling
+	 * by the corresponding group processor
+	 * 
+	 * False if otherwise. 
+	 */
+	processUnparsedMessage: function (messageWrapper) { _abstract(); },
+
+	process: function (messageWrapper) { _abstract(); }// not supposed to be implemented
+
+}, IMessageGroupProcessor);
+
+function EPEvent(endPoint) {
+	this.endPoint = endPoint;
+}
+
+function IClient(configuration) {
+	this.config = configuration;
+}
+_c(IClient, {
+	connect: _abstract
+});
+
+function MetaInformationCode(code) {
+	this._code = code;
+}
+
+_c(MetaInformationCode, {
+	code: function () {
+		return this._code;
+	}
+});
+
+function StreamNameCode() {
+	StreamNameCode.super(this, 0);
+}
+_c(StreamNameCode, {}, MetaInformationCode);
+
+//StreamNameCode = new StreamNameCode();
+
+function MessageIdCode() {
+	MessageIdCode.super(this, 1);
+}
+_c(MessageIdCode, {}, MetaInformationCode);
+
+//MessageIdCode = new MessageIdCode();
+
+function MessageWrapper(message, messageClass, metaInfo) {
+	this.message = message;
+	this.messageClass = messageClass;
+	this.metaInfo = metaInfo;
+}
+_c(MessageWrapper, {
+	hasMetaInfo: function () {
+		return this.metaInfo != null;
+	},
+
+	containsMetaInfo: function (metaCode) {
+		if (this.hasMetaInfo() == false) return false;
+		return this.metaInfo[metaCode] != null;
+	},
+
+	getMetaInfo: function (metaCode) {
+		if (this.hasMetaInfo() == false) return null;
+		var content = this.metaInfo[metaCode];
+		return content;
+	},
+
+	addMetaInfo: function (metaCode, content) {
+		if (!this.hasMetaInfo()) this.metaInfo = {};
+		this.metaInfo[metaCode] = content;
+	}
+});
+
+/************END INTERFACE DEFINITION *******************/
+
+/************* STANDARD EVENTS **************************/
+function EPConnectedEvent(endPoint) {
+	EPConnectedEvent.super(this, endPoint);
+}
+_c(EPConnectedEvent, {}, EPEvent);
+
+function EPDisconnectedEvent(endPoint) {
+	EPDisconnectedEvent.super(this, endPoint);
+}
+_c(EPDisconnectedEvent, {}, EPEvent);
+
+function EPConnectionError() { };
+_c(EPConnectionError, {}, EPEvent);
+/************ END STANDARD EVENT *************************/
+
+
+/*********** IMPLEMENTATION *****************************/
+
+function GroupRegistry() {
+	this.processors = {};	// a map from registered group to the corresponding processor
+	this.processingGroups = {};
+	this.preparsingHooks = {};	// map from registered group to the corresponding hook
+	this.preHookGroups = {};
+}
+_c(GroupRegistry, {
+	registerGroup: function (msgGroup, processor) {
+		if (this.processors[msgGroup.id()] !== undefined
+			&& this.processors[msgGroup.id()].onDeregistered !== undefined) {
+			this.processors[msgGroup.id()].onDeregistered(this);
+		}
+
+		this.processors[msgGroup.id()] = processor;
+		this.processingGroups[msgGroup.id()] = msgGroup;
+
+		if (processor.onRegistered !== undefined) processor.onRegistered(this);
+	},
+
+	deregisterGroup: function (msgGroup) {
+		if (this.processors[msgGroup.id()] !== undefined) {
+			var p = this.processors[msgGroup.id()];
+
+			delete this.processors[msgGroup.id()];
+			delete this.processingGroups[msgGroup.id()];
+
+			if (p.onDeregistered !== undefined) p.onDeregistered(this);
+		}
+	},
+
+	registerPreparsingHook: function (msgGroup, hook) {
+		if (this.preparsingHooks[msgGroup.id()] !== undefined
+			&& this.preparsingHooks[msgGroup.id()].onDeregistered !== undefined) {
+			this.preparsingHooks[msgGroup.id()].onDeregistered(this);
+		}
+
+		this.preparsingHooks[msgGroup.id()] = hook;
+		this.preHookGroups[msgGroup.id()] = msgGroup;
+
+		if (hook.onRegistered !== undefined) hook.onRegistered(this);
+	},
+
+	deregisterPreparsingHook: function (msgGroup) {
+		if (this.preparsingHooks[msgGroup.id()] !== undefined) {
+			var p = this.preparsingHooks[msgGroup.id()];
+
+			delete this.preparsingHooks[msgGroup.id()];
+			delete this.preHookGroups[msgGroup.id()];
+
+			if (p.onDeregistered !== undefined) p.onDeregistered(this);
+		}
+	},
+
+	hasPreHook: function (groupId) {
+		return this.preparsingHooks[groupId] !== undefined;
+	},
+
+	hasProcessor: function (groupId) {
+		return this.processors[groupId] !== undefined;
+	},
+
+	/**
+	 * Copy the registration function from other
+	 */
+	copyGroupRegistry: function (other) {
+		this.processors = other.processors;
+		this.processingGroups = other.processingGroups;
+		this.preparsingHooks = other.preparsingHooks;	// map from registered group to the corresponding hook
+		this.preHookGroups = other.preHookGroups;
+	}
+});
+
+function EndPoint(websocketClient) {
+
+	GroupRegistry.call(this);								// initialize parameters related to GroupRegistry
+	this.metaCodeMap = {};
+	// config some default codes.
+	this.streamNameCode = new StreamNameCode();
+	this.metaCodeMap[this.streamNameCode.code()] = this.streamNameCode;
+	this.messageIdCode = new MessageIdCode();
+	this.metaCodeMap[this.messageIdCode.code()] = this.messageIdCode;
+	this.ws = websocketClient;
+	this.ws.onmessage = _.bind(this.onMessage, this);		// bind the end point onMessage to the websocket client on message
+	this.waiters = {}; // promise to get the reply. 
+	this.currentTimeout = 0; // timeout of current task checking timeout requests.
+	this.timeOutRequestsSchedule = new Util._treeMap(); // contains requests grouped by their timeout.
+	this.requestTimeoutChecker = null; // task for firing timeout requests.
+	this.isTimeoutTaskRunning = false;
+}
+_c(EndPoint, {
+
+	/**
+	 * Extract class, group, meta header 
+	 * and payload
+	 */
+	_extract: function (decodedMsg) {
+		var metaHeader = {};
+		var metaHeaderBytes;
+		var metaLength = ((decodedMsg[0] & 128) == 0) ? 0 : ((decodedMsg[0] << 8) | decodedMsg[1]) & 127;
+		// Get encrypted MetaHeader Content
+		if (metaLength > 0) metaHeaderBytes = decodedMsg.subarray(2, metaLength + 2);
+		var i = 0;
+		while (i < metaLength) {
+			// read FC-FLF byte.
+			// first byte in block [FC-FLF]-[FL]-[FV]
+			var firstByteInBlock = metaHeaderBytes[i];
+			i++;
+			var codeByte = firstByteInBlock >> 2;
+			var nBytesOfFLF = (firstByteInBlock & 3);
+
+			// read FL
+			var fieldLength = metaHeaderBytes.subarray(i, nBytesOfFLF + i);
+			i += nBytesOfFLF;
+			var contentLen = 0;
+			for (var index = 0; index < nBytesOfFLF; index++) {
+				var leftShift = 8 * (nBytesOfFLF - 1 - index);
+				contentLen |= ((fieldLength[index] & 0xff) << leftShift);
+			}
+			var content = metaHeaderBytes.subarray(i, contentLen + i);
+			i += contentLen;
+			metaHeader[codeByte] = String.fromCharCode.apply(String, content);
+		}
+		// remove the meta information
+		if (metaLength > 0) {
+			decodedMsg = decodedMsg.subarray(metaLength + 2);
+		} else {
+			decodedMsg = decodedMsg.subarray(1);
+		}
+		for (var headerKey in metaHeader) {
+			if (metaHeader.hasOwnProperty(headerKey)) {
+				var metaCode = this.metaCodeMap[headerKey];
+				if (metaCode == null) throw "Code " + headerKey + " is not defined.";
+			}
+		}
+		if (decodedMsg.byteLength < 2) throw "Corrupted Message Format!";
+
+		var groupId = decodedMsg[0]; // group id
+		var classId = decodedMsg[1]; // class id.
+
+		var payload = decodedMsg.subarray(2);
+
+		return { meta: metaHeader, gid: groupId, cid: classId, pl: payload };
+	},
+
+	/**
+	 * In contrast to the java implementation, we only have one transport
+	 * which is websocket so we will merge the router into the endpoint as well.
+	 * 
+	 * This method will use the pipeline (defined by message group and class) and 
+	 * turn the message into a message wrapper
+	 */
+	onMessage: function (message) {
+
+		//try{
+		// extract information
+		var ext = this._extract(new Uint8Array(message.data));
+
+		if (this.hasPreHook(ext.gid)) {
+
+			var hook = this.preparsingHooks[ext.gid];
+			var msgGroup = this.preHookGroups[ext.gid];
+			var msgClass = msgGroup.classById(ext.cid);
+
+			var wrapper = new MessageWrapper(ext.pl, msgClass, ext.meta);
+			if (!hook.processUnparsedMessage(wrapper, message.origin)) {
+
+				// check if it is messageId.
+				if (!wrapper.containsMetaInfo(this.messageIdCode.code())) {
+					return;	// if processUnparsedMessage return false, it means there isn't a need to proceed
+				}
+
+			}
+
+		}
+
+		if (this.hasProcessor(ext.gid)) {
+
+			var processor = this.processors[ext.gid];
+			var msgGroup = this.processingGroups[ext.gid];
+			var msgClass = msgGroup.classById(ext.cid);
+
+			var wrapper = new MessageWrapper(ext.pl, msgClass, ext.meta);
+
+			if (msgClass == null) {
+				console.log("Message class id " + ext.cid + " is not supported.");
+				return null;
+			}
+
+			_.each(msgClass.inHandlers(), function (handler) {
+				handler.unpack(wrapper);
+			})
+
+			// check if it is messageId.
+			var messageId = wrapper.getMetaInfo(this.messageIdCode.code());
+			if (messageId != null) {
+				var responseFuture = this.clearRequest(messageId);
+				if (responseFuture !== undefined) { // resolve waiter if available.
+					responseFuture.waiter.resolve(wrapper);
+					var stopTime = responseFuture.stopTime;
+					// remove the requestId in time line.
+					if (stopTime > 0) {
+						var requestIds = this.timeOutRequestsSchedule.get(stopTime);
+						if (requestIds != null) {
+							var deletedIndex = -1;
+							for (var i = 0; i < requestIds.length; i++) {
+								if (requestIds[i] == messageId) {
+									deletedIndex = i;
+									break;
+								}
+							}
+							if (deletedIndex != -1) {
+								requestIds.splice(deletedIndex, 1);
+							}
+							if (isEmpty(requestIds)) {
+								this.timeOutRequestsSchedule.remove(stopTime);
+							}
+						}
+					}
+					return;
+				}
+			}
+			processor.process(wrapper);
+			return;
+
+		}
+
+		// if we reach here, it's equals to the groupId is not registered!!
+		console.log("Received a message with id " + ext.gid + " not registered!");
+		return null;
+
+		//}
+		//catch(e){
+		//	console.log("Exception while decoding message frame!");
+		//	throw e;
+		//}
+	},
+
+	/**
+	 * Send a request to other endpoint and wait for an response from that endpoint.
+	 * Zero timeOut is waiting forever. 
+	 */
+	request: function (wrapper, timeout) {
+		var responseFuture = this.storeRequest(wrapper, timeout);
+		try {
+			this.send(wrapper);
+		} catch (e) {
+			// Remove the responseFuture if cannot send.
+			console.error("Cannot send message ", e);
+			var stopTime = responseFuture.stopTime;
+			var messageId = responseFuture.messageId;
+			this.clearRequest(messageId);
+			if (stopTime > 0) {
+				var requestIds = this.timeOutRequestsSchedule.get(stopTime);
+				if (requestIds != null) {
+					var deletedIndex = -1;
+					for (var i = 0; i < requestIds.length; i++) {
+						if (requestIds[i] == messageId) {
+							deletedIndex = i;
+							break;
+						}
+					}
+					if (deletedIndex != -1) {
+						requestIds.splice(deletedIndex, 1);
+					}
+					if (isEmpty(requestIds)) {
+						this.timeOutRequestsSchedule.remove(stopTime);
+					}
+				}
+			}
+			return null;
+		}
+		return responseFuture;
+	},
+
+	/**
+	 * Send a response to endpoint making a request.
+	 */
+	reply: function (original, response) {
+		var wrapper = this.createReply(original, response);
+		this.send(wrapper);
+	},
+
+	createReply: function (original, response) {
+		var metaMIDCode = this.messageIdCode.code();
+		if (original.hasMetaInfo(metaMIDCode)) {
+			response.addMetaInfo(metaMIDCode, original.getMetaInfo(metaMIDCode));
+		} else throw "Trying to reply to a non-request message!";
+
+		return response;
+	},
+
+	/**
+	 * store the message to wait for the corresponding reply
+	 * will fire an Request timeout exception after a given delay.
+	 * will be called before encode message handler finishes.
+	 * leverage the executor of channel context instead of the GlobalEventExecutor.
+	 */
+	storeRequest: function (wrapper, timeout) {
+		var uuid = generateUUID();
+		console.log(uuid);
+		wrapper.addMetaInfo(this.messageIdCode.code(), uuid);
+		var waiter = Util._newPromise();
+
+		// Create a promise to get the reply.
+		// The promise can be resolved in case the endpoint get the reply on time.
+		// Fire requestT timeout task after a period.
+		var stopTime = 0;
+		if (timeout > 0) {
+			var stopTime = new Date().getTime() + timeout;
+			var requestIds = this.timeOutRequestsSchedule.get(stopTime);
+			if (requestIds == null) {
+				requestIds = [];
+				this.timeOutRequestsSchedule.put(stopTime, requestIds);
+			}
+			requestIds.push(uuid);
+			this.waitRequestTimeOut();
+		}
+		var responseFuture = { waiter: waiter, stopTime: stopTime, messageId: uuid };
+		this.waiters[uuid] = responseFuture;
+		return responseFuture;
+	},
+
+	waitRequestTimeOut: function () {
+		var currentTime = new Date().getTime();
+		// Handle firing timeout request task when it hasn't fired and there isn't a cancelled task.
+		if (this.requestTimeoutChecker == null) {
+			if (!this.timeOutRequestsSchedule.isEmpty()) {
+				var firstEntry = this.timeOutRequestsSchedule.firstEntry();
+				var currentRequestTimeOut = firstEntry.key;
+				var delay = currentRequestTimeOut - currentTime;
+				// submit a task to fire timeout request exception.
+				this.requestTimeoutChecker = setTimeout(_.bind(this.rejectRequestsAndRepeatWaitingNextTimeout, this, currentRequestTimeOut), delay);
+				console.log("Run new task with stoptime " + currentRequestTimeOut);
+				this.currentTimeout = currentRequestTimeOut;
+			}
+			return;
+		}
+
+		// Handle in case it fired. Cancel it if there is an urgent one.
+		if (!this.timeOutRequestsSchedule.isEmpty()) {
+			var firstEntry = this.timeOutRequestsSchedule.firstEntry();
+			var firstRequestTimeout = firstEntry.key;
+			// if there is an urgent request, cancel the current timeout task.
+			// otherwise, do nothing.
+			if (firstRequestTimeout < this.currentTimeout) {
+				this.cancelRequestTimeout();
+				// If cancel the the current task successfully.
+				if (this.requestTimeoutChecker == null) {
+					var delay = firstRequestTimeout - currentTime;
+					// submit a task to fire timeout request exception.
+					this.requestTimeoutChecker = setTimeout(_.bind(this.rejectRequestsAndRepeatWaitingNextTimeout, this, firstRequestTimeout), delay);
+					console.log("re-run new task with stop time " + firstRequestTimeout);
+					this.currentTimeout = firstRequestTimeout;
+				}
+			}
+		}
+	},
+
+	cancelRequestTimeout: function () {
+		if (!this.isTimeoutTaskRunning) {
+			clearTimeout(this.requestTimeoutChecker);
+			this.requestTimeoutChecker = null;
+		}
+	},
+
+	rejectRequestsAndRepeatWaitingNextTimeout: function (stopTime) {
+		this.isTimeoutTaskRunning = true;
+		// Stop all requests 
+		this._rejectTimeoutRequest(stopTime);
+		// Stop all requests have expired too.
+		var currentStopTime = stopTime;
+		var lowerEntry = null;
+		while ((lowerEntry = this.timeOutRequestsSchedule.lowerEntry(currentStopTime)) != null) {
+			this._rejectTimeoutRequest(currentStopTime);
+			currentStopTime = lowerEntry.key;
+		}
+		this.requestTimeoutChecker = null;
+		this.currentTimeout = 0;
+		this.isTimeoutTaskRunning = false;
+		setTimeout(_.bind(this.waitRequestTimeOut, this), 0);
+	},
+
+	_rejectTimeoutRequest: function (stopTime) {
+		var requestIds = this.timeOutRequestsSchedule.remove(stopTime);
+		if (requestIds != null) {
+			for (var i = 0; i < requestIds.length; i++) {
+				var requestId = requestIds[i];
+				var responseFuture = this.clearRequest(requestId);
+				if (responseFuture != null) {
+					responseFuture.waiter.reject('Request timeout');
+				}
+			}
+		}
+	},
+
+	clearRequest: function (requestId) {
+		var waiter = this.waiters[requestId];
+		delete this.waiters[requestId];
+		return waiter;
+	},
+
+	/**
+	 * Method to send a message wrapped inside a message wrapper.
+	 * The message wrapper should contains enough information about the message the message class
+	 * correspond to the message content
+	 * 
+	 * Message will be sent asynchronously through setTimeout(0). Once the message is sent
+	 * successfully, the callback will be invoked.
+	 */
+	send: function (wrapper) {
+		if (this.ws != null) {
+
+			_.each(wrapper.messageClass.outHandlers(), function (handler) {
+				handler.pack(wrapper);
+			});
+
+			if (!(wrapper.message instanceof Array)) throw "Output pipeline doesn't encod message to byte array successfully!";
+
+
+			var encodedMetaInfo = this._encodeMetaInfo(wrapper.metaInfo);
+			var metaLength = encodedMetaInfo.length;
+			var encodedMsg = new Uint8Array(wrapper.message.length + metaLength + 2);
+
+			for (var i = 0; i < encodedMetaInfo.length; i++) encodedMsg[i] = encodedMetaInfo[i];
+
+			encodedMsg[metaLength] = wrapper.messageClass.group().id();
+			encodedMsg[metaLength + 1] = wrapper.messageClass.id();
+
+			for (var i = 0; i < wrapper.message.length; i++) encodedMsg[metaLength + 2 + i] = wrapper.message[i];
+
+			if (encodedMsg != null && encodedMsg.length >= 3) {
+				this.ws.send(encodedMsg);
+				return encodedMsg;
+			} else {
+				throw "Endpoint sends invalid frame!!";
+			}
+		} else {
+			throw "Invalid socket Exception. Cannot send message.";
+		}
+	},
+
+	_encodeMetaInfo: function (metaHeaders) {
+		if (isEmpty(metaHeaders))
+			return [0];
+		var encodedMetaInfo = [];	// contains mamy
+		// blocks [FC FLF]
+		// [FL] [FV]
+		for (var metaCode in metaHeaders) {
+			if (metaHeaders.hasOwnProperty(metaCode)) {
+				var encodedFV = [];
+				for (var i = 0; i < metaHeaders[metaCode].length; i++) {
+					encodedFV.push(metaHeaders[metaCode].charCodeAt(i));
+				}
+				var nBytesFV = encodedFV.length;// number of bytes that FV will
+				// occupy.
+
+				// convert nBytesFV to byte[] and left-trim it.
+				var convertedContentLen = new Uint8Array([
+					(nBytesFV & 0xff000000) >> 24,
+					(nBytesFV & 0x00ff0000) >> 16,
+					(nBytesFV & 0x0000ff00) >> 8,
+					(nBytesFV & 0x000000ff)
+				]);
+
+				var encodedFL = [];	// bytes that FL after
+				// being left-trimmed.
+				var metNotZero = false;
+				for (var i = 0; i < convertedContentLen.length; i++) {
+					if (convertedContentLen[i] != 0) {
+						metNotZero = true;
+					}
+					if (metNotZero) {
+						encodedFL.push(convertedContentLen[i]);
+					}
+				}
+				var encodedFLF = encodedFL.length; // FLF.
+				// nBitsFLF in [0,3]
+				if (encodedFLF > 3 | encodedFLF < 0)
+					return [0];
+				// first byte of meta content block has the format xxxxxxyy. Where:
+				// xxxxxx : FC
+				// yy: FLF
+				var firstByte = (metaCode << 2) | (3 & encodedFLF);
+				encodedMetaInfo.push(firstByte);// insert FC-FLF
+				for (var i = 0; i < encodedFL.length; i++) {
+					encodedMetaInfo.push(encodedFL[i]);// insert FL
+				}
+				// insert FV
+				for (var index = 0; index < encodedFV.length; index++) {
+					encodedMetaInfo.push(encodedFV[index]);
+				}
+
+			}
+
+		}
+
+		var contentSize = encodedMetaInfo.length;
+		var metaLength = 0x8000 | contentSize;
+		var encodedMetaLength = new Uint8Array([
+			(metaLength & 0x0000ff00) >> 8,
+			(metaLength & 0x000000ff)
+		]);
+		var result = new Uint8Array(encodedMetaLength.length + contentSize);
+		result[0] = encodedMetaLength[0];
+		result[1] = encodedMetaLength[1];
+		for (var index = 0; index < contentSize; index++) {
+			result[2 + index] = encodedMetaInfo[index];
+		}
+		return result;
+	}
+
+}, IEndPoint, GroupRegistry);
+
+/**
+ * The client on javascript is different from java counter part. It will act as the
+ * monitor that monitoring the connection events. On java implementation, there is
+ * a EndPointMonitor.
+ * 
+ * The configuration is an object define as following:
+ * {
+ * 		url : url of the target server. The URL should be in a full form
+ * 		params : { field : value, ... }
+ * 		msgClass : the message class we want in the connection request
+ * 		msgGroup : the message group we want in the connection request
+ * }
+ * 
+ * Note that: if we specified msgClass as the actual object (not only the id) the group will not needed
+ * as it can be extracted from message class.
+ */
+function DefaultClient(configuration, keepAliveMsgGrp) {
+	DefaultClient.super(this, configuration);	// call IClient
+	IEndPointEventSource.call(this);			// initialize stuff for event source mixin
+	GroupRegistry.call(this);
+
+	this._ep = undefined;						// initialize the endpoint
+
+	this.config = {
+		url: "",
+		keepAliveInterval: 30000,	// by default send keep alive every 30s
+		msgClass: null,
+		msgGroup: null
+	};
+
+	_.extend(this.config, configuration);	// copy configuration into the config to override default value
+
+	this.keepAlive = false;
+
+	this._keepAliveMsgGrp = keepAliveMsgGrp;
+
+	this.registerPreparsingHook(keepAliveMsgGrp, this);
+
+
+	return this;
+}
+_c(DefaultClient, {
+
+	/**
+	 * Configuration object has following format
+	 * {
+	 * 		url : 
+	 * 		params : { field : value, ... }
+	 * 		msgClass :
+	 * 		msgGroup :
+	 * }
+	 */
+	connect: function () {			// connect the client
+		this.websocket = null;
+
+		var queryString = "";
+		var params = this._generateConnectionParams();
+
+		//not in browser env but using node js to run
+		if (!("WebSocket" in window) 
+				&& W3CWebSocket) {
+			WebSocket = W3CWebSocket;
+		}
+
+		if (typeof jQuery == "undefined") {
+			jQuery = node_jquery;
+		}
+
+		if (WebSocket && jQuery) {
+			// serialize the object into query string
+			
+			/*
+			 * TODO If you don't want to use jQuery you can use below logic to generate same string
+			 *
+			if (params != null) queryString = "?" +  Object.keys(params).map(function(k) {
+    				return encodeURIComponent(k) + '=' + encodeURIComponent(params[k])
+			}).join('&')
+			*
+			*/
+			if (params != null) queryString = "?" + jQuery.param(params);	
+			
+			var ws_url = this.config.url + queryString;
+			var websocket = new WebSocket(ws_url);
+			websocket.binaryType = "arraybuffer";
+
+			// on message will be attached to the endpoint directly
+			// after it is created
+			websocket.onopen = _.bind(this.onConnected, this);
+			websocket.onclose = _.bind(this.onDisconnected, this);
+			websocket.onerror = _.bind(this.onConnectionError, this);
+
+			console.log("Created websocket: " + ws_url);
+
+			this.websocket = websocket;
+
+		} else {
+			alert("PLEASE UPGRADE YOUR BROWSER TO SUPPORT WEBSOCKET!");
+			throw "Please upgrade your browser to support WEBSOCKET!";
+		}
+	},
+
+	disconnect: function () {
+		if (this.websocket != null) {
+			this.websocket.close();
+			if (this.keepAlive) this.disableKeepAlive();
+			delete this._ep;
+		}
+	},
+
+	/**
+	 * Generate the object containing data to be put into the get request
+	 */
+	_generateConnectionParams: function () {
+		var params = {};
+
+		if (this.config.params !== undefined) params = _.clone(this.config.params);
+
+		if (this.config.msgGroup !== undefined && this.config.msgGroup !== "" && this.config.msgGroup !== null) {
+
+			if (this.config.msgGroup instanceof IMessageGroup) params["MessageGroup"] = this.config.msgGroup.id();
+			else params["MessageGroup"] = this.config.msgGroup;
+
+		}
+
+		if (this.config.msgClass !== undefined && this.config.msgClass !== "" && this.config.msgClass !== null) {
+
+			if (this.config.msgClass instanceof IMessageClass) {
+
+				if (params["MessageGroup"] !== undefined && this.config.msgClass.group().id() != params["MessageGroup"])
+					throw "Cannot generate connection params! Group ID " + params["MessageClass"] + " doesn't match with what defined in accompanied message class!";
+
+				params["MessageClass"] = this.config.msgClass.id();
+				params["MessageGroup"] = this.config.msgClass.group().id();
+
+			} else params["MessageClass"] = this.config.msgClass;
+
+		}
+
+		if (_.isEmpty(params)) return null;
+		else return params;
+	},
+
+	enableKeepAlive: function () {
+
+		if (this.keepAlive == false) {
+			this.keepAliveTimeout = setInterval(_.bind(this.sendKeepAlive, this), this.config.keepAliveInterval);
+		}
+
+		this.keepAlive = true;
+	},
+
+	disableKeepAlive: function () {
+
+		if (this.keepAlive == true) {
+			clearInterval(this.keepAliveTimeout);
+		}
+
+		this.keepAlive = false;
+	},
+
+	sendKeepAlive: function () {
+
+		if (this._ep == undefined) return;
+
+		var wrapper = new MessageWrapper("", this._keepAliveMsgGrp.classById(0));	// send an empty string
+		this._ep.send(wrapper);
+	},
+
+	send: function (wrapper) {
+		this._ep.send(wrapper);
+	},
+
+	onConnected: function (event) {
+		this._ep = new EndPoint(this.websocket);
+		this._ep.copyGroupRegistry(this);
+
+		this.dispatch(new EPConnectedEvent(this._ep));
+
+	},
+
+	onDisconnected: function (event) {
+		if (this._ep !== undefined) {
+			this.dispatch(new EPDisconnectedEvent(this._ep));
+			this._ep = undefined;
+		}
+	},
+
+	onConnectionError: function (event) {
+		this.dispatch(new EPConnectionError());
+	},
+
+	processUnparsedMessage: function (mw, origin) {
+
+		if (mw.messageClass.group().id() == 4) {
+			console.debug("Receive keep alive message from", origin)
+			return false;	// no need to continue processing this message
+		}
+
+	}
+
+}, IClient, IEndPointEventSource, GroupRegistry);
+
+module.exports = exports = {
+	DefaultClient: DefaultClient,
+	IMessageClass: IMessageClass,
+	IMessageGroup: IMessageGroup,
+	IMessageGroupProcessor: IMessageGroupProcessor,
+	MetaInformationCode: MetaInformationCode,
+	StreamNameCode: StreamNameCode,
+	MessageIdCode: MessageIdCode,
+	IEndPoint: IEndPoint,
+	IEndPointEventSource: IEndPointEventSource,
+	IPreparsingHook: IPreparsingHook,
+	IClient: IClient,
+	EndPoint: EndPoint,
+	EPEvent: EPEvent,
+	EPConnectedEvent: EPConnectedEvent,
+	EPConnectionError: EPConnectionError,
+	EPDisconnectedEvent: EPDisconnectedEvent,
+	MessageWrapper: MessageWrapper,
+	Util: Util,
+	generateUUID: generateUUID
+}