To preface I read https://nim-lang.org/docs/asyncdispatch.html many times, but I'm not sure I fully get it
I understand how to await procs marked by {.async.}, but I don't know how to create a root async proc. (i.e: the first awaitable)
Here is the use case scenario:
I am using prologue to create a sqlite3 wrapper, and want to have a pool of connections where I can request a cursor, carry the query, and then return the cursor (dbConn) back to the pool (or set in_use bool to false).
this is a mockup of how I want it to look, excuse the logic errors for now
proc createPool(): seq[DbConn] =
var connPool = newSeq[DbConn](100)
for i in 0..<connPool.len:
connPool[i] = open("data.db", "", "", "")
return connPool
var connPool = createPool()
proc getConn(p: var seq[DbConn]): Future[DbConn] {.async.} =
if pool.len > 0:
return pool.pop()
else:
await getConn(pool)
template withConn(pool: var seq[DbConn],body:untyped) : untyped {.dirty.} =
var conn: DbConn = waitFor getConn(pool)
body
pool.add(conn)the withConn template will be inside the routes' callback, will still have to figure out how to make the pool global to all threads, smartptrs/sharedpointer maybe? The problem is the getConn proc, how do I go about making it so that I wait for available connections if they were all busy? Do I endlessly loop to check if the pool is not empty? Sounds too brute force
Maybe using locks? Still not sure how to implement it Is async the right way to do this?
To get back to the title, how to build a future that returns a dbconnection?
I tried to read how asynchttpclient's getContent works, and it was many many layers of awaiting smaller primitives up until the socket read (which i will not pretend that I understood)
I don't know how to create a root async proc. (i.e: the first awaitable)
Use waitfor to call async functions from synchronous context:
import std/asyncdispatch
proc foo(): Future[int] {.async.} =
return 123
proc main {.async.} =
echo await foo()
waitFor main()There's also runForever for starting infinite dispatcher poll loop.
There should only be one waitFor per thread!
Nowadays, you can get an immediate and interactive and pretty good answer from AI. Well, I know that there some concerns of hallucination, but in my current experience with grok, I didn't aware of any serious hallucination with it.
Well, I also know it is more fun to interact with people, but be honest, It is just like let-me-google-that-for-you moment decades ago. You gonna use AI anyway.
I don't know how to create a root async proc. (i.e: the first awaitable)
Generally, you create a proc that returns a Future but that does not go through async transformation - in this proc, you create an instance of the future that you store in some state and you return it to the user - later, when the operation is done, you mark it completed.
A good example is AsyncEvent - its wait function creates a future and adds it to a list of futures, and its fire function completes all waiting futures, like so:
proc wait*(event: AsyncEvent): Future[void] {.
async: (raw: true, raises: [CancelledError]).} =
let retFuture = newFuture[void]("AsyncEvent.wait")
proc cancellation(udata: pointer) {.gcsafe, raises: [].} =
event.waiters.keepItIf(it != retFuture)
if not(event.flag):
retFuture.cancelCallback = cancellation
event.waiters.add(retFuture)
else:
retFuture.complete()
retFuture
proc fire*(event: AsyncEvent) =
if not(event.flag):
event.flag = true
for fut in event.waiters:
if not(fut.finished()): # Could have been cancelled
fut.complete()
event.waiters.setLen(0)The example uses {.async: (raw: true... which is the chronos equivalent of not adding any async at all in AD - asyncdispatch will be similar (albeit more buggy and without the cancellation support you see above).