Index

Modules: guildenstern/dispatcher, guildenstern/epolldispatcher, guildenstern/guildenserver, guildenstern/httpserver, guildenstern/multipartserver, guildenstern/websocketclient, guildenstern/websocketserver.

API symbols

`$`:

• guildenserver: proc `$`(x: SocketHandle): string

AlreadyClosed:

• guildenserver: SocketCloseCause.AlreadyClosed

BodyChunk:

• multipartserver: PartState.BodyChunk

BodyReady:

• multipartserver: PartState.BodyReady

checkSocketState:

• httpserver: proc checkSocketState(ret: int): SocketState

close:

• websocketclient: proc close(client: WebsocketClient; handshake = true)

CloseCalled:

• guildenserver: SocketCloseCause.CloseCalled

ClosedbyClient:

• guildenserver: SocketCloseCause.ClosedbyClient

closeOtherSocket:

• guildenserver: proc closeOtherSocket(server: GuildenServer; socket: posix.SocketHandle; cause: SocketCloseCause = CloseCalled; msg: string = "")

closeSocket:

• guildenserver: proc closeSocket(server: GuildenServer; socket: SocketHandle; cause = CloseCalled; msg = "")
• guildenserver: proc closeSocket(cause = CloseCalled; msg = "")

CloseSocketCallback:

• guildenserver: type CloseSocketCallback

Compact:

• httpserver: ContentType.Compact

Complete:

• httpserver: SocketState.Complete

Completed:

• multipartserver: PartState.Completed

connect:

• websocketclient: proc connect(client: WebsocketClient; key = "dGhlIHNhbXBsZSBub25jZQ=="): bool

connectedClients:

• websocketclient: iterator connectedClients(clientele: WebsocketClientele): WebsocketClient

ConnectionLost:

• guildenserver: SocketCloseCause.ConnectionLost

ContentType:

• httpserver: enum ContentType

DEBUG:

• guildenserver: LogLevel.DEBUG

DeprecatedOnCloseSocketCallback:

• guildenserver: type DeprecatedOnCloseSocketCallback

DontClose:

• guildenserver: SocketCloseCause.DontClose

EFault:

• guildenserver: SocketCloseCause.EFault

epollSupported:

• guildenserver: proc epollSupported(): bool

ERROR:

• guildenserver: LogLevel.ERROR

Excepted:

• guildenserver: SocketCloseCause.Excepted

Fail:

• httpserver: SocketState.Fail

Failed:

• multipartserver: PartState.Failed

FATAL:

• guildenserver: LogLevel.FATAL

findClient:

• websocketclient: proc findClient(clientele: WebsocketClientele; socket: SocketHandle): WebsocketClient

getBody:

• httpserver: proc getBody(): string

getBodylen:

• httpserver: proc getBodylen(): int

getBodyview:

• httpserver: proc getBodyview(http: HttpContext): openArray[char]

getContentLength:

• httpserver: proc getContentLength(): bool

getFlags:

• guildenserver: proc getFlags(server: GuildenServer; socket: posix.SocketHandle): int

GetFlagsCallback:

• guildenserver: type GetFlagsCallback

getMessage:

• websocketserver: proc getMessage(): string

getMessageview:

• websocketserver: proc getMessageview(ws: HttpContext): openArray[char]

getMethod:

• httpserver: proc getMethod(): string

getRequest:

• httpserver: proc getRequest(): string

getUri:

• httpserver: proc getUri(): string

GuildenServer:

• guildenserver: type GuildenServer

GuildenServerObj:

• guildenserver: object GuildenServerObj

GuildenSternVersion:

• guildenserver: const GuildenSternVersion

handleHttpThreadInitialization:

• httpserver: proc handleHttpThreadInitialization(theserver: GuildenServer)

HandlerCallback:

• guildenserver: type HandlerCallback

handleRead:

• guildenserver: proc handleRead(theserver: GuildenServer; socket: SocketHandle; customdata: pointer)

handleWsRequest:

• websocketserver: proc handleWsRequest()

handleWsThreadInitialization:

• websocketserver: proc handleWsThreadInitialization(theserver: GuildenServer)

HeaderReady:

• multipartserver: PartState.HeaderReady

http:

• httpserver: template http(): untyped

HttpContext:

• httpserver: type HttpContext

HttpServer:

• httpserver: type HttpServer

HttpServerObj:

• httpserver: object HttpServerObj

INFO:

• guildenserver: LogLevel.INFO

initHttpServer:

• httpserver: proc initHttpServer(s: HttpServer; loglevel: LogLevel; parserequestline: bool; contenttype: ContentType; headerfields: openArray[string])

initialbackoff:

• httpserver: const initialbackoff

initialize:

• guildenserver: proc initialize(server: GuildenServer; loglevel: LogLevel)

initializeThread:

• guildenserver: proc initializeThread(server: GuildenServer)

initWebsocketServer:

