cheatfate / asynctools Goto Github PK

block:
    var event = newAsyncEv()

    proc testEvent(n: int, ev: AsyncEv) {.async.} =
      while true:
        await ev.wait()
        debugEcho n

    event.clear()
    asyncCheck testEvent(0, event)
    asyncCheck testEvent(1, event)
    event.fire()
    event.clear()
    waitFor sleepAsync(10_000)

0
1

import asynctools/asyncipc
let ipc = createIpc("blablabla")
let writeHandle = open("blablabla", sideWriter)

import os, asyncdispatch, winlean

# import asynctools/asyncproc
#
# proc main()= 
#
#   let cmd = "nim -v"
#   let p = cmd.startProcess(options = {poStdErrToStdOut, poUsePath, poEvalCommand})
#
#   let exitCode = waitFor p.waitForExit()
#   quit exitCode
#
# main()


const
  pipeHeaderName = r"\\.\pipe\asyncpipe_"

const
  DEFAULT_PIPE_SIZE = 65536'i32
  FILE_FLAG_FIRST_PIPE_INSTANCE = 0x00080000'i32
  PIPE_WAIT = 0x00000000'i32
  PIPE_TYPE_BYTE = 0x00000000'i32
  PIPE_READMODE_BYTE = 0x00000000'i32
  ERROR_PIPE_CONNECTED = 535
  ERROR_PIPE_BUSY = 231
  ERROR_BROKEN_PIPE = 109
  ERROR_PIPE_NOT_CONNECTED = 233

proc QueryPerformanceCounter(res: var int64)
      {.importc: "QueryPerformanceCounter", stdcall, dynlib: "kernel32".}

