net/websocket

import net.websocket
import encoding.json

mut server := websocket.Server {}

func chat():
    mut conn := websocket.Accept(server)
    mut name := ""
    until websocket.IsOpen(conn):
        msg := websocket.Receive(conn)
        if not websocket.IsText(msg): break end
        kind := json.Get(msg.text, "type")
        if kind == "join":
            name = json.Get(msg.text, "name")
            _ := websocket.SendText(conn, `{"type": "joined", "users": 1}`)
        else kind == "say":
            reply := `{"type": "said", "from": ` + json.Str(name) + `, "text": ` + json.Str(json.Get(msg.text, "text")) + `}`
            _ := websocket.SendText(conn, reply)
        else:
            _ := websocket.SendText(conn, `{"type": "error", "reason": "unknown type"}`)
        end
    end
    websocket.Close(conn)
end

func ask(c &: websocket.Conn, request: str): str:
    _ := websocket.SendText(c, request)
    ret websocket.ReceiveText(c)
end

func main:
    server = websocket.Listen(0)
    t := spawn(chat)
    mut c := websocket.Dial("127.0.0.1", websocket.Port(server), "/chat")
    joined := ask(c, `{"type": "join", "name": "Sara"}`)
    println json.Get(joined, "type"), "users:", json.GetInt(joined, "users")
    said := ask(c, `{"type": "say", "text": "salam \"everyone\""}`)
    println json.Get(said, "from"), "said:", json.Get(said, "text")
    println ask(c, `{"type": "dance"}`)
    websocket.Close(c)
    join(t)
    websocket.CloseServer(server)
end

import net.websocket
import str

mut server := websocket.Server {}
mut hub := websocket.NewHub()

func acceptor():
    repeat 3:
        conn := websocket.Accept(server)
        room := str.Replace(conn.path, "/rooms/", "")
        websocket.Register(hub, room, conn)
    end
end

func main:
    server = websocket.Listen(0)
    port := websocket.Port(server)
    t := spawn(acceptor)
    mut ali := websocket.Dial("127.0.0.1", port, "/rooms/news")
    mut sara := websocket.Dial("127.0.0.1", port, "/rooms/news")
    mut reza := websocket.Dial("127.0.0.1", port, "/rooms/sport")
    join(t)
    println "news:", websocket.RoomSize(hub, "news"), "sport:", websocket.RoomSize(hub, "sport")
    println "sent to", websocket.Broadcast(hub, "news", "rates are up"), "in news"
    println "sent to", websocket.Broadcast(hub, "sport", "2 to 1 at half time"), "in sport"
    println "ali:", websocket.ReceiveText(ali)
    println "sara:", websocket.ReceiveText(sara)
    println "reza:", websocket.ReceiveText(reza)
    println "nobody in chess:", websocket.Broadcast(hub, "chess", "hello")
    websocket.Close(ali)
    websocket.Close(sara)
    websocket.Close(reza)
    websocket.CloseServer(server)
end

import net.websocket
import str
import sync

mut server := websocket.Server {}
mut hub := websocket.NewHub()
mut lock := sync.NewMutex()

func announce(text: str):
    sync.Lock(lock)
    _ := websocket.Broadcast(hub, "lobby", text)
    sync.Unlock(lock)
end

func member():
    mut conn := websocket.Accept(server)
    if not websocket.IsOpen(conn): ret end
    name := str.Replace(conn.path, "/chat/", "")
    entry := conn
    sync.Lock(lock)
    websocket.Register(hub, "lobby", entry)
    sync.Unlock(lock)
    _ := websocket.SendText(conn, "welcome, " + name)
    until websocket.IsOpen(conn):
        m := websocket.Receive(conn)
        if not websocket.IsText(m): break end
        announce(name + ": " + m.text)
    end
    sync.Lock(lock)
    websocket.Unregister(hub, "lobby", entry)
    sync.Unlock(lock)
    announce(name + " left")
    websocket.Close(conn)
end

func main:
    server = websocket.Listen(0)
    port := websocket.Port(server)
    a := spawn(member)
    b := spawn(member)
    mut sara := websocket.Dial("127.0.0.1", port, "/chat/sara")
    println "sara got:", websocket.ReceiveText(sara)
    mut reza := websocket.Dial("127.0.0.1", port, "/chat/reza")
    println "reza got:", websocket.ReceiveText(reza)

    _ := websocket.SendText(sara, "lunch at one?")
    println "sara got:", websocket.ReceiveText(sara)
    println "reza got:", websocket.ReceiveText(reza)

    websocket.Close(reza)
    println "sara got:", websocket.ReceiveText(sara)
    websocket.Close(sara)
    join(a)
    join(b)
    println "left in the lobby:", websocket.RoomSize(hub, "lobby")
    websocket.CloseServer(server)
    sync.Destroy(lock)
end

import net.websocket
import net.http

mut server := websocket.Server {}

func gate():
    repeat 2:
        mut conn := websocket.Accept(server)
        token := http.HeaderValue(conn.hdr, "authorization")
        if token == "Bearer sara-token":
            _ := websocket.SendText(conn, "welcome, sara")
            question := websocket.ReceiveText(conn)
            _ := websocket.SendText(conn, "you asked: " + question)
        else:
            _ := websocket.SendText(conn, "who are you?")
        end
        websocket.Close(conn)
    end
end

func attempt(port: int, extra: str):
    mut c := websocket.DialWith("127.0.0.1", port, "/live", extra)
    println "open:", websocket.IsOpen(c), "server says:", websocket.ReceiveText(c)
    if extra != "":
        _ := websocket.SendText(c, "any news?")
        println websocket.ReceiveText(c)
    end
    m := websocket.Poll(c, 2000)
    println "closed by the server:", websocket.IsClose(m)
end

func main:
    server = websocket.Listen(0)
    t := spawn(gate)
    attempt(websocket.Port(server), "Authorization: Bearer sara-token\r\n")
    attempt(websocket.Port(server), "")
    join(t)
    websocket.CloseServer(server)
end

import net.websocket
import time

mut server := websocket.Server {}

func worker():
    mut conn := websocket.Accept(server)
    time.Sleep(400)
    _ := websocket.SendText(conn, "report ready")
    until websocket.IsOpen(conn):
        m := websocket.Receive(conn)
        if websocket.IsClose(m) or m.kind == websocket.NONE: break end
    end
    websocket.Close(conn)
end

func main:
    server = websocket.Listen(0)
    t := spawn(worker)
    mut c := websocket.Dial("127.0.0.1", websocket.Port(server), "/jobs/42")
    mut idle := 0
    mut answer := ""
    until answer == "" and idle < 50:
        m := websocket.Poll(c, 100)
        if m.kind == websocket.TIMEOUT:
            idle += 1
            _ := websocket.Ping(c, "still here")
        else websocket.IsText(m):
            answer = m.text
        else websocket.IsClose(m):
            break
        end
    end
    println "answer:", answer
    println "pinged while waiting:", idle > 0
    websocket.Close(c)
    join(t)
    websocket.CloseServer(server)
end