fixups to container naming and service classes

Author: willcl-ark

src/services/dns_seed.py

@@ -3,6 +3,9 @@
 
 
 PORT = 15353
+DNS_SEED_NAME = "dns-seed"
+ZONE_FILE_NAME = "dns-seed.zone"
+NAMED_CONF_NAME = "named.conf.local"
 
 
 class DnsSeed(BaseService):
@@ -11,7 +14,7 @@ def __init__(self, docker_network, templates, config_dir):
         self.docker_network = docker_network
         self.templates = templates
         self.service = {
-            "container_name": "dns-seed",
+            "container_name": DNS_SEED_NAME,
             "ports": [f"{PORT}:53/udp", f"{PORT}:53/tcp"],
             "build": {
                 "context": ".",
@@ -20,5 +23,5 @@ def __init__(self, docker_network, templates, config_dir):
             "networks": [self.docker_network],
         }
         # Copy files for dockerfile
-        shutil.copy(str(self.templates / "dns-seed.zone"), config_dir)
-        shutil.copy(str(self.templates / "named.conf.local"), config_dir)
+        shutil.copy(str(self.templates / ZONE_FILE_NAME), config_dir)
+        shutil.copy(str(self.templates / NAMED_CONF_NAME), config_dir)

src/warnet/tank.py

@@ -40,7 +40,7 @@ def __init__(self):
         self._container = None
         self._suffix = None
         self._ipv4 = None
-        self._bitcoind_name = None
+        self._container_name = None
         self._exporter_name = None
         self.config_dir = Path()
 
@@ -118,10 +118,12 @@ def ipv4(self):
         return self._ipv4
 
     @property
-    def bitcoind_name(self):
-        if self._bitcoind_name is None:
-            self._bitcoind_name = f"{CONTAINER_PREFIX_BITCOIND}_{self.suffix}"
-        return self._bitcoind_name
+    def container_name(self):
+        if self._container_name is None:
+            self._container_name = (
+                f"{self.docker_network}_{CONTAINER_PREFIX_BITCOIND}_{self.suffix}"
+            )
+        return self._container_name
 
     @property
     def exporter_name(self):
@@ -132,7 +134,7 @@ def exporter_name(self):
     @property
     def container(self) -> Container:
         if self._container is None:
-            self._container = docker.from_env().containers.get(self.bitcoind_name)
+            self._container = docker.from_env().containers.get(self.container_name)
         return self._container
 
     @exponential_backoff()
@@ -150,19 +152,19 @@ def apply_network_conditions(self):
 
         if not sanitize_tc_netem_command(self.netem):
             logger.warning(
-                f"Not applying unsafe tc-netem conditions to container {self.bitcoind_name}: `{self.netem}`"
+                f"Not applying unsafe tc-netem conditions to container {self.container_name}: `{self.netem}`"
             )
             return
 
         # Apply the network condition to the container
         rcode, result = self.exec(self.netem)
         if rcode == 0:
             logger.info(
-                f"Successfully applied network conditions to {self.bitcoind_name}: `{self.netem}`"
+                f"Successfully applied network conditions to {self.container_name}: `{self.netem}`"
             )
         else:
             logger.error(
-                f"Error applying network conditions to {self.bitcoind_name}: `{self.netem}` ({result})"
+                f"Error applying network conditions to {self.container_name}: `{self.netem}` ({result})"
             )
 
     def write_bitcoin_conf(self, base_bitcoin_conf):
@@ -198,7 +200,7 @@ def write_torrc(self):
     def add_services(self, services):
         assert self.index is not None
         assert self.conf_file is not None
-        services[self.bitcoind_name] = {}
+        services[self.container_name] = {}
 
         # Setup bitcoind, either release binary or build from source
         if "/" and "#" in self.version:
@@ -219,12 +221,14 @@ def add_services(self, services):
                 "dockerfile": str(TEMPLATES / f"Dockerfile_{self.version}"),
             }
             # Use entrypoint for derived build, but not for compiled build
