Issue #94 Validator MessageRepository add to specific validator (#97)

* [+test] domain - validator - MessageRepository - change signature of `add`

* The `State` as `Adapter` associated type instead of the `Adapter` to impl `State`

* run `rustfmt`

Author: elpiel

adapter/src/adapter.rs

@@ -42,22 +42,27 @@ impl fmt::Display for AdapterError {
     }
 }
 
-pub trait Adapter: SanityChecker + State {
+pub trait Adapter: SanityChecker {
+    type State: State;
+
     fn config(&self) -> &Config;
 
     fn validate_channel(&self, channel: &Channel) -> AdapterFuture<bool> {
         futures::future::ok(Self::check(&self.config(), &channel).is_ok()).boxed()
     }
 
     /// Signs the provided state_root
-    fn sign(&self, state_root: &Self::StateRoot) -> AdapterFuture<Self::Signature>;
+    fn sign(
+        &self,
+        state_root: &<Self::State as State>::StateRoot,
+    ) -> AdapterFuture<<Self::State as State>::Signature>;
 
     /// Verify, based on the signature & state_root, that the signer is the same
     fn verify(
         &self,
         signer: &str,
-        state_root: &Self::StateRoot,
-        signature: &Self::Signature,
+        state_root: &<Self::State as State>::StateRoot,
+        signature: &<Self::State as State>::Signature,
     ) -> AdapterFuture<bool>;
 
     /// Gets authentication for specific validator
@@ -66,9 +71,10 @@ pub trait Adapter: SanityChecker + State {
     fn signable_state_root(
         channel_id: ChannelId,
         balance_root: BalanceRoot,
-    ) -> SignableStateRoot<Self::StateRoot>;
+    ) -> SignableStateRoot<<Self::State as State>::StateRoot>;
 }
 
+#[derive(Clone)]
 pub struct Config {
     pub identity: String,
     pub validators_whitelist: Vec<String>,

adapter/src/dummy.rs

@@ -63,6 +63,13 @@ impl AsRef<[u8]> for DummyStateRoot {
 }
 impl Hexable for DummyStateRoot {}
 
+#[derive(Clone)]
+pub struct DummyState {}
+impl State for DummyState {
+    type Signature = DummySignature;
+    type StateRoot = DummyStateRoot;
+}
+
 pub struct DummyAdapter<'a> {
     pub config: Config,
     /// Dummy participants which will be used for
@@ -72,12 +79,9 @@ pub struct DummyAdapter<'a> {
 
 impl SanityChecker for DummyAdapter<'_> {}
 
-impl State for DummyAdapter<'_> {
-    type Signature = DummySignature;
-    type StateRoot = DummyStateRoot;
-}
-
 impl<'a> Adapter for DummyAdapter<'a> {
+    type State = DummyState;
+
     fn config(&self) -> &Config {
         &self.config
     }
@@ -98,7 +102,10 @@ impl<'a> Adapter for DummyAdapter<'a> {
     /// assert_eq!(DummySignature::from(expected), actual);
     /// # });
     /// ```
-    fn sign(&self, state_root: &Self::StateRoot) -> AdapterFuture<Self::Signature> {
+    fn sign(
+        &self,
+        state_root: &<Self::State as State>::StateRoot,
+    ) -> AdapterFuture<<Self::State as State>::Signature> {
         let signature = format!(
             "Dummy adapter signature for {} by {}",
             state_root.to_hex(),
@@ -125,8 +132,8 @@ impl<'a> Adapter for DummyAdapter<'a> {
     fn verify(
         &self,
         signer: &str,
-        _state_root: &Self::StateRoot,
-        signature: &Self::Signature,
+        _state_root: &<Self::State as State>::StateRoot,
+        signature: &<Self::State as State>::Signature,
     ) -> AdapterFuture<bool> {
         // select the `identity` and compare it to the signer
         // for empty string this will return array with 1 element - an empty string `[""]`
@@ -183,7 +190,7 @@ impl<'a> Adapter for DummyAdapter<'a> {
     fn signable_state_root(
         channel_id: ChannelId,
         balance_root: BalanceRoot,
-    ) -> SignableStateRoot<Self::StateRoot> {
+    ) -> SignableStateRoot<<Self::State as State>::StateRoot> {
         let state_root = format!(
             "Signable State Root for Adapter channel id {} with balance root {}",
             channel_id.to_hex(),

domain/src/channel.rs

@@ -212,6 +212,15 @@ impl From<[ValidatorDesc; 2]> for SpecValidators {
     }
 }
 
+impl<'a> IntoIterator for &'a SpecValidators {
+    type Item = &'a ValidatorDesc;
+    type IntoIter = ::std::vec::IntoIter<Self::Item>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        vec![self.leader(), self.follower()].into_iter()
+    }
+}
+
 #[cfg(any(test, feature = "fixtures"))]
 #[path = "./channel_fixtures.rs"]
 pub mod fixtures;

domain/src/validator/message.rs

@@ -6,7 +6,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::BalancesMap;
 
-pub trait State {
+pub trait State: Clone {
     type Signature: DeserializeOwned + Serialize + fmt::Display + fmt::Debug + Clone;
     type StateRoot: DeserializeOwned + Serialize + fmt::Display + fmt::Debug + Clone;
 }
@@ -119,7 +119,7 @@ pub mod fixtures {
 
     use super::*;
 
-    #[derive(Serialize, Deserialize, Debug)]
+    #[derive(Serialize, Deserialize, Debug, Clone)]
     pub struct DummyState {}
 
     impl State for DummyState {

validator/src/application/heartbeat.rs

@@ -9,7 +9,7 @@ use domain::{Channel, ChannelId, RepositoryError, ValidatorId};
 
 use crate::domain::MessageRepository;
 
-pub struct HeartbeatFactory<A: Adapter + State> {
+pub struct HeartbeatFactory<A: Adapter> {
     adapter: A,
 }
 
@@ -40,22 +40,25 @@ impl fmt::Display for HeartbeatError {
     }
 }
 
-impl<A: Adapter + State> HeartbeatFactory<A> {
-    pub async fn create(&self, state_root: A::StateRoot) -> Result<Heartbeat<A>, HeartbeatError> {
+impl<A: Adapter> HeartbeatFactory<A> {
+    pub async fn create(
+        &self,
+        state_root: <A::State as State>::StateRoot,
+    ) -> Result<Heartbeat<A::State>, HeartbeatError> {
         let signature = await!(self.adapter.sign(&state_root)).map_err(HeartbeatError::Adapter)?;
 
         Ok(Heartbeat::new(signature, state_root))
     }
 }
 
-pub struct HeartbeatSender<A: Adapter + State> {
-    message_repository: Box<dyn MessageRepository<A>>,
+pub struct HeartbeatSender<A: Adapter> {
+    message_repository: Box<dyn MessageRepository<A::State>>,
     adapter: A,
     factory: HeartbeatFactory<A>,
     // @TODO: Add config value for Heartbeat send frequency
 }
 
-impl<A: Adapter + State> HeartbeatSender<A> {
+impl<A: Adapter> HeartbeatSender<A> {
     pub async fn conditional_send(&self, channel: Channel) -> Result<(), HeartbeatError> {
         // get latest Heartbeat message from repo
         // TODO: Handle this error, removing this ValidatorId from here
@@ -75,7 +78,7 @@ impl<A: Adapter + State> HeartbeatSender<A> {
 
         // if it doesn't exist or the Passed time is greater than the Timer Time
         match latest_heartbeat.as_ref() {
-            Some(heartbeat) if !self.is_heartbeat_time(&heartbeat) => {
+            Some(heartbeat) if !self.is_heartbeat_time(heartbeat) => {
                 return Err(HeartbeatError::NotYetTime)
             }
             _ => (),
@@ -91,14 +94,15 @@ impl<A: Adapter + State> HeartbeatSender<A> {
         // call the HeartbeatFactory and create the new Heartbeat
         let heartbeat = await!(self.factory.create(signable_state_root.0))?;
 
+        // @TODO: Issue #93 - this should propagate the message to all validators!
         // `add()` the heartbeat with the Repository
         await!(self
             .message_repository
-            .add(channel.id, Message::Heartbeat(heartbeat)))
+            .add(&channel.id, &validator, Message::Heartbeat(heartbeat)))
         .map_err(HeartbeatError::Repository)
     }
 
-    fn is_heartbeat_time(&self, latest_heartbeat: &Heartbeat<A>) -> bool {
+    fn is_heartbeat_time(&self, latest_heartbeat: &Heartbeat<A::State>) -> bool {
         // @TODO: Use the configuration value for the duration!
         latest_heartbeat.timestamp - Utc::now() >= Duration::seconds(10)
     }

validator/src/domain/validator.rs

@@ -23,11 +23,16 @@ pub mod repository {
     use domain::{ChannelId, RepositoryFuture};
 
     pub trait MessageRepository<S: State> {
-        fn add(&self, channel_id: ChannelId, message: Message<S>) -> RepositoryFuture<()>;
+        fn add(
+            &self,
+            channel: &ChannelId,
+            validator: &ValidatorId,
+            message: Message<S>,
+        ) -> RepositoryFuture<()>;
 
         fn latest(
             &self,
-            channel_id: &ChannelId,
+            channel: &ChannelId,
             from: &ValidatorId,
             types: Option<&[&MessageType]>,
         ) -> RepositoryFuture<Option<Message<S>>>;