updates

datastore/fsds.nim

@@ -280,6 +280,7 @@ else:
   proc new*(
     T: type FSDatastore,
     root: string,
+    tp: Taskpool = nil,
     depth = 2,
     caseSensitive = true,
     ignoreProtected = false): ?!FSDatastore =

datastore/sql.nim

@@ -274,6 +274,7 @@ else:
   proc new*(
     T: type SQLiteDatastore,
     path: string,
+    tp: Taskpool = nil,
     readOnly = false): ?!T =
 
     let
@@ -281,14 +282,14 @@ else:
         if readOnly: SQLITE_OPEN_READONLY
         else: SQLITE_OPEN_READWRITE or SQLITE_OPEN_CREATE
 
-    success T(
+    success SQLiteDatastore(
-      db: ? SQLiteDsDb.open(path, flags),
+      db: ? SQLiteDsDb[string, seq[byte]].open(path, flags),
       readOnly: readOnly)
 
   proc new*(
     T: type SQLiteDatastore,
-    db: SQLiteDsDb): ?!T =
+    db: SQLiteDsDb): ?!SQLiteDatastore =
 
-    success T(
+    success SQLiteDatastore(
       db: db,
       readOnly: db.readOnly)

tests/datastore/threads/testthreadproxy.nim

@@ -126,110 +126,111 @@ suite "Test Query ThreadDatastore with fsds":
 
   queryTests(ds, false)
 
-for i in 1..N:
+when datastoreUseAsync:
-  suite "Test ThreadDatastore cancelations":
+  for i in 1..N:
+    suite "Test ThreadDatastore cancelations":
 
-    privateAccess(SQLiteDatastore) # expose private fields
+      privateAccess(SQLiteDatastore) # expose private fields
-    privateAccess(ThreadProxy) # expose private fields
+      privateAccess(ThreadProxy) # expose private fields
-    privateAccess(TaskCtx) # expose private fields
+      privateAccess(TaskCtx) # expose private fields
 
-    var sds: SQLiteDatastore
+      var sds: SQLiteDatastore
 
-    setupAll:
+      setupAll:
-      sds = SQLiteDatastore.new(Memory, tp = taskPool).tryGet()
+        sds = SQLiteDatastore.new(Memory, tp = taskPool).tryGet()
 
-    teardown:
+      teardown:
-      GC_fullCollect() # run full collect after each test
+        GC_fullCollect() # run full collect after each test
 
-    test "Should monitor signal and cancel":
+      test "Should monitor signal and cancel":
-      var
+        var
-        signal = ThreadSignalPtr.new().tryGet()
+          signal = ThreadSignalPtr.new().tryGet()
 
-      proc cancelTestTask(ctx: TaskCtx[bool]) {.gcsafe.} =
+        proc cancelTestTask(ctx: TaskCtx[bool]) {.gcsafe.} =
-        executeTask(ctx):
+          executeTask(ctx):
-          (?!bool).ok(true)
+            (?!bool).ok(true)
 
-      let ctx = newTaskCtx(bool, signal=signal)
+        let ctx = newTaskCtx(bool, signal=signal)
-      ctx[].cancelled = true
+        ctx[].cancelled = true
-      dispatchTask(sds.db, signal):
+        dispatchTask(sds.db, signal):
-        sds.db.tp.spawn cancelTestTask(ctx)
+          sds.db.tp.spawn cancelTestTask(ctx)
 
-      check:
+        check:
-        ctx[].res.isErr == true
+          ctx[].res.isErr == true
-        ctx[].cancelled == true
+          ctx[].cancelled == true
-        ctx[].running == false
+          ctx[].running == false
 
-    test "Should cancel future":
+      test "Should cancel future":
 
-      var
+        var
-        signal = ThreadSignalPtr.new().tryGet()
+          signal = ThreadSignalPtr.new().tryGet()
-        ms {.global.}: MutexSignal
+          ms {.global.}: MutexSignal
-        flag {.global.}: Atomic[bool]
+          flag {.global.}: Atomic[bool]
-        futFreed {.global.}: Atomic[bool]
+          futFreed {.global.}: Atomic[bool]
-        ready {.global.}: Atomic[bool]
+          ready {.global.}: Atomic[bool]
 
-      ms.init()
+        ms.init()
 
-      type
+        type
-        FutTestObj = object
+          FutTestObj = object
-          val: int
+            val: int
-        TestValue = object
+          TestValue = object
-        ThreadTestInt = (TestValue, )
+          ThreadTestInt = (TestValue, )
 
-      proc `=destroy`(obj: var TestValue) =
+        proc `=destroy`(obj: var TestValue) =
-        # echo "destroy TestObj!"
+          # echo "destroy TestObj!"
-        flag.store(true)
+          flag.store(true)
 
-      proc `=destroy`(obj: var FutTestObj) =
+        proc `=destroy`(obj: var FutTestObj) =
-        # echo "destroy FutTestObj!"
+          # echo "destroy FutTestObj!"
-        futFreed.store(true)
+          futFreed.store(true)
 
-      proc wait(flag: var Atomic[bool], name = "task") =
+        proc wait(flag: var Atomic[bool], name = "task") =
-        # echo "wait for " & name & " to be ready..."
+          # echo "wait for " & name & " to be ready..."
-        # defer: echo ""
+          # defer: echo ""
-        for i in 1..100:
+          for i in 1..100:
-          # stdout.write(".")
+            # stdout.write(".")
-          if flag.load() == true: 
+            if flag.load() == true: 
-            return
+              return
-          os.sleep(10)
+            os.sleep(10)
-        raise newException(Defect, "timeout")
+          raise newException(Defect, "timeout")
 
-      proc errorTestTask(ctx: TaskCtx[ThreadTestInt]) {.gcsafe, nimcall.} =
+        proc errorTestTask(ctx: TaskCtx[ThreadTestInt]) {.gcsafe, nimcall.} =
-        executeTask(ctx):
+          executeTask(ctx):
-          # echo "task:exec"
+            # echo "task:exec"
-          discard ctx[].signal.fireSync()
+            discard ctx[].signal.fireSync()
-          ready.store(true)
+            ready.store(true)
-          ms.wait()
+            ms.wait()
-          echo "task context memory: ", ctx[]
+            echo "task context memory: ", ctx[]
-          (?!ThreadTestInt).ok(default(ThreadTestInt))
+            (?!ThreadTestInt).ok(default(ThreadTestInt))
 
-      proc runTestTask() {.async.} =
+        proc runTestTask() {.async.} =
-        let obj = FutTestObj(val: 42)
+          let obj = FutTestObj(val: 42)
-        await sleepAsync(1.milliseconds)
+          await sleepAsync(1.milliseconds)
+          try:
+            let ctx = newTaskCtx(ThreadTestInt, signal=signal)
+            dispatchTask(sds.db, signal):
+              sds.db.tp.spawn errorTestTask(ctx)
+              ready.wait()
+              # echo "raise error"
+              raise newException(ValueError, "fake error")
+          finally:
+            # echo "fut FutTestObj: ", obj
+            assert obj.val == 42 # need to force future to keep ref here
         try:
-          let ctx = newTaskCtx(ThreadTestInt, signal=signal)
+          block:
-          dispatchTask(sds.db, signal):
+            await runTestTask()
-            sds.db.tp.spawn errorTestTask(ctx)
+        except CatchableError as exc:
-            ready.wait()
+          # echo "caught: ", $exc
-            # echo "raise error"
+          discard
-            raise newException(ValueError, "fake error")
         finally:
-          # echo "fut FutTestObj: ", obj
+          # echo "finish"
-          assert obj.val == 42 # need to force future to keep ref here
+          check ready.load() == true
-      try:
+          GC_fullCollect()
-        block:
+          futFreed.wait("futFreed")
-          await runTestTask()
+          echo "future freed it's mem!"
-      except CatchableError as exc:
+          check futFreed.load() == true
-        # echo "caught: ", $exc
-        discard
-      finally:
-        # echo "finish"
-        check ready.load() == true
-        GC_fullCollect()
-        futFreed.wait("futFreed")
-        echo "future freed it's mem!"
-        check futFreed.load() == true
 
-        ms.fire()
+          ms.fire()
-        flag.wait("flag")
+          flag.wait("flag")
-        check flag.load() == true
+          check flag.load() == true