tighten up simln and plugin interaction

Author: mplsgrant

resources/plugins/simln/charts/simln/templates/pod.yaml

@@ -4,7 +4,7 @@ metadata:
   name: {{ include "mychart.fullname" . }}
   labels:
     app: {{ include "mychart.name" . }}
-    mission: plugin
+    mission: {{ .Values.name }}
 spec:
   initContainers:
     - name: "init-container"

resources/plugins/simln/simln.py

@@ -5,7 +5,7 @@
 from subprocess import run
 from time import sleep
 
-from warnet.k8s import get_pods_with_label, wait_for_pod
+from warnet.k8s import download, get_pods_with_label, wait_for_pod
 from warnet.plugin import _get_plugin_directory as get_plugin_directory
 from warnet.process import run_command
 from warnet.status import _get_tank_status as network_status
@@ -21,17 +21,8 @@
 lightning_selector = "mission=lightning"
 
 
-# @post_deploy
-def deploy_helm():
-    print("SimLN Plugin ⚡")
-    plugin_dir = get_plugin_directory()
-    print(f"DIR: {plugin_dir}")
-    command = f"helm upgrade --install simln {plugin_dir}/simln/charts/simln"
-    helm_result = run_command(command)
-    print(helm_result)
-
-
 def run_simln():
+    """Run a SimLN Plugin demo"""
     init_network()
     fund_wallets()
     wait_for_everyone_to_have_a_host()
@@ -41,43 +32,46 @@ def run_simln():
     log.info(warnet("bitcoin rpc tank-0000 -generate 7"))
     wait_for_gossip_sync(2)
     log.info("done waiting")
-    pod_name = prepare_and_launch_activity()
+    pod_name = _prepare_and_launch_activity()
     log.info(pod_name)
     wait_for_pod(pod_name, 60)
 
 
-def prepare_and_launch_activity() -> str:
-    pods = get_pods_with_label(lightning_selector)
-    pod_a = pods[1].metadata.name
-    pod_b = pods[2].metadata.name
-    log.info(f"pod_a: {pod_a}")
-    log.info(f"pod_b: {pod_b}")
-    sample_activity = [
-        {"source": pod_a, "destination": pod_b, "interval_secs": 1, "amount_msat": 2000}
-    ]
+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
 
 
+def get_example_activity() -> list[dict]:
+    """Get an activity representing node 2 sending msat to node 3"""
+    pods = get_pods_with_label(lightning_selector)
+    pod_a = pods[1].metadata.name
+    pod_b = pods[2].metadata.name
+    return [{"source": pod_a, "destination": pod_b, "interval_secs": 1, "amount_msat": 2000}]
+
+
 def launch_activity(activity: list[dict]) -> str:
+    """Launch a SimLN chart which includes the `activity`"""
     random_digits = "".join(random.choices("0123456789", k=10))
     plugin_dir = get_plugin_directory()
-    generate_nodes_file(activity, plugin_dir / Path("simln/charts/simln/files/sim.json"))
+    _generate_nodes_file(activity, plugin_dir / Path("simln/charts/simln/files/sim.json"))
     command = f"helm upgrade --install simln-{random_digits} {plugin_dir}/simln/charts/simln"
     log.info(f"generate activity: {command}")
     run_command(command)
     return f"simln-simln-{random_digits}"
 
 
 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)
+    _wait_for_predicate(lambda: int(warnet("bitcoin rpc tank-0000 getblockcount")) > 100)
 
     def wait_for_all_ln_rpc():
         lns = get_pods_with_label(lightning_selector)
@@ -90,10 +84,11 @@ def wait_for_all_ln_rpc():
                 return False
         return True
 
-    wait_for_predicate(wait_for_all_ln_rpc)
+    _wait_for_predicate(wait_for_all_ln_rpc)
 
 
 def fund_wallets():
+    """Fund each ln node with 10 regtest coins."""
     log.info("Funding wallets")
     outputs = ""
     lns = get_pods_with_label(lightning_selector)
