Merge pull request #132 from samparsky/sentry_implementation

Sentry implementation

Author: samparsky

adapter/src/dummy.rs

@@ -2,12 +2,13 @@
 #![deny(rust_2018_idioms)]
 
 use futures::future::{ok, FutureExt};
-use primitives::adapter::{Adapter, AdapterFuture, AdapterOptions};
+use primitives::adapter::{Adapter, AdapterOptions, AdapterResult};
 use primitives::channel_validator::ChannelValidator;
 use primitives::config::Config;
-use primitives::Channel;
+use primitives::{Channel, ValidatorDesc};
 use std::collections::HashMap;
 
+#[derive(Debug, Clone)]
 pub struct DummyAdapter {
     identity: String,
     auth_tokens: HashMap<String, String>,
@@ -35,45 +36,45 @@ impl Adapter for DummyAdapter {
         }
     }
 
-    fn unlock(&self) -> AdapterFuture<bool> {
-        ok(true).boxed()
+    fn unlock(&self) -> AdapterResult<bool> {
+        Ok(true)
     }
 
     fn whoami(&self) -> String {
         self.identity.to_string()
     }
 
-    fn sign(&self, state_root: String) -> AdapterFuture<String> {
+    fn sign(&self, state_root: String) -> AdapterResult<String> {
         let signature = format!(
             "Dummy adapter signature for {} by {}",
             state_root,
             self.whoami()
         );
-        ok(signature).boxed()
+        Ok(signature)
     }
 
-    fn verify(&self, signer: &str, _state_root: &str, signature: &str) -> AdapterFuture<bool> {
+    fn verify(&self, signer: &str, _state_root: &str, signature: &str) -> AdapterResult<bool> {
         // select the `identity` and compare it to the signer
         // for empty string this will return array with 1 element - an empty string `[""]`
         let is_same = match signature.rsplit(' ').take(1).next() {
             Some(from) => from == signer,
             None => false,
         };
 
-        ok(is_same).boxed()
+        Ok(is_same)
     }
 
-    fn validate_channel(&self, _channel: &Channel) -> AdapterFuture<bool> {
+    fn validate_channel(&self, _channel: &Channel) -> AdapterResult<bool> {
         // @TODO
-        ok(true).boxed()
+        Ok(true)
     }
 
-    fn session_from_token(&self, _token: &str) -> AdapterFuture<String> {
+    fn session_from_token(&self, _token: &str) -> AdapterResult<String> {
         // @TODO
-        ok("hello".to_string()).boxed()
+        Ok("hello".to_string())
     }
 
-    fn get_auth(&self, _validator: &str) -> AdapterFuture<String> {
+    fn get_auth(&self, _validator: &ValidatorDesc) -> AdapterResult<String> {
         // let participant = self
         //     .participants
         //     .iter()
@@ -84,6 +85,6 @@ impl Adapter for DummyAdapter {
         //         "Identity not found".to_string(),
         //     )),
         // };
-        ok("auth".to_string()).boxed()
+        Ok("auth".to_string())
     }
 }

adapter/src/ethereum.rs

@@ -1,15 +1,15 @@
 #![deny(clippy::all)]
 #![deny(rust_2018_idioms)]
 
-use std::collections::HashMap;
-
 use futures::future::{ok, FutureExt};
-use primitives::adapter::{Adapter, AdapterFuture, AdapterOptions};
+use primitives::adapter::{Adapter, AdapterOptions, AdapterResult};
 use primitives::channel_validator::ChannelValidator;
 use primitives::config::Config;
-use primitives::Channel;
+use primitives::{Channel, ValidatorDesc};
+use std::collections::HashMap;
 use web3::types::Address;
 
+#[derive(Debug, Clone)]
 pub struct EthereumAdapter {
     address: Option<Address>,
     keystore_json: String,
@@ -47,45 +47,45 @@ impl Adapter for EthereumAdapter {
         }
     }
 
-    fn unlock(&self) -> AdapterFuture<bool> {
-        ok(true).boxed()
+    fn unlock(&self) -> AdapterResult<bool> {
+        Ok(true)
     }
 
     fn whoami(&self) -> String {
         self.address.unwrap().to_string()
     }
 
-    fn sign(&self, state_root: String) -> AdapterFuture<String> {
+    fn sign(&self, state_root: String) -> AdapterResult<String> {
         let signature = format!(
             "Dummy adapter signature for {} by {}",
             state_root,
             self.whoami()
         );
-        ok(signature).boxed()
+        Ok(signature)
     }
 
-    fn verify(&self, signer: &str, _state_root: &str, signature: &str) -> AdapterFuture<bool> {
+    fn verify(&self, signer: &str, _state_root: &str, signature: &str) -> AdapterResult<bool> {
         // select the `identity` and compare it to the signer
         // for empty string this will return array with 1 element - an empty string `[""]`
         let is_same = match signature.rsplit(' ').take(1).next() {
             Some(from) => from == signer,
             None => false,
         };
 
-        ok(is_same).boxed()
+        Ok(is_same)
     }
 
-    fn validate_channel(&self, _channel: &Channel) -> AdapterFuture<bool> {
+    fn validate_channel(&self, _channel: &Channel) -> AdapterResult<bool> {
         // @TODO
-        ok(true).boxed()
+        Ok(true)
     }
 
-    fn session_from_token(&self, _token: &str) -> AdapterFuture<String> {
+    fn session_from_token(&self, _token: &str) -> AdapterResult<String> {
         // @TODO
-        ok("hello".to_string()).boxed()
+        Ok("hello".to_string())
     }
 
-    fn get_auth(&self, _validator: &str) -> AdapterFuture<String> {
+    fn get_auth(&self, _validator: &ValidatorDesc) -> AdapterResult<String> {
         // let participant = self
         //     .participants
         //     .iter()
@@ -96,6 +96,6 @@ impl Adapter for EthereumAdapter {
         //         "Identity not found".to_string(),
         //     )),
         // };
-        ok("auth".to_string()).boxed()
+        Ok("auth".to_string())
     }
 }

docs/config/dev.toml

@@ -1,4 +1,4 @@
-max_channels = 512
+max_channels=512
 channels_find_limit = 200
 wait_time = 500
 
@@ -14,8 +14,14 @@ list_timeout = 5000
 fetch_timeout = 5000
 validator_tick_timeout = 5000
 
-ip_rate_limit = { type = "ip", timeframe = 20000 }
-SID_RATE_LIMIT = { type = 'sid', timeframe = 20000 }
+ip_rate_limit = {type='ip', timeframe=20000}
+sid_rate_limit = {type='sid', timeframe=20000}
 
 ethereum_core_address = '0x333420fc6a897356e69b62417cd17ff012177d2b'
-ethereum_network = 'goerli'
+ethereum_network = 'goerli'
+
+creators_whitelist = []
+minimal_deposit = "0"
+minimal_fee = "0"
+token_address_whitelist = []
+validators_whitelist = []

docs/config/prod.toml

@@ -17,12 +17,12 @@ fetch_timeout = 10000
 validator_tick_timeout = 10000
 
 ip_rate_limit = { type = "ip", timeframe = 20000 }
-
+sid_rate_limit = { type = "sid", timeframe = 0 }
 ethereum_core_address = '0x333420fc6a897356e69b62417cd17ff012177d2b'
 ethereum_network = 'homestead'
 token_address_whitelist = ['0x89d24A6b4CcB1B6fAA2625fE562bDD9a23260359']
 
 creators_whitelist = []
-minimal_deposit = 0
-minimal_fee = 0
-validators_whitelist = []
+minimal_deposit = "0"
+minimal_fee = "0"
+validators_whitelist = []

primitives/src/adapter.rs

@@ -2,13 +2,15 @@ use futures::prelude::*;
 use std::collections::HashMap;
 use std::pin::Pin;
 // use domain::validator::message::State;
+use crate::channel_validator::ChannelValidator;
+use crate::validator::ValidatorDesc;
 use crate::{Channel, Config};
-//
 //use crate::sanity::SanityChecker;
 use std::error::Error;
 use std::fmt;
+use std::fmt::Debug;
 
-pub type AdapterFuture<T> = Pin<Box<dyn Future<Output = Result<T, AdapterError>> + Send>>;
+pub type AdapterResult<T> = Result<T, AdapterError>;
 
 #[derive(Debug, Eq, PartialEq)]
 pub enum AdapterError {
@@ -34,30 +36,30 @@ pub struct AdapterOptions {
     pub keystore_pwd: Option<String>,
 }
 
-pub trait Adapter {
+pub trait Adapter: ChannelValidator + Clone + Debug + Send + Sync {
     type Output;
 
     /// Initialize adapter
     fn init(opts: AdapterOptions, config: &Config) -> Self::Output;
 
     /// Unlock adapter
-    fn unlock(&self) -> AdapterFuture<bool>;
+    fn unlock(&self) -> AdapterResult<bool>;
 
     /// Get Adapter whoami
     fn whoami(&self) -> String;
 
     /// Signs the provided state_root
-    fn sign(&self, state_root: String) -> AdapterFuture<String>;
+    fn sign(&self, state_root: String) -> AdapterResult<String>;
 
     /// Verify, based on the signature & state_root, that the signer is the same
-    fn verify(&self, signer: &str, state_root: &str, signature: &str) -> AdapterFuture<bool>;
+    fn verify(&self, signer: &str, state_root: &str, signature: &str) -> AdapterResult<bool>;
 
     /// Validate a channel
-    fn validate_channel(&self, channel: &Channel) -> AdapterFuture<bool>;
+    fn validate_channel(&self, channel: &Channel) -> AdapterResult<bool>;
 
     /// Get user session from token
-    fn session_from_token(&self, token: &str) -> AdapterFuture<String>;
+    fn session_from_token(&self, token: &str) -> AdapterResult<String>;
 
     /// Gets authentication for specific validator
-    fn get_auth(&self, validator: &str) -> AdapterFuture<String>;
+    fn get_auth(&self, validator: &ValidatorDesc) -> AdapterResult<String>;
 }

primitives/src/channel.rs

@@ -38,10 +38,14 @@ pub struct ChannelSpec {
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub min_targeting_score: Option<f64>,
     /// EventSubmission object, applies to event submission (POST /channel/:id/events)
-    pub event_submission: EventSubmission,
+    pub event_submission: Option<EventSubmission>,
     /// A millisecond timestamp of when the campaign was created
-    #[serde(with = "ts_milliseconds")]
-    pub created: DateTime<Utc>,
+    #[serde(
+        default,
+        skip_serializing_if = "Option::is_none",
+        with = "ts_milliseconds_option"
+    )]
+    pub created: Option<DateTime<Utc>>,
     /// A millisecond timestamp representing the time you want this campaign to become active (optional)
     /// Used by the AdViewManager
     #[serde(
@@ -51,7 +55,7 @@ pub struct ChannelSpec {
     )]
     pub active_from: Option<DateTime<Utc>>,
     /// A random number to ensure the campaignSpec hash is unique
-    pub nonce: BigNum,
+    pub nonce: Option<BigNum>,
     /// A millisecond timestamp of when the campaign should enter a withdraw period
     /// (no longer accept any events other than CHANNEL_CLOSE)
     /// A sane value should be lower than channel.validUntil * 1000 and higher than created

primitives/src/channel_validator.rs

@@ -4,7 +4,8 @@ use chrono::Utc;
 
 pub trait ChannelValidator {
     fn is_channel_valid(config: &Config, channel: &Channel) -> Result<(), ChannelError> {
-        let adapter_channel_validator = match channel.spec.validators.find(&config.identity) {
+        let identity = &config.clone().identity.unwrap_or_else(|| "".to_string());
+        let adapter_channel_validator = match channel.spec.validators.find(identity) {
             // check if the channel validators include our adapter identity
             SpecValidator::None => return Err(ChannelError::AdapterNotIncluded),
             SpecValidator::Leader(validator) | SpecValidator::Follower(validator) => validator,