Imports

asyncloop, asyncsync, config, asyncstream, boundstream, chunkstream, httptable, httpcommon, multipart, common

Types

ByteChar = string | seq[byte]: Source Edit
ConnectionFence = Result[HttpConnectionRef, HttpProcessError]: Result type that can contain either a valid HttpConnectionRef or an HttpProcessError. Source Edit
HttpCloseConnectionCallback = proc (connection: HttpConnectionRef): Future[void] {. async: (...raises: []).}: Source Edit
HttpConnection = object of RootObj state*: HttpState server*: HttpServerRef transp*: StreamTransport mainReader*: AsyncStreamReader mainWriter*: AsyncStreamWriter reader*: AsyncStreamReader writer*: AsyncStreamWriter closeCb*: HttpCloseConnectionCallback createMoment*: Moment currentRawQuery*: Opt[string] buffer: seq[byte]: Source Edit
HttpConnectionCallback = proc (server: HttpServerRef; transp: StreamTransport): Future[ HttpConnectionRef] {.async: (...raises: [CancelledError, HttpConnectionError]).}: Source Edit
HttpConnectionHolder = object of RootObj connection*: HttpConnectionRef server*: HttpServerRef future*: Future[void] transp*: StreamTransport acceptMoment*: Moment connectionId*: string: Source Edit
HttpConnectionHolderRef = ref HttpConnectionHolder: Source Edit
HttpConnectionRef = ref HttpConnection: Source Edit
HttpProcessCallback = proc (req: RequestFence): Future[HttpResponseRef] {. ...gcsafe, raises: [].}: Source Edit
HttpProcessCallback2 = proc (req: RequestFence): Future[HttpResponseRef] {. async: (...raises: [CancelledError]).}: Source Edit
HttpProcessError = object kind*: HttpServerError code*: HttpCode exc*: ref HttpError remote*: Opt[TransportAddress]: Source Edit
HttpProcessExitType {.pure.} = enum KeepAlive, Graceful, Immediate: Source Edit
HttpRequest = object of RootObj state*: HttpState headers*: HttpTable query*: HttpTable postTable: Opt[HttpTable] rawPath*: string uri*: Uri scheme*: string version*: HttpVersion meth*: HttpMethod contentEncoding*: set[ContentEncodingFlags] transferEncoding*: set[TransferEncodingFlags] requestFlags*: set[HttpRequestFlags] contentLength*: int contentTypeData*: Opt[ContentTypeData] connection*: HttpConnectionRef response*: Opt[HttpResponseRef]: Source Edit
HttpRequestFlags {.pure.} = enum BoundBody, UnboundBody, MultipartForm, UrlencodedForm, ClientExpect: Source Edit
HttpRequestRef = ref HttpRequest: Source Edit
HttpResponse = object of RootObj status*: HttpCode version*: HttpVersion headersTable: HttpTable body: seq[byte] flags: set[HttpResponseFlags] state*: HttpResponseState connection*: HttpConnectionRef streamType*: HttpResponseStreamType writer: AsyncStreamWriter: Source Edit
HttpResponseFlags {.pure.} = enum KeepAlive, Stream: Source Edit
HttpResponseRef = ref HttpResponse: Source Edit
HttpResponseState {.pure.} = enum Empty, Prepared, Sending, Finished, Failed, Cancelled, ErrorCode, Default: Source Edit
HttpResponseStreamType {.pure.} = enum Plain, SSE, Chunked: Source Edit
HttpServer = object of RootObj instance*: StreamServer address*: TransportAddress maxConnections*: int backlogSize*: int baseUri*: Uri serverIdent*: string flags*: set[HttpServerFlags] socketFlags*: set[ServerFlags] connections*: OrderedTable[string, HttpConnectionHolderRef] acceptLoop*: Future[void].Raising([]) lifetime*: Future[void] headersTimeout*: Duration bufferSize*: int maxHeadersSize*: int maxRequestBodySize*: int processCallback*: HttpProcessCallback2 createConnCallback*: HttpConnectionCallback middlewares: seq[HttpProcessCallback2]: Source Edit
HttpServerError {.pure.} = enum InterruptError, TimeoutError, ProtocolError, DisconnectError: Source Edit
HttpServerFlags {.pure.} = enum Secure, ## Internal flag which indicates that server working in secure TLS mode NoExpectHandler, ## Do not handle `Expect` header automatically NotifyDisconnect, ## Notify user-callback when remote client disconnects. QueryCommaSeparatedArray, ## Enable usage of comma as an array item delimiter in url-encoded ## entities (e.g. query string or POST body). Http11Pipeline ## Enable persistent connections in HTTP/1.1 - the name refers to ## pipelining for historical reasons.: Source Edit
HttpServerMiddleware = object of RootObj handler*: MiddlewareHandleCallback: Source Edit
HttpServerMiddlewareRef = ref HttpServerMiddleware: Source Edit
HttpServerRef = ref HttpServer: Source Edit
HttpServerState {.pure.} = enum ServerRunning, ServerStopped, ServerClosed: Source Edit
MiddlewareHandleCallback = proc (middleware: HttpServerMiddlewareRef; request: RequestFence; handler: HttpProcessCallback2): Future[ HttpResponseRef] {.async: (...raises: [CancelledError]).}: Source Edit
RequestFence = Result[HttpRequestRef, HttpProcessError]: Result type that can contain either a valid HttpRequestRef or an HttpProcessError. Source Edit