• websocketserver: proc initWebsocketServer(theserver: WebsocketServer; upgradecallback: WsUpgradeCallback; afterupgradecallback: WsAfterUpgradeCallback; onwsmessagecallback: WsMessageCallback; loglevel = LogLevel.WARN; clientmaskkey = "\x00\x00\x00\x00")

isBody:

• httpserver: proc isBody(body: string): bool

isConnected:

• websocketclient: proc isConnected(client: WebsocketClient): bool

isHeaderreceived:

• httpserver: proc isHeaderreceived(previouslen, currentlen: int): bool

isHttpContext:

• httpserver: proc isHttpContext(): bool

isMessage:

• websocketserver: proc isMessage(message: string): bool

isMethod:

• httpserver: proc isMethod(amethod: string): bool

isUri:

• httpserver: proc isUri(uri: string): bool

log:

• guildenserver: template log(theserver: GuildenServer; level: LogLevel; message: string)
• guildenserver: template log(theserver: GuildenServer; level: LogLevel; source: string; message: string)

LogCallback:

• guildenserver: type LogCallback

LogLevel:

• guildenserver: enum LogLevel

longdivider:

• httpserver: let longdivider

MSG_DONTWAIT:

• httpserver: const MSG_DONTWAIT

MSG_MORE:

• httpserver: const MSG_MORE

NetErrored:

• guildenserver: SocketCloseCause.NetErrored

newHttpServer:

• httpserver: proc newHttpServer(onrequestcallback: proc () {.gcsafe, nimcall, raises: [].}; loglevel = LogLevel.WARN; parserequestline = true; contenttype = Compact; headerfields: openArray[string] = []): HttpServer

newMultipartServer:

• multipartserver: proc newMultipartServer(onrequestcallback: proc () {.gcsafe, nimcall, raises: [].}; loglevel = LogLevel.WARN; headerfields: openArray[string] = []): HttpServer

newWebsocketClient:

• websocketclient: proc newWebsocketClient(clientele: WebsocketClientele; url: string; receive: proc (client: WebsocketClient) {.nimcall.}): WebsocketClient

newWebsocketClientele:

• websocketclient: proc newWebsocketClientele(close: OnCloseSocketCallback = nil; loglevel = LogLevel.WARN; bufferlength = 1000; bytemask = "\v\x16!,"): WebsocketClientele

newWebsocketServer:

• websocketserver: proc newWebsocketServer(upgradecallback: WsUpgradeCallback; afterupgradecallback: WsAfterUpgradeCallback; onwsmessagecallback: WsMessageCallback; deprecatedOnclosesocketcallback: DeprecatedOnCloseSocketCallback; loglevel = LogLevel.WARN): WebsocketServer
• websocketserver: proc newWebsocketServer(upgrade: WsUpgradeCallback = nil; afterupgrade: WsAfterUpgradeCallback = nil; receive: WsMessageCallback; close: OnCloseSocketCallback = nil; loglevel = LogLevel.WARN): WebsocketServer

NoBody:

• httpserver: ContentType.NoBody

NONE:

• guildenserver: LogLevel.NONE

NOTICE:

• guildenserver: LogLevel.NOTICE

OnCloseSocketCallback:

• guildenserver: type OnCloseSocketCallback

parseContentDisposition:

• multipartserver: proc parseContentDisposition(): (string, string)

parseMethod:

• httpserver: proc parseMethod(): bool

parseRequestLine:

• httpserver: proc parseRequestLine(): bool

PartState:

• multipartserver: enum PartState

prepareHttpContext:

• httpserver: proc prepareHttpContext()

Progress:

• httpserver: SocketState.Progress

ProtocolViolated:

• guildenserver: SocketCloseCause.ProtocolViolated

readHeader:

• httpserver: proc readHeader(): bool

receiveParts:

• multipartserver: iterator receiveParts(parsepartheaders: bool = true): (PartState, string)

receiveStream:

• httpserver: iterator receiveStream(): (SocketState, string)

registerSocket:

• dispatcher: proc registerSocket(theserver: GuildenServer; socket: SocketHandle; flags = 0; customdata: pointer = nil): bool
• epolldispatcher: proc registerSocket(server: GuildenServer; socket: SocketHandle; flags = 0; customdata: pointer = nil): bool

reply:

• httpserver: proc reply(code: HttpCode): SocketState
• httpserver: proc reply(code: HttpCode; body: ptr string; headers: openArray[string])
• httpserver: proc reply(code: HttpCode; body: ptr string; headers: ptr string)
• httpserver: proc reply(code: HttpCode; body: ptr string; lengthstring: string; length: int; headers: ptr string; moretocome: bool): SocketState
• httpserver: template reply(code: HttpCode; headers: openArray[string])
• httpserver: template reply(code: HttpCode; body: string)
• httpserver: template reply(code: HttpCode; body: string; headers: openArray[string])
• httpserver: template reply(body: string)
• httpserver: template reply(body: string; headers: openArray[string])

