twitst4tz

client.js (5902B)

---

 
 /**
  * Module dependencies.
  */
 
 var parser = require('socket.io-parser');
 var debug = require('debug')('socket.io:client');
 var url = require('url');
 
 /**
  * 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 = server.encoder;
   this.decoder = new server.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
  * @param {Object} query the query parameters
  * @api private
  */
 
 Client.prototype.connect = function(name, query){
   if (this.server.nsps[name]) {
     debug('connecting to namespace %s', name);
     return this.doConnect(name, query);
   }
 
   this.server.checkNamespace(name, query, (dynamicNsp) => {
     if (dynamicNsp) {
       debug('dynamic namespace %s was created', dynamicNsp.name);
       this.doConnect(name, query);
     } else {
       debug('creation of namespace %s was denied', name);
       this.packet({ type: parser.ERROR, nsp: name, data: 'Invalid namespace' });
     }
   });
 };
 
 /**
  * Connects a client to a namespace.
  *
  * @param {String} name namespace
  * @param {String} query the query parameters
  * @api private
  */
 
 Client.prototype.doConnect = function(name, query){
   var nsp = this.server.of(name);
 
   if ('/' != name && !this.nsps['/']) {
     this.connectBuffer.push(name);
     return;
   }
 
   var self = this;
   var socket = nsp.add(this, query, 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, writeToEngine); // encode, then write results to engine
     } 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(url.parse(packet.nsp).pathname, url.parse(packet.nsp, true).query);
   } else {
     var socket = this.nsps[packet.nsp];
     if (socket) {
       process.nextTick(function() {
         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.conn.close();
 };
 
 /**
  * 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);
 };