WebSocket: Fehler bei der WebSocket-handshake: Gesendet nicht leer "Sec-WebSocket-Protocol" - header, aber keine Antwort empfangen wurde

Ich versuche zu schaffen, eine WS-Verbindung mit meinem tornado-server. Der server-code ist einfach:

class WebSocketHandler(tornado.websocket.WebSocketHandler):

    def open(self):
        print("WebSocket opened")

    def on_message(self, message):
        self.write_message(u"You said: " + message)

    def on_close(self):
        print("WebSocket closed")

def main():

    settings = {
        "static_path": os.path.join(os.path.dirname(__file__), "static")
    }


    app = tornado.web.Application([
            (r'/ws', WebSocketHandler),
            (r"/()$", tornado.web.StaticFileHandler, {'path':'static/index.html'}),
        ], **settings)


    app.listen(8888)
    tornado.ioloop.IOLoop.current().start()

Ich kopieren eingefügt, die der client-code von hier:

$(document).ready(function () {
    if ("WebSocket" in window) {

        console.log('WebSocket is supported by your browser.');

        var serviceUrl = 'ws://localhost:8888/ws';
        var protocol = 'Chat-1.0';
        var socket = new WebSocket(serviceUrl, protocol);

        socket.onopen = function () {
            console.log('Connection Established!');
        };

        socket.onclose = function () {
            console.log('Connection Closed!');
        };

        socket.onerror = function (error) {
            console.log('Error Occured: ' + error);
        };

        socket.onmessage = function (e) {
            if (typeof e.data === "string") {
                console.log('String message received: ' + e.data);
            }
            else if (e.data instanceof ArrayBuffer) {
                console.log('ArrayBuffer received: ' + e.data);
            }
            else if (e.data instanceof Blob) {
                console.log('Blob received: ' + e.data);
            }
        };

        socket.send("Hello WebSocket!");
        socket.close();
    }
});

Wenn er versucht zu verbinden, bekomme ich die folgende Ausgabe auf dem browser-Konsole:

WebSocket connection to 'ws://localhost:8888/ws' failed: Error during WebSocket handshake: Sent non-empty 'Sec-WebSocket-Protocol' header but no response was received

Warum ist das so?

Posten Sie Ihre Verbindung mit dem client-code, oder wir werden zu erraten...
Ich benutzte die Chat-1 Protokoll. Schließlich habe ich gelöscht, das Teil, und öffnete die WS ohne Angabe von Protokoll und arbeitet auf diese Weise. Ich bin immer noch interessiert, wie ich das konfigurieren der server-Seite, es zu akzeptieren.

InformationsquelleAutor Midiparse | 2015-12-10

python websocket

19

Wie bereits in whatwg.org's Websocket-Dokumentation (es ist eine Kopie von der Norm-Entwurf):

WebSocket(url-Protokolle) Konstruktor nimmt ein oder zwei Argumente. Das erste argument, die url gibt den URL für die Verbindung. Die zweite, Protokolle, falls vorhanden, ist entweder ein string oder ein array von strings. Wenn es ein string ist, ist es äquivalent zu einem array aus genau dieser string; wenn es weggelassen wird, ist äquivalent zu der leeres array ist. Jeder string in dem array ist ein subprotocol Namen. Die Verbindung wird nur hergestellt, wenn der server meldet, dass es ausgewählt hat, eine dieser subprotocols. Die subprotocol Namen müssen alle Zeichenfolgen, die mit den Anforderungen übereinstimmen, die für die Elemente, aus denen sich der Wert von Sec-WebSocket-Protokoll-Felder definiert durch das WebSocket-Protokoll-Spezifikation.

Dein server Antworten die websocket-Verbindung-request mit leerer Sec-WebSocket-Protocol header, da es nicht die Unterstützung der Chat-1 subprotocol.

Da bist du schreiben der server-Seite und client-Seite (und, sofern Ihr das schreiben einer API, die Sie verwenden wollen), es sollte nicht super wichtig, ein bestimmtes subprotocol Namen.