replyContinueChunked:

• httpserver: proc replyContinueChunked(chunk: string): bool

replyFinish:

• httpserver: proc replyFinish(): SocketState

replyFinishChunked:

• httpserver: proc replyFinishChunked(): bool

replyMore:

• httpserver: proc replyMore(bodypart: ptr string; start: int; partlength: int = -1): (SocketState, int)
• httpserver: template replyMore(bodypart: string): bool

replyStart:

• httpserver: proc replyStart(code: HttpCode; contentlength: int; headers: openArray[string]): SocketState
• httpserver: proc replyStart(code: HttpCode; contentlength: int; headers: ptr string = nil): SocketState

replyStartChunked:

• httpserver: proc replyStartChunked(code: HttpCode = Http200; headers: openArray[string] = []): bool

SecurityThreatened:

• guildenserver: SocketCloseCause.SecurityThreatened

send:

• websocketclient: proc send(client: WebsocketClient; message: string; timeoutsecs = 10): bool
• websocketserver: proc send(theserver: WebsocketServer; socket: posix.SocketHandle; message: string; binary = false; timeoutsecs = 2; sleepmillisecs = 10): bool
• websocketserver: proc send(theserver: WebsocketServer; delivery: ptr WsDelivery; timeoutsecs = 10; sleepmillisecs = 10): int
• websocketserver: proc send(theserver: WebsocketServer; delivery: ptr WsDelivery; failedsockets: var seq[SocketHandle]; timeoutsecs = 10; sleepmillisecs = 10)
• websocketserver: proc send(theserver: WebsocketServer; sockets: seq[posix.SocketHandle]; message: string; binary = false; timeoutsecs = 10; sleepmillisecs = 10): bool
• websocketserver: proc send(theserver: WebsocketServer; sockets: seq[posix.SocketHandle]; message: string; failedsockets: var seq[SocketHandle]; binary = false; timeoutsecs = 10; sleepmillisecs = 10)

sendClose:

• websocketserver: proc sendClose(theserver: WebsocketServer; socket: posix.SocketHandle; statuscode: int16 = 1000.int16; timeoutsecs = 1; sleepmillisecs = 10): bool

server:

• httpserver: template server(): untyped

setFlags:

• guildenserver: proc setFlags(server: GuildenServer; socket: posix.SocketHandle; flags: int): bool

SetFlagsCallback:

• guildenserver: type SetFlagsCallback

shortdivider:

• httpserver: let shortdivider

shutdown:

• guildenserver: proc shutdown()

shutdownCallbacks:

• guildenserver: var shutdownCallbacks

shuttingdown:

• guildenserver: var shuttingdown

SocketCloseCause:

• guildenserver: enum SocketCloseCause

SocketContext:

• guildenserver: type SocketContext

socketcontext:

• guildenserver: var socketcontext

SocketData:

• guildenserver: object SocketData

socketdata:

• guildenserver: proc socketdata(sc: SocketContext): SocketContext

SocketState:

• httpserver: enum SocketState

start:

• dispatcher: proc start(server: GuildenServer; port: int; threadpoolsize: uint = 0; maxactivethreadcount: uint = 0): bool
• epolldispatcher: proc start(server: GuildenServer; port: int; threadpoolsize: uint = 0): bool
• websocketclient: proc start(clientele: WebsocketClientele; threadpoolsize = 0): bool

startsUri:

• httpserver: proc startsUri(uristart: string): bool

Streaming:

• httpserver: ContentType.Streaming

suspend:

• guildenserver: proc suspend(server: GuildenServer; sleepmillisecs: int)
• guildenserver: proc suspend(sleepmillisecs: int)

SuspendCallback:

• guildenserver: type SuspendCallback

thesocket:

• guildenserver: template thesocket(): untyped

ThreadFinalizerCallback:

• guildenserver: type ThreadFinalizerCallback

ThreadInitializerCallback:

• guildenserver: type ThreadInitializerCallback

TimedOut:

• guildenserver: SocketCloseCause.TimedOut

TRACE:

• guildenserver: LogLevel.TRACE

TryAgain:

• httpserver: SocketState.TryAgain

WARN:

• guildenserver: LogLevel.WARN

WebsocketClient:

• websocketclient: type WebsocketClient

WebsocketClientele:

• websocketclient: type WebsocketClientele

WebsocketClienteleObj:

• websocketclient: object WebsocketClienteleObj

WebsocketServer:

• websocketserver: type WebsocketServer

WebsocketServerObj:

• websocketserver: object WebsocketServerObj

ws:

• websocketserver: template ws(): untyped

WsAfterUpgradeCallback:

• websocketserver: type WsAfterUpgradeCallback

WsDelivery:

• websocketserver: tuple WsDelivery

WsMessageCallback:

• websocketserver: type WsMessageCallback

wsserver:

• websocketserver: template wsserver(): untyped

WsUpgradeCallback:

• websocketserver: type WsUpgradeCallback