silk/http_server

Profiles: aarch64-apple-darwin, aarch64-unknown-linux-gnu, aarch64-unknown-linux-gnu-no-libc, wasm32-unknown-unknown, x86_64-unknown-linux-gnu, x86_64-unknown-linux-gnu-no-libc.

Scoped bounded streaming HTTP/1.0 and HTTP/1.1 server connections.

Details

withConnection binds one concrete byte provider and one buffered session for a serial connection lifetime. withRequest lends one request at a time; its parsed head, body decoder, response writer, and upgraded channel cannot escape their nested callbacks. Scope release closes abortively and never hides a protected exit behind flush or drain work.

Import as Connection with import silk.http_server { Connection }.

Public declarations: 22.

`ConnectionPhase`

pub enum ConnectionPhase

The externally visible connection lifecycle.

`Ready`

Ready = 0

Permits admission of the next request within the request budget.

`RequestActive`

RequestActive = 1

Permits request inspection, body reads, and response selection.

`Responding`

Responding = 2

Permits writes through the active response writer.

`Closing`

Closing = 3

Requires closure and forbids another request.

`Upgraded`

Upgraded = 4

Lends the channel to another protocol and forbids HTTP operations.

`Closed`

Closed = 5

Marks a completed connection with no further I/O permitted.

`Failed`

Failed = 6

Marks a terminal protocol or transport failure.

`BodyMode`

pub union BodyMode

The caller-selected response body delimiter.

`NoBody`

BodyMode.NoBody: BodyMode

Sends no response payload, including special responses such as HEAD and 204.

`ContentLength`

BodyMode.ContentLength { length: u64 }: BodyMode

Sends exactly the declared number of payload bytes.

Field `length`

pub length: u64

The exact payload length required before finish.

`Chunked`

BodyMode.Chunked: BodyMode

Uses HTTP/1.1 chunk framing and permits bounded trailers.

`CloseDelimited`

BodyMode.CloseDelimited: BodyMode

Uses connection closure as the payload delimiter and forbids reuse.

Implementation `Copy for BodyMode`

impl Copy for BodyMode

`ReusePolicy`

pub enum ReusePolicy

Persistence policy. A policy never overrides missing completion evidence.

`Automatic`

Automatic = 0

Uses HTTP/1.1 persistence when both message boundaries and peer policy permit it.

`CloseAfterResponse`

CloseAfterResponse = 1

Closes after this response regardless of peer persistence policy.

`Http10KeepAlive`

Http10KeepAlive = 2

Also permits HTTP/1.0 reuse when the peer explicitly requests keep-alive.

`Limits`

pub struct Limits

Finite server budgets and the exact lower-level limits they compose.

Field `head`

pub head: HeadLimits

The finite limits for request and response head parsing.

Field `body`

pub body: BodyLimits

The finite limits for body framing, payload, trailers, and owned decoder storage.

Field `values`

pub values: HeaderLimits

The limits for response values, including generated Connection fields.

Field `readCapacity`

pub readCapacity: usize

The positive fixed capacity of the input buffer.

Field `writeCapacity`

pub writeCapacity: usize

The positive fixed capacity of the output buffer.

Field `maxRequestsPerConnection`

pub maxRequestsPerConnection: usize

The maximum admitted requests; zero prevents any request-head read.

Field `maxInformationalResponses`

pub maxInformationalResponses: usize

The maximum explicit and automatic informational responses per request.

Field `maxDiscardWireBytes`

pub maxDiscardWireBytes: u64

The maximum wire bytes discarded by one request-body discard call.

Field `shutdownDrainBytes`

pub shutdownDrainBytes: usize

The maximum input bytes discarded by explicit connection finish.

Implementation `Copy for Limits`

impl Copy for Limits

`ServerLimitKind`

pub enum ServerLimitKind

Server-owned limits distinct from lower-level parser, value, and framing limits.

`InformationalResponses`

InformationalResponses = 0

The combined count of explicit and automatic informational responses.

`ServerError`