Procs

proc addHeader(resp: HttpResponseRef; key, value: string) {....raises: [], tags: [].}

Adds value value to header's key value. Source Edit

proc closeWait(conn: HttpConnectionRef): InternalRaisesFuture[void, void] {.
    stackTrace: false, ...raises: [], gcsafe, raises: [], raises: [],
    tags: [RootEffect].}

Source Edit

proc closeWait(req: HttpRequestRef): InternalRaisesFuture[void, void] {.
    stackTrace: false, ...raises: [], gcsafe, raises: [], raises: [],
    tags: [RootEffect].}

Source Edit

proc closeWait(server: HttpServerRef): InternalRaisesFuture[void, void] {.
    stackTrace: false, ...raises: [], gcsafe, raises: [], raises: [],
    tags: [RootEffect].}

Stop HTTP server and drop all the pending connections. Source Edit

proc codeResponse(status: HttpCode): HttpResponseRef {....raises: [], tags: [].}

Source Edit

proc consumeBody(request: HttpRequestRef): InternalRaisesFuture[void,
    (CancelledError, HttpTransportError, HttpProtocolError)] {.
    stackTrace: false, ...raises: [], gcsafe, raises: [], raises: [],
    tags: [RootEffect].}

Consume/discard request's body. Source Edit

proc defaultResponse(): HttpResponseRef {....raises: [], tags: [].}

Create an empty response to return when request processor got no request. Source Edit

proc defaultResponse(err: HttpProcessError): HttpResponseRef {....raises: [],
    tags: [].}

Source Edit

proc defaultResponse(exc: ref CatchableError): HttpResponseRef {....raises: [],
    tags: [].}

Create response with error code based on exception type. Source Edit

proc defaultResponse(msg: HttpMessage): HttpResponseRef {....raises: [], tags: [].}

Source Edit

proc drop(server: HttpServerRef): InternalRaisesFuture[void, void] {.
    stackTrace: false, ...raises: [], gcsafe, raises: [], raises: [],
    tags: [RootEffect].}

Drop all pending HTTP connections. Source Edit

proc dropResponse(): HttpResponseRef {....raises: [], tags: [].}

Source Edit

proc dumbResponse(): HttpResponseRef {....deprecated: "Please use defaultResponse() instead",
                                       raises: [], tags: [].}

Deprecated: Please use defaultResponse() instead

Create an empty response to return when request processor got no request. Source Edit

proc error(e: HttpProcessError): HttpServerError {....raises: [], tags: [].}

Source Edit

proc finish(resp: HttpResponseRef): InternalRaisesFuture[void,
    (CancelledError, HttpWriteError)] {.stackTrace: false, ...raises: [], gcsafe,
                                        raises: [], raises: [],
                                        tags: [RootEffect].}

Sending last chunk of data, so it will indicate end of HTTP response. Source Edit

proc getAcceptInfo(request: HttpRequestRef): Result[AcceptInfo, cstring] {.
    ...raises: [], tags: [].}

Returns value of Accept header as AcceptInfo object.

