parametrized rpc endpoint for majority mode

Author: felix314159

src/ethereum_test_rpc/rpc.py

@@ -104,7 +104,8 @@ def post_request(
         }
         headers = base_header | self.extra_headers | extra_headers
 
-        print(f"Sending RPC request to {self.url}, timeout is set to {timeout}...")
+        # print(f"Sending RPC request to {self.url}, timeout is set to {timeout}...")
+        print(f"Sending RPC request, timeout is set to {timeout}...")  # don't leak url in logs
         response = requests.post(self.url, json=json, headers=headers, timeout=timeout)
         response.raise_for_status()
         response_json = response.json()

src/pytest_plugins/execute/eth_config/eth_config.py

@@ -3,10 +3,9 @@
 import re
 from os.path import realpath
 from pathlib import Path
-from typing import Dict, List, Tuple
+from typing import Dict, List
 
 import pytest
-import requests
 
 from ethereum_test_rpc import EthRPC
 
@@ -78,6 +77,7 @@ def pytest_configure(config: pytest.Config) -> None:
     network_name = config.getoption("network")
     network_configs_path = config.getoption("network_config_file")
     clients = config.getoption("clients")
+    rpc_endpoint = config.getoption("rpc_endpoint")
 
     # set flags for defining whether to run majority eth_config test or not, and how
     config.option.majority_eth_config_test_enabled = False
@@ -109,27 +109,29 @@ def pytest_configure(config: pytest.Config) -> None:
     print(f"Activating majority mode\nProvided client list: {clients}")
 
     # store majority mode configuration
-    config.option.majority_eth_config_test_enabled = True
-    config.option.majority_clients = clients  # List[str]
+    if ".ethpandaops.io" in rpc_endpoint:
+        print("Ethpandaops RPC detected, toggling majority test on")
+        config.option.majority_eth_config_test_enabled = True
+        config.option.majority_clients = clients  # List[str]
+    else:
+        print("No ethpandaops RPC detected, majority test will not be toggled on")
 
     if config.getoption("collectonly", default=False):
         return
 
     # Test out the RPC endpoint to be able to fail fast if it's not working
-    eth_rpc = EthRPC(config.getoption("rpc_endpoint"))
+    eth_rpc = EthRPC(rpc_endpoint)
     try:
         print("Will now perform a connection check (request chain_id)..")
         chain_id = eth_rpc.chain_id()
-        print(f"Connection check ok (successfully got chain id {chain_id} from {eth_rpc.url})")
+        print(f"Connection check ok (successfully got chain id {chain_id})")
     except Exception as e:
-        pytest.exit(f"Could not connect to RPC endpoint {config.getoption('rpc_endpoint')}: {e}")
+        pytest.exit(f"Could not connect to RPC endpoint {rpc_endpoint}: {e}")
     try:
-        print(f"Will now briefly check whether {eth_rpc.url} supports eth_config..")
+        print("Will now briefly check whether eth_config is supported by target rpc..")
         eth_rpc.config()
     except Exception as e:
-        pytest.exit(
-            f"RPC endpoint {config.getoption('rpc_endpoint')} does not support `eth_config`: {e}"
-        )
+        pytest.exit(f"RPC endpoint {rpc_endpoint} does not support `eth_config`: {e}")
 
 
 @pytest.fixture(autouse=True, scope="session")
@@ -139,63 +141,36 @@ def rpc_endpoint(request) -> str:
 
 
 @pytest.fixture(autouse=True, scope="session")
