scenarios_test passing

Author: pinheadmz

resources/images/commander/src/commander.py

@@ -52,19 +52,6 @@ def ensure_miner(node):
             node.createwallet("miner", descriptors=True)
         return node.get_wallet_rpc("miner")
 
-    def network_connected(self):
-        for tank in self.nodes:
-            peerinfo = tank.getpeerinfo()
-            manuals = 0
-            for peer in peerinfo:
-                if peer["connection_type"] == "manual":
-                    manuals += 1
-            # Even if more edges are specifed, bitcoind only allows
-            # 8 manual outbound connections
-            if min(8, len(tank.init_peers)) > manuals:
-                return False
-        return True
-
     def handle_sigterm(self, signum, frame):
         print("SIGTERM received, stopping...")
         self.shutdown()

src/warnet/cli/k8s.py

@@ -92,3 +92,8 @@ def apply_kubernetes_yaml(yaml_file: str):
 def delete_namespace(namespace: str):
     command = f"kubectl delete namespace {namespace}"
     return stream_command(command)
+
+
+def delete_pod(pod_name: str):
+    command = f"kubectl delete pod {pod_name}"
+    return stream_command(command)

src/warnet/cli/scenarios.py

@@ -28,7 +28,7 @@ def available():
     """
     console = Console()
 
-    scenario_list = []
+    scenario_list = _available()
     for s in pkgutil.iter_modules(SCENARIOS.__path__):
         scenario_list.append(s.name)
 
@@ -41,6 +41,13 @@ def available():
     console.print(table)
 
 
+def _available():
+    scenario_list = []
+    for s in pkgutil.iter_modules(SCENARIOS.__path__):
+        scenario_list.append(s.name)
+    return scenario_list
+
+
 @scenarios.command(context_settings={"ignore_unknown_options": True})
 @click.argument("scenario", type=str)
 @click.argument("additional_args", nargs=-1, type=click.UNPROCESSED)
@@ -56,14 +63,32 @@ def run(scenario, additional_args):
     # Ensure the scenario file exists within the package
     with importlib.resources.path(scenario_package, scenario_filename) as scenario_path:
         scenario_path = str(scenario_path)  # Convert Path object to string
+    return run_scenario(scenario_path, additional_args)
+
+
+@scenarios.command(context_settings={"ignore_unknown_options": True})
+@click.argument("scenario_path", type=str)
+@click.argument("additional_args", nargs=-1, type=click.UNPROCESSED)
+def run_file(scenario_path, additional_args):
+    """
+    Run <scenario_path> from the Warnet Test Framework with optional arguments
+    """
+    if not scenario_path.endswith(".py"):
+        print("Error. Currently only python scenarios are supported")
+        sys.exit(1)
+    return run_scenario(scenario_path, additional_args)
+
 
+def run_scenario(scenario_path, additional_args):
     if not os.path.exists(scenario_path):
-        raise Exception(f"Scenario {scenario} not found at {scenario_path}.")
+        raise Exception(f"Scenario file not found at {scenario_path}.")
 
     with open(scenario_path) as file:
         scenario_text = file.read()
 
-    name = f"commander-{scenario.replace('_', '')}-{int(time.time())}"
+    scenario_name = os.path.splitext(os.path.basename(scenario_path))[0]
+
+    name = f"commander-{scenario_name.replace('_', '')}-{int(time.time())}"
 
     tankpods = get_mission("tank")
     tanks = [
@@ -142,37 +167,12 @@ def run(scenario, additional_args):
     apply_kubernetes_yaml(temp_file_path)
 
 
-@scenarios.command(context_settings={"ignore_unknown_options": True})
-@click.argument("scenario_path", type=str)
-@click.argument("additional_args", nargs=-1, type=click.UNPROCESSED)
-@click.option("--name", type=str)
-def run_file(scenario_path, additional_args, name=""):
-    """
-    Run <scenario_path> from the Warnet Test Framework with optional arguments
-    """
-    if not scenario_path.endswith(".py"):
-        print("Error. Currently only python scenarios are supported")
-        sys.exit(1)
-    scenario_name = name if name else os.path.splitext(os.path.basename(scenario_path))[0]
-    scenario_base64 = ""
-    with open(scenario_path, "rb") as f:
-        scenario_base64 = base64.b64encode(f.read()).decode("utf-8")
-
-    params = {
-        "scenario_base64": scenario_base64,
-        "scenario_name": scenario_name,
-        "additional_args": additional_args,
-    }
-    # TODO
-    # print(rpc_call("scenarios_run_file", params))
-
-
 @scenarios.command()
 def active():
     """
     List running scenarios "name": "pid" pairs
     """
-    commanders = get_mission("commander")
+    commanders = _active()
     if len(commanders) == 0:
         print("No scenarios running")
         return
@@ -182,7 +182,12 @@ def active():
     table.add_column("Status")
 
     for commander in commanders:
-        table.add_row(commander.metadata.name, commander.status.phase)
+        table.add_row(commander["commander"], commander["status"])
 
     console = Console()
     console.print(table)
+
+
+def _active():
+    commanders = get_mission("commander")
+    return [{"commander": c.metadata.name, "status": c.status.phase.lower()} for c in commanders]

src/warnet/scenarios/miner_std.py

@@ -46,10 +46,7 @@ def add_options(self, parser):
         )
 
     def run_test(self):
-        while not self.network_connected():
-            self.log.info("Waiting for complete network connection...")
-            sleep(5)
-        self.log.info("Network connected. Starting miners.")
+        self.log.info("Starting miners.")
 
         max_miners = 1
         if self.options.allnodes:

test/data/scenario_p2p_interface.py

@@ -4,8 +4,9 @@
 
 from test_framework.messages import CInv, msg_getdata
 from test_framework.p2p import P2PInterface
-from warnet.test_framework_bridge import WarnetTestFramework
 
+# The base class exists inside the commander container
+from commander import Commander
 
 def cli_help():
     return "Run P2P GETDATA test"
@@ -21,20 +22,15 @@ def on_block(self, message):
         self.blocks[message.block.sha256] += 1
 
 
-class GetdataTest(WarnetTestFramework):
+class GetdataTest(Commander):
     def set_test_params(self):
         self.num_nodes = 1
 
     def run_test(self):
-        while not self.warnet.network_connected():
-            self.log.info("Waiting for complete network connection...")
-            sleep(5)
-        self.log.info("Network connected")
-
         self.log.info("Adding the p2p connection")
 
         p2p_block_store = self.nodes[0].add_p2p_connection(
-            P2PStoreBlock(), dstaddr=self.warnet.tanks[0].ipv4, dstport=18444
+            P2PStoreBlock(), dstaddr=self.nodes[0].rpchost, dstport=18444
         )
 
         self.log.info("test that an invalid GETDATA doesn't prevent processing of future messages")

test/scenarios_test.py

@@ -2,7 +2,9 @@
 
 import os
 from pathlib import Path
-
+from warnet.cli.scenarios import _available as scenarios_available
+from warnet.cli.scenarios import _active as scenarios_active
+from warnet.cli.k8s import delete_pod
 from test_base import TestBase
 
 
@@ -13,7 +15,6 @@ def __init__(self):
 
     def run_test(self):
         try:
-            self.start_server()
             self.setup_network()
             self.test_scenarios()
         finally:
@@ -23,85 +24,71 @@ def setup_network(self):
         self.log.info("Setting up network")
         self.log.info(self.warcli(f"network start {self.graph_file_path}"))
         self.wait_for_all_tanks_status(target="running")
+        self.wait_for_all_edges()
 
     def test_scenarios(self):
         self.check_available_scenarios()
-        self.run_and_check_miner_scenario("miner_std")
-        self.run_and_check_miner_scenario_from_file("src/warnet/scenarios/miner_std.py")
-        self.run_and_check_scenario_from_file("test/data/scenario_p2p_interface.py")
+        self.run_and_check_miner_scenario()
+        self.run_and_check_miner_scenario_from_file()
+        self.run_and_check_scenario_from_file()
 
     def check_available_scenarios(self):
         self.log.info("Checking available scenarios")
         # Use rpc instead of warcli so we get raw JSON object
-        scenarios = self.rpc("scenarios_available")
+        scenarios = scenarios_available()
         assert len(scenarios) == 4, f"Expected 4 available scenarios, got {len(scenarios)}"
         self.log.info(f"Found {len(scenarios)} available scenarios")
 
     def scenario_running(self, scenario_name: str):
         """Check that we are only running a single scenario of the correct name"""
-        active = self.rpc("scenarios_list_running")
-        running = scenario_name in active[0]["cmd"]
-        return running and len(active) == 1
+        active = scenarios_active()
+        assert len(active) == 1
+        return scenario_name in active[0]["commander"]
 
-    def run_and_check_scenario_from_file(self, scenario_file):
-        scenario_name = self.get_scenario_name_from_path(scenario_file)
+    def run_and_check_scenario_from_file(self):
+        scenario_file = "test/data/scenario_p2p_interface.py"
 
         def check_scenario_clean_exit():
-            running = self.rpc("scenarios_list_running")
-            scenarios = [s for s in running if s["cmd"].strip() == scenario_name]
-            if not scenarios:
-                return False
-            scenario = scenarios[0]
-            if scenario["active"]:
-                return False
-            if scenario["return_code"] != 0:
-                raise Exception(
-                    f"Scenario {scenario_name} failed with return code {scenario['return_code']}"
-                )
-            return True
-
-        self.log.info(f"Running scenario: {scenario_name}")
+            active = scenarios_active()
+            assert len(active) == 1
+            return active[0]["status"] == "succeeded"
+
+        self.log.info(f"Running scenario from: {scenario_file}")
         self.warcli(f"scenarios run-file {scenario_file}")
         self.wait_for_predicate(lambda: check_scenario_clean_exit())
 
-    def run_and_check_miner_scenario(self, scenario_name):
-        self.log.info(f"Running scenario: {scenario_name}")
-        self.warcli(f"scenarios run {scenario_name} --allnodes --interval=1")
-        self.wait_for_predicate(lambda: self.scenario_running(scenario_name))
+    def run_and_check_miner_scenario(self):
+        sc = "miner_std"
+        self.log.info(f"Running scenario {sc}")
+        self.warcli(f"scenarios run {sc} --allnodes --interval=1")
+        self.wait_for_predicate(lambda: self.scenario_running("commander-minerstd"))
         self.wait_for_predicate(lambda: self.check_blocks(30))
         self.stop_scenario()
 
-    def run_and_check_miner_scenario_from_file(self, scenario_file):
+    def run_and_check_miner_scenario_from_file(self):
+        scenario_file = "src/warnet/scenarios/miner_std.py"
         self.log.info(f"Running scenario from file: {scenario_file}")
         self.warcli(f"scenarios run-file {scenario_file} --allnodes --interval=1")
         start = int(self.warcli("bitcoin rpc 0 getblockcount"))
-        scenario_name = self.get_scenario_name_from_path(scenario_file)
-        self.wait_for_predicate(lambda: self.scenario_running(scenario_name))
+        self.wait_for_predicate(lambda: self.scenario_running("commander-minerstd"))
         self.wait_for_predicate(lambda: self.check_blocks(2, start=start))
         self.stop_scenario()
 
-    def get_scenario_name_from_path(self, scenario_file):
-        return os.path.splitext(os.path.basename(scenario_file))[0]
-
     def check_blocks(self, target_blocks, start: int = 0):
-        running = self.rpc("scenarios_list_running")
-        assert len(running) == 1, f"Expected one running scenario, got {len(running)}"
-        assert running[0]["active"], "Scenario should be active"
-
         count = int(self.warcli("bitcoin rpc 0 getblockcount"))
         self.log.debug(f"Current block count: {count}, target: {start + target_blocks}")
         return count >= start + target_blocks
 
     def stop_scenario(self):
         self.log.info("Stopping running scenario")
-        running = self.rpc("scenarios_list_running")
+        running = scenarios_active()
         assert len(running) == 1, f"Expected one running scenario, got {len(running)}"
-        assert running[0]["active"], "Scenario should be active"
-        self.warcli(f"scenarios stop {running[0]['pid']}", False)
+        assert running[0]["status"] == "running", "Scenario should be running"
+        delete_pod(running[0]["commander"])
         self.wait_for_predicate(self.check_scenario_stopped)
 
     def check_scenario_stopped(self):
-        running = self.rpc("scenarios_list_running")
+        running = scenarios_active()
         self.log.debug(f"Checking if scenario stopped. Running scenarios: {len(running)}")
         return len(running) == 0