Integrate lssd

Author: devrandom

contrib/pyln-testing/pyln/testing/fixtures.py

@@ -1,6 +1,6 @@
 from concurrent import futures
 from pyln.testing.db import SqliteDbProvider, PostgresDbProvider
-from pyln.testing.utils import NodeFactory, BitcoinD, ElementsD, env, LightningNode, TEST_DEBUG
+from pyln.testing.utils import NodeFactory, BitcoinD, ElementsD, env, LightningNode, TEST_DEBUG, LssD
 from pyln.client import Millisatoshi
 from typing import Dict
 
@@ -167,6 +167,25 @@ def bitcoind(directory, teardown_checks):
     bitcoind.proc.wait()
 
 
+@pytest.fixture
+def lssd(directory, teardown_checks):
+    lssd = LssD(directory)
+
+    try:
+        lssd.start()
+    except Exception:
+        lssd.stop()
+        raise
+
+    yield lssd
+
+    try:
+        lssd.stop()
+    except Exception:
+        lssd.proc.kill()
+    lssd.proc.wait()
+
+
 class TeardownErrors(object):
     def __init__(self):
         self.errors = []
@@ -449,11 +468,12 @@ def jsonschemas():
 
 
 @pytest.fixture
-def node_factory(request, directory, test_name, bitcoind, executor, db_provider, teardown_checks, node_cls, jsonschemas):
+def node_factory(request, directory, test_name, bitcoind, lssd, executor, db_provider, teardown_checks, node_cls, jsonschemas):
     nf = NodeFactory(
         request,
         test_name,
         bitcoind,
+        lssd,
         executor,
         directory=directory,
         db_provider=db_provider,

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

@@ -384,6 +384,45 @@ def f(*args):
         return f
 
 
+class LssD(TailableProc):
+    def __init__(self, directory, rpcport=None):
+        lss_dir = os.path.join(directory, 'lss')
+        TailableProc.__init__(self, lss_dir, verbose=False)
+
+        if rpcport is None:
+            self.reserved_rpcport = reserve_unused_port()
+            rpcport = self.reserved_rpcport
+        else:
+            self.reserved_rpcport = None
+
+        self.rpcport = rpcport
+        self.prefix = 'lss'
+
+        if not os.path.exists(lss_dir):
+            os.makedirs(lss_dir)
+
+        self.cmd_line = [
+            'lssd',
+            '--datadir={}'.format(lss_dir),
+            '--port={}'.format(rpcport),
+        ]
+
+    def __del__(self):
+        if self.reserved_rpcport is not None:
+            drop_unused_port(self.reserved_rpcport)
+
+    def start(self):
+        self.env['RUST_LOG'] = 'debug'
+        TailableProc.start(self)
+        self.wait_for_log("ready on", timeout=TIMEOUT)
+
+        logging.info("LssD started")
+
+    def stop(self):
+        logging.info("Stopping LssD")
+        return TailableProc.stop(self)
+
+
 class BitcoinD(TailableProc):
 
     def __init__(self, bitcoin_dir="/tmp/bitcoind-test", rpcport=None):
@@ -625,6 +664,7 @@ def __init__(
             self,
             lightning_dir,
             bitcoindproxy,
+            lssd_port,
             port=9735,
             random_hsm=False,
             node_id=0,
@@ -645,6 +685,7 @@ def __init__(
 
         self.rpcproxy = bitcoindproxy
         self.env['CLN_PLUGIN_LOG'] = "cln_plugin=trace,cln_rpc=trace,cln_grpc=trace,debug"
+        self.lssd_port = lssd_port
 
         self.opts = LIGHTNINGD_CONFIG.copy()
         opts = {
@@ -759,6 +800,8 @@ def start(self, stdin=None, wait_for_initialized=True, stderr_redir=False):
                 # We can't do this in the constructor because we need a new port on each restart.
                 self.env['REMOTE_HSMD_ENDPOINT'] = '127.0.0.1:{}'.format(self.vlsd_port)
 
+            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'],
@@ -873,7 +916,7 @@ def call(self, method, payload=None, cmdprefix=None, filter=None):
 
 
 class LightningNode(object):
-    def __init__(self, node_id, lightning_dir, bitcoind, executor, valgrind, may_fail=False,
+    def __init__(self, node_id, lightning_dir, bitcoind, lssd, executor, valgrind, may_fail=False,
                  may_reconnect=False,
                  allow_broken_log=False,
                  allow_warning=False,
@@ -883,6 +926,7 @@ def __init__(self, node_id, lightning_dir, bitcoind, executor, valgrind, may_fai
                  valgrind_plugins=True,
                  **kwargs):
         self.bitcoin = bitcoind
+        self.lssd = lssd
         self.executor = executor
         self.may_fail = may_fail
         self.may_reconnect = may_reconnect
@@ -902,6 +946,7 @@ def __init__(self, node_id, lightning_dir, bitcoind, executor, valgrind, may_fai
 
         self.daemon = LightningD(
             lightning_dir, bitcoindproxy=bitcoind.get_proxy(),
+            lssd_port=lssd.rpcport,
             port=port, random_hsm=random_hsm, node_id=node_id,
             grpc_port=self.grpc_port,
         )
@@ -1606,7 +1651,7 @@ def flock(directory: Path):
 class NodeFactory(object):
     """A factory to setup and start `lightningd` daemons.
     """
-    def __init__(self, request, testname, bitcoind, executor, directory,
+    def __init__(self, request, testname, bitcoind, lssd, executor, directory,
                  db_provider, node_cls, jsonschemas):
         if request.node.get_closest_marker("slow_test") and SLOW_MACHINE:
             self.valgrind = False
@@ -1618,6 +1663,7 @@ def __init__(self, request, testname, bitcoind, executor, directory,
         self.reserved_ports = []
         self.executor = executor
         self.bitcoind = bitcoind
+        self.lssd = lssd
         self.directory = directory
         self.lock = threading.Lock()
         self.db_provider = db_provider
@@ -1703,7 +1749,7 @@ def get_node(self, node_id=None, options=None, dbfile=None,
         db = self.db_provider.get_db(os.path.join(lightning_dir, TEST_NETWORK), self.testname, node_id)
         db.provider = self.db_provider
         node = self.node_cls(
-            node_id, lightning_dir, self.bitcoind, self.executor, self.valgrind, db=db,
+            node_id, lightning_dir, self.bitcoind, self.lssd, self.executor, self.valgrind, db=db,
             port=port, options=options, may_fail=may_fail or expect_fail,
             jsonschemas=self.jsonschemas,
             **kwargs

tests/fixtures.py

@@ -1,5 +1,5 @@
 from utils import TEST_NETWORK, VALGRIND  # noqa: F401,F403
-from pyln.testing.fixtures import directory, test_base_dir, test_name, chainparams, node_factory, bitcoind, teardown_checks, db_provider, executor, setup_logging, jsonschemas  # noqa: F401,F403
+from pyln.testing.fixtures import directory, test_base_dir, test_name, chainparams, node_factory, bitcoind, lssd, teardown_checks, db_provider, executor, setup_logging, jsonschemas  # noqa: F401,F403
 from pyln.testing import utils
 from utils import COMPAT
 from pathlib import Path

tests/test_misc.py

@@ -2549,13 +2549,13 @@ def test_unicode_rpc(node_factory, executor, bitcoind):
 
 
 @unittest.skipIf(VALGRIND, "Testing pyln doesn't exercise anything interesting in the c code.")
-def test_unix_socket_path_length(node_factory, bitcoind, directory, executor, db_provider, test_base_dir):
+def test_unix_socket_path_length(node_factory, bitcoind, lssd, directory, executor, db_provider, test_base_dir):
     lightning_dir = os.path.join(directory, "anode" + "far" * 30 + "away")
     os.makedirs(lightning_dir)
     db = db_provider.get_db(lightning_dir, "test_unix_socket_path_length", 1)
     db.provider = db_provider
 
-    l1 = LightningNode(1, lightning_dir, bitcoind, executor, VALGRIND, db=db, port=reserve())
+    l1 = LightningNode(1, lightning_dir, bitcoind, lssd, executor, VALGRIND, db=db, port=reserve())
 
     # `LightningNode.start()` internally calls `LightningRpc.getinfo()` which
     # exercises the socket logic, and raises an issue if it fails.