WebSocket Connection timeout

Bin ich versucht zu implementieren failsafe-websocket-wrapper. Und das problem, das ich habe, ist der Umgang mit timeout-Fehler. Die Logik sollte sein: wenn der socket ist nicht geöffnet während $timeoutInMiliseconds - es muss geschlossen und wieder geöffnet $N-mal.

Ich bin etwas zu schreiben wie dieses.

var maxReconects = 0;
var ws = new WebSocket(url);
var onCloseHandler = function() {
    if ( maxReconects < N ) {
        maxReconects++;
        //construct new Websocket 
        ....
    }
};
ws.onclose = onCloseHandler;
var timeout = setTimeout(function() {
                console.log("Socket connection timeout",ws.readyState);
                timedOut = true;
                ws.close();  <--- ws.readyState is 0 here 
                timedOut = false;
},timeoutInMiliseconds);

Aber das problem ist der Umgang mit timeout websockets richtige Weg ist - wenn ich versuche zu schließen nonconnected socket erhalte ich die Warnung in chrome :

"WebSocket-Verbindung zu 'ws://127.0.0.1:9010/timeout' ist fehlgeschlagen: WebSocket ist geschlossen, bevor die Verbindung hergestellt wird."

Und ich habe keine Ahnung, wie es zu vermeiden - ws-Schnittstelle hat kein Abbruch-Funktion .

Die andere Vorgehensweise habe ich versucht, ist nicht zu schließen socket-timeout auf, wenn es nonconnected, sondern nur Kennzeichnen, dass Sie nicht mehr verwendet werden, und schließen Sie es, wenn Sie es erhalten readyState mehr als eine - aber es können mögliche Undichtigkeiten und zu kompliziert für diese einfache Aufgabe.

InformationsquelleAutor Oleg | 2015-04-26

  1. 2

    Ihre timeout variable zugewiesen wird, die setTimeout(... - Funktion, die aufgerufen wird lexikalisch. Durch die Zeit, die Ihr code bekommt var onCloseHander = ... Ihre timeout Funktion bereits aufgerufen.

    Eine Lösung dies ist, um eine makeTimeout Funktion:

    var makeTimeout = function (timeoutInMiliseconds) {
    return window.setTimeout(function() {
        //do stuff
    }, timeoutInMiliseconds)
};

    var timeoutId = makeTimeout(100) ruft die setTimeout - Funktion und stellen timeoutId als der Wert der timeout-ID. Wenn Sie stornieren müssen dieses Zeitlimit, das getan werden kann, durch aufrufen window.clearTimeout(timeoutId).

    InformationsquelleAutor amarpatel

  2. 2

    Ich geschrieben habe folgenden code für öffnen einer websocket-failsafe mit timeout und Wiederholungen, siehe Kommentare im code weitere details.

    Nutzung - öffnen einer websocket mit timeout 5000ms und 10 Wiederholungen (maximal):

    initWebsocket('ws:\\localhost:8090', null, 5000, 10).then(function(socket){
    console.log('socket initialized!');
    //do something with socket...

    //if you want to use the socket later again and assure that it is still open:
    initWebsocket('ws:\\localhost:8090', socket, 5000, 10).then(function(socket){
        //if socket is still open, you are using the same "socket" object here
        //if socket was closed, you are using a new opened "socket" object
    }

}, function(){
    console.log('init of socket failed!');
});

    Methode initWebsocket() irgendwo in einer Bibliothek definiert oder ähnliches:

    /**
 * inits a websocket by a given url, returned promise resolves with initialized websocket, rejects after failure/timeout.
 *
 * @param url the websocket url to init
 * @param existingWebsocket if passed and this passed websocket is already open, this existingWebsocket is resolved, no additional websocket is opened
 * @param timeoutMs the timeout in milliseconds for opening the websocket
 * @param numberOfRetries the number of times initializing the socket should be retried, if not specified or 0, no retries are made
 *        and a failure/timeout causes rejection of the returned promise
 * @return {Promise}
 */
function initWebsocket(url, existingWebsocket, timeoutMs, numberOfRetries) {
    timeoutMs = timeoutMs ? timeoutMs : 1500;
    numberOfRetries = numberOfRetries ? numberOfRetries : 0;
    var hasReturned = false;
    var promise = new Promise((resolve, reject) => {
        setTimeout(function () {
            if(!hasReturned) {
                console.info('opening websocket timed out: ' + url);
                rejectInternal();
            }
        }, timeoutMs);
        if (!existingWebsocket || existingWebsocket.readyState != existingWebsocket.OPEN) {
            if (existingWebsocket) {
                existingWebsocket.close();
            }
            var websocket = new WebSocket(url);
            websocket.onopen = function () {
                if(hasReturned) {
                    websocket.close();
                } else {
                    console.info('websocket to opened! url: ' + url);
                    resolve(websocket);
                }
            };
            websocket.onclose = function () {
                console.info('websocket closed! url: ' + url);
                rejectInternal();
            };
            websocket.onerror = function () {
                console.info('websocket error! url: ' + url);
                rejectInternal();
            };
        } else {
            resolve(existingWebsocket);
        }

        function rejectInternal() {
            if(numberOfRetries <= 0) {
                reject();
            } else if(!hasReturned) {
                hasReturned = true;
                console.info('retrying connection to websocket! url: ' + url + ', remaining retries: ' + (numberOfRetries-1));
                initWebsocket(url, null, timeoutMs, numberOfRetries-1).then(resolve, reject);
            }
        }
    });
    promise.then(function () {hasReturned = true;}, function () {hasReturned = true;});
    return promise;
};

    eine bessere Lösung wäre die Kapselung der Funktionalität in einer eigenen Klasse FailsafeWebsocket oder was auch immer. Allerdings ist diese Lösung ausreichend ist, in meinem Projekt - vielleicht hilft es jemand anderem zu.

    InformationsquelleAutor klues

Schreibe einen Kommentar