socket.io: Disconnect-Ereignis - 'Transport schließen', 'Client-Namespace trennen', 'Transportfehler' und 'erzwungenes Schließen'

Question

Mit socket.io v1.2.1 (nur mit dem "Polling" -Transport), manchmal meine Kunden Unterbrechungen erleben.

Ungefähr 50% der Zeit bekomme ich ping timeout auf meine Callback-Funktion Verbindung trennen, was vernünftig ist.

Andere Zeiten, ich bekomme transport close, client namespace disconnect, transport error und forced close. Ich habe in der Dokumentation keinen Hinweis auf diese Verbindungsunterbrechungsgründe gefunden und konnte deren Bedeutung aus dem Code nicht wirklich verstehen.

Ich möchte sicherstellen, dass ich jede Trennung die beste Weise behandeln (und sie möglicherweise verhindern).

Vielleicht kann jemand ein wenig Licht über diese Gründe werfen.

Answer 1

Leider kann dies passieren. Manchmal, weil ich Unglück hatte, lag es an der Firewall irgendwo zwischen mir, dem Server und anderen Clients.

Für Ping Timeouts Sie versuchen können Ping-Intervall auf Server-Seite

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

Answer 2

Es gibt keine Dokumentation zu erhöhen, dies ist mehr oder weniger, was ich aus dem Code interpretieren kann:

Forced close - Der Socket in Schließzustand ist

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(); 
}; 

Der Transport wo geschlossen (kein Grund, hier)

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"); 
    } 

wir einen Kunden trennen Paket erhalten, so dass wir Buchse Zustand auf 'Schließen' ändern

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'); 
}; 

Einer der Gründe der Verkehrs schließen

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); 
    } 
}; 

Es scheint, wie sie Fehler Steckdosen von überall her zu werfen, so dass der einzige Weg, um die Ursache zu finden, ist durch die Fehlerbeschreibung zu lesen (nicht zu viele Informationen) oder auf der Suche alle Bibliotheken zu finden, was das verursacht Error.

PD: Es gibt viele Fehler.