server/loaderiface

Search:
Group by:

Types

BlobFinish = proc (opaque: BlobOpaque; blob: Blob) {.nimcall, ...raises: [].}
BlobOpaque = ref object of RootObj
  contentType*: string
ClientKey = array[32, uint8]
ConnectData = ref object of LoaderData
  opaque*: RootRef
ConnectDataState = enum
  cdsBeforeResult, cdsBeforeStatus
FetchFinish = proc (opaque: RootRef; res: Response) {.nimcall, ...raises: [].}
FileLoader = ref object of RootObj
  clientPid*: int
  mapFds*: int
  pollData*: PollData
  unregistered*: seq[cint]
  controlStream*: PosixStream
LoaderClientConfig = object
  originURL*: URL
  cookieJar*: CookieJar
  defaultHeaders*: Headers
  proxy*: URL
  allowSchemes*: seq[string]
  allowAllSchemes*: bool
  insecureSslNoVerify*: bool
  referrerPolicy*: ReferrerPolicy
  cookieMode*: CookieMode
LoaderCommand = enum
  lcAddAuth, lcAddCacheFile, lcAddClient, lcAddPipe, lcGetCacheFile, lcLoad,
  lcLoadConfig, lcOpenCachedItem, lcPassFd, lcRedirectToFile,
  lcRemoveCachedItem, lcRemoveClient, lcResume, lcShareCachedItem, lcSuspend,
  lcTee
MapData = ref object of RootObj
  stream*: PosixStream
Response = ref object of LoaderData
  flags*: set[ResponseFlag]
  responseType* {.jsget: "type".}: ResponseType
  status* {.jsget.}: uint16
  headers* {.jsget.}: Headers
  url*: URL
  onRead*: ResponseRead
  onFinish*: ResponseFinish
  outputId*: int
  opaque*: RootRef
ResponseFinish = proc (response: Response; success: bool) {.nimcall, ...raises: [].}
ResponseFlag = enum
  rfAborted, rfBodyUsed, rfResumed
ResponseRead = proc (response: Response) {.nimcall, ...raises: [].}
ResponseType = enum
  rtDefault = "default", rtBasic = "basic", rtCors = "cors", rtError = "error",
  rtOpaque = "opaque", rtOpaquedirect = "opaqueredirect"
TextResult = object
  isOk*: bool
  get*: string

Vars

getLoaderImpl: proc (ctx: JSContext): FileLoader {.nimcall, ...raises: [].}

Procs

proc addAuth(loader: FileLoader; url: URL) {....raises: [], tags: [RootEffect],
    forbids: [].}
proc addCacheFile(loader: FileLoader; outputId: int): int {....raises: [],
    tags: [], forbids: [].}
