use ValidatorId & TryFrom wherever makes sense **for now** (#108)

Author: elpiel

adapter/src/sanity.rs

@@ -3,13 +3,16 @@ use std::{error, fmt};
 use chrono::Utc;
 
 use domain::channel::{SpecValidator, SpecValidators};
-use domain::{Asset, Channel};
+use domain::{Asset, Channel, ValidatorId};
 
 use crate::adapter::Config;
+use std::convert::TryFrom;
 
 pub trait SanityChecker {
     fn check(config: &Config, channel: &Channel) -> Result<(), SanityError> {
-        let adapter_channel_validator = match channel.spec.validators.find(&config.identity) {
+        let identity =
+            ValidatorId::try_from(config.identity.as_str()).expect("Identity failed to be created");
+        let adapter_channel_validator = match channel.spec.validators.find(&identity) {
             // check if the channel validators include our adapter identity
             SpecValidator::None => return Err(SanityError::AdapterNotIncluded),
             SpecValidator::Leader(validator) | SpecValidator::Follower(validator) => validator,
@@ -50,7 +53,8 @@ fn all_validators_listed(validators: &SpecValidators, whitelist: &[String]) -> b
         let found_validators = whitelist
             .iter()
             .filter(|&allowed| {
-                allowed == &validators.leader().id || allowed == &validators.follower().id
+                allowed == validators.leader().id.as_ref()
+                    || allowed == validators.follower().id.as_ref()
             })
             // this will ensure that if we find the 2 validators earlier
             // we don't go over the other values of the whitelist
@@ -131,7 +135,7 @@ mod test {
         let channel = get_channel("channel_1", &Some(passed_valid_until), None);
 
         let identity = channel.spec.validators.leader().id.clone();
-        let config = ConfigBuilder::new(&identity).build();
+        let config = ConfigBuilder::new(identity.as_ref()).build();
 
         assert_eq!(
             Err(SanityError::PassedValidUntil),
@@ -145,17 +149,18 @@ mod test {
 
         // as identity use the leader, otherwise we won't pass the AdapterNotIncluded check
         let identity = channel.spec.validators.leader().id.clone();
-        let config = ConfigBuilder::new(&identity)
+        let config = ConfigBuilder::new(identity.as_ref())
             .set_validators_whitelist(&["my validator"])
             .build();
 
         // make sure we don't use the leader or follower validators as a whitelisted validator
         assert_ne!(
-            &identity, "my validator",
+            identity.as_ref(),
+            "my validator",
             "The whitelisted validator and the leader have the same id"
         );
         assert_ne!(
-            &channel.spec.validators.follower().id,
+            channel.spec.validators.follower().id.as_ref(),
             "my validator",
             "The whitelisted validator and the follower have the same id"
         );
@@ -172,7 +177,7 @@ mod test {
 
         // as identity use the leader, otherwise we won't pass the AdapterNotIncluded check
         let identity = channel.spec.validators.leader().id.clone();
-        let config = ConfigBuilder::new(&identity)
+        let config = ConfigBuilder::new(identity.as_ref())
             .set_creators_whitelist(&["creator"])
             .build();
 
@@ -193,7 +198,7 @@ mod test {
 
         // as identity use the leader, otherwise we won't pass the AdapterNotIncluded check
         let identity = channel.spec.validators.leader().id.clone();
-        let config = ConfigBuilder::new(&identity)
+        let config = ConfigBuilder::new(identity.as_ref())
             .set_assets_whitelist(&["ASSET".into()])
             .build();
 
@@ -215,7 +220,7 @@ mod test {
 
         // as identity use the leader, otherwise we won't pass the AdapterNotIncluded check
         let identity = channel.spec.validators.leader().id.clone();
-        let config = ConfigBuilder::new(&identity)
+        let config = ConfigBuilder::new(identity.as_ref())
             // set the minimum deposit to the `channel.deposit_amount + 1`
             .set_minimum_deposit(&channel.deposit_amount + &1.into())
             .build();
@@ -233,7 +238,7 @@ mod test {
         let leader = channel.spec.validators.leader();
         // as identity use the leader, otherwise we won't pass the AdapterNotIncluded check
         let identity = leader.id.clone();
-        let config = ConfigBuilder::new(&identity)
+        let config = ConfigBuilder::new(identity.as_ref())
             // set the minimum deposit to the `leader.fee + 1`
             .set_minimum_fee(&leader.fee + &1.into())
             .build();

domain/src/balances_map.rs

@@ -54,7 +54,7 @@ impl BalancesMap {
 
             if fee_rounded > 0.into() {
                 let entry = balances
-                    .entry(validator.id.clone())
+                    .entry(validator.id.clone().into())
                     .or_insert_with(|| 0.into());
 
                 *entry += &fee_rounded;

domain/src/channel.rs

@@ -9,7 +9,9 @@ use serde_hex::{SerHex, StrictPfx};
 
 use crate::big_num::BigNum;
 use crate::util::serde::ts_milliseconds_option;
-use crate::{AdUnit, Asset, DomainError, EventSubmission, TargetingTag, ValidatorDesc};
+use crate::{
+    AdUnit, Asset, DomainError, EventSubmission, TargetingTag, ValidatorDesc, ValidatorId,
+};
 
 #[derive(Serialize, Deserialize, PartialEq, Eq, Debug, Copy, Clone)]
 #[serde(transparent)]
@@ -195,10 +197,10 @@ impl SpecValidators {
         &self.0[1]
     }
 
-    pub fn find(&self, validator_id: &str) -> SpecValidator<'_> {
-        if self.leader().id == validator_id {
+    pub fn find(&self, validator: &ValidatorId) -> SpecValidator<'_> {
+        if &self.leader().id == validator {
             SpecValidator::Leader(&self.leader())
-        } else if self.follower().id == validator_id {
+        } else if &self.follower().id == validator {
             SpecValidator::Follower(&self.follower())
         } else {
             SpecValidator::None

domain/src/validator.rs

@@ -22,6 +22,12 @@ impl TryFrom<&str> for ValidatorId {
     }
 }
 
+impl Into<String> for ValidatorId {
+    fn into(self) -> String {
+        self.0
+    }
+}
+
 impl AsRef<str> for ValidatorId {
     fn as_ref(&self) -> &str {
         self.0.as_str()
@@ -37,8 +43,7 @@ impl fmt::Display for ValidatorId {
 #[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(rename_all = "camelCase")]
 pub struct ValidatorDesc {
-    // @TODO: Replace id `String` with `ValidatorId` https://github.com/AdExNetwork/adex-validator-stack-rust/issues/83
-    pub id: String,
+    pub id: ValidatorId,
     pub url: String,
     pub fee: BigNum,
 }
@@ -47,19 +52,21 @@ pub struct ValidatorDesc {
 pub mod fixtures {
     use fake::faker::*;
 
+    use super::{ValidatorDesc, ValidatorId};
     use crate::BigNum;
-
-    use super::ValidatorDesc;
+    use std::convert::TryFrom;
 
     pub fn get_validator<V: AsRef<str>>(validator_id: V, fee: Option<BigNum>) -> ValidatorDesc {
         let fee = fee.unwrap_or_else(|| BigNum::from(<Faker as Number>::between(1, 13)));
         let url = format!(
             "http://{}-validator-url.com/validator",
             validator_id.as_ref()
         );
+        let validator_id =
+            ValidatorId::try_from(validator_id.as_ref()).expect("Creating ValidatorId failed");
 
         ValidatorDesc {
-            id: validator_id.as_ref().to_string(),
+            id: validator_id,
             url,
             fee,
         }

sentry/src/application/resource/channel.rs

@@ -54,13 +54,13 @@ impl ChannelListQuery {
         }
     }
 
-    pub fn validator(&self) -> Option<String> {
-        self.validator.to_owned().and_then(|s| {
+    pub fn validator(&self) -> Option<&str> {
+        self.validator.as_ref().and_then(|s| {
             if s.is_empty() {
                 return None;
             }
 
-            Some(s)
+            Some(s.as_str())
         })
     }
 }

sentry/src/application/resource/channel/channel_list/handler.rs

@@ -22,10 +22,10 @@ impl ChannelListHandler {
 
 impl ChannelListHandler {
     #[allow(clippy::needless_lifetimes)]
-    pub async fn handle(
-        &self,
+    pub async fn handle<'a>(
+        &'a self,
         page: u64,
-        validator: Option<String>,
+        validator: Option<&'a str>,
     ) -> Result<ChannelListResponse, ()> {
         let channel_list_params =
             ChannelListParams::new(Utc::now(), self.limit_per_page, page, validator)

sentry/src/domain/channel.rs

@@ -1,7 +1,8 @@
 use chrono::{DateTime, Utc};
 
-use domain::{Channel, RepositoryFuture};
+use domain::{Channel, RepositoryFuture, ValidatorId};
 use domain::{ChannelId, DomainError};
+use std::convert::TryFrom;
 
 pub struct ChannelListParams {
     /// page to show, should be >= 1
@@ -11,7 +12,7 @@ pub struct ChannelListParams {
     /// filters `valid_until` to be `>= valid_until_ge`
     pub valid_until_ge: DateTime<Utc>,
     /// filters the channels containing a specific validator if provided
-    pub validator: Option<String>,
+    pub validator: Option<ValidatorId>,
     /// Ensures that this struct can only be created by calling `new()`
     _secret: (),
 }
@@ -21,7 +22,7 @@ impl ChannelListParams {
         valid_until_ge: DateTime<Utc>,
         limit: u32,
         page: u64,
-        validator: Option<String>,
+        validator: Option<&str>,
     ) -> Result<Self, DomainError> {
         if page < 1 {
             return Err(DomainError::InvalidArgument(
@@ -35,7 +36,10 @@ impl ChannelListParams {
             ));
         }
 
-        let validator = validator.and_then(|s| if s.is_empty() { None } else { Some(s) });
+        let validator = validator
+            .and_then(|s| if s.is_empty() { None } else { Some(s) })
+            .map(ValidatorId::try_from)
+            .transpose()?;
 
         Ok(Self {
             valid_until_ge,

sentry/src/infrastructure/persistence/channel/memory_test.rs

@@ -151,8 +151,7 @@ fn listing_channels_can_handles_validator_filtration_and_keeps_valid_until_filtr
 
         let repository = MemoryChannelRepository::new(Some(&channels));
 
-        let params =
-            ChannelListParams::new(valid_until_ge, 10, 1, Some("validator-1".to_string())).unwrap();
+        let params = ChannelListParams::new(valid_until_ge, 10, 1, Some("validator-1")).unwrap();
         let list_channels = await!(repository.list(&params)).expect("Should list all channels");
 
         assert_eq!(1, list_channels.len());

validator/src/application/message_propagation.rs

@@ -1,9 +1,8 @@
-use std::convert::TryFrom;
 use std::error::Error;
 use std::fmt;
 
 use domain::validator::message::{Message, State};
-use domain::{Channel, RepositoryError, ValidatorId};
+use domain::{Channel, RepositoryError};
 
 use crate::domain::MessageRepository;
 
@@ -55,12 +54,10 @@ impl<S: State> MessagePropagator<S> {
         let mut results = Vec::default();
 
         for validator in channel.spec.validators.into_iter() {
-            // @TODO: Remove once we have ValidatorId in ValidatorDesc
-            let validator_id = ValidatorId::try_from(validator.id.as_str()).unwrap();
             let add_result =
                 await!(self
                     .message_repository
-                    .add(&channel.id, &validator_id, message.clone()))
+                    .add(&channel.id, &validator.id, message.clone()))
                 .map_err(Into::into);
             results.push(add_result);
         }

validator/src/application/worker.rs

@@ -49,7 +49,11 @@ pub mod single {
         async fn handle_channel(self, channel: Channel) -> Result<(), ()> {
             let channel_id = channel.id;
 
-            match &channel.spec.validators.find(&self.identity) {
+            // @TODO: Update once we figure out if ValidatorId can fail from a &str
+            let validator_id = ValidatorId::try_from(self.identity.as_str())
+                .expect("ValidatorId doesn't have a failing case right now");
+
+            match &channel.spec.validators.find(&validator_id) {
                 SpecValidator::Leader(_) => {
                     let tick_future = self.leader.tick(channel);