rpc: export simln data

Author: pinheadmz

src/backends/backend_interface.py

@@ -109,6 +109,13 @@ def get_tank_ipv4(self, index: int) -> str:
         """
         raise NotImplementedError("This method should be overridden by child class")
 
+    @abstractmethod
+    def get_lnnode_hostname(self, index: int) -> str:
+        """
+        Get the hostname assigned to a lnnode attached to a tank from the backend
+        """
+        raise NotImplementedError("This method should be overridden by child class")
+
     @abstractmethod
     def wait_for_healthy_tanks(self, warnet, timeout=60) -> bool:
         """

src/backends/compose/compose_backend.py

@@ -356,9 +356,12 @@ def add_services(self, tank: Tank, compose):
                 "networks": [tank.network_name],
             }
 
+    def get_lnnode_hostname(self, index: int) -> str:
+        return self.get_container_name(index, ServiceType.LIGHTNING)
+
     def add_lnd_service(self, tank, compose):
         services = compose["services"]
-        ln_container_name = self.get_container_name(tank.index, ServiceType.LIGHTNING)
+        ln_container_name = self.get_lnnode_hostname(tank.index)
         ln_cb_container_name = self.get_container_name(tank.index, ServiceType.CIRCUITBREAKER)
         bitcoin_container_name = self.get_container_name(tank.index, ServiceType.BITCOIN)
         # These args are appended to the Dockerfile `ENTRYPOINT ["lnd"]`
@@ -475,5 +478,10 @@ def service_from_json(self, service_name: str) -> object:
             "devices": obj.get("devices", []),
             "command": obj.get("args", []),
             "environment": obj.get("environment", []),
+            "restart": "on-failure",
             "networks": [self.network_name]
         }
+
+    def restart_service_container(self, service_name: str):
+        container = self.client.containers.get(self.get_service_container_name(service_name))
+        container.restart()

src/backends/kubernetes/kubernetes_backend.py

@@ -442,12 +442,15 @@ def remove_prometheus_service_monitors(self, tanks):
             except ResourceNotFoundError:
                 continue
 
+    def get_lnnode_hostname(self, index: int) -> str:
+        return f"lightning-{index}.{self.namespace}"
+
     def create_lnd_container(
         self, tank, bitcoind_service_name, volume_mounts
     ) -> client.V1Container:
         # These args are appended to the Dockerfile `ENTRYPOINT ["lnd"]`
         bitcoind_rpc_host = f"{bitcoind_service_name}.{self.namespace}"