-def eth_rpc(rpc_endpoint: str) -> EthRPC:
-    """Initialize ethereum RPC client for the execution client under test."""
-    return EthRPC(rpc_endpoint)
-
-
-def request_eth_config(*, url: str, timeout: int = 10) -> Tuple[bool, str]:  # success, response
-    """Request data from devnet node via JSON_RPC."""
-    payload = {
-        "jsonrpc": "2.0",
-        "method": "eth_config",
-        "params": [],
-        "id": 1,
-    }
-
-    headers = {"Content-Type": "application/json"}
-
-    try:
-        # Make the request
-        response = requests.post(url, json=payload, headers=headers, timeout=timeout)
+def eth_rpc(rpc_endpoint: str, request) -> Dict[str, List[EthRPC]]:
+    """Generate list of RPC URLs which define which clients are tested."""
+    # generate all cl+el client combinations
+    config = request.config
+    el_clients: List[str] = config.getoption("majority_clients")  # besu, erigon, ..
 
-        # Return JSON response
-        return True, response.json()
-
-    except Exception as e:
-        return False, f"error: {e}"
-
-
-def get_rpc_url_combinations_el_cl(
-    el_clients: List[str], rpc_endpoint: str
-) -> None | Dict[str, List[str]]:
-    """Get cl+el url combinations for json rpc."""
-    # sanity checks
-    assert ".ethpandaops.io" in rpc_endpoint
     assert len(el_clients) > 0
     if "geth" in el_clients and "fusaka-devnet-3" in rpc_endpoint:
-        print("fusaka-devnet-3 geth does not support eth_config")
-        return None
+        pytest.exit("fusaka-devnet-3 geth does not support eth_config!")
 
     # generate client-specific URLs from provided rpc_endpoint (it does not matter which client the original rpc_endpoint specifies)  # noqa: E501
     # we want all combinations of consensus and execution clients (sometimes an exec client is only reachable via a subset of consensus client combinations)  # noqa: E501
     pattern = r"(.*?@rpc\.)([^-]+)-([^-]+)(-.*)"
