make ln_init part of deploy() if ln channels are defined

Author: pinheadmz

.github/workflows/test.yml

@@ -45,7 +45,6 @@ jobs:
           - graph_test.py
           - logging_test.py
           - ln_test.py
-          - ln_basic_test.py
           - rpc_test.py
           - services_test.py
           - signet_test.py

resources/scenarios/ln_init.py

@@ -322,30 +322,32 @@ def update_policy(self, ln, txid_hex, policy, capacity):
 
         update_threads = []
         for ch in self.channels:
-            ts = threading.Thread(
-                target=update_policy,
-                args=(
-                    self,
-                    self.lns[ch["source"]],
-                    ch["txid"],
-                    ch["source_policy"],
-                    ch["capacity"],
-                ),
-            )
-            ts.start()
-            update_threads.append(ts)
-            tt = threading.Thread(
-                target=update_policy,
-                args=(
-                    self,
-                    self.lns[ch["target"]],
-                    ch["txid"],
-                    ch["target_policy"],
-                    ch["capacity"],
-                ),
-            )
-            tt.start()
-            update_threads.append(tt)
+            if "source_policy" in ch:
+                ts = threading.Thread(
+                    target=update_policy,
+                    args=(
+                        self,
+                        self.lns[ch["source"]],
+                        ch["txid"],
+                        ch["source_policy"],
+                        ch["capacity"],
+                    ),
+                )
+                ts.start()
+                update_threads.append(ts)
+            if "target_policy" in ch:
+                tt = threading.Thread(
+                    target=update_policy,
+                    args=(
+                        self,
+                        self.lns[ch["target"]],
+                        ch["txid"],
+                        ch["target_policy"],
+                        ch["capacity"],
+                    ),
+                )
+                tt.start()
+                update_threads.append(tt)
         count = len(update_threads)
 
         all(thread.join() is None for thread in update_threads)

src/warnet/control.py

@@ -252,6 +252,16 @@ def run(
     Run a scenario from a file.
     Pass `-- --help` to get individual scenario help
     """
+    return _run(scenario_file, debug, source_dir, additional_args, namespace)
+
+
+def _run(
+    scenario_file: str,
+    debug: bool,
+    source_dir,
+    additional_args: tuple[str],
+    namespace: Optional[str],
+):
     namespace = get_default_namespace_or(namespace)
 
     scenario_path = Path(scenario_file).resolve()

src/warnet/deploy.py

@@ -1,7 +1,7 @@
 import subprocess
 import sys
 import tempfile
-from multiprocessing import Process
+from multiprocessing import Process, Queue
 from pathlib import Path
 from typing import Optional
 
@@ -22,8 +22,10 @@
     NAMESPACES_CHART_LOCATION,
     NAMESPACES_FILE,
     NETWORK_FILE,
+    SCENARIOS_DIR,
     WARGAMES_NAMESPACE_PREFIX,
 )
+from .control import _run
 from .k8s import (
     get_default_namespace,
     get_default_namespace_or,
@@ -295,24 +297,42 @@ def deploy_network(directory: Path, debug: bool = False, namespace: Optional[str
     with network_file_path.open() as f:
         network_file = yaml.safe_load(f)
 
+    queue = Queue()
     processes = []
+
     for node in network_file["nodes"]:
-        p = Process(target=deploy_single_node, args=(node, directory, debug, namespace))
+        p = Process(target=deploy_single_node, args=(node, directory, debug, namespace, queue))
         p.start()
         processes.append(p)
 
     for p in processes:
         p.join()
 
+    if any([queue.get() for _ in range(queue.qsize())]):
+        _run(
+            scenario_file=SCENARIOS_DIR / "ln_init.py",
+            debug=True,
+            source_dir=SCENARIOS_DIR,
+            additional_args=None,
+            namespace=namespace,
+        )
+
 
-def deploy_single_node(node, directory: Path, debug: bool, namespace: str):
+def deploy_single_node(node, directory: Path, debug: bool, namespace: str, queue: Queue):
     defaults_file_path = directory / DEFAULTS_FILE
     click.echo(f"Deploying node: {node.get('name')}")
     temp_override_file_path = ""
     try:
         node_name = node.get("name")
         node_config_override = {k: v for k, v in node.items() if k != "name"}
 
+        if (
+            "lnd" in node_config_override
+            and "channels" in node_config_override["lnd"]
+            and len(node_config_override["lnd"]["channels"]) > 0
+        ):
+            queue.put(True)
+
         defaults_file_path = directory / DEFAULTS_FILE
         cmd = f"{HELM_COMMAND} {node_name} {BITCOIN_CHART_LOCATION} --namespace {namespace} -f {defaults_file_path}"
         if debug:

src/warnet/ln.py

@@ -4,7 +4,6 @@
 import click
 
 from .k8s import (
-    get_channels,
     get_default_namespace_or,
     get_pod,
 )
@@ -70,30 +69,3 @@ def _host(pod):
         return uris[0].split("@")[1]
     else:
         return ""
-
-
-@ln.command()
-def open_all_channels():
-    """
-    Open all channels with source policies defined in the network.yaml
-    <!> IGNORES HARD CODED CHANNEL IDs <!>
-    <!> Should only be run once or you'll end up with duplicate channels <!>
-    """
-    channels = get_channels()
-    commands = []
-    for ch in channels:
-        pk = _pubkey(ch["target"])
-        host = _host(ch["target"])
-        local_amt = ch["local_amt"]
-        push_amt = ch.get("push_amt", 0)
-        assert pk, f"{ch['target']} has no public key"
-        assert host, f"{ch['target']} has no host"
-        assert local_amt, "Channel has no local_amount"
-        commands.append(
-            (
-                ch["source"],
-                f"openchannel --node_key {pk} --connect {host} --local_amt {local_amt} --push_amt {push_amt}",
-            )
-        )
-    for command in commands:
-        _rpc(*command)

test/data/ln/network.yaml

@@ -30,7 +30,7 @@ nodes:
             block: 300
             index: 1
           target: tank-0004-ln
-          local_amt: 100000
+          capacity: 100000
           push_amt: 50000
 
   - name: tank-0004
@@ -44,7 +44,7 @@ nodes:
             block: 300
             index: 2
           target: tank-0005-ln
-          local_amt: 50000
+          capacity: 50000
           push_amt: 25000
 
   - name: tank-0005

test/ln_basic_test.py

@@ -20,7 +20,6 @@ def run_test(self):
         try:
             self.import_network()
             self.setup_network()
-            self.run_ln_init_scenario()
             self.test_channel_policies()
             self.test_payments()
         finally:
@@ -33,13 +32,7 @@ def import_network(self):
 
     def setup_network(self):
         self.log.info("Setting up network...")
-        self.log.info(self.warnet(f"deploy {self.imported_network_dir}"))
-        self.wait_for_all_tanks_status(target="running")
-
-    def run_ln_init_scenario(self):
-        self.log.info("Running LN Init scenario")
-        stream_command(f"warnet run {self.scen_dir / 'ln_init.py'} --debug")
-        self.wait_for_all_scenarios()
+        stream_command(f"warnet deploy {self.imported_network_dir}")
 
     def test_channel_policies(self):
         self.log.info("Ensuring node-level channel policy settings")