From f864fd9a7366ba4339a6d8dcd50a8bf305330c9b Mon Sep 17 00:00:00 2001 From: librelois Date: Wed, 24 Apr 2019 20:47:46 +0200 Subject: [PATCH 1/5] [ref] ws2pv1: move crate code in folder src --- lib/modules/ws2p-v1-legacy/Cargo.toml | 2 +- lib/modules/ws2p-v1-legacy/{ => src}/ack_message.rs | 0 lib/modules/ws2p-v1-legacy/{ => src}/connect_message.rs | 0 lib/modules/ws2p-v1-legacy/{ => src}/constants.rs | 0 lib/modules/ws2p-v1-legacy/{ => src}/datas.rs | 0 lib/modules/ws2p-v1-legacy/{ => src}/heads.rs | 0 lib/modules/ws2p-v1-legacy/{ => src}/lib.rs | 0 lib/modules/ws2p-v1-legacy/{ => src}/ok_message.rs | 0 lib/modules/ws2p-v1-legacy/{ => src}/parsers/blocks.rs | 0 lib/modules/ws2p-v1-legacy/{ => src}/parsers/excluded.rs | 0 lib/modules/ws2p-v1-legacy/{ => src}/parsers/identities.rs | 0 lib/modules/ws2p-v1-legacy/{ => src}/parsers/memberships.rs | 0 lib/modules/ws2p-v1-legacy/{ => src}/parsers/mod.rs | 0 lib/modules/ws2p-v1-legacy/{ => src}/parsers/transactions.rs | 0 lib/modules/ws2p-v1-legacy/{ => src}/serializer.rs | 0 lib/modules/ws2p-v1-legacy/{ => src}/ws2p_connection.rs | 0 lib/modules/ws2p-v1-legacy/{ => src}/ws2p_db.rs | 0 lib/modules/ws2p-v1-legacy/{ => src}/ws2p_requests.rs | 0 18 files changed, 1 insertion(+), 1 deletion(-) rename lib/modules/ws2p-v1-legacy/{ => src}/ack_message.rs (100%) rename lib/modules/ws2p-v1-legacy/{ => src}/connect_message.rs (100%) rename lib/modules/ws2p-v1-legacy/{ => src}/constants.rs (100%) rename lib/modules/ws2p-v1-legacy/{ => src}/datas.rs (100%) rename lib/modules/ws2p-v1-legacy/{ => src}/heads.rs (100%) rename lib/modules/ws2p-v1-legacy/{ => src}/lib.rs (100%) rename lib/modules/ws2p-v1-legacy/{ => src}/ok_message.rs (100%) rename lib/modules/ws2p-v1-legacy/{ => src}/parsers/blocks.rs (100%) rename lib/modules/ws2p-v1-legacy/{ => src}/parsers/excluded.rs (100%) rename lib/modules/ws2p-v1-legacy/{ => src}/parsers/identities.rs (100%) rename lib/modules/ws2p-v1-legacy/{ => src}/parsers/memberships.rs (100%) rename lib/modules/ws2p-v1-legacy/{ => src}/parsers/mod.rs (100%) rename lib/modules/ws2p-v1-legacy/{ => src}/parsers/transactions.rs (100%) rename lib/modules/ws2p-v1-legacy/{ => src}/serializer.rs (100%) rename lib/modules/ws2p-v1-legacy/{ => src}/ws2p_connection.rs (100%) rename lib/modules/ws2p-v1-legacy/{ => src}/ws2p_db.rs (100%) rename lib/modules/ws2p-v1-legacy/{ => src}/ws2p_requests.rs (100%) diff --git a/lib/modules/ws2p-v1-legacy/Cargo.toml b/lib/modules/ws2p-v1-legacy/Cargo.toml index 30909adc..e4aba182 100644 --- a/lib/modules/ws2p-v1-legacy/Cargo.toml +++ b/lib/modules/ws2p-v1-legacy/Cargo.toml @@ -7,7 +7,7 @@ license = "AGPL-3.0" edition = "2018" [lib] -path = "lib.rs" +path = "src/lib.rs" [dependencies] byteorder = "1.2.3" diff --git a/lib/modules/ws2p-v1-legacy/ack_message.rs b/lib/modules/ws2p-v1-legacy/src/ack_message.rs similarity index 100% rename from lib/modules/ws2p-v1-legacy/ack_message.rs rename to lib/modules/ws2p-v1-legacy/src/ack_message.rs diff --git a/lib/modules/ws2p-v1-legacy/connect_message.rs b/lib/modules/ws2p-v1-legacy/src/connect_message.rs similarity index 100% rename from lib/modules/ws2p-v1-legacy/connect_message.rs rename to lib/modules/ws2p-v1-legacy/src/connect_message.rs diff --git a/lib/modules/ws2p-v1-legacy/constants.rs b/lib/modules/ws2p-v1-legacy/src/constants.rs similarity index 100% rename from lib/modules/ws2p-v1-legacy/constants.rs rename to lib/modules/ws2p-v1-legacy/src/constants.rs diff --git a/lib/modules/ws2p-v1-legacy/datas.rs b/lib/modules/ws2p-v1-legacy/src/datas.rs similarity index 100% rename from lib/modules/ws2p-v1-legacy/datas.rs rename to lib/modules/ws2p-v1-legacy/src/datas.rs diff --git a/lib/modules/ws2p-v1-legacy/heads.rs b/lib/modules/ws2p-v1-legacy/src/heads.rs similarity index 100% rename from lib/modules/ws2p-v1-legacy/heads.rs rename to lib/modules/ws2p-v1-legacy/src/heads.rs diff --git a/lib/modules/ws2p-v1-legacy/lib.rs b/lib/modules/ws2p-v1-legacy/src/lib.rs similarity index 100% rename from lib/modules/ws2p-v1-legacy/lib.rs rename to lib/modules/ws2p-v1-legacy/src/lib.rs diff --git a/lib/modules/ws2p-v1-legacy/ok_message.rs b/lib/modules/ws2p-v1-legacy/src/ok_message.rs similarity index 100% rename from lib/modules/ws2p-v1-legacy/ok_message.rs rename to lib/modules/ws2p-v1-legacy/src/ok_message.rs diff --git a/lib/modules/ws2p-v1-legacy/parsers/blocks.rs b/lib/modules/ws2p-v1-legacy/src/parsers/blocks.rs similarity index 100% rename from lib/modules/ws2p-v1-legacy/parsers/blocks.rs rename to lib/modules/ws2p-v1-legacy/src/parsers/blocks.rs diff --git a/lib/modules/ws2p-v1-legacy/parsers/excluded.rs b/lib/modules/ws2p-v1-legacy/src/parsers/excluded.rs similarity index 100% rename from lib/modules/ws2p-v1-legacy/parsers/excluded.rs rename to lib/modules/ws2p-v1-legacy/src/parsers/excluded.rs diff --git a/lib/modules/ws2p-v1-legacy/parsers/identities.rs b/lib/modules/ws2p-v1-legacy/src/parsers/identities.rs similarity index 100% rename from lib/modules/ws2p-v1-legacy/parsers/identities.rs rename to lib/modules/ws2p-v1-legacy/src/parsers/identities.rs diff --git a/lib/modules/ws2p-v1-legacy/parsers/memberships.rs b/lib/modules/ws2p-v1-legacy/src/parsers/memberships.rs similarity index 100% rename from lib/modules/ws2p-v1-legacy/parsers/memberships.rs rename to lib/modules/ws2p-v1-legacy/src/parsers/memberships.rs diff --git a/lib/modules/ws2p-v1-legacy/parsers/mod.rs b/lib/modules/ws2p-v1-legacy/src/parsers/mod.rs similarity index 100% rename from lib/modules/ws2p-v1-legacy/parsers/mod.rs rename to lib/modules/ws2p-v1-legacy/src/parsers/mod.rs diff --git a/lib/modules/ws2p-v1-legacy/parsers/transactions.rs b/lib/modules/ws2p-v1-legacy/src/parsers/transactions.rs similarity index 100% rename from lib/modules/ws2p-v1-legacy/parsers/transactions.rs rename to lib/modules/ws2p-v1-legacy/src/parsers/transactions.rs diff --git a/lib/modules/ws2p-v1-legacy/serializer.rs b/lib/modules/ws2p-v1-legacy/src/serializer.rs similarity index 100% rename from lib/modules/ws2p-v1-legacy/serializer.rs rename to lib/modules/ws2p-v1-legacy/src/serializer.rs diff --git a/lib/modules/ws2p-v1-legacy/ws2p_connection.rs b/lib/modules/ws2p-v1-legacy/src/ws2p_connection.rs similarity index 100% rename from lib/modules/ws2p-v1-legacy/ws2p_connection.rs rename to lib/modules/ws2p-v1-legacy/src/ws2p_connection.rs diff --git a/lib/modules/ws2p-v1-legacy/ws2p_db.rs b/lib/modules/ws2p-v1-legacy/src/ws2p_db.rs similarity index 100% rename from lib/modules/ws2p-v1-legacy/ws2p_db.rs rename to lib/modules/ws2p-v1-legacy/src/ws2p_db.rs diff --git a/lib/modules/ws2p-v1-legacy/ws2p_requests.rs b/lib/modules/ws2p-v1-legacy/src/ws2p_requests.rs similarity index 100% rename from lib/modules/ws2p-v1-legacy/ws2p_requests.rs rename to lib/modules/ws2p-v1-legacy/src/ws2p_requests.rs -- GitLab From cea0216b5701a0418ae10850bde37980a8041588 Mon Sep 17 00:00:00 2001 From: librelois Date: Thu, 25 Apr 2019 00:53:11 +0200 Subject: [PATCH 2/5] [feat] common-tools: add fn read & write binary file --- lib/tools/common-tools/src/lib.rs | 44 +++++++++++++++++++++++++------ 1 file changed, 36 insertions(+), 8 deletions(-) diff --git a/lib/tools/common-tools/src/lib.rs b/lib/tools/common-tools/src/lib.rs index f726482e..be0eee5c 100644 --- a/lib/tools/common-tools/src/lib.rs +++ b/lib/tools/common-tools/src/lib.rs @@ -26,6 +26,13 @@ unused_import_braces )] +use std::fs::File; +use std::io::Read; +use std::io::Write; +use std::path::Path; +use std::time::SystemTime; +use std::time::UNIX_EPOCH; + /// Interrupts the program and log error message /// WARNING: this macro must not be called before the logger is initialized ! #[macro_export] @@ -44,14 +51,35 @@ macro_rules! fatal_error { }); } -/*macro_rules! error { - (target: $target:expr, $($arg:tt)+) => ( - log!(target: $target, $crate::Level::Error, $($arg)+); - ); - ($($arg:tt)+) => ( - log!($crate::Level::Error, $($arg)+); - ) -}*/ +#[inline] +/// Get current timestamp in seconds +pub fn current_timestamp() -> u64 { + SystemTime::now() + .duration_since(UNIX_EPOCH) + .expect("SystemTime::duration_since failed") + .as_secs() +} + +/// Read bin file +pub fn read_bin_file(file_path: &Path) -> Result, std::io::Error> { + let mut file = File::open(file_path)?; + if file.metadata()?.len() == 0 { + Ok(vec![]) + } else { + let mut bin_datas = Vec::new(); + file.read_to_end(&mut bin_datas)?; + + Ok(bin_datas) + } +} + +/// Write bin file +pub fn write_bin_file(file_path: &Path, datas: &[u8]) -> Result<(), std::io::Error> { + let mut file = File::create(file_path)?; + file.write_all(&datas[..])?; + + Ok(()) +} /// Unescape backslash pub fn unescape_str(source: &str) -> String { -- GitLab From c0ad94390555672cb038bdccce17b113f319daef Mon Sep 17 00:00:00 2001 From: librelois Date: Thu, 25 Apr 2019 00:54:34 +0200 Subject: [PATCH 3/5] [ref] network-documents: use new serde derive way --- lib/tools/network-documents/Cargo.toml | 3 +-- lib/tools/network-documents/src/lib.rs | 5 ++--- lib/tools/network-documents/src/network_head.rs | 1 + lib/tools/network-documents/src/network_head_v2.rs | 1 + 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/lib/tools/network-documents/Cargo.toml b/lib/tools/network-documents/Cargo.toml index d53595f8..f218c133 100644 --- a/lib/tools/network-documents/Cargo.toml +++ b/lib/tools/network-documents/Cargo.toml @@ -18,8 +18,7 @@ dubp-documents= { path = "../documents" } hex = "0.3.*" pest = "2.1.0" pest_derive = "2.1.0" -serde = "1.0.*" -serde_derive = "1.0.*" +serde = { version = "1.0.*", features = ["derive"] } serde_json = "1.0.*" [dev-dependencies] diff --git a/lib/tools/network-documents/src/lib.rs b/lib/tools/network-documents/src/lib.rs index dd95a0f3..a5eeec12 100644 --- a/lib/tools/network-documents/src/lib.rs +++ b/lib/tools/network-documents/src/lib.rs @@ -30,8 +30,6 @@ extern crate pest_derive; #[cfg(test)] #[macro_use] extern crate pretty_assertions; -#[macro_use] -extern crate serde_derive; pub mod network_endpoint; pub mod network_head; @@ -48,6 +46,7 @@ use dup_crypto::hashs::*; use dup_crypto::keys::*; use pest::iterators::Pair; use pest::Parser; +use serde::{Deserialize, Serialize}; use std::fmt::{Display, Error, Formatter}; #[derive(Parser)] @@ -116,7 +115,7 @@ impl<'a> From<&'a str> for NodeId { } } -#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +#[derive(Copy, Clone, Debug, Deserialize, Eq, Hash, PartialEq, Serialize)] /// Complete identifier of a duniter node. pub struct NodeFullId(pub NodeId, pub PubKey); diff --git a/lib/tools/network-documents/src/network_head.rs b/lib/tools/network-documents/src/network_head.rs index b3d50090..fddce933 100644 --- a/lib/tools/network-documents/src/network_head.rs +++ b/lib/tools/network-documents/src/network_head.rs @@ -21,6 +21,7 @@ use crate::{NodeFullId, NodeId}; use dubp_documents::blockstamp::*; use dup_crypto::bases::BaseConvertionError; use dup_crypto::keys::*; +use serde::{Deserialize, Serialize}; use serde_json; use std::collections::HashMap; use std::num::ParseIntError; diff --git a/lib/tools/network-documents/src/network_head_v2.rs b/lib/tools/network-documents/src/network_head_v2.rs index f8e8b596..cd113c9f 100644 --- a/lib/tools/network-documents/src/network_head_v2.rs +++ b/lib/tools/network-documents/src/network_head_v2.rs @@ -19,6 +19,7 @@ use crate::NodeId; use dubp_documents::blockstamp::*; use dup_crypto::bases::BaseConvertionError; use dup_crypto::keys::*; +use serde::{Deserialize, Serialize}; use std::cmp::Ordering; use std::num::ParseIntError; use std::ops::Deref; -- GitLab From c544ba13f02e9e408def849a789bbc7f1aea22ed Mon Sep 17 00:00:00 2001 From: librelois Date: Thu, 25 Apr 2019 00:55:46 +0200 Subject: [PATCH 4/5] [ref+feat] ws2p1: deep ref whole crate + migrate sqlite -> bin file --- lib/modules/ws2p-v1-legacy/Cargo.toml | 15 +- lib/modules/ws2p-v1-legacy/clippy.toml | 2 +- lib/modules/ws2p-v1-legacy/src/ack_message.rs | 28 +- .../ws2p-v1-legacy/src/connect_message.rs | 31 +- lib/modules/ws2p-v1-legacy/src/constants.rs | 47 +- lib/modules/ws2p-v1-legacy/src/datas.rs | 491 --------- lib/modules/ws2p-v1-legacy/src/events/mod.rs | 19 + .../ws2p-v1-legacy/src/events/received.rs | 72 ++ lib/modules/ws2p-v1-legacy/src/events/sent.rs | 59 ++ lib/modules/ws2p-v1-legacy/src/lib.rs | 956 ++++++++---------- lib/modules/ws2p-v1-legacy/src/ok_message.rs | 34 +- .../ws2p-v1-legacy/src/parsers/excluded.rs | 15 +- .../ws2p-v1-legacy/src/parsers/identities.rs | 19 +- .../ws2p-v1-legacy/src/parsers/memberships.rs | 22 +- lib/modules/ws2p-v1-legacy/src/parsers/mod.rs | 58 +- .../src/parsers/transactions.rs | 25 +- .../ws2p-v1-legacy/src/requests/mod.rs | 19 + .../ws2p-v1-legacy/src/requests/received.rs | 66 ++ .../ws2p-v1-legacy/src/requests/sent.rs | 37 + .../ws2p-v1-legacy/src/responses/mod.rs | 19 + .../ws2p-v1-legacy/src/responses/received.rs | 16 + .../ws2p-v1-legacy/src/responses/sent.rs | 36 + lib/modules/ws2p-v1-legacy/src/ws2p_db.rs | 157 ++- .../ws2p-v1-legacy/src/ws2p_requests.rs | 37 - .../src/ws_connections/handler.rs | 241 +++++ .../src/ws_connections/messages.rs | 291 ++++++ .../meta_datas.rs} | 406 +------- .../ws2p-v1-legacy/src/ws_connections/mod.rs | 184 ++++ .../src/ws_connections/requests/mod.rs | 19 + .../src/ws_connections/requests/received.rs | 1 + .../src/ws_connections/requests/sent.rs | 77 ++ .../src/ws_connections/states.rs | 76 ++ 32 files changed, 1929 insertions(+), 1646 deletions(-) delete mode 100644 lib/modules/ws2p-v1-legacy/src/datas.rs create mode 100644 lib/modules/ws2p-v1-legacy/src/events/mod.rs create mode 100644 lib/modules/ws2p-v1-legacy/src/events/received.rs create mode 100644 lib/modules/ws2p-v1-legacy/src/events/sent.rs create mode 100644 lib/modules/ws2p-v1-legacy/src/requests/mod.rs create mode 100644 lib/modules/ws2p-v1-legacy/src/requests/received.rs create mode 100644 lib/modules/ws2p-v1-legacy/src/requests/sent.rs create mode 100644 lib/modules/ws2p-v1-legacy/src/responses/mod.rs create mode 100644 lib/modules/ws2p-v1-legacy/src/responses/received.rs create mode 100644 lib/modules/ws2p-v1-legacy/src/responses/sent.rs delete mode 100644 lib/modules/ws2p-v1-legacy/src/ws2p_requests.rs create mode 100644 lib/modules/ws2p-v1-legacy/src/ws_connections/handler.rs create mode 100644 lib/modules/ws2p-v1-legacy/src/ws_connections/messages.rs rename lib/modules/ws2p-v1-legacy/src/{ws2p_connection.rs => ws_connections/meta_datas.rs} (52%) create mode 100644 lib/modules/ws2p-v1-legacy/src/ws_connections/mod.rs create mode 100644 lib/modules/ws2p-v1-legacy/src/ws_connections/requests/mod.rs create mode 100644 lib/modules/ws2p-v1-legacy/src/ws_connections/requests/received.rs create mode 100644 lib/modules/ws2p-v1-legacy/src/ws_connections/requests/sent.rs create mode 100644 lib/modules/ws2p-v1-legacy/src/ws_connections/states.rs diff --git a/lib/modules/ws2p-v1-legacy/Cargo.toml b/lib/modules/ws2p-v1-legacy/Cargo.toml index e4aba182..6b2f9788 100644 --- a/lib/modules/ws2p-v1-legacy/Cargo.toml +++ b/lib/modules/ws2p-v1-legacy/Cargo.toml @@ -10,23 +10,24 @@ edition = "2018" path = "src/lib.rs" [dependencies] +bincode = "1.0.1" byteorder = "1.2.3" +dubp-documents= { path = "../../tools/documents" } duniter-conf = { path = "../../core/conf" } +duniter-module = { path = "../../core/module" } +duniter-network = { path = "../../core/network" } dup-crypto = { path = "../../tools/crypto" } -dubp-documents= { path = "../../tools/documents" } durs-network-documents = { path = "../../tools/network-documents" } durs-message = { path = "../../core/message" } -duniter-module = { path = "../../core/module" } -duniter-network = { path = "../../core/network" } +durs-common-tools = { path = "../../tools/common-tools" } durs-wot = { path = "../../tools/wot" } log = "0.4.*" rand = "0.4.*" -sqlite = "0.23.*" -serde = "1.0.*" -serde_derive = "1.0.*" +serde = { version = "1.0.*", features = ["derive"] } serde_json = "1.0.*" structopt= "0.2.*" -ws = { version = "0.7.*", features = ["permessage-deflate"] } +unwrap = "1.2.1" +ws = "0.7.*" [features] ssl = ["ws/ssl"] \ No newline at end of file diff --git a/lib/modules/ws2p-v1-legacy/clippy.toml b/lib/modules/ws2p-v1-legacy/clippy.toml index 05bd01e1..fbfe7d8a 100644 --- a/lib/modules/ws2p-v1-legacy/clippy.toml +++ b/lib/modules/ws2p-v1-legacy/clippy.toml @@ -1 +1 @@ -cyclomatic-complexity-threshold = 77 \ No newline at end of file +cyclomatic-complexity-threshold = 51 \ No newline at end of file diff --git a/lib/modules/ws2p-v1-legacy/src/ack_message.rs b/lib/modules/ws2p-v1-legacy/src/ack_message.rs index e1fcdeed..f18bf55e 100644 --- a/lib/modules/ws2p-v1-legacy/src/ack_message.rs +++ b/lib/modules/ws2p-v1-legacy/src/ack_message.rs @@ -1,4 +1,4 @@ -use super::WS2PMessage; +use crate::*; use dup_crypto::keys::*; use serde::ser::{Serialize, SerializeStruct, Serializer}; @@ -11,20 +11,19 @@ pub struct WS2PAckMessageV1 { } impl WS2PMessage for WS2PAckMessageV1 { - fn parse(v: &serde_json::Value, currency: String) -> Option { + fn parse(v: &serde_json::Value, currency: String) -> Result { let pubkey = match v.get("pub") { - Some(pubkey) => pubkey.as_str().unwrap().to_string(), - None => return None, + Some(pubkey) => pubkey.as_str().ok_or(WS2PMsgParseErr {})?.to_string(), + None => return Err(WS2PMsgParseErr {}), }; let signature = match v.get("sig") { - Some(signature) => signature.as_str().unwrap().to_string(), - None => return None, + Some(signature) => signature.as_str().ok_or(WS2PMsgParseErr {})?.to_string(), + None => return Err(WS2PMsgParseErr {}), }; - let pubkey = PubKey::Ed25519(ed25519::PublicKey::from_base58(&pubkey).unwrap()); - let signature: Option = Some(Sig::Ed25519( - ed25519::Signature::from_base64(&signature).unwrap(), - )); - Some(WS2PAckMessageV1 { + let pubkey = PubKey::Ed25519(ed25519::PublicKey::from_base58(&pubkey)?); + let signature: Option = + Some(Sig::Ed25519(ed25519::Signature::from_base64(&signature)?)); + Ok(WS2PAckMessageV1 { currency, pubkey, challenge: "".to_string(), @@ -38,8 +37,11 @@ impl WS2PMessage for WS2PAckMessageV1 { ) } fn verify(&self) -> bool { - self.pubkey - .verify(self.to_raw().as_bytes(), &self.signature.unwrap()) + if let Some(sig) = self.signature { + self.pubkey.verify(self.to_raw().as_bytes(), &sig) + } else { + false + } } } diff --git a/lib/modules/ws2p-v1-legacy/src/connect_message.rs b/lib/modules/ws2p-v1-legacy/src/connect_message.rs index 1f917ade..e229cc1d 100644 --- a/lib/modules/ws2p-v1-legacy/src/connect_message.rs +++ b/lib/modules/ws2p-v1-legacy/src/connect_message.rs @@ -1,4 +1,4 @@ -use super::WS2PMessage; +use crate::*; use dup_crypto::keys::*; use serde::ser::{Serialize, SerializeStruct, Serializer}; @@ -11,24 +11,22 @@ pub struct WS2PConnectMessageV1 { } impl WS2PMessage for WS2PConnectMessageV1 { - fn parse(v: &serde_json::Value, currency: String) -> Option { + fn parse(v: &serde_json::Value, currency: String) -> Result { let pubkey = match v.get("pub") { - Some(pubkey) => pubkey.as_str().unwrap().to_string(), - None => return None, + Some(pubkey) => pubkey.as_str().ok_or(WS2PMsgParseErr {})?.to_string(), + None => return Err(WS2PMsgParseErr {}), }; let challenge = match v.get("challenge") { - Some(challenge) => challenge.as_str().unwrap().to_string(), - None => return None, + Some(challenge) => challenge.as_str().ok_or(WS2PMsgParseErr {})?.to_string(), + None => return Err(WS2PMsgParseErr {}), }; let signature = match v.get("sig") { - Some(signature) => signature.as_str().unwrap().to_string(), - None => return None, + Some(signature) => signature.as_str().ok_or(WS2PMsgParseErr {})?.to_string(), + None => return Err(WS2PMsgParseErr {}), }; - let pubkey = PubKey::Ed25519(ed25519::PublicKey::from_base58(&pubkey).unwrap()); - let signature = Some(Sig::Ed25519( - ed25519::Signature::from_base64(&signature).unwrap(), - )); - Some(WS2PConnectMessageV1 { + let pubkey = PubKey::Ed25519(ed25519::PublicKey::from_base58(&pubkey)?); + let signature = Some(Sig::Ed25519(ed25519::Signature::from_base64(&signature)?)); + Ok(WS2PConnectMessageV1 { currency, pubkey, challenge, @@ -42,8 +40,11 @@ impl WS2PMessage for WS2PConnectMessageV1 { ) } fn verify(&self) -> bool { - self.pubkey - .verify(self.to_raw().as_bytes(), &self.signature.unwrap()) + if let Some(sig) = self.signature { + self.pubkey.verify(self.to_raw().as_bytes(), &sig) + } else { + false + } } } diff --git a/lib/modules/ws2p-v1-legacy/src/constants.rs b/lib/modules/ws2p-v1-legacy/src/constants.rs index aaada76d..cdc14af7 100644 --- a/lib/modules/ws2p-v1-legacy/src/constants.rs +++ b/lib/modules/ws2p-v1-legacy/src/constants.rs @@ -1,12 +1,55 @@ +// Copyright (C) 2018 The Durs Project Developers. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +//! WS2Pv1 constants + +/// API Name +pub static WS2P_API: &'static str = "WS2P"; + +/// Interval between to sequence of general actions +pub static WS2P_GENERAL_STATE_INTERVAL: &'static u64 = &15; + +/// Connection wave interval at startup pub static WS2P_OUTCOMING_INTERVAL_AT_STARTUP: &'static u64 = &75; + +/// Interval of connection waves after the start-up phase pub static WS2P_OUTCOMING_INTERVAL: &'static u64 = &300; + +/// Default outgoing connection quota pub static WS2P_DEFAULT_OUTCOMING_QUOTA: &'static usize = &10; + +/// Maximum duration of a connection negotiation pub static WS2P_NEGOTIATION_TIMEOUT: &'static u64 = &15; + +/// Maximum waiting time for a response to a request //pub static WS2P_REQUEST_TIMEOUT : &'static u64 = &30; + +/// Maximum duration of inactivity of a connection (the connection will be closed after this delay) pub static WS2P_EXPIRE_TIMEOUT: &'static u64 = &120; + +/// Interval between 2 messages from which it''s perhaps a spam (in milliseconds) pub static WS2P_SPAM_INTERVAL_IN_MILLI_SECS: &'static u64 = &80; + +/// Number of consecutive closed messages from which messages will be considered as spam. pub static WS2P_SPAM_LIMIT: &'static usize = &6; + +/// Rest time in a situation of proven spam pub static WS2P_SPAM_SLEEP_TIME_IN_SEC: &'static u64 = &100; -pub static DURATION_BEFORE_RECORDING_ENDPOINT: &'static u64 = &180; -pub static BLOCKS_REQUEST_INTERVAL: &'static u64 = &60; + +/// Duration between 2 endpoints saving +pub static DURATION_BETWEEN_2_ENDPOINTS_SAVING: &'static u64 = &180; + +/// Duration between 2 requests from the pool of the wot data pub static PENDING_IDENTITIES_REQUEST_INTERVAL: &'static u64 = &40; diff --git a/lib/modules/ws2p-v1-legacy/src/datas.rs b/lib/modules/ws2p-v1-legacy/src/datas.rs deleted file mode 100644 index 89968a51..00000000 --- a/lib/modules/ws2p-v1-legacy/src/datas.rs +++ /dev/null @@ -1,491 +0,0 @@ -// Copyright (C) 2018 The Duniter Project Developers. -// -// This program is free software: you can redistribute it and/or modify -// it under the terms of the GNU Affero General Public License as -// published by the Free Software Foundation, either version 3 of the -// License, or (at your option) any later version. -// -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU Affero General Public License for more details. -// -// You should have received a copy of the GNU Affero General Public License -// along with this program. If not, see . - -use crate::*; -use dup_crypto::keys::*; -use durs_message::requests::BlockchainRequest; -use durs_message::*; -use durs_network_documents::network_endpoint::*; -use durs_network_documents::network_head::*; -use durs_network_documents::*; -use std::collections::HashSet; -use std::sync::mpsc; - -#[derive(Debug)] -pub struct WS2PModuleDatas { - pub router_sender: mpsc::Sender>, - pub currency: Option, - pub key_pair: Option, - pub conf: WS2PConf, - pub ssl: bool, - pub node_id: NodeId, - pub main_thread_channel: ( - mpsc::Sender, - mpsc::Receiver, - ), - pub ws2p_endpoints: HashMap, - pub websockets: HashMap, - pub requests_awaiting_response: - HashMap, - pub heads_cache: HashMap, - pub my_head: Option, - pub uids_cache: HashMap, - pub count_dal_requests: u32, -} - -#[inline] -#[cfg(not(feature = "ssl"))] -fn ssl() -> bool { - false -} -#[cfg(feature = "ssl")] -fn ssl() -> bool { - true -} - -impl WS2PModuleDatas { - pub fn new( - router_sender: mpsc::Sender>, - conf: WS2PConf, - node_id: NodeId, - ) -> WS2PModuleDatas { - WS2PModuleDatas { - router_sender, - key_pair: None, - currency: None, - conf, - ssl: ssl(), - node_id, - main_thread_channel: mpsc::channel(), - ws2p_endpoints: HashMap::new(), - websockets: HashMap::new(), - requests_awaiting_response: HashMap::new(), - heads_cache: HashMap::new(), - my_head: None, - uids_cache: HashMap::new(), - count_dal_requests: 0, - } - } - pub fn open_db(db_path: &PathBuf) -> Result { - let conn: sqlite::Connection; - if !db_path.as_path().exists() { - conn = sqlite::open(db_path.as_path())?; - conn.execute( - "CREATE TABLE endpoints (hash_full_id TEXT, status INTEGER, node_id INTEGER, pubkey TEXT, - api INTEGER, version INTEGER, endpoint TEXT, last_check INTEGER);", - )?; - } else { - conn = sqlite::open(db_path.as_path())?; - } - Ok(conn) - } - pub fn send_dal_request(&mut self, req: &BlockchainRequest) { - self.count_dal_requests += 1; - if self.count_dal_requests == std::u32::MAX { - self.count_dal_requests = 0; - } - self.router_sender - .send(RouterThreadMessage::ModuleMessage(DursMsg::Request { - req_from: WS2PModule::name(), - req_to: ModuleRole::BlockchainDatas, - req_id: ModuleReqId(self.count_dal_requests), - req_content: DursReqContent::BlockchainRequest(req.clone()), - })) - .expect("Fail to send message to router !"); - } - pub fn send_network_req_response( - &self, - requester: ModuleStaticName, - req_id: ModuleReqId, - response: NetworkResponse, - ) { - self.router_sender - .send(RouterThreadMessage::ModuleMessage(DursMsg::Response { - res_from: WS2PModule::name(), - res_to: requester, - req_id, - res_content: DursResContent::NetworkResponse(response), - })) - .expect("Fail to send message to router !"); - } - pub fn send_network_event(&self, event: &NetworkEvent) { - let module_event = match event { - NetworkEvent::ConnectionStateChange(_, _, _, _) => { - ModuleEvent::ConnectionsChangeNodeNetwork - } - NetworkEvent::ReceiveBlocks(_) => ModuleEvent::NewBlockFromNetwork, - NetworkEvent::ReceiveDocuments(network_docs) => { - if !network_docs.is_empty() { - match network_docs[0] { - BlockchainDocument::Block(_) => ModuleEvent::NewBlockFromNetwork, - BlockchainDocument::Transaction(_) => ModuleEvent::NewTxFromNetwork, - _ => ModuleEvent::NewWotDocFromNetwork, - } - } else { - return; - } - } - NetworkEvent::ReceiveHeads(_) => ModuleEvent::NewValidHeadFromNetwork, - NetworkEvent::ReceivePeers(_) => ModuleEvent::NewValidPeerFromNodeNetwork, - NetworkEvent::NewSelfPeer(_) => ModuleEvent::NewSelfPeer, - }; - self.router_sender - .send(RouterThreadMessage::ModuleMessage(DursMsg::Event { - event_type: module_event, - event_content: DursEvent::NetworkEvent(event.clone()), - })) - .expect("Fail to send network event to router !"); - } - fn count_established_connections(&self) -> usize { - let mut count_established_connections = 0; - for (_ws2p_full_id, (_ep, state)) in self.ws2p_endpoints.clone() { - if let WS2PConnectionState::Established = state { - count_established_connections += 1; - } - } - count_established_connections - } - pub fn connect_to_know_endpoints(&mut self) { - info!("WS2P: connect to know endpoints..."); - let mut count_established_connections = 0; - let mut pubkeys = HashSet::new(); - let mut reachable_endpoints = Vec::new(); - let mut unreachable_endpoints = Vec::new(); - for (_ws2p_full_id, (ep, state)) in self.ws2p_endpoints.clone() { - if ep.issuer == self.key_pair.unwrap().public_key() || !pubkeys.contains(&ep.issuer) { - match state { - WS2PConnectionState::Established => count_established_connections += 1, - WS2PConnectionState::NeverTry - | WS2PConnectionState::Close - | WS2PConnectionState::Denial => { - pubkeys.insert(ep.issuer); - reachable_endpoints.push(ep); - } - _ => { - pubkeys.insert(ep.issuer); - unreachable_endpoints.push(ep); - } - } - } - } - let mut free_outcoming_rooms = - self.conf.clone().outcoming_quota - count_established_connections; - while free_outcoming_rooms > 0 { - let ep = if !reachable_endpoints.is_empty() { - reachable_endpoints - .pop() - .expect("WS2P: Fail to pop() reachable_endpoints !") - } else if !unreachable_endpoints.is_empty() { - unreachable_endpoints - .pop() - .expect("WS2P: Fail to pop() unreachable_endpoints !") - } else { - break; - }; - if !self.ssl && ep.port == 443 { - continue; - } - self.connect_to_without_checking_quotas(&ep); - free_outcoming_rooms -= 1; - } - } - pub fn connect_to(&mut self, endpoint: &EndpointV1) { - // Add endpoint to endpoints list (if there isn't already) - match self.ws2p_endpoints.get( - &endpoint - .node_full_id() - .expect("WS2P: Fail to get ep.node_full_id() !"), - ) { - Some(_) => { - self.ws2p_endpoints - .get_mut( - &endpoint - .node_full_id() - .expect("WS2P: Fail to get ep.node_full_id() !"), - ) - .expect("WS2P: Fail to get_mut() a ws2p_endpoint !") - .1 = WS2PConnectionState::NeverTry; - } - None => { - self.ws2p_endpoints.insert( - endpoint - .node_full_id() - .expect("WS2P: Fail to get ep.node_full_id() !"), - (endpoint.clone(), WS2PConnectionState::NeverTry), - ); - } - }; - if self.conf.clone().outcoming_quota > self.count_established_connections() { - self.connect_to_without_checking_quotas(&endpoint); - } - } - pub fn close_connection( - &mut self, - ws2p_full_id: &NodeFullId, - reason: WS2PCloseConnectionReason, - ) { - match reason { - WS2PCloseConnectionReason::NegociationTimeout => {} - WS2PCloseConnectionReason::AuthMessInvalidSig - | WS2PCloseConnectionReason::Timeout - | WS2PCloseConnectionReason::WsError - | WS2PCloseConnectionReason::Unknow => { - self.ws2p_endpoints - .get_mut(ws2p_full_id) - .expect("Failure : attempt to delete a non-existent connection !") - .1 = WS2PConnectionState::Close - } - } - if let Some(websocket) = self.websockets.get(&ws2p_full_id) { - let _result = websocket.0.close(ws::CloseCode::Normal); - } - let _result = self.websockets.remove(ws2p_full_id); - } - pub fn ws2p_conn_message_pretreatment(&mut self, message: WS2PConnectionMessage) -> WS2PSignal { - let ws2p_full_id = message.0; - match message.1 { - WS2PConnectionMessagePayload::WrongUrl - | WS2PConnectionMessagePayload::FailOpenWS - | WS2PConnectionMessagePayload::FailToSplitWS => { - self.ws2p_endpoints - .get_mut(&ws2p_full_id) - .expect("WS2P: Fail to get mut ep !") - .1 = WS2PConnectionState::WSError; - return WS2PSignal::WSError(ws2p_full_id); - } - WS2PConnectionMessagePayload::TryToSendConnectMess => { - self.ws2p_endpoints - .get_mut(&ws2p_full_id) - .expect("WS2P: Fail to get mut ep !") - .1 = WS2PConnectionState::TryToSendConnectMess; - } - WS2PConnectionMessagePayload::FailSendConnectMess => { - self.ws2p_endpoints - .get_mut(&ws2p_full_id) - .expect("WS2P: Fail to mut ep !") - .1 = WS2PConnectionState::Unreachable; - } - WS2PConnectionMessagePayload::WebsocketOk(sender) => { - self.websockets.insert(ws2p_full_id, sender); - } - WS2PConnectionMessagePayload::ValidConnectMessage(response, new_con_state) => { - self.ws2p_endpoints - .get_mut(&ws2p_full_id) - .expect("WS2P: Fail to get mut ep !") - .1 = new_con_state; - self.ws2p_endpoints - .get_mut(&ws2p_full_id) - .expect("Endpoint don't exist !") - .1 = WS2PConnectionState::ConnectMessOk; - debug!("Send: {:#?}", response); - if let Some(websocket) = self.websockets.get_mut(&ws2p_full_id) { - if websocket.0.send(Message::text(response)).is_err() { - return WS2PSignal::WSError(ws2p_full_id); - } - } else { - // Connection closed by remote peer - self.ws2p_endpoints - .get_mut(&ws2p_full_id) - .expect("Endpoint don't exist !") - .1 = WS2PConnectionState::Close; - } - } - WS2PConnectionMessagePayload::ValidAckMessage(response, new_con_state) => { - self.ws2p_endpoints - .get_mut(&ws2p_full_id) - .expect("WS2P: Fail to get mut ep !") - .1 = new_con_state; - if let WS2PConnectionState::AckMessOk = self.ws2p_endpoints[&ws2p_full_id].1 { - debug!("Send: {:#?}", response); - if let Some(websocket) = self.websockets.get_mut(&ws2p_full_id) { - if websocket.0.send(Message::text(response)).is_err() { - return WS2PSignal::WSError(ws2p_full_id); - } - } else { - panic!("Fatal error : no websocket for {} !", ws2p_full_id); - } - } - } - WS2PConnectionMessagePayload::ValidOk(new_con_state) => { - self.ws2p_endpoints - .get_mut(&ws2p_full_id) - .expect("WS2P: Fail to get mut ep !") - .1 = new_con_state; - match self.ws2p_endpoints[&ws2p_full_id].1 { - WS2PConnectionState::OkMessOkWaitingAckMess => {} - WS2PConnectionState::Established => { - return WS2PSignal::ConnectionEstablished(ws2p_full_id); - } - _ => { - self.close_connection(&ws2p_full_id, WS2PCloseConnectionReason::Unknow); - return WS2PSignal::Empty; - } - } - } - WS2PConnectionMessagePayload::DalRequest(req_id, req_body) => { - return WS2PSignal::DalRequest(ws2p_full_id, req_id, req_body); - } - WS2PConnectionMessagePayload::PeerCard(body, ws2p_endpoints) => { - return WS2PSignal::PeerCard(ws2p_full_id, body, ws2p_endpoints); - } - WS2PConnectionMessagePayload::Heads(heads) => { - let mut applied_heads = Vec::with_capacity(heads.len()); - for head in heads { - if let Ok(head) = NetworkHead::from_json_value(&head) { - if head.verify() - && (self.my_head.is_none() - || head.node_full_id() - != self - .my_head - .clone() - .expect("WS2P: Fail to clone my_head") - .node_full_id()) - && head.apply(&mut self.heads_cache) - { - applied_heads.push(head); - } - } - } - return WS2PSignal::Heads(ws2p_full_id, applied_heads); - } - WS2PConnectionMessagePayload::Document(network_doc) => { - return WS2PSignal::Document(ws2p_full_id, network_doc); - } - WS2PConnectionMessagePayload::ReqResponse(req_id, response) => { - if self.requests_awaiting_response.len() > req_id.0 as usize { - if let Some((ref ws2p_request, ref recipient_fulld_id, ref _timestamp)) = - self.requests_awaiting_response.remove(&req_id) - { - return WS2PSignal::ReqResponse( - req_id, - *ws2p_request, - *recipient_fulld_id, - response, - ); - } - } - } - WS2PConnectionMessagePayload::NegociationTimeout => { - match self.ws2p_endpoints[&ws2p_full_id].1 { - WS2PConnectionState::AckMessOk | WS2PConnectionState::ConnectMessOk => { - self.ws2p_endpoints - .get_mut(&ws2p_full_id) - .expect("WS2P: Fail to get mut ep !") - .1 = WS2PConnectionState::Denial - } - WS2PConnectionState::WaitingConnectMess => { - self.ws2p_endpoints - .get_mut(&ws2p_full_id) - .expect("WS2P: Fail to get mut ep !") - .1 = WS2PConnectionState::NoResponse - } - _ => { - self.ws2p_endpoints - .get_mut(&ws2p_full_id) - .expect("WS2P: Fail to get mut ep !") - .1 = WS2PConnectionState::Unreachable - } - } - self.close_connection(&ws2p_full_id, WS2PCloseConnectionReason::NegociationTimeout); - return WS2PSignal::NegociationTimeout(ws2p_full_id); - } - WS2PConnectionMessagePayload::Timeout => { - self.close_connection(&ws2p_full_id, WS2PCloseConnectionReason::Timeout); - return WS2PSignal::Timeout(ws2p_full_id); - } - WS2PConnectionMessagePayload::UnknowMessage => { - warn!("WS2P : Receive Unknow Message from {}.", &ws2p_full_id.1) - } - WS2PConnectionMessagePayload::WrongFormatMessage => warn!( - "WS2P : Receive Wrong Format Message from {}.", - &ws2p_full_id.1 - ), - WS2PConnectionMessagePayload::InvalidMessage => return WS2PSignal::Empty, - WS2PConnectionMessagePayload::Close => { - if self.websockets.contains_key(&ws2p_full_id) { - self.close_connection( - &ws2p_full_id, - WS2PCloseConnectionReason::AuthMessInvalidSig, - ) - } - } - } - let connections_count = self.websockets.len(); - if connections_count == 0 { - return WS2PSignal::NoConnection; - } - // Detect timeout requests - let mut requests_timeout = Vec::new(); - for &(ref req, ref ws2p_full_id, ref timestamp) in - self.requests_awaiting_response.clone().values() - { - if SystemTime::now().duration_since(*timestamp).unwrap() > Duration::new(20, 0) { - requests_timeout.push(req.get_req_full_id()); - warn!("request timeout : {:?} (sent to {:?})", req, ws2p_full_id); - } - } - // Delete (and resend) timeout requests - for req_id in requests_timeout { - //let ws2p_endpoints = self.ws2p_endpoints.clone(); - let _request_option = self.requests_awaiting_response.remove(&req_id.1); - /*if let Some((request, _, _)) = request_option { - let _request_result = self.send_request_to_specific_node( - &get_random_connection(&ws2p_endpoints), - &request, - ); - }*/ - } - WS2PSignal::Empty - } - - pub fn send_request_to_specific_node( - &mut self, - receiver_ws2p_full_id: &NodeFullId, - ws2p_request: &OldNetworkRequest, - ) -> ws::Result<()> { - self.websockets - .get_mut(receiver_ws2p_full_id) - .expect("WS2P: Fail to get mut websocket !") - .0 - .send(Message::text( - network_request_to_json(ws2p_request).to_string(), - ))?; - self.requests_awaiting_response.insert( - ws2p_request.get_req_id(), - (*ws2p_request, *receiver_ws2p_full_id, SystemTime::now()), - ); - debug!( - "send request {} to {}", - network_request_to_json(ws2p_request).to_string(), - receiver_ws2p_full_id - ); - Ok(()) - } - - fn connect_to_without_checking_quotas(&mut self, endpoint: &EndpointV1) { - let endpoint_copy = endpoint.clone(); - let conductor_sender_copy = self.main_thread_channel.0.clone(); - let currency_copy = self.currency.clone(); - let key_pair_copy = self.key_pair; - thread::spawn(move || { - let _result = connect_to_ws2p_endpoint( - &endpoint_copy, - &conductor_sender_copy, - ¤cy_copy.expect("WS2PError : No currency !"), - key_pair_copy.expect("WS2PError : No key_pair !"), - ); - }); - } -} diff --git a/lib/modules/ws2p-v1-legacy/src/events/mod.rs b/lib/modules/ws2p-v1-legacy/src/events/mod.rs new file mode 100644 index 00000000..0e373125 --- /dev/null +++ b/lib/modules/ws2p-v1-legacy/src/events/mod.rs @@ -0,0 +1,19 @@ +// Copyright (C) 2018 The Durs Project Developers. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +//! Sub-module managing the events received and sent. + +pub mod received; +pub mod sent; diff --git a/lib/modules/ws2p-v1-legacy/src/events/received.rs b/lib/modules/ws2p-v1-legacy/src/events/received.rs new file mode 100644 index 00000000..a8bb4f27 --- /dev/null +++ b/lib/modules/ws2p-v1-legacy/src/events/received.rs @@ -0,0 +1,72 @@ +// Copyright (C) 2018 The Durs Project Developers. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +//! Sub-module managing events received from other durs modules + +use crate::*; +use dubp_documents::Document; +use duniter_module::*; +use durs_message::events::DursEvent; +use std::ops::Deref; + +pub fn receive_event( + ws2p_module: &mut WS2PModule, + _event_type: ModuleEvent, + event_content: &DursEvent, +) { + if let DursEvent::BlockchainEvent(ref bc_event) = *event_content { + match *bc_event.deref() { + BlockchainEvent::StackUpValidBlock(ref block) => { + ws2p_module.current_blockstamp = block.deref().blockstamp(); + debug!( + "WS2PModule : current_blockstamp = {}", + ws2p_module.current_blockstamp + ); + ws2p_module.my_head = Some(heads::generate_my_head( + &ws2p_module.key_pair, + ws2p_module.node_id, + ws2p_module.soft_name, + ws2p_module.soft_version, + &ws2p_module.current_blockstamp, + None, + )); + super::sent::send_network_event( + ws2p_module, + NetworkEvent::ReceiveHeads(vec![unwrap!(ws2p_module.my_head.clone())]), + ); + // Send my head to all connections + let my_json_head = serializer::serialize_head(unwrap!(ws2p_module.my_head.clone())); + trace!("Send my HEAD: {:#?}", my_json_head); + let _results: Result<(), ws::Error> = ws2p_module + .websockets + .iter_mut() + .map(|ws| { + (ws.1).0.send(Message::text( + json!({ + "name": "HEAD", + "body": { + "heads": [my_json_head] + } + }) + .to_string(), + )) + }) + .collect(); + } + BlockchainEvent::RevertBlocks(ref _blocks) => {} + _ => {} + } + } +} diff --git a/lib/modules/ws2p-v1-legacy/src/events/sent.rs b/lib/modules/ws2p-v1-legacy/src/events/sent.rs new file mode 100644 index 00000000..bb5a49b6 --- /dev/null +++ b/lib/modules/ws2p-v1-legacy/src/events/sent.rs @@ -0,0 +1,59 @@ +// Copyright (C) 2018 The Durs Project Developers. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +//! Sub-module managing the events emitted by the blockchain module. + +use crate::WS2PModule; +use duniter_module::{ModuleEvent, RouterThreadMessage}; +use duniter_network::documents::BlockchainDocument; +use duniter_network::events::NetworkEvent; +use durs_message::events::DursEvent; +use durs_message::*; + +pub fn send_network_events(ws2p_module: &mut WS2PModule, events: Vec) { + for event in events { + send_network_event(ws2p_module, event); + } +} + +pub fn send_network_event(ws2p_module: &mut WS2PModule, event: NetworkEvent) { + let module_event = match event { + NetworkEvent::ConnectionStateChange(_, _, _, _) => { + ModuleEvent::ConnectionsChangeNodeNetwork + } + NetworkEvent::ReceiveBlocks(_) => ModuleEvent::NewBlockFromNetwork, + NetworkEvent::ReceiveDocuments(ref network_docs) => { + if !network_docs.is_empty() { + match network_docs[0] { + BlockchainDocument::Block(_) => ModuleEvent::NewBlockFromNetwork, + BlockchainDocument::Transaction(_) => ModuleEvent::NewTxFromNetwork, + _ => ModuleEvent::NewWotDocFromNetwork, + } + } else { + return; + } + } + NetworkEvent::ReceiveHeads(_) => ModuleEvent::NewValidHeadFromNetwork, + NetworkEvent::ReceivePeers(_) => ModuleEvent::NewValidPeerFromNodeNetwork, + NetworkEvent::NewSelfPeer(_) => ModuleEvent::NewSelfPeer, + }; + ws2p_module + .router_sender + .send(RouterThreadMessage::ModuleMessage(DursMsg::Event { + event_type: module_event, + event_content: DursEvent::NetworkEvent(event), + })) + .expect("Fail to send network event to router !"); +} diff --git a/lib/modules/ws2p-v1-legacy/src/lib.rs b/lib/modules/ws2p-v1-legacy/src/lib.rs index a3e7663e..c19854b3 100644 --- a/lib/modules/ws2p-v1-legacy/src/lib.rs +++ b/lib/modules/ws2p-v1-legacy/src/lib.rs @@ -1,4 +1,4 @@ -// Copyright (C) 2018 The Duniter Project Developers. +// Copyright (C) 2018 The Durs Project Developers. // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU Affero General Public License as @@ -13,7 +13,7 @@ // You should have received a copy of the GNU Affero General Public License // along with this program. If not, see . -//! WebSocketToPeer API for the Duniter project. +//! WebSocketToPeer API for the Durs project. #![deny( missing_debug_implementations, @@ -29,8 +29,6 @@ #[macro_use] extern crate log; #[macro_use] -extern crate serde_derive; -#[macro_use] extern crate serde_json; #[macro_use] extern crate structopt; @@ -38,24 +36,27 @@ extern crate structopt; mod ack_message; mod connect_message; pub mod constants; -mod datas; +mod events; mod heads; mod ok_message; pub mod parsers; +mod requests; +mod responses; pub mod serializer; -pub mod ws2p_connection; pub mod ws2p_db; -pub mod ws2p_requests; +pub mod ws_connections; use crate::ack_message::WS2PAckMessageV1; use crate::connect_message::WS2PConnectMessageV1; use crate::constants::*; -use crate::datas::*; use crate::ok_message::WS2POkMessageV1; use crate::parsers::blocks::parse_json_block; -use crate::ws2p_connection::*; -use crate::ws2p_requests::network_request_to_json; -use dubp_documents::{Blockstamp, Document}; +use crate::requests::sent::send_dal_request; +use crate::ws2p_db::DbEndpoint; +use crate::ws_connections::messages::WS2PConnectionMessage; +use crate::ws_connections::states::WS2PConnectionState; +use crate::ws_connections::*; +use dubp_documents::Blockstamp; use duniter_conf::DuRsConf; use duniter_module::*; use duniter_network::cli::sync::SyncOpt; @@ -64,6 +65,7 @@ use duniter_network::events::*; use duniter_network::requests::*; use duniter_network::*; use dup_crypto::keys::*; +use durs_common_tools::fatal_error; use durs_message::events::*; use durs_message::requests::*; use durs_message::responses::*; @@ -71,14 +73,28 @@ use durs_message::*; use durs_network_documents::network_endpoint::*; use durs_network_documents::network_head::*; use durs_network_documents::*; +use serde::{Deserialize, Serialize}; use std::collections::HashMap; +use std::fs; use std::ops::Deref; use std::path::PathBuf; use std::sync::mpsc; use std::thread; use std::time::{Duration, SystemTime, UNIX_EPOCH}; +use unwrap::unwrap; use ws::Message; +#[inline] +#[cfg(not(feature = "ssl"))] +pub fn ssl() -> bool { + false +} +#[inline] +#[cfg(feature = "ssl")] +pub fn ssl() -> bool { + true +} + #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)] /// WS2P Configuration pub struct WS2PConf { @@ -93,54 +109,38 @@ impl Default for WS2PConf { WS2PConf { outcoming_quota: *WS2P_DEFAULT_OUTCOMING_QUOTA, sync_endpoints: vec![ - EndpointV1::parse_from_raw( + unwrap!(EndpointV1::parse_from_raw( "WS2P c1c39a0a ts.g1.librelois.fr 443 /ws2p", - PubKey::Ed25519( - ed25519::PublicKey::from_base58( - "D9D2zaJoWYWveii1JRYLVK3J4Z7ZH3QczoKrnQeiM6mx", - ) - .unwrap(), - ), + PubKey::Ed25519(unwrap!(ed25519::PublicKey::from_base58( + "D9D2zaJoWYWveii1JRYLVK3J4Z7ZH3QczoKrnQeiM6mx", + )),), 0, 0, - ) - .unwrap(), - EndpointV1::parse_from_raw( + )), + unwrap!(EndpointV1::parse_from_raw( "WS2P fb17fcd4 g1.duniter.fr 443 /ws2p", - PubKey::Ed25519( - ed25519::PublicKey::from_base58( - "38MEAZN68Pz1DTvT3tqgxx4yQP6snJCQhPqEFxbDk4aE", - ) - .unwrap(), - ), + PubKey::Ed25519(unwrap!(ed25519::PublicKey::from_base58( + "38MEAZN68Pz1DTvT3tqgxx4yQP6snJCQhPqEFxbDk4aE", + ))), 0, 0, - ) - .unwrap(), - EndpointV1::parse_from_raw( + )), + unwrap!(EndpointV1::parse_from_raw( "WS2P 7b33becd g1.nordstrom.duniter.org 443 /ws2p", - PubKey::Ed25519( - ed25519::PublicKey::from_base58( - "DWoSCRLQyQ48dLxUGr1MDKg4NFcbPbC56LN2hJjCCPpZ", - ) - .unwrap(), - ), + PubKey::Ed25519(unwrap!(ed25519::PublicKey::from_base58( + "DWoSCRLQyQ48dLxUGr1MDKg4NFcbPbC56LN2hJjCCPpZ", + ))), 0, 0, - ) - .unwrap(), - EndpointV1::parse_from_raw( + )), + unwrap!(EndpointV1::parse_from_raw( "WS2P dff60418 duniter.normandie-libre.fr 443 /ws2p", - PubKey::Ed25519( - ed25519::PublicKey::from_base58( - "8t6Di3pLxxoTEfjXHjF49pNpjSTXuGEQ6BpkT75CkNb2", - ) - .unwrap(), - ), + PubKey::Ed25519(unwrap!(ed25519::PublicKey::from_base58( + "8t6Di3pLxxoTEfjXHjF49pNpjSTXuGEQ6BpkT75CkNb2", + ))), 0, 0, - ) - .unwrap(), + )), ], } } @@ -181,8 +181,64 @@ pub enum SendRequestError { WSError(usize, Vec), } -#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] -pub struct WS2PModule {} +#[derive(Debug)] +pub struct WS2PModule { + pub conf: WS2PConf, + pub count_dal_requests: u32, + pub currency: Option, + pub current_blockstamp: Blockstamp, + pub ep_file_path: PathBuf, + pub heads_cache: HashMap, + pub key_pair: KeyPairEnum, + pub main_thread_channel: ( + mpsc::Sender, + mpsc::Receiver, + ), + pub my_head: Option, + pub next_receiver: usize, + pub node_id: NodeId, + pub requests_awaiting_response: + HashMap, + pub router_sender: mpsc::Sender>, + pub soft_name: &'static str, + pub soft_version: &'static str, + pub ssl: bool, + pub websockets: HashMap, + pub ws2p_endpoints: HashMap, + pub uids_cache: HashMap, +} + +impl WS2PModule { + pub fn new( + soft_meta_datas: &SoftwareMetaDatas, + conf: WS2PConf, + ep_file_path: PathBuf, + key_pair: KeyPairEnum, + router_sender: mpsc::Sender>, + ) -> WS2PModule { + WS2PModule { + router_sender, + key_pair, + currency: None, + current_blockstamp: Blockstamp::default(), + conf, + ep_file_path, + soft_name: soft_meta_datas.soft_name, + soft_version: soft_meta_datas.soft_version, + ssl: ssl(), + node_id: NodeId(soft_meta_datas.conf.my_node_id()), + main_thread_channel: mpsc::channel(), + next_receiver: 0, + ws2p_endpoints: HashMap::new(), + websockets: HashMap::new(), + requests_awaiting_response: HashMap::new(), + heads_cache: HashMap::new(), + my_head: None, + uids_cache: HashMap::new(), + count_dal_requests: 0, + } + } +} #[derive(Debug)] pub enum WS2PThreadSignal { @@ -190,8 +246,18 @@ pub enum WS2PThreadSignal { WS2PConnectionMessage(WS2PConnectionMessage), } +#[derive(Copy, Clone, Debug)] +/// Error when parsing WS2P message +pub struct WS2PMsgParseErr {} + +impl From for WS2PMsgParseErr { + fn from(_: dup_crypto::bases::BaseConvertionError) -> Self { + WS2PMsgParseErr {} + } +} + pub trait WS2PMessage: Sized { - fn parse(v: &serde_json::Value, currency: String) -> Option; + fn parse(v: &serde_json::Value, currency: String) -> Result; fn to_raw(&self) -> String; fn sign(&self, key_pair: KeyPairEnum) -> Sig { key_pair.sign(self.to_raw().as_bytes()) @@ -200,12 +266,6 @@ pub trait WS2PMessage: Sized { //fn parse_and_verify(v: serde_json::Value, currency: String) -> bool; } -impl Default for WS2PModule { - fn default() -> WS2PModule { - WS2PModule {} - } -} - #[derive(Debug)] /// WS2PFeaturesParseError pub enum WS2PFeaturesParseError { @@ -291,34 +351,76 @@ impl DursModule for WS2PModule { // Get start time let start_time = SystemTime::now(); - // Define WS2PModuleDatas - let mut ws2p_module = WS2PModuleDatas::new( - router_sender.clone(), - conf, - NodeId(soft_meta_datas.conf.my_node_id()), - ); + // Get key_pair + let key_pair = if let RequiredKeysContent::NetworkKeyPair(key_pair) = keys { + key_pair + } else { + return Err(ModuleInitError::FailToLoadConf( + "WS2PModule fatal error at load_conf() : keys != NetworkKeyPair", + )); + }; // load conf - let key_pair = match keys { - RequiredKeysContent::NetworkKeyPair(key_pair) => key_pair, - _ => panic!("WS2PModule fatal error at load_conf() : keys != NetworkKeyPair"), - }; let mut ws2p_endpoints = HashMap::new(); - for ep in &ws2p_module.conf.sync_endpoints { + for ep in &conf.sync_endpoints { + info!("Load sync endpoint {}", ep.raw_endpoint); + let node_full_id = ep + .node_full_id() + .expect("Fail to get endpoint node_full_id"); ws2p_endpoints.insert( - ep.node_full_id() - .expect("Fail to get endpoint node_full_id"), - (ep.clone(), WS2PConnectionState::Close), + node_full_id, + DbEndpoint { + ep: ep.clone(), + state: WS2PConnectionState::Close, + last_check: 0, + }, ); - info!("Load sync endpoint {}", ep.raw_endpoint); } - ws2p_module.key_pair = Some(key_pair); + + // Get endpoints file path + let mut ep_file_path = + duniter_conf::datas_path(&soft_meta_datas.profile, &soft_meta_datas.conf.currency()); + ep_file_path.push("ws2pv1"); + if !ep_file_path.exists() { + fs::create_dir(ep_file_path.as_path()).expect("Impossible to create ws2pv1 dir !"); + } + ep_file_path.push("endpoints.bin"); + + // Define WS2PModule + let mut ws2p_module = WS2PModule::new( + soft_meta_datas, + conf, + ep_file_path.clone(), + key_pair, + router_sender.clone(), + ); ws2p_module.currency = Some(soft_meta_datas.conf.currency().to_string()); ws2p_module.ws2p_endpoints = ws2p_endpoints; // Create ws2p main thread channel let ws2p_sender_clone = ws2p_module.main_thread_channel.0.clone(); + // Get ws2p endpoints in file + info!("TMP: WS2P SSL={}", ssl()); + let count; + match ws2p_db::get_endpoints(&ep_file_path) { + Ok(ws2p_enpoints) => { + let ws2p_enpoints = ws2p_enpoints + .into_iter() + .filter(|(_, dal_ep)| cfg!(feature = "ssl") || dal_ep.ep.port != 443) + .collect::>(); + count = ws2p_enpoints.len(); + ws2p_module.ws2p_endpoints.extend(ws2p_enpoints); + } + Err(err) => fatal_error!("WS2Pv1: fail to load endpoints from DB: {:?}", err), + } + info!("Load {} endpoints from DB !", count); + + // Stop here in load_conf_only mode + if load_conf_only { + return Ok(()); + } + // Create proxy channel let (proxy_sender, proxy_receiver): (mpsc::Sender, mpsc::Receiver) = mpsc::channel(); @@ -364,50 +466,29 @@ impl DursModule for WS2PModule { } }); - // open ws2p bdd - let mut db_path = - duniter_conf::datas_path(&soft_meta_datas.profile, &soft_meta_datas.conf.currency()); - db_path.push("ws2p.db"); - let db = WS2PModuleDatas::open_db(&db_path).expect("Fatal error : fail to open WS2P DB !"); + // Request current blockstamp + send_dal_request(&mut ws2p_module, &BlockchainRequest::CurrentBlockstamp()); - // Get ws2p endpoints in BDD - let mut count = 0; - let dal_enpoints = - ws2p_db::get_endpoints_for_api(&db, &NetworkEndpointApi(String::from("WS2P"))); - for ep in dal_enpoints { - if ep.api == NetworkEndpointApi(String::from("WS2P")) - && (cfg!(feature = "ssl") || ep.port != 443) - { - count += 1; - ws2p_module.ws2p_endpoints.insert( - ep.node_full_id() - .expect("WS2P: Fail to get ep.node_full_id() !"), - (ep.clone(), WS2PConnectionState::from(ep.status)), - ); - } - } - info!("Load {} endpoints from bdd !", count); + // Start + connect_to_know_endpoints(&mut ws2p_module); + ws2p_module.main_loop(start_time, soft_meta_datas); - // Stop here in load_conf_only mode - if load_conf_only { - return Ok(()); - } + Ok(()) + } +} +impl WS2PModule { + fn main_loop(mut self, start_time: SystemTime, soft_meta_datas: &SoftwareMetaDatas) { // Initialize variables + let key_pair = self.key_pair; let mut last_ws2p_connecting_wave = SystemTime::now(); - let mut last_ws2p_connections_print = SystemTime::now(); + let mut last_ws2p_state_print = SystemTime::now(); + let mut last_ws2p_endpoints_write = SystemTime::now(); let mut endpoints_to_update_status: HashMap = HashMap::new(); let mut last_identities_request = UNIX_EPOCH; - let mut current_blockstamp = Blockstamp::default(); - let mut next_receiver = 0; - // Request current blockstamp - ws2p_module.send_dal_request(&BlockchainRequest::CurrentBlockstamp()); - - // Start - ws2p_module.connect_to_know_endpoints(); loop { - match ws2p_module + match self .main_thread_channel .1 .recv_timeout(Duration::from_millis(200)) @@ -418,112 +499,16 @@ impl DursModule for WS2PModule { DursMsg::Stop => break, DursMsg::Request { ref req_content, .. - } => { - if let DursReqContent::OldNetworkRequest(ref old_net_request) = - *req_content - { - match *old_net_request { - OldNetworkRequest::GetBlocks( - ref req_id, - ref count, - ref from, - ) => { - let mut receiver_index = 0; - let mut real_receiver = None; - for (ws2p_full_id, (_ep, state)) in - ws2p_module.ws2p_endpoints.clone() - { - if let WS2PConnectionState::Established = state { - if receiver_index == next_receiver { - real_receiver = Some(ws2p_full_id); - break; - } - receiver_index += 1; - } - } - if real_receiver.is_none() { - next_receiver = 0; - for (ws2p_full_id, (_ep, state)) in - &ws2p_module.ws2p_endpoints - { - if let WS2PConnectionState::Established = *state - { - real_receiver = Some(*ws2p_full_id); - break; - } - } - } else { - next_receiver += 1; - } - if let Some(real_receiver) = real_receiver { - debug!("WS2P: send req to: ({:?})", real_receiver); - let _blocks_request_result = ws2p_module - .send_request_to_specific_node( - &real_receiver, - &OldNetworkRequest::GetBlocks( - *req_id, *count, *from, - ), - ); - } else { - warn!("WS2P: not found peer to send request !"); - } - } - OldNetworkRequest::GetEndpoints(ref _request) => {} - _ => {} - } - } - } + } => requests::received::receive_req(&mut self, req_content), DursMsg::Event { - ref event_content, .. - } => { - if let DursEvent::BlockchainEvent(ref bc_event) = *event_content { - match *bc_event.deref() { - BlockchainEvent::StackUpValidBlock(ref block) => { - current_blockstamp = block.deref().blockstamp(); - debug!( - "WS2PModule : current_blockstamp = {}", - current_blockstamp - ); - ws2p_module.my_head = Some(heads::generate_my_head( - &key_pair, - NodeId(soft_meta_datas.conf.my_node_id()), - soft_meta_datas.soft_name, - soft_meta_datas.soft_version, - ¤t_blockstamp, - None, - )); - ws2p_module.send_network_event( - &NetworkEvent::ReceiveHeads(vec![ws2p_module - .my_head - .clone() - .unwrap()]), - ); - // Send my head to all connections - let my_json_head = serializer::serialize_head( - ws2p_module.my_head.clone().unwrap(), - ); - trace!("Send my HEAD: {:#?}", my_json_head); - let _results: Result<(), ws::Error> = ws2p_module - .websockets - .iter_mut() - .map(|ws| { - (ws.1).0.send(Message::text( - json!({ - "name": "HEAD", - "body": { - "heads": [my_json_head] - } - }) - .to_string(), - )) - }) - .collect(); - } - BlockchainEvent::RevertBlocks(ref _blocks) => {} - _ => {} - } - } - } + ref event_type, + ref event_content, + .. + } => events::received::receive_event( + &mut self, + *event_type, + event_content, + ), DursMsg::Response { ref res_content, .. } => { @@ -536,70 +521,61 @@ impl DursModule for WS2PModule { ) => { debug!( "WS2PModule : receive DALResBc::CurrentBlockstamp({})", - current_blockstamp + self.current_blockstamp ); - current_blockstamp = *current_blockstamp_; - if ws2p_module.my_head.is_none() { - ws2p_module.my_head = - Some(heads::generate_my_head( - &key_pair, - NodeId(soft_meta_datas.conf.my_node_id()), - soft_meta_datas.soft_name, - soft_meta_datas.soft_version, - ¤t_blockstamp, - None, - )); + self.current_blockstamp = *current_blockstamp_; + if self.my_head.is_none() { + self.my_head = Some(heads::generate_my_head( + &key_pair, + NodeId(soft_meta_datas.conf.my_node_id()), + soft_meta_datas.soft_name, + soft_meta_datas.soft_version, + &self.current_blockstamp, + None, + )); } - ws2p_module.send_network_event( - &NetworkEvent::ReceiveHeads(vec![ws2p_module + let event = + NetworkEvent::ReceiveHeads(vec![unwrap!(self .my_head - .clone() - .unwrap()]), - ); + .clone())]); + events::sent::send_network_event(&mut self, event); } BlockchainResponse::UIDs(ref _req_id, ref uids) => { // Add uids to heads - for head in ws2p_module.heads_cache.values_mut() { + for head in self.heads_cache.values_mut() { if let Some(uid_option) = uids.get(&head.pubkey()) { if let Some(ref uid) = *uid_option { head.set_uid(uid); - ws2p_module - .uids_cache + self.uids_cache .insert(head.pubkey(), uid.to_string()); } else { - ws2p_module - .uids_cache - .remove(&head.pubkey()); + self.uids_cache.remove(&head.pubkey()); } } } // Resent heads to other modules - ws2p_module.send_network_event( - &NetworkEvent::ReceiveHeads( - ws2p_module - .heads_cache - .values() - .cloned() - .collect(), - ), + let event = NetworkEvent::ReceiveHeads( + self.heads_cache.values().cloned().collect(), ); + events::sent::send_network_event(&mut self, event); // Resent to other modules connections that match receive uids - for (node_full_id, (ep, conn_state)) in - &ws2p_module.ws2p_endpoints - { - if let Some(uid_option) = uids.get(&node_full_id.1) - { - ws2p_module.send_network_event( - &NetworkEvent::ConnectionStateChange( + let events = self.ws2p_endpoints + .iter() + .filter_map(|(node_full_id, DbEndpoint { ep, state, .. })| { + if let Some(uid_option) = uids.get(&node_full_id.1) { + Some(NetworkEvent::ConnectionStateChange( *node_full_id, - *conn_state as u32, + *state as u32, uid_option.clone(), ep.get_url(false, false) .expect("Endpoint unreachable !"), - ), - ); - } - } + )) + } else { + None + } + }) + .collect(); + events::sent::send_network_events(&mut self, events); } _ => {} // Others BlockchainResponse variants } @@ -608,187 +584,208 @@ impl DursModule for WS2PModule { _ => {} // Others DursMsg variants } } - WS2PThreadSignal::WS2PConnectionMessage(ws2p_conn_message) => match ws2p_module - .ws2p_conn_message_pretreatment(ws2p_conn_message) - { - WS2PSignal::NoConnection => { - warn!("WS2PSignal::NoConnection"); - } - WS2PSignal::ConnectionEstablished(ws2p_full_id) => { - let req_id = - ModuleReqId(ws2p_module.requests_awaiting_response.len() as u32); - let module_id = WS2PModule::name(); - debug!("WS2P: send req to: ({:?})", ws2p_full_id); - let _current_request_result = ws2p_module - .send_request_to_specific_node( + WS2PThreadSignal::WS2PConnectionMessage(ws2p_conn_message) => { + match crate::ws_connections::messages::ws2p_conn_message_pretreatment( + &mut self, + ws2p_conn_message, + ) { + WS2PSignal::NoConnection => { + warn!("WS2PSignal::NoConnection"); + } + WS2PSignal::ConnectionEstablished(ws2p_full_id) => { + let req_id = + ModuleReqId(self.requests_awaiting_response.len() as u32); + let module_id = WS2PModule::name(); + debug!("WS2P: send req to: ({:?})", ws2p_full_id); + let _current_request_result = + ws_connections::requests::sent::send_request_to_specific_node( + &mut self, + &ws2p_full_id, + &OldNetworkRequest::GetCurrent(ModuleReqFullId( + module_id, req_id, + )), + ); + if self.uids_cache.get(&ws2p_full_id.1).is_none() { + send_dal_request( + &mut self, + &BlockchainRequest::UIDs(vec![ws2p_full_id.1]), + ); + } + let event = NetworkEvent::ConnectionStateChange( + ws2p_full_id, + WS2PConnectionState::Established as u32, + self.uids_cache.get(&ws2p_full_id.1).cloned(), + self.ws2p_endpoints[&ws2p_full_id] + .ep + .get_url(false, false) + .expect("Endpoint unreachable !"), + ); + events::sent::send_network_event(&mut self, event); + } + WS2PSignal::WSError(ws2p_full_id) => { + endpoints_to_update_status.insert(ws2p_full_id, SystemTime::now()); + close_connection( + &mut self, &ws2p_full_id, - &OldNetworkRequest::GetCurrent(ModuleReqFullId( - module_id, req_id, - )), + WS2PCloseConnectionReason::WsError, ); - if ws2p_module.uids_cache.get(&ws2p_full_id.1).is_none() { - ws2p_module.send_dal_request(&BlockchainRequest::UIDs(vec![ - ws2p_full_id.1, - ])); + let event = NetworkEvent::ConnectionStateChange( + ws2p_full_id, + WS2PConnectionState::WSError as u32, + self.uids_cache.get(&ws2p_full_id.1).cloned(), + self.ws2p_endpoints[&ws2p_full_id] + .ep + .get_url(false, false) + .expect("Endpoint unreachable !"), + ); + events::sent::send_network_event(&mut self, event); } - ws2p_module.send_network_event(&NetworkEvent::ConnectionStateChange( - ws2p_full_id, - WS2PConnectionState::Established as u32, - ws2p_module.uids_cache.get(&ws2p_full_id.1).cloned(), - ws2p_module.ws2p_endpoints[&ws2p_full_id] - .0 - .get_url(false, false) - .expect("Endpoint unreachable !"), - )); - } - WS2PSignal::WSError(ws2p_full_id) => { - endpoints_to_update_status.insert(ws2p_full_id, SystemTime::now()); - ws2p_module.close_connection( - &ws2p_full_id, - WS2PCloseConnectionReason::WsError, - ); - ws2p_module.send_network_event(&NetworkEvent::ConnectionStateChange( - ws2p_full_id, - WS2PConnectionState::WSError as u32, - ws2p_module.uids_cache.get(&ws2p_full_id.1).cloned(), - ws2p_module.ws2p_endpoints[&ws2p_full_id] - .0 - .get_url(false, false) - .expect("Endpoint unreachable !"), - )); - } - WS2PSignal::NegociationTimeout(ws2p_full_id) => { - endpoints_to_update_status.insert(ws2p_full_id, SystemTime::now()); - ws2p_module.send_network_event(&NetworkEvent::ConnectionStateChange( - ws2p_full_id, - WS2PConnectionState::Denial as u32, - ws2p_module.uids_cache.get(&ws2p_full_id.1).cloned(), - ws2p_module.ws2p_endpoints[&ws2p_full_id] - .0 - .get_url(false, false) - .expect("Endpoint unreachable !"), - )); - } - WS2PSignal::Timeout(ws2p_full_id) => { - endpoints_to_update_status.insert(ws2p_full_id, SystemTime::now()); - ws2p_module.send_network_event(&NetworkEvent::ConnectionStateChange( - ws2p_full_id, - WS2PConnectionState::Close as u32, - ws2p_module.uids_cache.get(&ws2p_full_id.1).cloned(), - ws2p_module.ws2p_endpoints[&ws2p_full_id] - .0 - .get_url(false, false) - .expect("Endpoint unreachable !"), - )); - } - WS2PSignal::PeerCard(_ws2p_full_id, _peer_card, ws2p_endpoints) => { - //trace!("WS2PSignal::PeerCard({})", ws2p_full_id); - //ws2p_module.send_network_event(NetworkEvent::ReceivePeers(_)); - for ep in ws2p_endpoints { - match ws2p_module.ws2p_endpoints.get( - &ep.node_full_id() - .expect("WS2P: Fail to get ep.node_full_id() !"), - ) { - Some(_) => {} - None => { - if let Some(_api) = - ws2p_db::string_to_api(&ep.api.0.clone()) - { - endpoints_to_update_status.insert( - ep.node_full_id().expect( - "WS2P: Fail to get ep.node_full_id() !", + WS2PSignal::NegociationTimeout(ws2p_full_id) => { + endpoints_to_update_status.insert(ws2p_full_id, SystemTime::now()); + let event = NetworkEvent::ConnectionStateChange( + ws2p_full_id, + WS2PConnectionState::Denial as u32, + self.uids_cache.get(&ws2p_full_id.1).cloned(), + self.ws2p_endpoints[&ws2p_full_id] + .ep + .get_url(false, false) + .expect("Endpoint unreachable !"), + ); + events::sent::send_network_event(&mut self, event); + } + WS2PSignal::Timeout(ws2p_full_id) => { + endpoints_to_update_status.insert(ws2p_full_id, SystemTime::now()); + let event = NetworkEvent::ConnectionStateChange( + ws2p_full_id, + WS2PConnectionState::Close as u32, + self.uids_cache.get(&ws2p_full_id.1).cloned(), + self.ws2p_endpoints[&ws2p_full_id] + .ep + .get_url(false, false) + .expect("Endpoint unreachable !"), + ); + events::sent::send_network_event(&mut self, event); + } + WS2PSignal::PeerCard(_ws2p_full_id, _peer_card, ws2p_endpoints) => { + //trace!("WS2PSignal::PeerCard({})", ws2p_full_id); + //self.send_network_event(NetworkEvent::ReceivePeers(_)); + for ep in ws2p_endpoints { + match self.ws2p_endpoints.get( + &ep.node_full_id() + .expect("WS2P: Fail to get ep.node_full_id() !"), + ) { + Some(_) => {} + None => { + if let Some(_api) = + ws2p_db::string_to_api(&ep.api.0.clone()) + { + endpoints_to_update_status.insert( + ep.node_full_id().expect( + "WS2P: Fail to get ep.node_full_id() !", + ), + SystemTime::now(), + ); + } + if cfg!(feature = "ssl") || ep.port != 443 { + connect_to(&mut self, &ep); + } + } + }; + } + } + WS2PSignal::Heads(ws2p_full_id, heads) => { + trace!("WS2PSignal::Heads({}, {:?})", ws2p_full_id, heads.len()); + send_dal_request( + &mut self, + &BlockchainRequest::UIDs( + heads.iter().map(NetworkHead::pubkey).collect(), + ), + ); + let event = NetworkEvent::ReceiveHeads( + heads + .iter() + .map(|head| { + let mut new_head = head.clone(); + if let Some(uid) = self.uids_cache.get(&head.pubkey()) { + new_head.set_uid(uid); + } + new_head + }) + .collect(), + ); + events::sent::send_network_event(&mut self, event); + } + WS2PSignal::Document(ws2p_full_id, network_doc) => { + trace!("WS2PSignal::Document({})", ws2p_full_id); + events::sent::send_network_event( + &mut self, + NetworkEvent::ReceiveDocuments(vec![network_doc]), + ); + } + WS2PSignal::ReqResponse(req_id, req, recipient_full_id, response) => { + match req { + OldNetworkRequest::GetCurrent(ref _req_id) => { + info!( + "WS2PSignal::ReceiveCurrent({}, {:?})", + req_id.0, req + ); + if let Some(block) = parse_json_block(&response) { + crate::responses::sent::send_network_req_response( + &self, + req.get_req_full_id().0, + req.get_req_full_id().1, + NetworkResponse::CurrentBlock( + ModuleReqFullId(WS2PModule::name(), req_id), + recipient_full_id, + Box::new(block), ), - SystemTime::now(), ); } - if cfg!(feature = "ssl") || ep.port != 443 { - ws2p_module.connect_to(&ep); - } } - }; - } - } - WS2PSignal::Heads(ws2p_full_id, heads) => { - trace!("WS2PSignal::Heads({}, {:?})", ws2p_full_id, heads.len()); - ws2p_module.send_dal_request(&BlockchainRequest::UIDs( - heads.iter().map(NetworkHead::pubkey).collect(), - )); - ws2p_module.send_network_event(&NetworkEvent::ReceiveHeads( - heads - .iter() - .map(|head| { - let mut new_head = head.clone(); - if let Some(uid) = - ws2p_module.uids_cache.get(&head.pubkey()) - { - new_head.set_uid(uid); - } - new_head - }) - .collect(), - )); - } - WS2PSignal::Document(ws2p_full_id, network_doc) => { - trace!("WS2PSignal::Document({})", ws2p_full_id); - ws2p_module.send_network_event(&NetworkEvent::ReceiveDocuments(vec![ - network_doc, - ])); - } - WS2PSignal::ReqResponse(req_id, req, recipient_full_id, response) => { - match req { - OldNetworkRequest::GetCurrent(ref _req_id) => { - info!("WS2PSignal::ReceiveCurrent({}, {:?})", req_id.0, req); - if let Some(block) = parse_json_block(&response) { - ws2p_module.send_network_req_response( - req.get_req_full_id().0, - req.get_req_full_id().1, - NetworkResponse::CurrentBlock( - ModuleReqFullId(WS2PModule::name(), req_id), - recipient_full_id, - Box::new(block), - ), + OldNetworkRequest::GetBlocks(ref _req_id, count, from) => { + info!( + "WS2PSignal::ReceiveChunk({}, {} blocks from {})", + req_id.0, count, from ); - } - } - OldNetworkRequest::GetBlocks(ref _req_id, count, from) => { - info!( - "WS2PSignal::ReceiveChunk({}, {} blocks from {})", - req_id.0, count, from - ); - if response.is_array() { - let mut chunk = Vec::new(); - for json_block in response.as_array().unwrap() { - if let Some(block) = parse_json_block(json_block) { - chunk.push(block); - } else { - warn!("WS2PModule: Error : fail to parse one json block !"); + if response.is_array() { + let mut chunk = Vec::new(); + for json_block in unwrap!(response.as_array()) { + if let Some(block) = parse_json_block(json_block) { + chunk.push(block); + } else { + warn!("WS2PModule: Error : fail to parse one json block !"); + } } + debug!("Send chunk to followers : {}", from); + events::sent::send_network_event( + &mut self, + NetworkEvent::ReceiveBlocks(chunk), + ); } - debug!("Send chunk to followers : {}", from); - ws2p_module.send_network_event( - &NetworkEvent::ReceiveBlocks(chunk), + } + OldNetworkRequest::GetRequirementsPending( + _req_id, + min_cert, + ) => { + info!( + "WS2PSignal::ReceiveRequirementsPending({}, {})", + req_id.0, min_cert ); + debug!("----------------------------------------"); + debug!("- BEGIN IDENTITIES PENDING -"); + debug!("----------------------------------------"); + debug!("{:#?}", response); + debug!("----------------------------------------"); + debug!("- END IDENTITIES PENDING -"); + debug!("----------------------------------------"); } + _ => {} } - OldNetworkRequest::GetRequirementsPending(_req_id, min_cert) => { - info!( - "WS2PSignal::ReceiveRequirementsPending({}, {})", - req_id.0, min_cert - ); - debug!("----------------------------------------"); - debug!("- BEGIN IDENTITIES PENDING -"); - debug!("----------------------------------------"); - debug!("{:#?}", response); - debug!("----------------------------------------"); - debug!("- END IDENTITIES PENDING -"); - debug!("----------------------------------------"); - } - _ => {} } + WS2PSignal::Empty => {} + _ => {} } - WS2PSignal::Empty => {} - _ => {} - }, + } }, Err(e) => match e { mpsc::RecvTimeoutError::Disconnected => { @@ -797,14 +794,21 @@ impl DursModule for WS2PModule { mpsc::RecvTimeoutError::Timeout => {} }, } - if SystemTime::now() - .duration_since(last_ws2p_connections_print) - .unwrap() - > Duration::new(5, 0) + if unwrap!(SystemTime::now().duration_since(last_ws2p_endpoints_write)) + > Duration::new(*DURATION_BETWEEN_2_ENDPOINTS_SAVING, 0) + { + last_ws2p_endpoints_write = SystemTime::now(); + if let Err(err) = ws2p_db::write_endpoints(&self.ep_file_path, &self.ws2p_endpoints) + { + fatal_error!("WS2P1: Fail to write endpoints in DB : {:?}", err); + } + } + if unwrap!(SystemTime::now().duration_since(last_ws2p_state_print)) + > Duration::new(*WS2P_GENERAL_STATE_INTERVAL, 0) { - last_ws2p_connections_print = SystemTime::now(); + last_ws2p_state_print = SystemTime::now(); let mut connected_nodes = Vec::new(); - for (k, (_ep, state)) in ws2p_module.ws2p_endpoints.clone() { + for (k, DbEndpoint { state, .. }) in self.ws2p_endpoints.clone() { if let WS2PConnectionState::Established = state { connected_nodes.push(k); } @@ -812,75 +816,37 @@ impl DursModule for WS2PModule { // Print current_blockstamp info!( "WS2PModule : current_blockstamp() = {:?}", - current_blockstamp + self.current_blockstamp ); // New WS2P connection wave - if connected_nodes.len() < ws2p_module.conf.clone().outcoming_quota - && (SystemTime::now() - .duration_since(last_ws2p_connecting_wave) - .unwrap() + if connected_nodes.len() < self.conf.clone().outcoming_quota + && (unwrap!(SystemTime::now().duration_since(last_ws2p_connecting_wave)) > Duration::new(*WS2P_OUTCOMING_INTERVAL, 0) - || (SystemTime::now() - .duration_since(last_ws2p_connecting_wave) - .unwrap() + || (unwrap!(SystemTime::now().duration_since(last_ws2p_connecting_wave)) > Duration::new(*WS2P_OUTCOMING_INTERVAL_AT_STARTUP, 0) - && SystemTime::now().duration_since(start_time).unwrap() + && unwrap!(SystemTime::now().duration_since(start_time)) < Duration::new(*WS2P_OUTCOMING_INTERVAL, 0))) { last_ws2p_connecting_wave = SystemTime::now(); info!("Connected to know endpoints..."); - ws2p_module.connect_to_know_endpoints(); + connect_to_know_endpoints(&mut self); } // Request pending_identities from network - if SystemTime::now() - .duration_since(last_identities_request) - .unwrap() + if unwrap!(SystemTime::now().duration_since(last_identities_request)) > Duration::new(*PENDING_IDENTITIES_REQUEST_INTERVAL, 0) - && SystemTime::now().duration_since(start_time).unwrap() > Duration::new(10, 0) + && unwrap!(SystemTime::now().duration_since(start_time)) > Duration::new(10, 0) { /*info!("get pending_identities from all connections..."); - let _blocks_request_result = ws2p_module.send_request_to_all_connections( + let _blocks_request_result = self.send_request_to_all_connections( &OldNetworkRequest::GetRequirementsPending(ModuleReqId(0 as u32), 5), );*/ last_identities_request = SystemTime::now(); } - // Write pending endpoints - for (ep_full_id, received_time) in endpoints_to_update_status.clone() { - if SystemTime::now().duration_since(received_time).unwrap() - > Duration::new(*DURATION_BEFORE_RECORDING_ENDPOINT, 0) - { - if let Some(&(ref ep, ref state)) = - ws2p_module.ws2p_endpoints.get(&ep_full_id) - { - ws2p_db::write_endpoint( - &db, - &ep, - state.to_u32(), - SystemTime::now() - .duration_since(UNIX_EPOCH) - .unwrap() - .as_secs(), - ); - } - endpoints_to_update_status.remove(&ep_full_id); - } else { - info!( - "Write {} endpoint in {} secs.", - ep_full_id, - *DURATION_BEFORE_RECORDING_ENDPOINT - - SystemTime::now() - .duration_since(received_time) - .unwrap() - .as_secs() - ); - } - } // .. // Request current blockstamp - ws2p_module.send_dal_request(&BlockchainRequest::CurrentBlockstamp()); + send_dal_request(&mut self, &BlockchainRequest::CurrentBlockstamp()); } } - Ok(()) } } @@ -888,13 +854,9 @@ impl DursModule for WS2PModule { mod tests { use super::parsers::blocks::parse_json_block; use super::*; + use crate::ws_connections::requests::sent::network_request_to_json; use dubp_documents::documents::block::BlockDocument; use duniter_module::DursModule; - use dup_crypto::keys::PublicKey; - use durs_network_documents::network_endpoint::NetworkEndpointApi; - use std::fs; - use std::path::PathBuf; - use std::time::{SystemTime, UNIX_EPOCH}; #[test] fn test_parse_json_block() { @@ -1062,40 +1024,6 @@ mod tests { ); } - #[test] - fn endpoint_db_tests() { - let test_db_path = PathBuf::from("test.db"); - if test_db_path.as_path().exists() { - fs::remove_file(&test_db_path).unwrap(); - } - let db = WS2PModuleDatas::open_db(&test_db_path).unwrap(); - - let current_time = SystemTime::now().duration_since(UNIX_EPOCH).unwrap(); - - let mut endpoint = EndpointV1::parse_from_raw( - "WS2P cb06a19b g1.imirhil.fr 53012 /", - PubKey::Ed25519( - ed25519::PublicKey::from_base58("5gJYnQp8v7bWwk7EWRoL8vCLof1r3y9c6VDdnGSM1GLv") - .unwrap(), - ), - 1, - current_time.as_secs(), - ) - .expect("Failt to parse test endpoint !"); - - ws2p_db::write_endpoint(&db, &endpoint, 1, current_time.as_secs()); - let mut written_endpoints = - ws2p_db::get_endpoints_for_api(&db, &NetworkEndpointApi(String::from("WS2P"))); - assert_eq!(endpoint, written_endpoints.pop().unwrap()); - - // Test status update - endpoint.status = 3; - ws2p_db::write_endpoint(&db, &endpoint, 3, current_time.as_secs()); - let mut written_endpoints = - ws2p_db::get_endpoints_for_api(&db, &NetworkEndpointApi(String::from("WS2P"))); - assert_eq!(endpoint, written_endpoints.pop().unwrap()); - } - #[test] fn ws2p_requests() { let module_id = WS2PModule::name(); diff --git a/lib/modules/ws2p-v1-legacy/src/ok_message.rs b/lib/modules/ws2p-v1-legacy/src/ok_message.rs index 95a63c9d..5d566034 100644 --- a/lib/modules/ws2p-v1-legacy/src/ok_message.rs +++ b/lib/modules/ws2p-v1-legacy/src/ok_message.rs @@ -1,4 +1,4 @@ -use super::WS2PMessage; +use crate::*; use dup_crypto::keys::*; use serde::ser::{Serialize, SerializeStruct, Serializer}; @@ -11,23 +11,18 @@ pub struct WS2POkMessageV1 { } impl WS2PMessage for WS2POkMessageV1 { - fn parse(v: &serde_json::Value, currency: String) -> Option { + fn parse(v: &serde_json::Value, currency: String) -> Result { let signature = match v.get("sig") { - Some(signature) => signature - .as_str() - .expect("Parsing of OK message : fail to convert sig to str") - .to_string(), - None => return None, + Some(signature) => signature.as_str().ok_or(WS2PMsgParseErr {})?.to_string(), + None => return Err(WS2PMsgParseErr {}), }; - let pubkey: PubKey = PubKey::Ed25519( - ed25519::PublicKey::from_base58("969qRJs8KhsnkyzqarpL4RKZGMdVKNbZgu8fhsigM7Lj") - .expect("fail to create default pubkey !"), - ); - let signature: Option = Some(Sig::Ed25519( - dup_crypto::keys::Signature::from_base64(&signature) - .expect("fail to parse signature of OK message !"), - )); - Some(WS2POkMessageV1 { + let pubkey: PubKey = PubKey::Ed25519(ed25519::PublicKey::from_base58( + "969qRJs8KhsnkyzqarpL4RKZGMdVKNbZgu8fhsigM7Lj", + )?); + let signature: Option = Some(Sig::Ed25519(dup_crypto::keys::Signature::from_base64( + &signature, + )?)); + Ok(WS2POkMessageV1 { currency, pubkey, challenge: "".to_string(), @@ -41,8 +36,11 @@ impl WS2PMessage for WS2POkMessageV1 { ) } fn verify(&self) -> bool { - self.pubkey - .verify(self.to_raw().as_bytes(), &self.signature.unwrap()) + if let Some(sig) = self.signature { + self.pubkey.verify(self.to_raw().as_bytes(), &sig) + } else { + false + } } } diff --git a/lib/modules/ws2p-v1-legacy/src/parsers/excluded.rs b/lib/modules/ws2p-v1-legacy/src/parsers/excluded.rs index 8e7dd84b..aff225c3 100644 --- a/lib/modules/ws2p-v1-legacy/src/parsers/excluded.rs +++ b/lib/modules/ws2p-v1-legacy/src/parsers/excluded.rs @@ -1,13 +1,14 @@ use dup_crypto::keys::ed25519; use dup_crypto::keys::*; +use unwrap::unwrap; pub fn parse_exclusions(json_datas: &str) -> Option> { - let raw_exclusions: serde_json::Value = serde_json::from_str(json_datas).unwrap(); + let raw_exclusions: serde_json::Value = unwrap!(serde_json::from_str(json_datas)); if raw_exclusions.is_array() { - Some(parse_exclusions_from_json_value( - raw_exclusions.as_array().unwrap(), - )) + Some(parse_exclusions_from_json_value(unwrap!( + raw_exclusions.as_array() + ))) } else { None } @@ -16,9 +17,9 @@ pub fn parse_exclusions(json_datas: &str) -> Option> { pub fn parse_exclusions_from_json_value(array_exclusions: &[serde_json::Value]) -> Vec { let mut exclusions: Vec = Vec::new(); for exclusion in array_exclusions.iter() { - exclusions.push(PubKey::Ed25519( - ed25519::PublicKey::from_base58(exclusion.as_str().unwrap()).unwrap(), - )); + exclusions.push(PubKey::Ed25519(unwrap!(ed25519::PublicKey::from_base58( + unwrap!(exclusion.as_str()) + )))); } exclusions } diff --git a/lib/modules/ws2p-v1-legacy/src/parsers/identities.rs b/lib/modules/ws2p-v1-legacy/src/parsers/identities.rs index 02aab9a9..254214a3 100644 --- a/lib/modules/ws2p-v1-legacy/src/parsers/identities.rs +++ b/lib/modules/ws2p-v1-legacy/src/parsers/identities.rs @@ -2,6 +2,7 @@ use dubp_documents::documents::identity::*; use dubp_documents::Blockstamp; use dubp_documents::DocumentBuilder; use dup_crypto::keys::*; +use unwrap::unwrap; #[derive(Debug, Copy, Clone, PartialEq, Eq)] pub enum IdentityParseError { @@ -9,10 +10,10 @@ pub enum IdentityParseError { } pub fn parse_identities(currency: &str, json_datas: &str) -> Option> { - let raw_idties: serde_json::Value = serde_json::from_str(json_datas).unwrap(); + let raw_idties: serde_json::Value = unwrap!(serde_json::from_str(json_datas)); if raw_idties.is_array() { return Some( - parse_identities_from_json_value(currency, raw_idties.as_array().unwrap()) + parse_identities_from_json_value(currency, unwrap!(raw_idties.as_array())) .iter() .map(|i| { i.clone() @@ -31,18 +32,18 @@ pub fn parse_identities_from_json_value( array_identities .iter() .map(|idty| { - let idty_datas: Vec<&str> = idty.as_str().unwrap().split(':').collect(); + let idty_datas: Vec<&str> = unwrap!(idty.as_str()).split(':').collect(); if idty_datas.len() == 4 { let idty_doc_builder = IdentityDocumentBuilder { currency, - issuer: &PubKey::Ed25519( - ed25519::PublicKey::from_base58(idty_datas[0]).unwrap(), - ), - blockstamp: &Blockstamp::from_string(idty_datas[2]).unwrap(), + issuer: &PubKey::Ed25519(unwrap!(ed25519::PublicKey::from_base58( + idty_datas[0] + ))), + blockstamp: &unwrap!(Blockstamp::from_string(idty_datas[2])), username: idty_datas[3], }; let idty_sig = - Sig::Ed25519(ed25519::Signature::from_base64(idty_datas[1]).unwrap()); + Sig::Ed25519(unwrap!(ed25519::Signature::from_base64(idty_datas[1]))); //memberships.push(membership_doc_builder.build_with_signature(vec![membership_sig])); Ok(idty_doc_builder.build_with_signature(vec![idty_sig])) } else { @@ -57,7 +58,7 @@ pub fn parse_compact_identity( source: &serde_json::Value, ) -> Option { if source.is_string() { - let idty_elements: Vec<&str> = source.as_str().unwrap().split(':').collect(); + let idty_elements: Vec<&str> = unwrap!(source.as_str()).split(':').collect(); let issuer = match ed25519::PublicKey::from_base58(idty_elements[0]) { Ok(pubkey) => PubKey::Ed25519(pubkey), Err(_) => return None, diff --git a/lib/modules/ws2p-v1-legacy/src/parsers/memberships.rs b/lib/modules/ws2p-v1-legacy/src/parsers/memberships.rs index a04d2d99..3fb2cf2a 100644 --- a/lib/modules/ws2p-v1-legacy/src/parsers/memberships.rs +++ b/lib/modules/ws2p-v1-legacy/src/parsers/memberships.rs @@ -2,6 +2,7 @@ use dubp_documents::documents::membership::*; use dubp_documents::Blockstamp; use dubp_documents::DocumentBuilder; use dup_crypto::keys::*; +use unwrap::unwrap; #[derive(Debug, Copy, Clone, PartialEq, Eq)] pub enum MembershipParseError { @@ -13,13 +14,13 @@ pub fn parse_memberships( membership_type: MembershipType, json_datas: &str, ) -> Option> { - let raw_memberships: serde_json::Value = serde_json::from_str(json_datas).unwrap(); + let raw_memberships: serde_json::Value = unwrap!(serde_json::from_str(json_datas)); if raw_memberships.is_array() { return Some( parse_memberships_from_json_value( currency, membership_type, - raw_memberships.as_array().unwrap(), + unwrap!(raw_memberships.as_array()), ) .iter() .map(|m| { @@ -41,20 +42,21 @@ pub fn parse_memberships_from_json_value( array_memberships .iter() .map(|membership| { - let membership_datas: Vec<&str> = membership.as_str().unwrap().split(':').collect(); + let membership_datas: Vec<&str> = unwrap!(membership.as_str()).split(':').collect(); if membership_datas.len() == 5 { let membership_doc_builder = MembershipDocumentBuilder { currency, - issuer: &PubKey::Ed25519( - ed25519::PublicKey::from_base58(membership_datas[0]).unwrap(), - ), - blockstamp: &Blockstamp::from_string(membership_datas[2]).unwrap(), + issuer: &PubKey::Ed25519(unwrap!(ed25519::PublicKey::from_base58( + membership_datas[0] + ))), + blockstamp: &unwrap!(Blockstamp::from_string(membership_datas[2])), membership: membership_type, identity_username: membership_datas[4], - identity_blockstamp: &Blockstamp::from_string(membership_datas[3]).unwrap(), + identity_blockstamp: &unwrap!(Blockstamp::from_string(membership_datas[3])), }; - let membership_sig = - Sig::Ed25519(ed25519::Signature::from_base64(membership_datas[1]).unwrap()); + let membership_sig = Sig::Ed25519(unwrap!(ed25519::Signature::from_base64( + membership_datas[1] + ))); Ok(membership_doc_builder.build_with_signature(vec![membership_sig])) } else { Err(MembershipParseError::WrongFormat()) diff --git a/lib/modules/ws2p-v1-legacy/src/parsers/mod.rs b/lib/modules/ws2p-v1-legacy/src/parsers/mod.rs index ca9a42a8..7c9c1edc 100644 --- a/lib/modules/ws2p-v1-legacy/src/parsers/mod.rs +++ b/lib/modules/ws2p-v1-legacy/src/parsers/mod.rs @@ -27,6 +27,7 @@ mod tests { use dubp_documents::DocumentBuilder; use dup_crypto::keys::*; use std::str::FromStr; + use unwrap::unwrap; #[test] fn parse_json_tx() { @@ -57,28 +58,24 @@ mod tests { let tx_builder = TransactionDocumentBuilder { currency: "g1", - blockstamp: &Blockstamp::from_string( + blockstamp: &unwrap!(Blockstamp::from_string( "112533-000002150F2E805E604D9B31212D079570AAD8D3A4D8BB75F2C15A94A345B6B1", - ) - .unwrap(), + )), locktime: &0, - issuers: &vec![PubKey::Ed25519( - ed25519::PublicKey::from_base58("51EFVNZwpfmTXU7BSLpeh3PZFgfdmm5hq5MzCDopdH2") - .unwrap(), - )], - inputs: &vec![TransactionInput::from_str( + issuers: &vec![PubKey::Ed25519(unwrap!(ed25519::PublicKey::from_base58( + "51EFVNZwpfmTXU7BSLpeh3PZFgfdmm5hq5MzCDopdH2" + )))], + inputs: &vec![unwrap!(TransactionInput::from_str( "1000:0:D:51EFVNZwpfmTXU7BSLpeh3PZFgfdmm5hq5MzCDopdH2:46496", - ) - .unwrap()], - outputs: &vec![TransactionOutput::from_str( + ))], + outputs: &vec![unwrap!(TransactionOutput::from_str( "1000:0:SIG(2yN8BRSkARcqE8NCxKMBiHfTpx1EvwULFn56Myf6qRmy)", - ) - .unwrap()], - unlocks: &vec![TransactionInputUnlocks::from_str("0:SIG(0)").unwrap()], + ))], + unlocks: &vec![unwrap!(TransactionInputUnlocks::from_str("0:SIG(0)"))], comment: "Merci pour la calligraphie ;) de Liam", hash: None, }; - let mut tx_doc = tx_builder.build_with_signature(vec![Sig::Ed25519(ed25519::Signature::from_base64("5olrjFylTCsVq8I5Yr7FpXeviynICyvIwe1yG5N0RJF+VZb+bCFBnLAMpmMCU2qzUvK7z41UXOrMRybXiLa2Dw==").unwrap())]); + let mut tx_doc = tx_builder.build_with_signature(vec![Sig::Ed25519(unwrap!(ed25519::Signature::from_base64("5olrjFylTCsVq8I5Yr7FpXeviynICyvIwe1yG5N0RJF+VZb+bCFBnLAMpmMCU2qzUvK7z41UXOrMRybXiLa2Dw==")))]); tx_doc.compute_hash(); assert_eq!( parse_transaction("g1", &tx_json).expect("Fail to parse transaction !"), @@ -116,32 +113,29 @@ mod tests { let tx_builder = TransactionDocumentBuilder { currency: "g1", - blockstamp: &Blockstamp::from_string( + blockstamp: &unwrap!(Blockstamp::from_string( "58-00005B9167EBA1E32C6EAD42AE7F72D8F14B765D3C9E47D233B553D47C5AEE0C", - ) - .unwrap(), + )), locktime: &0, - issuers: &vec![PubKey::Ed25519( - ed25519::PublicKey::from_base58("FVUFRrk1K5TQGsY7PRLwqHgdHRoHrwb1hcucp4C2N5tD") - .unwrap(), - )], - inputs: &vec![TransactionInput::from_str( + issuers: &vec![PubKey::Ed25519(unwrap!(ed25519::PublicKey::from_base58( + "FVUFRrk1K5TQGsY7PRLwqHgdHRoHrwb1hcucp4C2N5tD" + )))], + inputs: &vec![unwrap!(TransactionInput::from_str( "1000:0:D:FVUFRrk1K5TQGsY7PRLwqHgdHRoHrwb1hcucp4C2N5tD:1", - ) - .unwrap()], + ))], outputs: &vec![ - TransactionOutput::from_str("3:0:SIG(7vU9BMDhN6fBuRa2iK3JRbC6pqQKb4qDMGsFcQuT5cz)") - .unwrap(), - TransactionOutput::from_str( + unwrap!(TransactionOutput::from_str( + "3:0:SIG(7vU9BMDhN6fBuRa2iK3JRbC6pqQKb4qDMGsFcQuT5cz)" + )), + unwrap!(TransactionOutput::from_str( "997:0:SIG(FVUFRrk1K5TQGsY7PRLwqHgdHRoHrwb1hcucp4C2N5tD)", - ) - .unwrap(), + )), ], - unlocks: &vec![TransactionInputUnlocks::from_str("0:SIG(0)").unwrap()], + unlocks: &vec![unwrap!(TransactionInputUnlocks::from_str("0:SIG(0)"))], comment: "Un petit cafe ;-)", hash: None, }; - let mut tx_doc = tx_builder.build_with_signature(vec![Sig::Ed25519(ed25519::Signature::from_base64("VWbvsiybM4L2X5+o+6lIiuKNw5KrD1yGZqmV+lHtA28XoRUFzochSIgfoUqBsTAaYEHY45vSX917LDXudTEzBg==").unwrap())]); + let mut tx_doc = tx_builder.build_with_signature(vec![Sig::Ed25519(unwrap!(ed25519::Signature::from_base64("VWbvsiybM4L2X5+o+6lIiuKNw5KrD1yGZqmV+lHtA28XoRUFzochSIgfoUqBsTAaYEHY45vSX917LDXudTEzBg==")))]); tx_doc.compute_hash(); assert_eq!( parse_transaction("g1", &tx_json).expect("Fail to parse transaction !"), diff --git a/lib/modules/ws2p-v1-legacy/src/parsers/transactions.rs b/lib/modules/ws2p-v1-legacy/src/parsers/transactions.rs index f979aa73..5beacc27 100644 --- a/lib/modules/ws2p-v1-legacy/src/parsers/transactions.rs +++ b/lib/modules/ws2p-v1-legacy/src/parsers/transactions.rs @@ -96,6 +96,7 @@ pub fn parse_transaction( #[cfg(test)] mod tests { use super::*; + use unwrap::unwrap; #[test] fn parse_compact_tx() { @@ -110,24 +111,20 @@ Merci pour la calligraphie ;) de Liam$\ let _tx_builder = TransactionDocumentBuilder { currency: "g1", - blockstamp: &Blockstamp::from_string( + blockstamp: &unwrap!(Blockstamp::from_string( "112533-000002150F2E805E604D9B31212D079570AAD8D3A4D8BB75F2C15A94A345B6B1", - ) - .unwrap(), + )), locktime: &0, - issuers: &vec![PubKey::Ed25519( - ed25519::PublicKey::from_base58("51EFVNZwpfmTXU7BSLpeh3PZFgfdmm5hq5MzCDopdH2") - .unwrap(), - )], - inputs: &vec![TransactionInput::from_str( + issuers: &vec![PubKey::Ed25519(unwrap!(ed25519::PublicKey::from_base58( + "51EFVNZwpfmTXU7BSLpeh3PZFgfdmm5hq5MzCDopdH2" + )))], + inputs: &vec![unwrap!(TransactionInput::from_str( "1000:0:D:51EFVNZwpfmTXU7BSLpeh3PZFgfdmm5hq5MzCDopdH2:46496", - ) - .unwrap()], - outputs: &vec![TransactionOutput::from_str( + ))], + outputs: &vec![unwrap!(TransactionOutput::from_str( "1000:0:SIG(2yN8BRSkARcqE8NCxKMBiHfTpx1EvwULFn56Myf6qRmy)", - ) - .unwrap()], - unlocks: &vec![TransactionInputUnlocks::from_str("0:SIG(0)").unwrap()], + ))], + unlocks: &vec![unwrap!(TransactionInputUnlocks::from_str("0:SIG(0)"))], comment: "Merci pour la calligraphie ;) de Liam", hash: None, }; diff --git a/lib/modules/ws2p-v1-legacy/src/requests/mod.rs b/lib/modules/ws2p-v1-legacy/src/requests/mod.rs new file mode 100644 index 00000000..f2456178 --- /dev/null +++ b/lib/modules/ws2p-v1-legacy/src/requests/mod.rs @@ -0,0 +1,19 @@ +// Copyright (C) 2018 The Duniter Project Developers. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +//! Sub-module managing the inter-modules requests sent and received. + +pub mod received; +pub mod sent; diff --git a/lib/modules/ws2p-v1-legacy/src/requests/received.rs b/lib/modules/ws2p-v1-legacy/src/requests/received.rs new file mode 100644 index 00000000..ab9c2d0e --- /dev/null +++ b/lib/modules/ws2p-v1-legacy/src/requests/received.rs @@ -0,0 +1,66 @@ +// Copyright (C) 2018 The Duniter Project Developers. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +//! Sub-module managing the inter-modules requests received. + +use crate::ws2p_db::DbEndpoint; +use crate::ws_connections::states::WS2PConnectionState; +use crate::WS2PModule; +use duniter_network::requests::OldNetworkRequest; +use durs_message::requests::DursReqContent; + +pub fn receive_req(ws2p_module: &mut WS2PModule, req_content: &DursReqContent) { + if let DursReqContent::OldNetworkRequest(ref old_net_request) = *req_content { + match *old_net_request { + OldNetworkRequest::GetBlocks(ref req_id, ref count, ref from) => { + let mut receiver_index = 0; + let mut real_receiver = None; + for (ws2p_full_id, DbEndpoint { state, .. }) in ws2p_module.ws2p_endpoints.clone() { + if let WS2PConnectionState::Established = state { + if receiver_index == ws2p_module.next_receiver { + real_receiver = Some(ws2p_full_id); + break; + } + receiver_index += 1; + } + } + if real_receiver.is_none() { + ws2p_module.next_receiver = 0; + for (ws2p_full_id, DbEndpoint { state, .. }) in &ws2p_module.ws2p_endpoints { + if let WS2PConnectionState::Established = *state { + real_receiver = Some(*ws2p_full_id); + break; + } + } + } else { + ws2p_module.next_receiver += 1; + } + if let Some(real_receiver) = real_receiver { + debug!("WS2P: send req to: ({:?})", real_receiver); + let _blocks_request_result = + crate::ws_connections::requests::sent::send_request_to_specific_node( + ws2p_module, + &real_receiver, + &OldNetworkRequest::GetBlocks(*req_id, *count, *from), + ); + } else { + warn!("WS2P: not found peer to send request !"); + } + } + OldNetworkRequest::GetEndpoints(ref _request) => {} + _ => {} + } + } +} diff --git a/lib/modules/ws2p-v1-legacy/src/requests/sent.rs b/lib/modules/ws2p-v1-legacy/src/requests/sent.rs new file mode 100644 index 00000000..e07093a9 --- /dev/null +++ b/lib/modules/ws2p-v1-legacy/src/requests/sent.rs @@ -0,0 +1,37 @@ +// Copyright (C) 2018 The Durs Project Developers. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +//! Sub-module managing the inter-modules requests sent. + +use crate::WS2PModule; +use duniter_module::{DursModule, ModuleReqId, ModuleRole, RouterThreadMessage}; +use durs_message::requests::{BlockchainRequest, DursReqContent}; +use durs_message::*; + +pub fn send_dal_request(ws2p_module: &mut WS2PModule, req: &BlockchainRequest) { + ws2p_module.count_dal_requests += 1; + if ws2p_module.count_dal_requests == std::u32::MAX { + ws2p_module.count_dal_requests = 0; + } + ws2p_module + .router_sender + .send(RouterThreadMessage::ModuleMessage(DursMsg::Request { + req_from: WS2PModule::name(), + req_to: ModuleRole::BlockchainDatas, + req_id: ModuleReqId(ws2p_module.count_dal_requests), + req_content: DursReqContent::BlockchainRequest(req.clone()), + })) + .expect("Fail to send message to router !"); +} diff --git a/lib/modules/ws2p-v1-legacy/src/responses/mod.rs b/lib/modules/ws2p-v1-legacy/src/responses/mod.rs new file mode 100644 index 00000000..516f7af7 --- /dev/null +++ b/lib/modules/ws2p-v1-legacy/src/responses/mod.rs @@ -0,0 +1,19 @@ +// Copyright (C) 2018 The Durs Project Developers. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +//! Sub-module managing the inter-modules responses sent and received. + +pub mod received; +pub mod sent; diff --git a/lib/modules/ws2p-v1-legacy/src/responses/received.rs b/lib/modules/ws2p-v1-legacy/src/responses/received.rs new file mode 100644 index 00000000..64e0f487 --- /dev/null +++ b/lib/modules/ws2p-v1-legacy/src/responses/received.rs @@ -0,0 +1,16 @@ +// Copyright (C) 2018 The Durs Project Developers. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +//! Sub-module managing the inter-modules responses received. diff --git a/lib/modules/ws2p-v1-legacy/src/responses/sent.rs b/lib/modules/ws2p-v1-legacy/src/responses/sent.rs new file mode 100644 index 00000000..f102489c --- /dev/null +++ b/lib/modules/ws2p-v1-legacy/src/responses/sent.rs @@ -0,0 +1,36 @@ +// Copyright (C) 2018 The Durs Project Developers. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +//! Sub-module managing the inter-modules responses sent. + +use crate::*; +use durs_message::*; + +pub fn send_network_req_response( + ws2p_module: &WS2PModule, + requester: ModuleStaticName, + req_id: ModuleReqId, + response: NetworkResponse, +) { + ws2p_module + .router_sender + .send(RouterThreadMessage::ModuleMessage(DursMsg::Response { + res_from: WS2PModule::name(), + res_to: requester, + req_id, + res_content: DursResContent::NetworkResponse(response), + })) + .expect("Fail to send message to router !"); +} diff --git a/lib/modules/ws2p-v1-legacy/src/ws2p_db.rs b/lib/modules/ws2p-v1-legacy/src/ws2p_db.rs index c23229dc..0b09fb1f 100644 --- a/lib/modules/ws2p-v1-legacy/src/ws2p_db.rs +++ b/lib/modules/ws2p-v1-legacy/src/ws2p_db.rs @@ -1,6 +1,27 @@ -use dup_crypto::keys::*; -use durs_network_documents::network_endpoint::{EndpointV1, NetworkEndpointApi}; -use sqlite::*; +// Copyright (C) 2018 The Durs Project Developers. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +//! Manage WS2Pv1 storage. + +use crate::ws_connections::states::WS2PConnectionState; +use durs_network_documents::network_endpoint::EndpointV1; +use durs_network_documents::NodeFullId; +use serde::{Deserialize, Serialize}; +use std::collections::HashMap; +use std::fs::File; +use std::path::Path; #[derive(Debug, Copy, Clone, PartialEq, Eq)] pub enum EndpointApi { @@ -12,14 +33,6 @@ pub enum EndpointApi { //BMAS, } -impl From for EndpointApi { - fn from(integer: u32) -> Self { - match integer { - _ => EndpointApi::WS2P, - } - } -} - pub fn string_to_api(api: &str) -> Option { match api { "WS2P" => Some(EndpointApi::WS2P), @@ -32,97 +45,53 @@ pub fn string_to_api(api: &str) -> Option { } } -pub fn api_to_integer(api: &NetworkEndpointApi) -> i64 { - match api.0.as_str() { - "WS2P" => 1, - //EndpointApi::WS2PS => 2, - //EndpointApi::WS2PTOR => 3, - //EndpointApi::DASA => 4, - //EndpointApi::BMA => 5, - //EndpointApi::BMAS => 6, - _ => 0, - } +#[derive(Debug)] +pub enum Ws2pPeersDbError { + IoErr(std::io::Error), + SerdeErr(bincode::Error), } -pub fn get_endpoints_for_api(db: &Connection, api: &NetworkEndpointApi) -> Vec { - let mut cursor: Cursor = db - .prepare("SELECT hash_full_id, status, node_id, pubkey, api, version, endpoint, last_check FROM endpoints WHERE api=? ORDER BY status DESC;") - .expect("get_endpoints_for_api() : Error in SQL request !") - .cursor(); - - cursor - .bind(&[Value::Integer(api_to_integer(&api))]) - .expect("get_endpoints_for_api() : Error in cursor binding !"); - let mut endpoints = Vec::new(); - while let Some(row) = cursor - .next() - .expect("get_endpoints_for_api() : Error in cursor.next()") - { - let raw_ep = row[6].as_string().unwrap().to_string(); - let ep_issuer = - PubKey::Ed25519(ed25519::PublicKey::from_base58(row[3].as_string().unwrap()).unwrap()); - let mut ep = match EndpointV1::parse_from_raw( - &raw_ep, - ep_issuer, - row[1].as_integer().unwrap() as u32, - row[7].as_integer().unwrap() as u64, - ) { - Ok(ep) => ep, - Err(e) => panic!(format!( - "Fail to parse endpoint : {} (Error: {:?})", - raw_ep, e - )), - }; - ep.status = row[1].as_integer().unwrap() as u32; - ep.last_check = row[7].as_integer().unwrap() as u64; +impl From for Ws2pPeersDbError { + fn from(e: std::io::Error) -> Self { + Ws2pPeersDbError::IoErr(e) + } +} - endpoints.push(ep); +impl From for Ws2pPeersDbError { + fn from(e: bincode::Error) -> Self { + Ws2pPeersDbError::SerdeErr(e) } - endpoints } -pub fn write_endpoint( - db: &Connection, - endpoint: &EndpointV1, - new_status: u32, - new_last_check: u64, -) { - let hash_full_id = endpoint - .node_full_id() - .expect("Fail to write endpoint : node_full_id() return None !") - .sha256(); - // Check if endpoint it's already written - let mut cursor: Cursor = db - .prepare("SELECT status FROM endpoints WHERE hash_full_id=? ORDER BY status DESC;") - .expect("write_endpoint() : Error in SQL request !") - .cursor(); - cursor - .bind(&[Value::String(hash_full_id.to_string())]) - .expect("write_endpoint() : Error in cursor binding !"); +#[derive(Clone, Debug, Deserialize, Serialize)] +pub struct DbEndpoint { + pub ep: EndpointV1, + pub state: WS2PConnectionState, + pub last_check: u64, +} - // If endpoint it's already written, update status - if let Some(row) = cursor - .next() - .expect("write_endpoint() : Error in cursor.next()") - { - if row[0].as_integer().expect("fail to read ep status !") as u32 != endpoint.status { - db.execute(format!( - "UPDATE endpoints SET status={} WHERE hash_full_id='{}'", - endpoint.status, hash_full_id - )) - .expect("Fail to parse SQL request update endpoint status !"); +pub fn get_endpoints( + file_path: &Path, +) -> Result, Ws2pPeersDbError> { + if file_path.exists() { + let bin_endpoints = durs_common_tools::read_bin_file(file_path)?; + if bin_endpoints.is_empty() { + Ok(HashMap::new()) + } else { + Ok(bincode::deserialize(&bin_endpoints[..])?) } } else { - let ep_v10 = endpoint; - db - .execute( - format!( - "INSERT INTO endpoints (hash_full_id, status, node_id, pubkey, api, version, endpoint, last_check) VALUES ('{}', {}, {}, '{}', {}, {}, '{}', {});", - ep_v10.hash_full_id.expect("ep_v10.hash_full_id = None"), new_status, ep_v10.node_id.expect("ep_v10.node_id = None").0, - ep_v10.issuer.to_string(), api_to_integer(&ep_v10.api), - 1, ep_v10.raw_endpoint, new_last_check - ) - ) - .expect("Fail to parse SQL request INSERT endpoint !"); + File::create(file_path)?; + Ok(HashMap::new()) } } + +pub fn write_endpoints( + file_path: &Path, + endpoints: &HashMap, +) -> Result<(), Ws2pPeersDbError> { + let bin_endpoints = bincode::serialize(&endpoints)?; + durs_common_tools::write_bin_file(file_path, &bin_endpoints)?; + + Ok(()) +} diff --git a/lib/modules/ws2p-v1-legacy/src/ws2p_requests.rs b/lib/modules/ws2p-v1-legacy/src/ws2p_requests.rs deleted file mode 100644 index 7ba0058b..00000000 --- a/lib/modules/ws2p-v1-legacy/src/ws2p_requests.rs +++ /dev/null @@ -1,37 +0,0 @@ -use duniter_network::requests::OldNetworkRequest; - -pub fn network_request_to_json(request: &OldNetworkRequest) -> serde_json::Value { - let (request_id, request_type, request_params) = match *request { - OldNetworkRequest::GetCurrent(ref req_full_id) => (req_full_id.1, "CURRENT", json!({})), - OldNetworkRequest::GetBlocks(ref req_full_id, count, from_mumber) => ( - req_full_id.1, - "BLOCKS_CHUNK", - json!({ - "count": count, - "fromNumber": from_mumber - }), - ), - OldNetworkRequest::GetRequirementsPending(ref req_full_id, min_cert) => ( - req_full_id.1, - "WOT_REQUIREMENTS_OF_PENDING", - json!({ "minCert": min_cert }), - ), - OldNetworkRequest::GetConsensus(_) => { - panic!("GetConsensus() request must be not convert to json !"); - } - OldNetworkRequest::GetHeadsCache(_) => { - panic!("GetHeadsCache() request must be not convert to json !"); - } - OldNetworkRequest::GetEndpoints(_) => { - panic!("GetEndpoints() request must be not convert to json !"); - } - }; - - json!({ - "reqId": request_id, - "body" : { - "name": request_type, - "params": request_params - } - }) -} diff --git a/lib/modules/ws2p-v1-legacy/src/ws_connections/handler.rs b/lib/modules/ws2p-v1-legacy/src/ws_connections/handler.rs new file mode 100644 index 00000000..d53b59ea --- /dev/null +++ b/lib/modules/ws2p-v1-legacy/src/ws_connections/handler.rs @@ -0,0 +1,241 @@ +// Copyright (C) 2018 The Durs Project Developers. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +//! WS2P connections handler. + +use super::messages::*; +use super::meta_datas::WS2PConnectionMetaDatas; +use super::states::WS2PConnectionState; +use crate::constants::*; +use crate::*; +use dup_crypto::keys::*; +use std::sync::mpsc; +#[allow(deprecated)] +use ws::util::{Timeout, Token}; +use ws::{CloseCode, Frame, Handler, Handshake, Message, Sender}; + +const CONNECT: Token = Token(1); +const EXPIRE: Token = Token(2); + +// Our Handler struct. +// Here we explicity indicate that the Client needs a Sender, +// whereas a closure captures the Sender for us automatically. +#[allow(deprecated)] +#[derive(Debug)] +pub struct Client { + ws: Sender, + conductor_sender: mpsc::Sender, + currency: String, + key_pair: KeyPairEnum, + connect_message: Message, + conn_meta_datas: WS2PConnectionMetaDatas, + last_mess_time: SystemTime, + spam_interval: bool, + spam_counter: usize, + timeout: Option, +} + +pub fn connect_to_ws2p_endpoint( + endpoint: &EndpointV1, + conductor_sender: &mpsc::Sender, + currency: &str, + key_pair: KeyPairEnum, +) -> ws::Result<()> { + // Get endpoint url + let ws_url = endpoint.get_url(true, false).expect("Endpoint unreachable"); + + // Create WS2PConnectionMetaDatass + let mut conn_meta_datas = WS2PConnectionMetaDatas::new( + "b60a14fd-0826-4ae0-83eb-1a92cd59fd5308535fd3-78f2-4678-9315-cd6e3b7871b1".to_string(), + ); + conn_meta_datas.remote_pubkey = Some(endpoint.issuer); + conn_meta_datas.remote_uuid = Some( + endpoint + .node_id + .expect("WS2P: Fail to get ep.node_uuid() !"), + ); + + // Generate connect message + let connect_message = + generate_connect_message(currency, key_pair, conn_meta_datas.challenge.clone()); + + // Log + info!("WS2P: Try connection to {} ...", ws_url); + + // Connect to websocket + ws::connect(ws_url, |ws| Client { + ws, + conductor_sender: conductor_sender.clone(), + currency: String::from(currency), + key_pair, + connect_message: connect_message.clone(), + conn_meta_datas: conn_meta_datas.clone(), + last_mess_time: SystemTime::now(), + spam_interval: false, + spam_counter: 0, + timeout: None, + }) +} + +// We implement the Handler trait for Client so that we can get more +// fine-grained control of the connection. +impl Handler for Client { + // `on_open` will be called only after the WebSocket handshake is successful + // so at this point we know that the connection is ready to send/receive messages. + // We ignore the `Handshake` for now, but you could also use this method to setup + // Handler state or reject the connection based on the details of the Request + // or Response, such as by checking cookies or Auth headers. + fn on_open(&mut self, _: Handshake) -> ws::Result<()> { + // Define timeouts + self.ws.timeout(WS2P_NEGOTIATION_TIMEOUT * 1_000, CONNECT)?; + self.ws.timeout(WS2P_EXPIRE_TIMEOUT * 1_000, EXPIRE)?; + // Send ws::Sender to WS2PConductor + let result = self + .conductor_sender + .send(WS2PThreadSignal::WS2PConnectionMessage( + WS2PConnectionMessage( + self.conn_meta_datas.node_full_id(), + WS2PConnectionMessagePayload::WebsocketOk(WsSender(self.ws.clone())), + ), + )); + // If WS2PConductor is unrechable, close connection. + if result.is_err() { + debug!("Close ws2p connection because ws2p main thread is unrechable !"); + self.ws.close(CloseCode::Normal) + } else { + // Send CONNECT Message + self.ws.send(self.connect_message.clone()) + } + } + + // `on_message` is roughly equivalent to the Handler closure. It takes a `Message` + // and returns a `Result<()>`. + fn on_message(&mut self, msg: Message) -> ws::Result<()> { + // Spam ? + if unwrap!(SystemTime::now().duration_since(self.last_mess_time)) + > Duration::new(*WS2P_SPAM_INTERVAL_IN_MILLI_SECS, 0) + { + if self.spam_interval { + self.spam_counter += 1; + } else { + self.spam_interval = true; + self.spam_counter = 2; + } + } else { + self.spam_interval = false; + self.spam_counter = 0; + } + // Spam ? + if self.spam_counter >= *WS2P_SPAM_LIMIT { + thread::sleep(Duration::from_millis(*WS2P_SPAM_SLEEP_TIME_IN_SEC)); + self.last_mess_time = SystemTime::now(); + return Ok(()); + } + self.last_mess_time = SystemTime::now(); + + // Parse and check incoming message + if msg.is_text() { + let s: String = msg + .into_text() + .expect("WS2P: Fail to convert message payload to String !"); + trace!("WS2P: receive mess: {}", s); + let json_message: serde_json::Value = serde_json::from_str(&s) + .expect("WS2P: Fail to convert string message ton json value !"); + let result = self + .conductor_sender + .send(WS2PThreadSignal::WS2PConnectionMessage( + WS2PConnectionMessage( + self.conn_meta_datas.node_full_id(), + self.conn_meta_datas.parse_and_check_incoming_message( + &self.currency, + self.key_pair, + &json_message, + ), + ), + )); + if result.is_err() { + info!("Close ws2p connection because ws2p main thread is unrechable !"); + self.ws.close(CloseCode::Normal)?; + } + } + Ok(()) + } + fn on_timeout(&mut self, event: Token) -> ws::Result<()> { + match event { + CONNECT => { + if self.conn_meta_datas.state != WS2PConnectionState::Established { + let _result = + self.conductor_sender + .send(WS2PThreadSignal::WS2PConnectionMessage( + WS2PConnectionMessage( + self.conn_meta_datas.node_full_id(), + WS2PConnectionMessagePayload::NegociationTimeout, + ), + )); + self.ws.close(CloseCode::Away) + } else { + Ok(()) + } + } + EXPIRE => { + let _result = self + .conductor_sender + .send(WS2PThreadSignal::WS2PConnectionMessage( + WS2PConnectionMessage( + self.conn_meta_datas.node_full_id(), + WS2PConnectionMessagePayload::Timeout, + ), + )); + self.ws.close(CloseCode::Away) + } + _ => Ok(()), + } + } + #[allow(deprecated)] + fn on_new_timeout(&mut self, event: Token, timeout: Timeout) -> ws::Result<()> { + if event == EXPIRE { + if let Some(t) = self.timeout.take() { + self.ws.cancel(t)?; + } + self.timeout = Some(timeout) + } + Ok(()) + } + fn on_frame(&mut self, frame: Frame) -> ws::Result> { + // some activity has occurred, let's reset the expiration timeout + self.ws.timeout(WS2P_EXPIRE_TIMEOUT * 1_000, EXPIRE)?; + Ok(Some(frame)) + } + fn on_close(&mut self, code: CloseCode, reason: &str) { + // The WebSocket protocol allows for a utf8 reason for the closing state after the + // close code. WS-RS will attempt to interpret this data as a utf8 description of the + // reason for closing the connection. I many cases, `reason` will be an empty string. + // So, you may not normally want to display `reason` to the user, + // but let's assume that we know that `reason` is human-readable. + match code { + CloseCode::Normal => info!("The remote server close the connection."), + CloseCode::Away => info!("The remote server is leaving."), + _ => warn!("The remote server encountered an error: {}", reason), + } + let _result = self + .conductor_sender + .send(WS2PThreadSignal::WS2PConnectionMessage( + WS2PConnectionMessage( + self.conn_meta_datas.node_full_id(), + WS2PConnectionMessagePayload::Close, + ), + )); + } +} diff --git a/lib/modules/ws2p-v1-legacy/src/ws_connections/messages.rs b/lib/modules/ws2p-v1-legacy/src/ws_connections/messages.rs new file mode 100644 index 00000000..d6465184 --- /dev/null +++ b/lib/modules/ws2p-v1-legacy/src/ws_connections/messages.rs @@ -0,0 +1,291 @@ +// Copyright (C) 2018 The Durs Project Developers. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +//! Define ws2p connections messages. + +use super::*; +use durs_network_documents::NodeFullId; +use ws::Message; + +#[derive(Debug)] +/// WS2Pv1 connection Message +pub struct WS2PConnectionMessage(pub NodeFullId, pub WS2PConnectionMessagePayload); + +#[derive(Debug)] +/// WS2Pv1 connection Message payload +pub enum WS2PConnectionMessagePayload { + FailOpenWS, + WrongUrl, + FailToSplitWS, + TryToSendConnectMess, + FailSendConnectMess, + WebsocketOk(WsSender), + NegociationTimeout, + ValidConnectMessage(String, WS2PConnectionState), + ValidAckMessage(String, WS2PConnectionState), + ValidOk(WS2PConnectionState), + DalRequest(ModuleReqId, serde_json::Value), + PeerCard(serde_json::Value, Vec), + Heads(Vec), + Document(BlockchainDocument), + ReqResponse(ModuleReqId, serde_json::Value), + InvalidMessage, + WrongFormatMessage, + UnknowMessage, + Timeout, + Close, +} + +pub fn generate_connect_message( + currency: &str, + key_pair: KeyPairEnum, + challenge: String, +) -> Message { + // Create CONNECT Message + let mut connect_message = WS2PConnectMessageV1 { + currency: String::from(currency), + pubkey: key_pair.public_key(), + challenge, + signature: None, + }; + connect_message.signature = Some(connect_message.sign(key_pair)); + Message::text( + serde_json::to_string(&connect_message).expect("Fail to serialize CONNECT message !"), + ) +} + +pub fn ws2p_conn_message_pretreatment( + ws2p_module: &mut WS2PModule, + message: WS2PConnectionMessage, +) -> WS2PSignal { + let ws2p_full_id = message.0; + match message.1 { + WS2PConnectionMessagePayload::WrongUrl + | WS2PConnectionMessagePayload::FailOpenWS + | WS2PConnectionMessagePayload::FailToSplitWS => { + let dal_ep = ws2p_module + .ws2p_endpoints + .get_mut(&ws2p_full_id) + .expect("WS2P: Fail to get mut ep !"); + dal_ep.state = WS2PConnectionState::WSError; + dal_ep.last_check = durs_common_tools::current_timestamp(); + return WS2PSignal::WSError(ws2p_full_id); + } + WS2PConnectionMessagePayload::TryToSendConnectMess => { + ws2p_module + .ws2p_endpoints + .get_mut(&ws2p_full_id) + .expect("WS2P: Fail to get mut ep !") + .state = WS2PConnectionState::TryToSendConnectMess; + } + WS2PConnectionMessagePayload::FailSendConnectMess => { + let dal_ep = ws2p_module + .ws2p_endpoints + .get_mut(&ws2p_full_id) + .expect("WS2P: Fail to get mut ep !"); + dal_ep.state = WS2PConnectionState::Unreachable; + dal_ep.last_check = durs_common_tools::current_timestamp(); + } + WS2PConnectionMessagePayload::WebsocketOk(sender) => { + ws2p_module.websockets.insert(ws2p_full_id, sender); + } + WS2PConnectionMessagePayload::ValidConnectMessage(response, new_con_state) => { + ws2p_module + .ws2p_endpoints + .get_mut(&ws2p_full_id) + .expect("WS2P: Fail to get mut ep !") + .state = new_con_state; + debug!("Send: {:#?}", response); + if let Some(websocket) = ws2p_module.websockets.get_mut(&ws2p_full_id) { + if websocket.0.send(Message::text(response)).is_err() { + return WS2PSignal::WSError(ws2p_full_id); + } + } else { + // Connection closed by remote peer + let dal_ep = ws2p_module + .ws2p_endpoints + .get_mut(&ws2p_full_id) + .expect("WS2P: Fail to get mut ep !"); + dal_ep.state = WS2PConnectionState::Close; + dal_ep.last_check = durs_common_tools::current_timestamp(); + } + } + WS2PConnectionMessagePayload::ValidAckMessage(response, new_con_state) => { + ws2p_module + .ws2p_endpoints + .get_mut(&ws2p_full_id) + .expect("WS2P: Fail to get mut ep !") + .state = new_con_state; + if let WS2PConnectionState::AckMessOk = ws2p_module.ws2p_endpoints[&ws2p_full_id].state + { + debug!("Send: {:#?}", response); + if let Some(websocket) = ws2p_module.websockets.get_mut(&ws2p_full_id) { + if websocket.0.send(Message::text(response)).is_err() { + return WS2PSignal::WSError(ws2p_full_id); + } + } else { + fatal_error!("Fatal error : no websocket for {} !", ws2p_full_id); + } + } + } + WS2PConnectionMessagePayload::ValidOk(new_con_state) => { + ws2p_module + .ws2p_endpoints + .get_mut(&ws2p_full_id) + .expect("WS2P: Fail to get mut ep !") + .state = new_con_state; + let mut close_conn = false; + let signal = match ws2p_module.ws2p_endpoints[&ws2p_full_id].state { + WS2PConnectionState::OkMessOkWaitingAckMess => WS2PSignal::Empty, + WS2PConnectionState::Established => WS2PSignal::ConnectionEstablished(ws2p_full_id), + _ => { + close_conn = true; + WS2PSignal::Empty + } + }; + if close_conn { + close_connection( + ws2p_module, + &ws2p_full_id, + WS2PCloseConnectionReason::Unknow, + ); + } + + return signal; + } + WS2PConnectionMessagePayload::DalRequest(req_id, req_body) => { + return WS2PSignal::DalRequest(ws2p_full_id, req_id, req_body); + } + WS2PConnectionMessagePayload::PeerCard(body, ws2p_endpoints) => { + return WS2PSignal::PeerCard(ws2p_full_id, body, ws2p_endpoints); + } + WS2PConnectionMessagePayload::Heads(heads) => { + let mut applied_heads = Vec::with_capacity(heads.len()); + for head in heads { + if let Ok(head) = NetworkHead::from_json_value(&head) { + if head.verify() + && (ws2p_module.my_head.is_none() + || head.node_full_id() + != ws2p_module + .my_head + .clone() + .expect("WS2P: Fail to clone my_head") + .node_full_id()) + && head.apply(&mut ws2p_module.heads_cache) + { + applied_heads.push(head); + } + } + } + return WS2PSignal::Heads(ws2p_full_id, applied_heads); + } + WS2PConnectionMessagePayload::Document(network_doc) => { + return WS2PSignal::Document(ws2p_full_id, network_doc); + } + WS2PConnectionMessagePayload::ReqResponse(req_id, response) => { + if ws2p_module.requests_awaiting_response.len() > req_id.0 as usize { + if let Some((ref ws2p_request, ref recipient_fulld_id, ref _timestamp)) = + ws2p_module.requests_awaiting_response.remove(&req_id) + { + return WS2PSignal::ReqResponse( + req_id, + *ws2p_request, + *recipient_fulld_id, + response, + ); + } + } + } + WS2PConnectionMessagePayload::NegociationTimeout => { + match ws2p_module.ws2p_endpoints[&ws2p_full_id].state { + WS2PConnectionState::AckMessOk | WS2PConnectionState::ConnectMessOk => { + ws2p_module + .ws2p_endpoints + .get_mut(&ws2p_full_id) + .expect("WS2P: Fail to get mut ep !") + .state = WS2PConnectionState::Denial + } + WS2PConnectionState::WaitingConnectMess => { + ws2p_module + .ws2p_endpoints + .get_mut(&ws2p_full_id) + .expect("WS2P: Fail to get mut ep !") + .state = WS2PConnectionState::NoResponse + } + _ => { + let dal_ep = ws2p_module + .ws2p_endpoints + .get_mut(&ws2p_full_id) + .expect("WS2P: Fail to get mut ep !"); + dal_ep.state = WS2PConnectionState::Unreachable; + dal_ep.last_check = durs_common_tools::current_timestamp(); + } + } + close_connection( + ws2p_module, + &ws2p_full_id, + WS2PCloseConnectionReason::NegociationTimeout, + ); + return WS2PSignal::NegociationTimeout(ws2p_full_id); + } + WS2PConnectionMessagePayload::Timeout => { + close_connection( + ws2p_module, + &ws2p_full_id, + WS2PCloseConnectionReason::Timeout, + ); + return WS2PSignal::Timeout(ws2p_full_id); + } + WS2PConnectionMessagePayload::UnknowMessage => { + warn!("WS2P : Receive Unknow Message from {}.", &ws2p_full_id.1) + } + WS2PConnectionMessagePayload::WrongFormatMessage => warn!( + "WS2P : Receive Wrong Format Message from {}.", + &ws2p_full_id.1 + ), + WS2PConnectionMessagePayload::InvalidMessage => return WS2PSignal::Empty, + WS2PConnectionMessagePayload::Close => close_connection( + ws2p_module, + &ws2p_full_id, + WS2PCloseConnectionReason::AuthMessInvalidSig, + ), + } + let connections_count = ws2p_module.websockets.len(); + if connections_count == 0 { + return WS2PSignal::NoConnection; + } + // Detect timeout requests + let mut requests_timeout = Vec::new(); + for &(ref req, ref ws2p_full_id, ref timestamp) in + ws2p_module.requests_awaiting_response.clone().values() + { + if unwrap!(SystemTime::now().duration_since(*timestamp)) > Duration::new(20, 0) { + requests_timeout.push(req.get_req_full_id()); + warn!("request timeout : {:?} (sent to {:?})", req, ws2p_full_id); + } + } + // Delete (and resend) timeout requests + for req_id in requests_timeout { + //let ws2p_endpoints = ws2p_module.ws2p_endpoints.clone(); + let _request_option = ws2p_module.requests_awaiting_response.remove(&req_id.1); + /*if let Some((request, _, _)) = request_option { + let _request_result = ws2p_module.send_request_to_specific_node( + &get_random_connection(&ws2p_endpoints), + &request, + ); + }*/ + } + WS2PSignal::Empty +} diff --git a/lib/modules/ws2p-v1-legacy/src/ws2p_connection.rs b/lib/modules/ws2p-v1-legacy/src/ws_connections/meta_datas.rs similarity index 52% rename from lib/modules/ws2p-v1-legacy/src/ws2p_connection.rs rename to lib/modules/ws2p-v1-legacy/src/ws_connections/meta_datas.rs index c25f3f60..e5b8950d 100644 --- a/lib/modules/ws2p-v1-legacy/src/ws2p_connection.rs +++ b/lib/modules/ws2p-v1-legacy/src/ws_connections/meta_datas.rs @@ -1,4 +1,22 @@ -use crate::constants::*; +// Copyright (C) 2018 The Durs Project Developers. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +//! WS2P connections meta datas. + +use super::messages::WS2PConnectionMessagePayload; +use super::states::WS2PConnectionState; use crate::parsers::blocks::parse_json_block; use crate::*; use duniter_module::ModuleReqId; @@ -6,294 +24,7 @@ use duniter_network::documents::BlockchainDocument; use dup_crypto::keys::*; use durs_network_documents::network_endpoint::{EndpointV1, NetworkEndpointApi}; use durs_network_documents::NodeId; -use rand::Rng; -use std::sync::mpsc; -use ws::deflate::DeflateBuilder; -#[allow(deprecated)] -use ws::util::{Timeout, Token}; -use ws::{connect, CloseCode, Frame, Handler, Handshake, Message, Sender}; - -const CONNECT: Token = Token(1); -const EXPIRE: Token = Token(2); - -/// Store a websocket sender -pub struct WsSender(pub Sender); - -impl ::std::fmt::Debug for WsSender { - fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - write!(f, "WsSender {{ }}") - } -} - -// Our Handler struct. -// Here we explicity indicate that the Client needs a Sender, -// whereas a closure captures the Sender for us automatically. #[allow(deprecated)] -struct Client { - ws: Sender, - conductor_sender: mpsc::Sender, - currency: String, - key_pair: KeyPairEnum, - connect_message: Message, - conn_meta_datas: WS2PConnectionMetaDatas, - last_mess_time: SystemTime, - spam_interval: bool, - spam_counter: usize, - timeout: Option, -} - -// We implement the Handler trait for Client so that we can get more -// fine-grained control of the connection. -impl Handler for Client { - // `on_open` will be called only after the WebSocket handshake is successful - // so at this point we know that the connection is ready to send/receive messages. - // We ignore the `Handshake` for now, but you could also use this method to setup - // Handler state or reject the connection based on the details of the Request - // or Response, such as by checking cookies or Auth headers. - fn on_open(&mut self, _: Handshake) -> ws::Result<()> { - // Define timeouts - self.ws.timeout(WS2P_NEGOTIATION_TIMEOUT * 1_000, CONNECT)?; - self.ws.timeout(WS2P_EXPIRE_TIMEOUT * 1_000, EXPIRE)?; - // Send ws::Sender to WS2PConductor - let result = self - .conductor_sender - .send(WS2PThreadSignal::WS2PConnectionMessage( - WS2PConnectionMessage( - self.conn_meta_datas.node_full_id(), - WS2PConnectionMessagePayload::WebsocketOk(WsSender(self.ws.clone())), - ), - )); - // If WS2PConductor is unrechable, close connection. - if result.is_err() { - debug!("Close ws2p connection because ws2p main thread is unrechable !"); - self.ws.close(CloseCode::Normal) - } else { - // Send CONNECT Message - self.ws.send(self.connect_message.clone()) - } - } - - // `on_message` is roughly equivalent to the Handler closure. It takes a `Message` - // and returns a `Result<()>`. - fn on_message(&mut self, msg: Message) -> ws::Result<()> { - // Spam ? - if SystemTime::now() - .duration_since(self.last_mess_time) - .unwrap() - > Duration::new(*WS2P_SPAM_INTERVAL_IN_MILLI_SECS, 0) - { - if self.spam_interval { - self.spam_counter += 1; - } else { - self.spam_interval = true; - self.spam_counter = 2; - } - } else { - self.spam_interval = false; - self.spam_counter = 0; - } - // Spam ? - if self.spam_counter >= *WS2P_SPAM_LIMIT { - thread::sleep(Duration::from_millis(*WS2P_SPAM_SLEEP_TIME_IN_SEC)); - self.last_mess_time = SystemTime::now(); - return Ok(()); - } - self.last_mess_time = SystemTime::now(); - - // Parse and check incoming message - if msg.is_text() { - let s: String = msg - .into_text() - .expect("WS2P: Fail to convert message payload to String !"); - trace!("WS2P: receive mess: {}", s); - let json_message: serde_json::Value = serde_json::from_str(&s) - .expect("WS2P: Fail to convert string message ton json value !"); - let result = self - .conductor_sender - .send(WS2PThreadSignal::WS2PConnectionMessage( - WS2PConnectionMessage( - self.conn_meta_datas.node_full_id(), - self.conn_meta_datas.parse_and_check_incoming_message( - &self.currency, - self.key_pair, - &json_message, - ), - ), - )); - if result.is_err() { - info!("Close ws2p connection because ws2p main thread is unrechable !"); - self.ws.close(CloseCode::Normal)?; - } - } - Ok(()) - } - fn on_timeout(&mut self, event: Token) -> ws::Result<()> { - match event { - CONNECT => { - if self.conn_meta_datas.state != WS2PConnectionState::Established { - let _result = - self.conductor_sender - .send(WS2PThreadSignal::WS2PConnectionMessage( - WS2PConnectionMessage( - self.conn_meta_datas.node_full_id(), - WS2PConnectionMessagePayload::NegociationTimeout, - ), - )); - self.ws.close(CloseCode::Away) - } else { - Ok(()) - } - } - EXPIRE => { - let _result = self - .conductor_sender - .send(WS2PThreadSignal::WS2PConnectionMessage( - WS2PConnectionMessage( - self.conn_meta_datas.node_full_id(), - WS2PConnectionMessagePayload::Timeout, - ), - )); - self.ws.close(CloseCode::Away) - } - _ => Ok(()), - } - } - #[allow(deprecated)] - fn on_new_timeout(&mut self, event: Token, timeout: Timeout) -> ws::Result<()> { - if event == EXPIRE { - if let Some(t) = self.timeout.take() { - self.ws.cancel(t)?; - } - self.timeout = Some(timeout) - } - Ok(()) - } - fn on_frame(&mut self, frame: Frame) -> ws::Result> { - // some activity has occurred, let's reset the expiration timeout - self.ws.timeout(WS2P_EXPIRE_TIMEOUT * 1_000, EXPIRE)?; - Ok(Some(frame)) - } - fn on_close(&mut self, code: CloseCode, reason: &str) { - // The WebSocket protocol allows for a utf8 reason for the closing state after the - // close code. WS-RS will attempt to interpret this data as a utf8 description of the - // reason for closing the connection. I many cases, `reason` will be an empty string. - // So, you may not normally want to display `reason` to the user, - // but let's assume that we know that `reason` is human-readable. - match code { - CloseCode::Normal => info!("The remote server close the connection."), - CloseCode::Away => info!("The remote server is leaving."), - _ => warn!("The remote server encountered an error: {}", reason), - } - let _result = self - .conductor_sender - .send(WS2PThreadSignal::WS2PConnectionMessage( - WS2PConnectionMessage( - self.conn_meta_datas.node_full_id(), - WS2PConnectionMessagePayload::Close, - ), - )); - } -} - -#[derive(Debug, Copy, Clone)] -pub enum WS2POrderForListeningThread { - Close, -} - -#[derive(Debug, Copy, Clone, PartialEq)] -pub enum WS2PConnectionState { - NeverTry = 0, - TryToOpenWS = 1, - WSError = 2, - TryToSendConnectMess = 3, - Unreachable = 4, - WaitingConnectMess = 5, - NoResponse = 6, - ConnectMessOk = 7, - OkMessOkWaitingAckMess = 8, - AckMessOk = 9, - Denial = 10, - Close = 11, - Established = 12, -} - -impl From for WS2PConnectionState { - fn from(integer: u32) -> Self { - match integer { - 1 | 2 => WS2PConnectionState::WSError, - 3 | 4 => WS2PConnectionState::Unreachable, - 5 | 6 => WS2PConnectionState::NoResponse, - 7 | 8 | 9 | 10 => WS2PConnectionState::Denial, - 11 | 12 => WS2PConnectionState::Close, - _ => WS2PConnectionState::NeverTry, - } - } -} - -impl WS2PConnectionState { - pub fn from_u32(integer: u32, from_db: bool) -> Self { - if from_db { - WS2PConnectionState::from(integer) - } else { - match integer { - 1 => WS2PConnectionState::TryToOpenWS, - 2 => WS2PConnectionState::WSError, - 3 | 4 => WS2PConnectionState::Unreachable, - 5 | 6 => WS2PConnectionState::NoResponse, - 7 => WS2PConnectionState::ConnectMessOk, - 8 => WS2PConnectionState::OkMessOkWaitingAckMess, - 9 => WS2PConnectionState::AckMessOk, - 10 => WS2PConnectionState::Denial, - 11 => WS2PConnectionState::Close, - 12 => WS2PConnectionState::Established, - _ => WS2PConnectionState::NeverTry, - } - } - } - pub fn to_u32(self) -> u32 { - match self { - WS2PConnectionState::NeverTry => 0, - _ => 1, - } - } -} - -#[derive(Debug)] -pub enum WS2PConnectionMessagePayload { - FailOpenWS, - WrongUrl, - FailToSplitWS, - TryToSendConnectMess, - FailSendConnectMess, - WebsocketOk(WsSender), - NegociationTimeout, - ValidConnectMessage(String, WS2PConnectionState), - ValidAckMessage(String, WS2PConnectionState), - ValidOk(WS2PConnectionState), - DalRequest(ModuleReqId, serde_json::Value), - PeerCard(serde_json::Value, Vec), - Heads(Vec), - Document(BlockchainDocument), - ReqResponse(ModuleReqId, serde_json::Value), - InvalidMessage, - WrongFormatMessage, - UnknowMessage, - Timeout, - Close, -} - -#[derive(Debug)] -pub struct WS2PConnectionMessage(pub NodeFullId, pub WS2PConnectionMessagePayload); - -#[derive(Debug, Copy, Clone, PartialEq)] -pub enum WS2PCloseConnectionReason { - AuthMessInvalidSig, - NegociationTimeout, - Timeout, - WsError, - Unknow, -} - #[derive(Debug, Clone)] pub struct WS2PConnectionMetaDatas { pub state: WS2PConnectionState, @@ -304,13 +35,6 @@ pub struct WS2PConnectionMetaDatas { pub current_blockstamp: Option<(u32, String)>, } -#[derive(Debug, Clone)] -pub struct WS2PDatasForListeningThread { - pub conn_meta_datas: WS2PConnectionMetaDatas, - pub currency: String, - pub key_pair: KeyPairEnum, -} - impl WS2PConnectionMetaDatas { pub fn new(challenge: String) -> Self { WS2PConnectionMetaDatas { @@ -340,11 +64,11 @@ impl WS2PConnectionMetaDatas { ) -> WS2PConnectionMessagePayload { if let Some(s) = m.get("auth") { if s.is_string() { - match s.as_str().unwrap() { + match s.as_str().unwrap_or("") { "CONNECT" => { let message = WS2PConnectMessageV1::parse(m, currency.to_string()) .expect("Failed to parsing CONNECT Message !"); - if message.verify() && message.pubkey == self.remote_pubkey.unwrap() { + if message.verify() && message.pubkey == unwrap!(self.remote_pubkey) { match self.state { WS2PConnectionState::WaitingConnectMess => { debug!("CONNECT sig is valid."); @@ -358,7 +82,7 @@ impl WS2PConnectionMetaDatas { }; response.signature = Some(response.sign(key_pair)); return WS2PConnectionMessagePayload::ValidConnectMessage( - serde_json::to_string(&response).unwrap(), + unwrap!(serde_json::to_string(&response)), self.state, ); } @@ -391,7 +115,7 @@ impl WS2PConnectionMetaDatas { }; response.signature = Some(response.sign(key_pair)); return WS2PConnectionMessagePayload::ValidAckMessage( - serde_json::to_string(&response).unwrap(), + unwrap!(serde_json::to_string(&response)), self.state, ); } else { @@ -483,7 +207,7 @@ impl WS2PConnectionMetaDatas { match body.get("name") { Some(s) => { if s.is_string() { - match s.as_str().unwrap() { + match s.as_str().unwrap_or("") { "BLOCK" => match body.get("block") { Some(block) => { if let Some(block_doc) = parse_json_block(&block) { @@ -584,85 +308,3 @@ impl WS2PConnectionMetaDatas { } } } - -pub fn get_random_connection( - connections: &HashMap, -) -> NodeFullId { - let mut rng = rand::thread_rng(); - let mut loop_count = 0; - loop { - for (ws2p_full_id, (_ep, state)) in &(*connections) { - if loop_count > 10 { - return *ws2p_full_id; - } - if let WS2PConnectionState::Established = state { - if rng.gen::() { - return *ws2p_full_id; - } - } - } - loop_count += 1; - } -} - -pub fn connect_to_ws2p_endpoint( - endpoint: &EndpointV1, - conductor_sender: &mpsc::Sender, - currency: &str, - key_pair: KeyPairEnum, -) -> ws::Result<()> { - // Get endpoint url - let ws_url = endpoint.get_url(true, false).expect("Endpoint unreachable"); - - // Create WS2PConnectionMetaDatass - let mut conn_meta_datas = WS2PConnectionMetaDatas::new( - "b60a14fd-0826-4ae0-83eb-1a92cd59fd5308535fd3-78f2-4678-9315-cd6e3b7871b1".to_string(), - ); - conn_meta_datas.remote_pubkey = Some(endpoint.issuer); - conn_meta_datas.remote_uuid = Some( - endpoint - .node_id - .expect("WS2P: Fail to get ep.node_uuid() !"), - ); - - // Generate connect message - let connect_message = - generate_connect_message(currency, key_pair, conn_meta_datas.challenge.clone()); - - // Log - info!("WS2P: Try connection to {} ...", ws_url); - - // Connect to websocket - connect(ws_url, |ws| { - DeflateBuilder::new().build(Client { - ws, - conductor_sender: conductor_sender.clone(), - currency: String::from(currency), - key_pair, - connect_message: connect_message.clone(), - conn_meta_datas: conn_meta_datas.clone(), - last_mess_time: SystemTime::now(), - spam_interval: false, - spam_counter: 0, - timeout: None, - }) - }) -} - -pub fn generate_connect_message( - currency: &str, - key_pair: KeyPairEnum, - challenge: String, -) -> Message { - // Create CONNECT Message - let mut connect_message = WS2PConnectMessageV1 { - currency: String::from(currency), - pubkey: key_pair.public_key(), - challenge, - signature: None, - }; - connect_message.signature = Some(connect_message.sign(key_pair)); - Message::text( - serde_json::to_string(&connect_message).expect("Fail to serialize CONNECT message !"), - ) -} diff --git a/lib/modules/ws2p-v1-legacy/src/ws_connections/mod.rs b/lib/modules/ws2p-v1-legacy/src/ws_connections/mod.rs new file mode 100644 index 00000000..f18a33b9 --- /dev/null +++ b/lib/modules/ws2p-v1-legacy/src/ws_connections/mod.rs @@ -0,0 +1,184 @@ +// Copyright (C) 2018 The Durs Project Developers. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +//! Manage websockets connections. + +pub mod handler; +pub mod messages; +mod meta_datas; +pub mod requests; +pub mod states; + +use crate::*; +use duniter_module::ModuleReqId; +use duniter_network::documents::BlockchainDocument; +use dup_crypto::keys::*; +use durs_network_documents::network_endpoint::EndpointV1; +use rand::Rng; +use states::WS2PConnectionState; +use std::collections::HashSet; +#[allow(deprecated)] +use ws::Sender; + +/// Store a websocket sender +pub struct WsSender(pub Sender); + +impl ::std::fmt::Debug for WsSender { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + write!(f, "WsSender {{ }}") + } +} + +#[derive(Debug, Copy, Clone, PartialEq)] +pub enum WS2PCloseConnectionReason { + AuthMessInvalidSig, + NegociationTimeout, + Timeout, + WsError, + Unknow, +} + +pub fn connect_to_know_endpoints(ws2p_module: &mut WS2PModule) { + info!("WS2P: connect to know endpoints..."); + let mut count_established_connections = 0; + let mut pubkeys = HashSet::new(); + let mut reachable_endpoints = Vec::new(); + let mut unreachable_endpoints = Vec::new(); + for (_ws2p_full_id, DbEndpoint { ep, state, .. }) in ws2p_module.ws2p_endpoints.clone() { + if ep.issuer == ws2p_module.key_pair.public_key() || !pubkeys.contains(&ep.issuer) { + match state { + WS2PConnectionState::Established => count_established_connections += 1, + WS2PConnectionState::NeverTry + | WS2PConnectionState::Close + | WS2PConnectionState::Denial => { + pubkeys.insert(ep.issuer); + reachable_endpoints.push(ep); + } + _ => { + pubkeys.insert(ep.issuer); + unreachable_endpoints.push(ep); + } + } + } + } + let mut free_outcoming_rooms = + ws2p_module.conf.clone().outcoming_quota - count_established_connections; + while free_outcoming_rooms > 0 { + let ep = if !reachable_endpoints.is_empty() { + reachable_endpoints + .pop() + .expect("WS2P: Fail to pop() reachable_endpoints !") + } else if !unreachable_endpoints.is_empty() { + unreachable_endpoints + .pop() + .expect("WS2P: Fail to pop() unreachable_endpoints !") + } else { + break; + }; + if !ws2p_module.ssl && ep.port == 443 { + continue; + } + connect_to_without_checking_quotas(ws2p_module, unwrap!(ep.node_full_id())); + free_outcoming_rooms -= 1; + } +} + +pub fn connect_to(ws2p_module: &mut WS2PModule, ep: &EndpointV1) { + // Add endpoint to endpoints list (if there isn't already) + let node_full_id = ep + .node_full_id() + .expect("WS2P: Fail to get ep.node_full_id() !"); + ws2p_module + .ws2p_endpoints + .entry(node_full_id) + .or_insert(DbEndpoint { + ep: ep.clone(), + state: WS2PConnectionState::NeverTry, + last_check: 0, + }); + let count_established_connections = count_established_connections(&ws2p_module); + if ws2p_module.conf.outcoming_quota > count_established_connections { + connect_to_without_checking_quotas(ws2p_module, node_full_id); + } +} + +pub fn connect_to_without_checking_quotas(ws2p_module: &mut WS2PModule, node_full_id: NodeFullId) { + let endpoint = unwrap!(ws2p_module.ws2p_endpoints.get(&node_full_id)); + let endpoint_copy = endpoint.ep.clone(); + let conductor_sender_copy = ws2p_module.main_thread_channel.0.clone(); + let currency_copy = ws2p_module.currency.clone(); + let key_pair_copy = ws2p_module.key_pair; + thread::spawn(move || { + let _result = crate::ws_connections::handler::connect_to_ws2p_endpoint( + &endpoint_copy, + &conductor_sender_copy, + ¤cy_copy.expect("WS2PError : No currency !"), + key_pair_copy, + ); + }); +} + +pub fn close_connection( + ws2p_module: &mut WS2PModule, + ws2p_full_id: &NodeFullId, + reason: WS2PCloseConnectionReason, +) { + match reason { + WS2PCloseConnectionReason::NegociationTimeout => {} + WS2PCloseConnectionReason::AuthMessInvalidSig + | WS2PCloseConnectionReason::Timeout + | WS2PCloseConnectionReason::WsError + | WS2PCloseConnectionReason::Unknow => { + if let Some(dal_ep) = ws2p_module.ws2p_endpoints.get_mut(ws2p_full_id) { + dal_ep.state = WS2PConnectionState::Close; + dal_ep.last_check = durs_common_tools::current_timestamp(); + } + } + } + if let Some(websocket) = ws2p_module.websockets.get(&ws2p_full_id) { + let _result = websocket.0.close(ws::CloseCode::Normal); + } + let _result = ws2p_module.websockets.remove(ws2p_full_id); +} + +pub fn get_random_connection( + connections: &HashMap, +) -> NodeFullId { + let mut rng = rand::thread_rng(); + let mut loop_count = 0; + loop { + for (ws2p_full_id, (_ep, state)) in &(*connections) { + if loop_count > 10 { + return *ws2p_full_id; + } + if let WS2PConnectionState::Established = state { + if rng.gen::() { + return *ws2p_full_id; + } + } + } + loop_count += 1; + } +} + +pub fn count_established_connections(ws2p_module: &WS2PModule) -> usize { + let mut count_established_connections = 0; + for DbEndpoint { state, .. } in ws2p_module.ws2p_endpoints.values() { + if let WS2PConnectionState::Established = state { + count_established_connections += 1; + } + } + count_established_connections +} diff --git a/lib/modules/ws2p-v1-legacy/src/ws_connections/requests/mod.rs b/lib/modules/ws2p-v1-legacy/src/ws_connections/requests/mod.rs new file mode 100644 index 00000000..3dbfe5e9 --- /dev/null +++ b/lib/modules/ws2p-v1-legacy/src/ws_connections/requests/mod.rs @@ -0,0 +1,19 @@ +// Copyright (C) 2018 The Duniter Project Developers. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +//! Sub-module managing the WS2Pv1 requests sent and received. + +pub mod received; +pub mod sent; diff --git a/lib/modules/ws2p-v1-legacy/src/ws_connections/requests/received.rs b/lib/modules/ws2p-v1-legacy/src/ws_connections/requests/received.rs new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/lib/modules/ws2p-v1-legacy/src/ws_connections/requests/received.rs @@ -0,0 +1 @@ + diff --git a/lib/modules/ws2p-v1-legacy/src/ws_connections/requests/sent.rs b/lib/modules/ws2p-v1-legacy/src/ws_connections/requests/sent.rs new file mode 100644 index 00000000..6a3b539b --- /dev/null +++ b/lib/modules/ws2p-v1-legacy/src/ws_connections/requests/sent.rs @@ -0,0 +1,77 @@ +// Copyright (C) 2018 The Durs Project Developers. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +//! Sub-module managing the WS2Pv1 requests sent. + +use crate::WS2PModule; +use duniter_network::requests::OldNetworkRequest; +use durs_network_documents::NodeFullId; +use std::time::SystemTime; +use ws::Message; + +pub fn send_request_to_specific_node( + ws2p_module: &mut WS2PModule, + ws2p_full_id: &NodeFullId, + ws2p_request: &OldNetworkRequest, +) -> ws::Result<()> { + if let Some(ws) = ws2p_module.websockets.get_mut(ws2p_full_id) { + let json_req = network_request_to_json(ws2p_request).to_string(); + debug!("send request {} to {}", json_req, ws2p_full_id); + ws.0.send(Message::text(json_req))?; + ws2p_module.requests_awaiting_response.insert( + ws2p_request.get_req_id(), + (*ws2p_request, *ws2p_full_id, SystemTime::now()), + ); + } else { + warn!("WS2P: Fail to get mut websocket !"); + } + Ok(()) +} + +pub fn network_request_to_json(request: &OldNetworkRequest) -> serde_json::Value { + let (request_id, request_type, request_params) = match *request { + OldNetworkRequest::GetCurrent(ref req_full_id) => (req_full_id.1, "CURRENT", json!({})), + OldNetworkRequest::GetBlocks(ref req_full_id, count, from_mumber) => ( + req_full_id.1, + "BLOCKS_CHUNK", + json!({ + "count": count, + "fromNumber": from_mumber + }), + ), + OldNetworkRequest::GetRequirementsPending(ref req_full_id, min_cert) => ( + req_full_id.1, + "WOT_REQUIREMENTS_OF_PENDING", + json!({ "minCert": min_cert }), + ), + OldNetworkRequest::GetConsensus(_) => { + panic!("GetConsensus() request must be not convert to json !"); + } + OldNetworkRequest::GetHeadsCache(_) => { + panic!("GetHeadsCache() request must be not convert to json !"); + } + OldNetworkRequest::GetEndpoints(_) => { + panic!("GetEndpoints() request must be not convert to json !"); + } + }; + + json!({ + "reqId": request_id, + "body" : { + "name": request_type, + "params": request_params + } + }) +} diff --git a/lib/modules/ws2p-v1-legacy/src/ws_connections/states.rs b/lib/modules/ws2p-v1-legacy/src/ws_connections/states.rs new file mode 100644 index 00000000..48e91425 --- /dev/null +++ b/lib/modules/ws2p-v1-legacy/src/ws_connections/states.rs @@ -0,0 +1,76 @@ +// Copyright (C) 2018 The Durs Project Developers. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +//! Define ws2p connections states. + +use serde::{Deserialize, Serialize}; + +#[derive(Copy, Clone, Debug, Deserialize, PartialEq, Serialize)] +pub enum WS2PConnectionState { + NeverTry = 0, + TryToOpenWS = 1, + WSError = 2, + TryToSendConnectMess = 3, + Unreachable = 4, + WaitingConnectMess = 5, + NoResponse = 6, + ConnectMessOk = 7, + OkMessOkWaitingAckMess = 8, + AckMessOk = 9, + Denial = 10, + Close = 11, + Established = 12, +} + +impl From for WS2PConnectionState { + fn from(integer: u32) -> Self { + match integer { + 1 | 2 => WS2PConnectionState::WSError, + 3 | 4 => WS2PConnectionState::Unreachable, + 5 | 6 => WS2PConnectionState::NoResponse, + 7 | 8 | 9 | 10 => WS2PConnectionState::Denial, + 11 | 12 => WS2PConnectionState::Close, + _ => WS2PConnectionState::NeverTry, + } + } +} + +impl WS2PConnectionState { + pub fn from_u32(integer: u32, from_db: bool) -> Self { + if from_db { + WS2PConnectionState::from(integer) + } else { + match integer { + 1 => WS2PConnectionState::TryToOpenWS, + 2 => WS2PConnectionState::WSError, + 3 | 4 => WS2PConnectionState::Unreachable, + 5 | 6 => WS2PConnectionState::NoResponse, + 7 => WS2PConnectionState::ConnectMessOk, + 8 => WS2PConnectionState::OkMessOkWaitingAckMess, + 9 => WS2PConnectionState::AckMessOk, + 10 => WS2PConnectionState::Denial, + 11 => WS2PConnectionState::Close, + 12 => WS2PConnectionState::Established, + _ => WS2PConnectionState::NeverTry, + } + } + } + pub fn to_u32(self) -> u32 { + match self { + WS2PConnectionState::NeverTry => 0, + _ => 1, + } + } +} -- GitLab From c5cfa20ca07f20a8d1f5a51812b3d1d66c40e155 Mon Sep 17 00:00:00 2001 From: librelois Date: Thu, 25 Apr 2019 00:56:20 +0200 Subject: [PATCH 5/5] [build] Update Cargo.lock --- Cargo.lock | 45 ++++++++++++--------------------------------- 1 file changed, 12 insertions(+), 33 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 4f80ede3..7462c888 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -457,7 +457,6 @@ dependencies = [ "pest_derive 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)", "pretty_assertions 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)", "serde 1.0.86 (registry+https://github.com/rust-lang/crates.io-index)", - "serde_derive 1.0.86 (registry+https://github.com/rust-lang/crates.io-index)", "serde_json 1.0.38 (registry+https://github.com/rust-lang/crates.io-index)", ] @@ -548,22 +547,23 @@ dependencies = [ name = "durs-ws2p-v1-legacy" version = "0.1.0-a0.1" dependencies = [ + "bincode 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)", "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)", "dubp-documents 0.12.0", "duniter-conf 0.1.0-a0.1", "duniter-module 0.1.0-a0.1", "duniter-network 0.1.0-a0.1", "dup-crypto 0.6.0", + "durs-common-tools 0.1.0", "durs-message 0.1.0-a0.1", "durs-network-documents 0.3.1", "durs-wot 0.8.0-a0.9", "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)", "rand 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)", "serde 1.0.86 (registry+https://github.com/rust-lang/crates.io-index)", - "serde_derive 1.0.86 (registry+https://github.com/rust-lang/crates.io-index)", "serde_json 1.0.38 (registry+https://github.com/rust-lang/crates.io-index)", - "sqlite 0.23.9 (registry+https://github.com/rust-lang/crates.io-index)", "structopt 0.2.14 (registry+https://github.com/rust-lang/crates.io-index)", + "unwrap 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)", "ws 0.7.9 (registry+https://github.com/rust-lang/crates.io-index)", ] @@ -1145,6 +1145,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index" name = "serde" version = "1.0.86" source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "serde_derive 1.0.86 (registry+https://github.com/rust-lang/crates.io-index)", +] [[package]] name = "serde_derive" @@ -1210,33 +1213,6 @@ name = "snowflake" version = "1.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -[[package]] -name = "sqlite" -version = "0.23.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -dependencies = [ - "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)", - "sqlite3-sys 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)", -] - -[[package]] -name = "sqlite3-src" -version = "0.2.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -dependencies = [ - "cc 1.0.28 (registry+https://github.com/rust-lang/crates.io-index)", - "pkg-config 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)", -] - -[[package]] -name = "sqlite3-sys" -version = "0.12.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -dependencies = [ - "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)", - "sqlite3-src 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)", -] - [[package]] name = "strsim" version = "0.7.0" @@ -1377,6 +1353,11 @@ dependencies = [ "void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)", ] +[[package]] +name = "unwrap" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" + [[package]] name = "url" version = "1.7.2" @@ -1571,9 +1552,6 @@ dependencies = [ "checksum slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "c111b5bd5695e56cffe5129854aa230b39c93a305372fdbb2668ca2394eea9f8" "checksum smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)" = "88aea073965ab29f6edb5493faf96ad662fb18aa9eeb186a3b7057951605ed15" "checksum snowflake 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "27207bb65232eda1f588cf46db2fee75c0808d557f6b3cf19a75f5d6d7c94df1" -"checksum sqlite 0.23.9 (registry+https://github.com/rust-lang/crates.io-index)" = "d18d7b10278336e7fd9dc259399a0f9ff419616738b6a841b136c362e16db626" -"checksum sqlite3-src 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)" = "62cd5d67c1eb94a2a019b8049f625f65ae7faee8f3c54f0197e5dbc68d5f698c" -"checksum sqlite3-sys 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)" = "71fec807a1534bd13eeaaec396175d67c79bdc68df55e18a452726ec62a8fb08" "checksum strsim 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bb4f380125926a99e52bc279241539c018323fab05ad6368b56f93d9369ff550" "checksum structopt 0.2.14 (registry+https://github.com/rust-lang/crates.io-index)" = "670ad348dc73012fcf78c71f06f9d942232cdd4c859d4b6975e27836c3efc0c3" "checksum structopt-derive 0.2.14 (registry+https://github.com/rust-lang/crates.io-index)" = "ef98172b1a00b0bec738508d3726540edcbd186d50dfd326f2b1febbb3559f04" @@ -1592,6 +1570,7 @@ dependencies = [ "checksum unicode-width 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "882386231c45df4700b275c7ff55b6f3698780a650026380e72dabe76fa46526" "checksum unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "fc72304796d0818e357ead4e000d19c9c174ab23dc11093ac919054d20a6a7fc" "checksum unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "382810877fe448991dfc7f0dd6e3ae5d58088fd0ea5e35189655f84e6814fa56" +"checksum unwrap 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7e33648dd74328e622c7be51f3b40a303c63f93e6fa5f08778b6203a4c25c20f" "checksum url 1.7.2 (registry+https://github.com/rust-lang/crates.io-index)" = "dd4e7c0d531266369519a4aa4f399d748bd37043b00bde1e4ff1f60a120b355a" "checksum vcpkg 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)" = "def296d3eb3b12371b2c7d0e83bfe1403e4db2d7a0bba324a12b21c4ee13143d" "checksum vec_map 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "05c78687fb1a80548ae3250346c3db86a80a7cdd77bda190189f2d0a0987c81a" -- GitLab