If Accept header is missing in request headers, */* content type will be returned.

Source Edit

proc getBody(request: HttpRequestRef): InternalRaisesFuture[seq[byte],
    (CancelledError, HttpTransportError, HttpProtocolError)] {.
    stackTrace: false, ...raises: [], gcsafe, raises: [], raises: [],
    tags: [RootEffect].}

Obtain request's body as sequence of bytes. Source Edit

proc getBodyReader(request: HttpRequestRef): HttpResult[HttpBodyReader] {.
    ...raises: [], tags: [RootEffect].}

Returns stream's reader instance which can be used to read request's body.

Please be sure to handle Expect header properly.

Streams which was obtained using this procedure must be closed to avoid leaks.

Source Edit

proc getConnectionFence(server: HttpServerRef; transp: StreamTransport): InternalRaisesFuture[
    ConnectionFence, void] {.stackTrace: false, ...raises: [], gcsafe, raises: [],
                             raises: [], tags: [RootEffect].}

Source Edit

proc getHeader(resp: HttpResponseRef; key: string; default: string = ""): string {.
    ...raises: [], tags: [].}

Returns value of header with name name or default, if header is not present in the table. Source Edit

proc getHostname(server: HttpServerRef): string {....raises: [], tags: [].}

Source Edit

proc getMultipartReader(req: HttpRequestRef): HttpResult[MultiPartReaderRef] {.
    ...raises: [], tags: [RootEffect].}

Create new MultiPartReader interface for specific request. Source Edit

proc getRequestFence(server: HttpServerRef; connection: HttpConnectionRef): InternalRaisesFuture[
    RequestFence, void] {.stackTrace: false, ...raises: [], gcsafe, raises: [],
                          raises: [], tags: [RootEffect].}

Source Edit

proc getResponse(req: HttpRequestRef): HttpResponseRef {....raises: [], tags: [].}

Source Edit

proc getResponseState(response: HttpResponseRef): HttpResponseState {.
    ...raises: [], tags: [].}

Source Edit

proc gracefulCloseWait(conn: HttpConnectionRef): InternalRaisesFuture[void, void] {.
    stackTrace: false, ...raises: [], gcsafe, raises: [], raises: [],
    tags: [RootEffect].}

Source Edit

proc handleExpect(request: HttpRequestRef): InternalRaisesFuture[void,
    (CancelledError, HttpWriteError)] {.stackTrace: false, ...raises: [], gcsafe,
                                        raises: [], raises: [],
                                        tags: [RootEffect].}

Handle expectation for Expect header. https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Expect Source Edit

proc hasBody(request: HttpRequestRef): bool {....raises: [], tags: [].}

Returns true if request has body. Source Edit

proc hasHeader(resp: HttpResponseRef; key: string): bool {....raises: [], tags: [].}

Returns true if header with name key present in the headers table. Source Edit

proc init(value: var HttpConnection; server: HttpServerRef;
          transp: StreamTransport) {....raises: [], tags: [].}

Source Edit

proc join(server: HttpServerRef): InternalRaisesFuture[void, (CancelledError,)] {.
    stackTrace: false, ...raises: [], gcsafe, raises: [], raises: [],
    tags: [RootEffect].}

Source Edit

proc keepalive(resp: HttpResponseRef): bool {....raises: [], tags: [].}

Source Edit

proc keepalive=(resp: HttpResponseRef; value: bool) {....raises: [], tags: [].}

Source Edit

proc local(request: HttpRequestRef): Opt[TransportAddress] {....raises: [],
    tags: [].}

Returns local address of HTTP request's connection. Source Edit

proc new(htype: typedesc[HttpServerRef]; address: TransportAddress;
         processCallback: HttpProcessCallback2;
         serverFlags: set[HttpServerFlags] = {};
         socketFlags: set[ServerFlags] = {ReuseAddr}; serverUri = Uri();
         serverIdent = ""; maxConnections: int = -1;
         bufferSize: int = chronosTransportDefaultBufferSize;
         backlogSize: int = DefaultBacklogSize; httpHeadersTimeout = 10.seconds;
         maxHeadersSize: int = 8192; maxRequestBodySize: int = 1048576;
         dualstack = DualStackType.Auto;
         middlewares: openArray[HttpServerMiddlewareRef] = []): HttpResult[
    HttpServerRef] {....raises: [].}

Source Edit

proc new(htype: typedesc[HttpServerRef]; address: TransportAddress;
         processCallback: HttpProcessCallback;
         serverFlags: set[HttpServerFlags] = {};
         socketFlags: set[ServerFlags] = {ReuseAddr}; serverUri = Uri();
         serverIdent = ""; maxConnections: int = -1;
         bufferSize: int = chronosTransportDefaultBufferSize;
         backlogSize: int = DefaultBacklogSize; httpHeadersTimeout = 10.seconds;
         maxHeadersSize: int = 8192; maxRequestBodySize: int = 1048576;
         dualstack = DualStackType.Auto;
         middlewares: openArray[HttpServerMiddlewareRef] = []): HttpResult[
    HttpServerRef] {....deprecated: "Callback could raise only CancelledError, annotate with {.async: (raises: [CancelledError]).}",
                     raises: [].}

Deprecated: Callback could raise only CancelledError, annotate with {.async: (raises: [CancelledError]).}

Source Edit

proc post(req: HttpRequestRef): InternalRaisesFuture[HttpTable,
    (CancelledError, HttpTransportError, HttpProtocolError)] {.
    stackTrace: false, ...raises: [], gcsafe, raises: [], raises: [],
    tags: [RootEffect].}

Return POST parameters Source Edit

proc preferredContentMediaType(acceptHeader: string): MediaType {....raises: [],
    tags: [].}

Returns preferred content-type using Accept header value specified by string acceptHeader. Source Edit

proc preferredContentMediaType(request: HttpRequestRef): MediaType {....raises: [],
    tags: [].}

Returns preferred content-type using Accept header specified by client in request request. Source Edit

proc preferredContentType(acceptHeader: string; types: varargs[MediaType]): Result[
    MediaType, cstring] {....raises: [], tags: [].}

Match or obtain preferred content type using Accept header specified by string acceptHeader and server preferred content types types.

If Accept header is missing in client's request - types[0] or */* value will be returned as result.

