WebSocket-Client

WebSocket-Client für bidirektionale Echtzeit-Kommunikation mit Servern.

Laden

local websocket = require("websocket")

Verbinden

Einfache Verbindung

local client, err = websocket.connect("wss://api.example.com/ws")
if err then
    return nil, err
end

Mit Optionen

local client, err = websocket.connect("wss://api.example.com/ws", {
    headers = {
        ["Authorization"] = "Bearer " .. token
    },
    protocols = {"graphql-ws"},
    dial_timeout = "10s",
    read_timeout = "30s",
    compression = websocket.COMPRESSION.CONTEXT_TAKEOVER
})

Gibt zurück: Client, error

Verbindungsoptionen

Timeout-Format: Zahlen sind Millisekunden, Strings verwenden Go-Dauerformat ("5s", "1m").

Nachrichten senden

Textnachrichten

local ok, err = client:send("Hello, Server!")
if err then
    return nil, err
end

-- JSON senden
client:send(json.encode({
    type = "subscribe",
    channel = "orders"
}))

Binarnachrichten

client:send(binary_data, websocket.BINARY)

Gibt zurück: boolean, error

Ping

client:ping()

Gibt zurück: boolean, error

Nachrichten empfangen

Die channel()-Methode gibt einen Channel zum Empfangen von Nachrichten zurück. Funktioniert mit channel.select für Multiplexing.

Einfaches Empfangen

local ch = client:channel()

local msg, ok = ch:receive()
if ok then
    print("Type:", msg.type)  -- "text" oder "binary"
    print("Data:", msg.data)
end

Nachrichtenschleife

local ch = client:channel()

while true do
    local msg, ok = ch:receive()
    if not ok then
        break  -- Verbindung geschlossen
    end

    if msg.type == "text" then
        local data = json.decode(msg.data)
        handle_message(data)
    end
end

Mit Select

local ch = client:channel()
local timeout = time.after("30s")

while true do
    local r = channel.select {
        ch:case_receive(),
        timeout:case_receive()
    }

    if r.channel == timeout then
        client:ping()  -- Keep-Alive
        timeout = time.after("30s")
    else
        local data = json.decode(r.value.data)
        process(data)
    end
end

Nachrichtenobjekt

Verbindung schließen

-- Normales Schließen (Code 1000)
client:close()

-- Mit Code und Grund
client:close(websocket.CLOSE_CODES.NORMAL, "Session ended")

-- Fehler-Schließen
client:close(websocket.CLOSE_CODES.INTERNAL_ERROR, "Processing failed")

Gibt zurück: boolean, error

Konstanten

Nachrichtentypen

-- Numerisch (für send)
websocket.TEXT    -- 1
websocket.BINARY  -- 2

-- String (empfangener Nachrichtentyp-Feld)
websocket.TYPE_TEXT    -- "text"
websocket.TYPE_BINARY  -- "binary"
websocket.TYPE_PING    -- "ping"
websocket.TYPE_PONG    -- "pong"
websocket.TYPE_CLOSE   -- "close"

Komprimierungsmodi

websocket.COMPRESSION.DISABLED         -- 0 (keine Komprimierung)
websocket.COMPRESSION.CONTEXT_TAKEOVER -- 1 (gleitendes Fenster)
websocket.COMPRESSION.NO_CONTEXT       -- 2 (pro Nachricht)

Schließ-Codes

client:close(websocket.CLOSE_CODES.NORMAL, "Done")

Beispiele

Echtzeit-Chat

local function connect_chat(room_id, on_message)
    local client, err = websocket.connect("wss://chat.example.com/ws", {
        headers = {["Authorization"] = "Bearer " .. token}
    })
    if err then
        return nil, err
    end

    -- Raum beitreten
    client:send(json.encode({
        type = "join",
        room = room_id
    }))

    -- Nachrichtenschleife
    local ch = client:channel()
    while true do
        local msg, ok = ch:receive()
        if not ok then break end

        local data = json.decode(msg.data)
        on_message(data)
    end

    client:close()
end

Preis-Stream mit Keep-Alive

local client = websocket.connect("wss://stream.example.com/prices")

client:send(json.encode({
    action = "subscribe",
    symbols = {"BTC-USD", "ETH-USD"}
}))

local ch = client:channel()
local heartbeat = time.after("30s")

while true do
    local r = channel.select {
        ch:case_receive(),
        heartbeat:case_receive()
    }

    if r.channel == heartbeat then
        client:ping()
        heartbeat = time.after("30s")
    elseif not r.ok then
        break  -- Verbindung geschlossen
    else
        local price = json.decode(r.value.data)
        update_price(price.symbol, price.value)
    end
end

client:close()

Berechtigungen

WebSocket-Verbindungen unterliegen der Sicherheitsrichtlinienauswertung.

Sicherheitsaktionen

Siehe Sicherheitsmodell für Richtlinienkonfiguration.

Fehler

local client, err = websocket.connect(url)
if err then
    if errors.is(err, errors.PERMISSION_DENIED) then
        print("Access denied:", err:message())
    elseif err:retryable() then
        print("Temporary error:", err:message())
    end
    return nil, err
end

Siehe Fehlerbehandlung für die Arbeit mit Fehlern.