launch activity in one line

Author: mplsgrant

resources/plugins/simln/simln.py

@@ -1,9 +1,9 @@
+#!/usr/bin/env python3
+
 import json
 import logging
 import time
 from pathlib import Path
-from subprocess import run
-from time import sleep
 from typing import Optional
 
 import click
@@ -18,12 +18,10 @@
     get_mission,
     get_static_client,
     wait_for_init,
-    wait_for_pod,
     write_file_to_container,
 )
 from warnet.plugins import get_plugins_directory_or
 from warnet.process import run_command
-from warnet.status import _get_tank_status as network_status
 
 # To make a "mission" tag for your plugin, declare it using the variable name MISSION. This will
 # be read by the warnet log system and status system.
@@ -54,8 +52,17 @@ class SimLNError(Exception):
 # Each plugin must declare a click "group" by decorating a function named after the plugin.
 # This makes your plugin available in the plugin section of Warnet.
 @click.group()
-def simln():
+@click.pass_context
+def simln(ctx):
     """Commands for the SimLN plugin"""
+    try:
+        # check if we have set a user directory
+        ctx.obj.get(USER_DIR_TAG)
+    except Exception:
+        # if not, set the great-grandparent of this file as the user dir
+        ctx.ensure_object(dict)
+        user_dir = Path(__file__).resolve().parent.parent.parent
+        ctx.obj[USER_DIR_TAG] = Path(user_dir)
     pass
 
 
@@ -66,22 +73,6 @@ def warnet_register_plugin(register_command):
 
 # The group function name is then used in decorators to create commands. These commands are
 # available to users when they access your plugin from the command line in Warnet.
-@simln.command()
-def run_demo():
-    """Run the SimLN Plugin demo"""
-    _init_network()
-    _fund_wallets()
-    _wait_for_all_ln_nodes_to_have_a_host()
-    log.info(warnet("bitcoin rpc tank-0000 -generate 7"))
-    manual_open_channels()
-    log.info(warnet("bitcoin rpc tank-0000 -generate 7"))
-    wait_for_gossip_sync(2)
-    log.info("done waiting")
-    pod_name = prepare_and_launch_activity()
-    log.info(pod_name)
-    wait_for_pod(pod_name, 60)
-
-
 @simln.command()
 def list_simln_podnames():
     """Get a list of simln pod names"""
@@ -96,14 +87,6 @@ def download_results(pod_name: str):
     print(f"Downloaded results to: {dest}")
 
 
-def prepare_and_launch_activity() -> str:
-    sample_activity = _get_example_activity()
-    log.info(f"Activity: {sample_activity}")
-    pod_name = _launch_activity(sample_activity)
-    log.info("Sent command. Done.")
-    return pod_name
-
-
 # When we want to use a command inside our plugin and also provide that command to the user, we like
 # to create a private function whose name starts with an underscore. We also make a public function
 # with the same name except that we leave off the underscore, decorate it with the command
@@ -168,141 +151,6 @@ def launch_activity(ctx, activity: str):
     print(_launch_activity(parsed_activity, user_dir))
 
 
