Add filtering options for name_scan.

domob1812 · domob1812 · commit 695204e96325 · 2018-10-23T17:47:17.000+02:00
This extends the "options" argument for name_scan to allow filtering of names by the number of confirmations, the prefix and a regexp as described in namecoin/namecoin-core#237. ("showExpired" is not yet implemented, as that will be part of a more general change also for other read-only RPCs in a later step.) With these options, name_scan now supports every feature of name_filter except for the "stats" mode. The latter will be removed in a follow-up change; the name_scanning.py regtest is already updated to only test name_scan (but all the new features) in this commit. This also implements namecoin/namecoin-core#16 through the new "prefix" option for name_scan.
diff --git a/doc/release-notes-namecoin.md b/doc/release-notes-namecoin.md
@@ -6,6 +6,12 @@
   can now be used to specify per-RPC encodings for names and values by setting
   the `nameEncoding` and `valueEncoding` fields, respectively.
 
+- `name_scan` now accepts an optional `options` argument, which can be used
+  to specify filtering conditions (based on number of confirmations, prefix and
+  regexp matches of a name).
+  See [#237](https://github.com/namecoin/namecoin-core/issues/237)
+  for more details.
+
 ## Version 0.17
 
 - Previously, `createrawtransaction` supported a separate argument for creating
diff --git a/src/rpc/names.cpp b/src/rpc/names.cpp
@@ -25,6 +25,7 @@
 
 #include <boost/xpressive/xpressive_dynamic.hpp>
 
+#include <algorithm>
 #include <cassert>
 #include <memory>
 #include <stdexcept>
@@ -542,18 +543,90 @@ name_scan (const JSONRPCRequest& request)
   if (request.params.size () >= 2)
     count = request.params[1].get_int ();
 
+  /* Parse and interpret the name_scan-specific options.  */
+  RPCTypeCheckObj (options,
+    {
+      {"minConf", UniValueType (UniValue::VNUM)},
+      {"maxConf", UniValueType (UniValue::VNUM)},
+      {"prefix", UniValueType (UniValue::VSTR)},
+      {"regexp", UniValueType (UniValue::VSTR)},
+    },
+    true, false);
+
+  int minConf = 1;
+  if (options.exists ("minConf"))
+    minConf = options["minConf"].get_int ();
+  if (minConf < 1)
+    throw JSONRPCError (RPC_INVALID_PARAMETER, "minConf must be >= 1");
+
+  int maxConf = -1;
+  if (options.exists ("maxConf"))
+    {
+      maxConf = options["maxConf"].get_int ();
+      if (maxConf < 0)
+        throw JSONRPCError (RPC_INVALID_PARAMETER,
+                            "maxConf must not be negative");
+    }
+
+  valtype prefix;
+  if (options.exists ("prefix"))
+    prefix = DecodeNameFromRPCOrThrow (options["prefix"], options);
+
+  bool haveRegexp = false;
+  boost::xpressive::sregex regexp;
+  if (options.exists ("regexp"))
+    {
+      haveRegexp = true;
+      regexp = boost::xpressive::sregex::compile (options["regexp"].get_str ());
+    }
+
+  /* Iterate over names and produce the result.  */
   UniValue res(UniValue::VARR);
   if (count <= 0)
     return res;
 
   MaybeWalletForRequest wallet(request);
   LOCK2 (cs_main, wallet.getLock ());
 
+  const int maxHeight = chainActive.Height () - minConf + 1;
+  int minHeight = -1;
+  if (maxConf >= 0)
+    minHeight = chainActive.Height () - maxConf + 1;
+
   valtype name;
   CNameData data;
   std::unique_ptr<CNameIterator> iter(pcoinsTip->IterateNames ());
-  for (iter->seek (start); count > 0 && iter->next (name, data); --count)
-    res.push_back (getNameInfo (options, name, data, wallet));
+  for (iter->seek (start); count > 0 && iter->next (name, data); )
+    {
+      const int height = data.getHeight ();
+      if (height > maxHeight)
+        continue;
+      if (minHeight >= 0 && height < minHeight)
+        continue;
+
+      if (name.size () < prefix.size ())
+        continue;
+      if (!std::equal (prefix.begin (), prefix.end (), name.begin ()))
+        continue;
+
+      if (haveRegexp)
+        {
+          try
+            {
+              const std::string nameStr = EncodeName (name, NameEncoding::UTF8);
+              boost::xpressive::smatch matches;
+              if (!boost::xpressive::regex_search (nameStr, matches, regexp))
+                continue;
+            }
+          catch (const InvalidNameString& exc)
+            {
+              continue;
+            }
+        }
+
+      res.push_back (getNameInfo (options, name, data, wallet));
+      --count;
+    }
 
   return res;
 }
