tests: add VLS to CLN integration suite

Author: ksedgwic

contrib/pyln-testing/pyln/testing/utils.py

@@ -78,6 +78,7 @@ def env(name, default=None):
 SLOW_MACHINE = env("SLOW_MACHINE", "0") == "1"
 DEPRECATED_APIS = env("DEPRECATED_APIS", "0") == "1"
 TIMEOUT = int(env("TIMEOUT", 180 if SLOW_MACHINE else 60))
+SUBDAEMON = env("SUBDAEMON", "")
 EXPERIMENTAL_DUAL_FUND = env("EXPERIMENTAL_DUAL_FUND", "0") == "1"
 EXPERIMENTAL_SPLICING = env("EXPERIMENTAL_SPLICING", "0") == "1"
 
@@ -578,6 +579,43 @@ def getnewaddress(self):
         return info['unconfidential']
 
 
+class ValidatingLightningSignerD(TailableProc):
+    def __init__(self, vlsd_dir, vlsd_port, node_id, network):
+        TailableProc.__init__(self, vlsd_dir, verbose=True)
+        self.executable = env("REMOTE_SIGNER_CMD", 'vlsd2')
+        os.environ['ALLOWLIST'] = env(
+            'REMOTE_SIGNER_ALLOWLIST',
+            'contrib/remote_hsmd/TESTING_ALLOWLIST')
+        self.opts = [
+            '--network={}'.format(network),
+            '--datadir={}'.format(vlsd_dir),
+            '--connect=http://localhost:{}'.format(vlsd_port),
+            '--integration-test',
+        ]
+        self.prefix = 'vlsd2-%d' % (node_id)
+        self.vlsd_port = vlsd_port
+
+    @property
+    def cmd_line(self):
+        return [self.executable] + self.opts
+
+    def start(self, stdin=None, stdout_redir=True, stderr_redir=True,
+              wait_for_initialized=True):
+        TailableProc.start(self, stdin, stdout_redir, stderr_redir)
+        # We need to always wait for initialization
+        self.wait_for_log("vlsd2 git_desc")
+        logging.info("vlsd2 started")
+
+    def stop(self, timeout=10):
+        logging.info("stopping vlsd2")
+        rc = TailableProc.stop(self, timeout)
+        logging.info("vlsd2 stopped")
+        self.logs_catchup()
+        return rc
+
+    def __del__(self):
+        self.logs_catchup()
+
 class LightningD(TailableProc):
     def __init__(
             self,
@@ -594,6 +632,12 @@ def __init__(
         self.lightning_dir = lightning_dir
         self.port = port
         self.cmd_prefix = []
+        self.lightning_dir = lightning_dir
+        self.use_vlsd = False
+        self.vlsd_dir = os.path.join(lightning_dir, "vlsd")
+        self.vlsd_port = None
+        self.vlsd = None
+        self.node_id = node_id
 
         self.rpcproxy = bitcoindproxy
         self.env['CLN_PLUGIN_LOG'] = "cln_plugin=trace,cln_rpc=trace,cln_grpc=trace,debug"
@@ -616,12 +660,38 @@ def __init__(
         if grpc_port is not None:
             opts['grpc-port'] = grpc_port
 
+        if SUBDAEMON:
+            assert node_id > 0
+            subdaemons = SUBDAEMON.split(',')
+            # VLS_SERIAL_SELECT "swaps" the selected item with the first item
+            select = env("VLS_SERIAL_SELECT", '1')
+            if node_id == int(select):
+                ndx = 1
+            elif node_id == 1:
+                ndx = int(select)
+            else:
+                ndx = node_id
+            if ndx > len(subdaemons):
+                # use the last element if not as many specifiers as nodes
+                opts['subdaemon'] = subdaemons[-1]
+            else:
+                # use the matching specifier
+                opts['subdaemon'] = subdaemons[ndx - 1]
+
+            print(f"starting node {node_id} with subdaemon {opts['subdaemon']}")
+            if SUBDAEMON == 'hsmd:remote_hsmd_socket':
+                self.use_vlsd = True
+
         for k, v in opts.items():
             self.opts[k] = v
 
         if not os.path.exists(os.path.join(lightning_dir, TEST_NETWORK)):
             os.makedirs(os.path.join(lightning_dir, TEST_NETWORK))
 
+        if self.use_vlsd:
+            if not os.path.exists(self.vlsd_dir):
+                os.makedirs(self.vlsd_dir)
+
         # Last 32-bytes of final part of dir -> seed.
         seed = (bytes(re.search('([^/]+)/*$', lightning_dir).group(1), encoding='utf-8') + bytes(32))[:32]
         if not random_hsm:
@@ -637,6 +707,10 @@ def __init__(
         self.early_opts = ['--developer']
 
     def cleanup(self):
+        if self.use_vlsd:
+            # Make sure the remotesigner is shutdown
+            self.vlsd.stop()
+
         # To force blackhole to exit, disconnect file must be truncated!
         if 'dev-disconnect' in self.opts:
             with open(self.opts['dev-disconnect'], "w") as f:
@@ -657,12 +731,65 @@ def cmd_line(self):
 
         return self.cmd_prefix + [self.executable] + self.early_opts + opts
 
+    def __del__(self):
+        if self.vlsd_port is not None:
+            drop_unused_port(self.vlsd_port)
+
     def start(self, stdin=None, wait_for_initialized=True, stderr_redir=False):
-        self.opts['bitcoin-rpcport'] = self.rpcproxy.rpcport
-        TailableProc.start(self, stdin, stdout_redir=False, stderr_redir=stderr_redir)
-        if wait_for_initialized:
-            self.wait_for_log("Server started with public key")
-        logging.info("LightningD started")
+        try:
+            self.env['VLS_LSS'] = f"http://localhost:{self.lssd_port}"
+            self.env['RUST_LOG'] = 'debug'
+            # Some of the remote hsmd proxies need a bitcoind RPC connection
+            self.env['BITCOIND_RPC_URL'] = 'http://{}:{}@localhost:{}'.format(
+                BITCOIND_CONFIG['rpcuser'],
+                BITCOIND_CONFIG['rpcpassword'],
+                BITCOIND_CONFIG['rpcport'])
+
+            # The remote hsmd proxies need to know which network we are using
+            if 'network' in self.opts:
+                self.env['VLS_NETWORK'] = self.opts['network']
+
+            self.opts['bitcoin-rpcport'] = self.rpcproxy.rpcport
+
+            if self.use_vlsd:
+                self.vlsd_port = reserve_unused_port()
+                # We can't do this in the constructor because we need a new port on each restart.
+                self.env['VLS_PORT'] = str(self.vlsd_port)
+                # Kill any previous vlsd (we may have been restarted)
+                if self.vlsd is not None:
+                    logging.info("killing prior vlsd")
+                    self.vlsd.kill()
+
+            TailableProc.start(self, stdin, stdout_redir=False, stderr_redir=stderr_redir)
+
+            if self.use_vlsd:
+                # Start the remote signer first
+                self.vlsd = ValidatingLightningSignerD(
+                    self.vlsd_dir, self.vlsd_port, self.node_id, self.opts['network'])
+                self.vlsd.start(
+                    stdin, stdout_redir=True, stderr_redir=True,
+                    wait_for_initialized=wait_for_initialized)
+
+            if wait_for_initialized:
+                self.wait_for_log("Server started with public key")
+            logging.info("LightningD started")
+        except Exception:
+            if self.use_vlsd:
+                # LightningD didn't start, stop the remotesigner
+                self.vlsd.stop()
+            raise
+
+    def stop(self, timeout=10):
+        if self.use_vlsd:
+            # Stop the remote signer first
+            self.vlsd.stop(timeout)
+        return TailableProc.stop(self, timeout)
+
+    def kill(self):
+        if self.use_vlsd:
+            # Kill the remote signer first
+            self.vlsd.kill()
+        TailableProc.kill(self)
 
     def wait(self, timeout=TIMEOUT):
         """Wait for the daemon to stop for up to timeout seconds