simln: export data inside kubernetes network

Author: pinheadmz

src/backends/backend_interface.py

@@ -109,14 +109,20 @@ 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:
         """
         Wait for healthy status on all bitcoind nodes
         """
         raise NotImplementedError("This method should be overridden by child class")
 
-
     @abstractmethod
     def service_from_json(self, json: object):
         """

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"]`

src/backends/kubernetes/kubernetes_backend.py

@@ -3,7 +3,7 @@
 import re
 import time
 from pathlib import Path
-from typing import cast
+from typing import IO, cast
 
 import yaml
 from backends import BackendInterface, ServiceType
@@ -441,12 +441,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(
@@ -714,6 +717,14 @@ def service_from_json(self, obj):
         for pair in obj.get("environment", []):
             name, value = pair.split("=")
             env.append(client.V1EnvVar(name=name, value=value))
+        volume_mounts = []
+        volumes = []
+        for vol in obj.get("config_files", []):
+            volume_name, mount_path = vol.split(":")
+            volume_name = volume_name.replace("/", "")
+            volume_mounts.append(client.V1VolumeMount(name=volume_name, mount_path=mount_path))
+            volumes.append(client.V1Volume(name=volume_name, empty_dir=client.V1EmptyDirVolumeSource()))
+
         service_container = client.V1Container(
             name=obj["container_name_suffix"],
             image=obj["image"],
@@ -722,6 +733,13 @@ def service_from_json(self, obj):
                 privileged=True,
                 capabilities=client.V1Capabilities(add=["NET_ADMIN", "NET_RAW"]),
             ),
+            volume_mounts=volume_mounts
+        )
+        sidecar_container = client.V1Container(
+            name="sidecar",
+            image="alpine:latest",
+            command=["/bin/sh", "-c", "sleep infinity"],
+            volume_mounts=volume_mounts
         )
         service_pod = client.V1Pod(
             api_version="v1",
@@ -736,8 +754,41 @@ def service_from_json(self, obj):
             ),
             spec=client.V1PodSpec(
                 restart_policy="OnFailure",
-                containers=[service_container],
-                volumes=[],
+                containers=[service_container, sidecar_container],
+                volumes=volumes,
             ),
         )
         self.client.create_namespaced_pod(namespace=self.namespace, body=service_pod)
+
+    def write_service_config(self, service_name: str, tar_buffer: IO[bytes], destination_path: str):
+        obj = services[service_name]
+        pod_name = obj["container_name_suffix"]
+        container_name = "sidecar"
+        # Write the archive
+        resp = stream(
+            self.client.connect_get_namespaced_pod_exec,
+            pod_name,
+            self.namespace,
+            container=container_name,
+            command=["/bin/sh", "-c", "cat > /arbitrary_filename.tar"],
+            stderr=True,
+            stdin=True,
+            stdout=True,
+            tty=False,
+            _preload_content=False
+        )
+        resp.write_stdin(tar_buffer.getvalue())
+        resp.close()
+        # Unpack the archive
+        stream(
+            self.client.connect_get_namespaced_pod_exec,
+            pod_name,
+            self.namespace,
+            container=container_name,
+            command=["/bin/sh", "-c", f"tar -xf /arbitrary_filename.tar -C {destination_path}"],
+            stderr=True,
+            stdin=False,
+            stdout=True,
+            tty=False,
+            _preload_content=False
+        )

src/warnet/lnnode.py

@@ -128,12 +128,12 @@ def export(self, config: object, tar_file):
             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
-        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"
-
         tarinfo1 = tarfile.TarInfo(name=macaroon_filename)
         tarinfo1.size = len(macaroon)
         fileobj1 = io.BytesIO(macaroon)
@@ -145,8 +145,8 @@ def export(self, config: object, tar_file):
 
         config["nodes"].append(
             {
-                "id": container_name,
-                "address": f"https://{container_name}:{self.rpc_port}",
+                "id": name,
+                "address": f"https://{host}:{self.rpc_port}",
                 "macaroon": f"/simln/{macaroon_filename}",
                 "cert": f"/simln/{cert_filename}",
             }

src/warnet/server.py

@@ -275,6 +275,8 @@ def network_export(self, network: str) -> bool:
         Export all data for a simln container running on the network
         """
         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": []}
@@ -290,11 +292,17 @@ def network_export(self, network: str) -> bool:
             tarinfo.size = len(config_bytes)
             tar_file.addfile(tarinfo=tarinfo, fileobj=config_stream)
 
-        with open(wn.config_dir / "simln.tar", "wb") as output:
-            tar_buffer.seek(0)
-            output.write(tar_buffer.read())
-
-        subprocess.run(["tar", "-xf", wn.config_dir / 'simln.tar', "-C", wn.config_dir / 'simln'])
+        if self.backend == "compose":
+            # Write the archive to the RPC server's config directory
+            with open(wn.config_dir / "simln.tar", "wb") as output:
+                tar_buffer.seek(0)
+                output.write(tar_buffer.read())
+            # Extract the archive into a subdirectory that is already
+            # shared with the simln container as a volume
+            subprocess.run(["tar", "-xf", wn.config_dir / 'simln.tar', "-C", wn.config_dir / 'simln'])
+        if self.backend == "k8s":
+            # Write the archive to the "emptydir" volume in the simln pod
+            wn.container_interface.write_service_config("simln", tar_buffer, "/simln/")
         return True
 
     def scenarios_available(self) -> list[tuple]: