Socket.io: Client.disconnect(), um einen Client zum Trennen der Verbindung zu zwingen

Es könnte interessant sein, darüber zu diskutieren, ob es sich lohnt zu implementieren (obwohl es eine geringe Priorität hätte). IRC Kick/Ban ist jedoch ein Beispiel dafür, wo ich solche Funktionen nicht verwenden würde. In diesen Szenarien ist es erwünscht, dass der Client verbunden bleibt und nur das Senden von Nachrichten eines bestimmten Kanals verhindert wird.

Fand dies, als ich über eine ähnliche Methode nachdachte.

Ich hätte gerne eine Möglichkeit, einem Client explizit und sauber mitzuteilen, dass die Verbindung aus Richtliniengründen und nicht aus Transportgründen getrennt wird. Zum Beispiel Autorisierungsfehler. Auf diese Weise weiß der Client, dass die Verbindung hergestellt wurde, aber auf Geheiß des Hosts getrennt wurde, und muss keine Fallback-Transporte versuchen.

Vielen Dank!

Dies wäre in der Tat sehr nützlich.

Ist client.connection.destroy() eine legitime Möglichkeit, einen Client zu trennen?

plus1. Würde gerne eine Möglichkeit haben, einen Client sauber zu trennen. :)

client._onDisconnect(); oder
socket.clients[kickedUserSocketId]._onDisconnect();

scheinen den Trick zu machen.

HINWEIS: Es gibt einen Unterstrich vor dem "onDisconnect", es wird in diesem Markdown einfach nicht gerendert.

Habe auch gesehen, dass es jemand so gemacht hat (habe es aber nicht selbst getestet):
socket.clients[kickedClientId].send({ event: 'disconnect' });
socket.clients[kickedClientId].connection.end();

Ist das jetzt implementiert, oder sollte ich die - Methode verwenden

socket.clients[kickedClientId].send({ event: 'disconnect' });
socket.clients[kickedClientId].connection.end();

Wie geht das "offiziell"????

Bitte öffnen Sie wieder, damit wir herausfinden, wie der offizielle Weg ist.

Es gibt immer noch keine Lösung dafür. Bitte öffnen Sie erneut, um den Fortschritt zu verfolgen.

Ich habe gerade diesen Code in client/socket.js entdeckt:

/**
 * Kicks client
 *
 * <strong i="6">@api</strong> public
 */

Socket.prototype.disconnect = function () {
  if (!this.disconnected) {
    this.log.info('booting client');

    if ('' === this.namespace.name) {
      if (this.manager.transports[this.id] && this.manager.transports[this.id].open) {
        this.manager.transports[this.id].onForcedDisconnect();
      } else {
        this.manager.onClientDisconnect(this.id);
        this.manager.store.publish('disconnect:' + this.id);
      }
    } else {
      this.packet({type: 'disconnect'});
      this.manager.onLeave(this.id, this.namespace.name);
      this.$emit('disconnect', 'booted');
    }

  }

  return this;
};

Ich habe es versucht ( socket.disconnect() ) und es funktioniert gut. Es sieht so aus, als ob dieser Code seit Mitte 2011 existiert und uns niemand gesagt hat.

Siehe auch Ausgabe #795.

das socket.disconnect(); scheint nicht richtig zu funktionieren, sicherlich löst es das Disconnect-Ereignis aus, aber es schließt die Verbindung nicht buchstäblich. Gibt es einen Fehler oder wird dieses Verhalten erwartet?

@geniousphp Ich habe das gleiche Problem

Warum ist das Problem also geschlossen, ist es gelöst? Wenn das so ist, wie? Was ist die Schlussfolgerung?

Ich weiß nicht, warum es geschlossen ist, es funktioniert bei mir nicht und ich benutze immer noch die hässliche Art, die Trennung zu erzwingen.

Versuchen,
socket.manager.onClientDisconnect(socket.id);