proc createPipe() =
    var number = 0'i64
    var pipeName: WideCString
    var pipeIn: Handle
    var pipeOut: Handle
    var sa = SECURITY_ATTRIBUTES(nLength: sizeof(SECURITY_ATTRIBUTES).cint,
                                  lpSecurityDescriptor: nil, bInheritHandle: 1)
    while true:
      QueryPerformanceCounter(number)
      let p = pipeHeaderName & $number
      pipeName = newWideCString(p)
      var openMode = FILE_FLAG_FIRST_PIPE_INSTANCE or FILE_FLAG_OVERLAPPED or
                      PIPE_ACCESS_INBOUND
      var pipeMode = PIPE_TYPE_BYTE or PIPE_READMODE_BYTE or PIPE_WAIT
      pipeIn = createNamedPipe(pipeName, openMode, pipeMode, 1'i32,
                                DEFAULT_PIPE_SIZE, DEFAULT_PIPE_SIZE,
                                1'i32, addr sa)
      if pipeIn == INVALID_HANDLE_VALUE:
        let err = osLastError()
        if err.int32 != ERROR_PIPE_BUSY:
          raiseOsError(err)
      else:
        break

    var openMode = (FILE_WRITE_DATA or SYNCHRONIZE)
    pipeOut = createFileW(pipeName, openMode, 0, addr(sa), OPEN_EXISTING,
                          FILE_FLAG_OVERLAPPED, 0)
    if pipeOut == INVALID_HANDLE_VALUE:
      let err = osLastError()
      discard closeHandle(pipeIn)
      raiseOsError(err)

createPipe()

import asynctools/asyncproc, asyncdispatch
echo waitFor execProcess("pwd")

import asynctools/[asyncproc, asyncpipe]
import asyncfutures
import asyncdispatch

var p = startProcess("q_outerr", options = {})
var pout = p.outputHandle
var perr = p.errorHandle

proc next() {.async.} =
  var bufo = newString(1)
  var fo = pout.readInto(bufo[0].addr, bufo.len)
  var bufe = newString(1)
  var fe = perr.readInto(bufe[0].addr, bufe.len)
  var fx = p.waitForExit()
  while true:
    await fe or fo or fx
    if fo.finished:
      if fo.read > 0:
        echo "O ", fo.read(), " ", bufo.substr(0, fo.read()-1)
      fo = pout.readInto(bufo[0].addr, bufo.len)
    if fe.finished:
      if fe.read > 0:
        echo "E ", fe.read(), " ", bufe.substr(0, fe.read()-1)
      fe = perr.readInto(bufe[0].addr, bufe.len)
    if fx.finished:
      echo "X ", fx.read()
      return
    if fo.finished and fe.finished and fo.read==0 and fe.read==0:
      return

waitFor next()

import os

stderr.writeLine "some stderr"
stderr.writeLine "some stderr2"
stdout.writeLine "some stdout2"
stderr.writeLine "some stderr3"
stderr.writeLine "some stderr4"

import asyncdispatch, asynctools/asyncproc

proc run() {.async.} =
  while true:
    await sleepAsync(300)
    var p = startProcess("sleep 1 && ls", options={poUsePath, poEvalCommand})
    asyncCheck p.waitForExit()

waitFor run()

import asyncdispatch
import asynctools/asyncpipe

proc main() {.async.} =
  let pipe = createPipe()
  var data = "x"
  for i in 0..100000:
    discard await pipe.write(data.cstring, 1)
    discard await pipe.readInto(data.cstring, 1)

waitFor main()
echo "Press ENTER to exit"
discard stdin.readLine()

import pkg/asynctools

import strformat, std/enumerate, os, asyncdispatch, asynctools/asyncproc

type
  ProcessOutput = tuple[exitCode: int, output: string]

var urlsToDownload: seq[string] = @[
  "www.w3.org/TR/html401/html40.txt",
  "www.w3.org/TR/2002/REC-xhtml1-20020801/xhtml1.pdf"]

proc downloadUrl(url: string): Future[ProcessOutput] {.async.} =
  return await asyncproc.execProcess(&"curl {url}")

var urlsContents: seq[Future[ProcessOutput]]
for url in urlsToDownload:
  echo &"Downloading {url} ..."
  urlsContents.add downloadUrl(url)

let results = waitFor all(urlsContents)
for i, result in enumerate(results):
  if result.exitCode != QuitSuccess:
    echo &"Error {result.exitCode}: {result.output}"
    continue
  let fileName = urlsToDownload[i].splitPath.tail
  writeFile(fileName, result.output)

import asyncdispatch, asynctools/asyncproc, os

proc oneTest() {.async.} =
    discard await execProcess("git ls-remote https://github.com/yglukhov/nimx")

proc manyTests() {.async.} =
    var futures = newSeq[Future[void]]()
    for i in 0 .. 10:
        futures.add(oneTest())
    await all futures

waitFor manyTests()

import
  faststreams/async_backend,
  faststreams/asynctools_adapters,
  faststreams/textio,
  faststreams/inputs

proc copyStdioToPipe(pipe: AsyncPipe) {.thread.} =
  var ch = "hello"
  var ch2 = "\n"

  while ch[0] != '\0':
    discard waitFor write(pipe, ch[0].addr, 1)
    discard waitFor write(pipe, ch[0].addr, 1)
    discard waitFor write(pipe, ch[0].addr, 1)
    discard waitFor write(pipe, ch[0].addr, 1)
    discard waitFor write(pipe, ch[0].addr, 1)
    discard waitFor write(pipe, ch[0].addr, 1)
    discard waitFor write(pipe, ch2[0].addr, 1)

proc myReadLine(input: AsyncInputStream): Future[void] {.async.} =
  while input.readable:
    discard input.readLine()

when isMainModule:
  var
    pipe = createPipe(register = true)
    stdioThread: Thread[AsyncPipe]

  createThread(stdioThread, copyStdioToPipe, pipe)
  let a = asyncPipeInput(pipe)
  waitFor(myReadLine(a))

import
  posix,
  os,
  faststreams/async_backend,
  faststreams/asynctools_adapters,
  faststreams/textio,
  faststreams/inputs

proc writeToPipe(p: AsyncPipe, data: pointer, nbytes: int) =
  if posix.write(p.getWriteHandle, data, cint(nbytes)) < 0:
    raiseOsError(osLastError())

proc copyStdioToPipe(pipe: AsyncPipe) {.thread.} =
  var ch = "X222"
  var ch2 = "\n"

  while ch[0] != '\0':
    writeToPipe(pipe, ch[0].addr, 1)
    writeToPipe(pipe, ch[0].addr, 1)
    writeToPipe(pipe, ch[0].addr, 1)
    writeToPipe(pipe, ch[0].addr, 1)
    writeToPipe(pipe, ch[0].addr, 1)
    writeToPipe(pipe, ch[0].addr, 1)
    writeToPipe(pipe, ch2[0].addr, 1)

proc myReadLine(input: AsyncInputStream): Future[void] {.async.} =
  while input.readable:
    echo await input.readLine()

when isMainModule:
  var
    pipe = createPipe(register = true)
    stdioThread: Thread[AsyncPipe]

  createThread(stdioThread, copyStdioToPipe, pipe)
  let a = asyncPipeInput(pipe)
  waitFor(myReadLine(a))