Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-server

Source of release 0.5.1

0.5.1 / src / internal / request_state.lucb

from internal.body import Body
import internal.lifecycle
from internal.model import Exchange, RequestData, State
from internal.response_data import Data
import internal.storage
from internal.storage import Buffer
import memory

pub func make_request(state: State*, http: bool = true) -> Exchange*!:
    let before = state.counters.outstanding.add(1, .acq_rel)
    if before >= state.config.network_threads * 4:
        _ = state.counters.outstanding.sub(1, .acq_rel)
        error(storage.limit, "too many outstanding server exchanges")
    errdefer _ = state.counters.outstanding.sub(1, .acq_rel)
    let exchange = try new Exchange(owner = state) in memory.heap
    errdefer free(exchange) in memory.heap
    if http:
        exchange.request = try new RequestData(
            wire = Buffer(maximum = 32768),
            path_buffer = Buffer(maximum = 8192),
            scratch = Buffer(maximum = 8192),
            loaded = Buffer(maximum = state.config.response_limit),
            payload = Body(bytes = Buffer(maximum = state.config.memory_body_limit), maximum = state.config.body_limit),
            reply = Data(bytes = Buffer(maximum = state.config.response_limit))) in memory.heap
    exchange.references.store(1, .relaxed)
    lifecycle.retain(state)
    return exchange

pub func retain_request(request: Exchange*):
    _ = request.references.add(1, .relaxed)

pub func release_request(request: Exchange*):
    if request.references.sub(1, .acq_rel) != 1:
        return
    let state = request.owner
    if let data = request.request:
        data.wire.destroy()
        data.path_buffer.destroy()
        data.scratch.destroy()
        data.loaded.destroy()
        data.payload.destroy()
        data.reply.close()
        free(data) in memory.heap
    free(request) in memory.heap
    _ = state.counters.outstanding.sub(1, .acq_rel)
    lifecycle.release(state)