-def _init_network():
-    """Mine regtest coins and wait for ln nodes to come online."""
-    log.info("Initializing network")
-    wait_for_all_tanks_status(target="running")
-
-    warnet("bitcoin rpc tank-0000 createwallet miner")
-    warnet("bitcoin rpc tank-0000 -generate 110")
-    wait_for_predicate(lambda: int(warnet("bitcoin rpc tank-0000 getblockcount")) > 100)
-
-    def wait_for_all_ln_rpc():
-        lns = get_mission(LIGHTNING_MISSION)
-        for v1_pod in lns:
-            ln = v1_pod.metadata.name
-            try:
-                warnet(f"ln rpc {ln} getinfo")
-            except Exception:
-                log.info(f"LN node {ln} not ready for rpc yet")
-                return False
-        return True
-
-    wait_for_predicate(wait_for_all_ln_rpc)
-
-
-@simln.command()
-def init_network():
-    """Initialize the demo network."""
-    _init_network()
-
-
-def _fund_wallets():
-    """Fund each ln node with 10 regtest coins."""
-    log.info("Funding wallets")
-    outputs = ""
-    lns = get_mission(LIGHTNING_MISSION)
-    for v1_pod in lns:
-        lnd = v1_pod.metadata.name
-        addr = json.loads(warnet(f"ln rpc {lnd} newaddress p2wkh"))["address"]
-        outputs += f',"{addr}":10'
-    # trim first comma
-    outputs = outputs[1:]
-    log.info(warnet("bitcoin rpc tank-0000 sendmany '' '{" + outputs + "}'"))
-    log.info(warnet("bitcoin rpc tank-0000 -generate 1"))
-
-
-@simln.command()
-def fund_wallets():
-    """Fund each ln node with 10 regtest coins."""
-    _fund_wallets()
-
-
-def all_ln_nodes_have_a_host() -> bool:
-    """Find out if each ln node has a host."""
-    pods = get_mission(LIGHTNING_MISSION)
-    host_havers = 0
-    for pod in pods:
-        name = pod.metadata.name
-        result = warnet(f"ln host {name}")
-        if len(result) > 1:
-            host_havers += 1
-    return host_havers == len(pods) and host_havers != 0
-
-
-@simln.command()
-def wait_for_all_ln_nodes_to_have_a_host():
-    log.info(_wait_for_all_ln_nodes_to_have_a_host())
-
-
-def _wait_for_all_ln_nodes_to_have_a_host():
-    wait_for_predicate(all_ln_nodes_have_a_host, timeout=10 * 60)
-
-
-def wait_for_predicate(predicate, timeout=5 * 60, interval=5):
-    log.info(
-        f"Waiting for predicate ({predicate.__name__}) with timeout {timeout}s and interval {interval}s"
-    )
-    while timeout > 0:
-        try:
-            if predicate():
-                return
-        except Exception:
-            pass
-        sleep(interval)
-        timeout -= interval
-    import inspect
-
-    raise Exception(
-        f"Timed out waiting for Truth from predicate: {inspect.getsource(predicate).strip()}"
-    )
-
-
-def wait_for_all_tanks_status(target: str = "running", timeout: int = 20 * 60, interval: int = 5):
-    """Poll the warnet server for container status. Block until all tanks are running"""
-
-    def check_status():
-        tanks = network_status()
-        stats = {"total": 0}
-        # "Probably" means all tanks are stopped and deleted
-        if len(tanks) == 0:
-            return True
-        for tank in tanks:
-            status = tank["status"]
-            stats["total"] += 1
-            stats[status] = stats.get(status, 0) + 1
-        log.info(f"Waiting for all tanks to reach '{target}': {stats}")
-        return target in stats and stats[target] == stats["total"]
-
-    wait_for_predicate(check_status, timeout, interval)
-
-
-def wait_for_gossip_sync(expected: int = 2):
-    """Wait for any of the ln nodes to have an `expected` number of edges."""
-    log.info(f"Waiting for sync (expecting {expected})...")
-    current = 0
-    while current < expected:
-        current = 0
-        pods = get_mission(LIGHTNING_MISSION)
-        for v1_pod in pods:
-            node = v1_pod.metadata.name
-            chs = json.loads(run_command(f"warnet ln rpc {node} describegraph"))["edges"]
-            log.info(f"{node}: {len(chs)} channels")
-            current += len(chs)
-        sleep(1)
-    log.info("Synced")
-
-
-def warnet(cmd: str = "--help"):
-    """Pass a `cmd` to Warnet."""
-    log.info(f"Executing warnet command: {cmd}")
-    command = ["warnet"] + cmd.split()
-    proc = run(command, capture_output=True)
-    if proc.stderr:
-        raise Exception(proc.stderr.decode().strip())
-    return proc.stdout.decode()
-
-
 def _generate_activity_json(activity: list[dict]) -> str:
     nodes = []
 
@@ -321,46 +169,6 @@ def _generate_activity_json(activity: list[dict]) -> str:
     return json.dumps(data, indent=2)
 
 
-def manual_open_channels():
-    """Manually open channels between ln nodes 1, 2, and 3"""
-
-    def wait_for_two_txs():
-        wait_for_predicate(
-            lambda: json.loads(warnet("bitcoin rpc tank-0000 getmempoolinfo"))["size"] == 2
-        )
-
-    # 0 -> 1 -> 2
-    pk1 = warnet("ln pubkey tank-0001-ln")
-    pk2 = warnet("ln pubkey tank-0002-ln")
-    log.info(f"pk1: {pk1}")
-    log.info(f"pk2: {pk2}")
-
-    host1 = ""
-    host2 = ""
-
-    while not host1 or not host2:
-        if not host1:
-            host1 = warnet("ln host tank-0001-ln")
-        if not host2:
-            host2 = warnet("ln host tank-0002-ln")
-        sleep(1)
-
-    print(
-        warnet(
-            f"ln rpc tank-0000-ln openchannel --node_key {pk1} --local_amt 100000 --connect {host1}"
-        )
-    )
-    print(
-        warnet(
-            f"ln rpc tank-0001-ln openchannel --node_key {pk2} --local_amt 100000 --connect {host2}"
-        )
-    )
-
-    wait_for_two_txs()
-
-    warnet("bitcoin rpc tank-0000 -generate 10")
-
-
 def _sh(pod, method: str, params: tuple[str, ...]) -> str:
     namespace = get_default_namespace()
 
