Diffusion SHRINE MedCo Fork (fork/1.22.8-medco) Browse

shrine-medco/shrine-webclient/src/main/html/node_modules/socket.io/lib/client.js
dcbff2869ab8fork/1.22.8-medco

client.js
View Options


			/**
			* Module dependencies.
			*/

			var parser = require('socket.io-parser');
			var debug = require('debug')('socket.io:client');

			/**
			* Module exports.
			*/

			module.exports = Client;

			/**
			* Client constructor.
			*
			* @param {Server} server instance
			* @param {Socket} conn
			* @api private
			*/

			function Client(server, conn){
			this.server = server;
			this.conn = conn;
			this.encoder = new parser.Encoder();
			this.decoder = new parser.Decoder();
			this.id = conn.id;
			this.request = conn.request;
			this.setup();
			this.sockets = {};
			this.nsps = {};
			this.connectBuffer = [];
			}

			/**
			* Sets up event listeners.
			*
			* @api private
			*/

			Client.prototype.setup = function(){
			this.onclose = this.onclose.bind(this);
			this.ondata = this.ondata.bind(this);
			this.onerror = this.onerror.bind(this);
			this.ondecoded = this.ondecoded.bind(this);

			this.decoder.on('decoded', this.ondecoded);
			this.conn.on('data', this.ondata);
			this.conn.on('error', this.onerror);
			this.conn.on('close', this.onclose);
			};

			/**
			* Connects a client to a namespace.
			*
			* @param {String} name namespace
			* @api private
			*/

			Client.prototype.connect = function(name){
			debug('connecting to namespace %s', name);
			var nsp = this.server.nsps[name];
			if (!nsp) {
			this.packet({ type: parser.ERROR, nsp: name, data : 'Invalid namespace'});
			return;
			}

			if ('/' != name && !this.nsps['/']) {
			this.connectBuffer.push(name);
			return;
			}

			var self = this;
			var socket = nsp.add(this, function(){
			self.sockets[socket.id] = socket;
			self.nsps[nsp.name] = socket;

			if ('/' == nsp.name && self.connectBuffer.length > 0) {
			self.connectBuffer.forEach(self.connect, self);
			self.connectBuffer = [];
			}
			});
			};

			/**
			* Disconnects from all namespaces and closes transport.
			*
			* @api private
			*/

			Client.prototype.disconnect = function(){
			for (var id in this.sockets) {
			if (this.sockets.hasOwnProperty(id)) {
			this.sockets[id].disconnect();
			}
			}
			this.sockets = {};
			this.close();
			};

			/**
			* Removes a socket. Called by each `Socket`.
			*
			* @api private
			*/

			Client.prototype.remove = function(socket){
			if (this.sockets.hasOwnProperty(socket.id)) {
			var nsp = this.sockets[socket.id].nsp.name;
			delete this.sockets[socket.id];
			delete this.nsps[nsp];
			} else {
			debug('ignoring remove for %s', socket.id);
			}
			};

			/**
			* Closes the underlying connection.
			*
			* @api private
			*/

			Client.prototype.close = function(){
			if ('open' == this.conn.readyState) {
			debug('forcing transport close');
			this.conn.close();
			this.onclose('forced server close');
			}
			};

			/**
			* Writes a packet to the transport.
			*
			* @param {Object} packet object
			* @param {Object} opts
			* @api private
			*/

			Client.prototype.packet = function(packet, opts){
			opts = opts \|\| {};
			var self = this;

			// this writes to the actual connection
			function writeToEngine(encodedPackets) {
			if (opts.volatile && !self.conn.transport.writable) return;
			for (var i = 0; i < encodedPackets.length; i++) {
			self.conn.write(encodedPackets[i], { compress: opts.compress });
			}
			}

			if ('open' == this.conn.readyState) {
			debug('writing packet %j', packet);
			if (!opts.preEncoded) { // not broadcasting, need to encode
			this.encoder.encode(packet, function (encodedPackets) { // encode, then write results to engine
			writeToEngine(encodedPackets);
			});
			} else { // a broadcast pre-encodes a packet
			writeToEngine(packet);
			}
			} else {
			debug('ignoring packet write %j', packet);
			}
			};

			/**
			* Called with incoming transport data.
			*
			* @api private
			*/

			Client.prototype.ondata = function(data){
			// try/catch is needed for protocol violations (GH-1880)
			try {
			this.decoder.add(data);
			} catch(e) {
			this.onerror(e);
			}
			};

			/**
			* Called when parser fully decodes a packet.
			*
			* @api private
			*/

			Client.prototype.ondecoded = function(packet) {
			if (parser.CONNECT == packet.type) {
			this.connect(packet.nsp);
			} else {
			var socket = this.nsps[packet.nsp];
			if (socket) {
			socket.onpacket(packet);
			} else {
			debug('no socket for namespace %s', packet.nsp);
			}
			}
			};

			/**
			* Handles an error.
			*
			* @param {Object} err object
			* @api private
			*/

			Client.prototype.onerror = function(err){
			for (var id in this.sockets) {
			if (this.sockets.hasOwnProperty(id)) {
			this.sockets[id].onerror(err);
			}
			}
			this.onclose('client error');
			};

			/**
			* Called upon transport close.
			*
			* @param {String} reason
			* @api private
			*/

			Client.prototype.onclose = function(reason){
			debug('client close with reason %s', reason);

			// ignore a potential subsequent `close` event
			this.destroy();

			// `nsps` and `sockets` are cleaned up seamlessly
			for (var id in this.sockets) {
			if (this.sockets.hasOwnProperty(id)) {
			this.sockets[id].onclose(reason);
			}
			}
			this.sockets = {};

			this.decoder.destroy(); // clean up decoder
			};

			/**
			* Cleans up event listeners.
			*
			* @api private
			*/

			Client.prototype.destroy = function(){
			this.conn.removeListener('data', this.ondata);
			this.conn.removeListener('error', this.onerror);
			this.conn.removeListener('close', this.onclose);
			this.decoder.removeListener('decoded', this.ondecoded);
			};