Replaced qnfs db with subing.IoSetSuber. Updated usages and removed d…

…b specific methods. Added test_query_not_found_escrow to test_querying.py (WebOfTrust#849)

src/keri/app/httping.py

@@ -41,7 +41,6 @@ def process_request(self, req, resp):
             req: Http request object
             resp: Http response object
 
-
         """
         sig = req.headers.get("SIGNATURE")
         ked = req.media

src/keri/core/eventing.py

@@ -41,7 +41,7 @@
 
 from . import serdering
 
-from ..db import basing, dbing
+from ..db import basing, dbing, subing
 from ..db.basing import KeyStateRecord, StateEERecord, OobiRecord
 from ..db.dbing import dgKey, snKey, fnKey, splitKeySN, splitKey
 
@@ -3324,6 +3324,7 @@ def __init__(self, *, cues=None, db=None, rvy=None,
         self.direct = True if direct else False  # process as direct mode
         self.check = True if check else False  # process as check mode
 
+
     @property
     def kevers(self):
         """
@@ -4790,7 +4791,7 @@ def escrowQueryNotFoundEvent(self, prefixer, serder, sigers, cigars=None):
         self.db.putDts(dgkey, helping.nowIso8601().encode("utf-8"))
         self.db.putSigs(dgkey, [siger.qb64b for siger in sigers])
         self.db.putEvt(dgkey, serder.raw)
-        self.db.addQnf(dgkey, serder.saidb)
+        self.db.qnfs.add(keys=(prefixer.qb64, serder.said), val=serder.saidb)
 
         for cigar in cigars:
             self.db.addRct(key=dgkey, val=cigar.verfer.qb64b + cigar.qb64b)
@@ -5935,7 +5936,7 @@ def processQueryNotFound(self):
         This allows FIFO processing of events with same prefix and sn but different
         digest.
 
-        Uses  .db.addQnf(self, key, val) which is IOVal with dups.
+        Uses .db.qnfs.add(key=(pre, said), val) which is IOVal with dups
 
         Value is dgkey for event stored in .Evt where .Evt has serder.raw of event.
 
@@ -5953,11 +5954,11 @@ def processQueryNotFound(self):
         pre = b''
         sn = 0
         while True:  # break when done
-            for ekey, edig in self.db.getQnfItemsNextIter(key=key):
+            for (pre, said), edig in self.db.qnfs.getItemIter(keys=key):
                 try:
-                    pre, _ = splitKey(ekey)  # get pre and sn from escrow item
                     # check date if expired then remove escrow.
-                    dtb = self.db.getDts(dgKey(pre, bytes(edig)))
+                    dgkey = dgKey(pre.encode("utf-8"), edig.encode("utf-8"))
+                    dtb = self.db.getDts(dgkey)
                     if dtb is None:  # othewise is a datetime as bytes
                         # no date time so raise ValidationError which unescrows below
                         logger.info("Kevery unescrow error: Missing event datetime"
@@ -5978,7 +5979,7 @@ def processQueryNotFound(self):
                                               "at dig = {}.".format(bytes(edig)))
 
                     # get the escrowed event using edig
-                    eraw = self.db.getEvt(dgKey(pre, bytes(edig)))
+                    eraw = self.db.getEvt(dgkey)
                     if eraw is None:
                         # no event so raise ValidationError which unescrows below
                         logger.info("Kevery unescrow error: Missing event at."
@@ -5990,7 +5991,7 @@ def processQueryNotFound(self):
                     eserder = serdering.SerderKERI(raw=bytes(eraw))  # escrowed event
 
                     #  get sigs and attach
-                    sigs = self.db.getSigs(dgKey(pre, bytes(edig)))
+                    sigs = self.db.getSigs(dgkey)
                     if not sigs:  # otherwise its a list of sigs
                         # no sigs so raise ValidationError which unescrows below
                         logger.info("Kevery unescrow error: Missing event sigs at."
@@ -6010,7 +6011,7 @@ def processQueryNotFound(self):
 
                     #  get nontrans endorsements
                     cigars = []
-                    cigs = self.db.getRcts(dgKey(pre, bytes(edig)))  # list of wigs
+                    cigs = self.db.getRcts(dgkey)  # list of wigs
                     for cig in cigs:
                         (_, cigar) = deReceiptCouple(cig)
                         cigars.append(cigar)
@@ -6025,7 +6026,7 @@ def processQueryNotFound(self):
 
                 except Exception as ex:  # log diagnostics errors etc
                     # error other than out of order so remove from OO escrow
-                    self.db.delQnf(dgKey(pre, edig), edig)  # removes one escrow at key val
+                    self.db.qnfs.rem(keys=(pre, said), val=edig)  # removes one escrow at key val
                     if logger.isEnabledFor(logging.DEBUG):
                         logger.exception("Kevery unescrowed: %s", ex.args[0])
                     else:
@@ -6034,7 +6035,7 @@ def processQueryNotFound(self):
                     # We don't remove all escrows at pre,sn because some might be
                     # duplicitous so we process remaining escrows in spite of found
                     # valid event escrow.
-                    self.db.delQnf(dgKey(pre, edig), edig)  # removes one escrow at key val
+                    self.db.qnfs.rem(keys=(pre, said), val=edig)   # removes one escrow at key val
                     logger.info("Kevery unescrow succeeded in valid event: "
                                 "event=%s", eserder.said)
                     logger.debug(f"event=\n{eserder.pretty()}\n")

src/keri/db/basing.py

@@ -994,7 +994,7 @@ def reopen(self, **kwa):
         self.ooes = self.env.open_db(key=b'ooes.', dupsort=True)
         self.dels = self.env.open_db(key=b'dels.', dupsort=True)
         self.ldes = self.env.open_db(key=b'ldes.', dupsort=True)
-        self.qnfs = self.env.open_db(key=b'qnfs.', dupsort=True)
+        self.qnfs = subing.IoSetSuber(db=self, subkey="qnfs.", dupsort=True)
 
         self.migs = subing.CesrSuber(db=self, subkey="migs.", klas=coring.Dater)
         self.vers = subing.Suber(db=self, subkey="vers.")
@@ -3028,97 +3028,6 @@ def delOoe(self, key, val):
         """
         return self.delIoVal(self.ooes, key, val)
 
-    def putQnfs(self, key, vals):
-        """
-        Use snKey()
-        Write each out of order escrow event dig entry from list of bytes vals to key
-        Adds to existing event indexes at key if any
-        Returns True If at least one of vals is added as dup, False otherwise
-        Duplicates are inserted in insertion order.
-        """
-        return self.putIoVals(self.qnfs, key, vals)
-
-    def addQnf(self, key, val):
-        """
-        Use snKey()
-        Add out of order escrow val bytes as dup to key in db
-        Adds to existing event indexes at key if any
-        Returns True if written else False if dup val already exists
-        Duplicates are inserted in insertion order.
-        """
-        return self.addIoVal(self.qnfs, key, val)
-
-    def getQnfs(self, key):
-        """
-        Use snKey()
-        Return list of out of order escrow event dig vals at key
-        Returns empty list if no entry at key
-        Duplicates are retrieved in insertion order.
-        """
-        return self.getIoVals(self.qnfs, key)
-
-    def getQnfLast(self, key):
-        """
-        Use snKey()
-        Return last inserted dup val of out of order escrow event dig vals at key
-        Returns None if no entry at key
-        Duplicates are retrieved in insertion order.
-        """
-        return self.getIoValLast(self.qnfs, key)
-
-    def getQnfItemsNext(self, key=b'', skip=True):
-        """
-        Use snKey()
-        Return all dups of out of order escrowed event dig items at next key after key.
-        Item is (key, val) where proem has already been stripped from val
-        If key is b'' empty then returns dup items at first key.
-        If skip is False and key is not b'' empty then returns dup items at key
-        Returns empty list if no entry at key
-        Duplicates are retrieved in insertion order.
-        """
-        return self.getIoItemsNext(self.qnfs, key, skip)
-
-    def getQnfItemsNextIter(self, key=b'', skip=True):
-        """
-        Use sgKey()
-        Return iterator of out of order escrowed event dig items at next key after key.
-        Items is (key, val) where proem has already been stripped from val
-        If key is b'' empty then returns dup items at first key.
-        If skip is False and key is not b'' empty then returns dup items at key
-        Raises StopIteration Error when empty
-        Duplicates are retrieved in insertion order.
-        """
-        return self.getIoItemsNextIter(self.qnfs, key, skip)
-
-    def cntQnfs(self, key):
-        """
-        Use snKey()
-        Return count of dup event dig at key
-        Returns zero if no entry at key
-        """
-        return self.cntIoVals(self.qnfs, key)
-
-    def delQnfs(self, key):
-        """
-        Use snKey()
-        Deletes all values at key.
-        Returns True If key exists in database Else False
-        """
-        return self.delIoVals(self.qnfs, key)
-
-    def delQnf(self, key, val):
-        """
-        Use snKey()
-        Deletes dup val at key in db.
-        Returns True If dup at  exists in db Else False
-
-        Parameters:
-            db is opened named sub db with dupsort=True
-            key is bytes of key within sub db's keyspace
-            val is dup val (does not include insertion ordering proem)
-        """
-        return self.delIoVal(self.qnfs, key, val)
-
     def putDes(self, key, vals):
         """
         Use snKey()

tests/app/test_querying.py

@@ -7,7 +7,8 @@
 
 from keri.app import habbing
 from keri.app.querying import QueryDoer, KeyStateNoticer, LogQuerier, SeqNoQuerier, AnchorQuerier
-from keri.core import parsing, eventing
+from keri.core import parsing, eventing, serdering
+from keri.db.dbing import dgKey
 
 
 def test_querying():
@@ -148,3 +149,22 @@ def test_querying():
         doist.recur(deeds=deeds)
         assert len(adoer.witq.msgs) == 1
 
+def test_query_not_found_escrow():
+    with habbing.openHby() as hby, \
+            habbing.openHby() as hby1:
+        inqHab = hby.makeHab(name="inquisitor")
+        subHab = hby1.makeHab(name="subject")
+
+        icp = inqHab.makeOwnInception()
+        subHab.psr.parseOne(ims=icp)
+        assert inqHab.pre in subHab.kevers
+
+        qry = inqHab.query(subHab.pre, route="/foo", src=inqHab.pre)
+        serder = serdering.SerderKERI(raw=qry)
+        dgkey = dgKey(inqHab.pre, serder.saidb)
+
+        subHab.db.putEvt(dgkey, serder.raw)
+        subHab.db.qnfs.add(keys=(inqHab.pre, serder.said), val=serder.saidb)
+
+        subHab.kvy.processQueryNotFound()
+        assert subHab.db.qnfs.get(dgkey) == []