Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-server

Source of release 0.5.1

0.5.1 / src / sessions / websocket_session.lucb

## A WebSocket session is valid for its handler's scope. The handler can send
## before receiving; frame parsing, fragmentation and control replies stay here.

import interop
import io
import body
import internal.body as body_storage
import internal.lifecycle
from internal.model import Exchange
import internal.responses
import internal.storage
from internal.storage import Buffer
import internal.wire
from internal.wire import Input
import response
from response import Response
from luce_std import net
import ownership
import time
from luce_std import utf8

pub struct Message:
    var payload: interop.Reference[body.Body]?
    var text_message: bool

    pub func is_text() -> bool:
        return self.text_message

    pub func body() -> interop.Reference[body.Body]:
        return (self.payload else trap("WebSocket message is closed")).clone()

    pub func bytes(limit: i64 = 1048576) -> const u8[]!:
        return try (self.payload else error(storage.closed, "WebSocket message is closed")).value().bytes(limit)

    pub func text(limit: i64 = 1048576) -> str!:
        if not self.text_message:
            error(storage.invalid, "WebSocket message is binary")
        return try (self.payload else error(storage.closed, "WebSocket message is closed")).value().text(limit)

    pub func close():
        if let payload = self.payload:
            self.payload = none
            payload.release()

    pub func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
        if let payload = self.payload:
            payload.trace(visit, context)

pub let message_type: interop.Type[Message] = interop.Type[Message]("WebSocket message", Message.close, Message.trace, closeable = true)

pub struct Session:
    var state: SessionState*

    pub func header(name: str) -> str?!:
        let value = self.state.pending.http().head.field(name) else return none
        var decoder: utf8.Decoder
        for byte in value.bytes:
            _ = try decoder.push(byte)
        try decoder.finish()
        return value

    pub func accept(protocol: str = "") -> !:
        let state = self.state
        if state.accepted or state.closed:
            error(storage.closed, "WebSocket opening was already answered")
        var encoded: u8[4096]
        let head = try net.websocket_encode_response(encoded, state.pending.http().head, protocol)
        var destination = try wire.stream(state.connection, state.pending.owner, state.pending.owner.config.response_timeout_ms)
        try io.write_all(&destination, head)
        state.accepted = true

    pub func reject(reply: interop.Reference[Response]) -> !:
        let state = self.state
        if state.accepted or state.closed:
            error(storage.closed, "WebSocket opening was already answered")
        let data = try response.transfer(reply, state.pending.owner.config.response_limit)
        state.pending.http().reply.close()
        state.pending.http().reply = data
        state.closed = true
        var destination = try wire.stream(state.connection, state.pending.owner, state.pending.owner.config.response_timeout_ms)
        try responses.send(&destination, state.pending, false)

    pub func send_text(value: str) -> !:
        try self.state.send(net.WebSocketOpcode.text, value.bytes)

    pub func send_bytes(value: const u8[]) -> !:
        try self.state.send(net.WebSocketOpcode.binary, value)

    pub func send(value: interop.Reference[Message]) -> !:
        let message = try value.get()
        let bytes = try message.bytes((i64)self.state.pending.owner.config.response_limit)
        try self.state.send(net.WebSocketOpcode.text if message.is_text() else net.WebSocketOpcode.binary, bytes)

    pub func receive() -> interop.Reference[Message]?!:
        return self.state.receive() catch failure:
            self.state.report_error(failure.code)
            error(failure.code, failure.message)

    pub func close(code: u16 = 1000) -> !:
        try self.state.close(code)

    pub func shutdown_server():
        lifecycle.begin_drain(self.state.pending.owner)

pub let session_type: interop.ViewType[Session] = interop.ViewType[Session]("WebSocket session")
pub type Handler = interop.Callback[interop.View[Session], unit]