@@ -108,6 +103,7 @@ def fund_wallets():
 
 
 def everyone_has_a_host() -> bool:
+    """Find out if each ln node has a host."""
     pods = get_pods_with_label(lightning_selector)
     host_havers = 0
     for pod in pods:
@@ -119,10 +115,10 @@ def everyone_has_a_host() -> bool:
 
 
 def wait_for_everyone_to_have_a_host():
-    wait_for_predicate(everyone_has_a_host)
+    _wait_for_predicate(everyone_has_a_host)
 
 
-def wait_for_predicate(predicate, timeout=5 * 60, interval=5):
+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"
     )
@@ -142,9 +138,7 @@ def wait_for_predicate(predicate, timeout=5 * 60, interval=5):
 
 
 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
-    """
+    """Poll the warnet server for container status. Block until all tanks are running"""
 
     def check_status():
         tanks = network_status()
@@ -159,10 +153,11 @@ def check_status():
         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)
+    _wait_for_predicate(check_status, timeout, interval)
 
 
-def wait_for_gossip_sync(expected: int):
+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:
@@ -178,6 +173,7 @@ def wait_for_gossip_sync(expected: int):
 
 
 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)
@@ -186,7 +182,7 @@ def warnet(cmd: str = "--help"):
     return proc.stdout.decode()
 
 
-def generate_nodes_file(activity: dict, output_file: Path = Path("nodes.json")):
+def _generate_nodes_file(activity: list[dict], output_file: Path = Path("nodes.json")):
     nodes = []
 
     for i in get_pods_with_label(lightning_selector):
@@ -206,8 +202,10 @@ def generate_nodes_file(activity: dict, output_file: Path = Path("nodes.json")):
 
 
 def manual_open_channels():
+    """Manually open channels between ln nodes 1, 2, and 3"""
+
     def wait_for_two_txs():
-        wait_for_predicate(
+        _wait_for_predicate(
             lambda: json.loads(warnet("bitcoin rpc tank-0000 getmempoolinfo"))["size"] == 2
         )
 
@@ -241,3 +239,13 @@ def wait_for_two_txs():
     wait_for_two_txs()
 
     warnet("bitcoin rpc tank-0000 -generate 10")
+
+
+def list_simln_podnames() -> list[str]:
+    """Get a list of simln pod names"""
+    return [pod.metadata.name for pod in get_pods_with_label("mission=simln")]
+
+
+def download_results(pod_name: str):
+    """Download SimLN results to the current directory"""
+    download(pod_name, source_path=Path("/working/results"))

src/warnet/k8s.py

@@ -564,15 +564,22 @@ def write_kubeconfig(kube_config: dict, kubeconfig_path: str) -> None:
         raise K8sError(f"Error writing kubeconfig: {kubeconfig_path}") from e
 
 
-def download(pod_name: str, namespace: str, source_path: Path, destination_path: Path = Path(".")):
+def download(
+    pod_name: str,
+    source_path: Path,
+    destination_path: Path = Path("."),
+    namespace: Optional[str] = None,
+):
     """Download the item from the `source_path` to the `destination_path`"""
 
+    namespace = get_default_namespace_or(namespace)
+
     v1 = get_static_client()
 
     target_folder = destination_path / source_path.stem
     os.makedirs(target_folder, exist_ok=True)
 
-    command = ["tar", "cf", "-", str(source_path)]
+    command = ["tar", "cf", "-", "-C", str(source_path.parent), str(source_path.name)]
 
     resp = stream(
         v1.connect_get_namespaced_pod_exec,
@@ -594,10 +601,9 @@ def download(pod_name: str, namespace: str, source_path: Path, destination_path:
                 f.write(resp.read_stdout().encode("utf-8"))
             if resp.peek_stderr():
                 print(resp.read_stderr())
-
         resp.close()
 
     with tarfile.open(tar_file, "r") as tar:
-        tar.extractall(path=target_folder)
+        tar.extractall(path=destination_path)
 
     os.remove(tar_file)