diff --git a/test/functional/name_scanning.py b/test/functional/name_scanning.py
@@ -3,7 +3,7 @@
 # Distributed under the MIT/X11 software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-# RPC test for the name scanning functions (name_scan and name_filter).
+# RPC test for the name_scan RPC method.
 
 from test_framework.names import NameTestFramework
 from test_framework.util import *
@@ -22,83 +22,107 @@ def run_test (self):
     # Initially, all should be empty.
     assert_equal (self.node.name_scan (), [])
     assert_equal (self.node.name_scan ("foo", 10), [])
-    assert_equal (self.node.name_filter (), [])
-    assert_equal (self.node.name_filter ("", 0, 0, 0, "stat"),
-                  {"blocks": 201,"count": 0})
 
     # Register some names with various data, heights and expiration status.
     # Using both "aa" and "b" ensures that we can also check for the expected
     # comparison order between string length and lexicographic ordering.
-
-    newA = self.node.name_new ("a")
-    newAA = self.node.name_new ("aa")
-    newB = self.node.name_new ("b")
-    newC = self.node.name_new ("c")
+    newA = self.node.name_new ("d/a")
+    newAA = self.node.name_new ("d/aa")
+    newB = self.node.name_new ("d/b")
+    newC = self.node.name_new ("d/c")
     self.node.generate (15)
 
-    self.firstupdateName (0, "a", newA, "wrong value")
-    self.firstupdateName (0, "aa", newAA, "value aa")
-    self.firstupdateName (0, "b", newB, "value b")
+    self.firstupdateName (0, "d/a", newA, "wrong value")
+    self.firstupdateName (0, "d/aa", newAA, "value aa")
+    self.firstupdateName (0, "d/b", newB, "value b")
     self.node.generate (15)
-    self.firstupdateName (0, "c", newC, "value c")
-    self.node.name_update ("a", "value a")
+    self.firstupdateName (0, "d/c", newC, "value c")
+    self.node.name_update ("d/a", "value a")
     self.node.generate (20)
 
     # Check the expected name_scan data values.
     scan = self.node.name_scan ()
     assert_equal (len (scan), 4)
-    self.checkNameData (scan[0], "a", "value a", 11, False)
-    self.checkNameData (scan[1], "b", "value b", -4, True)
-    self.checkNameData (scan[2], "c", "value c", 11, False)
-    self.checkNameData (scan[3], "aa", "value aa", -4, True)
+    self.checkNameData (scan[0], "d/a", "value a", 11, False)
+    self.checkNameData (scan[1], "d/b", "value b", -4, True)
+    self.checkNameData (scan[2], "d/c", "value c", 11, False)
+    self.checkNameData (scan[3], "d/aa", "value aa", -4, True)
 
-    # Check for expected names in various name_scan calls.
-    self.checkList (self.node.name_scan (), ["a", "b", "c", "aa"])
+    # Check for expected names in various basic name_scan calls.
+    self.checkList (self.node.name_scan (), ["d/a", "d/b", "d/c", "d/aa"])
     self.checkList (self.node.name_scan ("", 0), [])
     self.checkList (self.node.name_scan ("", -1), [])