Können Sie dieses Problem beheben, indem entweder das entfernen der subprotocol Namen von der javascript-Verbindung:
```
var socket = new WebSocket(serviceUrl);
```
Oder ändern Sie Ihre server unterstützt das Protokoll angefordert.

Ich könnte Ihnen ein Ruby-Beispiel, aber ich kann nicht geben ein Python-Beispiel, da ich nicht genügend Informationen.

BEARBEITEN (Ruby-Beispiel)

Da wurde ich gebeten, in den Kommentaren, hier ist ein Ruby Beispiel.

Diesem Beispiel erfordert die iodine HTTP/WebSockets server, da es unterstützt die rack.upgrade Spezifikation Entwurf (Konzept detaillierte hier) und fügt ein pub/sub-API.

Server-code kann entweder ausgeführt durch das terminal oder als Rack-Anwendung in einem config.ru - Datei (run iodine von der Befehlszeile aus um den server zu starten):
```
# frozen_string_literal: true

class ChatClient
  def on_open client
    @nickname = client.env['PATH_INFO'].to_s.split('/')[1] || "Guest"
    client.subscribe :chat    
    client.publish :chat , "#{@nickname} joined the chat."
    if client.env['my_websocket.protocol']
      client.write "You're using the #{client.env['my_websocket.protocol']} protocol"
    else
      client.write "You're not using a protocol, but we let it slide"
    end
  end
  def on_close client
    client.publish :chat , "#{@nickname} left the chat."
  end
  def on_message client, message
    client.publish :chat , "#{@nickname}: #{message}"
  end
end

module APP
  # the Rack application
  def self.call env
    return [200, {}, ["Hello World"]] unless env["rack.upgrade?"]
    env["rack.upgrade"] = ChatClient.new
    protocol = select_protocol(env)
    if protocol
      # we will use the same client for all protocols, because it's a toy example
      env['my_websocket.protocol'] = protocol # <= used by the client
      [101, { "Sec-Websocket-Protocol" => protocol }, []]
    else
      # we can either refuse the connection, or allow it without a match
      # here, it is allowed
      [101, {}, []]
    end
  end

  # the allowed protocols
  PROTOCOLS = %w{ chat-1.0 soap raw }

  def select_protocol(env)
    request_protocols = env["HTTP_SEC_WEBSOCKET_PROTOCOL"]
    unless request_protocols.nil?
      request_protocols = request_protocols.split(/,\s?/) if request_protocols.is_a?(String)
      request_protocols.detect { |request_protocol| PROTOCOLS.include? request_protocol }
    end # either `nil` or the result of `request_protocols.detect` are returned
  end

  # make functions available as a singleton module
  extend self
end

# config.ru
if __FILE__.end_with? ".ru"
  run APP 
else
# terminal?
  require 'iodine'
  Iodine.threads = 1
  Iodine.listen2http app: APP, log: true
  Iodine.start
end
```
Um den code zu testen, wird die folgende JavaScript funktionieren sollte:
```
ws = new WebSocket("ws://localhost:3000/Mitchel", "chat-1.0");
ws.onmessage = function(e) { console.log(e.data); };
ws.onclose = function(e) { console.log("Closed"); };
ws.onopen = function(e) { e.target.send("Yo!"); };
```
- Ich wäre sehr daran interessiert, ein Ruby Beispiel. Ich bin Herumspielen mit der wamp-Juwel und habe das gleiche Problem (github.com/bradylove/wamp-ruby), aber es nutzt v1. Ich denke dabei an das schreiben einer v2 WAMP gem ...
- Ich bin mir nicht sicher, ob ich verstehe Ihr Problem. Dies ist eine client-bezogene Frage und die Perle, die Sie erwähnt haben, ist eine server-Implementierung. Vielleicht könnten Sie eröffnen eine neue Frage mit einem full trace und lassen Sie einen link zurück hierher?
- Hey, darf ich die Ruby-Beispiel, wenn du Sie noch?
- Ich bearbeitete die Antwort auf fügen Sie ein Ruby-Beispiel für Ihre Bequemlichkeit. Viel Glück!
InformationsquelleAutor Myst

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

BEARBEITEN (Ruby-Beispiel)