dymokomi/luce-server
Source of release 0.5.1
0.5.1 / src / internal / http_connection.lucb
## One persistent HTTP connection, owned by one Base network thread. Completed
## requests are serialized on the wire, including pipelined input already read.
import io
import internal.dispatch_queue
import internal.lifecycle
from internal.model import Exchange, State, WorkKind
import internal.request_state
import internal.responses
from internal.routes import Kind
import internal.static_files
from internal.storage import Buffer
import internal.url
import internal.wire
from internal.wire import Input
import memory
from luce_std import net
func allowed(request: Exchange*) -> bool!:
var methods: str[128]
var count: usize = 0
var output = Buffer(maximum = 4096)
defer output.destroy()
var get = false
for entry in request.owner.table.entries[..<request.owner.table.count]:
if entry.kind == Kind.static_files or not url.matches(entry.pattern, request.http().path):
continue
var present = false
for previous in methods[..<count]:
if entry.method == previous:
present = true
if present:
continue
methods[count] = entry.method
count += 1
if output.used > 0:
try output.append(", ".bytes)
try output.append(entry.method.bytes)
if entry.method == "GET":
get = true
if count == 0:
return false
var head = false
var options = false
for item in methods[..<count]:
if item == "HEAD": head = true
if item == "OPTIONS": options = true
if get and not head:
try output.append(", HEAD".bytes)
if not options:
try output.append(", OPTIONS".bytes)
try responses.field(request, "Allow", (str)output.view())
return true
func automatic(request: Exchange*) -> !:
if try allowed(request):
let status: i64 = 204 if request.http().head.method == "OPTIONS" else 405
try responses.content(request, status, "text/plain; charset=utf-8", "".bytes)
else:
try responses.content(request, 404, "text/plain; charset=utf-8", "not found\n".bytes)
pub func serve(connection: net.Connection*, state: State*, final_started: bool*) -> !:
let input = try new Input() in memory.heap
defer free(input) in memory.heap
var served: usize = 0
while not state.cancellation.is_requested() and not state.lifecycle.draining.load(.acquire) and served < state.config.requests_per_connection:
*final_started = false
var idle = try wire.stream(connection, state, state.config.idle_timeout_ms)
if input.available().length == 0 and not try input.fill(&idle):
return
var source = try wire.stream(connection, state, state.config.request_timeout_ms)
let head_bytes = try input.head(&source) else return
let request = try request_state.make_request(state)
defer request_state.release_request(request)
try request.http().wire.append(head_bytes)
input.consume(head_bytes.length)
request.http().head = try net.http_parse_request(request.http().wire.view(), request.http().fields, net.HttpLimits(body_bytes = (u64)state.config.body_limit))
request.http().path = try url.request_path(request.http().head.target, &request.http().path_buffer)
let route = state.table.find(request.http().head.method, request.http().path)
let mount = state.table.mount(request.http().path)
if route == none and (mount == none or state.table.contains_path(request.http().path)):
try automatic(request)
var destination = try wire.stream(connection, state, state.config.response_timeout_ms)
*final_started = true
try responses.send(&destination, request, false)
_ = state.counters.completed.add(1, .relaxed)
return
if request.http().head.expect_continue:
try io.write_all(&source, "HTTP/1.1 100 Continue\r\n\r\n".bytes)
try wire.read_body(input, &source, request)
if let index = route:
request.http().route_index = index
if state.table.entries[index].kind == Kind.websocket:
_ = try net.websocket_check_request(request.http().head)
request.kind = WorkKind.websocket
if request.kind == WorkKind.websocket:
request.session_connection = connection
request.session_input = (void*)input
# The session handler owns all subsequent wire output. submit
# keeps these borrowed pointers alive until that handler exits.
*final_started = true
if not dispatch_queue.submit(request):
if not request.claimed:
wire.fail(connection, state, 503)
return
if not dispatch_queue.submit(request):
*final_started = true
wire.fail(connection, state, 503)
return
else:
let index = mount else trap("request lost its static mount")
static_files.serve(request, &state.table.entries[index]) catch failure:
request.http().reply.headers.clear()
request.http().reply.field_count = 0
try responses.content(request, 500, "text/plain; charset=utf-8", "file unavailable\n".bytes)
served += 1
let keep = request.http().head.keep_alive and not request.http().reply.close_after and not request.http().reply.stop_after and not state.lifecycle.draining.load(.acquire) and served < state.config.requests_per_connection
var destination = try wire.stream(connection, state, state.config.response_timeout_ms)
*final_started = true
try responses.send(&destination, request, keep)
_ = state.counters.completed.add(1, .relaxed)
if request.http().reply.stop_after:
lifecycle.begin_drain(state)
if not keep:
return