-    url_dict: Dict[str, List[str]] = {
+    url_dict: Dict[str, List[EthRPC]] = {
         exec_client: [
-            re.sub(
-                pattern,
-                f"\\g<1>{consensus}-{exec_client}\\g<4>",
-                rpc_endpoint,
+            EthRPC(
+                re.sub(
+                    pattern,
+                    f"\\g<1>{consensus}-{exec_client}\\g<4>",
+                    rpc_endpoint,
+                )
             )
             for consensus in CONSENSUS_CLIENTS
         ]
         for exec_client in el_clients
     }
     # url_dict looks like this:
     # {
-    #     'besu': ["url for grandine+besu", "url for lighthouse+besu"], ...
-    #     'erigon': ["url for grandine+erigon", "url for lighthouse+erigon"], ...
+    #     'besu': [<EthRPC that holds url for grandine+besu>, <EthRPC that holds url for lighthouse+besu>, ..],  # noqa: E501
+    #     'erigon':  ...
     #     ...
     # }
-
     return url_dict

src/pytest_plugins/execute/eth_config/execute_eth_config.py

@@ -9,14 +9,16 @@
 
 from ethereum_test_rpc import EthConfigResponse, EthRPC
 
-from .eth_config import get_rpc_url_combinations_el_cl, request_eth_config
 from .types import NetworkConfig
 
 
 @pytest.fixture(scope="session")
-def eth_config_response(eth_rpc: EthRPC) -> EthConfigResponse | None:
-    """Get the `eth_config` response from the client to be verified by all tests."""
-    return eth_rpc.config(timeout=10)
+def eth_config_response(request) -> EthConfigResponse | None:
+    """Get the `eth_config` response from the user-provided RPC endpoint."""
+    config = request.config
+    eth_rpc_url = config.getoption("rpc_endpoint")
+    eth_rpc_target = EthRPC(eth_rpc_url)
+    return eth_rpc_target.config()
 
 
 @pytest.fixture(scope="session")
@@ -209,6 +211,7 @@ def test_eth_config_last_fork_id(
 
 
 def test_eth_config_majority(
+    eth_rpc: Dict[str, List[EthRPC]],
     request,
 ) -> None:
     """Queries devnet exec clients for their eth_config and fails if not all have the same response."""  # noqa: E501
@@ -218,39 +221,38 @@ def test_eth_config_majority(
     if not run_this_test_bool:
         pytest.skip("Skipping eth_config majority test")
 
-    # retrieve required values for running this test
-    rpc_endpoint = config.getoption("rpc_endpoint")
-    el_clients: List[str] = config.getoption("majority_clients")  # besu, erigon, ..
+    assert eth_rpc is not None
 
-    url_dict: None | Dict[str, List[str]] = get_rpc_url_combinations_el_cl(
-        el_clients=el_clients, rpc_endpoint=rpc_endpoint
-    )
-    assert url_dict is not None
-
-    responses = dict()  # noqa: C408
-    for exec_client in url_dict.keys():
+    responses = dict()  # Dict[exec_client_name : response] # noqa: C408
+    client_to_url_used_dict = dict()  # noqa: C408
+    for exec_client in eth_rpc.keys():
         # try only as many consensus+exec client combinations until you receive a response
-        # if all combinations fail we panic
-        for url in url_dict[exec_client]:
-            success, response = request_eth_config(url=url, timeout=9)
-            if not success:
+        # if all combinations for a given exec client fail we panic
+        for eth_rpc_target in eth_rpc[exec_client]:
+            response = eth_rpc_target.config(timeout=10)
+            if response is None:
                 # safely split url to not leak rpc_endpoint in logs
                 print(
-                    f"When trying to get eth_config from {url.split('@', 1)[-1] if '@' in url else ''} the following problem occurred: {response}"  # noqa: E501
+                    f"When trying to get eth_config from {eth_rpc_target} a problem occurred"  # problem itself is logged by .config() call # noqa: E501
                 )
                 continue
 
-            responses[exec_client] = response
-            print(f"Response of {exec_client}: {response}\n\n")
+            response_str = json.dumps(response.model_dump(mode="json"))
+            responses[exec_client] = response_str
+            client_to_url_used_dict[exec_client] = (
+                eth_rpc_target.url
+            )  # remember which cl+el combination was used  # noqa: E501
+            print(f"Response of {exec_client}: {response_str}\n\n")
+
             break  # no need to gather more responses for this client
 
-    assert len(responses.keys()) == len(el_clients), "Failed to get an eth_config response "
-    f" from each specified execution client. Full list of execution clients is {el_clients} "
+    assert len(responses.keys()) == len(eth_rpc.keys()), "Failed to get an eth_config response "
+    f" from each specified execution client. Full list of execution clients is {eth_rpc.keys()} "
     f"but we were only able to gather eth_config responses from: {responses.keys()}\nWill try "
     "again with a different consensus-execution client combination for this execution client"
 
     # determine hashes of client responses
-    client_to_hash_dict = dict()  # noqa: C408
+    client_to_hash_dict = dict()  # Dict[exec_client : response hash] # noqa: C408
     for client in responses.keys():
         response_bytes = json.dumps(responses[client], sort_keys=True).encode("utf-8")
         response_hash = sha256(response_bytes).digest().hex()
@@ -265,7 +267,10 @@ def test_eth_config_majority(
             continue
 
         assert client_to_hash_dict[h] == expected_hash, (
-            "Critical consensus issue: Not all eth_config responses are the same!"
+            "Critical consensus issue: Not all eth_config responses are the same! "
+            f"Here is an overview of client response hashes:\n{'\n\t'.join(f'{k}: {v}' for k, v in client_to_hash_dict.items())}\n\n"  # noqa: E501
+            f"Here is an overview of which URLs were contacted:\n\t{'\n\t'.join(f'{k}: @{v.split("@")[1]}' for k, v in client_to_url_used_dict.items())}\n\n"  # log which cl+el combinations were used without leaking full url # noqa: E501
+            f"Here is a dump of all client responses:\n{'\n\n'.join(f'{k}: {v}' for k, v in responses.items())}"  # noqa: E501
         )
     assert expected_hash != ""