run dag connection test

Author: pinheadmz

.github/workflows/test.yml

@@ -30,7 +30,7 @@ jobs:
     strategy:
       matrix:
         # test: [scenarios_test.py, rpc_test.py, graph_test.py, ln_test.py, dag_connection_test.py, logging_test.py]
-        test: [scenarios_test.py, rpc_test.py, graph_test.py,                                       logging_test.py]
+        test: [scenarios_test.py, rpc_test.py, graph_test.py,               dag_connection_test.py, logging_test.py]
     steps:
       - uses: actions/checkout@v4
       - uses: azure/[email protected]

resources/images/commander/src/commander.py

@@ -1,6 +1,5 @@
 import argparse
 import configparser
-import ipaddress
 import json
 import logging
 import os
@@ -93,6 +92,7 @@ def setup(self):
                 cwd=self.options.tmpdir,
                 coverage_dir=self.options.coveragedir,
             )
+            node.tank = tank["tank"]
             node.rpc = get_rpc_proxy(
                 f"http://{tank['rpc_user']}:{tank['rpc_password']}@{tank['rpc_host']}:{tank['rpc_port']}",
                 i,
@@ -302,83 +302,63 @@ def connect_nodes(self, a, b, *, peer_advertises_v2=None, wait_for_connect: bool
         """
         from_connection = self.nodes[a]
         to_connection = self.nodes[b]
-
-        to_ip_port = self.warnet.tanks[b].get_dns_addr()
-        from_ip_port = self.warnet.tanks[a].get_ip_addr()
+        from_num_peers = 1 + len(from_connection.getpeerinfo())
+        to_num_peers = 1 + len(to_connection.getpeerinfo())
+        ip_port = self.nodes[b].rpchost + ":18444"
 
         if peer_advertises_v2 is None:
             peer_advertises_v2 = self.options.v2transport
 
         if peer_advertises_v2:
-            from_connection.addnode(node=to_ip_port, command="onetry", v2transport=True)
+            from_connection.addnode(node=ip_port, command="onetry", v2transport=True)
         else:
             # skip the optional third argument (default false) for
             # compatibility with older clients
-            from_connection.addnode(to_ip_port, "onetry")
+            from_connection.addnode(ip_port, "onetry")
 
         if not wait_for_connect:
             return
 
-        def get_peer_ip(peer):
-            try:  # we encounter a regular ip address
-                ip_addr = str(ipaddress.ip_address(peer["addr"].split(":")[0]))
-                return ip_addr
-            except ValueError as err:  # or we encounter a service name
-                try:
-                    # NETWORK-tank-TANK_INDEX-service
-                    # NETWORK-test-TEST-tank-TANK_INDEX-service
-                    tank_index = int(peer["addr"].split("-")[-2])
-                except (ValueError, IndexError) as inner_err:
-                    raise ValueError(
-                        "could not derive tank index from service name: {} {}".format(
-                            peer["addr"], inner_err
-                        )
-                    ) from err
-
-                ip_addr = self.warnet.tanks[tank_index].get_ip_addr()
-                return ip_addr
-
         # poll until version handshake complete to avoid race conditions
         # with transaction relaying
         # See comments in net_processing:
         # * Must have a version message before anything else
         # * Must have a verack message before anything else
         self.wait_until(
-            lambda: any(
-                peer["addr"] == to_ip_port and peer["version"] != 0
-                for peer in from_connection.getpeerinfo()
-            )
+            lambda: sum(peer["version"] != 0 for peer in from_connection.getpeerinfo())
+            == from_num_peers
         )
         self.wait_until(
-            lambda: any(
-                get_peer_ip(peer) == from_ip_port and peer["version"] != 0
-                for peer in to_connection.getpeerinfo()
-            )
+            lambda: sum(peer["version"] != 0 for peer in to_connection.getpeerinfo())
+            == to_num_peers
         )
         self.wait_until(
-            lambda: any(
-                peer["addr"] == to_ip_port and peer["bytesrecv_per_msg"].pop("verack", 0) >= 21
+            lambda: sum(
+                peer["bytesrecv_per_msg"].pop("verack", 0) >= 21
                 for peer in from_connection.getpeerinfo()
             )
+            == from_num_peers
         )
         self.wait_until(
-            lambda: any(
-                get_peer_ip(peer) == from_ip_port
-                and peer["bytesrecv_per_msg"].pop("verack", 0) >= 21
+            lambda: sum(
+                peer["bytesrecv_per_msg"].pop("verack", 0) >= 21
                 for peer in to_connection.getpeerinfo()
             )
+            == to_num_peers
         )
         # The message bytes are counted before processing the message, so make
         # sure it was fully processed by waiting for a ping.
         self.wait_until(
-            lambda: any(
-                peer["addr"] == to_ip_port and peer["bytesrecv_per_msg"].pop("pong", 0) >= 29
+            lambda: sum(
+                peer["bytesrecv_per_msg"].pop("pong", 0) >= 29
                 for peer in from_connection.getpeerinfo()
             )
+            == from_num_peers
         )
         self.wait_until(
-            lambda: any(
-                get_peer_ip(peer) == from_ip_port and peer["bytesrecv_per_msg"].pop("pong", 0) >= 29
+            lambda: sum(
+                peer["bytesrecv_per_msg"].pop("pong", 0) >= 29
                 for peer in to_connection.getpeerinfo()
             )
+            == to_num_peers
         )

resources/scripts/apidocs.py

@@ -6,7 +6,6 @@
 
 from click import Context
 from tabulate import tabulate
-
 from warnet.cli.main import cli
 
 file_path = Path(os.path.dirname(os.path.abspath(__file__))) / ".." / ".." / "docs" / "warcli.md"

resources/scripts/graphdocs.py

@@ -5,7 +5,6 @@
 from pathlib import Path
 
 from tabulate import tabulate
-
 from warnet.cli.util import load_schema
 
 graph_schema = load_schema()

src/warnet/cli/bitcoin.py

@@ -5,7 +5,6 @@
 from io import BytesIO
 
 import click
-
 from test_framework.messages import ser_uint256
 from test_framework.p2p import MESSAGEMAP
 

src/warnet/cli/namespaces.py

@@ -5,7 +5,7 @@
 import click
 import yaml
 
-from .process import stream_command, run_command
+from .process import run_command, stream_command
 
 NAMESPACES_DIR = Path("namespaces")
 DEFAULT_NAMESPACES = "two_namespaces_two_users"
@@ -14,6 +14,7 @@
 HELM_COMMAND = "helm upgrade --install"
 BITCOIN_CHART_LOCATION = "./resources/charts/namespaces"
 
+
 @click.group(name="namespaces")
 def namespaces():
     """Namespaces commands"""
@@ -35,7 +36,9 @@ def deploy(namespaces: str):
     names = [n.get("name") for n in namespaces_file["namespaces"]]
     for n in names:
         if not n.startswith("warnet-"):
-            print(f"Failled to create namespace: {n}. Namespaces must start with a 'warnet-' prefix.")
+            print(
+                f"Failled to create namespace: {n}. Namespaces must start with a 'warnet-' prefix."
+            )
 
     # deploy namespaces
     for namespace in namespaces_file["namespaces"]:
@@ -46,7 +49,9 @@ def deploy(namespaces: str):
             # all the keys apart from name
             namespace_config_override = {k: v for k, v in namespace.items() if k != "name"}
 
-            cmd = f"{HELM_COMMAND} {namespace_name} {BITCOIN_CHART_LOCATION} -f {defaults_file_path}"
+            cmd = (
+                f"{HELM_COMMAND} {namespace_name} {BITCOIN_CHART_LOCATION} -f {defaults_file_path}"
+            )
 
             if namespace_config_override:
                 with tempfile.NamedTemporaryFile(
@@ -63,6 +68,7 @@ def deploy(namespaces: str):
             print(f"Error: {e}")
             return
 
+
 @namespaces.command()
 def list():
     """List all namespaces with 'warnet-' prefix"""
@@ -78,6 +84,7 @@ def list():
     else:
         print("No warnet namespaces found.")
 
+
 @namespaces.command()
 @click.option("--all", "destroy_all", is_flag=True, help="Destroy all warnet- prefixed namespaces")
 @click.argument("namespace", required=False)

src/warnet/cli/scenarios.py

@@ -11,7 +11,6 @@
 from rich import print
 from rich.console import Console
 from rich.table import Table
-
 from warnet import scenarios as SCENARIOS
 
 from .k8s import apply_kubernetes_yaml, create_namespace, get_mission

test/dag_connection_test.py

@@ -17,7 +17,6 @@ def run_test(self):
         try:
             self.setup_network()
             self.run_connect_dag_scenario()
-            self.run_connect_dag_scenario_post_connection()
         finally:
             self.stop_server()
 
@@ -29,21 +28,8 @@ def setup_network(self):
 
     def run_connect_dag_scenario(self):
         self.log.info("Running connect_dag scenario")
-        self.log_expected_msgs = [
-            "Successfully ran the connect_dag.py scenario using a temporary file"
-        ]
-        self.log_unexpected_msgs = ["Test failed."]
         self.warcli("scenarios run-file test/data/scenario_connect_dag.py")
         self.wait_for_all_scenarios()
-        self.assert_log_msgs()
-
-    def run_connect_dag_scenario_post_connection(self):
-        self.log.info("Running connect_dag scenario")
-        self.log_expected_msgs = ["Successfully ran the connect_dag.py scenario"]
-        self.log_unexpected_msgs = ["Test failed"]
-        self.warcli("scenarios run-file test/data/scenario_connect_dag.py")
-        self.wait_for_all_scenarios()
-        self.assert_log_msgs()
 
 
 if __name__ == "__main__":

test/data/scenario_connect_dag.py

@@ -2,7 +2,6 @@
 
 import os
 from enum import Enum, auto, unique
-from time import sleep
 
 # The base class exists inside the commander container
 from commander import Commander
@@ -23,18 +22,7 @@ def set_test_params(self):
         # This is just a minimum
         self.num_nodes = 10
 
-    def add_options(self, parser):
-        parser.add_argument(
-            "--network_name",
-            dest="network_name",
-            default="warnet",
-            help="",
-        )
-
     def run_test(self):
-        while not self.warnet.network_connected():
-            sleep(1)
-
         # All permutations of a directed acyclic graph with zero, one, or two inputs/outputs
         #
         # │ Node │ In │ Out │ Con In │ Con Out │
@@ -66,12 +54,6 @@ def run_test(self):
         self.connect_nodes(5, 4)
         self.connect_nodes(5, 6)
         self.connect_nodes(6, 7)
-
-        # Nodes 8 & 9 shall come pre-connected. Attempt to connect them anyway to test the handling
-        # of dns node addresses
-        self.connect_nodes(8, 9)
-        self.connect_nodes(9, 8)
-
         self.sync_all()
 
         zero_peers = self.nodes[0].getpeerinfo()
@@ -85,31 +67,29 @@ def run_test(self):
         eight_peers = self.nodes[8].getpeerinfo()
         nine_peers = self.nodes[9].getpeerinfo()
 
-        for tank in self.warnet.tanks:
-            self.log.info(
-                f"Tank {tank.index}: {tank.warnet.tanks[tank.index].get_dns_addr()} pod:"
-                f" {tank.warnet.tanks[tank.index].get_ip_addr()}"
-            )
+        for node in self.nodes:
+            self.log.info(f"Node {node.index}: tank={node.tank} ip={node.rpchost}")
 
-        self.assert_connection(zero_peers, 2, ConnectionType.DNS)
-        self.assert_connection(one_peers, 2, ConnectionType.DNS)
-        self.assert_connection(one_peers, 3, ConnectionType.DNS)
+        self.assert_connection(zero_peers, 2, ConnectionType.IP)
+        self.assert_connection(one_peers, 2, ConnectionType.IP)
+        self.assert_connection(one_peers, 3, ConnectionType.IP)
         self.assert_connection(two_peers, 0, ConnectionType.IP)
         self.assert_connection(two_peers, 1, ConnectionType.IP)
-        self.assert_connection(two_peers, 3, ConnectionType.DNS)
-        self.assert_connection(two_peers, 4, ConnectionType.DNS)
+        self.assert_connection(two_peers, 3, ConnectionType.IP)
+        self.assert_connection(two_peers, 4, ConnectionType.IP)
         self.assert_connection(three_peers, 1, ConnectionType.IP)
         self.assert_connection(three_peers, 2, ConnectionType.IP)
-        self.assert_connection(three_peers, 5, ConnectionType.DNS)
+        self.assert_connection(three_peers, 5, ConnectionType.IP)
         self.assert_connection(four_peers, 2, ConnectionType.IP)
         self.assert_connection(four_peers, 5, ConnectionType.IP)
         self.assert_connection(five_peers, 3, ConnectionType.IP)
-        self.assert_connection(five_peers, 4, ConnectionType.DNS)
-        self.assert_connection(five_peers, 6, ConnectionType.DNS)
+        self.assert_connection(five_peers, 4, ConnectionType.IP)
+        self.assert_connection(five_peers, 6, ConnectionType.IP)
         self.assert_connection(six_peers, 5, ConnectionType.IP)
-        self.assert_connection(six_peers, 7, ConnectionType.DNS)
+        self.assert_connection(six_peers, 7, ConnectionType.IP)
         self.assert_connection(seven_peers, 6, ConnectionType.IP)
         # Check the pre-connected nodes
+        # The only connection made by DNS name would be from the initial graph edges
         self.assert_connection(eight_peers, 9, ConnectionType.DNS)
         self.assert_connection(nine_peers, 8, ConnectionType.IP)
 
@@ -121,14 +101,15 @@ def run_test(self):
     def assert_connection(self, connector, connectee_index, connection_type: ConnectionType):
         if connection_type == ConnectionType.DNS:
             assert any(
-                d.get("addr") == self.warnet.tanks[connectee_index].get_dns_addr()
+                # ignore the ...-service suffix
+                self.nodes[connectee_index].tank in d.get("addr")
                 for d in connector
-            ), f"Could not find {self.options.network_name}-tank-00000{connectee_index}-service"
+            ), "Could not find conectee hostname"
         elif connection_type == ConnectionType.IP:
             assert any(
-                d.get("addr").split(":")[0] == self.warnet.tanks[connectee_index].get_ip_addr()
+                d.get("addr").split(":")[0] == self.nodes[connectee_index].rpchost
                 for d in connector
-            ), f"Could not find Tank {connectee_index}'s ip addr"
+            ), "Could not find connectee ip addr"
         else:
             raise ValueError("ConnectionType must be of type DNS or IP")
 

test/data/scenario_p2p_interface.py

@@ -3,7 +3,6 @@
 
 # The base class exists inside the commander container
 from commander import Commander
-
 from test_framework.messages import CInv, msg_getdata
 from test_framework.p2p import P2PInterface