-    self.checkList (self.node.name_scan ("b"), ["b", "c", "aa"])
-    self.checkList (self.node.name_scan ("zz"), [])
-    self.checkList (self.node.name_scan ("", 2), ["a", "b"])
-    self.checkList (self.node.name_scan ("b", 1), ["b"])
-
-    # Check the expected name_filter data values.
-    scan = self.node.name_scan ()
-    assert_equal (len (scan), 4)
-    self.checkNameData (scan[0], "a", "value a", 11, False)
-    self.checkNameData (scan[1], "b", "value b", -4, True)
-    self.checkNameData (scan[2], "c", "value c", 11, False)
-    self.checkNameData (scan[3], "aa", "value aa", -4, True)
-
-    # Check for expected names in various name_filter calls.
-    height = self.node.getblockcount ()
-    self.checkList (self.node.name_filter (), ["a", "b", "c", "aa"])
-    self.checkList (self.node.name_filter ("[ac]"), ["a", "c", "aa"])
-    self.checkList (self.node.name_filter ("", 10), [])
-    self.checkList (self.node.name_filter ("", 30), ["a", "c"])
-    self.checkList (self.node.name_filter ("", 0, 0, 0),
-                    ["a", "b", "c", "aa"])
-    self.checkList (self.node.name_filter ("", 0, 0, 1), ["a"])
-    self.checkList (self.node.name_filter ("", 0, 1, 4), ["b", "c", "aa"])
-    self.checkList (self.node.name_filter ("", 0, 4, 4), [])
-    assert_equal (self.node.name_filter ("", 30, 0, 0, "stat"),
-                  {"blocks": height, "count": 2})
-
-    # Check test for "stat" argument.
-    assert_raises_rpc_error (-8, "must be the literal string 'stat'",
-                             self.node.name_filter, "", 0, 0, 0, "string")
+    self.checkList (self.node.name_scan ("d/b"), ["d/b", "d/c", "d/aa"])
+    self.checkList (self.node.name_scan ("d/zz"), [])
+    self.checkList (self.node.name_scan ("", 2), ["d/a", "d/b"])
+    self.checkList (self.node.name_scan ("d/b", 1), ["d/b"])
+
+    # Verify encoding for start argument.
+    self.checkList (self.node.name_scan ("642f63", 10, {"nameEncoding": "hex"}),
+                    ["642f63", "642f6161"])
+
+    # Verify filtering based on number of confirmations.
+    self.checkList (self.node.name_scan ("", 100, {"minConf": 35}),
+                    ["d/b", "d/aa"])
+    self.checkList (self.node.name_scan ("", 100, {"minConf": 36}), [])
+    self.checkList (self.node.name_scan ("", 100, {"maxConf": 19}), [])
+    self.checkList (self.node.name_scan ("", 100, {"maxConf": 20}),
+                    ["d/a", "d/c"])
+
+    # Verify interaction with filtering and count.
+    self.checkList (self.node.name_scan ("", 1, {"maxConf": 20}), ["d/a"])
+    self.checkList (self.node.name_scan ("", 2, {"maxConf": 20}),
+                    ["d/a", "d/c"])
+
+    # Error checks for confirmation options.
+    assert_raises_rpc_error (-8, "minConf must be >= 1",
+                             self.node.name_scan, "", 100, {"minConf": 0})
+    assert_raises_rpc_error (-8, "minConf must be >= 1",
+                             self.node.name_scan, "", 100, {"minConf": -42})
+    self.node.name_scan ("", 100, {"minConf": 1})
+    assert_raises_rpc_error (-8, "maxConf must not be negative",
+                             self.node.name_scan, "", 100, {"maxConf": -1})
+    self.node.name_scan ("", 100, {"maxConf": 0})
+
+    # Verify filtering based on prefix.
+    self.checkList (self.node.name_scan ("", 100, {"prefix": ""}),
+                    ["d/a", "d/b", "d/c", "d/aa"])
+    self.checkList (self.node.name_scan ("", 100, {"prefix": "d/a"}),
+                    ["d/a", "d/aa"])
+
+    # Check prefix and nameEncoding.
+    options = {
+        "prefix": "642f61",
+        "nameEncoding": "hex",
+    }
+    self.checkList (self.node.name_scan ("", 100, options),
+                    ["642f61", "642f6161"])
+    assert_raises_rpc_error (-1000, "Name/value is invalid for encoding ascii",
+                             self.node.name_scan, "", 100, {"prefix": "äöü"})
+
+    # Verify filtering based on regexp.
+    self.checkList (self.node.name_scan ("", 100, {"regexp": "[ac]"}),
+                    ["d/a", "d/c", "d/aa"])
+
+    # Multiple filters are combined using "and".
+    options = {
+        "prefix": "d/a",
+        "maxConf": 20,
+    }
+    self.checkList (self.node.name_scan ("", 100, options), ["d/a"])
 
     # Include a name with invalid UTF-8 to make sure it doesn't break
-    # name_filter's regexp check.
+    # the regexp check.
     self.restart_node (0, extra_args=["-nameencoding=hex"])
     hexName = "642f00ff"
     new = self.node.name_new (hexName)
     self.node.generate (10)
     self.firstupdateName (0, hexName, new, "{}")
     self.node.generate (5)
-    fullHexList = ['61', '62', '63', '6161', hexName]
+    fullHexList = ['642f61', '642f62', '642f63', hexName, '642f6161']
     self.checkList (self.node.name_scan (), fullHexList)
-    self.checkList (self.node.name_filter (), fullHexList)
-    self.checkList (self.node.name_filter ("a"), ['61', '6161'])
+    self.checkList (self.node.name_scan ("", 100, {"regexp": "a"}),
+                    ['642f61', '642f6161'])
 
   def checkList (self, data, names):
     """
@@ -112,5 +136,6 @@ def walker (e):
 
     assert_equal (dataNames, names)
 
+
 if __name__ == '__main__':
   NameScanningTest ().main ()