-            services[self.bitcoind_name].update({"entrypoint": "/warnet_entrypoint.sh"})
+            services[self.container_name].update(
+                {"entrypoint": "/warnet_entrypoint.sh"}
+            )
 
         # Add the bitcoind service
-        services[self.bitcoind_name].update(
+        services[self.container_name].update(
             {
-                "container_name": self.bitcoind_name,
+                "container_name": self.container_name,
                 "build": build,
                 "volumes": [
                     f"{self.conf_file}:/home/bitcoin/.bitcoin/bitcoin.conf",
@@ -257,7 +261,7 @@ def add_services(self, services):
     def add_scrapers(self, scrapers):
         scrapers.append(
             {
-                "job_name": self.bitcoind_name,
+                "job_name": self.container_name,
                 "scrape_interval": "5s",
                 "static_configs": [{"targets": [f"{self.exporter_name}:9332"]}],
             }

src/warnet/test_framework_bridge.py

@@ -33,7 +33,7 @@ def setup(self):
         warnet = Warnet.from_docker_env(self.options.network)
         for i, tank in enumerate(warnet.tanks):
             ip = tank.ipv4
-            logger.info(f"Adding TestNode {i} from {tank.bitcoind_name} with IP {ip}")
+            logger.info(f"Adding TestNode {i} from {tank.container_name} with IP {ip}")
             node = TestNode(
                 i,
                 "",  # datadir path

src/warnet/utils.py

@@ -1,4 +1,5 @@
 import functools
+import inspect
 import ipaddress
 import logging
 import os
@@ -326,3 +327,22 @@ def gen_config_dir(network: str) -> Path:
     xdg_config = os.getenv("XDG_CONFIG_HOME", os.path.expanduser("~/.config"))
     config_dir = Path(xdg_config) / "warnet" / network
     return config_dir
+
+
+def bubble_exception_str(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except Exception as e:
+            func_name = inspect.currentframe().f_code.co_name
+            local_vars = inspect.currentframe().f_locals
+            # Filter out the 'self' variable from the local_vars
+            context_str = ", ".join(
+                f"{k}={v}" for k, v in local_vars.items() if k != "self"
+            )
+            raise Exception(
+                f"Exception in function '{func_name}' with context ({context_str}): {str(e)}"
+            )
+
+    return wrapper

src/warnet/warnet.py

@@ -17,13 +17,12 @@
 from services.grafana import Grafana
 from services.tor import Tor
 from services.fork_observer import ForkObserver
-from services.dns_seed import DnsSeed
+from services.dns_seed import DnsSeed, ZONE_FILE_NAME, DNS_SEED_NAME
 from warnet.tank import Tank
-from warnet.utils import parse_bitcoin_conf, gen_config_dir
+from warnet.utils import parse_bitcoin_conf, gen_config_dir, bubble_exception_str
 
-logger = logging.getLogger("Warnet")
+logger = logging.getLogger("warnet")
 FO_CONF_NAME = "fork_observer_config.toml"
-ZONE_FILE_NAME = "dns-seed.zone"
 logging.getLogger("docker.utils.config").setLevel(logging.WARNING)
 logging.getLogger("docker.auth").setLevel(logging.WARNING)
 
@@ -60,6 +59,7 @@ def __str__(self) -> str:
         )
 
     @classmethod
+    @bubble_exception_str
     def from_graph_file(
         cls, graph_file: str, config_dir: Path, network: str = "warnet"
     ):
@@ -74,6 +74,7 @@ def from_graph_file(
         return self
 
     @classmethod
+    @bubble_exception_str
     def from_graph(cls, graph):
         self = cls(Path())
         self.graph = graph
@@ -82,6 +83,7 @@ def from_graph(cls, graph):
         return self
 
     @classmethod
+    @bubble_exception_str
     def from_network(
         cls, config_dir: Path = Path(), network: str = "warnet", tanks=True
     ):
@@ -95,6 +97,7 @@ def from_network(
         return self
 
     @classmethod
+    @bubble_exception_str
     def from_docker_env(cls, network_name):
         config_dir = gen_config_dir(network_name)
         self = cls(config_dir)
@@ -113,9 +116,11 @@ def from_docker_env(cls, network_name):
         return self
 
     @property
+    @bubble_exception_str
     def zone_file_path(self):
         return self.config_dir / ZONE_FILE_NAME
 
+    @bubble_exception_str
     def tanks_from_graph(self):
         for node_id in self.graph.nodes():
             if int(node_id) != len(self.tanks):
@@ -125,17 +130,20 @@ def tanks_from_graph(self):
             self.tanks.append(Tank.from_graph_node(node_id, self))
         logger.info(f"Imported {len(self.tanks)} tanks from graph")
 
+    @bubble_exception_str
     def write_bitcoin_confs(self):
         with open(TEMPLATES / "bitcoin.conf", "r") as file:
             text = file.read()
         base_bitcoin_conf = parse_bitcoin_conf(text)
         for tank in self.tanks:
             tank.write_bitcoin_conf(base_bitcoin_conf)
 
+    @bubble_exception_str
     def apply_network_conditions(self):
         for tank in self.tanks:
             tank.apply_network_conditions()
 
+    @bubble_exception_str
     def generate_zone_file_from_tanks(self):
         records_list = [
             f"seed.dns-seed.     300 IN  A   {tank.ipv4}" for tank in self.tanks
@@ -152,11 +160,12 @@ def generate_zone_file_from_tanks(self):
         with open(self.config_dir / ZONE_FILE_NAME, "w") as f:
             f.write(content_str)
 
+    @bubble_exception_str
     def apply_zone_file(self):
         """
         Sync the dns seed list served by dns-seed with currently active Tanks.
         """
-        seeder = self.docker.containers.get("dns-seed")
+        seeder = self.docker.containers.get(f"{self.docker_network}_{DNS_SEED_NAME}")
 
         # Read the content from the generated zone file
         with open(self.config_dir / ZONE_FILE_NAME, "r") as f:
@@ -171,6 +180,7 @@ def apply_zone_file(self):
         # Reload that single zone only
         seeder.exec_run("rndc reload dns-seed")
 
+    @bubble_exception_str
     def connect_edges(self):
         for edge in self.graph.edges():
             (src, dst) = edge
@@ -180,6 +190,7 @@ def connect_edges(self):
             cmd = f"bitcoin-cli addpeeraddress {dst_ip} 18444"
             src_tank.exec(cmd=cmd, user="bitcoin")
 
+    @bubble_exception_str
     def docker_compose_build_up(self):
         command = ["docker-compose", "-p", self.docker_network, "up", "-d", "--build"]
         try:
@@ -196,6 +207,7 @@ def docker_compose_build_up(self):
                 f"An error occurred while executing `{' '.join(command)}` in {self.config_dir}: {e}"
             )
 
+    @bubble_exception_str
     def docker_compose_up(self):
         command = ["docker-compose", "-p", self.docker_network, "up", "-d"]
         try:
@@ -212,6 +224,7 @@ def docker_compose_up(self):
                 f"An error occurred while executing `{' '.join(command)}` in {self.config_dir}: {e}"
             )
 
+    @bubble_exception_str
     def docker_compose_down(self):
         command = ["docker-compose", "down"]
         try:
@@ -228,6 +241,7 @@ def docker_compose_down(self):
                 f"An error occurred while executing `{' '.join(command)}` in {self.config_dir}: {e}"
             )
 
+    @bubble_exception_str
     def write_docker_compose(self, dns=True):
         compose = {
             "version": "3.8",
@@ -270,6 +284,7 @@ def write_docker_compose(self, dns=True):
                 f"An error occurred while writing to {docker_compose_path}: {e}"
             )
 
+    @bubble_exception_str
     def write_prometheus_config(self):
         config = {
             "global": {"scrape_interval": "15s"},