Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / loader / tests_loader_5.lucb

#==============================================================================================
#
#   tests_loader_5 - a loopback HTTP/1.1 server for the non-blocking in-process client: keep-
#   alive connections served concurrently, slow and stalled responses, TLS
#
#   DESCRIPTION:
#       tests_loader_3.lucb's server answers one connection at a time and closes it; the
#       non-blocking client needs more: a server on 127.0.0.1 (luce-std net, the C heap) that
#       accepts on a thread of its own and serves every connection on a thread of its own,
#       request after request while the client keeps the connection alive, optionally over
#       TLS (luce-tls's Stream.accept_tls with a self-signed certificate minted for
#       localhost). It counts the connections it accepted and the most it served at once, and
#       answers by path: a small body (/keep, /id: the connection's number), a body dripped a
#       few bytes at a time (/drip), a large gzip body sent chunked in pieces
#       (/chunked-gzip), a large body (/big), a response that closes the connection without
#       saying so (/close), and no response at all until the client goes away (/hang).
#       tests_loader_6.lucb has the tests.
#
#==============================================================================================

# mark: The server ==============================================================================

## The server's state, in the C heap.
struct NetTestServer:
    var listener: net.Listener
    var port: u16
    var secure: bool
    var certificate: u8[2048]
    var certificate_length: usize
    var key: u8[32]
    var issuer_x: u8[32]
    var issuer_y: u8[32]
    var gzip_body: u8[]
    var stopping: @u64
    ## Connections accepted, served now, the most served at once, and stalled requests the client abandoned.
    var accepted: @u64
    var active: @u64
    var most_active: @u64
    var abandoned: @u64
    var accept_thread: thread.Handle

## The bytes of the body /big sends: 1 MiB of a pattern.
let net_test_big_size: usize = 1048576