struct SessionState:
    var pending: Exchange*
    var connection: net.Connection*
    var input: Input*
    var decoder: net.WebSocketDecoder
    var encoder: net.WebSocketEncoder
    var accepted: bool
    var closed: bool

    func send(opcode: net.WebSocketOpcode, payload: const u8[]) -> !:
        if not self.accepted or self.closed:
            error(storage.closed, "WebSocket session is not open")
        var destination = try wire.stream(self.connection, self.pending.owner, self.pending.owner.config.response_timeout_ms)
        try self.encoder.write(&destination, opcode, payload)

    func receive() -> interop.Reference[Message]?!:
        if self.closed:
            return none
        if not self.accepted:
            error(storage.conflict, "accept the WebSocket before receiving messages")
        let server = self.pending.owner
        var payload = body_storage.Body(bytes = Buffer(maximum = server.config.memory_body_limit), maximum = server.config.body_limit)
        defer payload.destroy()
        var control = Buffer(maximum = 125)
        defer control.destroy()
        var output: u8[16384]
        var message_until: u64 = 0
        var text_message = false
        var message_started = false
        while not server.cancellation.is_requested():
            if server.lifecycle.draining.load(.acquire):
                try self.close(1001)
                return none
            if message_until != 0 and time.now() >= message_until:
                error(net.timed_out, "WebSocket message deadline expired")
            let deadline = net.Deadline.at(message_until) if message_until != 0 else try net.Deadline.after(server.config.idle_timeout_ms * 1000000)
            var source = try net.DeadlineStream.over(self.connection, deadline, &server.cancellation)
            if self.input.available().length == 0 and not try self.input.fill(&source):
                try self.decoder.finish()
                self.closed = true
                return none
            if message_until == 0:
                message_until = time.now() + server.config.request_timeout_ms * 1000000
            let step = try self.decoder.consume(self.input.available(), output)
            self.input.consume(step.consumed)
            if (u8)step.opcode >= 8:
                if step.frame_start:
                    control.clear()
                try control.append(output[..<step.written])
                if step.frame_end:
                    if step.opcode == net.WebSocketOpcode.ping:
                        try self.send(net.WebSocketOpcode.pong, control.view())
                    elif step.opcode == net.WebSocketOpcode.close:
                        try self.send(net.WebSocketOpcode.close, control.view())
                        self.closed = true
                        return none
                    if not message_started:
                        message_until = 0
                continue
            if step.frame_start and step.opcode != net.WebSocketOpcode.continuation:
                message_started = true
                text_message = step.opcode == net.WebSocketOpcode.text
            try payload.append(output[..<step.written], server.temporary_directory)
            if step.message_end:
                let owned_body = try body.take(&payload)
                let native = new Message(owned_body, text_message) catch failure:
                    owned_body.release()
                    error(failure.code, failure.message)
                return try interop.Reference[Message].adopt(native, message_type)
        error(net.cancelled, "WebSocket server stopped")

    func report_error(code: ErrorCode):
        if self.closed or not self.accepted:
            return
        var close_code: u16 = 1011
        if code == net.websocket_invalid:
            close_code = 1002
        elif code == utf8.invalid_sequence or code == utf8.incomplete_sequence:
            close_code = 1007
        elif code == net.websocket_limit or code == storage.limit:
            close_code = 1009
        elif code == net.cancelled or code == net.timed_out:
            close_code = 1001
        self.closed = true
        let deadline = net.Deadline.after(1000000000) catch:
            return
        var destination = net.DeadlineStream.over(self.connection, deadline) catch:
            return
        let payload: u8[2] = [(u8)(close_code >> 8), (u8)close_code]
        self.encoder.write(&destination, net.WebSocketOpcode.close, payload) catch: return

    func close(code: u16) -> !:
        if self.closed:
            return
        if not self.accepted:
            error(storage.conflict, "WebSocket has not been accepted")
        # A closing server gives its peer one bounded opportunity to acknowledge.
        var stream = try net.DeadlineStream.over(self.connection, try net.Deadline.after(1000000000))
        let payload: u8[2] = [(u8)(code >> 8), (u8)code]
        try self.encoder.write(&stream, net.WebSocketOpcode.close, payload)
        self.closed = true
        var discarded: u8[16384]
        while true:
            if self.input.available().length == 0:
                let filled = self.input.fill(&stream) catch: return
                if not filled:
                    return
            let step = self.decoder.consume(self.input.available(), discarded) catch: return
            self.input.consume(step.consumed)
            if step.opcode == net.WebSocketOpcode.close and step.frame_end:
                return

## Called only by the router while transport holds its connection/input alive.
pub func dispatch(pending: Exchange*, handler: Handler, lease: interop.Lease) -> !:
    let connection = pending.session_connection else trap("WebSocket has no connection")
    let input = (Input*)(pending.session_input else trap("WebSocket has no input"))
    let server = pending.owner
    var state = SessionState(pending, connection, input,
                             net.WebSocketDecoder.create(true, (u64)server.config.body_limit, (u64)server.config.body_limit),
                             net.WebSocketEncoder.create(false, (u64)server.config.response_limit, (u64)server.config.response_limit), false, false)
    let view = try interop.View[Session].make(Session(&state), session_type, lease)
    defer view.release()
    let result = handler.invoke(view)
    defer result.release()
    _ = result.get() catch failure:
        state.report_error(failure.code)
        error(failure.code, failure.message)
    if state.accepted:
        try state.close(1000)
    elif not state.closed:
        var destination = try wire.stream(connection, server, server.config.response_timeout_ms)
        try responses.content(pending, 403, "text/plain; charset=utf-8", b"WebSocket was not accepted")
        try responses.send(&destination, pending, false)