apollo_deployments: assemble and deserialize node config from jsonnet

Author: nimrod-starkware

crates/apollo_deployments/jsonnet/testing/chain_params.libsonnet

@@ -0,0 +1,42 @@
+// Testing chain_params: the per chain/env mandatory values, read directly by the applicative config.
+{
+  chain_id: 'SN_SEPOLIA',
+  native_classes_whitelist: '[]',
+  recorder_url: 'https://recorder_url',
+  starknet_url: 'https://starknet_url/',
+  base_layer_config: {
+    bpo1_start_block_number: 9456501,
+    bpo2_start_block_number: 9504747,
+    fusaka_no_bpo_start_block_number: 9408577,
+    starknet_contract_address: '0x0000000000000000000000000000000000000001',
+  },
+  batcher_config: {
+    static_config: {
+      first_block_with_partial_block_hash: null,
+    },
+  },
+  consensus_manager_config: {
+    network_config: {
+      advertised_multiaddr: null,
+      bootstrap_peer_multiaddr: null,
+    },
+    staking_manager_config: {
+      dynamic_config: {
+        default_committee: '0,100:',
+      },
+    },
+  },
+  gateway_config: {
+    static_config: {
+      proof_archive_writer_config: {
+        bucket_name: 'test-bucket',
+      },
+    },
+  },
+  mempool_p2p_config: {
+    network_config: {
+      advertised_multiaddr: null,
+      bootstrap_peer_multiaddr: null,
+    },
+  },
+}

crates/apollo_deployments/jsonnet/testing/node_params.libsonnet

@@ -0,0 +1,4 @@
+// Testing node_params: the per-node mandatory values, read directly by the applicative config.
+{
+  validator_id: '0x64',
+}

crates/apollo_deployments/src/deployment_definitions_test.rs

@@ -13,7 +13,7 @@ use crate::deployment_definitions::ComponentConfigInService;
 use crate::deployments::consolidated::ConsolidatedNodeServiceName;
 use crate::deployments::distributed::DistributedNodeServiceName;
 use crate::deployments::hybrid::HybridNodeServiceName;
-use crate::jsonnet::assert_infra_matches_rust;
+use crate::jsonnet::{assert_build_deserializes, assert_infra_matches_rust};
 use crate::service::NodeType;
 use crate::test_utils::SecretsConfigOverride;
 
@@ -49,6 +49,33 @@ fn distributed_infra_matches_rust() {
     assert_infra_matches_rust::<DistributedNodeServiceName>();
 }
 