-        lightning_dns = f"lightning-{tank.index}.{self.namespace}"
+        lightning_dns = self.get_lnnode_hostname(tank.index)
         args = tank.lnnode.get_conf(lightning_dns, bitcoind_rpc_host)
         self.log.debug(f"Creating lightning container for tank {tank.index} using {args=:}")
         lightning_container = client.V1Container(

src/cli/network.py

@@ -143,8 +143,11 @@ def connected(network: str):
 
 @network.command()
 @click.option("--network", default="warnet", show_default=True)
-def export(network):
+@click.option("--activity", type=str)
+def export(network: str, activity: str):
     """
-    Export all [network] data for sim-ln to subdirectory
+    Export all [network] data for a "simln" service running in a container
+    on the network. Optionally add JSON string [activity] to simln config.
+    Returns True on success.
     """
-    print(rpc_call("network_export", {"network": network}))
+    print(rpc_call("network_export", {"network": network, "activity": activity}))

src/warnet/lnnode.py

@@ -1,4 +1,5 @@
-import os
+import io
+import tarfile
 
 from backends import BackendInterface, ServiceType
 from warnet.utils import exponential_backoff, generate_ipv4_addr, handle_json
@@ -115,30 +116,38 @@ def generate_cli_command(self, command: list[str]):
                 raise Exception(f"Unsupported LN implementation: {self.impl}")
         return cmd
 
-    def export(self, config, subdir):
-        container_name = self.backend.get_container_name(self.tank.index, ServiceType.LIGHTNING)
-        macaroon_filename = f"{container_name}_admin.macaroon"
-        cert_filename = f"{container_name}_tls.cert"
-        macaroon_path = os.path.join(subdir, macaroon_filename)
-        cert_path = os.path.join(subdir, cert_filename)
+    def export(self, config: object, tar_file):
+        # Retrieve the credentials
         macaroon = self.backend.get_file(
             self.tank.index,
             ServiceType.LIGHTNING,
             "/root/.lnd/data/chain/bitcoin/regtest/admin.macaroon",
         )
-        cert = self.backend.get_file(self.tank.index, ServiceType.LIGHTNING, "/root/.lnd/tls.cert")
-
-        with open(macaroon_path, "wb") as f:
-            f.write(macaroon)
-
-        with open(cert_path, "wb") as f:
-            f.write(cert)
+        cert = self.backend.get_file(
+            self.tank.index,
+            ServiceType.LIGHTNING,
+            "/root/.lnd/tls.cert"
+        )
+        name = f"ln-{self.tank.index}"
+        macaroon_filename = f"{name}_admin.macaroon"
+        cert_filename = f"{name}_tls.cert"
+        host = self.backend.get_lnnode_hostname(self.tank.index)
+
+        # Add the files to the in-memory tar archive
+        tarinfo1 = tarfile.TarInfo(name=macaroon_filename)
+        tarinfo1.size = len(macaroon)
+        fileobj1 = io.BytesIO(macaroon)
+        tar_file.addfile(tarinfo=tarinfo1, fileobj=fileobj1)
+        tarinfo2 = tarfile.TarInfo(name=cert_filename)
+        tarinfo2.size = len(cert)
+        fileobj2 = io.BytesIO(cert)
+        tar_file.addfile(tarinfo=tarinfo2, fileobj=fileobj2)
 
         config["nodes"].append(
             {
-                "id": container_name,
-                "address": f"https://{self.ipv4}:{self.rpc_port}",
-                "macaroon": macaroon_path,
-                "cert": cert_path,
+                "id": name,
+                "address": f"https://{host}:{self.rpc_port}",
+                "macaroon": f"/simln/{macaroon_filename}",
+                "cert": f"/simln/{cert_filename}",
             }
         )

src/warnet/server.py

@@ -1,5 +1,6 @@
 import argparse
 import base64
+import io
 import json
 import logging
 import logging.config
@@ -10,6 +11,7 @@
 import signal
 import subprocess
 import sys
+import tarfile
 import tempfile
 import threading
 import time
@@ -268,20 +270,47 @@ def tank_messages(self, network: str, node_a: int, node_b: int) -> str:
             self.logger.error(msg)
             raise ServerError(message=msg) from e
 
-    def network_export(self, network: str) -> str:
+    def network_export(self, network: str, activity: str | None) -> bool:
         """
-        Export all data for sim-ln to subdirectory
+        Export all data for a simln container running on the network
         """
-        try:
-            wn = self.get_warnet(network)
-            subdir = os.path.join(wn.config_dir, "simln")
-            os.makedirs(subdir, exist_ok=True)
-            wn.export(subdir)
-            return subdir
-        except Exception as e:
-            msg = f"Error exporting network: {e}"
-            self.logger.error(msg)
-            raise ServerError(message=msg) from e
+        wn = self.get_warnet(network)
+        if "simln" not in wn.services:
+            raise Exception("No simln service in network")
+
+        # JSON object that will eventually be written to simln config file
+        config = {"nodes": []}
+        if activity:
+            config["activity"] = json.loads(activity)
+        # In-memory file to build tar archive
+        tar_buffer = io.BytesIO()
+        with tarfile.open(fileobj=tar_buffer, mode="w") as tar_file:
+            # tank LN nodes add their credentials to tar archive
+            wn.export(config, tar_file)
+            # write config file
+            config_bytes = json.dumps(config).encode('utf-8')
+            config_stream = io.BytesIO(config_bytes)
+            tarinfo = tarfile.TarInfo(name="sim.json")
+            tarinfo.size = len(config_bytes)
+            tar_file.addfile(tarinfo=tarinfo, fileobj=config_stream)
+
+        # Write the archive to the RPC server's config directory
+        source_file = wn.config_dir / "simln.tar"
+        with open(source_file, "wb") as output:
+            tar_buffer.seek(0)
+            output.write(tar_buffer.read())
+
+        if self.backend == "compose":
+            # Extract the archive into a subdirectory that is already
+            # shared with the simln container as a volume
+            subprocess.run(["tar", "-xf", source_file, "-C", wn.config_dir / 'simln'])
+            # Force quick restart of the container instead of waiting
+            # for the exponential backoff to come around
+            wn.container_interface.restart_service_container("simln")
+        if self.backend == "k8s":
+            # Copy the archive to the "emptydir" volume in the simln pod
+            wn.container_interface.write_service_config(source_file, "simln", "/simln/")
+        return True
 
     def scenarios_available(self) -> list[tuple]:
         """

src/warnet/tank.py

@@ -169,6 +169,6 @@ def apply_network_conditions(self):
                 f"Error applying network conditions to tank {self.index}: `{self.netem}` ({e})"
             )
 
-    def export(self, config, subdir):
+    def export(self, config: object, tar_file):
         if self.lnnode is not None:
-            self.lnnode.export(config, subdir)
+            self.lnnode.export(config, tar_file)

src/warnet/warnet.py

@@ -5,7 +5,6 @@
 import base64
 import json
 import logging
-import os
 import shutil
 from pathlib import Path
 
@@ -239,15 +238,9 @@ def write_prometheus_config(self):
         except Exception as e:
             logger.error(f"An error occurred while writing to {prometheus_path}: {e}")
 
-    def export(self, subdir):
-        if self.backend != "compose":
-            raise NotImplementedError("Export is only supported for compose backend")
-        config = {"nodes": []}
+    def export(self, config: object, tar_file):
         for tank in self.tanks:
-            tank.export(config, subdir)
-        config_path = os.path.join(subdir, "sim.json")
-        with open(config_path, "a") as f:
-            json.dump(config, f)
+            tank.export(config, tar_file)
 
     def wait_for_health(self):
         self.container_interface.wait_for_healthy_tanks(self)