dymokomi/luce-server
Source of release 0.5.1
## Independent wire clients use the same object API as the Luce application.
## Factories build retained handlers on their application worker; no test thread
## attaches tokens or reaches into transport state.
from luce_server import http, websocket, socket
import interop
import ownership
import thread
from luce_json import json
import strings
var parallel_handlers: @u64
var peak_handlers: @u64
func failed(code: ErrorCode, message: str) -> interop.Outcome[interop.Reference[http.Response]]:
let copied = interop.copy_text(message) catch failure:
return interop.Outcome[interop.Reference[http.Response]].failure(failure.code, interop.Owned[str]("error text allocation failed"))
return interop.Outcome[interop.Reference[http.Response]].failure(code, copied)
func reply(text: str, status: i64 = 200) -> interop.Outcome[interop.Reference[http.Response]]:
let value = http.Response.bytes(text.bytes, "text/plain; charset=utf-8", status) catch failure:
return failed(failure.code, failure.message)
return interop.Outcome[interop.Reference[http.Response]].success(interop.Owned[interop.Reference[http.Response]](value, &value.owner.header))
func owned(value: interop.Reference[http.Response]) -> interop.Outcome[interop.Reference[http.Response]]:
return interop.Outcome[interop.Reference[http.Response]].success(interop.Owned[interop.Reference[http.Response]](value, &value.owner.header))
func session_failure(code: ErrorCode, message: str) -> interop.Outcome[unit]:
let copy = interop.copy_text(message) catch failure:
return interop.Outcome[unit].failure(failure.code, interop.Owned[str]("error text allocation failed"))
return interop.Outcome[unit].failure(code, copy)
struct Handlers:
var uploads: interop.Owned[str]
var retained_body: interop.Reference[http.Body]?
var expired_request: interop.View[http.Request]?
var expired_websocket: interop.View[websocket.Session]?
var expired_tcp: interop.View[socket.Session]?
func ping(view: interop.View[http.Request]) -> interop.Outcome[interop.Reference[http.Response]]:
_ = self
_ = view
var data = json.Value() catch failure: return failed(failure.code, failure.message)
defer data.close()
data.set_boolean("ok", true) catch failure: return failed(failure.code, failure.message)
let response = http.Response.bytes(data.encode().bytes, "application/json") catch failure: return failed(failure.code, failure.message)
return owned(response)
func echo(view: interop.View[http.Request]) -> interop.Outcome[interop.Reference[http.Response]]:
_ = self
let body = view.value().body() catch failure: return failed(failure.code, failure.message)
defer body.release()
let bytes = body.value().bytes(1048576) catch failure: return failed(failure.code, failure.message)
let response = http.Response.bytes(bytes) catch failure: return failed(failure.code, failure.message)
return owned(response)
func item(view: interop.View[http.Request]) -> interop.Outcome[interop.Reference[http.Response]]:
_ = self
return reply(view.value().parameter("id") else "missing")
func query(view: interop.View[http.Request]) -> interop.Outcome[interop.Reference[http.Response]]:
_ = self
let value = view.value().query("name") catch failure: return failed(failure.code, failure.message)
return reply(value else "missing")
func upload(view: interop.View[http.Request]) -> interop.Outcome[interop.Reference[http.Response]]:
var path: u8[4096]
let name = view.value().parameter("name") else "missing"
let destination = strings.format(path, f"{self.uploads.value}/{name}") catch failure: return failed(failure.code, failure.message)
let body = view.value().body() catch failure: return failed(failure.code, failure.message)
defer body.release()
body.value().save(destination) catch failure: return failed(failure.code, failure.message)
return reply("stored", 201)
func download(view: interop.View[http.Request]) -> interop.Outcome[interop.Reference[http.Response]]:
var path: u8[4096]
let name = view.value().parameter("name") else "missing"
let destination = strings.format(path, f"{self.uploads.value}/{name}") catch failure: return failed(failure.code, failure.message)
let response = http.Response.file(destination) catch failure: return failed(failure.code, failure.message)
return owned(response)
func shutdown(view: interop.View[http.Request]) -> interop.Outcome[interop.Reference[http.Response]]:
_ = self
_ = view
let response = http.Response.bytes(b"bye") catch failure: return failed(failure.code, failure.message)
response.value().shutdown_after() catch failure:
response.release()
return failed(failure.code, failure.message)
return owned(response)
func failure(view: interop.View[http.Request]) -> interop.Outcome[interop.Reference[http.Response]]:
_ = view
return failed(http.invalid_state, self.uploads.value)
func slow(view: interop.View[http.Request]) -> interop.Outcome[interop.Reference[http.Response]]:
_ = self
_ = view
thread.sleep(800)
return reply("late")
func parallel(view: interop.View[http.Request]) -> interop.Outcome[interop.Reference[http.Response]]:
_ = self
_ = view
let active = parallel_handlers.add(1, .acq_rel) + 1
var peak = peak_handlers.load(.acquire)
while peak < active:
let (changed, observed) = peak_handlers.cas(peak, active, .acq_rel, .acquire)
if changed:
break
peak = observed
thread.sleep(100)
_ = parallel_handlers.sub(1, .acq_rel)
var buffer: u8[64]
let text = strings.format(buffer, f"{peak_handlers.load(.acquire)}") catch failure: return failed(failure.code, failure.message)
return reply(text)
func retain(view: interop.View[http.Request]) -> interop.Outcome[interop.Reference[http.Response]]:
if let previous = self.expired_request:
assert(not previous.is_valid())
previous.release()
if let previous = self.retained_body:
previous.release()
self.expired_request = view.clone()
self.retained_body = view.value().body() catch failure: return failed(failure.code, failure.message)
return reply("retained")
func ws(view: interop.View[websocket.Session]) -> interop.Outcome[unit]:
if let previous = self.expired_websocket:
assert(not previous.is_valid())
previous.release()
self.expired_websocket = view.clone()
let session = view.value()
let origin = session.header("Origin") catch failure: return session_failure(failure.code, failure.message)
if origin == "http://blocked.test":
let response = http.Response.bytes(b"origin refused", status = 403) catch failure: return session_failure(failure.code, failure.message)
defer response.release()
session.reject(response) catch failure: return session_failure(failure.code, failure.message)
return interop.Outcome[unit].success(interop.Owned[unit](()))
session.accept() catch failure: return session_failure(failure.code, failure.message)
while true:
let next = session.receive() catch failure: return session_failure(failure.code, failure.message)
let message = next else break
defer message.release()
session.send(message) catch failure: return session_failure(failure.code, failure.message)
let bytes = message.value().bytes() catch failure: return session_failure(failure.code, failure.message)
if (str)bytes == "close":
session.close() catch failure: return session_failure(failure.code, failure.message)
break
return interop.Outcome[unit].success(interop.Owned[unit](()))
func ws_greeting(view: interop.View[websocket.Session]) -> interop.Outcome[unit]:
_ = self
let session = view.value()
session.accept() catch failure: return session_failure(failure.code, failure.message)
session.send_text("hello before input") catch failure: return session_failure(failure.code, failure.message)
let next = session.receive() catch failure: return session_failure(failure.code, failure.message)
if let message = next:
message.release()
return interop.Outcome[unit].success(interop.Owned[unit](()))
func tcp(view: interop.View[socket.Session]) -> interop.Outcome[unit]:
if let previous = self.expired_tcp:
assert(not previous.is_valid())
previous.release()
self.expired_tcp = view.clone()
let session = view.value()
while true:
let bytes = session.read() catch failure: return session_failure(failure.code, failure.message)
if bytes.length == 0:
break
session.write(bytes) catch failure: return session_failure(failure.code, failure.message)
if (str)bytes == "stop":
session.shutdown_server()
break
return interop.Outcome[unit].success(interop.Owned[unit](()))
func close():
if let view = self.expired_request:
assert(not view.is_valid())
let rejected: const http.Request*? = view.get() catch problem:
assert(problem.code == interop.expired)
recover none
assert(rejected == none)
view.release()
if let body = self.retained_body:
assert((body.value().text() catch failure: trap(failure.message)) == "retained payload")
assert((str)(body.value().read(3) catch failure: trap(failure.message)) == "ret")
assert((str)(body.value().read(64) catch failure: trap(failure.message)) == "ained payload")
assert((body.value().read() catch failure: trap(failure.message)).length == 0)
body.release()
if let view = self.expired_websocket:
assert(not view.is_valid())
view.release()
if let view = self.expired_tcp:
assert(not view.is_valid())
view.release()
self.uploads.release()
func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
self.uploads.trace(visit, context)
if let view = self.expired_request: view.trace(visit, context)
if let body = self.retained_body: body.trace(visit, context)
if let view = self.expired_websocket: view.trace(visit, context)
if let view = self.expired_tcp: view.trace(visit, context)
let handlers_type: interop.Type[Handlers] = interop.Type[Handlers]("test handlers", Handlers.close, Handlers.trace)
func register(router: http.Router*, handlers: interop.Reference[Handlers], method: str, pattern: str,
handler: func(const Handlers*, interop.View[http.Request]) -> interop.Outcome[interop.Reference[http.Response]]) -> !:
let callback = try http.Handler.bind(handlers, handler)
defer callback.release()
let native = try new http.Route(method, pattern, callback)
let declaration = interop.Type[http.Route]("test route", http.Route.close, http.Route.trace)
let route = try interop.Reference[http.Route].adopt(native, declaration)
defer route.release()
try router.add(route)
func configure(data: str, raw: bool) -> interop.Outcome[http.Application]:
let copy = interop.copy_text(data) catch failure: trap(failure.message)
let native = new Handlers(uploads = copy) catch failure: trap(failure.message)
let handlers = interop.Reference[Handlers].adopt(native, handlers_type) catch failure: trap(failure.message)
defer handlers.release()
var router = http.Router() catch failure: trap(failure.message)
defer router.close()
if raw:
let callback = socket.Handler.bind_mutating(handlers, Handlers.tcp) catch failure: trap(failure.message)
defer callback.release()
router.socket(callback) catch failure: trap(failure.message)
else:
register(&router, handlers, "GET", "/ping", Handlers.ping) catch failure: trap(failure.message)
register(&router, handlers, "POST", "/echo", Handlers.echo) catch failure: trap(failure.message)
register(&router, handlers, "GET", "/items/{id}", Handlers.item) catch failure: trap(failure.message)
register(&router, handlers, "GET", "/query", Handlers.query) catch failure: trap(failure.message)
register(&router, handlers, "PUT", "/upload/{name}", Handlers.upload) catch failure: trap(failure.message)
register(&router, handlers, "GET", "/files/{name}", Handlers.download) catch failure: trap(failure.message)
register(&router, handlers, "POST", "/shutdown", Handlers.shutdown) catch failure: trap(failure.message)
register(&router, handlers, "POST", "/failure", Handlers.failure) catch failure: trap(failure.message)
register(&router, handlers, "GET", "/slow", Handlers.slow) catch failure: trap(failure.message)
register(&router, handlers, "GET", "/parallel", Handlers.parallel) catch failure: trap(failure.message)
let retained = http.Handler.bind_mutating(handlers, Handlers.retain) catch failure: trap(failure.message)
defer retained.release()
router.post("/retain", retained) catch failure: trap(failure.message)
let ws = websocket.Handler.bind_mutating(handlers, Handlers.ws) catch failure: trap(failure.message)
defer ws.release()
router.websocket("/ws", ws) catch failure: trap(failure.message)
let greeting = websocket.Handler.bind(handlers, Handlers.ws_greeting) catch failure: trap(failure.message)
defer greeting.release()
router.websocket("/ws/greeting", greeting) catch failure: trap(failure.message)
let result = router.application() catch failure: trap(failure.message)
return interop.Outcome[http.Application].success(interop.Owned[http.Application](result, result.owner))
func http_factory(data: str) -> interop.Outcome[http.Application]:
return configure(data, false)
func tcp_factory(data: str) -> interop.Outcome[http.Application]:
return configure(data, true)
func exercise(arguments: str[]) -> !:
var options = http.ServerConfig(port = 0, network_workers = 8, application_workers = 2,
request_timeout_ms = 700, idle_timeout_ms = 700, application_timeout_ms = 300,
response_timeout_ms = 700, shutdown_timeout_ms = 250, memory_body_limit = 1024,
body_limit = 8388608, temporary_directory = arguments[2])
if arguments[3] == "lifetime":
options.memory_body_limit = 4
let raw = arguments[3] == "raw"
let factory = tcp_factory if raw else http_factory
var server = try http.Server(options, interop.WorkerEntry[str, unit, unit].native(factory), arguments[2])
defer server.close()
if not raw:
let native = try new http.StaticRoot(arguments[1])
let root = try interop.Reference[http.StaticRoot].adopt(native, interop.Type[http.StaticRoot]("test root", http.StaticRoot.close))
defer root.release()
try server.mount("/static", root)
try server.mount("/", root)
try server.shutdown_on_signals()
try server.start()
print(f"READY {try server.port()}")
try server.run()
print("STOPPED")
pub func main(arguments: str[]) -> i32!:
if arguments.length != 4:
return 2
try exercise(arguments)
return ownership.finish_run(0)