pub union ServerError

A precise server lifecycle failure preserving its lower-level cause.

`Head`

ServerError.Head { error: ParseError }: ServerError

A request or response head failed validation.

Field `error`

pub error: ParseError

The exact head parser failure.

`Body`

ServerError.Body { error: BodyError }: ServerError

A request or response body violated its framing contract.

Field `error`

pub error: BodyError

The framing failure and its committed progress.

`Buffer`

ServerError.Buffer { error: BufferError }: ServerError

A buffered transport operation failed.

Field `error`

pub error: BufferError

The buffer failure and any recorded transport progress.

`Output`

ServerError.Output { error: BufferError, progress: WriteProgress }: ServerError

Response framing advanced before buffered output failed.

Field `error`

pub error: BufferError

The failure from the buffered transport.

Field `progress`

pub progress: WriteProgress

The accepted payload, buffered prefix, and cumulative framing coordinates.

`Value`

ServerError.Value { error: ValueError }: ServerError

A response value or normalized header failed validation.

Field `error`

pub error: ValueError

The exact shared HTTP value failure.

`LimitExceeded`

ServerError.LimitExceeded { limit: ServerLimitKind, allowed: u64, attempted: u64 }: ServerError

An operation would exceed a finite server limit.

Field `limit`

pub limit: ServerLimitKind

The exhausted resource.

Field `allowed`

pub allowed: u64

The configured maximum for this resource.

Field `attempted`

pub attempted: u64

The count that the operation attempted to reach.

`SizeOverflow`

ServerError.SizeOverflow: ServerError

Checked count or byte arithmetic cannot represent the requested result.

`UnsupportedExpectation`

ServerError.UnsupportedExpectation: ServerError

A body operation encountered an unsupported request expectation.

`InvalidBodyMode`

ServerError.InvalidBodyMode: ServerError

The chosen body mode conflicts with the response framing or status.

`InvalidState`

ServerError.InvalidState { phase: ConnectionPhase }: ServerError

The requested operation is unavailable in the current phase.

Field `phase`

pub phase: ConnectionPhase

The phase that rejected the operation.

`UpgradeRejected`

ServerError.UpgradeRejected: ServerError

The request, selected protocol, or response cannot perform a generic Upgrade.

`TunnelRejected`

ServerError.TunnelRejected: ServerError

The request or response cannot perform a CONNECT tunnel handoff.

`TruncatedHead`

ServerError.TruncatedHead: ServerError

Input ended before a complete HTTP head became available.

`WriteProgress`

pub struct WriteProgress

Exact payload accepted by one response-writer call and framed bytes accepted by buffering.

Field `consumed`

pub consumed: usize

The caller payload prefix accepted during this writer call.

Field `buffered`

pub buffered: usize

The framed prefix accepted by the output buffer during this writer call.

Field `totalPayload`

pub totalPayload: u64

The cumulative payload bytes accepted by the response encoder.

Field `totalWire`

pub totalWire: u64

The cumulative framed bytes produced by the response encoder.

Implementation `Copy for WriteProgress`

impl Copy for WriteProgress

`Connection`

pub struct Connection<'connection, 'transport, P>

One affine serial server connection borrowing its concrete buffered channel.

Method `Connection.phase`

pub fn phase<'connection, 'transport, P, 'life3>(self: &'life3 Connection<'connection, 'transport, P>) -> ConnectionPhase

Returns the current connection phase.

Method `Connection.requests`

pub fn requests<'connection, 'transport, P, 'life3>(self: &'life3 Connection<'connection, 'transport, P>) -> usize

Returns the number of request heads admitted by this connection.

Method `Connection.unread`

pub fn unread<'connection, 'transport, P, 'life3>(self: &'life3 Connection<'connection, 'transport, P>) -> usize

Returns the exact byte count retained in the input buffer.

`Request`

pub struct Request<'request, 'connection, 'transport, P>

One callback-scoped active request and its single-message framing decoder.

Method `Request.head`