If Accept header has incorrect format in client's request - types[0] or */* value will be returned as result.

If Accept header is present in request to server and it has one or more content types supported by client, the best value will be selected from types using position and quality value (weight) reported in Accept header. If client do not support any methods in types error will be returned.

Note: Quality value (weight) for content type has priority over server's preferred content-type.

Source Edit

proc preferredContentType(request: HttpRequestRef; types: varargs[MediaType]): Result[
    MediaType, cstring] {....raises: [], tags: [].}

Match or obtain preferred content-type using Accept header specified by client in request request. Source Edit

proc prepare(resp: HttpResponseRef; streamType = HttpResponseStreamType.Chunked): InternalRaisesFuture[
    void, (CancelledError, HttpWriteError)] {.stackTrace: false, ...raises: [],
    gcsafe, raises: [], raises: [], tags: [RootEffect].}

Prepare for HTTP stream response.

Such responses will be sent chunk by chunk using chunked encoding.

Source Edit

proc prepareChunked(resp: HttpResponseRef): InternalRaisesFuture[void,
    (CancelledError, HttpWriteError)] {.stackTrace: false, ...raises: [], gcsafe,
                                        raises: [], raises: [],
                                        tags: [RootEffect].}

Source Edit

proc preparePlain(resp: HttpResponseRef): InternalRaisesFuture[void,
    (CancelledError, HttpWriteError)] {.stackTrace: false, ...raises: [], gcsafe,
                                        raises: [], raises: [],
                                        tags: [RootEffect].}

Source Edit

proc prepareSSE(resp: HttpResponseRef): InternalRaisesFuture[void,
    (CancelledError, HttpWriteError)] {.stackTrace: false, ...raises: [], gcsafe,
                                        raises: [], raises: [],
                                        tags: [RootEffect].}

Source Edit

proc redirect(req: HttpRequestRef; code: HttpCode; location: string): InternalRaisesFuture[
    HttpResponseRef, (CancelledError, HttpWriteError)] {.stackTrace: false,
    ...raises: [], gcsafe, raises: [], raises: [], tags: [RootEffect].}

Source Edit

proc redirect(req: HttpRequestRef; code: HttpCode; location: string;
              headers: HttpTable): InternalRaisesFuture[HttpResponseRef,
    (CancelledError, HttpWriteError)] {.stackTrace: false, ...raises: [], gcsafe,
                                        raises: [], raises: [],
                                        tags: [RootEffect].}

Source Edit

proc redirect(req: HttpRequestRef; code: HttpCode; location: Uri): InternalRaisesFuture[
    HttpResponseRef, (CancelledError, HttpWriteError)] {.stackTrace: false,
    ...raises: [], gcsafe, raises: [], raises: [], tags: [RootEffect].}

Source Edit

proc redirect(req: HttpRequestRef; code: HttpCode; location: Uri;
              headers: HttpTable): InternalRaisesFuture[HttpResponseRef,
    (CancelledError, HttpWriteError)] {.stackTrace: false, ...raises: [], gcsafe,
                                        raises: [], raises: [],
                                        tags: [RootEffect].}

Source Edit

proc remote(request: HttpRequestRef): Opt[TransportAddress] {....raises: [],
    tags: [].}

Returns remote address of HTTP request's connection. Source Edit

proc remoteAddress(conn: HttpConnectionRef): TransportAddress {.
    ...raises: [HttpAddressError], raises: [], tags: [].}

Returns address of the remote host that established connection conn. Source Edit

proc remoteAddress(request: HttpRequestRef): TransportAddress {.
    ...raises: [HttpAddressError], raises: [], tags: [].}

Returns address of the remote host that made request request. Source Edit

proc requestInfo(req: HttpRequestRef; contentType = "text/plain"): string {.
    ...raises: [], tags: [].}