+/// Verifies build('consolidated', params) deserializes into SequencerNodeConfig per service.
+#[test]
+fn build_consolidated_deserializes_into_node_config() {
+    env::set_current_dir(resolve_project_relative_path("").unwrap())
+        .expect("Couldn't set working dir.");
+
+    assert_build_deserializes::<ConsolidatedNodeServiceName>();
+}
+
+/// Verifies build('hybrid', params) deserializes into SequencerNodeConfig per service.
+#[test]
+fn build_hybrid_deserializes_into_node_config() {
+    env::set_current_dir(resolve_project_relative_path("").unwrap())
+        .expect("Couldn't set working dir.");
+
+    assert_build_deserializes::<HybridNodeServiceName>();
+}
+
+/// Verifies build('distributed', params) deserializes into SequencerNodeConfig per service.
+#[test]
+fn build_distributed_deserializes_into_node_config() {
+    env::set_current_dir(resolve_project_relative_path("").unwrap())
+        .expect("Couldn't set working dir.");
+
+    assert_build_deserializes::<DistributedNodeServiceName>();
+}
+
 /// Test that the deployment file is up to date.
 #[test]
 fn deployment_files_are_up_to_date() {

crates/apollo_deployments/src/jsonnet.rs

@@ -1,5 +1,6 @@
 use std::path::PathBuf;
 
+use apollo_node_config::node_config::SequencerNodeConfig;
 use jrsonnet_evaluator::trace::PathResolver;
 use jrsonnet_evaluator::{FileImportResolver, State};
 use serde_json::Value;
@@ -8,14 +9,24 @@ use strum::IntoEnumIterator;
 use crate::service::{GetComponentConfigs, NodeService, NodeType};
 
 const JSONNET_DIR: &str = "crates/apollo_deployments/jsonnet";
+const TESTING_CHAIN_PARAMS_PATH: &str = "testing/chain_params.libsonnet";
+const TESTING_NODE_PARAMS_PATH: &str = "testing/node_params.libsonnet";
 
-/// Evaluates `services/<layout>.jsonnet` (the per-layout infra renderer) and returns its JSON.
-fn eval_layout_infra(layout: &str) -> Value {
+/// Evaluates a jsonnet `snippet` against a fresh evaluator (stdlib installed, imports resolved
+/// relative to the jsonnet dir) and converts the result to a serde `Value`. `context` labels the
+/// evaluation in panic messages.
+fn eval_jsonnet(context: &str, snippet: String) -> Value {
     let state = jsonnet_state();
     let _guard = state.enter();
-    let entry = format!("services/{layout}.jsonnet");
-    let val = state.import(entry.as_str()).expect("failed to evaluate the layout infra renderer");
-    serde_json::to_value(&val).expect("infra config is not serializable")
+    let val = state
+        .evaluate_snippet(context.to_owned(), snippet)
+        .expect("Failed to evaluate jsonnet snippet.");
+    serde_json::to_value(&val).expect("Failed to serialize jsonnet result to Value.")
+}
+
+/// Evaluates `services/<layout>.jsonnet` (the per-layout infra renderer) and returns its JSON.
+fn eval_layout_infra(layout: &str) -> Value {
+    eval_jsonnet("layout infra", format!("import 'services/{layout}.jsonnet'"))
 }
 
 /// A jrsonnet evaluator with the stdlib installed and file imports resolved relative to the jsonnet
@@ -57,6 +68,46 @@ where
     }
 }
 
+/// Evaluates `build(layout, { chain_params, node_params })` and returns its JSON: a map from service
+/// name to that service's fully-assembled config. The testing params supply only the mandatory
+/// chain_params + node_params buckets; `replacers` is omitted, so every replacer falls back to its
+/// applicative-config default.
+fn eval_build(layout: &str) -> Value {
+    let layout_literal = serde_json::to_string(layout).unwrap();
+    eval_jsonnet(
+        "build",
+        format!(
+            "(import 'lib/build.libsonnet').build({layout_literal}, {{ chain_params: import \
+             '{TESTING_CHAIN_PARAMS_PATH}', node_params: import '{TESTING_NODE_PARAMS_PATH}' }})"
+        ),
+    )
+}
+
+/// Asserts that `build(layout, params)` produces, for every service of layout `S`, an object that
+/// deserializes into `SequencerNodeConfig`.
+pub(crate) fn assert_build_deserializes<S>()
+where
+    S: GetComponentConfigs + IntoEnumIterator + Into<NodeService>,
+{
+    let some_service: NodeService =
+        S::iter().next().expect("a layout has at least one service").into();
+    let layout = NodeType::from(&some_service).to_string();
+    let built = eval_build(&layout);
+    let services = built.as_object().unwrap();
+
+    // Sanity check: the build result should have at least one service.
+    assert!(!services.is_empty(), "build({layout}) produced no services");
+
+    for (service_name, config) in services {
+        serde_json::from_value::<SequencerNodeConfig>(config.clone()).unwrap_or_else(|error| {
+            panic!(
+                "service {service_name} of layout {layout} does not deserialize into \
+                 SequencerNodeConfig: {error}"
+            )
+        });
+    }
+}
+
 /// Clones a `components` map with `url` and `port` removed from each component object — the two
 /// fields the Rust config leaves as deploy-time placeholders, so they can't be compared against the
 /// jsonnet's baked-in real values.