Ich glaube, das will ich. genial.

Leider funktioniert @acidhax seine Methode seit der Version 1.0 nicht mehr

Gibt es trotzdem ein reibungsloses Upgrade von 0.9.16 auf 1.XX, Leute?

+1

Das gleiche Boot hier. Dies ist für das Testen sehr wichtig, da Sie Tests voneinander isolieren möchten.

    try {
        IO.Options opts = new IO.Options();
        opts.forceNew = true;
        opts.timeout = -1;
        socket1 = IO.socket(c.ip, opts);
        socket1.on("res", getdataListener);
        socket1.connect();
                socket1.on(com.github.nkzawa.socketio.client.Socket.EVENT_CONNECT,
                new Emitter.Listener() {

                    <strong i="5">@Override</strong>
                    public void call(Object... args) {

                        Logger.print("CONNECTED...............");

                        Message msg = new Message();
                        msg.what = ResponseCodes.CreateQueueResp;
                        Login.handler.sendMessage(msg);

                        activity.runOnUiThread(new Runnable() {

                            <strong i="6">@Override</strong>
                            public void run() {
                                // TODO Auto-generated method stub

                                startChecking();
                                startIdleChecking();

                            }

                        }); 
                    }

                })
                .on(com.github.nkzawa.socketio.client.Socket.EVENT_RECONNECT,
                        new Emitter.Listener() {

                            <strong i="7">@Override</strong>
                            public void call(Object... arg0) {


                                System.out
                                        .println("............... EVENT_RECONNECT");

                                // TODO Auto-generated method stub

                            }
                        })
                .on(com.github.nkzawa.socketio.client.Socket.EVENT_CONNECT_ERROR,
                        new Emitter.Listener() {

                            <strong i="8">@Override</strong>
                            public void call(Object... args) {

                                System.out
                                        .println("............... EVENT_CONNECT_ERROR");

                            }

                        })
                .on(com.github.nkzawa.socketio.client.Socket.EVENT_CONNECT_TIMEOUT,
                        new Emitter.Listener() {

                            <strong i="9">@Override</strong>
                            public void call(Object... args) {

                                System.out
                                        .println("............... EVENT_CONNECT_TIMEOUT");

                            }

                            // this is the emit from the server
                        })

                .on(Socket.EVENT_ERROR, new Emitter.Listener() {

                    <strong i="10">@Override</strong>
                    public void call(Object... args) {

                        System.out
                                .println("......................... EVENT_ERROR");

                    }

                    // this is the emit from the server

                })
                .on(com.github.nkzawa.socketio.client.Socket.EVENT_DISCONNECT,
                        new Emitter.Listener() {

                            <strong i="11">@Override</strong>
                            public void call(Object... args) {

                                Logger.print(".............EVENT_DISCONNECT");


                                if (!open) {

                                    //server_message = getResources().getString(R.string.It_seems_that);


                                    server_message="It seems that connection to server have been Lost.Please reconnect!"; 

                                    ServerError error = new ServerError(activity, server_message);


                                }

                            }

                        });

    } catch (Exception e) {

        e.printStackTrace();

    }

Meine Funktions-App wurde wiederholt ausgelöst, wenn das Gerät die Nachricht erhält. Jedes Mal, wenn meine Funktions-App-Socket-Verbindung geöffnet wurde. So schließen Sie die geöffnete Verbindung gewaltsam.
Hier ist meine Logik:
'streng verwenden';
var _test = require('socket.io-client');
var-Socket = _test.connect('http://XXXXXXXXXX.net/');
exports.handler = Funktion (Ereignis, Kontext) {
var ResultMessage = JSON.stringify(event.message,null,2);
if(!socket.verbunden)
{
socket.emit('Benutzer hinzufügen', '1542');
}
socket.emit('neue Nachricht',"[" + ResultMessage + "]");

};
Vielen Dank,
Im Voraus.