proc addClient(loader: FileLoader; pid: int; config: LoaderClientConfig): PosixStream {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc addPipe(loader: FileLoader; id: string): PosixStream {....raises: [],
    tags: [], forbids: [].}
proc addResponseModule(ctx: JSContext): JSClassID {....raises: [], tags: [],
    forbids: [].}
proc blob(loader: FileLoader; response: Response; opaque: BlobOpaque) {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc blockRegister(loader: FileLoader) {....raises: [], tags: [], forbids: [].}
proc bodyUsed(response: Response): bool {....raises: [], tags: [], forbids: [].}
proc close(loader: FileLoader; response: Response) {....raises: [],
    tags: [RootEffect], forbids: [].}
proc doPipeRequest(loader: FileLoader; id: string): tuple[ps: PosixStream,
    response: Response] {....raises: [], tags: [RootEffect], forbids: [].}
proc doRequest(loader: FileLoader; request: Request): Response {....raises: [],
    tags: [RootEffect], forbids: [].}
proc fetch(loader: FileLoader; input: Request; finish: FetchFinish;
           opaque: RootRef) {....raises: [], tags: [RootEffect], forbids: [].}
proc get(loader: FileLoader; fd: cint): MapData {....raises: [], tags: [],
    forbids: [].}
proc getCacheFile(loader: FileLoader; cacheId, sourcePid: int): string {.
    ...raises: [], tags: [], forbids: [].}
proc getCharset(this: Response; fallback: Charset): Charset {....raises: [],
    tags: [], forbids: [].}
proc getContentLength(this: Response): int64 {....raises: [], tags: [], forbids: [].}
proc getContentType(this: Response; fallback = "application/octet-stream"): string {.
    ...raises: [], tags: [], forbids: [].}
proc getLongContentType(this: Response; fallback: string): string {....raises: [],
    tags: [], forbids: [].}
proc getRedirect(response: Response; request: Request): Request {....raises: [],
    tags: [RootEffect], forbids: [].}
proc getReferrerPolicy(this: Response): Opt[ReferrerPolicy] {....raises: [],
    tags: [], forbids: [].}
proc hasFds(loader: FileLoader): bool {....raises: [], tags: [], forbids: [].}
proc makeNetworkError(): Response {....raises: [], tags: [], forbids: [].}
proc newFileLoader(clientPid: int; controlStream: PosixStream): FileLoader {.
    ...raises: [], tags: [], forbids: [].}
proc newResponse(ctx: JSContext; body: JSValueConst = JS_UNDEFINED;
                 init: JSValueConst = JS_UNDEFINED): Opt[Response] {....raises: [],
    tags: [], forbids: [].}
proc newResponse(request: Request; stream: PosixStream; outputId: int): Response {.
    ...raises: [], tags: [], forbids: [].}
proc onError(loader: FileLoader; fd: int): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc onError(loader: FileLoader; response: Response) {....raises: [],
    tags: [RootEffect], forbids: [].}
proc onFinishBlob(response: Response; success: bool): Blob {....raises: [],
    tags: [], forbids: [].}
proc onRead(loader: FileLoader; fd: int) {....raises: [], tags: [RootEffect],
    forbids: [].}
proc onRead(loader: FileLoader; response: Response) {....raises: [],
    tags: [RootEffect], forbids: [].}
proc openCachedItem(loader: FileLoader; cacheId: int): PosixStream {....raises: [],
    tags: [], forbids: [].}
proc passFd(loader: FileLoader; id: string; fd: cint) {....raises: [], tags: [],
    forbids: [].}
proc put(loader: FileLoader; data: MapData) {....raises: [], tags: [], forbids: [].}
proc redirectToFile(loader: FileLoader; outputId: int; targetPath: string;
                    displayUrl: URL): bool {....raises: [], tags: [], forbids: [].}
proc register(loader: FileLoader; data: MapData; events: cshort) {....raises: [],
    tags: [], forbids: [].}
proc removeCachedItem(loader: FileLoader; cacheId: int) {....raises: [], tags: [],
    forbids: [].}
proc removeClient(loader: FileLoader; pid: int) {....raises: [], tags: [],
    forbids: [].}
proc resume(loader: FileLoader; outputId: int) {....raises: [], tags: [],
    forbids: [].}
proc resume(loader: FileLoader; outputIds: openArray[int]) {....raises: [],
    tags: [], forbids: [].}
proc resume(loader: FileLoader; response: Response) {....raises: [],
    tags: [RootEffect], forbids: [].}
proc shareCachedItem(loader: FileLoader; id, targetPid: int; sourcePid = -1): bool {.
    ...raises: [], tags: [], forbids: [].}
proc startRequest(loader: FileLoader; request: Request;
                  config: LoaderClientConfig): PosixStream {....raises: [],
    tags: [RootEffect], forbids: [].}
proc surl(response: Response): string {....raises: [], tags: [], forbids: [].}
proc suspend(loader: FileLoader; fds: seq[int]) {....raises: [], tags: [],
    forbids: [].}
proc tee(loader: FileLoader; sourceId, targetPid: int): (PosixStream, int) {.
    ...raises: [], tags: [], forbids: [].}
proc toJS(ctx: JSContext; x: TextResult): JSValue {....raises: [], tags: [],
    forbids: [].}
proc unblockRegister(loader: FileLoader) {....raises: [], tags: [], forbids: [].}
proc unregister(loader: FileLoader; data: MapData) {....raises: [], tags: [],
    forbids: [].}
proc unregister(loader: FileLoader; fd: cint) {....raises: [], tags: [],
    forbids: [].}
proc unset(loader: FileLoader; data: MapData) {....raises: [], tags: [],
    forbids: [].}
proc unset(loader: FileLoader; fd: cint) {....raises: [], tags: [], forbids: [].}

Iterators

iterator data(loader: FileLoader): MapData {.inline, ...raises: [], tags: [],
    forbids: [].}
iterator ongoing(loader: FileLoader): Response {.inline, ...raises: [], tags: [],
    forbids: [].}

Templates

template err(t: typedesc[TextResult]): TextResult {..}
template isErr(x: TextResult): bool {..}
template ok(t: typedesc[TextResult]; s: string): TextResult {..}