Kann ich den Fehler "kann keine Verbindung herstellen" für eine fehlgeschlagene Websocket-Verbindung abfangen?

Question

Ich muss testen, ob die Verbindung zu meinem Websocket-Server hergestellt ist oder nicht.

Zu diesem Zeitpunkt kann ich eine Verbindung zum Server herstellen, aber ich möchte in der Lage sein, die Möglichkeit zu erkennen, dass dieser Server nicht erreichbar ist, also diese Frage ist, was zu tun ist, wenn die Websocket-Verbindung nicht hergestellt werden kann oder wenn Die Zeit ist abgelaufen.

Mit nur dem grundlegenden Websocket-Code in Firefox wird es in ca. 20 Sekunden Timeout und rufen Sie meine Fehlerbehandlung. Aber es wird auch einen JavaScript-Fehler werfen, der (zumindest für mich mit Firebug) im Browser auftaucht. Das Protokoll zeigt dann:

Firefox can't establish a connection to the server at ws://192.168.0.1/. 

Was ich bisher versucht habe:

• verhindern, dass die 20 Sekunden Timeout, indem Sie meinen eigenen window.timeout, der überprüft, ob die onopen Handler noch oder nicht genannt wurde, aber das verhindert den JavaScript-Fehler nicht.

• Schließen erzwingen die websocket am Ende meiner eigenen Timeout, aber jetzt bekomme ich zwei JavaScript-Fehler - das Original plus:

  The connection to ws://192.168.0.1/ was interrupted while the page was loading.

• try {} catch(e) {} zu meinem Code hinzufügen, sowohl beim Anschluss der Steckdose und schließen es - keine Veränderung.

Haben Sie Ideen, wie Sie WebSocket-Fehler nicht im Browser anzeigen können?

Answer 1

Was ich bisher learnd habe, ist: Sie heucheln: 0 (

... weil dies etwas Browser spezifisches Verhalten ist ...

• so das einzige, was Sie tun können, ist mit Rückrufe auf ws Objekt und beten ...
• OR nur console.log überschreiben; 0)

mit dem Code habe ich aber tat i rid Meldungen einiger Fehler, es wird vielleicht helfen;)

zB:

• Chrome über tote Server nicht und geräuschlos beschweren werden versuchen, .. 11
• IE gibt
Skriptfehler noch wieder zu verbinden
• etc ..

A Basic Class WS wickeln: einen Blick auf Rückrufe haben!

/** 
* Socket Class 
*/ 
Client.Source.Network.Socket.Class = new Class({ implements: [Client.Source.Network.Socket.Interface] },function(Host, Port){ 

var Configuration = { 
    Server: { 
     Protocol: 'ws', 
     Host: Host, 
     Port: Port 
    }, 
    Event: { 
     Open: function(){}, 
     Error: function(){}, 
     Message: function(){}, 
     Close: function(){} 
    } 
}; 

var Socket = null; 

/** 
* @return {string} 
*/ 
var HostUrl = function() { 
    return Configuration.Server.Protocol + '://' + Configuration.Server.Host + ':' + Configuration.Server.Port + '/Connection' 
}; 

/** 
* @returns {boolean} 
*/ 
var IsSupported = function() { 
    return "WebSocket" in window; 
}; 

this.Open = function() { 
    if(IsSupported()) { 
     Socket = new WebSocket(HostUrl()); 
     Socket.onopen = Configuration.Event.Open; 
     Socket.onerror = Configuration.Event.Error; 
     Socket.onmessage = Configuration.Event.Message; 
     Socket.onclose = Configuration.Event.Close; 
    } else { 

    } 
}; 

this.Send = function(Text) { 
    Socket.send(Text); 
}; 

this.Close = function() { 
    Socket.close(); 
}; 

this.onOpen = function(Callback) { 
    Configuration.Event.Open = Callback; 
}; 
this.onError = function(Callback) { 
    Configuration.Event.Error = Callback; 
}; 
this.onMessage = function(Callback) { 
    Configuration.Event.Message = Callback; 
}; 
this.onClose = function(Callback) { 
    Configuration.Event.Close = Callback; 
}; 

}); 

Werfen Sie einen Blick auf die Connect(): onError(), onClose() Funktion

/** 
* Network Class 
*/ 
Client.Source.Network.Class = new Class({ implements: [Client.Source.Network.Interface] },function(){ 

var _Self = this; 
var Socket = null; 

this.Connect = function(Host, Port) { 
    Socket = new Client.Source.Network.Socket.Class(Host, Port); 
    Socket.onOpen(function(){ 
     _Self.Gui().Create(Client.Module.Client.Gui()); 
     Client.Module.Chat.Message('Connected', 'green', 11); 
     Client.Module.Audio.Play('Client.Resource.Audio.Chat.UserOnline', 0.2); 
    }); 
    Socket.onMessage(Response); 
    Socket.onError(function(){ 
     Client.Module.Chat.Message('Connection Error', 'red', 11); 
    }); 
    Socket.onClose(function(){ 
     _Self.Gui().Destroy(); 
     Client.Module.Chat.Message('Disconnected', 'darkred', 11); 
     Client.Module.Chat.Message('Connecting...', 'orange', 11); 
     window.setTimeout(function() { 
      _Self.Connect(Host, Port); 
     }, 2000); 
    }); 
    Socket.Open(); 
}; 

this.Request = function(Application, Request, Data) { 
    Socket.Send(JSON.stringify({ Application: Application, Request: Request, Data: Data })); 
}; 
var Response = function(Message) { 
    Message = JSON.parse(Message.data); 
    Library[Message.Application].Execute(Message.Request, Message.Data); 
}; 

var Library = {}; 
this.Protocol = function(Application, Callback) { 
    Library[Application] = Callback; 
}; 

var GuiObject = null; 
this.Gui = function Gui() { 
    if(GuiObject === null) { 
     GuiObject = new Client.Source.Network.Gui(); 
    } 
    return GuiObject; 
}; 
});