Tsabary/component runner

Cargo.toml

@@ -1,6 +1,6 @@
 [workspace]
 resolver = "2"
-members = ["crates/gateway", "crates/mempool", "crates/mempool_node"]
+members = ["crates/gateway", "crates/mempool", "crates/mempool_node", "crates/mempool_infra"]
 
 [workspace.package]
 version = "0.0.0"
@@ -19,6 +19,7 @@ unused = "deny"
 as_conversions = "deny"
 
 [workspace.dependencies]
+anyhow = "1.0.44"
 assert_matches = "1.5.0"
 async-trait = "0.1.79"
 axum = "0.6.12"

crates/mempool_infra/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "mempool_infra"
+version.workspace = true
+edition.workspace = true
+repository.workspace = true
+license.workspace = true
+
+[package.metadata.cargo-udeps.ignore]
+normal = ["tokio"]
+
+[lints]
+workspace = true
+
+[dependencies]
+async-trait.workspace = true
+clap.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+papyrus_config.workspace = true
+thiserror.workspace = true
+tokio.workspace = true
+validator.workspace = true
+
+[dev-dependencies]
+assert_matches.workspace = true
+pretty_assertions.workspace = true
+

crates/mempool_infra/src/infra_test.rs

@@ -0,0 +1,145 @@
+use assert_matches::assert_matches;
+use async_trait::async_trait;
+use pretty_assertions::assert_eq;
+use serde::{Deserialize, Serialize};
+
+use std::collections::BTreeMap;
+
+use crate::{ComponentRunner, ComponentStartError};
+use papyrus_config::dumping::{ser_param, SerializeConfig};
+
+use papyrus_config::ParamPrivacyInput;
+use papyrus_config::{ParamPath, SerializedParam};
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+pub struct TestConfig1 {
+    pub config1: bool,
+}
+
+impl SerializeConfig for TestConfig1 {
+    fn dump(&self) -> BTreeMap<ParamPath, SerializedParam> {
+        BTreeMap::from_iter([ser_param(
+            "test1",
+            &self.config1,
+            "...",
+            ParamPrivacyInput::Public,
+        )])
+    }
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+pub struct TestConfig2 {
+    pub config2: u32,
+}
+
+impl SerializeConfig for TestConfig2 {
+    fn dump(&self) -> BTreeMap<ParamPath, SerializedParam> {
+        BTreeMap::from_iter([ser_param(
+            "test2",
+            &self.config2,
+            "...",
+            ParamPrivacyInput::Public,
+        )])
+    }
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+pub struct TestConfig3 {
+    pub config3: f64,
+}
+
+impl SerializeConfig for TestConfig3 {
+    fn dump(&self) -> BTreeMap<ParamPath, SerializedParam> {
+        BTreeMap::from_iter([ser_param(
+            "test2",
+            &self.config3,
+            "...",
+            ParamPrivacyInput::Public,
+        )])
+    }
+}
+
+trait ExtendedConfigTrait: SerializeConfig + std::fmt::Debug + Send + Sync {}
+
+impl ExtendedConfigTrait for TestConfig1 {}
+impl ExtendedConfigTrait for TestConfig2 {}
+
+#[async_trait]
+impl ComponentRunner for TestComponent1 {
+    async fn start_component(&self) -> Result<(), ComponentStartError> {
+        println!("TestComponent1::start_component(): {:#?}", self.config);
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl ComponentRunner for TestComponent2 {
+    async fn start_component(&self) -> Result<(), ComponentStartError> {
+        println!("TestComponent2::start_component(): {:#?}", self.config);
+        if self.config.config2 == 42 {
+            return Err(ComponentStartError::InternalComponentError);
+        } else {
+            return Ok(());
+        };
+    }
+}
+
+pub struct TestComponent1 {
+    pub config: TestConfig1,
+}
+
+pub struct TestComponent2 {
+    pub config: TestConfig2,
+}
+
+#[tokio::test]
+async fn test_testruner1() {
+    let test_config = TestConfig1 { config1: true };
+    let test_component = TestComponent1 {
+        config: test_config,
+    };
+    assert_matches!(test_component.start_component().await, Ok(()));
+}
+
+#[tokio::test]
+async fn test_testruner2() {
+    let test_config = TestConfig2 { config2: 16 };
+    let test_component = TestComponent2 {
+        config: test_config,
+    };
+    assert_matches!(test_component.start_component().await, Ok(()));
+}
+
+#[tokio::test]
+async fn test_run_from_vector() {
+    let test_config_1 = TestConfig1 { config1: true };
+    let test_config_2 = TestConfig2 { config2: 17 };
+    let erroneous_test_config_2 = TestConfig2 { config2: 42 };
+
+    let test_component_1 = TestComponent1 {
+        config: test_config_1,
+    };
+    let test_component_2 = TestComponent2 {
+        config: test_config_2,
+    };
+    let erroneous_test_component_2 = TestComponent2 {
+        config: erroneous_test_config_2,
+    };
+
+    let components: Vec<Box<dyn ComponentRunner>> = vec![
+        Box::new(test_component_1),
+        Box::new(test_component_2),
+        Box::new(erroneous_test_component_2),
+    ];
+
+    let expected_results: Vec<Result<(), ComponentStartError>> = vec![
+        Ok(()),
+        Ok(()),
+        Err(ComponentStartError::InternalComponentError),
+    ];
+
+    for (component, expected_result) in components.iter().zip(expected_results.iter()) {
+        let ret_val = component.start_component().await;
+        assert_eq!(ret_val, *expected_result);
+    }
+}

crates/mempool_infra/src/lib.rs

@@ -0,0 +1,21 @@
+use async_trait::async_trait;
+// use papyrus_config::dumping::SerializeConfig;
+use std::fmt::Debug;
+
+#[cfg(test)]
+mod infra_test;
+
+#[derive(thiserror::Error, Debug, PartialEq)]
+pub enum ComponentStartError {
+    #[error("Error in the component configuration.")]
+    ComponentConfigError,
+    #[error("An internal component error.")]
+    InternalComponentError,
+}
+
+/// Interface to start memepool components.
+#[async_trait]
+pub trait ComponentRunner {
+    /// Start the component. Normally this function should never return.
+    async fn start_component(&self) -> Result<(), ComponentStartError>;
+}