pub effect<'env> fn head<'request: 'env, 'connection: 'env, 'transport: 'env, P: 'env, 'head: 'env, 'env>(self: &'head Request<'request, 'connection, 'transport, P>) -> silk/http_head.RequestHead<'head> ! ServerError

Borrows the completed parsed head from active request storage.

Method `Request.bodyComplete`

pub effect<'env> fn bodyComplete<'request: 'env, 'connection: 'env, 'transport: 'env, P: 'env, 'life4: 'env, 'env>(self: &'life4 Request<'request, 'connection, 'transport, P>) -> bool ! ServerError

Returns whether request framing completed; fails unless the request remains active.

Method `Request.expectationRejected`

pub effect<'env> fn expectationRejected<'request: 'env, 'connection: 'env, 'transport: 'env, P: 'env, 'life4: 'env, 'env>(self: &'life4 Request<'request, 'connection, 'transport, P>) -> bool ! ServerError

Returns whether Expect requires rejection; fails unless the request remains active.

`ResponseWriter`

pub struct ResponseWriter<'writer, 'request, 'connection, 'transport, P>

One nested final-response writer. Its fields are private so completion cannot be forged.

Method `ResponseWriter.writeSome`

pub effect<'env> fn writeSome<'writer: 'env, 'request: 'env, 'connection: 'env, 'transport: 'env, P: 'env, 'life5: 'env, 'life6: 'env, 'env>(self: &'life5 mut ResponseWriter<'writer, 'request, 'connection, 'transport, P>, input: &'life6 [u8], deadline: silk/option.Option<silk/system_clock.Instant>) -> WriteProgress ! ServerError ? &mut MonotonicClock where &mut P provides &ByteDuplex from &mut ByteDuplex | &mut MonotonicClock

Accepts one payload prefix into the shared framing and bounded output owners.

Method `ResponseWriter.writeAll`

pub effect<'env> fn writeAll<'writer: 'env, 'request: 'env, 'connection: 'env, 'transport: 'env, P: 'env, 'life5: 'env, 'life6: 'env, 'env>(self: &'life5 mut ResponseWriter<'writer, 'request, 'connection, 'transport, P>, input: &'life6 [u8], deadline: silk/option.Option<silk/system_clock.Instant>) -> WriteProgress ! ServerError ? &mut MonotonicClock where &mut P provides &ByteDuplex from &mut ByteDuplex | &mut MonotonicClock

Accepts the complete caller payload in order.

Method `ResponseWriter.finish`

pub effect<'env> fn finish<'writer: 'env, 'request: 'env, 'connection: 'env, 'transport: 'env, P: 'env, 'value: 'env, 'life6: 'env, 'life7: 'env, 'env>(self: &'life6 mut ResponseWriter<'writer, 'request, 'connection, 'transport, P>, trailers: &'life7 silk/http_headers.Headers<'value>, deadline: silk/option.Option<silk/system_clock.Instant>) -> () ! ServerError ? &mut MonotonicClock where &mut P provides &ByteDuplex from &mut ByteDuplex | &mut MonotonicClock

Snapshots trailers, completes response framing, and flushes the response exactly once.

`ConnectionHandler`

pub interface ConnectionHandler<P, A, E, ?R>

Compile-time handler selected for one scoped server connection.

Operation `handle`

effect<'call> fn handle<'call: 'call, 'connection: 'call, 'transport: 'connection + 'call>(handler: Self, connection: &'call mut silk/http_server.Connection<'connection, 'transport, P>) -> A ! E ? R where &mut P provides &ByteDuplex from &mut ByteDuplex | &mut MonotonicClock

Runs within the connection loan and preserves the handler failure and requirement channels.

`validateLimits`

pub fn validateLimits<'life0>(limits: &'life0 silk/http_server.Limits) -> silk/result.Result<(), silk/http_server.ServerError>

Validates server-only construction invariants without allocation or I/O.

`withConnection`

