apollo_http_server: add config manager client

Author: Itay-Tsabary-Starkware

Cargo.lock

@@ -19,6 +19,7 @@ testing = [
 workspace = true
 
 [dependencies]
+apollo_config_manager_types.workspace = true
 apollo_gateway_types.workspace = true
 apollo_http_server_config.workspace = true
 apollo_infra.workspace = true
@@ -40,7 +41,9 @@ thiserror.workspace = true
 tokio = { workspace = true, features = ["rt"] }
 tracing.workspace = true
 
+
 [dev-dependencies]
+apollo_config_manager_types = { workspace = true, features = ["testing"] }
 apollo_gateway_types = { workspace = true, features = ["testing"] }
 apollo_metrics = { workspace = true, features = ["testing"] }
 assert_matches.workspace = true

crates/apollo_http_server/Cargo.toml

@@ -2,6 +2,7 @@ use std::clone::Clone;
 use std::net::SocketAddr;
 use std::string::String;
 
+use apollo_config_manager_types::communication::SharedConfigManagerClient;
 use apollo_gateway_types::communication::{GatewayClientError, SharedGatewayClient};
 use apollo_gateway_types::deprecated_gateway_error::{
     KnownStarknetErrorCode,
@@ -56,12 +57,18 @@ pub struct HttpServer {
 
 #[derive(Clone)]
 pub struct AppState {
+    // TODO(Tsabary): use the config manager in the tx processing.
+    _config_manager_client: SharedConfigManagerClient,
     pub gateway_client: SharedGatewayClient,
 }
 
 impl HttpServer {
-    pub fn new(config: HttpServerConfig, gateway_client: SharedGatewayClient) -> Self {
-        let app_state = AppState { gateway_client };
+    pub fn new(
+        config: HttpServerConfig,
+        config_manager_client: SharedConfigManagerClient,
+        gateway_client: SharedGatewayClient,
+    ) -> Self {
+        let app_state = AppState { _config_manager_client: config_manager_client, gateway_client };
         HttpServer { config, app_state }
     }
 
@@ -259,9 +266,10 @@ fn record_added_transactions(add_tx_result: &HttpServerResult<GatewayOutput>, re
 
 pub fn create_http_server(
     config: HttpServerConfig,
+    config_manager_client: SharedConfigManagerClient,
     gateway_client: SharedGatewayClient,
 ) -> HttpServer {
-    HttpServer::new(config, gateway_client)
+    HttpServer::new(config, config_manager_client, gateway_client)
 }
 
 #[async_trait]

crates/apollo_http_server/src/http_server.rs

@@ -1,3 +1,4 @@
+use apollo_config_manager_types::communication::MockConfigManagerClient;
 use apollo_gateway_types::communication::{GatewayClientError, MockGatewayClient};
 use apollo_gateway_types::deprecated_gateway_error::{
     KnownStarknetErrorCode,
@@ -126,8 +127,11 @@ async fn record_region_test(#[case] index: u16, #[case] tx: impl GatewayTransact
         .times(1)
         .return_const(Ok(GatewayOutput::Invoke(InvokeGatewayOutput::new(tx_hash_2))));
 
+    let mock_config_manager_client = MockConfigManagerClient::new();
+
     // TODO(Yael): avoid the hardcoded node offset index, consider dynamic allocation.
-    let http_client = add_tx_http_client(mock_gateway_client, 1 + index).await;
+    let http_client =
+        add_tx_http_client(mock_config_manager_client, mock_gateway_client, 1 + index).await;
 
     // Send a transaction to the server, without a region.
     http_client.add_tx(tx.clone()).await;
@@ -159,7 +163,10 @@ async fn record_region_gateway_failing_tx(#[case] index: u16, #[case] tx: impl G
         )),
     ));
 
-    let http_client = add_tx_http_client(mock_gateway_client, 3 + index).await;
+    let mock_config_manager_client = MockConfigManagerClient::new();
+
+    let http_client =
+        add_tx_http_client(mock_config_manager_client, mock_gateway_client, 3 + index).await;
 
     // Send a transaction to the server.
     http_client.add_tx(tx).await;
@@ -207,7 +214,10 @@ async fn test_response(#[case] index: u16, #[case] tx: impl GatewayTransaction)
         expected_internal_err,
     ));
 
-    let http_client = add_tx_http_client(mock_gateway_client, 5 + index).await;
+    let mock_config_manager_client = MockConfigManagerClient::new();
+
+    let http_client =
+        add_tx_http_client(mock_config_manager_client, mock_gateway_client, 5 + index).await;
 
     // Test a successful response.
     let tx_hash = http_client.assert_add_tx_success(tx.clone()).await;
@@ -264,6 +274,8 @@ async fn test_unsupported_tx_version(
     #[case] expected_err: StarknetError,
 ) {
     // Set the tx version to the given version.
+
+    use apollo_config_manager_types::communication::MockConfigManagerClient;
     let mut tx_json =
         TransactionSerialization(serde_json::to_value(deprecated_gateway_invoke_tx()).unwrap());
     let as_object = tx_json.0.as_object_mut().unwrap();
@@ -274,7 +286,10 @@ async fn test_unsupported_tx_version(
     }
 
     let mock_gateway_client = MockGatewayClient::new();
-    let http_client = add_tx_http_client(mock_gateway_client, 9 + index).await;
+    let mock_config_manager_client = MockConfigManagerClient::new();
+
+    let http_client =
+        add_tx_http_client(mock_config_manager_client, mock_gateway_client, 9 + index).await;
 
     let serialized_err =
         http_client.assert_add_tx_error(tx_json, reqwest::StatusCode::BAD_REQUEST).await;
@@ -293,7 +308,9 @@ async fn sanitizing_error_message() {
     tx_object.insert("version".to_string(), Value::String(malicious_version.to_string())).unwrap();
 
     let mock_gateway_client = MockGatewayClient::new();
-    let http_client = add_tx_http_client(mock_gateway_client, 13).await;
+    let mock_config_manager_client = MockConfigManagerClient::new();
+
+    let http_client = add_tx_http_client(mock_config_manager_client, mock_gateway_client, 13).await;
 
     let serialized_err =
         http_client.assert_add_tx_error(tx_json, reqwest::StatusCode::BAD_REQUEST).await;

crates/apollo_http_server/src/http_server_test.rs

@@ -1,3 +1,4 @@
+use apollo_config_manager_types::communication::MockConfigManagerClient;
 use apollo_gateway_types::communication::{GatewayClientError, MockGatewayClient};
 use apollo_gateway_types::gateway_types::{GatewayOutput, InvokeGatewayOutput};
 use apollo_infra::component_client::ClientError;
@@ -54,12 +55,15 @@ async fn add_tx_metrics_test(#[case] index: u16, #[case] tx: impl GatewayTransac
         )))
     });
 
+    let mock_config_manager_client = MockConfigManagerClient::new();
+
     // Initialize the metrics directly instead of spawning a monitoring endpoint task.
     let recorder = PrometheusBuilder::new().build_recorder();
     let _recorder_guard = metrics::set_default_local_recorder(&recorder);
     let prometheus_handle = recorder.handle();
 
-    let http_client = add_tx_http_client(mock_gateway_client, 14 + index).await;
+    let http_client =
+        add_tx_http_client(mock_config_manager_client, mock_gateway_client, 14 + index).await;
 
     // Send transactions to the server.
     for _ in std::iter::repeat_n((), SUCCESS_TXS_TO_SEND + FAILURE_TXS_TO_SEND) {
@@ -85,12 +89,14 @@ async fn add_tx_serde_failure_metrics_test() {
         .times(1)
         .return_once(move |_| Ok(success_gateway_client_output()));
 
+    let mock_config_manager_client = MockConfigManagerClient::new();
+
     // Initialize the metrics directly instead of spawning a monitoring endpoint task.
     let recorder = PrometheusBuilder::new().build_recorder();
     let _recorder_guard = metrics::set_default_local_recorder(&recorder);
     let prometheus_handle = recorder.handle();
 
-    let http_client = add_tx_http_client(mock_gateway_client, 16).await;
+    let http_client = add_tx_http_client(mock_config_manager_client, mock_gateway_client, 16).await;
 
     // Send a transaction that fails deserialization.
     let tx: InvalidTransaction = "invalid transaction";

crates/apollo_http_server/src/metrics_test.rs

@@ -1,6 +1,7 @@
 use std::net::{IpAddr, Ipv4Addr, SocketAddr};
 use std::sync::Arc;
 
+use apollo_config_manager_types::communication::MockConfigManagerClient;
 use apollo_gateway_types::communication::MockGatewayClient;
 use apollo_gateway_types::gateway_types::GatewayOutput;
 use apollo_http_server_config::config::{HttpServerConfig, DEFAULT_MAX_SIERRA_PROGRAM_SIZE};
@@ -87,13 +88,17 @@ pub fn create_http_server_config(socket: SocketAddr) -> HttpServerConfig {
 }
 
 /// Creates an HTTP server and an HttpTestClient that can interact with it.
-pub async fn http_client_server_setup(
+async fn http_client_server_setup(
+    mock_config_manager_client: MockConfigManagerClient,
     mock_gateway_client: MockGatewayClient,
     http_server_config: HttpServerConfig,
 ) -> HttpTestClient {
     // Create and run the server.
-    let mut http_server =
-        HttpServer::new(http_server_config.clone(), Arc::new(mock_gateway_client));
+    let mut http_server = HttpServer::new(
+        http_server_config.clone(),
+        Arc::new(mock_config_manager_client),
+        Arc::new(mock_gateway_client),
+    );
     tokio::spawn(async move { http_server.run().await });
 
     let (ip, port) = http_server_config.ip_and_port();
@@ -145,6 +150,7 @@ impl GatewayTransaction for TransactionSerialization {
 }
 
 pub async fn add_tx_http_client(
+    mock_config_manager_client: MockConfigManagerClient,
     mock_gateway_client: MockGatewayClient,
     port_index: u16,
 ) -> HttpTestClient {
@@ -153,7 +159,8 @@ pub async fn add_tx_http_client(
         AvailablePorts::new(TestIdentifier::HttpServerUnitTests.into(), port_index);
     let http_server_config =
         HttpServerConfig::new(ip, available_ports.get_next_port(), DEFAULT_MAX_SIERRA_PROGRAM_SIZE);
-    http_client_server_setup(mock_gateway_client, http_server_config).await
+    http_client_server_setup(mock_config_manager_client, mock_gateway_client, http_server_config)
+        .await
 }
 
 pub fn rpc_invoke_tx() -> RpcTransaction {

crates/apollo_http_server/src/test_utils.rs

@@ -232,12 +232,19 @@ pub async fn create_node_components(
 
     let http_server = match config.components.http_server.execution_mode {
         ActiveComponentExecutionMode::Enabled => {
+            let config_manager_client = clients
+                .get_config_manager_shared_client()
+                .expect("Config Manager client should be available");
             let http_server_config =
                 config.http_server_config.as_ref().expect("HTTP Server config should be set");
             let gateway_client =
                 clients.get_gateway_shared_client().expect("Gateway client should be available");
 
-            Some(create_http_server(http_server_config.clone(), gateway_client))
+            Some(create_http_server(
+                http_server_config.clone(),
+                config_manager_client,
+                gateway_client,
+            ))
         }
         ActiveComponentExecutionMode::Disabled => None,
     };