Issue #79 heartbeat factory service (#85)

* domain - validator - message - Heartbeat - add `state_root`

* validator - Cargo.toml - add `chrono`

* adapter - AdapterError - impl Error + Display and update `sign()`

* domain - validator - message - Heartbeat add `state_root` and `new()`

* validator - application - heartbeat - HeartbeatFactory

* domain - validator - message - Heartbeat add `new()` and a private field

* [+test] validator - application - heartbeat - HeartbeatFactory

* `rustfmt`

Author: elpiel

Cargo.lock

@@ -6,6 +6,8 @@ use domain::validator::message::State;
 use domain::{Asset, BigNum, Channel};
 
 use crate::sanity::SanityChecker;
+use std::error::Error;
+use std::fmt;
 
 pub type AdapterFuture<T> = Pin<Box<dyn Future<Output = Result<T, AdapterError>> + Send>>;
 
@@ -14,6 +16,16 @@ pub enum AdapterError {
     Authentication(String),
 }
 
+impl Error for AdapterError {}
+
+impl fmt::Display for AdapterError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            AdapterError::Authentication(error) => write!(f, "Authentication error: {}", error),
+        }
+    }
+}
+
 pub trait Adapter: SanityChecker + State {
     fn config(&self) -> &Config;
 
@@ -22,7 +34,7 @@ pub trait Adapter: SanityChecker + State {
     }
 
     /// Signs the provided state_root
-    fn sign(&self, state_root: &str) -> AdapterFuture<String>;
+    fn sign(&self, state_root: &Self::StateRoot) -> AdapterFuture<Self::Signature>;
 
     /// Verify, based on the signature & state_root, that the signer is the same
     fn verify(

adapter/src/adapter.rs

@@ -44,12 +44,12 @@ impl<'a> Adapter for DummyAdapter<'a> {
     /// let config = ConfigBuilder::new("identity").build();
     /// let adapter = DummyAdapter { config, participants: HashMap::new() };
     ///
-    /// let actual = await!(adapter.sign("abcdefghijklmnopqrstuvwxyz012345")).unwrap();
+    /// let actual = await!(adapter.sign(&"abcdefghijklmnopqrstuvwxyz012345".to_string())).unwrap();
     /// let expected = "Dummy adapter signature for 6162636465666768696a6b6c6d6e6f707172737475767778797a303132333435 by identity";
     /// assert_eq!(expected, &actual);
     /// # });
     /// ```
-    fn sign(&self, state_root: &str) -> AdapterFuture<String> {
+    fn sign(&self, state_root: &Self::StateRoot) -> AdapterFuture<Self::Signature> {
         let signature = format!(
             "Dummy adapter signature for {} by {}",
             encode(&state_root),
@@ -148,8 +148,9 @@ mod test {
             };
 
             let expected_signature = "Dummy adapter signature for 6162636465666768696a6b6c6d6e6f707172737475767778797a303132333435 by identity";
-            let actual_signature = await!(adapter.sign("abcdefghijklmnopqrstuvwxyz012345"))
-                .expect("Signing shouldn't fail");
+            let actual_signature =
+                await!(adapter.sign(&"abcdefghijklmnopqrstuvwxyz012345".to_string()))
+                    .expect("Signing shouldn't fail");
 
             assert_eq!(expected_signature, &actual_signature);
 

adapter/src/dummy.rs

@@ -82,8 +82,23 @@ pub struct RejectState {
 #[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(rename_all = "camelCase")]
 pub struct Heartbeat<S: State> {
-    signature: S::Signature,
-    timestamp: DateTime<Utc>,
+    pub signature: S::Signature,
+    pub state_root: S::StateRoot,
+    pub timestamp: DateTime<Utc>,
+    // we always want to create heartbeat with Timestamp NOW, so add a hidden field
+    // and force the creation of Heartbeat always to be from the `new()` method
+    _secret: (),
+}
+
+impl<S: State> Heartbeat<S> {
+    pub fn new(signature: S::Signature, state_root: S::StateRoot) -> Self {
+        Self {
+            signature,
+            state_root,
+            timestamp: Utc::now(),
+            _secret: (),
+        }
+    }
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
@@ -142,10 +157,15 @@ pub mod fixtures {
         }
     }
 
-    pub fn get_heartbeat<S: State>(signature: S::Signature) -> Heartbeat<S> {
+    pub fn get_heartbeat<S: State>(
+        state_root: S::StateRoot,
+        signature: S::Signature,
+    ) -> Heartbeat<S> {
         Heartbeat {
+            state_root,
             signature,
             timestamp: past_datetime(None),
+            _secret: (),
         }
     }
 

domain/src/validator/message.rs

@@ -13,6 +13,7 @@ path = "src/lib.rs"
 domain = { version = "0.1", path = "../domain", features = ["repositories"] }
 adapter = { version = "0.1", path = "../adapter", features = ["dummy-adapter"] }
 memory-repository = { version = "0.1", path = "../memory-repository" }
+chrono = { version = "0.4", features = ["serde"] }
 # Futures
 futures-preview = { version = "=0.3.0-alpha.16", features = ["compat", "io-compat"] }
 futures_legacy = { version = "0.1", package = "futures" }

validator/Cargo.toml

@@ -1,2 +1,3 @@
+pub mod heartbeat;
 pub mod validator;
 pub mod worker;

validator/src/application.rs

@@ -0,0 +1,70 @@
+use std::error::Error;
+use std::fmt;
+
+use adapter::{Adapter, AdapterError};
+use domain::validator::message::{Heartbeat, State};
+
+pub struct HeartbeatFactory<A: Adapter + State> {
+    adapter: A,
+}
+
+#[derive(Debug)]
+pub enum HeartbeatFactoryError {
+    Adapter(AdapterError),
+}
+
+impl Error for HeartbeatFactoryError {}
+
+impl fmt::Display for HeartbeatFactoryError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            HeartbeatFactoryError::Adapter(error) => write!(f, "Adapter error: {}", error),
+        }
+    }
+}
+
+impl<A: Adapter + State> HeartbeatFactory<A> {
+    #[allow(clippy::needless_lifetimes)]
+    pub async fn create(
+        &self,
+        state_root: A::StateRoot,
+    ) -> Result<Heartbeat<A>, HeartbeatFactoryError> {
+        let signature =
+            await!(self.adapter.sign(&state_root)).map_err(HeartbeatFactoryError::Adapter)?;
+
+        Ok(Heartbeat::new(signature, state_root))
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use std::collections::HashMap;
+
+    use adapter::dummy::DummyAdapter;
+    use adapter::ConfigBuilder;
+
+    use super::*;
+    use chrono::Utc;
+
+    #[test]
+    fn creates_heartbeat() {
+        futures::executor::block_on(async {
+            let adapter = DummyAdapter {
+                config: ConfigBuilder::new("identity").build(),
+                participants: HashMap::default(),
+            };
+
+            let factory = HeartbeatFactory { adapter };
+
+            let state_root = "my dummy StateRoot".to_string();
+
+            let adapter_signature = await!(factory.adapter.sign(&state_root))
+                .expect("Adapter should sign the StateRoot");
+            let heartbeat =
+                await!(factory.create(state_root)).expect("Heartbeat should be created");
+
+            assert!(Utc::now() >= heartbeat.timestamp);
+            assert_eq!(adapter_signature, heartbeat.signature);
+        });
+    }
+}