pub effect<'env1> fn withConnection<'env: 'env1, A, E, ?CallbackRequirements, P: 'env1, H: 'env1, 'env1>(transport: &'env mut P, limits: Limits, handler: H) -> A ! E | ServerError | BufferError | OutOfMemoryError ? CallbackRequirements | &mut Allocator where &mut P provides &ByteDuplex from &mut ByteDuplex, &mut P provides &ByteDuplex from &mut ByteDuplex | &mut MonotonicClock, CallbackRequirements in Without<CallbackRequirements, &ByteDuplex>

Runs one higher-ranked server callback over a single bound concrete provider.

`withRequest`

pub effect<'env> fn withRequest<'request: 'env, 'connection: 'request + 'env, 'transport: 'connection + 'env, 'callback: 'env, A, E, ?CallbackRequirements, P: 'env, 'env>(connection: &'request mut silk/http_server.Connection<'connection, 'transport, P>, deadline: silk/option.Option<silk/system_clock.Instant>, callback: for<'call, 'requestView: 'call, 'connectionView: 'requestView, 'transportView: 'connectionView> once fn<'callback>(&'call mut silk/http_server.Request<'requestView, 'connectionView, 'transportView, P>) -> once Effect<'call; A ! E ? CallbackRequirements>) -> silk/option.Option<A> ! E | ServerError | OutOfMemoryError ? CallbackRequirements | &mut Allocator | &mut MonotonicClock where &mut P provides &ByteDuplex from &mut ByteDuplex | &mut MonotonicClock

Admits at most one request and lends it exclusively. None is clean end between requests.

`readSome`

pub effect<'env> fn readSome<'request: 'env, 'connection: 'env, 'transport: 'env, P: 'env, 'life4: 'env, 'life5: 'env, 'env>(request: &'life4 mut silk/http_server.Request<'request, 'connection, 'transport, P>, output: &'life5 mut [u8], deadline: silk/option.Option<silk/system_clock.Instant>) -> usize ! ServerError ? &mut MonotonicClock where &mut P provides &ByteDuplex from &mut ByteDuplex | &mut MonotonicClock

Reads one provisional decoded payload prefix.

`discardRemaining`

pub effect<'env> fn discardRemaining<'request: 'env, 'connection: 'env, 'transport: 'env, P: 'env, 'life4: 'env, 'env>(request: &'life4 mut silk/http_server.Request<'request, 'connection, 'transport, P>, maxWireBytes: u64, deadline: silk/option.Option<silk/system_clock.Instant>) -> () ! ServerError ? &mut MonotonicClock where &mut P provides &ByteDuplex from &mut ByteDuplex | &mut MonotonicClock

Explicitly discards the remaining framed request under the smaller configured/caller wire bound.

`finishConnection`

pub effect<'env> fn finishConnection<'connection: 'env, 'transport: 'env, P: 'env, 'life3: 'env, 'env>(connection: &'life3 mut silk/http_server.Connection<'connection, 'transport, P>, maxDrainBytes: usize, deadline: Instant) -> () ! ServerError ? &mut MonotonicClock where &mut P provides &ByteDuplex from &mut ByteDuplex | &mut MonotonicClock

Gracefully flushes, shuts down writes, and performs one finite best-effort input drain.

`sendInformational`

pub effect<'env> fn sendInformational<'request: 'env, 'connection: 'env, 'transport: 'env, 'value: 'env, P: 'env, 'life5: 'env, 'life6: 'env, 'env>(request: &'life5 mut silk/http_server.Request<'request, 'connection, 'transport, P>, head: &'life6 silk/http.ResponseHead<'value>, deadline: silk/option.Option<silk/system_clock.Instant>) -> () ! ServerError ? &mut MonotonicClock where &mut P provides &ByteDuplex from &mut ByteDuplex | &mut MonotonicClock

Sends one bounded informational response and flushes it before returning.

`respond`

