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

@@ -93,6 +93,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,
@@ -292,6 +293,7 @@ def parse_args(self):
 
         PortSeed.n = self.options.port_seed
 
+
     def connect_nodes(self, a, b, *, peer_advertises_v2=None, wait_for_connect: bool = True):
         """
         Kwargs:
@@ -302,83 +304,33 @@ 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()
-            )
-        )
-        self.wait_until(
-            lambda: any(
-                get_peer_ip(peer) == from_ip_port and peer["version"] != 0
-                for peer in to_connection.getpeerinfo()
-            )
-        )
-        self.wait_until(
-            lambda: any(
-                peer["addr"] == to_ip_port and peer["bytesrecv_per_msg"].pop("verack", 0) >= 21
-                for peer in from_connection.getpeerinfo()
-            )
-        )
-        self.wait_until(
-            lambda: any(
-                get_peer_ip(peer) == from_ip_port
-                and peer["bytesrecv_per_msg"].pop("verack", 0) >= 21
-                for peer in to_connection.getpeerinfo()
-            )
-        )
+        self.wait_until(lambda: sum(peer['version'] != 0 for peer in from_connection.getpeerinfo()) == from_num_peers)
+        self.wait_until(lambda: sum(peer['version'] != 0 for peer in to_connection.getpeerinfo()) == to_num_peers)
+        self.wait_until(lambda: sum(peer['bytesrecv_per_msg'].pop('verack', 0) >= 21 for peer in from_connection.getpeerinfo()) == from_num_peers)
+        self.wait_until(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
-                for peer in from_connection.getpeerinfo()
-            )
-        )
-        self.wait_until(
-            lambda: any(
-                get_peer_ip(peer) == from_ip_port and peer["bytesrecv_per_msg"].pop("pong", 0) >= 29
-                for peer in to_connection.getpeerinfo()
-            )
-        )
+        self.wait_until(lambda: sum(peer["bytesrecv_per_msg"].pop("pong", 0) >= 29 for peer in from_connection.getpeerinfo()) == from_num_peers)
+        self.wait_until(lambda: sum(peer["bytesrecv_per_msg"].pop("pong", 0) >= 29 for peer in to_connection.getpeerinfo()) == to_num_peers)

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,22 +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 = DAGConnectionTest()

test/data/scenario_connect_dag.py

@@ -23,18 +23,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 +55,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 +68,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 +102,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"
+            ), f"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"
+            ), f"Could not find connectee ip addr"
         else:
             raise ValueError("ConnectionType must be of type DNS or IP")