socket.io: Disconnetti evento - 'trasporto chiuso', 'client namespace disconnect', 'transport error' e 'forced close'

Question

Utilizzo di socket.io v1.2.1 (solo utilizzando il trasporto "polling"), a volte i miei clienti sperimentare disconnessioni.

Circa il 50% delle volte ricevo ping timeout sulla funzione di richiamata dell'evento di disconnessione, che è ragionevole.

Altre volte, ricevo transport close, client namespace disconnect, transport error e forced close. Non ho trovato alcun riferimento a quei motivi di disconnessione nella documentazione, e non sono stato in grado di capire veramente il loro significato dal codice.

Voglio assicurarmi che gestisco ogni disconnessione nel modo migliore (e forse prevenirli).

Forse qualcuno può gettare un po 'di luce su questi motivi.

Answer 1

Purtroppo ciò può accadere. A volte, come ho avuto la sfortuna di affrontare, era dovuto al firewall da qualche parte tra me, server e altri client.

per Ping timeout si può cercare di aumentare intervallo di ping sul lato server

io = require('socket.io')(httpServer, { pingInterval: 60000 }); 

Answer 2

Non v'è alcuna documentazione, questo è più o meno quello che posso interpretare dal codice:

Forced close - La presa è in stato di chiusura

Forced close - https://github.com/socketio/engine.io/blob/master/lib/socket.js

function onPacket(packet){ 
    if ('ping' == packet.type && 'probe' == packet.data) { 
     transport.send([{ type: 'pong', data: 'probe' }]); 
     self.emit('upgrading', transport); 
     clearInterval(self.checkIntervalTimer); 
     self.checkIntervalTimer = setInterval(check, 100); 
    } else if ('upgrade' == packet.type && self.readyState != 'closed') { 
     debug('got upgrade packet - upgrading'); 
     cleanup(); 
     self.upgraded = true; 
     self.clearTransport(); 
     self.setTransport(transport); 
     self.emit('upgrade', transport); 
     self.setPingTimeout(); 
     self.flush(); 
     if (self.readyState == 'closing') { 
     transport.close(function() { 
      self.onClose('forced close'); 
     }); 
     } 
    } else { 
     cleanup(); 
     transport.close(); 
    } 
    } 


Socket.prototype.close = function() { 
    if ('open' != this.readyState) return; 

    this.readyState = 'closing'; 

    if (this.writeBuffer.length) { 
    this.once('drain', this.closeTransport.bind(this)); 
    return; 
    } 

    this.closeTransport(); 
}; 

Il trasporto in cui ha chiuso (nessuna ragione qui)

Transport close - https://github.com/socketio/engine.io/blob/master/lib/socket.js

function cleanup() { 
    self.upgrading = false; 

    clearInterval(self.checkIntervalTimer); 
    self.checkIntervalTimer = null; 

    clearTimeout(self.upgradeTimeoutTimer); 
    self.upgradeTimeoutTimer = null; 

    transport.removeListener('packet', onPacket); 
    transport.removeListener('close', onTransportClose); 
    transport.removeListener('error', onError); 
    self.removeListener('close', onClose); 
    } 


    function onTransportClose(){ 
    onError("transport closed"); 
    } 

Abbiamo ottenuto un pacchetto di client di disconnessione, quindi cambiamo stato presa di 'chiusura'

Client namespace disconnect - https://github.com/socketio/socket.io/blob/master/lib/socket.js

Socket.prototype.onpacket = function(packet){ 
    debug('got packet %j', packet); 
    switch (packet.type) { 
    case parser.EVENT: 
     this.onevent(packet); 
     break; 

    case parser.BINARY_EVENT: 
     this.onevent(packet); 
     break; 

    case parser.ACK: 
     this.onack(packet); 
     break; 

    case parser.BINARY_ACK: 
     this.onack(packet); 
     break; 

    case parser.DISCONNECT: 
     this.ondisconnect(); 
     break; 

    case parser.ERROR: 
     this.emit('error', packet.data); 
    } 
}; 


Socket.prototype.ondisconnect = function(){ 
    debug('got disconnect packet'); 
    this.onclose('client namespace disconnect'); 
}; 

Uno dei motivi di trasporto vicino

Transport error - https://github.com/socketio/engine.io/blob/master/lib/socket.js

/** 
* Called upon transport error. 
* 
* @param {Error} error object 
* @api private 
*/ 

Socket.prototype.onError = function (err) { 
    debug('transport error'); 
    this.onClose('transport error', err); 
}; 

https://github.com/socketio/engine.io/blob/master/lib/transport.js

/** 
* Called with a transport error. 
* 
* @param {String} message error 
* @param {Object} error description 
* @api private 
*/ 

Transport.prototype.onError = function (msg, desc) { 
    if (this.listeners('error').length) { 
    var err = new Error(msg); 
    err.type = 'TransportError'; 
    err.description = desc; 
    this.emit('error', err); 
    } else { 
    debug('ignored transport error %s (%s)', msg, desc); 
    } 
}; 

Sembra che essi gettano errori da prese da tutto il mondo, quindi l'unico modo di trovare la causa è leggendo la descrizione dell'errore (non troppe informazioni) o in cerca tutte le loro librerie di trovare che cosa sta causando la errore.

PD: ci sono molti errori.