pub effect<'env> fn respond<'writer: 'env, 'request: 'writer + 'env, 'connection: 'request + 'env, 'transport: 'connection + 'env, 'value: 'writer + 'env, 'names: 'request + 'env, 'callback: 'env, A, E, ?CallbackRequirements, P: 'env, 'life11: 'env, 'env>(request: &'writer mut silk/http_server.Request<'request, 'connection, 'transport, P>, head: &'life11 silk/http.ResponseHead<'value>, mode: BodyMode, reuse: ReusePolicy, trailerPolicy: silk/http_body.TrailerPolicy<'names>, deadline: silk/option.Option<silk/system_clock.Instant>, callback: for<'call, 'writerView: 'call, 'requestView: 'writerView, 'connectionView: 'requestView, 'transportView: 'connectionView> once fn<'callback>(&'call mut silk/http_server.ResponseWriter<'writerView, 'requestView, 'connectionView, 'transportView, P>) -> once Effect<'call; A ! E ? CallbackRequirements>) -> A ! E | ServerError | OutOfMemoryError ? CallbackRequirements | &mut Allocator | &mut MonotonicClock where &mut P provides &ByteDuplex from &mut ByteDuplex | &mut MonotonicClock

Begins exactly one final response and lends its streaming writer.

`reject`

pub effect<'env> fn reject<'loan: 'env, 'request: 'loan + 'env, 'connection: 'request + 'env, 'transport: 'connection + 'env, 'value: 'env, P: 'env, 'life6: 'env, 'env>(request: &'loan mut silk/http_server.Request<'request, 'connection, 'transport, P>, head: &'life6 silk/http.ResponseHead<'value>, deadline: silk/option.Option<silk/system_clock.Instant>) -> () ! ServerError | OutOfMemoryError ? &mut Allocator | &mut MonotonicClock where &mut P provides &ByteDuplex from &mut ByteDuplex | &mut MonotonicClock

Sends a final body-free response without waiting for unread request content.

`withUpgrade`

pub effect<'env> fn withUpgrade<'loan: 'env, 'request: 'loan + 'env, 'connection: 'request + 'env, 'transport: 'connection + 'env, 'value: 'loan + 'env, 'callback: 'env, A, E, ?CallbackRequirements, P: 'env, 'life10: 'env, 'life11: 'env, 'env>(request: &'loan mut silk/http_server.Request<'request, 'connection, 'transport, P>, selectedProtocol: string<'life10>, response: &'life11 silk/http.ResponseHead<'value>, deadline: silk/option.Option<silk/system_clock.Instant>, callback: for<'call, 'transportView: 'call> once fn<'callback>(&'call mut silk/buffered_duplex.BufferedDuplex<'transportView, P>) -> once Effect<'call; A ! E ? CallbackRequirements>) -> A ! E | ServerError | OutOfMemoryError ? CallbackRequirements | &mut Allocator | &mut MonotonicClock where &mut P provides &ByteDuplex from &mut ByteDuplex | &mut MonotonicClock

Completes a validated HTTP Upgrade response and lends the exact buffered suffix.

`withTunnel`

pub effect<'env> fn withTunnel<'loan: 'env, 'request: 'loan + 'env, 'connection: 'request + 'env, 'transport: 'connection + 'env, 'value: 'loan + 'env, 'callback: 'env, A, E, ?CallbackRequirements, P: 'env, 'life10: 'env, 'env>(request: &'loan mut silk/http_server.Request<'request, 'connection, 'transport, P>, response: &'life10 silk/http.ResponseHead<'value>, deadline: silk/option.Option<silk/system_clock.Instant>, callback: for<'call, 'transportView: 'call> once fn<'callback>(&'call mut silk/buffered_duplex.BufferedDuplex<'transportView, P>) -> once Effect<'call; A ! E ? CallbackRequirements>) -> A ! E | ServerError | OutOfMemoryError ? CallbackRequirements | &mut Allocator | &mut MonotonicClock where &mut P provides &ByteDuplex from &mut ByteDuplex | &mut MonotonicClock

Completes a successful CONNECT response and lends the exact buffered tunnel suffix.

silk/http_server

On this page