## The byte of /big's body at `index`.
func net_test_big_byte(index: usize) -> u8:
    return (u8)((index * 7 + index // 251) % 256)

## The text of /chunked-gzip's body: 4000 numbered lines.
func net_test_gzip_text() -> u8[]:
    var builder = ak.string_builder_new()
    for line in 0..<4000:
        ak.string_builder_append(&builder, "line ")
        loader_test_append_number(&builder, (i64)line)
        ak.string_builder_append(&builder, " of the streamed gzip body\n")
    let text = ak.string_builder_to_byte_string(&builder)
    let bytes = ak.byte_string_bytes(&text)
    let copy = (new u8[bytes.length] --- in memory.heap) else trap("out of memory")
    memory.copy(copy, bytes, bytes.length)
    return copy

## What one connection's thread serves: the server and its connection's number.
struct NetTestConnection:
    var server: NetTestServer*
    var connection: net.Connection
    var number: u64

## Reads a request's head (and its Content-Length body) into `buffer`; answers its target, or none at the end of the
## stream.
func net_test_read_request(stream: tls_stream.Stream*, buffer: u8[], used: usize*) -> str?:
    while true:
        if let end = net.http_head_end(buffer[..<*used]):
            let body_length = loader_test_server_content_length(buffer[..<end])
            while *used < end + body_length:
                let count = stream.read(buffer[*used..]) catch: return none
                if count == 0:
                    return none
                *used += count
            var first: usize = 0
            while first < end and buffer[first] != ' ':
                first += 1
            var second = first + 1
            while second < end and buffer[second] != ' ':
                second += 1
            let target = (str)buffer[first + 1..<second]
            return target
        if *used == buffer.length:
            return none
        let count = stream.read(buffer[*used..]) catch: return none
        if count == 0:
            return none
        *used += count

## Writes all of `bytes`; false when the client went away.
func net_test_write(stream: tls_stream.Stream*, bytes: const u8[]) -> bool:
    _ = stream.write(bytes) catch: return false
    return true

## Answers one request for `target`; false when the connection must close afterwards.
func net_test_answer(served: NetTestConnection*, stream: tls_stream.Stream*, target: str) -> bool:
    let server = served.server
    if target == "/keep":
        return net_test_write(stream, b"HTTP/1.1 200 OK\r\nContent-Length: 4\r\n\r\nkeep")
    if target == "/id":
        var head: u8[64] = ---
        var text: u8[20] = ---
        var digits: usize = 0
        var number = served.number
        while digits == 0 or number > 0:
            text[19 - digits] = '0' + (u8)(number % 10)
            number = number // 10
            digits += 1
        let prefix = "HTTP/1.1 200 OK\r\nContent-Length: "
        memory.copy(head, prefix.bytes, prefix.length)
        var length = prefix.length
        head[length] = '0' + (u8)digits
        memory.copy(head[length + 1..], b"\r\n\r\n", 4)
        length += 5
        memory.copy(head[length..], text[20 - digits..], digits)
        length += digits
        return net_test_write(stream, head[..<length])
    if target == "/drip":
        if not net_test_write(stream, b"HTTP/1.1 200 OK\r\nContent-Length: 100\r\n\r\n"):
            return false
        for _ in 0..<10:
            thread.sleep(30)
            if not net_test_write(stream, b"0123456789"):
                return false
        return true
    if target == "/chunked-gzip":
        if not net_test_write(stream, b"HTTP/1.1 200 OK\r\nContent-Encoding: gzip\r\nTransfer-Encoding: chunked\r\n\r\n"):
            return false
        let body = server.gzip_body
        var at: usize = 0
        var piece: usize = 1
        while at < body.length:
            let size = body.length - at if body.length - at < piece else piece
            var line: u8[16] = ---
            let digits = "0123456789abcdef"
            var count: usize = 0
            var rest = size
            var reversed: u8[16] = ---
            while count == 0 or rest > 0:
                reversed[count] = digits.bytes[rest % 16]
                rest = rest // 16
                count += 1
            for index in 0..<count:
                line[index] = reversed[count - 1 - index]
            line[count] = '\r'
            line[count + 1] = '\n'
            if not net_test_write(stream, line[..<count + 2]) or not net_test_write(stream, body[at..<at + size]) or not net_test_write(stream, b"\r\n"):
                return false
            at += size
            piece = piece * 3 + 1
            if piece < 64:
                thread.sleep(2)
        return net_test_write(stream, b"0\r\n\r\n")
    if target == "/big":
        if not net_test_write(stream, b"HTTP/1.1 200 OK\r\nContent-Length: 1048576\r\n\r\n"):
            return false
        var block: u8[65536] = ---
        var at: usize = 0
        while at < net_test_big_size:
            for index in 0..<block.length:
                block[index] = net_test_big_byte(at + index)
            if not net_test_write(stream, block):
                return false
            at += block.length
        return true
    if target == "/close":
        _ = net_test_write(stream, b"HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\nclose")
        return false
    if target == "/hang":
        # Nothing until the client goes away (its read answers the end of the stream).
        var buffer: u8[64] = ---
        while true:
            let count = stream.read(buffer) catch: break
            if count == 0:
                break
        _ = server.abandoned.add(1, .acq_rel)
        return false
    _ = net_test_write(stream, b"HTTP/1.1 404 Not Found\r\nContent-Length: 0\r\n\r\n")
    return true

## One connection's thread: requests until the client closes the connection (or a response closes it).
func net_test_serve(context: void*?):
    let served = (NetTestConnection*)(context else trap("no connection"))
    let server = served.server
    let active = server.active.add(1, .acq_rel) + 1
    var most = server.most_active.load(.acquire)
    while active > most:
        let (swapped, seen) = server.most_active.cas(most, active, .acq_rel, .acquire)
        if swapped:
            break
        most = seen
    var stream = tls_stream.Stream.plain(served.connection)
    var usable = true
    if server.secure:
        stream.accept_tls(server.certificate[..<server.certificate_length], server.key) catch:
            usable = false
    var buffer: u8[8192] = ---
    while usable:
        var used: usize = 0
        let target = net_test_read_request(&stream, buffer, &used) else break
        if not net_test_answer(served, &stream, target):
            break
    _ = stream.close() catch: recover ()
    _ = server.active.add(0xFFFFFFFFFFFFFFFF, .acq_rel)
    free(served) in memory.heap

## The accepting thread: a thread per connection until the server stops.
func net_test_accept(context: void*?):
    let server = (NetTestServer*)(context else trap("no server"))
    while server.stopping.load(.acquire) == 0:
        let connection = server.listener.accept() catch: return
        if server.stopping.load(.acquire) != 0:
            var unused = connection
            unused.destroy()
            return
        let number = server.accepted.add(1, .acq_rel) + 1
        let served = (new NetTestConnection(server = server, connection = connection, number = number) in memory.heap) else trap("out of memory")
        let handle = thread.spawn(net_test_serve, served, name = "net-test-connection") else trap("a connection's thread")
        handle.detach()

## A server on 127.0.0.1, over TLS when `secure`, accepting on its own thread.
func net_test_server_start(secure: bool = false) -> NetTestServer*:
    with memory.heap:
        let listener = net.Listener.bind(net.SocketAddress.loopback(0)) else trap("the server's listener")
        let address = listener.address() else trap("the server's address")
        let server = new NetTestServer(listener = listener, port = address.port, secure = secure) else trap("out of memory")
        let text = net_test_gzip_text()
        server.gzip_body = compress_gzip.encode(text, 6) else trap("the gzip body")
        free(text) in memory.heap
        if secure:
            crypto.ecdsa_p256_keygen(server.key, server.issuer_x, server.issuer_y) else trap("a key")
            server.certificate_length = tls_x509.mint_self_signed("localhost", server.key, server.issuer_x, server.issuer_y, server.certificate) else trap("a certificate")
        server.accept_thread = thread.spawn(net_test_accept, server, name = "net-test-server") else trap("the server's thread")
        return server

## The end of a server: it stops accepting, waits (at most five seconds) for its connections' threads to end, and is
## freed. The client must have closed its connections first.
func net_test_server_stop(server: NetTestServer*):
    server.stopping.store(1, .release)
    with memory.heap:
        # Wake the accepting thread with one last connection.
        var wake = net.Connection.connect(net.SocketAddress.loopback(server.port)) catch: recover net.Connection()
        wake.destroy()
    var joined = server.accept_thread
    joined.join() else trap("the server's thread joins")
    var waited = 0
    while server.active.load(.acquire) > 0 and waited < 500:
        thread.sleep(10)
        waited += 1
    assert(server.active.load(.acquire) == 0, "the server's connections ended")
    server.listener.destroy()
    free(server.gzip_body) in memory.heap
    free(server) in memory.heap

## `http(s)://<host>:<port><path>` on `server`.
func net_test_url(server: const NetTestServer*, path: str, host: str = "127.0.0.1") -> ak.ByteString:
    var builder = ak.string_builder_new()
    ak.string_builder_append(&builder, "https://" if server.secure else "http://")
    ak.string_builder_append(&builder, host)
    ak.string_builder_append(&builder, ":")
    loader_test_append_number(&builder, (i64)server.port)
    ak.string_builder_append(&builder, path)
    return ak.string_builder_to_byte_string(&builder)

## Starts a GET of `path` on `server` through `client`.
func net_test_get(client: InProcessRequestClient*, server: const NetTestServer*, path: str, host: str = "127.0.0.1") -> (LoaderTestSeamLog*, RequestsRequest*):
    let url = net_test_url(server, path, host)
    return loader_test_start(client, ak.string_view_text(ak.byte_string_view(&url)))