dymokomi/luce-std
Source of release 0.7.3
0.7.3 / tests / http / server.lucb
## A multi-threaded HTTP server: a listener thread accepts, a pool of workers
## serves. Static files come from a root directory; `/echo` returns a POST body;
## `/stats` reports counters; `/quit` stops the server.
##
## http [--port N] [--root DIR] [--threads N]
import c
import files
import http
import memory
import net
import paths
import pool
import process
import strings
import thread
pub let max_request: usize = 65536
struct Stats:
var requests: @u64
var bytes_out: @u64
var errors: @u64
struct Server:
var root: str
var port: u16
var stats: Stats
var stopping: @bool
var queue: pool.Queue
var server: Server
## One connection: read requests until the client closes or asks to.
func serve(connection: net.Connection):
var live = connection
defer live.destroy()
var buffer: u8[65536]
var used: usize = 0
while true:
# a request may arrive in pieces, and a pipelined one may follow in the same read
var end = http.header_end(buffer[..<used])
while end == none:
if used == max_request:
fail(&live, 413)
return
let n = live.read(buffer[used..]) catch:
return
if n == 0:
return
used += n
end = http.header_end(buffer[..<used])
let head_end = end else return
var request = http.parse(buffer[..<used], head_end) catch:
fail(&live, 400)
return
let length = request.content_length()
if head_end + length > max_request:
fail(&live, 413)
return
while used < head_end + length:
let n = live.read(buffer[used..]) catch:
return
if n == 0:
return
used += n
request.body = buffer[head_end..<head_end + length]
_ = server.stats.requests.add(1, .relaxed)
let keep = handle(&live, &request) catch failure:
_ = server.stats.errors.add(1, .relaxed)
print(f"error: {failure.message}")
return
if not keep:
return
# keep the bytes of a pipelined request that arrived with this one
let consumed = head_end + length
let rest = used - consumed
if rest > 0:
memory.move(buffer[..<rest], buffer[consumed..<used], rest)
used = rest
func fail(connection: net.Connection*, status: u32):
_ = server.stats.errors.add(1, .relaxed)
http.respond(connection, status, "text/plain", http.reason(status).bytes, false) catch:
return
## Route one request; the result says whether the connection stays open.
func handle(connection: net.Connection*, request: http.Request*) -> bool!:
let route = route_of(request.path)
if route == "/quit":
try http.respond(connection, 200, "text/plain", "bye\n".bytes, false)
server.stopping.store(true, .release)
# a connection to the listener wakes the accept loop so it can see the flag
var poke = net.Connection.connect(net.SocketAddress.loopback(server.port)) catch:
return false
try poke.close()
return false
if route == "/echo":
if request.method != "POST":
try http.respond(connection, 405, "text/plain", "POST only\n".bytes, request.keep_alive)
return request.keep_alive
try http.respond(connection, 200, "application/octet-stream", request.body, request.keep_alive)
return request.keep_alive
if route == "/stats":
var text: u8[256]
let body = try strings.format(text, f"{{\"requests\": {server.stats.requests.load(.relaxed)}, \"bytes_out\": {server.stats.bytes_out.load(.relaxed)}, \"errors\": {server.stats.errors.load(.relaxed)}}}\n")
try http.respond(connection, 200, "application/json", body.bytes, request.keep_alive)
return request.keep_alive
if request.method != "GET" and request.method != "HEAD":
try http.respond(connection, 405, "text/plain", "GET only\n".bytes, request.keep_alive)
return request.keep_alive
try serve_file(connection, request, route)
return request.keep_alive
## The path without its query.
func route_of(path: str) -> str:
let question = strings.find(path, "?") else return path
return (str)path.bytes[..<question]
## A file under the root; `/` is `index.html`; `..` never escapes the root.
func serve_file(connection: net.Connection*, request: http.Request*, route: str) -> !:
if strings.contains(route, "..") or strings.contains(route, "//"):
try http.respond(connection, 403, "text/plain", "forbidden\n".bytes, request.keep_alive)
return
let relative = "index.html" if route == "/" else (str)route.bytes[1..]
var name: u8[1024]
let path = try strings.format(name, f"{server.root}/{relative}")
let file = files.read((c.str)path) catch failure:
if failure.code == files.missing:
try http.respond(connection, 404, "text/plain", "not found\n".bytes, request.keep_alive)
return
try http.respond(connection, 500, "text/plain", "cannot read\n".bytes, request.keep_alive)
return
defer file.release()
let data = file.value
let body = data[..<0] if request.method == "HEAD" else data[0..]
try http.respond(connection, 200, http.content_type(route), body, request.keep_alive)
_ = server.stats.bytes_out.add((u64)body.length, .relaxed)
## `--port N`, `--root DIR`, `--threads N`.
struct Options:
var port: u16
var root: str
var threads: usize
func parse_options(arguments: str[]) -> Options!:
var options = Options(port = 8080, root = ".", threads = 4)
var i: usize = 1
while i + 1 < arguments.length:
let flag = arguments[i]
let value = arguments[i + 1]
if flag == "--port":
let n = strings.parse_i64(value) else error(bad_option, "--port needs a number")
options.port = (u16)n
elif flag == "--root":
options.root = value
elif flag == "--threads":
let n = strings.parse_i64(value) else error(bad_option, "--threads needs a number")
options.threads = (usize)n if n > 0 and n <= 64 else 4
else:
error(bad_option, "unknown option")
i += 2
return options
pub let bad_option: ErrorCode = ErrorCode.package(4)
pub func main(arguments: str[]) -> i32!:
let options = parse_options(arguments) catch failure:
print(f"http: {failure.message}")
print("usage: http [--port N] [--root DIR] [--threads N]")
return 2
server.root = options.root
var listener = try net.Listener.bind(net.SocketAddress.any(options.port))
let bound = (try listener.address())
server.port = bound.port
var worker = pool.Worker(queue = &server.queue, serve = serve)
var handles: thread.Handle[64]
try pool.start(&worker, options.threads, handles)
print(f"listening on {bound.port} with {options.threads} threads, serving {options.root}")
while not server.stopping.load(.acquire):
var connection = listener.accept() catch:
continue
if server.stopping.load(.acquire):
try connection.close()
break
server.queue.push(connection) catch:
# every slot taken: turn the client away rather than queue without bound
var busy = connection
http.respond(&busy, 500, "text/plain", "busy\n".bytes, false) catch:
_ = 0
try busy.close()
try pool.stop_all(&server.queue, handles, options.threads)
try listener.close()
print(f"served {server.stats.requests.load(.relaxed)} requests")
return 0