Open random files at blobsets_fs with "/?"

genode/blobsets/src/blobsets_fs.nim

@@ -1,5 +1,5 @@
 import std/asyncdispatch
-import std/tables, std/xmltree, std/strtabs, std/strutils, std/streams, std/xmlparser
+import std/tables, std/xmltree, std/strtabs, std/strutils, std/streams, std/xmlparser, std/random
 
 import genode, genode/signals, genode/parents, genode/servers, genode/roms
 
@@ -78,10 +78,8 @@ type
     fsSet: BlobSet
     next: Handle
     nodes: Table[Handle, Node]
-    cache: string
       ## Read files from the store into this buffer
-    cacheCid: BlobId
-      ## CID of the cache contents
+    random: int
 
   Session = ptr SessionObj | ref SessionObj | SessionObj
 
@@ -162,7 +160,12 @@ proc statusProc(state: pointer; handle: Handle): Status {.exportc.} =
     let node = session.nodes[handle]
     st.inode = 0
     st.mode = DirMode
-    if node.path != "/":
+    if node.path == "?":
+      session.store.randomApply(session.fsSet, session.random) do (id: BlobId; size: BiggestInt):
+        st.size = (culonglong)size
+        st.mode = FileMode
+        st.inode = node.inode
+    elif node.path != "/":
       session.apply(node.path) do (id: BlobId; size: BiggestInt):
         st.size = (culonglong)size
         st.mode = FileMode
@@ -197,14 +200,29 @@ proc fileProc(state: pointer; dirH: Handle; name: cstring; mode: cuint; create:
     assertInvalidHandle(dir.kind == dirNode)
     let path = if dir.path == "": name else: dir.path & "/" & name
     var success = false
-    session.apply(path) do (id: BlobId; size: BiggestInt):
-      let stream = session.store.openBlobStream(id, size, dataBlob)
-      n = Node(path: path, kind: fileNode, id: id, size: size, stream: stream)
-      success = true
+    if path == "?":
+      var retry = 16
+      while not success and retry > 0:
+        # just open something
+        session.store.randomApply(session.fsSet, session.random) do (id: BlobId; size: BiggestInt):
+          try:
+            let stream = session.store.openBlobStream(id, size, dataBlob)
+            n = Node(path: path, kind: fileNode, id: id, size: size, stream: stream)
+            session.random = rand(int.high)
+            success = true
+          except:
+            dec retry
+        inc session.random
+    else:
+      session.apply(path) do (id: BlobId; size: BiggestInt):
+        let stream = session.store.openBlobStream(id, size, dataBlob)
+        n = Node(path: path, kind: fileNode, id: id, size: size, stream: stream)
+        success = true
     if not success:
-      return (not Handle(0))
-    result = session.nextId
-    session.nodes[result] = n
+      result = (not Handle(0))
+    else:
+      result = session.nextId
+      session.nodes[result] = n
 
 proc closeProc(state: pointer; h: Handle) {.exportc.} =
   let session = cast[ptr SessionObj](state)
@@ -265,8 +283,7 @@ proc newSession(env: GenodeEnv; store: BlobStore; label: string; setId: SetId; f
     fsSetId: setId,
     fsSet: fsSet,
     nodes: initTable[Handle, Node](),
-    cache: "",
-    # Buffer for reading file data.
+    random: rand(int.high)
   )
   session.sig = env.ep.newSignalHandler do ():
     while session.cpp.packetAvail and session.cpp.readyToAck:
@@ -291,7 +308,7 @@ componentConstructHook = proc(env: GenodeEnv) =
       session = env.newSession(store, label, setId, fsSet, txBufSize)
       cap = env.ep.manage session
     sessions[id] = session
-    echo setId, " served to ", label
+    echo setId.toHex, " served to ", label
     env.parent.deliverSession(id, cap)
 
   proc processSessions(rom: RomClient) =
@@ -373,3 +390,6 @@ componentConstructHook = proc(env: GenodeEnv) =
   process sessionsRom
 
   env.parent.announce "File_system"
+
+  randomize()
+    # initialize the RNG

src/blobsets.nim

@@ -555,6 +555,12 @@ proc openIngestStream*(s: BlobStore; size = 0.BiggestInt; kind = dataBlob): Inge
   assert(not s.openIngestStreamImpl.isNil)
   s.openIngestStreamImpl(s, size, kind)
 
+proc ingest*(store: BlobStore; buf: string): Future[BlobId] {.async.} =
+  let stream = store.openIngestStream(buf.len.BiggestInt, dataBlob)
+  await stream.ingest(buf[0].unsafeAddr, buf.len)
+  let (id, size) = await stream.finish()
+  return id
+
 iterator dumpBlob*(store: BlobStore; id: BlobId): string =
   var
     stream = store.openBlobStream(id, kind=dataBlob)

tests/test_http.nim

@@ -32,26 +32,28 @@ suite "Http store":
 suite "store":
   var
     setId: SetId
+    bs: BlobSet
 
-  const count = 256
+  const count = 64
 
   test "commit":
-    var bs = newBlobSet()
+    bs = newBlobSet()
     for i in 1..count:
       let
         name = $i
-        blob = blobHash name
+        blob = waitFor client.ingest(newString(i))
+      echo "insert ", blob, " ", i
       bs = insert(bs, name, blob, i)
     setId = commit(client, bs).setId
 
   test "load":
-    var bs = load(client, setId)
+    bs = load(client, setId)
     for i in 1..count:
       let
         name = $i
-        blob = blobHash name
+        blob = blobHash newString(i)
         other = bs.search(name)
-      doAssert(other == blob)
+      #doAssert(other == blob)
     for i in 1..count:
       let
         i = i and 0x8000
@@ -60,6 +62,10 @@ suite "store":
         echo "inserted ", name, " - ", name.toKey
         echo "applied ", name, " - ", ($(i xor 0x8000)).toKey
         raiseAssert("apply succedded for a key not inserted")
+
+  test "random":
     for i in 1..count:
       store.randomApply(bs, i) do (id: BlobId; size: BiggestInt):
         echo "randomApply: ", id, " ", size
+        let stream = store.openBlobStream(id, size, dataBlob)
+        close stream