@@ -403,5 +211,9 @@ def _sh(pod, method: str, params: tuple[str, ...]) -> str:
 @click.argument("method", type=str)
 @click.argument("params", type=str, nargs=-1)  # this will capture all remaining arguments
 def sh(pod: str, method: str, params: tuple[str, ...]):
-    """Run commands on a pod"""
+    """Run shell commands in a pod"""
     print(_sh(pod, method, params))
+
+
+if __name__ == "__main__":
+    simln()

test/ln_test.py

@@ -6,7 +6,7 @@
 
 from test_base import TestBase
 
-from warnet.process import stream_command
+from warnet.process import run_command, stream_command
 
 
 class LNTest(TestBase):
@@ -15,13 +15,15 @@ def __init__(self):
         self.graph_file = Path(os.path.dirname(__file__)) / "data" / "LN_10.json"
         self.imported_network_dir = self.tmpdir / "imported_network"
         self.scen_dir = Path(os.path.dirname(__file__)).parent / "resources" / "scenarios"
+        self.plugins_dir = Path(os.path.dirname(__file__)).parent / "resources" / "plugins"
 
     def run_test(self):
         try:
             self.import_network()
             self.setup_network()
             self.test_channel_policies()
             self.test_payments()
+            self.run_simln()
         finally:
             self.cleanup()
 
@@ -81,6 +83,14 @@ def get_and_pay(src, tgt):
         get_and_pay(8, 7)
         get_and_pay(4, 6)
 
+    def run_simln(self):
+        self.log.info("Running activity")
+        activity_cmd = f"{self.plugins_dir}/simln/simln.py get-example-activity"
+        activity = run_command(activity_cmd).strip()
+        self.log.info(f"Activity: {activity}")
+        command = f"{self.plugins_dir}/simln/simln.py launch-activity '{activity}'"
+        self.log.info(run_command(command))
+
 
 if __name__ == "__main__":
     test = LNTest()

test/simln_test.py

@@ -8,6 +8,7 @@
 from typing import Optional
 
 import pexpect
+from ln_test import LNTest
 from test_base import TestBase
 
 from warnet.k8s import download, get_pods_with_label, pod_log, wait_for_pod
@@ -16,40 +17,35 @@
 lightning_selector = "mission=lightning"
 
 
-class SimLNTest(TestBase):
+class SimLNTest(LNTest, TestBase):
     def __init__(self):
         super().__init__()
         self.network_dir = Path(os.path.dirname(__file__)) / "data" / "ln"
+        self.plugins_dir = Path(os.path.dirname(__file__)).parent / "resources" / "plugins"
 
     def run_test(self):
         try:
             os.chdir(self.tmpdir)
+            self.init_directory()
+
+            self.import_network()
             self.setup_network()
-            self.run_plugin()
+            self.run_ln_init_scenario()
+            self.run_simln()
+
             self.copy_results()
             self.run_activity()
             self.run_activity_with_user_dir()
         finally:
             self.cleanup()
 
-    def setup_network(self):
-        self.log.info("Setting up network")
-        self.log.info(self.warnet(f"deploy {self.network_dir}"))
-        self.wait_for_all_tanks_status(target="running")
-
-    def run_plugin(self):
+    def init_directory(self):
         self.log.info("Initializing SimLN plugin...")
         self.sut = pexpect.spawn("warnet init")
         self.sut.expect("network", timeout=10)
         self.sut.sendline("n")
         self.sut.close()
 
-        cmd = "warnet plugins simln run-demo"
-        self.log.info(f"Running: {cmd}")
-        run_command(cmd)
-        self.wait_for_predicate(self.found_results_remotely)
-        self.log.info("Ran SimLn plugin.")
-
     def copy_results(self):
         self.log.info("Copying results")
         pod = get_pods_with_label("mission=simln")[0]
@@ -59,6 +55,9 @@ def copy_results(self):
         log_resp = pod_log(pod.metadata.name, "simln")
         self.log.info(log_resp.data.decode("utf-8"))
 
+        partial_func = partial(self.found_results_remotely, pod.metadata.name)
+        self.wait_for_predicate(partial_func)
+
         download(pod.metadata.name, Path("/working/results"), Path("."), pod.metadata.namespace)
         self.wait_for_predicate(self.found_results_locally)