Luce packages
LuceLuce BaseLuciaOS

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