dymokomi/luce-server
Source of release 0.5.1
## 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)