mirror of
https://github.com/logos-storage/nim-datastore.git
synced 2026-01-04 22:53:08 +00:00
141 lines
3.0 KiB
Nim
141 lines
3.0 KiB
Nim
|
|
import pkg/chronos/threadsync
|
|
import stew/results
|
|
import pkg/upraises
|
|
import pkg/taskpools
|
|
|
|
import ./key
|
|
import ./query
|
|
import ./datastore
|
|
import ./databuffer
|
|
import threading/smartptrs
|
|
|
|
import pretty
|
|
|
|
export key, query, smartptrs, databuffer
|
|
|
|
push: {.upraises: [].}
|
|
|
|
type
|
|
|
|
ThreadResultKind* {.pure.} = enum
|
|
NotReady
|
|
Success
|
|
Error
|
|
|
|
ThreadResult*[T: DataBuffer | void | ThreadDatastorePtr] = object
|
|
state*: ThreadResultKind
|
|
signal*: ThreadSignalPtr
|
|
value*: T
|
|
error*: CatchableErrorBuffer
|
|
|
|
TResult*[T] = SharedPtr[ThreadResult[T]]
|
|
|
|
ThreadBackendKind* {.pure.} = enum
|
|
NoBackend
|
|
TestBackend
|
|
FSBackend
|
|
SQliteBackend
|
|
|
|
ThreadBackend* = object
|
|
case kind*: ThreadBackendKind
|
|
of FSBackend:
|
|
root*: StringBuffer
|
|
depth*: int
|
|
caseSensitive*: bool
|
|
ignoreProtected*: bool
|
|
of SQliteBackend:
|
|
discard
|
|
of TestBackend:
|
|
count*: int
|
|
of NoBackend:
|
|
discard
|
|
|
|
ThreadDatastore* = object
|
|
tp*: Taskpool
|
|
backend*: ThreadBackendKind
|
|
ds*: Datastore
|
|
|
|
ThreadDatastorePtr* = SharedPtr[ThreadDatastore]
|
|
|
|
Test* = object
|
|
count*: ThreadBackendKind
|
|
|
|
TestPtr* = SharedPtr[Test]
|
|
|
|
proc newThreadResult*[T](
|
|
tp: typedesc[T]
|
|
): Result[TResult[T], ref CatchableError] =
|
|
let res = newSharedPtr(ThreadResult[T])
|
|
let signal = ThreadSignalPtr.new()
|
|
if signal.isErr:
|
|
return err((ref CatchableError)(msg: signal.error()))
|
|
else:
|
|
res[].signal = signal.get()
|
|
ok res
|
|
|
|
proc getTask*(
|
|
ret: TResult[DataBuffer],
|
|
backend: ThreadBackendKind,
|
|
key: KeyBuffer,
|
|
) =
|
|
# return ok(DataBuffer.new())
|
|
print "\nthrbackend: getTask: ", ret[]
|
|
print "\nthrbackend: getTask:key: ", key
|
|
let data = DataBuffer.new("hello world!")
|
|
print "\nthrbackend: getTask:data: ", data
|
|
ret[].state = Success
|
|
ret[].value = data
|
|
|
|
print "thrbackend: putTask: fire", ret[].signal.fireSync()
|
|
|
|
proc get*(
|
|
ret: TResult[DataBuffer],
|
|
tds: ThreadDatastorePtr,
|
|
key: Key,
|
|
) =
|
|
echo "thrfrontend:put: "
|
|
let bkey = StringBuffer.new(key.id())
|
|
print "bkey: ", bkey
|
|
|
|
tds[].tp.spawn getTask(ret, tds[].backend, bkey)
|
|
|
|
import os
|
|
|
|
proc putTask*(
|
|
ret: TResult[void],
|
|
backend: ThreadBackendKind,
|
|
key: KeyBuffer,
|
|
data: DataBuffer,
|
|
) =
|
|
print "\nthrbackend: putTask: ", ret[]
|
|
print "\nthrbackend: putTask:key: ", key
|
|
print "\nthrbackend: putTask:data: ", data
|
|
|
|
os.sleep(200)
|
|
print "thrbackend: putTask: fire", ret[].signal.fireSync().get()
|
|
|
|
proc put*(
|
|
ret: TResult[void],
|
|
tds: ThreadDatastorePtr,
|
|
key: Key,
|
|
data: seq[byte]
|
|
) =
|
|
echo "thrfrontend:put: "
|
|
let bkey = StringBuffer.new(key.id())
|
|
let bval = DataBuffer.new(data)
|
|
print "bkey: ", bkey
|
|
print "bval: ", bval
|
|
|
|
tds[].tp.spawn putTask(ret, tds[].backend, bkey, bval)
|
|
|
|
proc createThreadDatastore*(ret: ThreadDatastorePtr): Result[void, ref CatchableError] =
|
|
try:
|
|
echo "createThreadDatastore: start"
|
|
ret[].tp = Taskpool.new(num_threads = 2)
|
|
echo "createThreadDatastore: done"
|
|
|
|
except Exception as exc:
|
|
return err((ref DatastoreError)(msg: exc.msg))
|
|
|