Returns comprehensive information about request for specific content type.

Only two content-types are supported: "text/text" and "text/html".

Source Edit

proc respond(req: HttpRequestRef; code: HttpCode): InternalRaisesFuture[
    HttpResponseRef, (CancelledError, HttpWriteError)] {.stackTrace: false,
    ...raises: [], gcsafe, raises: [], raises: [], tags: [RootEffect].}

Source Edit

proc respond(req: HttpRequestRef; code: HttpCode; content: ByteChar): InternalRaisesFuture[
    HttpResponseRef, (CancelledError, HttpWriteError)] {.stackTrace: false,
    ...raises: [], gcsafe, raises: [], raises: [].}

Source Edit

proc respond(req: HttpRequestRef; code: HttpCode; content: ByteChar;
             headers: HttpTable): InternalRaisesFuture[HttpResponseRef,
    (CancelledError, HttpWriteError)] {.stackTrace: false, ...raises: [], gcsafe,
                                        raises: [], raises: [].}

Responds to the request with the specified HttpCode, HTTP headers and content. Source Edit

proc responded(req: HttpRequestRef): bool {....raises: [], tags: [].}

Returns true if request req has been responded or responding. Source Edit

proc send(resp: HttpResponseRef; data: ByteChar): InternalRaisesFuture[void,
    (CancelledError, HttpWriteError)] {.stackTrace: false, ...raises: [], gcsafe,
                                        raises: [], raises: [].}

Send single chunk of data data. Source Edit

proc send(resp: HttpResponseRef; pbytes: pointer; nbytes: int): InternalRaisesFuture[
    void, (CancelledError, HttpWriteError)] {.stackTrace: false, ...raises: [],
    gcsafe, raises: [], raises: [], tags: [RootEffect].}

Send single chunk of data pointed by pbytes and nbytes. Source Edit

proc sendBody(resp: HttpResponseRef; data: ByteChar): InternalRaisesFuture[void,
    (CancelledError, HttpWriteError)] {.stackTrace: false, ...raises: [], gcsafe,
                                        raises: [], raises: [].}

Send HTTP response at once by using data data. Source Edit

proc sendBody(resp: HttpResponseRef; pbytes: pointer; nbytes: int): InternalRaisesFuture[
    void, (CancelledError, HttpWriteError)] {.stackTrace: false, ...raises: [],
    gcsafe, raises: [], raises: [], tags: [RootEffect].}

Send HTTP response at once by using bytes pointer pbytes and length nbytes. Source Edit

proc sendChunk(resp: HttpResponseRef; data: ByteChar): InternalRaisesFuture[
    void, (CancelledError, HttpWriteError)] {.stackTrace: false, ...raises: [],
    gcsafe, raises: [], raises: [].}

Source Edit

proc sendChunk(resp: HttpResponseRef; pbytes: pointer; nbytes: int): InternalRaisesFuture[
    void, (CancelledError, HttpWriteError)] {.stackTrace: false, ...raises: [],
    gcsafe, raises: [], raises: [], tags: [RootEffect].}

Source Edit

proc sendError(resp: HttpResponseRef; code: HttpCode; body = ""): InternalRaisesFuture[
    void, (CancelledError, HttpWriteError)] {.stackTrace: false, ...raises: [],
    gcsafe, raises: [], raises: [], tags: [RootEffect].}

Send HTTP error status response. Source Edit

proc sendEvent(resp: HttpResponseRef; eventName: string; data: string): InternalRaisesFuture[
    void, (CancelledError, HttpWriteError)] {.stackTrace: false, ...raises: [],
    gcsafe, raises: [], raises: [], tags: [RootEffect].}

Source Edit

proc setHeader(resp: HttpResponseRef; key, value: string) {....raises: [], tags: [].}

Sets value of header key to value. Source Edit

proc setHeaderDefault(resp: HttpResponseRef; key, value: string) {....raises: [],
    tags: [].}

Sets value of header key to value, only if header key is not present in the headers table. Source Edit

proc start(server: HttpServerRef) {....raises: [], tags: [RootEffect].}

Starts HTTP server. Source Edit

proc state(server: HttpServerRef): HttpServerState {....raises: [], tags: [].}

Returns current HTTP server's state. Source Edit

proc stop(server: HttpServerRef): InternalRaisesFuture[void, void] {.
    stackTrace: false, ...raises: [], gcsafe, raises: [], raises: [],
    tags: [RootEffect].}

Stop HTTP server from accepting new connections. Source Edit

proc updateRequest(request: HttpRequestRef; headers: HttpTable): HttpResultMessage[
    void] {....raises: [], tags: [].}