Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-server

Source of release 0.5.1

0.5.1 / src / router.lucb

## Routers own worker-local callbacks. Only copied route metadata is shared with
## transport threads; application owners never leave their runtime thread.

import interop
import internal.application_pool
from internal.application_pool import Application
import internal.dispatch_queue
from internal.model import Exchange, WorkKind
import internal.responses
from internal.routes import Kind, Table
import internal.storage
import request
import response
import route
from route import Route
import sessions.tcp_session as socket_api
import static_root
from static_root import StaticRoot
import sessions.websocket_session as websocket_api
import ownership

struct RouterState:
    var table: Table
    var handlers: (route.Handler?)[128]
    var websocket_handlers: (websocket_api.Handler?)[128]
    var socket_handler: socket_api.Handler?
    var frozen: bool

    func add(method: str, pattern: str, handler: route.Handler) -> !:
        if self.frozen or self.socket_handler != none:
            error(storage.conflict, "router is frozen after publishing its application")
        let index = try self.table.add(method, pattern)
        self.handlers[index] = handler.clone()

    func close():
        for index in 0..<self.handlers.length:
            if let handler = self.handlers[index]:
                self.handlers[index] = none
                handler.release()
        for index in 0..<self.websocket_handlers.length:
            if let callback = self.websocket_handlers[index]:
                self.websocket_handlers[index] = none
                callback.release()
        if let callback = self.socket_handler:
            self.socket_handler = none
            callback.release()
        self.table.destroy()

    func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
        for item in self.handlers:
            if let handler = item:
                handler.trace(visit, context)
        for item in self.websocket_handlers:
            if let callback = item:
                callback.trace(visit, context)
        if let callback = self.socket_handler:
            callback.trace(visit, context)

    func dispatch(pending: Exchange*) -> !:
        let scope = try request.open(pending)
        defer scope.release()
        defer scope.close()
        let lease = try scope.lease()
        defer lease.release()
        defer lease.invalidate()
        if pending.kind == WorkKind.websocket:
            let callback = self.websocket_handlers[pending.http().route_index] else error(storage.conflict, "WebSocket route has no handler")
            try websocket_api.dispatch(pending, callback, lease)
            RouterState.complete_session(pending)
            return
        if pending.kind == WorkKind.tcp:
            let callback = self.socket_handler else error(storage.conflict, "TCP server has no session handler")
            try socket_api.dispatch(pending, callback, lease)
            RouterState.complete_session(pending)
            return
        let view = try request.view(scope, lease)
        defer view.release()
        let handler = self.handlers[pending.http().route_index] else error(storage.conflict, "route has no handler")
        let outcome = handler.invoke(view)
        defer outcome.release()
        let reply = try outcome.get()
        let state = pending.owner
        state.dispatch.lock.lock()
        defer state.dispatch.lock.unlock()
        if pending.done or pending.expired or state.cancellation.is_requested():
            error(storage.closed, "request can no longer be answered")
        let data = try response.transfer(reply, state.config.response_limit)
        pending.http().reply.close()
        pending.http().reply = data
        pending.done = true
        state.dispatch.changed.broadcast()

    static func complete_session(pending: Exchange*):
        let state = pending.owner
        state.dispatch.lock.lock()
        pending.done = true
        state.dispatch.changed.broadcast()
        state.dispatch.lock.unlock()

    func run(ignored: unit) -> interop.Outcome[unit]:
        _ = ignored
        let state = application_pool.server() catch failure:
            return interop.Outcome[unit].failure(failure.code, interop.Owned[str](failure.message))
        while let pending = dispatch_queue.take(state):
            defer dispatch_queue.abandon(pending)
            let mark = ownership.mark()
            defer ownership.drain(mark)
            self.dispatch(pending) catch failure:
                _ = state.counters.failures.add(1, .relaxed)
                state.dispatch.lock.lock()
                if pending.session_connection != none:
                    pending.done = true
                    pending.abandoned = true
                    state.dispatch.changed.broadcast()
                elif not pending.done and not pending.expired and not state.cancellation.is_requested():
                    responses.content(pending, 500, "text/plain; charset=utf-8", b"handler failed") catch:
                        pending.abandoned = true
                    pending.done = true
                    state.dispatch.changed.broadcast()
                state.dispatch.lock.unlock()
        return interop.Outcome[unit].success(interop.Owned[unit](()))

let state_type: interop.Type[RouterState] = interop.Type[RouterState]("router state", RouterState.close, RouterState.trace)

pub struct Router:
    var state: interop.Reference[RouterState]?

    pub func init() -> !:
        self.state = try interop.Reference[RouterState].adopt(try new RouterState(), state_type)

    pub func add(value: interop.Reference[Route]) -> !:
        let callback = try route.get_handler(value)
        defer callback.release()
        try (try self.owner()).value().add(try route.get_method(value), try route.get_pattern(value), callback)

    pub func get(pattern: str, handler: route.Handler) -> !:
        try (try self.owner()).value().add("GET", pattern, handler)

    pub func post(pattern: str, handler: route.Handler) -> !:
        try (try self.owner()).value().add("POST", pattern, handler)

    pub func put(pattern: str, handler: route.Handler) -> !:
        try (try self.owner()).value().add("PUT", pattern, handler)

    pub func websocket(pattern: str, handler: websocket_api.Handler) -> !:
        let state = (try self.owner()).value()
        if state.frozen or state.socket_handler != none:
            error(storage.conflict, "router cannot accept WebSocket routes")
        let slot = try state.table.add("GET", pattern, Kind.websocket)
        state.websocket_handlers[slot] = handler.clone()

    pub func socket(handler: socket_api.Handler) -> !:
        let state = (try self.owner()).value()
        if state.frozen or state.socket_handler != none or state.table.count != 0:
            error(storage.conflict, "TCP router accepts exactly one session handler")
        state.socket_handler = handler.clone()

    pub func mount(prefix: str, root: interop.Reference[StaticRoot]) -> !:
        let state = (try self.owner()).value()
        if state.frozen:
            error(storage.conflict, "router is frozen after publishing its application")
        var directory = try static_root.duplicate(root)
        errdefer directory.destroy()
        let index = try state.table.add("GET", prefix, Kind.static_files)
        state.table.entries[index].root = directory

    ## Called once by the named factory. The returned callback retains this
    ## router's state and runs on that factory's application worker.
    pub func application() -> Application!:
        let native = (try self.owner()).value()
        if native.frozen:
            error(storage.conflict, "router was already published")
        let server = try application_pool.server()
        try application_pool.register_router()
        if application_pool.first():
            server.config.raw_socket = native.socket_handler != none
            server.table = native.table
            native.table = Table()
        else:
            if (native.socket_handler != none) != server.config.raw_socket or native.table.count != server.table.count:
                error(storage.conflict, "application workers declared different routes")
            for index in 0..<native.table.count:
                let actual = native.table.entries[index]
                let expected = server.table.entries[index]
                if actual.method != expected.method or actual.pattern != expected.pattern or actual.kind != expected.kind:
                    error(storage.conflict, "application workers declared different routes")
                if actual.kind == Kind.static_files:
                    let first = try expected.root.metadata()
                    let next = try actual.root.metadata()
                    if first.device != next.device or first.inode != next.inode:
                        error(storage.conflict, "application workers declared different static roots")
            native.table.destroy()
        native.frozen = true
        return try Application.bind(try self.owner(), RouterState.run)

    func owner() -> interop.Reference[RouterState]!:
        return self.state else error(storage.closed, "router is closed")

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

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

pub let router_type: interop.Type[Router] = interop.Type[Router]("Router", Router.close, Router.trace, closeable = true)