From 7bd8411904cac12d7b3d5ee1bf6bd04104c6f595 Mon Sep 17 00:00:00 2001 From: utkarshg6 Date: Thu, 6 Apr 2023 14:59:27 +0530 Subject: [PATCH 01/56] GH-690: add boilerplate for --min-hops command --- masq/src/commands/min_hops_command.rs | 1 + masq/src/commands/mod.rs | 1 + 2 files changed, 2 insertions(+) create mode 100644 masq/src/commands/min_hops_command.rs diff --git a/masq/src/commands/min_hops_command.rs b/masq/src/commands/min_hops_command.rs new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/masq/src/commands/min_hops_command.rs @@ -0,0 +1 @@ + diff --git a/masq/src/commands/mod.rs b/masq/src/commands/mod.rs index 44026ebf8..82f8aa94b 100644 --- a/masq/src/commands/mod.rs +++ b/masq/src/commands/mod.rs @@ -9,6 +9,7 @@ pub mod crash_command; pub mod descriptor_command; pub mod financials_command; pub mod generate_wallets_command; +pub mod min_hops_command; pub mod recover_wallets_command; pub mod scan_command; pub mod set_configuration_command; From 065f0aa170d8ac5d27d044dbdc6b42f7e294fb8e Mon Sep 17 00:00:00 2001 From: utkarshg6 Date: Thu, 6 Apr 2023 15:04:12 +0530 Subject: [PATCH 02/56] GH-690: populate necessary code for the command --- masq/src/command_factory.rs | 5 + masq/src/commands/min_hops_command.rs | 156 ++++++++++++++++++++++++++ masq_lib/src/messages.rs | 11 ++ 3 files changed, 172 insertions(+) diff --git a/masq/src/command_factory.rs b/masq/src/command_factory.rs index 21222c454..7310e06c0 100644 --- a/masq/src/command_factory.rs +++ b/masq/src/command_factory.rs @@ -10,6 +10,7 @@ use crate::commands::crash_command::CrashCommand; use crate::commands::descriptor_command::DescriptorCommand; use crate::commands::financials_command::FinancialsCommand; use crate::commands::generate_wallets_command::GenerateWalletsCommand; +use crate::commands::min_hops_command::MinHopsSubCommand; use crate::commands::recover_wallets_command::RecoverWalletsCommand; use crate::commands::scan_command::ScanCommand; use crate::commands::set_configuration_command::SetConfigurationCommand; @@ -60,6 +61,10 @@ impl CommandFactory for CommandFactoryReal { Ok(command) => Box::new(command), Err(msg) => return Err(CommandSyntax(msg)), }, + "min-hops" => match MinHopsSubCommand::new(pieces) { + Ok(command) => Box::new(command), + Err(msg) => return Err(CommandSyntax(msg)), + }, "recover-wallets" => match RecoverWalletsCommand::new(pieces) { Ok(command) => Box::new(command), Err(msg) => return Err(CommandSyntax(msg)), diff --git a/masq/src/commands/min_hops_command.rs b/masq/src/commands/min_hops_command.rs index 8b1378917..4075316f4 100644 --- a/masq/src/commands/min_hops_command.rs +++ b/masq/src/commands/min_hops_command.rs @@ -1 +1,157 @@ +// Copyright (c) 2019, MASQ (https://masq.ai) and/or its affiliates. All rights reserved. +use crate::command_context::CommandContext; +use crate::commands::commands_common::{ + transaction, Command, CommandError, STANDARD_COMMAND_TIMEOUT_MILLIS, +}; +use clap::{App, Arg, SubCommand}; +use masq_lib::messages::{UiSetMinHopsRequest, UiSetMinHopsResponse}; +use std::fmt::Debug; + +#[derive(Debug)] +pub struct MinHopsSubCommand { + value: u8, +} + +const MIN_HOPS_ABOUT: &str = "Sets the value of the minimum hops count in Node."; +const MIN_HOPS_HELP: &str = "Enter the count as an argument. 3-hops is required for anonymity."; + +pub fn min_hops_subcommand() -> App<'static, 'static> { + SubCommand::with_name("min-hops").about(MIN_HOPS_ABOUT).arg( + Arg::with_name("value") + .help(MIN_HOPS_HELP) + .index(1) + .possible_values(&["1", "2", "3", "4", "5", "6"]) + .required(true), + ) +} + +impl Command for MinHopsSubCommand { + fn execute(&self, context: &mut dyn CommandContext) -> Result<(), CommandError> { + let input = UiSetMinHopsRequest { + min_hops_count: self.value, + }; + let result = transaction::( + input, + context, + STANDARD_COMMAND_TIMEOUT_MILLIS, + ); + match result { + Ok(_response) => Ok(()), + Err(e) => Err(e), + } + } +} + +impl MinHopsSubCommand { + pub fn new(pieces: &[String]) -> Result { + let matches = match min_hops_subcommand().get_matches_from_safe(pieces) { + Ok(matches) => matches, + Err(e) => return Err(format!("{}", e)), + }; + let input_string = matches + .value_of("value") + .expect("value parameter is not properly required"); + let value: u8 = match input_string { + "1" => 1, + "2" => 2, + "3" => 3, + "4" => 4, + "5" => 5, + "6" => 6, + _ => panic!("Invalid input string!"), + }; + + Ok(Self { value }) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::command_context::ContextError; + use crate::command_factory::{CommandFactory, CommandFactoryReal}; + use crate::test_utils::mocks::CommandContextMock; + use masq_lib::messages::{ToMessageBody, UiSetMinHopsResponse}; + use std::sync::{Arc, Mutex}; + + #[test] + fn constants_have_correct_values() { + assert_eq!( + MIN_HOPS_ABOUT, + "Sets the value of the minimum hops count in Node." + ); + assert_eq!( + MIN_HOPS_HELP, + "Enter the count as an argument. 3-hops is required for anonymity." + ); + } + + #[test] + fn testing_command_factory_here() { + let factory = CommandFactoryReal::new(); + let mut context = + CommandContextMock::new().transact_result(Ok(UiSetMinHopsResponse {}.tmb(0))); + let subject = factory + .make(&["min-hops".to_string(), "3".to_string()]) + .unwrap(); + + let result = subject.execute(&mut context); + + assert_eq!(result, Ok(())); + } + + #[test] + fn min_hops_subcommand_works() { + min_hops_subcommand_works_for_value(1); + min_hops_subcommand_works_for_value(2); + min_hops_subcommand_works_for_value(3); + min_hops_subcommand_works_for_value(4); + min_hops_subcommand_works_for_value(5); + min_hops_subcommand_works_for_value(6); + } + + fn min_hops_subcommand_works_for_value(value: u8) { + let transact_params_arc = Arc::new(Mutex::new(vec![])); + let mut context = CommandContextMock::new() + .transact_params(&transact_params_arc) + .transact_result(Ok(UiSetMinHopsResponse {}.tmb(0))); + let stdout_arc = context.stdout_arc(); + let stderr_arc = context.stderr_arc(); + let factory = CommandFactoryReal::new(); + let subject = factory + .make(&["min-hops".to_string(), value.to_string()]) + .unwrap(); + + let result = subject.execute(&mut context); + + assert_eq!(result, Ok(())); + assert_eq!(stdout_arc.lock().unwrap().get_string(), String::new()); + assert_eq!(stderr_arc.lock().unwrap().get_string(), String::new()); + let transact_params = transact_params_arc.lock().unwrap(); + assert_eq!( + *transact_params, + vec![( + UiSetMinHopsRequest { + min_hops_count: value + } + .tmb(0), + STANDARD_COMMAND_TIMEOUT_MILLIS + )] + ) + } + + #[test] + fn scan_command_handles_send_failure() { + let mut context = CommandContextMock::new() + .transact_result(Err(ContextError::ConnectionDropped("blah".to_string()))); + let subject = MinHopsSubCommand::new(&["min-hops".to_string(), "3".to_string()]).unwrap(); + + let result = subject.execute(&mut context); + + assert_eq!( + result, + Err(CommandError::ConnectionProblem("blah".to_string())) + ) + } +} diff --git a/masq_lib/src/messages.rs b/masq_lib/src/messages.rs index 412076e0d..1b3e6e4c5 100644 --- a/masq_lib/src/messages.rs +++ b/masq_lib/src/messages.rs @@ -806,6 +806,17 @@ conversation_message!(UiScanRequest, "scan"); pub struct UiScanResponse {} conversation_message!(UiScanResponse, "scan"); +#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)] +pub struct UiSetMinHopsRequest { + #[serde(rename = "minHops")] + pub min_hops_count: u8, +} +conversation_message!(UiSetMinHopsRequest, "minHops"); + +#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)] +pub struct UiSetMinHopsResponse {} +conversation_message!(UiSetMinHopsResponse, "minHops"); + #[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)] pub struct UiSetConfigurationRequest { pub name: String, From 0e857bd4a4073c75f830c01bdbad9603d3c68ca9 Mon Sep 17 00:00:00 2001 From: utkarshg6 Date: Thu, 6 Apr 2023 17:54:00 +0530 Subject: [PATCH 03/56] GH-690: add the command to schema --- masq/src/command_factory.rs | 17 +++++++++++++++++ masq/src/commands/min_hops_command.rs | 8 ++++++-- masq/src/schema.rs | 2 ++ 3 files changed, 25 insertions(+), 2 deletions(-) diff --git a/masq/src/command_factory.rs b/masq/src/command_factory.rs index 7310e06c0..488bc1035 100644 --- a/masq/src/command_factory.rs +++ b/masq/src/command_factory.rs @@ -348,6 +348,23 @@ mod tests { ); } + #[test] + fn factory_produces_min_hops() { + let subject = CommandFactoryReal::new(); + + let command = subject + .make(&["min-hops".to_string(), "3".to_string()]) + .unwrap(); + + assert_eq!( + command + .as_any() + .downcast_ref::() + .unwrap(), + &MinHopsSubCommand { value: 3 } + ); + } + #[test] fn complains_about_generate_wallets_command_with_bad_syntax() { let subject = CommandFactoryReal::new(); diff --git a/masq/src/commands/min_hops_command.rs b/masq/src/commands/min_hops_command.rs index 4075316f4..b5efbf58d 100644 --- a/masq/src/commands/min_hops_command.rs +++ b/masq/src/commands/min_hops_command.rs @@ -5,12 +5,14 @@ use crate::commands::commands_common::{ transaction, Command, CommandError, STANDARD_COMMAND_TIMEOUT_MILLIS, }; use clap::{App, Arg, SubCommand}; +use masq_lib::implement_as_any; use masq_lib::messages::{UiSetMinHopsRequest, UiSetMinHopsResponse}; +use std::any::Any; use std::fmt::Debug; -#[derive(Debug)] +#[derive(Debug, PartialEq, Eq)] pub struct MinHopsSubCommand { - value: u8, + pub value: u8, } const MIN_HOPS_ABOUT: &str = "Sets the value of the minimum hops count in Node."; @@ -41,6 +43,8 @@ impl Command for MinHopsSubCommand { Err(e) => Err(e), } } + + implement_as_any!(); } impl MinHopsSubCommand { diff --git a/masq/src/schema.rs b/masq/src/schema.rs index c03a3ea39..6ce21b7f9 100644 --- a/masq/src/schema.rs +++ b/masq/src/schema.rs @@ -10,6 +10,7 @@ use crate::commands::crash_command::crash_subcommand; use crate::commands::descriptor_command::descriptor_subcommand; use crate::commands::financials_command::args_validation::financials_subcommand; use crate::commands::generate_wallets_command::generate_wallets_subcommand; +use crate::commands::min_hops_command::min_hops_subcommand; use crate::commands::recover_wallets_command::recover_wallets_subcommand; use crate::commands::scan_command::scan_subcommand; use crate::commands::set_configuration_command::set_configuration_subcommand; @@ -69,6 +70,7 @@ pub fn app() -> App<'static, 'static> { .subcommand(descriptor_subcommand()) .subcommand(financials_subcommand()) .subcommand(generate_wallets_subcommand()) + .subcommand(min_hops_subcommand()) .subcommand(recover_wallets_subcommand()) .subcommand(scan_subcommand()) .subcommand(set_configuration_subcommand()) From 65bd6d7926a82910290a3b38637bfd796bf3dbc8 Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Tue, 11 Apr 2023 12:54:01 +0530 Subject: [PATCH 04/56] GH-690: allow Neighborhood to process the --min-hops command --- node/src/neighborhood/mod.rs | 63 ++++++++++++++++++++++++++++++++++++ 1 file changed, 63 insertions(+) diff --git a/node/src/neighborhood/mod.rs b/node/src/neighborhood/mod.rs index 82b4f7a31..521e0eade 100644 --- a/node/src/neighborhood/mod.rs +++ b/node/src/neighborhood/mod.rs @@ -22,6 +22,7 @@ use actix::{Actor, System}; use itertools::Itertools; use masq_lib::messages::{ FromMessageBody, ToMessageBody, UiConnectionStage, UiConnectionStatusRequest, + UiSetMinHopsRequest, UiSetMinHopsResponse, }; use masq_lib::messages::{UiConnectionStatusResponse, UiShutdownRequest}; use masq_lib::ui_gateway::{MessageTarget, NodeFromUiMessage, NodeToUiMessage}; @@ -376,6 +377,22 @@ impl Handler for Neighborhood { let client_id = msg.client_id; if let Ok((_, context_id)) = UiConnectionStatusRequest::fmb(msg.body.clone()) { self.handle_connection_status_message(client_id, context_id); + } else if let Ok((body, context_id)) = UiSetMinHopsRequest::fmb(msg.body.clone()) { + // TODO: Write code that'll modify the min hops count in Neighborhood and migrate code to a new fn + info!( + self.logger, + "Min Hops has been set to {}", + body.min_hops_count.to_string() + ); + let message = NodeToUiMessage { + target: MessageTarget::ClientId(client_id), + body: UiSetMinHopsResponse {}.tmb(context_id), + }; + self.node_to_ui_recipient_opt + .as_ref() + .expect("UI Gateway is unbound") + .try_send(message) + .expect("UiGateway is dead"); } else if let Ok((body, _)) = UiShutdownRequest::fmb(msg.body.clone()) { self.handle_shutdown_order(client_id, body); } else { @@ -5610,6 +5627,52 @@ mod tests { ) } + #[test] + fn set_min_hops_message_from_ui_is_handled_properly() { + let test_name = "set_min_hops_message_from_ui_is_handled_properly"; + running_test(); + init_test_logging(); + let system = System::new(test_name); + let subject = Neighborhood::new( + main_cryptde(), + &bc_from_nc_plus( + NeighborhoodConfig { + mode: NeighborhoodMode::ZeroHop, + }, + make_wallet("earning"), + None, + test_name, + ), + ); + let (ui_gateway, _, ui_gateway_recording_arc) = make_recorder(); + let (client_id, context_id) = (1234, 4321); + let subject_addr = subject.start(); + let peer_actors = peer_actors_builder().ui_gateway(ui_gateway).build(); + subject_addr.try_send(BindMessage { peer_actors }).unwrap(); + + subject_addr + .try_send(NodeFromUiMessage { + client_id, + body: UiSetMinHopsRequest { min_hops_count: 5 }.tmb(context_id), + }) + .unwrap(); + + System::current().stop(); + system.run(); + let ui_gateway_recording = ui_gateway_recording_arc.lock().unwrap(); + let message = ui_gateway_recording.get_record::(0); + assert_eq!(ui_gateway_recording.len(), 1); + assert_eq!( + message, + &NodeToUiMessage { + target: MessageTarget::ClientId(client_id), + body: UiSetMinHopsResponse {}.tmb(context_id), + } + ); + TestLogHandler::new() + .exists_log_containing("INFO: Neighborhood: Min Hops has been set to 5"); + } + #[test] fn new_password_message_works() { let system = System::new("test"); From 0095658f24be51dfda24fc18f2bbc105436af3b9 Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Tue, 11 Apr 2023 14:47:25 +0530 Subject: [PATCH 05/56] GH-690: add min_hops_count as a field inside NeighborhoodConfig --- node/src/actor_system_factory.rs | 6 +++++ node/src/bootstrapper.rs | 10 +++++++ node/src/neighborhood/mod.rs | 27 +++++++++++++++++++ .../node_configurator_standard.rs | 4 ++- .../unprivileged_parse_args_configuration.rs | 25 +++++++++++------ node/src/sub_lib/neighborhood.rs | 1 + .../src/test_utils/neighborhood_test_utils.rs | 4 ++- 7 files changed, 67 insertions(+), 10 deletions(-) diff --git a/node/src/actor_system_factory.rs b/node/src/actor_system_factory.rs index f03f57df2..ca1340ab5 100644 --- a/node/src/actor_system_factory.rs +++ b/node/src/actor_system_factory.rs @@ -678,6 +678,7 @@ mod tests { use std::sync::{Arc, Mutex}; use std::thread; use std::time::Duration; + use crate::neighborhood::DEFAULT_MIN_HOPS_COUNT; struct LogRecipientSetterNull {} @@ -1070,6 +1071,7 @@ mod tests { vec![], rate_pack(100), ), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }, payment_thresholds_opt: Some(PaymentThresholds::default()), when_pending_too_long_sec: DEFAULT_PENDING_TOO_LONG_SEC, @@ -1143,6 +1145,7 @@ mod tests { vec![], rate_pack(100), ), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }, payment_thresholds_opt: Default::default(), when_pending_too_long_sec: DEFAULT_PENDING_TOO_LONG_SEC @@ -1286,6 +1289,7 @@ mod tests { vec![], rate_pack(100), ), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }; let make_params_arc = Arc::new(Mutex::new(vec![])); let mut subject = make_subject_with_null_setter(); @@ -1439,6 +1443,7 @@ mod tests { real_user: RealUser::null(), neighborhood_config: NeighborhoodConfig { mode: NeighborhoodMode::ConsumeOnly(vec![]), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }, payment_thresholds_opt: Default::default(), when_pending_too_long_sec: DEFAULT_PENDING_TOO_LONG_SEC @@ -1627,6 +1632,7 @@ mod tests { vec![], rate_pack(100), ), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }, node_descriptor: Default::default(), payment_thresholds_opt: Default::default(), diff --git a/node/src/bootstrapper.rs b/node/src/bootstrapper.rs index 2103cdf04..e78e017d3 100644 --- a/node/src/bootstrapper.rs +++ b/node/src/bootstrapper.rs @@ -57,6 +57,7 @@ use tokio::prelude::stream::futures_unordered::FuturesUnordered; use tokio::prelude::Async; use tokio::prelude::Future; use tokio::prelude::Stream; +use crate::neighborhood::DEFAULT_MIN_HOPS_COUNT; static mut MAIN_CRYPTDE_BOX_OPT: Option> = None; static mut ALIAS_CRYPTDE_BOX_OPT: Option> = None; @@ -395,6 +396,7 @@ impl BootstrapperConfig { consuming_wallet_opt: None, neighborhood_config: NeighborhoodConfig { mode: NeighborhoodMode::ZeroHop, + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }, when_pending_too_long_sec: DEFAULT_PENDING_TOO_LONG_SEC, } @@ -653,6 +655,7 @@ impl Bootstrapper { neighbor_configs.clone(), *rate_pack, ), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, // TODO: Verify, is this right? }; Some(clandestine_port) } else { @@ -770,6 +773,7 @@ mod tests { use tokio::executor::current_thread::CurrentThread; use tokio::prelude::stream::FuturesUnordered; use tokio::prelude::Async; + use crate::neighborhood::DEFAULT_MIN_HOPS_COUNT; lazy_static! { pub static ref INITIALIZATION: Mutex = Mutex::new(false); @@ -1222,6 +1226,7 @@ mod tests { let clandestine_port_opt = Some(44444); let neighborhood_config = NeighborhoodConfig { mode: NeighborhoodMode::OriginateOnly(vec![], rate_pack(9)), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }; let earning_wallet = make_wallet("earning wallet"); let consuming_wallet_opt = Some(make_wallet("consuming wallet")); @@ -1822,6 +1827,7 @@ mod tests { ))], rate_pack(100), ), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }; config.data_directory = data_dir.clone(); config.clandestine_port_opt = Some(port); @@ -1891,6 +1897,7 @@ mod tests { ))], rate_pack(100), ), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }; config.data_directory = data_dir.clone(); config.clandestine_port_opt = None; @@ -1939,6 +1946,7 @@ mod tests { ))], rate_pack(100), ), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }; let listener_handler = ListenerHandlerNull::new(vec![]); let mut subject = BootstrapperBuilder::new() @@ -1975,6 +1983,7 @@ mod tests { Chain::EthRopsten, cryptde, ))]), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }; let listener_handler = ListenerHandlerNull::new(vec![]); let mut subject = BootstrapperBuilder::new() @@ -2004,6 +2013,7 @@ mod tests { config.clandestine_port_opt = None; config.neighborhood_config = NeighborhoodConfig { mode: NeighborhoodMode::ZeroHop, + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }; let listener_handler = ListenerHandlerNull::new(vec![]); let mut subject = BootstrapperBuilder::new() diff --git a/node/src/neighborhood/mod.rs b/node/src/neighborhood/mod.rs index 521e0eade..aa38aec13 100644 --- a/node/src/neighborhood/mod.rs +++ b/node/src/neighborhood/mod.rs @@ -79,6 +79,7 @@ use neighborhood_database::NeighborhoodDatabase; use node_record::NodeRecord; pub const CRASH_KEY: &str = "NEIGHBORHOOD"; +pub const DEFAULT_MIN_HOPS_COUNT: u8 = 3; pub const UNREACHABLE_HOST_PENALTY: i64 = 100_000_000; pub const RESPONSE_UNDESIRABILITY_FACTOR: usize = 1_000; // assumed response length is request * this @@ -1680,6 +1681,7 @@ mod tests { #[test] fn constants_have_correct_values() { assert_eq!(CRASH_KEY, "NEIGHBORHOOD"); + assert_eq!(DEFAULT_MIN_HOPS_COUNT, 3); } #[test] @@ -1696,6 +1698,7 @@ mod tests { "masq://eth-ropsten:AQIDBA@1.2.3.4:1234", )) .unwrap()]), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }, earning_wallet.clone(), None, @@ -1720,6 +1723,7 @@ mod tests { "masq://eth-mainnet:AQIDBA@1.2.3.4:1234", )) .unwrap()]), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }, earning_wallet.clone(), None, @@ -1740,6 +1744,7 @@ mod tests { &bc_from_nc_plus( NeighborhoodConfig { mode: NeighborhoodMode::ZeroHop, + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }, earning_wallet.clone(), None, @@ -1768,6 +1773,7 @@ mod tests { vec![neighbor.node_descriptor(TEST_DEFAULT_CHAIN, cryptde)], DEFAULT_RATE_PACK.clone(), ), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }, earning_wallet.clone(), None, @@ -1824,6 +1830,7 @@ mod tests { &bc_from_nc_plus( NeighborhoodConfig { mode: NeighborhoodMode::ZeroHop, + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }, earning_wallet.clone(), consuming_wallet.clone(), @@ -1872,6 +1879,7 @@ mod tests { ], rate_pack(100), ), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }, earning_wallet.clone(), consuming_wallet.clone(), @@ -1951,6 +1959,7 @@ mod tests { initial_node_descriptors, rate_pack(100), ), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }; let bootstrap_config = bc_from_nc_plus(neighborhood_config, make_wallet("earning"), None, "test"); @@ -2419,6 +2428,7 @@ mod tests { initial_node_descriptors, rate_pack(100), ), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }; let mut subject = Neighborhood::new( main_cryptde(), @@ -2495,6 +2505,7 @@ mod tests { ], rate_pack(100), ), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }, earning_wallet.clone(), None, @@ -2566,6 +2577,7 @@ mod tests { ))], rate_pack(100), ), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }, earning_wallet.clone(), consuming_wallet.clone(), @@ -2601,6 +2613,7 @@ mod tests { vec![node_record_to_neighbor_config(&one_neighbor)], rate_pack(100), ), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }, earning_wallet.clone(), consuming_wallet.clone(), @@ -2653,6 +2666,7 @@ mod tests { ))], rate_pack(100), ), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }, earning_wallet.clone(), consuming_wallet.clone(), @@ -2693,6 +2707,7 @@ mod tests { ))], rate_pack(100), ), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }, node_record.earning_wallet(), None, @@ -3567,6 +3582,7 @@ mod tests { vec![], rate_pack(100), ), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }, earning_wallet.clone(), consuming_wallet.clone(), @@ -3945,6 +3961,7 @@ mod tests { initial_node_descriptors, rate_pack(100), ), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }; let bootstrap_config = bc_from_nc_plus(neighborhood_config, make_wallet("earning"), None, "test"); @@ -4622,6 +4639,7 @@ mod tests { vec![], rate_pack(100), ), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }, this_node_inside.earning_wallet(), None, @@ -4684,6 +4702,7 @@ mod tests { vec![debut_target.clone()], rate_pack(100), ), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }, NodeRecord::earning_wallet_from_key(&cryptde.public_key()), NodeRecord::consuming_wallet_from_key(&cryptde.public_key()), @@ -4875,6 +4894,7 @@ mod tests { ))], rate_pack(100), ), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }, earning_wallet.clone(), consuming_wallet.clone(), @@ -4936,6 +4956,7 @@ mod tests { vec![node_record_to_neighbor_config(&one_neighbor)], rate_pack(100), ), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }, earning_wallet.clone(), consuming_wallet.clone(), @@ -5002,6 +5023,7 @@ mod tests { ))], rate_pack(100), ), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }, earning_wallet.clone(), consuming_wallet.clone(), @@ -5065,6 +5087,7 @@ mod tests { ))], rate_pack(100), ), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }, node_record.earning_wallet(), None, @@ -5522,6 +5545,7 @@ mod tests { &bc_from_nc_plus( NeighborhoodConfig { mode: NeighborhoodMode::ZeroHop, + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }, make_wallet("earning"), None, @@ -5638,6 +5662,7 @@ mod tests { &bc_from_nc_plus( NeighborhoodConfig { mode: NeighborhoodMode::ZeroHop, + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }, make_wallet("earning"), None, @@ -5918,6 +5943,7 @@ mod tests { initial_node_descriptors, rate_pack(100), ), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }; let bootstrap_config = bc_from_nc_plus(neighborhood_config, make_wallet("earning"), None, test_name); @@ -5941,6 +5967,7 @@ mod tests { &bc_from_nc_plus( NeighborhoodConfig { mode: NeighborhoodMode::ConsumeOnly(vec![make_node_descriptor(make_ip(1))]), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }, make_wallet("earning"), None, diff --git a/node/src/node_configurator/node_configurator_standard.rs b/node/src/node_configurator/node_configurator_standard.rs index b5700144b..1ff0eca17 100644 --- a/node/src/node_configurator/node_configurator_standard.rs +++ b/node/src/node_configurator/node_configurator_standard.rs @@ -304,6 +304,7 @@ mod tests { use std::path::PathBuf; use std::sync::{Arc, Mutex}; use std::vec; + use crate::neighborhood::DEFAULT_MIN_HOPS_COUNT; #[test] fn node_configurator_standard_unprivileged_uses_parse_args_configurator_dao_real() { @@ -574,7 +575,8 @@ mod tests { assert_eq!( config.neighborhood_config, NeighborhoodConfig { - mode: NeighborhoodMode::ZeroHop // not populated on the privileged side + mode: NeighborhoodMode::ZeroHop, // not populated on the privileged side + min_hops_count: DEFAULT_MIN_HOPS_COUNT, } ); assert_eq!( diff --git a/node/src/node_configurator/unprivileged_parse_args_configuration.rs b/node/src/node_configurator/unprivileged_parse_args_configuration.rs index 45d771c40..28582b75c 100644 --- a/node/src/node_configurator/unprivileged_parse_args_configuration.rs +++ b/node/src/node_configurator/unprivileged_parse_args_configuration.rs @@ -25,6 +25,7 @@ use masq_lib::utils::{AutomapProtocol, ExpectValue}; use rustc_hex::FromHex; use std::net::{IpAddr, Ipv4Addr}; use std::str::FromStr; +use crate::neighborhood::DEFAULT_MIN_HOPS_COUNT; pub trait UnprivilegedParseArgsConfiguration { // Only initialization that cannot be done with privilege should happen here. @@ -214,7 +215,7 @@ pub fn make_neighborhood_config( } }; match make_neighborhood_mode(multi_config, neighbor_configs, persistent_config) { - Ok(mode) => Ok(NeighborhoodConfig { mode }), + Ok(mode) => Ok(NeighborhoodConfig { mode, min_hops_count: DEFAULT_MIN_HOPS_COUNT, }), Err(e) => Err(e), } } @@ -705,7 +706,8 @@ mod tests { .unwrap() ], DEFAULT_RATE_PACK - ) + ), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }) ); } @@ -738,6 +740,7 @@ mod tests { let node_addr = match result { Ok(NeighborhoodConfig { mode: NeighborhoodMode::Standard(node_addr, _, _), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }) => node_addr, x => panic!("Wasn't expecting {:?}", x), }; @@ -794,7 +797,8 @@ mod tests { .unwrap() ], DEFAULT_RATE_PACK - ) + ), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }) ); } @@ -869,7 +873,8 @@ mod tests { .as_str() )) .unwrap() - ],) + ],), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }) ); } @@ -932,7 +937,8 @@ mod tests { assert_eq!( result, Ok(NeighborhoodConfig { - mode: NeighborhoodMode::ZeroHop + mode: NeighborhoodMode::ZeroHop, + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }) ); } @@ -1262,7 +1268,8 @@ mod tests { assert_eq!( config.neighborhood_config, NeighborhoodConfig { - mode: NeighborhoodMode::ZeroHop + mode: NeighborhoodMode::ZeroHop, + min_hops_count: DEFAULT_MIN_HOPS_COUNT, } ); let set_past_neighbors_params = set_past_neighbors_params_arc.lock().unwrap(); @@ -1308,7 +1315,8 @@ mod tests { assert_eq!( config.neighborhood_config, NeighborhoodConfig { - mode: NeighborhoodMode::ZeroHop + mode: NeighborhoodMode::ZeroHop, + min_hops_count: DEFAULT_MIN_HOPS_COUNT, } ); let set_past_neighbors_params = set_past_neighbors_params_arc.lock().unwrap(); @@ -1489,7 +1497,8 @@ mod tests { .unwrap(), ], DEFAULT_RATE_PACK.clone() - ) + ), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, } ); assert_eq!(config.db_password_opt, Some(password.to_string())); diff --git a/node/src/sub_lib/neighborhood.rs b/node/src/sub_lib/neighborhood.rs index 4a1b7f78f..c4ace19f9 100644 --- a/node/src/sub_lib/neighborhood.rs +++ b/node/src/sub_lib/neighborhood.rs @@ -370,6 +370,7 @@ impl Display for DescriptorParsingError<'_> { #[derive(Clone, Debug, PartialEq, Eq)] pub struct NeighborhoodConfig { pub mode: NeighborhoodMode, + pub min_hops_count: u8, } lazy_static! { diff --git a/node/src/test_utils/neighborhood_test_utils.rs b/node/src/test_utils/neighborhood_test_utils.rs index c8c5250ce..e217d2889 100644 --- a/node/src/test_utils/neighborhood_test_utils.rs +++ b/node/src/test_utils/neighborhood_test_utils.rs @@ -3,7 +3,7 @@ use crate::bootstrapper::BootstrapperConfig; use crate::neighborhood::gossip::GossipNodeRecord; use crate::neighborhood::neighborhood_database::NeighborhoodDatabase; use crate::neighborhood::node_record::{NodeRecord, NodeRecordInner_0v1}; -use crate::neighborhood::{AccessibleGossipRecord, Neighborhood}; +use crate::neighborhood::{AccessibleGossipRecord, DEFAULT_MIN_HOPS_COUNT, Neighborhood}; use crate::sub_lib::cryptde::PublicKey; use crate::sub_lib::cryptde::{CryptDE, PlainData}; use crate::sub_lib::cryptde_null::CryptDENull; @@ -95,9 +95,11 @@ pub fn neighborhood_from_nodes( vec![NodeDescriptor::from((neighbor, Chain::EthRopsten, cryptde))], *root.rate_pack(), ), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }, None => NeighborhoodConfig { mode: NeighborhoodMode::ZeroHop, + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }, }; config.earning_wallet = root.earning_wallet(); From acc284f74579aee3301fd594c86488c780af77af Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Thu, 13 Apr 2023 12:39:58 +0530 Subject: [PATCH 06/56] GH-690: add min-hops to shared_schema.rs --- masq_lib/src/shared_schema.rs | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/masq_lib/src/shared_schema.rs b/masq_lib/src/shared_schema.rs index 2d77ea687..d8ad9c393 100644 --- a/masq_lib/src/shared_schema.rs +++ b/masq_lib/src/shared_schema.rs @@ -105,6 +105,7 @@ pub const MAPPING_PROTOCOL_HELP: &str = public IP address with the --ip parameter. If the Node communicates successfully with your router, \ it will remember the protocol it used, and on its next run it will try that protocol first, unless \ you specify a different protocol on the command line."; +pub const MIN_HOPS_HELP: &str = "Enter the count as an argument. 3-hops is required for anonymity."; // TODO: rewrite this pub const REAL_USER_HELP: &str = "The user whose identity Node will assume when dropping privileges after bootstrapping. Since Node refuses to \ run with root privilege after bootstrapping, you might want to use this if you start the Node as root, or if \ @@ -407,6 +408,16 @@ pub fn shared_app(head: App<'static, 'static>) -> App<'static, 'static> { .case_insensitive(true) .help(MAPPING_PROTOCOL_HELP), ) + .arg( + Arg::with_name("min-hops") + .long("min-hops") + .value_name("MIN_HOPS") + .required(false) + .min_values(0) + .max_values(1) + .possible_values(&["1", "2", "3", "4", "5", "6"]) + .help(MIN_HOPS_HELP) + ) .arg( Arg::with_name("neighborhood-mode") .long("neighborhood-mode") @@ -713,6 +724,10 @@ mod tests { generates a lot of log traffic. This will both consume your disk space and degrade your Node's performance. \ You should probably not specify a level higher than the default unless you have security concerns about \ persistent logs being kept on your computer: if your Node crashes, it's good to know why."); + assert_eq!( + MIN_HOPS_HELP, + "Enter the count as an argument. 3-hops is required for anonymity." + ); assert_eq!( NEIGHBORS_HELP, "One or more Node descriptors for running Nodes in the MASQ \ From 814b5211feac144b0a3a3b8a2277b444f924c116 Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Thu, 13 Apr 2023 15:47:18 +0530 Subject: [PATCH 07/56] GH-690: use --min-hops while building NeighborhoodConfig --- .../unprivileged_parse_args_configuration.rs | 20 +++++++++++++++++-- 1 file changed, 18 insertions(+), 2 deletions(-) diff --git a/node/src/node_configurator/unprivileged_parse_args_configuration.rs b/node/src/node_configurator/unprivileged_parse_args_configuration.rs index 28582b75c..af68be656 100644 --- a/node/src/node_configurator/unprivileged_parse_args_configuration.rs +++ b/node/src/node_configurator/unprivileged_parse_args_configuration.rs @@ -214,8 +214,23 @@ pub fn make_neighborhood_config( .get_past_neighbors(persistent_config, unprivileged_config)?, } }; + + let min_hops_count_string = + value_m!(multi_config, "min-hops", String) + .unwrap_or_else(|| DEFAULT_MIN_HOPS_COUNT.to_string()); + + let min_hops_count: u8 = match min_hops_count_string.as_str() { + "1" => 1, + "2" => 2, + "3" => 3, + "4" => 4, + "5" => 5, + "6" => 6, + _ => panic!("Invalid input string!"), + }; + match make_neighborhood_mode(multi_config, neighbor_configs, persistent_config) { - Ok(mode) => Ok(NeighborhoodConfig { mode, min_hops_count: DEFAULT_MIN_HOPS_COUNT, }), + Ok(mode) => Ok(NeighborhoodConfig { mode, min_hops_count }), Err(e) => Err(e), } } @@ -671,6 +686,7 @@ mod tests { vec![Box::new(CommandLineVcl::new( ArgsBuilder::new() .param("--neighborhood-mode", "standard") + .param("--min-hops", "1") .param("--ip", "1.2.3.4") .param( "--neighbors", @@ -707,7 +723,7 @@ mod tests { ], DEFAULT_RATE_PACK ), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: 1, }) ); } From 0ac93942b3f4a947d6a68f2cd9ad3f21e55b8b2f Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Fri, 14 Apr 2023 12:48:20 +0530 Subject: [PATCH 08/56] GH-690: remove min-hops as a command --- masq/src/command_factory.rs | 22 ---- masq/src/commands/min_hops_command.rs | 161 -------------------------- masq/src/commands/mod.rs | 1 - masq/src/schema.rs | 2 - masq_lib/src/messages.rs | 11 -- node/src/neighborhood/mod.rs | 64 ---------- 6 files changed, 261 deletions(-) delete mode 100644 masq/src/commands/min_hops_command.rs diff --git a/masq/src/command_factory.rs b/masq/src/command_factory.rs index 488bc1035..21222c454 100644 --- a/masq/src/command_factory.rs +++ b/masq/src/command_factory.rs @@ -10,7 +10,6 @@ use crate::commands::crash_command::CrashCommand; use crate::commands::descriptor_command::DescriptorCommand; use crate::commands::financials_command::FinancialsCommand; use crate::commands::generate_wallets_command::GenerateWalletsCommand; -use crate::commands::min_hops_command::MinHopsSubCommand; use crate::commands::recover_wallets_command::RecoverWalletsCommand; use crate::commands::scan_command::ScanCommand; use crate::commands::set_configuration_command::SetConfigurationCommand; @@ -61,10 +60,6 @@ impl CommandFactory for CommandFactoryReal { Ok(command) => Box::new(command), Err(msg) => return Err(CommandSyntax(msg)), }, - "min-hops" => match MinHopsSubCommand::new(pieces) { - Ok(command) => Box::new(command), - Err(msg) => return Err(CommandSyntax(msg)), - }, "recover-wallets" => match RecoverWalletsCommand::new(pieces) { Ok(command) => Box::new(command), Err(msg) => return Err(CommandSyntax(msg)), @@ -348,23 +343,6 @@ mod tests { ); } - #[test] - fn factory_produces_min_hops() { - let subject = CommandFactoryReal::new(); - - let command = subject - .make(&["min-hops".to_string(), "3".to_string()]) - .unwrap(); - - assert_eq!( - command - .as_any() - .downcast_ref::() - .unwrap(), - &MinHopsSubCommand { value: 3 } - ); - } - #[test] fn complains_about_generate_wallets_command_with_bad_syntax() { let subject = CommandFactoryReal::new(); diff --git a/masq/src/commands/min_hops_command.rs b/masq/src/commands/min_hops_command.rs deleted file mode 100644 index b5efbf58d..000000000 --- a/masq/src/commands/min_hops_command.rs +++ /dev/null @@ -1,161 +0,0 @@ -// Copyright (c) 2019, MASQ (https://masq.ai) and/or its affiliates. All rights reserved. - -use crate::command_context::CommandContext; -use crate::commands::commands_common::{ - transaction, Command, CommandError, STANDARD_COMMAND_TIMEOUT_MILLIS, -}; -use clap::{App, Arg, SubCommand}; -use masq_lib::implement_as_any; -use masq_lib::messages::{UiSetMinHopsRequest, UiSetMinHopsResponse}; -use std::any::Any; -use std::fmt::Debug; - -#[derive(Debug, PartialEq, Eq)] -pub struct MinHopsSubCommand { - pub value: u8, -} - -const MIN_HOPS_ABOUT: &str = "Sets the value of the minimum hops count in Node."; -const MIN_HOPS_HELP: &str = "Enter the count as an argument. 3-hops is required for anonymity."; - -pub fn min_hops_subcommand() -> App<'static, 'static> { - SubCommand::with_name("min-hops").about(MIN_HOPS_ABOUT).arg( - Arg::with_name("value") - .help(MIN_HOPS_HELP) - .index(1) - .possible_values(&["1", "2", "3", "4", "5", "6"]) - .required(true), - ) -} - -impl Command for MinHopsSubCommand { - fn execute(&self, context: &mut dyn CommandContext) -> Result<(), CommandError> { - let input = UiSetMinHopsRequest { - min_hops_count: self.value, - }; - let result = transaction::( - input, - context, - STANDARD_COMMAND_TIMEOUT_MILLIS, - ); - match result { - Ok(_response) => Ok(()), - Err(e) => Err(e), - } - } - - implement_as_any!(); -} - -impl MinHopsSubCommand { - pub fn new(pieces: &[String]) -> Result { - let matches = match min_hops_subcommand().get_matches_from_safe(pieces) { - Ok(matches) => matches, - Err(e) => return Err(format!("{}", e)), - }; - let input_string = matches - .value_of("value") - .expect("value parameter is not properly required"); - let value: u8 = match input_string { - "1" => 1, - "2" => 2, - "3" => 3, - "4" => 4, - "5" => 5, - "6" => 6, - _ => panic!("Invalid input string!"), - }; - - Ok(Self { value }) - } -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::command_context::ContextError; - use crate::command_factory::{CommandFactory, CommandFactoryReal}; - use crate::test_utils::mocks::CommandContextMock; - use masq_lib::messages::{ToMessageBody, UiSetMinHopsResponse}; - use std::sync::{Arc, Mutex}; - - #[test] - fn constants_have_correct_values() { - assert_eq!( - MIN_HOPS_ABOUT, - "Sets the value of the minimum hops count in Node." - ); - assert_eq!( - MIN_HOPS_HELP, - "Enter the count as an argument. 3-hops is required for anonymity." - ); - } - - #[test] - fn testing_command_factory_here() { - let factory = CommandFactoryReal::new(); - let mut context = - CommandContextMock::new().transact_result(Ok(UiSetMinHopsResponse {}.tmb(0))); - let subject = factory - .make(&["min-hops".to_string(), "3".to_string()]) - .unwrap(); - - let result = subject.execute(&mut context); - - assert_eq!(result, Ok(())); - } - - #[test] - fn min_hops_subcommand_works() { - min_hops_subcommand_works_for_value(1); - min_hops_subcommand_works_for_value(2); - min_hops_subcommand_works_for_value(3); - min_hops_subcommand_works_for_value(4); - min_hops_subcommand_works_for_value(5); - min_hops_subcommand_works_for_value(6); - } - - fn min_hops_subcommand_works_for_value(value: u8) { - let transact_params_arc = Arc::new(Mutex::new(vec![])); - let mut context = CommandContextMock::new() - .transact_params(&transact_params_arc) - .transact_result(Ok(UiSetMinHopsResponse {}.tmb(0))); - let stdout_arc = context.stdout_arc(); - let stderr_arc = context.stderr_arc(); - let factory = CommandFactoryReal::new(); - let subject = factory - .make(&["min-hops".to_string(), value.to_string()]) - .unwrap(); - - let result = subject.execute(&mut context); - - assert_eq!(result, Ok(())); - assert_eq!(stdout_arc.lock().unwrap().get_string(), String::new()); - assert_eq!(stderr_arc.lock().unwrap().get_string(), String::new()); - let transact_params = transact_params_arc.lock().unwrap(); - assert_eq!( - *transact_params, - vec![( - UiSetMinHopsRequest { - min_hops_count: value - } - .tmb(0), - STANDARD_COMMAND_TIMEOUT_MILLIS - )] - ) - } - - #[test] - fn scan_command_handles_send_failure() { - let mut context = CommandContextMock::new() - .transact_result(Err(ContextError::ConnectionDropped("blah".to_string()))); - let subject = MinHopsSubCommand::new(&["min-hops".to_string(), "3".to_string()]).unwrap(); - - let result = subject.execute(&mut context); - - assert_eq!( - result, - Err(CommandError::ConnectionProblem("blah".to_string())) - ) - } -} diff --git a/masq/src/commands/mod.rs b/masq/src/commands/mod.rs index 82f8aa94b..44026ebf8 100644 --- a/masq/src/commands/mod.rs +++ b/masq/src/commands/mod.rs @@ -9,7 +9,6 @@ pub mod crash_command; pub mod descriptor_command; pub mod financials_command; pub mod generate_wallets_command; -pub mod min_hops_command; pub mod recover_wallets_command; pub mod scan_command; pub mod set_configuration_command; diff --git a/masq/src/schema.rs b/masq/src/schema.rs index 6ce21b7f9..c03a3ea39 100644 --- a/masq/src/schema.rs +++ b/masq/src/schema.rs @@ -10,7 +10,6 @@ use crate::commands::crash_command::crash_subcommand; use crate::commands::descriptor_command::descriptor_subcommand; use crate::commands::financials_command::args_validation::financials_subcommand; use crate::commands::generate_wallets_command::generate_wallets_subcommand; -use crate::commands::min_hops_command::min_hops_subcommand; use crate::commands::recover_wallets_command::recover_wallets_subcommand; use crate::commands::scan_command::scan_subcommand; use crate::commands::set_configuration_command::set_configuration_subcommand; @@ -70,7 +69,6 @@ pub fn app() -> App<'static, 'static> { .subcommand(descriptor_subcommand()) .subcommand(financials_subcommand()) .subcommand(generate_wallets_subcommand()) - .subcommand(min_hops_subcommand()) .subcommand(recover_wallets_subcommand()) .subcommand(scan_subcommand()) .subcommand(set_configuration_subcommand()) diff --git a/masq_lib/src/messages.rs b/masq_lib/src/messages.rs index 1b3e6e4c5..412076e0d 100644 --- a/masq_lib/src/messages.rs +++ b/masq_lib/src/messages.rs @@ -806,17 +806,6 @@ conversation_message!(UiScanRequest, "scan"); pub struct UiScanResponse {} conversation_message!(UiScanResponse, "scan"); -#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)] -pub struct UiSetMinHopsRequest { - #[serde(rename = "minHops")] - pub min_hops_count: u8, -} -conversation_message!(UiSetMinHopsRequest, "minHops"); - -#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)] -pub struct UiSetMinHopsResponse {} -conversation_message!(UiSetMinHopsResponse, "minHops"); - #[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)] pub struct UiSetConfigurationRequest { pub name: String, diff --git a/node/src/neighborhood/mod.rs b/node/src/neighborhood/mod.rs index aa38aec13..303f08954 100644 --- a/node/src/neighborhood/mod.rs +++ b/node/src/neighborhood/mod.rs @@ -22,7 +22,6 @@ use actix::{Actor, System}; use itertools::Itertools; use masq_lib::messages::{ FromMessageBody, ToMessageBody, UiConnectionStage, UiConnectionStatusRequest, - UiSetMinHopsRequest, UiSetMinHopsResponse, }; use masq_lib::messages::{UiConnectionStatusResponse, UiShutdownRequest}; use masq_lib::ui_gateway::{MessageTarget, NodeFromUiMessage, NodeToUiMessage}; @@ -378,22 +377,6 @@ impl Handler for Neighborhood { let client_id = msg.client_id; if let Ok((_, context_id)) = UiConnectionStatusRequest::fmb(msg.body.clone()) { self.handle_connection_status_message(client_id, context_id); - } else if let Ok((body, context_id)) = UiSetMinHopsRequest::fmb(msg.body.clone()) { - // TODO: Write code that'll modify the min hops count in Neighborhood and migrate code to a new fn - info!( - self.logger, - "Min Hops has been set to {}", - body.min_hops_count.to_string() - ); - let message = NodeToUiMessage { - target: MessageTarget::ClientId(client_id), - body: UiSetMinHopsResponse {}.tmb(context_id), - }; - self.node_to_ui_recipient_opt - .as_ref() - .expect("UI Gateway is unbound") - .try_send(message) - .expect("UiGateway is dead"); } else if let Ok((body, _)) = UiShutdownRequest::fmb(msg.body.clone()) { self.handle_shutdown_order(client_id, body); } else { @@ -5651,53 +5634,6 @@ mod tests { ) } - #[test] - fn set_min_hops_message_from_ui_is_handled_properly() { - let test_name = "set_min_hops_message_from_ui_is_handled_properly"; - running_test(); - init_test_logging(); - let system = System::new(test_name); - let subject = Neighborhood::new( - main_cryptde(), - &bc_from_nc_plus( - NeighborhoodConfig { - mode: NeighborhoodMode::ZeroHop, - min_hops_count: DEFAULT_MIN_HOPS_COUNT, - }, - make_wallet("earning"), - None, - test_name, - ), - ); - let (ui_gateway, _, ui_gateway_recording_arc) = make_recorder(); - let (client_id, context_id) = (1234, 4321); - let subject_addr = subject.start(); - let peer_actors = peer_actors_builder().ui_gateway(ui_gateway).build(); - subject_addr.try_send(BindMessage { peer_actors }).unwrap(); - - subject_addr - .try_send(NodeFromUiMessage { - client_id, - body: UiSetMinHopsRequest { min_hops_count: 5 }.tmb(context_id), - }) - .unwrap(); - - System::current().stop(); - system.run(); - let ui_gateway_recording = ui_gateway_recording_arc.lock().unwrap(); - let message = ui_gateway_recording.get_record::(0); - assert_eq!(ui_gateway_recording.len(), 1); - assert_eq!( - message, - &NodeToUiMessage { - target: MessageTarget::ClientId(client_id), - body: UiSetMinHopsResponse {}.tmb(context_id), - } - ); - TestLogHandler::new() - .exists_log_containing("INFO: Neighborhood: Min Hops has been set to 5"); - } - #[test] fn new_password_message_works() { let system = System::new("test"); From 441adeb249e4d204d765ca4825f0de00dbf2da2e Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Mon, 17 Apr 2023 10:41:17 +0530 Subject: [PATCH 09/56] GH-690: make min_hops_count a field of Neighborhood --- node/src/neighborhood/mod.rs | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/node/src/neighborhood/mod.rs b/node/src/neighborhood/mod.rs index 303f08954..4494a2029 100644 --- a/node/src/neighborhood/mod.rs +++ b/node/src/neighborhood/mod.rs @@ -92,6 +92,7 @@ pub struct Neighborhood { gossip_producer_opt: Option>, neighborhood_database: NeighborhoodDatabase, consuming_wallet_opt: Option, + min_hops_count: u8, next_return_route_id: u32, overall_connection_status: OverallConnectionStatus, chain: Chain, @@ -434,6 +435,7 @@ enum RouteDirection { impl Neighborhood { pub fn new(cryptde: &'static dyn CryptDE, config: &BootstrapperConfig) -> Self { let neighborhood_config = &config.neighborhood_config; + let min_hops_count = config.neighborhood_config.min_hops_count; if neighborhood_config.mode.is_zero_hop() && !neighborhood_config.mode.neighbor_configs().is_empty() { @@ -477,6 +479,7 @@ impl Neighborhood { gossip_producer_opt: None, neighborhood_database, consuming_wallet_opt: config.consuming_wallet_opt.clone(), + min_hops_count, next_return_route_id: 0, overall_connection_status, chain: config.blockchain_bridge_config.chain, @@ -1667,6 +1670,32 @@ mod tests { assert_eq!(DEFAULT_MIN_HOPS_COUNT, 3); } + #[test] + fn min_hops_count_is_set_inside_neighborhood() { + let min_hops_count = 6; + let mode = NeighborhoodMode::Standard( + NodeAddr::new(&make_ip(1), &[1234, 2345]), + vec![make_node_descriptor(make_ip(2))], + rate_pack(100), + ); + let neighborhood_config = NeighborhoodConfig { + mode, + min_hops_count, + }; + + let subject = Neighborhood::new( + main_cryptde(), + &bc_from_nc_plus( + neighborhood_config, + make_wallet("earning"), + None, + "min_hops_count_is_set_inside_neighborhood", + ), + ); + + assert_eq!(subject.min_hops_count, 6); + } + #[test] #[should_panic( expected = "Neighbor masq://eth-ropsten:AQIDBA@1.2.3.4:1234 is not on the mainnet blockchain" From 0558bbce27028787f4679fffd48134b08426c96a Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Mon, 17 Apr 2023 12:11:22 +0530 Subject: [PATCH 10/56] GH-690: pass min_hops_count from Neighborhood to GossipHandler --- node/src/neighborhood/gossip_acceptor.rs | 69 ++++++++++++++++++++---- node/src/neighborhood/mod.rs | 7 ++- node/src/sub_lib/proxy_server.rs | 5 -- 3 files changed, 63 insertions(+), 18 deletions(-) diff --git a/node/src/neighborhood/gossip_acceptor.rs b/node/src/neighborhood/gossip_acceptor.rs index ca44b8b6a..c36b31702 100644 --- a/node/src/neighborhood/gossip_acceptor.rs +++ b/node/src/neighborhood/gossip_acceptor.rs @@ -9,7 +9,6 @@ use crate::sub_lib::neighborhood::{ ConnectionProgressEvent, ConnectionProgressMessage, GossipFailure_0v1, }; use crate::sub_lib::node_addr::NodeAddr; -use crate::sub_lib::proxy_server::DEFAULT_MINIMUM_HOP_COUNT; use actix::Recipient; use masq_lib::logger::Logger; use std::cell::RefCell; @@ -65,6 +64,7 @@ trait GossipHandler: NamedType + Send /* Send because lazily-written tests requi gossip_source: SocketAddr, connection_progress_peers: &[IpAddr], cpm_recipient: &Recipient, + min_hops_count: u8, ) -> GossipAcceptanceResult; } @@ -135,6 +135,7 @@ impl GossipHandler for DebutHandler { gossip_source: SocketAddr, _connection_progress_peers: &[IpAddr], _cpm_recipient: &Recipient, + _min_hops_count: u8, ) -> GossipAcceptanceResult { let source_agr = { let mut agr = agrs.remove(0); // empty Gossip shouldn't get here @@ -512,6 +513,7 @@ impl GossipHandler for PassHandler { _gossip_source: SocketAddr, connection_progress_peers: &[IpAddr], cpm_recipient: &Recipient, + _min_hops_count: u8, ) -> GossipAcceptanceResult { let pass_agr = &agrs[0]; // empty Gossip shouldn't get here let pass_target_node_addr: NodeAddr = pass_agr @@ -630,6 +632,7 @@ impl GossipHandler for IntroductionHandler { gossip_source: SocketAddr, _connection_progress_peers: &[IpAddr], cpm_recipient: &Recipient, + _min_hops_count: u8, ) -> GossipAcceptanceResult { if database.root().full_neighbor_keys(database).len() >= MAX_DEGREE { GossipAcceptanceResult::Ignored @@ -935,11 +938,12 @@ impl GossipHandler for StandardGossipHandler { gossip_source: SocketAddr, _connection_progress_peers: &[IpAddr], cpm_recipient: &Recipient, + min_hops_count: u8, ) -> GossipAcceptanceResult { let initial_neighborship_status = StandardGossipHandler::check_full_neighbor(database, gossip_source.ip()); - let patch = self.compute_patch(&agrs, database.root()); + let patch = self.compute_patch(&agrs, database.root(), min_hops_count); let filtered_agrs = self.filter_agrs_by_patch(agrs, patch); let mut db_changed = self.identify_and_add_non_introductory_new_nodes( @@ -986,6 +990,7 @@ impl StandardGossipHandler { &self, agrs: &[AccessibleGossipRecord], root_node: &NodeRecord, + min_hops_count: u8, ) -> HashSet { let agrs_by_key = agrs .iter() @@ -997,7 +1002,7 @@ impl StandardGossipHandler { &mut patch, root_node.public_key(), &agrs_by_key, - DEFAULT_MINIMUM_HOP_COUNT, + min_hops_count, root_node, ); @@ -1009,7 +1014,7 @@ impl StandardGossipHandler { patch: &mut HashSet, current_node_key: &PublicKey, agrs: &HashMap<&PublicKey, &AccessibleGossipRecord>, - hops_remaining: usize, + hops_remaining: u8, root_node: &NodeRecord, ) { patch.insert(current_node_key.clone()); @@ -1211,6 +1216,7 @@ impl GossipHandler for RejectHandler { _gossip_source: SocketAddr, _connection_progress_peers: &[IpAddr], _cpm_recipient: &Recipient, + _min_hops_count: u8 ) -> GossipAcceptanceResult { panic!("Should never be called") } @@ -1229,6 +1235,7 @@ pub trait GossipAcceptor: Send /* Send because lazily-written tests require it * agrs: Vec, gossip_source: SocketAddr, connection_progress_peers: &[IpAddr], + min_hops_count: u8, ) -> GossipAcceptanceResult; } @@ -1246,6 +1253,7 @@ impl<'a> GossipAcceptor for GossipAcceptorReal<'a> { agrs: Vec, gossip_source: SocketAddr, connection_progress_peers: &[IpAddr], + min_hops_count: u8, ) -> GossipAcceptanceResult { let (qualification, handler_ref) = self .gossip_handlers @@ -1267,6 +1275,7 @@ impl<'a> GossipAcceptor for GossipAcceptorReal<'a> { gossip_source, connection_progress_peers, &self.cpm_recipient, + min_hops_count ) } Qualification::Unmatched => { @@ -1352,6 +1361,7 @@ mod tests { use std::ops::{Add, Sub}; use std::str::FromStr; use std::time::Duration; + use crate::neighborhood::DEFAULT_MIN_HOPS_COUNT; #[test] fn constants_have_correct_values() { @@ -1388,6 +1398,7 @@ mod tests { gossip_source_opt, &vec![], &cpm_recipient, + DEFAULT_MIN_HOPS_COUNT ); assert_eq!(Qualification::Matched, qualifies_result); @@ -1425,6 +1436,7 @@ mod tests { gossip_source, &vec![], &cpm_recipient, + DEFAULT_MIN_HOPS_COUNT ); assert_eq!(Qualification::Matched, qualifies_result); @@ -1480,6 +1492,7 @@ mod tests { src_root.node_addr_opt().unwrap().into(), &vec![], &cpm_recipient, + DEFAULT_MIN_HOPS_COUNT ); assert_eq!(result, GossipAcceptanceResult::Accepted); @@ -1514,6 +1527,7 @@ mod tests { src_root.node_addr_opt().unwrap().into(), &vec![], &cpm_recipient, + DEFAULT_MIN_HOPS_COUNT ); assert_eq!( @@ -1628,6 +1642,7 @@ mod tests { dest_root.node_addr_opt().clone().unwrap().into(), &vec![], &cpm_recipient, + DEFAULT_MIN_HOPS_COUNT ); assert_eq!(result, GossipAcceptanceResult::Accepted); @@ -1650,6 +1665,7 @@ mod tests { gossip_source, &vec![], &cpm_recipient, + DEFAULT_MIN_HOPS_COUNT ); assert_eq!(Qualification::Matched, qualifies_result); @@ -1909,6 +1925,7 @@ mod tests { gossip_source, &vec![], &cpm_recipient, + DEFAULT_MIN_HOPS_COUNT ); let after = time_t_timestamp(); @@ -1956,6 +1973,7 @@ mod tests { gossip_source, &vec![], &cpm_recipient, + DEFAULT_MIN_HOPS_COUNT ); assert_eq!(Qualification::Matched, qualifies_result); @@ -2006,6 +2024,7 @@ mod tests { gossip_source, &vec![], &cpm_recipient, + DEFAULT_MIN_HOPS_COUNT ); assert_eq!(handle_result, GossipAcceptanceResult::Ignored); @@ -2036,6 +2055,7 @@ mod tests { gossip_source, &vec![], &cpm_recipient, + DEFAULT_MIN_HOPS_COUNT ); assert_eq!(Qualification::Matched, qualifies_result); @@ -2093,6 +2113,7 @@ mod tests { gossip_source, &vec![], &cpm_recipient, + DEFAULT_MIN_HOPS_COUNT ); assert_eq!(Qualification::Matched, qualifies_result); @@ -2345,6 +2366,7 @@ mod tests { gossip_source, &vec![], &cpm_recipient, + DEFAULT_MIN_HOPS_COUNT ); assert_eq!(Qualification::Matched, qualifies_result); @@ -2400,7 +2422,7 @@ mod tests { .build(); let agrs: Vec = gossip.try_into().unwrap(); - let result = subject.compute_patch(&agrs, node_a_db.root()); + let result = subject.compute_patch(&agrs, node_a_db.root(), DEFAULT_MIN_HOPS_COUNT); let expected_hashset = vec![ node_a.public_key().clone(), @@ -2452,7 +2474,7 @@ mod tests { .build(); let agrs: Vec = gossip.try_into().unwrap(); - let patch = subject.compute_patch(&agrs, node_a_db.root()); + let patch = subject.compute_patch(&agrs, node_a_db.root(), DEFAULT_MIN_HOPS_COUNT); let expected_hashset = vec![ node_a.public_key().clone(), @@ -2501,7 +2523,7 @@ mod tests { .build(); let agrs: Vec = gossip.try_into().unwrap(); - let patch = subject.compute_patch(&agrs, node_a_db.root()); + let patch = subject.compute_patch(&agrs, node_a_db.root(), DEFAULT_MIN_HOPS_COUNT); let expected_hashset = vec![ node_a.public_key().clone(), @@ -2580,11 +2602,16 @@ mod tests { gossip_source, &vec![], &cpm_recipient, + DEFAULT_MIN_HOPS_COUNT ); assert_eq!(result, GossipAcceptanceResult::Ignored); } + fn patch_can_be_calculated_for_different_hop_counts() { + unimplemented!(); + } + #[test] fn no_cpm_is_sent_in_case_full_neighborship_doesn_t_exist_and_cannot_be_created() { // Received gossip from a node we couldn't make a neighbor {Degree too high or malefactor banned node} (false, false) @@ -2614,6 +2641,7 @@ mod tests { src_node_socket_addr, &vec![], &cpm_recipient, + DEFAULT_MIN_HOPS_COUNT ); System::current().stop(); @@ -2653,6 +2681,7 @@ mod tests { src_node_socket_addr, &vec![], &cpm_recipient, + DEFAULT_MIN_HOPS_COUNT ); System::current().stop(); @@ -2699,6 +2728,7 @@ mod tests { src_node_socket_addr, &vec![], &cpm_recipient, + DEFAULT_MIN_HOPS_COUNT ); System::current().stop(); @@ -2739,6 +2769,7 @@ mod tests { src_node_socket_addr, &vec![], &cpm_recipient, + DEFAULT_MIN_HOPS_COUNT ); System::current().stop(); @@ -2782,6 +2813,7 @@ mod tests { gossip.try_into().unwrap(), src_root.node_addr_opt().clone().unwrap().into(), &vec![], + DEFAULT_MIN_HOPS_COUNT ); assert_eq!(result, GossipAcceptanceResult::Ignored); @@ -2866,6 +2898,7 @@ mod tests { gossip.try_into().unwrap(), src_node.node_addr_opt().unwrap().into(), &vec![], + DEFAULT_MIN_HOPS_COUNT ); assert_eq!(GossipAcceptanceResult::Ignored, result); @@ -2885,6 +2918,7 @@ mod tests { gossip.try_into().unwrap(), gossip_source, &vec![], + DEFAULT_MIN_HOPS_COUNT ); let after = time_t_timestamp(); @@ -2924,6 +2958,7 @@ mod tests { gossip.try_into().unwrap(), gossip_source, &vec![], + DEFAULT_MIN_HOPS_COUNT ); let after = time_t_timestamp(); @@ -2995,6 +3030,7 @@ mod tests { gossip.try_into().unwrap(), gossip_source, &vec![], + DEFAULT_MIN_HOPS_COUNT ); let after = time_t_timestamp(); @@ -3091,6 +3127,7 @@ mod tests { gossip.try_into().unwrap(), gossip_source, &vec![], + DEFAULT_MIN_HOPS_COUNT ); let expected_acceptance_gossip_2 = GossipBuilder::new(&dest_db) @@ -3180,6 +3217,7 @@ mod tests { gossip.try_into().unwrap(), gossip_source, &vec![], + DEFAULT_MIN_HOPS_COUNT ); let expected_acceptance_gossip = GossipBuilder::new(&dest_db) @@ -3235,6 +3273,7 @@ mod tests { debut.try_into().unwrap(), gossip_source, &vec![], + DEFAULT_MIN_HOPS_COUNT ); assert_eq!(GossipAcceptanceResult::Ignored, result); @@ -3269,7 +3308,7 @@ mod tests { let subject = make_subject(main_cryptde()); let begin_at = time_t_timestamp(); - let result = subject.handle(&mut dest_db, debut_agrs, gossip_source, &vec![]); + let result = subject.handle(&mut dest_db, debut_agrs, gossip_source, &vec![], DEFAULT_MIN_HOPS_COUNT); let end_at = time_t_timestamp(); assert_eq!(GossipAcceptanceResult::Accepted, result); @@ -3297,7 +3336,7 @@ mod tests { let gossip_source = src_node.node_addr_opt().unwrap().into(); let subject = make_subject(main_cryptde()); - let result = subject.handle(&mut dest_db, debut_agrs, gossip_source, &vec![]); + let result = subject.handle(&mut dest_db, debut_agrs, gossip_source, &vec![], DEFAULT_MIN_HOPS_COUNT); assert_eq!(result, GossipAcceptanceResult::Accepted); assert_eq!( @@ -3327,7 +3366,7 @@ mod tests { let gossip_source = src_node.node_addr_opt().unwrap().into(); let subject = make_subject(main_cryptde()); - let result = subject.handle(&mut dest_db, debut_agrs, gossip_source, &vec![]); + let result = subject.handle(&mut dest_db, debut_agrs, gossip_source, &vec![], DEFAULT_MIN_HOPS_COUNT); assert_eq!(result, GossipAcceptanceResult::Accepted); assert_eq!( @@ -3361,6 +3400,7 @@ mod tests { gossip_source, &vec![], &cpm_recipient, + DEFAULT_MIN_HOPS_COUNT ); System::current().stop(); @@ -3396,7 +3436,7 @@ mod tests { let (gossip, pass_target, gossip_source) = make_pass(2345); let subject = make_subject(main_cryptde()); - let result = subject.handle(&mut db, gossip.try_into().unwrap(), gossip_source, &vec![]); + let result = subject.handle(&mut db, gossip.try_into().unwrap(), gossip_source, &vec![], DEFAULT_MIN_HOPS_COUNT); let expected_relay_gossip = GossipBuilder::new(&db) .node(root_node.public_key(), true) @@ -3430,6 +3470,7 @@ mod tests { gossip_source, &vec![], &cpm_recipient, + DEFAULT_MIN_HOPS_COUNT ); let final_timestamp = SystemTime::now(); @@ -3483,6 +3524,7 @@ mod tests { gossip_source, &vec![], &cpm_recipient, + DEFAULT_MIN_HOPS_COUNT ); let final_timestamp = SystemTime::now(); @@ -3523,6 +3565,7 @@ mod tests { gossip_source, &vec![pass_target_ip_addr], &cpm_recipient, + DEFAULT_MIN_HOPS_COUNT ); System::current().stop(); @@ -3563,6 +3606,7 @@ mod tests { gossip_source, &vec![], &cpm_recipient, + DEFAULT_MIN_HOPS_COUNT ); let final_timestamp = SystemTime::now(); @@ -3668,6 +3712,7 @@ mod tests { gossip.try_into().unwrap(), node_a.node_addr_opt().unwrap().into(), &vec![], + DEFAULT_MIN_HOPS_COUNT ); let after = time_t_timestamp(); @@ -3784,6 +3829,7 @@ mod tests { gossip.try_into().unwrap(), src_node.node_addr_opt().unwrap().into(), &vec![], + DEFAULT_MIN_HOPS_COUNT ); let after = time_t_timestamp(); @@ -3871,6 +3917,7 @@ mod tests { gossip.try_into().unwrap(), src_root.node_addr_opt().unwrap().into(), &vec![], + DEFAULT_MIN_HOPS_COUNT ); let after = time_t_timestamp(); diff --git a/node/src/neighborhood/mod.rs b/node/src/neighborhood/mod.rs index 4494a2029..321e76bc0 100644 --- a/node/src/neighborhood/mod.rs +++ b/node/src/neighborhood/mod.rs @@ -59,7 +59,6 @@ use crate::sub_lib::neighborhood::{NRMetadataChange, NodeQueryMessage}; use crate::sub_lib::neighborhood::{NeighborhoodSubs, NeighborhoodTools}; use crate::sub_lib::node_addr::NodeAddr; use crate::sub_lib::peer_actors::{BindMessage, NewPublicIp, StartMessage}; -use crate::sub_lib::proxy_server::DEFAULT_MINIMUM_HOP_COUNT; use crate::sub_lib::route::Route; use crate::sub_lib::route::RouteSegment; use crate::sub_lib::set_consuming_wallet_message::SetConsumingWalletMessage; @@ -748,6 +747,7 @@ impl Neighborhood { agrs, gossip_source, &connection_progress_peers, + self.min_hops_count ); match acceptance_result { GossipAcceptanceResult::Accepted => self.gossip_to_neighbors(), @@ -827,7 +827,7 @@ impl Neighborhood { let msg = RouteQueryMessage { target_key_opt: None, target_component: Component::ProxyClient, - minimum_hop_count: DEFAULT_MINIMUM_HOP_COUNT, + minimum_hop_count: self.min_hops_count as usize, // TODO: do we need to test this sepertely? return_component_opt: Some(Component::ProxyServer), payload_size: 10000, hostname_opt: None, @@ -3842,6 +3842,7 @@ mod tests { _agrs: Vec, _gossip_source: SocketAddr, _connection_progress_peers: &[IpAddr], + _min_hops_count: u8, ) -> GossipAcceptanceResult { let non_root_database_keys = database .keys() @@ -4075,6 +4076,7 @@ mod tests { _agrs: Vec, _gossip_source: SocketAddr, _connection_progress_peers: &[IpAddr], + _min_hops_count: u8, ) -> GossipAcceptanceResult { let half_neighbor_keys = database .root() @@ -5796,6 +5798,7 @@ mod tests { agrs: Vec, gossip_source: SocketAddr, connection_progress_peers: &[IpAddr], + _min_hops_count: u8, ) -> GossipAcceptanceResult { self.handle_params.lock().unwrap().push(( database.clone(), diff --git a/node/src/sub_lib/proxy_server.rs b/node/src/sub_lib/proxy_server.rs index 8c69e6878..5d3b242ae 100644 --- a/node/src/sub_lib/proxy_server.rs +++ b/node/src/sub_lib/proxy_server.rs @@ -96,11 +96,6 @@ mod tests { use crate::test_utils::recorder::Recorder; use actix::Actor; - #[test] - fn constants_have_correct_values() { - assert_eq!(DEFAULT_MINIMUM_HOP_COUNT, 3); - } - #[test] fn proxy_server_subs_debug() { let recorder = Recorder::new().start(); From ea42650d8626e1f12da9a7759679c6b48c904ced Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Mon, 17 Apr 2023 12:55:24 +0530 Subject: [PATCH 11/56] GH-690: add NeighborhoodMetadata inside gossip_acceptor.rs --- node/src/neighborhood/gossip_acceptor.rs | 215 ++++++++++------------- node/src/neighborhood/mod.rs | 8 +- 2 files changed, 98 insertions(+), 125 deletions(-) diff --git a/node/src/neighborhood/gossip_acceptor.rs b/node/src/neighborhood/gossip_acceptor.rs index c36b31702..ab9da0b2f 100644 --- a/node/src/neighborhood/gossip_acceptor.rs +++ b/node/src/neighborhood/gossip_acceptor.rs @@ -49,6 +49,12 @@ trait NamedType { fn type_name(&self) -> &'static str; } +struct NeighborhoodMetadata { + connection_progress_peers: Vec, + cpm_recipient: Recipient, + min_hops_count: u8, +} + trait GossipHandler: NamedType + Send /* Send because lazily-written tests require it */ { fn qualifies( &self, @@ -62,9 +68,10 @@ trait GossipHandler: NamedType + Send /* Send because lazily-written tests requi database: &mut NeighborhoodDatabase, agrs: Vec, gossip_source: SocketAddr, - connection_progress_peers: &[IpAddr], - cpm_recipient: &Recipient, - min_hops_count: u8, + neighborhood_metadata: NeighborhoodMetadata, + // connection_progress_peers: Vec, + // cpm_recipient: Recipient, + // min_hops_count: u8, ) -> GossipAcceptanceResult; } @@ -133,9 +140,7 @@ impl GossipHandler for DebutHandler { database: &mut NeighborhoodDatabase, mut agrs: Vec, gossip_source: SocketAddr, - _connection_progress_peers: &[IpAddr], - _cpm_recipient: &Recipient, - _min_hops_count: u8, + _neighborhood_metadata: NeighborhoodMetadata, ) -> GossipAcceptanceResult { let source_agr = { let mut agr = agrs.remove(0); // empty Gossip shouldn't get here @@ -511,9 +516,7 @@ impl GossipHandler for PassHandler { database: &mut NeighborhoodDatabase, agrs: Vec, _gossip_source: SocketAddr, - connection_progress_peers: &[IpAddr], - cpm_recipient: &Recipient, - _min_hops_count: u8, + neighborhood_metadata: NeighborhoodMetadata, ) -> GossipAcceptanceResult { let pass_agr = &agrs[0]; // empty Gossip shouldn't get here let pass_target_node_addr: NodeAddr = pass_agr @@ -526,7 +529,7 @@ impl GossipHandler for PassHandler { peer_addr: _gossip_source.ip(), event, }; - cpm_recipient + neighborhood_metadata.cpm_recipient .try_send(connection_progress_message) .expect("System is dead."); }; @@ -543,7 +546,7 @@ impl GossipHandler for PassHandler { let mut hash_map = self.previous_pass_targets.borrow_mut(); let gossip_acceptance_result = match hash_map.get_mut(&pass_target_ip_addr) { - None => match connection_progress_peers.contains(&pass_target_ip_addr) { + None => match neighborhood_metadata.connection_progress_peers.contains(&pass_target_ip_addr) { true => { send_cpm(ConnectionProgressEvent::PassLoopFound); GossipAcceptanceResult::Ignored @@ -630,9 +633,7 @@ impl GossipHandler for IntroductionHandler { database: &mut NeighborhoodDatabase, agrs: Vec, gossip_source: SocketAddr, - _connection_progress_peers: &[IpAddr], - cpm_recipient: &Recipient, - _min_hops_count: u8, + neighborhood_metadata: NeighborhoodMetadata, ) -> GossipAcceptanceResult { if database.root().full_neighbor_keys(database).len() >= MAX_DEGREE { GossipAcceptanceResult::Ignored @@ -663,7 +664,7 @@ impl GossipHandler for IntroductionHandler { peer_addr: introducer_ip_addr, event: ConnectionProgressEvent::IntroductionGossipReceived(introducee_ip_addr), }; - cpm_recipient + neighborhood_metadata.cpm_recipient .try_send(connection_progess_message) .expect("Neighborhood is dead"); let (debut, target_key, target_node_addr) = @@ -936,14 +937,12 @@ impl GossipHandler for StandardGossipHandler { database: &mut NeighborhoodDatabase, agrs: Vec, gossip_source: SocketAddr, - _connection_progress_peers: &[IpAddr], - cpm_recipient: &Recipient, - min_hops_count: u8, + neighborhood_metadata: NeighborhoodMetadata, ) -> GossipAcceptanceResult { let initial_neighborship_status = StandardGossipHandler::check_full_neighbor(database, gossip_source.ip()); - let patch = self.compute_patch(&agrs, database.root(), min_hops_count); + let patch = self.compute_patch(&agrs, database.root(), neighborhood_metadata.min_hops_count); let filtered_agrs = self.filter_agrs_by_patch(agrs, patch); let mut db_changed = self.identify_and_add_non_introductory_new_nodes( @@ -966,7 +965,7 @@ impl GossipHandler for StandardGossipHandler { peer_addr: gossip_source.ip(), event: ConnectionProgressEvent::StandardGossipReceived, }; - cpm_recipient + neighborhood_metadata.cpm_recipient .try_send(cpm) .unwrap_or_else(|e| panic!("Neighborhood is dead: {}", e)); } @@ -1214,9 +1213,7 @@ impl GossipHandler for RejectHandler { _database: &mut NeighborhoodDatabase, _agrs: Vec, _gossip_source: SocketAddr, - _connection_progress_peers: &[IpAddr], - _cpm_recipient: &Recipient, - _min_hops_count: u8 + _neighborhood_metadata: NeighborhoodMetadata, ) -> GossipAcceptanceResult { panic!("Should never be called") } @@ -1234,7 +1231,7 @@ pub trait GossipAcceptor: Send /* Send because lazily-written tests require it * database: &mut NeighborhoodDatabase, agrs: Vec, gossip_source: SocketAddr, - connection_progress_peers: &[IpAddr], + connection_progress_peers: Vec, min_hops_count: u8, ) -> GossipAcceptanceResult; } @@ -1252,7 +1249,7 @@ impl<'a> GossipAcceptor for GossipAcceptorReal<'a> { database: &mut NeighborhoodDatabase, agrs: Vec, gossip_source: SocketAddr, - connection_progress_peers: &[IpAddr], + connection_progress_peers: Vec, min_hops_count: u8, ) -> GossipAcceptanceResult { let (qualification, handler_ref) = self @@ -1268,14 +1265,17 @@ impl<'a> GossipAcceptor for GossipAcceptorReal<'a> { "Gossip delegated to {}", handler_ref.type_name() ); + let neighborhood_metadata = NeighborhoodMetadata { + connection_progress_peers, + cpm_recipient: self.cpm_recipient.clone(), + min_hops_count, + }; handler_ref.handle( self.cryptde, database, agrs, gossip_source, - connection_progress_peers, - &self.cpm_recipient, - min_hops_count + neighborhood_metadata ) } Qualification::Unmatched => { @@ -1377,6 +1377,14 @@ mod tests { // ZeroHop is decentralized and should never appear in GossipAcceptor tests } + fn make_default_neighborhood_metadata() -> NeighborhoodMetadata { + NeighborhoodMetadata { + connection_progress_peers: vec![], + cpm_recipient: make_cpm_recipient().0, + min_hops_count: DEFAULT_MIN_HOPS_COUNT, + } + } + #[test] fn proper_debut_of_accepting_node_with_populated_database_is_identified_and_handled() { let (gossip, new_node, gossip_source_opt) = make_debut(2345, Mode::Standard); @@ -1386,7 +1394,6 @@ mod tests { db.add_arbitrary_full_neighbor(root_node.public_key(), neighbor_key); let cryptde = CryptDENull::from(db.root().public_key(), TEST_DEFAULT_CHAIN); let agrs_vec: Vec = gossip.try_into().unwrap(); - let (cpm_recipient, _) = make_cpm_recipient(); let subject = DebutHandler::new(Logger::new("test")); let qualifies_result = @@ -1396,9 +1403,7 @@ mod tests { &mut db, agrs_vec, gossip_source_opt, - &vec![], - &cpm_recipient, - DEFAULT_MIN_HOPS_COUNT + make_default_neighborhood_metadata() ); assert_eq!(Qualification::Matched, qualifies_result); @@ -1425,7 +1430,6 @@ mod tests { db.add_arbitrary_full_neighbor(root_node.public_key(), neighbor_key); let cryptde = CryptDENull::from(db.root().public_key(), TEST_DEFAULT_CHAIN); let agrs_vec: Vec = gossip.try_into().unwrap(); - let (cpm_recipient, _) = make_cpm_recipient(); let subject = DebutHandler::new(Logger::new("test")); let qualifies_result = subject.qualifies(&db, agrs_vec.as_slice(), gossip_source.clone()); @@ -1434,9 +1438,7 @@ mod tests { &mut db, agrs_vec, gossip_source, - &vec![], - &cpm_recipient, - DEFAULT_MIN_HOPS_COUNT + make_default_neighborhood_metadata() ); assert_eq!(Qualification::Matched, qualifies_result); @@ -1482,7 +1484,6 @@ mod tests { .node(src_db.root().public_key(), true) .build(); let agrs_vec: Vec = gossip.try_into().unwrap(); - let (cpm_recipient, _) = make_cpm_recipient(); let subject = DebutHandler::new(Logger::new("test")); let result = subject.handle( @@ -1490,9 +1491,7 @@ mod tests { &mut dest_db, agrs_vec, src_root.node_addr_opt().unwrap().into(), - &vec![], - &cpm_recipient, - DEFAULT_MIN_HOPS_COUNT + make_default_neighborhood_metadata() ); assert_eq!(result, GossipAcceptanceResult::Accepted); @@ -1517,7 +1516,6 @@ mod tests { .node(src_db.root().public_key(), true) .build(); let agrs_vec: Vec = gossip.try_into().unwrap(); - let (cpm_recipient, _) = make_cpm_recipient(); let subject = DebutHandler::new(Logger::new("test")); let result = subject.handle( @@ -1525,9 +1523,7 @@ mod tests { &mut dest_db, agrs_vec, src_root.node_addr_opt().unwrap().into(), - &vec![], - &cpm_recipient, - DEFAULT_MIN_HOPS_COUNT + make_default_neighborhood_metadata() ); assert_eq!( @@ -1632,7 +1628,6 @@ mod tests { .build() .try_into() .unwrap(); - let (cpm_recipient, _) = make_cpm_recipient(); let subject = DebutHandler::new(Logger::new("test")); let result = subject.handle( @@ -1640,9 +1635,7 @@ mod tests { &mut dest_db, agrs_vec, dest_root.node_addr_opt().clone().unwrap().into(), - &vec![], - &cpm_recipient, - DEFAULT_MIN_HOPS_COUNT + make_default_neighborhood_metadata() ); assert_eq!(result, GossipAcceptanceResult::Accepted); @@ -1655,7 +1648,6 @@ mod tests { let mut dest_db = make_meaningless_db(); let cryptde = CryptDENull::from(dest_db.root().public_key(), TEST_DEFAULT_CHAIN); let agrs_vec: Vec = gossip.try_into().unwrap(); - let (cpm_recipient, _) = make_cpm_recipient(); let qualifies_result = subject.qualifies(&dest_db, agrs_vec.as_slice(), gossip_source); let handle_result = subject.handle( @@ -1663,9 +1655,7 @@ mod tests { &mut dest_db, agrs_vec, gossip_source, - &vec![], - &cpm_recipient, - DEFAULT_MIN_HOPS_COUNT + make_default_neighborhood_metadata() ); assert_eq!(Qualification::Matched, qualifies_result); @@ -1913,7 +1903,6 @@ mod tests { &SocketAddr::from_str("4.5.6.7:4567").unwrap(), )); dest_db.resign_node(introducer_key); - let (cpm_recipient, _) = make_cpm_recipient(); let introducer_before_gossip = dest_db.node_by_key(introducer_key).unwrap().clone(); let before = time_t_timestamp(); @@ -1923,9 +1912,7 @@ mod tests { &mut dest_db, agrs.clone(), gossip_source, - &vec![], - &cpm_recipient, - DEFAULT_MIN_HOPS_COUNT + make_default_neighborhood_metadata() ); let after = time_t_timestamp(); @@ -1963,7 +1950,6 @@ mod tests { let cryptde = CryptDENull::from(dest_db.root().public_key(), TEST_DEFAULT_CHAIN); let subject = IntroductionHandler::new(Logger::new("test")); let agrs: Vec = gossip.try_into().unwrap(); - let (cpm_recipient, _) = make_cpm_recipient(); let qualifies_result = subject.qualifies(&dest_db, &agrs, gossip_source); let handle_result = subject.handle( @@ -1971,9 +1957,7 @@ mod tests { &mut dest_db, agrs.clone(), gossip_source, - &vec![], - &cpm_recipient, - DEFAULT_MIN_HOPS_COUNT + make_default_neighborhood_metadata() ); assert_eq!(Qualification::Matched, qualifies_result); @@ -2015,16 +1999,13 @@ mod tests { let cryptde = CryptDENull::from(dest_db.root().public_key(), TEST_DEFAULT_CHAIN); let subject = IntroductionHandler::new(Logger::new("test")); let agrs: Vec = gossip.try_into().unwrap(); - let (cpm_recipient, _) = make_cpm_recipient(); let handle_result = subject.handle( &cryptde, &mut dest_db, agrs.clone(), gossip_source, - &vec![], - &cpm_recipient, - DEFAULT_MIN_HOPS_COUNT + make_default_neighborhood_metadata() ); assert_eq!(handle_result, GossipAcceptanceResult::Ignored); @@ -2045,7 +2026,6 @@ mod tests { .unwrap() .set_version(0); dest_db.resign_node(&agrs[0].inner.public_key); - let (cpm_recipient, _) = make_cpm_recipient(); let qualifies_result = subject.qualifies(&dest_db, &agrs, gossip_source); let handle_result = subject.handle( @@ -2053,9 +2033,7 @@ mod tests { &mut dest_db, agrs.clone(), gossip_source, - &vec![], - &cpm_recipient, - DEFAULT_MIN_HOPS_COUNT + make_default_neighborhood_metadata() ); assert_eq!(Qualification::Matched, qualifies_result); @@ -2103,7 +2081,6 @@ mod tests { let agrs: Vec = gossip.try_into().unwrap(); dest_db.add_node(NodeRecord::from(&agrs[0])).unwrap(); dest_db.add_arbitrary_half_neighbor(dest_root.public_key(), &agrs[0].inner.public_key); - let (cpm_recipient, _) = make_cpm_recipient(); let qualifies_result = subject.qualifies(&dest_db, &agrs, gossip_source); let handle_result = subject.handle( @@ -2111,9 +2088,7 @@ mod tests { &mut dest_db, agrs.clone(), gossip_source, - &vec![], - &cpm_recipient, - DEFAULT_MIN_HOPS_COUNT + make_default_neighborhood_metadata() ); assert_eq!(Qualification::Matched, qualifies_result); @@ -2356,6 +2331,8 @@ mod tests { let agrs_vec: Vec = gossip.try_into().unwrap(); let gossip_source: SocketAddr = src_root.node_addr_opt().unwrap().into(); let (cpm_recipient, recording_arc) = make_cpm_recipient(); + let mut neighborhood_metadata = make_default_neighborhood_metadata(); + neighborhood_metadata.cpm_recipient = cpm_recipient; let system = System::new("test"); let qualifies_result = subject.qualifies(&dest_db, agrs_vec.as_slice(), gossip_source); @@ -2364,9 +2341,7 @@ mod tests { &mut dest_db, agrs_vec, gossip_source, - &vec![], - &cpm_recipient, - DEFAULT_MIN_HOPS_COUNT + neighborhood_metadata ); assert_eq!(Qualification::Matched, qualifies_result); @@ -2557,7 +2532,6 @@ mod tests { */ let cryptde = main_cryptde(); - let (cpm_recipient, _) = make_cpm_recipient(); let subject = StandardGossipHandler::new(Logger::new("test")); let node_a = make_node_record(1111, true); let node_b = make_node_record(2222, true); @@ -2600,9 +2574,7 @@ mod tests { &mut node_a_db, agrs, gossip_source, - &vec![], - &cpm_recipient, - DEFAULT_MIN_HOPS_COUNT + make_default_neighborhood_metadata() ); assert_eq!(result, GossipAcceptanceResult::Ignored); @@ -2631,6 +2603,8 @@ mod tests { .build(); let agrs = gossip.try_into().unwrap(); let (cpm_recipient, recording_arc) = make_cpm_recipient(); + let mut neighborhood_metadata = make_default_neighborhood_metadata(); + neighborhood_metadata.cpm_recipient = cpm_recipient; let subject = StandardGossipHandler::new(Logger::new("test")); let system = System::new("test"); @@ -2639,9 +2613,7 @@ mod tests { &mut root_db, agrs, src_node_socket_addr, - &vec![], - &cpm_recipient, - DEFAULT_MIN_HOPS_COUNT + make_default_neighborhood_metadata() ); System::current().stop(); @@ -2671,6 +2643,8 @@ mod tests { .build(); let agrs = gossip.try_into().unwrap(); let (cpm_recipient, recording_arc) = make_cpm_recipient(); + let mut neighborhood_metadata = make_default_neighborhood_metadata(); + neighborhood_metadata.cpm_recipient = cpm_recipient; let subject = StandardGossipHandler::new(Logger::new("test")); let system = System::new("test"); @@ -2679,9 +2653,7 @@ mod tests { &mut root_db, agrs, src_node_socket_addr, - &vec![], - &cpm_recipient, - DEFAULT_MIN_HOPS_COUNT + neighborhood_metadata ); System::current().stop(); @@ -2718,6 +2690,8 @@ mod tests { .build(); let agrs = gossip.try_into().unwrap(); let (cpm_recipient, recording_arc) = make_cpm_recipient(); + let mut neighborhood_metadata = make_default_neighborhood_metadata(); + neighborhood_metadata.cpm_recipient = cpm_recipient; let subject = StandardGossipHandler::new(Logger::new("test")); let system = System::new("test"); @@ -2726,9 +2700,7 @@ mod tests { &mut root_db, agrs, src_node_socket_addr, - &vec![], - &cpm_recipient, - DEFAULT_MIN_HOPS_COUNT + neighborhood_metadata ); System::current().stop(); @@ -2759,6 +2731,8 @@ mod tests { .build(); let agrs = gossip.try_into().unwrap(); let (cpm_recipient, recording_arc) = make_cpm_recipient(); + let mut neighborhood_metadata = make_default_neighborhood_metadata(); + neighborhood_metadata.cpm_recipient = cpm_recipient; let subject = StandardGossipHandler::new(Logger::new("test")); let system = System::new("test"); @@ -2767,9 +2741,7 @@ mod tests { &mut root_db, agrs, src_node_socket_addr, - &vec![], - &cpm_recipient, - DEFAULT_MIN_HOPS_COUNT + neighborhood_metadata ); System::current().stop(); @@ -2812,7 +2784,7 @@ mod tests { &mut dest_db, gossip.try_into().unwrap(), src_root.node_addr_opt().clone().unwrap().into(), - &vec![], + vec![], DEFAULT_MIN_HOPS_COUNT ); @@ -2897,7 +2869,7 @@ mod tests { &mut dest_db, gossip.try_into().unwrap(), src_node.node_addr_opt().unwrap().into(), - &vec![], + vec![], DEFAULT_MIN_HOPS_COUNT ); @@ -2917,7 +2889,7 @@ mod tests { &mut dest_db, gossip.try_into().unwrap(), gossip_source, - &vec![], + vec![], DEFAULT_MIN_HOPS_COUNT ); @@ -2957,7 +2929,7 @@ mod tests { &mut dest_db, gossip.try_into().unwrap(), gossip_source, - &vec![], + vec![], DEFAULT_MIN_HOPS_COUNT ); @@ -3029,7 +3001,7 @@ mod tests { &mut dest_db, gossip.try_into().unwrap(), gossip_source, - &vec![], + vec![], DEFAULT_MIN_HOPS_COUNT ); @@ -3126,7 +3098,7 @@ mod tests { &mut dest_db, gossip.try_into().unwrap(), gossip_source, - &vec![], + vec![], DEFAULT_MIN_HOPS_COUNT ); @@ -3216,7 +3188,7 @@ mod tests { &mut dest_db, gossip.try_into().unwrap(), gossip_source, - &vec![], + vec![], DEFAULT_MIN_HOPS_COUNT ); @@ -3272,7 +3244,7 @@ mod tests { &mut dest_db, debut.try_into().unwrap(), gossip_source, - &vec![], + vec![], DEFAULT_MIN_HOPS_COUNT ); @@ -3308,7 +3280,7 @@ mod tests { let subject = make_subject(main_cryptde()); let begin_at = time_t_timestamp(); - let result = subject.handle(&mut dest_db, debut_agrs, gossip_source, &vec![], DEFAULT_MIN_HOPS_COUNT); + let result = subject.handle(&mut dest_db, debut_agrs, gossip_source, vec![], DEFAULT_MIN_HOPS_COUNT); let end_at = time_t_timestamp(); assert_eq!(GossipAcceptanceResult::Accepted, result); @@ -3336,7 +3308,7 @@ mod tests { let gossip_source = src_node.node_addr_opt().unwrap().into(); let subject = make_subject(main_cryptde()); - let result = subject.handle(&mut dest_db, debut_agrs, gossip_source, &vec![], DEFAULT_MIN_HOPS_COUNT); + let result = subject.handle(&mut dest_db, debut_agrs, gossip_source, vec![], DEFAULT_MIN_HOPS_COUNT); assert_eq!(result, GossipAcceptanceResult::Accepted); assert_eq!( @@ -3366,7 +3338,7 @@ mod tests { let gossip_source = src_node.node_addr_opt().unwrap().into(); let subject = make_subject(main_cryptde()); - let result = subject.handle(&mut dest_db, debut_agrs, gossip_source, &vec![], DEFAULT_MIN_HOPS_COUNT); + let result = subject.handle(&mut dest_db, debut_agrs, gossip_source, vec![], DEFAULT_MIN_HOPS_COUNT); assert_eq!(result, GossipAcceptanceResult::Accepted); assert_eq!( @@ -3386,6 +3358,8 @@ mod tests { let subject = IntroductionHandler::new(Logger::new("test")); let (gossip, gossip_source) = make_introduction(0, 1); let (cpm_recipient, recording_arc) = make_cpm_recipient(); + let mut neighborhood_metadata = make_default_neighborhood_metadata(); + neighborhood_metadata.cpm_recipient = cpm_recipient; let agrs: Vec = gossip.try_into().unwrap(); let (_introducer, introducee) = IntroductionHandler::identify_players(agrs.clone(), gossip_source).unwrap(); @@ -3398,9 +3372,7 @@ mod tests { &mut db, agrs, gossip_source, - &vec![], - &cpm_recipient, - DEFAULT_MIN_HOPS_COUNT + neighborhood_metadata ); System::current().stop(); @@ -3436,7 +3408,7 @@ mod tests { let (gossip, pass_target, gossip_source) = make_pass(2345); let subject = make_subject(main_cryptde()); - let result = subject.handle(&mut db, gossip.try_into().unwrap(), gossip_source, &vec![], DEFAULT_MIN_HOPS_COUNT); + let result = subject.handle(&mut db, gossip.try_into().unwrap(), gossip_source, vec![], DEFAULT_MIN_HOPS_COUNT); let expected_relay_gossip = GossipBuilder::new(&db) .node(root_node.public_key(), true) @@ -3461,6 +3433,8 @@ mod tests { let (gossip, pass_target, gossip_source) = make_pass(2345); let system = System::new("handles_a_new_pass_target"); let (cpm_recipient, recording_arc) = make_cpm_recipient(); + let mut neighborhood_metadata = make_default_neighborhood_metadata(); + neighborhood_metadata.cpm_recipient = cpm_recipient; let initial_timestamp = SystemTime::now(); let result = subject.handle( @@ -3468,9 +3442,7 @@ mod tests { &mut db, gossip.try_into().unwrap(), gossip_source, - &vec![], - &cpm_recipient, - DEFAULT_MIN_HOPS_COUNT + neighborhood_metadata ); let final_timestamp = SystemTime::now(); @@ -3515,6 +3487,8 @@ mod tests { ); let system = System::new("handles_pass_target_that_is_not_yet_expired"); let (cpm_recipient, recording_arc) = make_cpm_recipient(); + let mut neighborhood_metadata = make_default_neighborhood_metadata(); + neighborhood_metadata.cpm_recipient = cpm_recipient; let initial_timestamp = SystemTime::now(); let result = subject.handle( @@ -3522,9 +3496,7 @@ mod tests { &mut db, gossip.try_into().unwrap(), gossip_source, - &vec![], - &cpm_recipient, - DEFAULT_MIN_HOPS_COUNT + neighborhood_metadata ); let final_timestamp = SystemTime::now(); @@ -3557,15 +3529,16 @@ mod tests { let system = System::new("handles_pass_target_that_is_a_part_of_a_different_connection_progress"); let (cpm_recipient, recording_arc) = make_cpm_recipient(); + let mut neighborhood_metadata = make_default_neighborhood_metadata(); + neighborhood_metadata.cpm_recipient = cpm_recipient; + neighborhood_metadata.connection_progress_peers = vec![pass_target_ip_addr]; let result = subject.handle( cryptde, &mut db, gossip.try_into().unwrap(), gossip_source, - &vec![pass_target_ip_addr], - &cpm_recipient, - DEFAULT_MIN_HOPS_COUNT + neighborhood_metadata ); System::current().stop(); @@ -3590,6 +3563,8 @@ mod tests { let subject = PassHandler::new(); let (gossip, pass_target, gossip_source) = make_pass(2345); let (cpm_recipient, recording_arc) = make_cpm_recipient(); + let mut neighborhood_metadata = make_default_neighborhood_metadata(); + neighborhood_metadata.cpm_recipient = cpm_recipient; let pass_target_ip_addr = pass_target.node_addr_opt().unwrap().ip_addr(); let expired_time = PASS_GOSSIP_EXPIRED_TIME.add(Duration::from_secs(1)); subject @@ -3604,9 +3579,7 @@ mod tests { &mut db, gossip.try_into().unwrap(), gossip_source, - &vec![], - &cpm_recipient, - DEFAULT_MIN_HOPS_COUNT + neighborhood_metadata ); let final_timestamp = SystemTime::now(); @@ -3711,7 +3684,7 @@ mod tests { &mut dest_db, gossip.try_into().unwrap(), node_a.node_addr_opt().unwrap().into(), - &vec![], + vec![], DEFAULT_MIN_HOPS_COUNT ); @@ -3828,7 +3801,7 @@ mod tests { &mut dest_db, gossip.try_into().unwrap(), src_node.node_addr_opt().unwrap().into(), - &vec![], + vec![], DEFAULT_MIN_HOPS_COUNT ); @@ -3916,7 +3889,7 @@ mod tests { &mut dest_db, gossip.try_into().unwrap(), src_root.node_addr_opt().unwrap().into(), - &vec![], + vec![], DEFAULT_MIN_HOPS_COUNT ); diff --git a/node/src/neighborhood/mod.rs b/node/src/neighborhood/mod.rs index 321e76bc0..e0a9a9d03 100644 --- a/node/src/neighborhood/mod.rs +++ b/node/src/neighborhood/mod.rs @@ -746,7 +746,7 @@ impl Neighborhood { &mut self.neighborhood_database, agrs, gossip_source, - &connection_progress_peers, + connection_progress_peers, self.min_hops_count ); match acceptance_result { @@ -3841,7 +3841,7 @@ mod tests { database: &mut NeighborhoodDatabase, _agrs: Vec, _gossip_source: SocketAddr, - _connection_progress_peers: &[IpAddr], + _connection_progress_peers: Vec, _min_hops_count: u8, ) -> GossipAcceptanceResult { let non_root_database_keys = database @@ -4075,7 +4075,7 @@ mod tests { database: &mut NeighborhoodDatabase, _agrs: Vec, _gossip_source: SocketAddr, - _connection_progress_peers: &[IpAddr], + _connection_progress_peers: Vec, _min_hops_count: u8, ) -> GossipAcceptanceResult { let half_neighbor_keys = database @@ -5797,7 +5797,7 @@ mod tests { database: &mut NeighborhoodDatabase, agrs: Vec, gossip_source: SocketAddr, - connection_progress_peers: &[IpAddr], + connection_progress_peers: Vec, _min_hops_count: u8, ) -> GossipAcceptanceResult { self.handle_params.lock().unwrap().push(( From a6f77086b0eba90f00202798007ca49101ffa1ff Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Tue, 18 Apr 2023 15:38:43 +0530 Subject: [PATCH 12/56] GH-690: receive cpm_recipient from handle_agrs() instead of storing it inside GossipAcceptor --- node/src/neighborhood/gossip_acceptor.rs | 67 ++++++------------ node/src/neighborhood/mod.rs | 90 +++++++++++++----------- node/src/sub_lib/neighborhood.rs | 7 ++ 3 files changed, 77 insertions(+), 87 deletions(-) diff --git a/node/src/neighborhood/gossip_acceptor.rs b/node/src/neighborhood/gossip_acceptor.rs index ab9da0b2f..fd024383b 100644 --- a/node/src/neighborhood/gossip_acceptor.rs +++ b/node/src/neighborhood/gossip_acceptor.rs @@ -5,9 +5,7 @@ use crate::neighborhood::neighborhood_database::{NeighborhoodDatabase, Neighborh use crate::neighborhood::node_record::NodeRecord; use crate::neighborhood::AccessibleGossipRecord; use crate::sub_lib::cryptde::{CryptDE, PublicKey}; -use crate::sub_lib::neighborhood::{ - ConnectionProgressEvent, ConnectionProgressMessage, GossipFailure_0v1, -}; +use crate::sub_lib::neighborhood::{ConnectionProgressEvent, ConnectionProgressMessage, GossipFailure_0v1, NeighborhoodMetadata}; use crate::sub_lib::node_addr::NodeAddr; use actix::Recipient; use masq_lib::logger::Logger; @@ -49,12 +47,6 @@ trait NamedType { fn type_name(&self) -> &'static str; } -struct NeighborhoodMetadata { - connection_progress_peers: Vec, - cpm_recipient: Recipient, - min_hops_count: u8, -} - trait GossipHandler: NamedType + Send /* Send because lazily-written tests require it */ { fn qualifies( &self, @@ -1231,8 +1223,7 @@ pub trait GossipAcceptor: Send /* Send because lazily-written tests require it * database: &mut NeighborhoodDatabase, agrs: Vec, gossip_source: SocketAddr, - connection_progress_peers: Vec, - min_hops_count: u8, + neighborhood_metadata: NeighborhoodMetadata, ) -> GossipAcceptanceResult; } @@ -1249,8 +1240,7 @@ impl<'a> GossipAcceptor for GossipAcceptorReal<'a> { database: &mut NeighborhoodDatabase, agrs: Vec, gossip_source: SocketAddr, - connection_progress_peers: Vec, - min_hops_count: u8, + neighborhood_metadata: NeighborhoodMetadata, ) -> GossipAcceptanceResult { let (qualification, handler_ref) = self .gossip_handlers @@ -1265,11 +1255,11 @@ impl<'a> GossipAcceptor for GossipAcceptorReal<'a> { "Gossip delegated to {}", handler_ref.type_name() ); - let neighborhood_metadata = NeighborhoodMetadata { - connection_progress_peers, - cpm_recipient: self.cpm_recipient.clone(), - min_hops_count, - }; + // let neighborhood_metadata = NeighborhoodMetadata { + // connection_progress_peers, + // cpm_recipient: self.cpm_recipient.clone(), + // min_hops_count, + // }; handler_ref.handle( self.cryptde, database, @@ -2784,8 +2774,7 @@ mod tests { &mut dest_db, gossip.try_into().unwrap(), src_root.node_addr_opt().clone().unwrap().into(), - vec![], - DEFAULT_MIN_HOPS_COUNT + make_default_neighborhood_metadata() ); assert_eq!(result, GossipAcceptanceResult::Ignored); @@ -2869,8 +2858,7 @@ mod tests { &mut dest_db, gossip.try_into().unwrap(), src_node.node_addr_opt().unwrap().into(), - vec![], - DEFAULT_MIN_HOPS_COUNT + make_default_neighborhood_metadata() ); assert_eq!(GossipAcceptanceResult::Ignored, result); @@ -2889,8 +2877,7 @@ mod tests { &mut dest_db, gossip.try_into().unwrap(), gossip_source, - vec![], - DEFAULT_MIN_HOPS_COUNT + make_default_neighborhood_metadata() ); let after = time_t_timestamp(); @@ -2929,8 +2916,7 @@ mod tests { &mut dest_db, gossip.try_into().unwrap(), gossip_source, - vec![], - DEFAULT_MIN_HOPS_COUNT + make_default_neighborhood_metadata() ); let after = time_t_timestamp(); @@ -3001,8 +2987,7 @@ mod tests { &mut dest_db, gossip.try_into().unwrap(), gossip_source, - vec![], - DEFAULT_MIN_HOPS_COUNT + make_default_neighborhood_metadata() ); let after = time_t_timestamp(); @@ -3098,8 +3083,7 @@ mod tests { &mut dest_db, gossip.try_into().unwrap(), gossip_source, - vec![], - DEFAULT_MIN_HOPS_COUNT + make_default_neighborhood_metadata() ); let expected_acceptance_gossip_2 = GossipBuilder::new(&dest_db) @@ -3188,8 +3172,7 @@ mod tests { &mut dest_db, gossip.try_into().unwrap(), gossip_source, - vec![], - DEFAULT_MIN_HOPS_COUNT + make_default_neighborhood_metadata() ); let expected_acceptance_gossip = GossipBuilder::new(&dest_db) @@ -3244,8 +3227,7 @@ mod tests { &mut dest_db, debut.try_into().unwrap(), gossip_source, - vec![], - DEFAULT_MIN_HOPS_COUNT + make_default_neighborhood_metadata() ); assert_eq!(GossipAcceptanceResult::Ignored, result); @@ -3280,7 +3262,7 @@ mod tests { let subject = make_subject(main_cryptde()); let begin_at = time_t_timestamp(); - let result = subject.handle(&mut dest_db, debut_agrs, gossip_source, vec![], DEFAULT_MIN_HOPS_COUNT); + let result = subject.handle(&mut dest_db, debut_agrs, gossip_source, make_default_neighborhood_metadata()); let end_at = time_t_timestamp(); assert_eq!(GossipAcceptanceResult::Accepted, result); @@ -3308,7 +3290,7 @@ mod tests { let gossip_source = src_node.node_addr_opt().unwrap().into(); let subject = make_subject(main_cryptde()); - let result = subject.handle(&mut dest_db, debut_agrs, gossip_source, vec![], DEFAULT_MIN_HOPS_COUNT); + let result = subject.handle(&mut dest_db, debut_agrs, gossip_source, make_default_neighborhood_metadata()); assert_eq!(result, GossipAcceptanceResult::Accepted); assert_eq!( @@ -3338,7 +3320,7 @@ mod tests { let gossip_source = src_node.node_addr_opt().unwrap().into(); let subject = make_subject(main_cryptde()); - let result = subject.handle(&mut dest_db, debut_agrs, gossip_source, vec![], DEFAULT_MIN_HOPS_COUNT); + let result = subject.handle(&mut dest_db, debut_agrs, gossip_source, make_default_neighborhood_metadata()); assert_eq!(result, GossipAcceptanceResult::Accepted); assert_eq!( @@ -3408,7 +3390,7 @@ mod tests { let (gossip, pass_target, gossip_source) = make_pass(2345); let subject = make_subject(main_cryptde()); - let result = subject.handle(&mut db, gossip.try_into().unwrap(), gossip_source, vec![], DEFAULT_MIN_HOPS_COUNT); + let result = subject.handle(&mut db, gossip.try_into().unwrap(), gossip_source, make_default_neighborhood_metadata()); let expected_relay_gossip = GossipBuilder::new(&db) .node(root_node.public_key(), true) @@ -3684,8 +3666,7 @@ mod tests { &mut dest_db, gossip.try_into().unwrap(), node_a.node_addr_opt().unwrap().into(), - vec![], - DEFAULT_MIN_HOPS_COUNT + make_default_neighborhood_metadata() ); let after = time_t_timestamp(); @@ -3801,8 +3782,7 @@ mod tests { &mut dest_db, gossip.try_into().unwrap(), src_node.node_addr_opt().unwrap().into(), - vec![], - DEFAULT_MIN_HOPS_COUNT + make_default_neighborhood_metadata() ); let after = time_t_timestamp(); @@ -3889,8 +3869,7 @@ mod tests { &mut dest_db, gossip.try_into().unwrap(), src_root.node_addr_opt().unwrap().into(), - vec![], - DEFAULT_MIN_HOPS_COUNT + make_default_neighborhood_metadata() ); let after = time_t_timestamp(); diff --git a/node/src/neighborhood/mod.rs b/node/src/neighborhood/mod.rs index e0a9a9d03..68d326ef1 100644 --- a/node/src/neighborhood/mod.rs +++ b/node/src/neighborhood/mod.rs @@ -13,7 +13,7 @@ use std::convert::TryFrom; use std::net::{IpAddr, SocketAddr}; use std::path::PathBuf; -use actix::Addr; +use actix::{Addr, AsyncContext}; use actix::Context; use actix::Handler; use actix::MessageResult; @@ -46,7 +46,7 @@ use crate::sub_lib::cryptde::{CryptDE, CryptData, PlainData}; use crate::sub_lib::dispatcher::{Component, StreamShutdownMsg}; use crate::sub_lib::hopper::{ExpiredCoresPackage, NoLookupIncipientCoresPackage}; use crate::sub_lib::hopper::{IncipientCoresPackage, MessageType}; -use crate::sub_lib::neighborhood::NodeQueryResponseMetadata; +use crate::sub_lib::neighborhood::{NeighborhoodMetadata, NodeQueryResponseMetadata}; use crate::sub_lib::neighborhood::NodeRecordMetadataMessage; use crate::sub_lib::neighborhood::RemoveNeighborMessage; use crate::sub_lib::neighborhood::RouteQueryMessage; @@ -224,11 +224,12 @@ impl Handler> for Neighborhood { fn handle( &mut self, msg: ExpiredCoresPackage, - _ctx: &mut Self::Context, + ctx: &mut Self::Context, ) -> Self::Result { let incoming_gossip = msg.payload; + let cpm_recipient = ctx.address().recipient::(); self.log_incoming_gossip(&incoming_gossip, msg.immediate_neighbor); - self.handle_gossip(incoming_gossip, msg.immediate_neighbor); + self.handle_gossip(incoming_gossip, msg.immediate_neighbor, cpm_recipient); } } @@ -630,7 +631,7 @@ impl Neighborhood { ); } - fn handle_gossip(&mut self, incoming_gossip: Gossip_0v1, gossip_source: SocketAddr) { + fn handle_gossip(&mut self, incoming_gossip: Gossip_0v1, gossip_source: SocketAddr, cpm_recipient: Recipient) { let record_count = incoming_gossip.node_records.len(); info!( self.logger, @@ -669,7 +670,7 @@ impl Neighborhood { return; } - self.handle_gossip_agrs(agrs, gossip_source); + self.handle_gossip_agrs(agrs, gossip_source, cpm_recipient); self.announce_gossip_handling_completion(record_count); } @@ -718,9 +719,9 @@ impl Neighborhood { .collect() } - fn handle_gossip_agrs(&mut self, agrs: Vec, gossip_source: SocketAddr) { + fn handle_gossip_agrs(&mut self, agrs: Vec, gossip_source: SocketAddr, cpm_recipient: Recipient) { let neighbor_keys_before = self.neighbor_keys(); - self.handle_agrs(agrs, gossip_source); + self.handle_agrs(agrs, gossip_source, cpm_recipient); let neighbor_keys_after = self.neighbor_keys(); self.handle_database_changes(neighbor_keys_before, neighbor_keys_after); } @@ -734,10 +735,14 @@ impl Neighborhood { .collect() } - fn handle_agrs(&mut self, agrs: Vec, gossip_source: SocketAddr) { + fn handle_agrs(&mut self, agrs: Vec, gossip_source: SocketAddr, cpm_recipient: Recipient) { let ignored_node_name = self.gossip_source_name(&agrs, gossip_source); let gossip_record_count = agrs.len(); - let connection_progress_peers = self.overall_connection_status.get_peer_addrs(); + let neighborhood_metadata = NeighborhoodMetadata { + connection_progress_peers: self.overall_connection_status.get_peer_addrs(), + cpm_recipient, + min_hops_count: self.min_hops_count, + }; let acceptance_result = self .gossip_acceptor_opt .as_ref() @@ -746,8 +751,7 @@ impl Neighborhood { &mut self.neighborhood_database, agrs, gossip_source, - connection_progress_peers, - self.min_hops_count + neighborhood_metadata ); match acceptance_result { GossipAcceptanceResult::Accepted => self.gossip_to_neighbors(), @@ -1614,7 +1618,7 @@ mod tests { use crate::sub_lib::dispatcher::Endpoint; use crate::sub_lib::hop::LiveHop; use crate::sub_lib::hopper::MessageType; - use crate::sub_lib::neighborhood::RatePack; + use crate::sub_lib::neighborhood::{NeighborhoodMetadata, RatePack}; use crate::sub_lib::neighborhood::{ AskAboutDebutGossipMessage, ExpectedServices, NeighborhoodMode, }; @@ -1635,10 +1639,7 @@ mod tests { use crate::test_utils::recorder::peer_actors_builder; use crate::test_utils::recorder::Recorder; use crate::test_utils::recorder::Recording; - use crate::test_utils::unshared_test_utils::{ - make_node_to_ui_recipient, make_recipient_and_recording_arc, - prove_that_crash_request_handler_is_hooked_up, AssertionsMessage, - }; + use crate::test_utils::unshared_test_utils::{make_node_to_ui_recipient, make_recipient_and_recording_arc, prove_that_crash_request_handler_is_hooked_up, AssertionsMessage, make_cpm_recipient}; use crate::test_utils::vec_to_set; use crate::test_utils::{main_cryptde, make_paying_wallet}; @@ -3726,7 +3727,7 @@ mod tests { System::current().stop(); system.run(); let mut handle_params = handle_params_arc.lock().unwrap(); - let (call_database, call_agrs, call_gossip_source, connection_progress_peers) = + let (call_database, call_agrs, call_gossip_source, neighborhood_metadata) = handle_params.remove(0); assert!(handle_params.is_empty()); assert_eq!(&subject_node, call_database.root()); @@ -3736,7 +3737,7 @@ mod tests { let actual_gossip_source: SocketAddr = subject_node.node_addr_opt().unwrap().into(); assert_eq!(actual_gossip_source, call_gossip_source); let neighbor_ip = neighbor.node_addr_opt().unwrap().ip_addr(); - assert_eq!(connection_progress_peers, vec![neighbor_ip]); + assert_eq!(neighborhood_metadata.connection_progress_peers, vec![neighbor_ip]); } #[test] @@ -3772,6 +3773,7 @@ mod tests { subject.handle_gossip( Gossip_0v1::new(vec![]), SocketAddr::from_str("1.1.1.1:1111").unwrap(), + make_cpm_recipient().0 ); System::current().stop(); @@ -3809,7 +3811,7 @@ mod tests { subject.hopper_no_lookup_opt = Some(peer_actors.hopper.from_hopper_client_no_lookup); subject.gossip_acceptor_opt = Some(Box::new(gossip_acceptor)); - subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap()); + subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap(), make_cpm_recipient().0); System::current().stop(); system.run(); @@ -3841,8 +3843,7 @@ mod tests { database: &mut NeighborhoodDatabase, _agrs: Vec, _gossip_source: SocketAddr, - _connection_progress_peers: Vec, - _min_hops_count: u8, + _neighborhood_metadata: NeighborhoodMetadata, ) -> GossipAcceptanceResult { let non_root_database_keys = database .keys() @@ -3904,7 +3905,7 @@ mod tests { let peer_actors = peer_actors_builder().accountant(accountant).build(); bind_subject(&mut subject, peer_actors); - subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap()); + subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap(), make_cpm_recipient().0); System::current().stop(); system.run(); @@ -3927,7 +3928,7 @@ mod tests { let peer_actors = peer_actors_builder().accountant(accountant).build(); bind_subject(&mut subject, peer_actors); - subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap()); + subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap(), make_cpm_recipient().0); System::current().stop(); system.run(); @@ -3945,7 +3946,7 @@ mod tests { bind_subject(&mut subject, peer_actors); let system = System::new("neighborhood_does_not_start_accountant_if_no_route_can_be_made"); - subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap()); + subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap(), make_cpm_recipient().0); System::current().stop(); system.run(); @@ -3990,7 +3991,7 @@ mod tests { .build(); let agrs: Vec = pass_gossip.try_into().unwrap(); - subject.handle_agrs(agrs, peer_2_socket_addr); + subject.handle_agrs(agrs, peer_2_socket_addr, make_cpm_recipient().0); TestLogHandler::new() .exists_log_containing(&format!("Gossip from {} ignored", peer_2_socket_addr)); @@ -4010,7 +4011,7 @@ mod tests { subject.connected_signal_opt = Some(connected_signal); let system = System::new(test_name); - subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap()); + subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap(), make_cpm_recipient().0); System::current().stop(); system.run(); @@ -4052,7 +4053,7 @@ mod tests { subject.connected_signal_opt = Some(connected_signal); let system = System::new(test_name); - subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap()); + subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap(), make_cpm_recipient().0); System::current().stop(); system.run(); @@ -4075,8 +4076,7 @@ mod tests { database: &mut NeighborhoodDatabase, _agrs: Vec, _gossip_source: SocketAddr, - _connection_progress_peers: Vec, - _min_hops_count: u8, + _neighborhood_metadata: NeighborhoodMetadata, ) -> GossipAcceptanceResult { let half_neighbor_keys = database .root() @@ -4120,7 +4120,7 @@ mod tests { subject.gossip_acceptor_opt = Some(Box::new(gossip_acceptor)); subject.persistent_config_opt = Some(Box::new(persistent_config)); - subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap()); + subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap(), make_cpm_recipient().0); let mut set_past_neighbors_params = set_past_neighbors_params_arc.lock().unwrap(); let (neighbors_opt, db_password) = set_past_neighbors_params.remove(0); @@ -4159,7 +4159,7 @@ mod tests { subject.gossip_acceptor_opt = Some(Box::new(gossip_acceptor)); subject.persistent_config_opt = Some(Box::new(persistent_config)); - subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap()); + subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap(), make_cpm_recipient().0); let mut set_past_neighbors_params = set_past_neighbors_params_arc.lock().unwrap(); let (neighbors_opt, db_password) = set_past_neighbors_params.remove(0); @@ -4190,7 +4190,7 @@ mod tests { subject.gossip_acceptor_opt = Some(Box::new(gossip_acceptor)); subject.persistent_config_opt = Some(Box::new(persistent_config)); - subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap()); + subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap(), make_cpm_recipient().0); let set_past_neighbors_params = set_past_neighbors_params_arc.lock().unwrap(); assert!(set_past_neighbors_params.is_empty()); @@ -4220,7 +4220,7 @@ mod tests { subject.persistent_config_opt = Some(Box::new(persistent_config)); subject.db_password_opt = None; - subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap()); + subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap(), make_cpm_recipient().0); let set_past_neighbors_params = set_past_neighbors_params_arc.lock().unwrap(); assert!(set_past_neighbors_params.is_empty()); @@ -4249,7 +4249,7 @@ mod tests { subject.gossip_acceptor_opt = Some(Box::new(gossip_acceptor)); subject.persistent_config_opt = Some(Box::new(persistent_config)); - subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap()); + subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap(), make_cpm_recipient().0); TestLogHandler::new().exists_log_containing("WARN: Neighborhood: Could not persist immediate-neighbor changes: database locked - skipping"); } @@ -4277,7 +4277,7 @@ mod tests { subject.gossip_acceptor_opt = Some(Box::new(gossip_acceptor)); subject.persistent_config_opt = Some(Box::new(persistent_config)); - subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap()); + subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap(), make_cpm_recipient().0); TestLogHandler::new().exists_log_containing("ERROR: Neighborhood: Could not persist immediate-neighbor changes: DatabaseError(\"Booga\")"); } @@ -4348,6 +4348,7 @@ mod tests { subject.handle_gossip( Gossip_0v1::new(vec![]), SocketAddr::from_str("1.1.1.1:1111").unwrap(), + make_cpm_recipient().0 ); System::current().stop(); @@ -4438,6 +4439,7 @@ mod tests { subject.handle_gossip( Gossip_0v1::new(vec![]), SocketAddr::from_str("1.1.1.1:1111").unwrap(), + make_cpm_recipient().0 ); System::current().stop(); @@ -4473,6 +4475,7 @@ mod tests { // In real life this would be Relay Gossip from gossip_source to debut_node. Gossip_0v1::new(vec![]), gossip_source, + make_cpm_recipient().0 ); System::current().stop(); @@ -4514,6 +4517,7 @@ mod tests { subject.handle_gossip( Gossip_0v1::new(vec![]), subject_node.node_addr_opt().unwrap().into(), + make_cpm_recipient().0 ); System::current().stop(); @@ -4540,6 +4544,7 @@ mod tests { subject.handle_gossip( Gossip_0v1::new(vec![]), subject_node.node_addr_opt().unwrap().into(), + make_cpm_recipient().0 ); System::current().stop(); @@ -4566,7 +4571,7 @@ mod tests { gossip.node_records[1].signed_data = PlainData::new(&[1, 2, 3, 4]); // corrupt second record let gossip_source = SocketAddr::from_str("1.2.3.4:1234").unwrap(); - subject.handle_gossip(gossip, gossip_source); + subject.handle_gossip(gossip, gossip_source, make_cpm_recipient().0); // No panic means that subject didn't try to invoke the GossipAcceptorMock: test passes! TestLogHandler::new().exists_log_containing(&format!( @@ -4591,7 +4596,7 @@ mod tests { gossip.node_records[1].signature = CryptData::new(&[1, 2, 3, 4]); // corrupt second record let gossip_source = SocketAddr::from_str("1.2.3.4:1234").unwrap(); - subject.handle_gossip(gossip, gossip_source); + subject.handle_gossip(gossip, gossip_source, make_cpm_recipient().0); // No panic means that subject didn't try to invoke the GossipAcceptorMock: test passes! TestLogHandler::new().exists_log_containing(&format!( @@ -5784,7 +5789,7 @@ mod tests { NeighborhoodDatabase, Vec, SocketAddr, - Vec, + NeighborhoodMetadata, )>, >, >, @@ -5797,14 +5802,13 @@ mod tests { database: &mut NeighborhoodDatabase, agrs: Vec, gossip_source: SocketAddr, - connection_progress_peers: Vec, - _min_hops_count: u8, + neighborhood_metadata: NeighborhoodMetadata, ) -> GossipAcceptanceResult { self.handle_params.lock().unwrap().push(( database.clone(), agrs, gossip_source, - connection_progress_peers.to_vec(), + neighborhood_metadata, )); self.handle_results.borrow_mut().remove(0) } @@ -5826,7 +5830,7 @@ mod tests { NeighborhoodDatabase, Vec, SocketAddr, - Vec, + NeighborhoodMetadata, )>, >, >, diff --git a/node/src/sub_lib/neighborhood.rs b/node/src/sub_lib/neighborhood.rs index c4ace19f9..bf8e619c9 100644 --- a/node/src/sub_lib/neighborhood.rs +++ b/node/src/sub_lib/neighborhood.rs @@ -551,6 +551,13 @@ impl fmt::Display for GossipFailure_0v1 { } } +// This metadata is only passed from Neighborhood to GossipHandler +pub struct NeighborhoodMetadata { + pub connection_progress_peers: Vec, + pub cpm_recipient: Recipient, + pub min_hops_count: u8, +} + pub struct NeighborhoodTools { pub notify_later_ask_about_gossip: Box>, From fbad5e1dd45f5cda9c9c38e206c8f46f52c7dab3 Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Tue, 18 Apr 2023 15:52:45 +0530 Subject: [PATCH 13/56] GH-690: remove cpm_recipient from gossip_acceptor --- node/src/neighborhood/gossip_acceptor.rs | 12 ++---------- node/src/neighborhood/mod.rs | 1 - 2 files changed, 2 insertions(+), 11 deletions(-) diff --git a/node/src/neighborhood/gossip_acceptor.rs b/node/src/neighborhood/gossip_acceptor.rs index fd024383b..768e32174 100644 --- a/node/src/neighborhood/gossip_acceptor.rs +++ b/node/src/neighborhood/gossip_acceptor.rs @@ -7,7 +7,6 @@ use crate::neighborhood::AccessibleGossipRecord; use crate::sub_lib::cryptde::{CryptDE, PublicKey}; use crate::sub_lib::neighborhood::{ConnectionProgressEvent, ConnectionProgressMessage, GossipFailure_0v1, NeighborhoodMetadata}; use crate::sub_lib::node_addr::NodeAddr; -use actix::Recipient; use masq_lib::logger::Logger; use std::cell::RefCell; use std::collections::{HashMap, HashSet}; @@ -1231,7 +1230,6 @@ pub struct GossipAcceptorReal<'a> { cryptde: &'a dyn CryptDE, gossip_handlers: Vec>, logger: Logger, - cpm_recipient: Recipient, } impl<'a> GossipAcceptor for GossipAcceptorReal<'a> { @@ -1279,7 +1277,6 @@ impl<'a> GossipAcceptor for GossipAcceptorReal<'a> { impl<'a> GossipAcceptorReal<'a> { pub fn new( cryptde: &'a dyn CryptDE, - cpm_recipient: Recipient, ) -> GossipAcceptorReal { let logger = Logger::new("GossipAcceptor"); GossipAcceptorReal { @@ -1292,7 +1289,6 @@ impl<'a> GossipAcceptorReal<'a> { ], cryptde, logger, - cpm_recipient, } } @@ -1341,10 +1337,9 @@ mod tests { use crate::test_utils::neighborhood_test_utils::{ db_from_node, make_meaningless_db, make_node_record, make_node_record_f, }; - use crate::test_utils::recorder::make_recorder; use crate::test_utils::unshared_test_utils::make_cpm_recipient; use crate::test_utils::{assert_contains, main_cryptde, vec_to_set}; - use actix::{Actor, System}; + use actix::System; use masq_lib::test_utils::logging::{init_test_logging, TestLogHandler}; use masq_lib::test_utils::utils::TEST_DEFAULT_CHAIN; use std::convert::TryInto; @@ -4227,10 +4222,7 @@ mod tests { } fn make_subject(crypt_de: &dyn CryptDE) -> GossipAcceptorReal { - let (neighborhood, _, _) = make_recorder(); - let addr = neighborhood.start(); - let recipient = addr.recipient::(); - GossipAcceptorReal::new(crypt_de, recipient) + GossipAcceptorReal::new(crypt_de) } fn assert_node_records_eq( diff --git a/node/src/neighborhood/mod.rs b/node/src/neighborhood/mod.rs index 68d326ef1..27243c7f4 100644 --- a/node/src/neighborhood/mod.rs +++ b/node/src/neighborhood/mod.rs @@ -117,7 +117,6 @@ impl Handler for Neighborhood { self.connected_signal_opt = Some(msg.peer_actors.accountant.start); self.gossip_acceptor_opt = Some(Box::new(GossipAcceptorReal::new( self.cryptde, - msg.peer_actors.neighborhood.connection_progress_sub, ))); self.gossip_producer_opt = Some(Box::new(GossipProducerReal::new())); self.node_to_ui_recipient_opt = Some(msg.peer_actors.ui_gateway.node_to_ui_message_sub); From 80cab883a9f5ad83bf840b875a40bcba337efd84 Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Tue, 18 Apr 2023 16:49:00 +0530 Subject: [PATCH 14/56] GH-690: generate gossip_acceptor and gossip_producer inside Neighborhood's constructor instead of the BindMessage --- node/src/neighborhood/mod.rs | 96 ++++++++++++------------------------ 1 file changed, 32 insertions(+), 64 deletions(-) diff --git a/node/src/neighborhood/mod.rs b/node/src/neighborhood/mod.rs index 27243c7f4..f333f8aa7 100644 --- a/node/src/neighborhood/mod.rs +++ b/node/src/neighborhood/mod.rs @@ -87,8 +87,8 @@ pub struct Neighborhood { hopper_no_lookup_opt: Option>, connected_signal_opt: Option>, node_to_ui_recipient_opt: Option>, - gossip_acceptor_opt: Option>, - gossip_producer_opt: Option>, + gossip_acceptor: Box, + gossip_producer: Box, neighborhood_database: NeighborhoodDatabase, consuming_wallet_opt: Option, min_hops_count: u8, @@ -115,10 +115,6 @@ impl Handler for Neighborhood { self.hopper_opt = Some(msg.peer_actors.hopper.from_hopper_client); self.hopper_no_lookup_opt = Some(msg.peer_actors.hopper.from_hopper_client_no_lookup); self.connected_signal_opt = Some(msg.peer_actors.accountant.start); - self.gossip_acceptor_opt = Some(Box::new(GossipAcceptorReal::new( - self.cryptde, - ))); - self.gossip_producer_opt = Some(Box::new(GossipProducerReal::new())); self.node_to_ui_recipient_opt = Some(msg.peer_actors.ui_gateway.node_to_ui_message_sub); } } @@ -474,8 +470,10 @@ impl Neighborhood { hopper_no_lookup_opt: None, connected_signal_opt: None, node_to_ui_recipient_opt: None, - gossip_acceptor_opt: None, - gossip_producer_opt: None, + gossip_acceptor: Box::new(GossipAcceptorReal::new( + cryptde, + )), + gossip_producer: Box::new(GossipProducerReal::new()), neighborhood_database, consuming_wallet_opt: config.consuming_wallet_opt.clone(), min_hops_count, @@ -579,9 +577,7 @@ impl Neighborhood { } let gossip = self - .gossip_producer_opt - .as_ref() - .expect("Gossip Producer uninitialized") + .gossip_producer .produce_debut(&self.neighborhood_database); self.overall_connection_status .iter_initial_node_descriptors() @@ -743,9 +739,7 @@ impl Neighborhood { min_hops_count: self.min_hops_count, }; let acceptance_result = self - .gossip_acceptor_opt - .as_ref() - .expect("Gossip Acceptor wasn't created.") + .gossip_acceptor .handle( &mut self.neighborhood_database, agrs, @@ -881,9 +875,7 @@ impl Neighborhood { .collect_vec(); neighbors.iter().for_each(|neighbor| { if let Some(gossip) = self - .gossip_producer_opt - .as_ref() - .expect("Gossip Producer uninitialized") + .gossip_producer .produce(&mut self.neighborhood_database, neighbor) { self.gossip_to_neighbor(neighbor, gossip) @@ -1802,24 +1794,6 @@ mod tests { assert_eq!(root_node_record_ref.half_neighbor_keys().len(), 0); } - #[test] - fn gossip_acceptor_and_gossip_producer_are_properly_initialized_through_bind_message() { - let subject = make_standard_subject(); - let addr = subject.start(); - let peer_actors = peer_actors_builder().build(); - let system = System::new("test"); - let assertions = Box::new(move |actor: &mut Neighborhood| { - assert!(actor.gossip_acceptor_opt.is_some()); - assert!(actor.gossip_producer_opt.is_some()); - }); - - addr.try_send(BindMessage { peer_actors }).unwrap(); - - addr.try_send(AssertionsMessage { assertions }).unwrap(); - System::current().stop(); - assert_eq!(system.run(), 0); - } - #[test] fn node_with_zero_hop_config_ignores_start_message() { init_test_logging(); @@ -3706,7 +3680,7 @@ mod tests { let subject_node = make_global_cryptde_node_record(1234, true); // 9e7p7un06eHs6frl5A let neighbor = make_node_record(1111, true); let mut subject = neighborhood_from_nodes(&subject_node, Some(&neighbor)); - subject.gossip_acceptor_opt = Some(Box::new(gossip_acceptor)); + subject.gossip_acceptor = Box::new(gossip_acceptor); let gossip = GossipBuilder::new(&subject.neighborhood_database) .node(subject_node.public_key(), true) .build(); @@ -3763,7 +3737,7 @@ mod tests { introduction_target_node.public_key().clone(), introduction_target_node.node_addr_opt().unwrap(), )); - subject.gossip_acceptor_opt = Some(Box::new(gossip_acceptor)); + subject.gossip_acceptor = Box::new(gossip_acceptor); let (hopper, _, hopper_recording_arc) = make_recorder(); let peer_actors = peer_actors_builder().hopper(hopper).build(); let system = System::new(""); @@ -3808,7 +3782,7 @@ mod tests { let system = System::new("neighborhood_transmits_gossip_failure_properly"); let peer_actors = peer_actors_builder().hopper(hopper).build(); subject.hopper_no_lookup_opt = Some(peer_actors.hopper.from_hopper_client_no_lookup); - subject.gossip_acceptor_opt = Some(Box::new(gossip_acceptor)); + subject.gossip_acceptor = Box::new(gossip_acceptor); subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap(), make_cpm_recipient().0); @@ -3896,9 +3870,9 @@ mod tests { replacement_database.add_node(neighbor.clone()).unwrap(); replacement_database .add_arbitrary_half_neighbor(subject_node.public_key(), neighbor.public_key()); - subject.gossip_acceptor_opt = Some(Box::new(DatabaseReplacementGossipAcceptor { + subject.gossip_acceptor = Box::new(DatabaseReplacementGossipAcceptor { replacement_database, - })); + }); let (accountant, _, accountant_recording_arc) = make_recorder(); let system = System::new("neighborhood_does_not_start_accountant_if_no_route_can_be_made"); let peer_actors = peer_actors_builder().accountant(accountant).build(); @@ -3919,9 +3893,9 @@ mod tests { let neighbor = make_node_record(1111, true); let mut subject: Neighborhood = neighborhood_from_nodes(&subject_node, Some(&neighbor)); let replacement_database = subject.neighborhood_database.clone(); - subject.gossip_acceptor_opt = Some(Box::new(DatabaseReplacementGossipAcceptor { + subject.gossip_acceptor = Box::new(DatabaseReplacementGossipAcceptor { replacement_database, - })); + }); let (accountant, _, accountant_recording_arc) = make_recorder(); let system = System::new("neighborhood_does_not_start_accountant_if_already_connected"); let peer_actors = peer_actors_builder().accountant(accountant).build(); @@ -3980,7 +3954,7 @@ mod tests { bc_from_nc_plus(neighborhood_config, make_wallet("earning"), None, "test"); let mut subject = Neighborhood::new(main_cryptde(), &bootstrap_config); subject.node_to_ui_recipient_opt = Some(node_to_ui_recipient); - subject.gossip_acceptor_opt = Some(Box::new(gossip_acceptor)); + subject.gossip_acceptor = Box::new(gossip_acceptor); let mut peer_2_db = db_from_node(&peer_2); peer_2_db.add_node(peer_1.clone()).unwrap(); peer_2_db.add_arbitrary_full_neighbor(peer_2.public_key(), peer_1.public_key()); @@ -4116,7 +4090,7 @@ mod tests { let persistent_config = PersistentConfigurationMock::new() .set_past_neighbors_params(&set_past_neighbors_params_arc) .set_past_neighbors_result(Ok(())); - subject.gossip_acceptor_opt = Some(Box::new(gossip_acceptor)); + subject.gossip_acceptor = Box::new(gossip_acceptor); subject.persistent_config_opt = Some(Box::new(persistent_config)); subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap(), make_cpm_recipient().0); @@ -4155,7 +4129,7 @@ mod tests { let persistent_config = PersistentConfigurationMock::new() .set_past_neighbors_params(&set_past_neighbors_params_arc) .set_past_neighbors_result(Ok(())); - subject.gossip_acceptor_opt = Some(Box::new(gossip_acceptor)); + subject.gossip_acceptor = Box::new(gossip_acceptor); subject.persistent_config_opt = Some(Box::new(persistent_config)); subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap(), make_cpm_recipient().0); @@ -4186,7 +4160,7 @@ mod tests { let set_past_neighbors_params_arc = Arc::new(Mutex::new(vec![])); let persistent_config = PersistentConfigurationMock::new() .set_past_neighbors_params(&set_past_neighbors_params_arc); - subject.gossip_acceptor_opt = Some(Box::new(gossip_acceptor)); + subject.gossip_acceptor = Box::new(gossip_acceptor); subject.persistent_config_opt = Some(Box::new(persistent_config)); subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap(), make_cpm_recipient().0); @@ -4215,7 +4189,7 @@ mod tests { let set_past_neighbors_params_arc = Arc::new(Mutex::new(vec![])); let persistent_config = PersistentConfigurationMock::new() .set_past_neighbors_params(&set_past_neighbors_params_arc); - subject.gossip_acceptor_opt = Some(Box::new(gossip_acceptor)); + subject.gossip_acceptor = Box::new(gossip_acceptor); subject.persistent_config_opt = Some(Box::new(persistent_config)); subject.db_password_opt = None; @@ -4245,7 +4219,7 @@ mod tests { let persistent_config = PersistentConfigurationMock::new().set_past_neighbors_result(Err( PersistentConfigError::DatabaseError("database is locked".to_string()), )); - subject.gossip_acceptor_opt = Some(Box::new(gossip_acceptor)); + subject.gossip_acceptor = Box::new(gossip_acceptor); subject.persistent_config_opt = Some(Box::new(persistent_config)); subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap(), make_cpm_recipient().0); @@ -4273,7 +4247,7 @@ mod tests { let persistent_config = PersistentConfigurationMock::new().set_past_neighbors_result(Err( PersistentConfigError::DatabaseError("Booga".to_string()), )); - subject.gossip_acceptor_opt = Some(Box::new(gossip_acceptor)); + subject.gossip_acceptor = Box::new(gossip_acceptor); subject.persistent_config_opt = Some(Box::new(persistent_config)); subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap(), make_cpm_recipient().0); @@ -4330,14 +4304,14 @@ mod tests { .add_arbitrary_half_neighbor(subject_node.public_key(), half_neighbor.public_key()); let gossip_acceptor = GossipAcceptorMock::new().handle_result(GossipAcceptanceResult::Accepted); - subject.gossip_acceptor_opt = Some(Box::new(gossip_acceptor)); + subject.gossip_acceptor = Box::new(gossip_acceptor); let gossip = Gossip_0v1::new(vec![]); let produce_params_arc = Arc::new(Mutex::new(vec![])); let gossip_producer = GossipProducerMock::new() .produce_params(&produce_params_arc) .produce_result(Some(gossip.clone())) .produce_result(Some(gossip.clone())); - subject.gossip_producer_opt = Some(Box::new(gossip_producer)); + subject.gossip_producer = Box::new(gossip_producer); let (hopper, _, hopper_recording_arc) = make_recorder(); let peer_actors = peer_actors_builder().hopper(hopper).build(); @@ -4423,12 +4397,12 @@ mod tests { .add_arbitrary_full_neighbor(subject_node.public_key(), ungossippable.public_key()); let gossip_acceptor = GossipAcceptorMock::new().handle_result(GossipAcceptanceResult::Accepted); - subject.gossip_acceptor_opt = Some(Box::new(gossip_acceptor)); + subject.gossip_acceptor = Box::new(gossip_acceptor); let produce_params_arc = Arc::new(Mutex::new(vec![])); let gossip_producer = GossipProducerMock::new() .produce_params(&produce_params_arc) .produce_result(None); - subject.gossip_producer_opt = Some(Box::new(gossip_producer)); + subject.gossip_producer = Box::new(gossip_producer); let (hopper, _, hopper_recording_arc) = make_recorder(); let peer_actors = peer_actors_builder().hopper(hopper).build(); @@ -4463,7 +4437,7 @@ mod tests { debut_node.public_key().clone(), debut_node.node_addr_opt().unwrap(), )); - subject.gossip_acceptor_opt = Some(Box::new(gossip_acceptor)); + subject.gossip_acceptor = Box::new(gossip_acceptor); let (hopper, _, hopper_recording_arc) = make_recorder(); let peer_actors = peer_actors_builder().hopper(hopper).build(); let system = System::new(""); @@ -4506,7 +4480,7 @@ mod tests { let mut subject = neighborhood_from_nodes(&subject_node, Some(&neighbor)); let gossip_acceptor = GossipAcceptorMock::new().handle_result(GossipAcceptanceResult::Ignored); - subject.gossip_acceptor_opt = Some(Box::new(gossip_acceptor)); + subject.gossip_acceptor = Box::new(gossip_acceptor); let subject_node = subject.neighborhood_database.root().clone(); let (hopper, _, hopper_recording_arc) = make_recorder(); let peer_actors = peer_actors_builder().hopper(hopper).build(); @@ -4533,7 +4507,7 @@ mod tests { let mut subject = neighborhood_from_nodes(&subject_node, Some(&neighbor)); let gossip_acceptor = GossipAcceptorMock::new() .handle_result(GossipAcceptanceResult::Ban("Bad guy".to_string())); - subject.gossip_acceptor_opt = Some(Box::new(gossip_acceptor)); + subject.gossip_acceptor = Box::new(gossip_acceptor); let subject_node = subject.neighborhood_database.root().clone(); let (hopper, _, hopper_recording_arc) = make_recorder(); let peer_actors = peer_actors_builder().hopper(hopper).build(); @@ -4558,8 +4532,6 @@ mod tests { fn neighborhood_does_not_accept_gossip_if_a_record_is_non_deserializable() { init_test_logging(); let mut subject = make_standard_subject(); - let gossip_acceptor = GossipAcceptorMock::new(); - subject.gossip_acceptor_opt = Some(Box::new(gossip_acceptor)); let db = &mut subject.neighborhood_database; let one_node_key = &db.add_node(make_node_record(2222, true)).unwrap(); let another_node_key = &db.add_node(make_node_record(3333, true)).unwrap(); @@ -4583,8 +4555,6 @@ mod tests { fn neighborhood_does_not_accept_gossip_if_a_record_signature_is_invalid() { init_test_logging(); let mut subject = make_standard_subject(); - let gossip_acceptor = GossipAcceptorMock::new(); - subject.gossip_acceptor_opt = Some(Box::new(gossip_acceptor)); let db = &mut subject.neighborhood_database; let one_node_key = &db.add_node(make_node_record(2222, true)).unwrap(); let another_node_key = &db.add_node(make_node_record(3333, true)).unwrap(); @@ -5525,7 +5495,6 @@ mod tests { ); let peer_actors = peer_actors_builder().hopper(hopper).build(); subject.hopper_opt = Some(peer_actors.hopper.from_hopper_client); - subject.gossip_producer_opt = Some(Box::new(GossipProducerReal::new())); subject.handle_stream_shutdown_msg(StreamShutdownMsg { peer_addr: shutdown_neighbor_node_socket_addr, @@ -5752,7 +5721,6 @@ mod tests { let mut subject = neighborhood_from_nodes(&root_node, Some(&neighbor_node)); let persistent_config = PersistentConfigurationMock::new(); subject.persistent_config_opt = Some(Box::new(persistent_config)); - assert!(subject.gossip_acceptor_opt.is_none()); subject } @@ -6007,9 +5975,9 @@ mod tests { .add_arbitrary_full_neighbor(&nodes[i as usize - 1], &nodes[i as usize]); } - neighborhood.gossip_acceptor_opt = Some(Box::new(DatabaseReplacementGossipAcceptor { + neighborhood.gossip_acceptor = Box::new(DatabaseReplacementGossipAcceptor { replacement_database, - })); + }); neighborhood.persistent_config_opt = Some(Box::new( PersistentConfigurationMock::new().set_past_neighbors_result(Ok(())), )); From 4c0578127c47b40fa22f521e29b5a2c95fdbdb25 Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Wed, 19 Apr 2023 08:49:05 +0530 Subject: [PATCH 15/56] GH-690: store hops count as an enum --- node/src/neighborhood/gossip_acceptor.rs | 8 +-- node/src/neighborhood/mod.rs | 12 ++--- .../unprivileged_parse_args_configuration.rs | 21 +++----- node/src/sub_lib/neighborhood.rs | 49 ++++++++++++++++++- 4 files changed, 64 insertions(+), 26 deletions(-) diff --git a/node/src/neighborhood/gossip_acceptor.rs b/node/src/neighborhood/gossip_acceptor.rs index 768e32174..66c0a1d8c 100644 --- a/node/src/neighborhood/gossip_acceptor.rs +++ b/node/src/neighborhood/gossip_acceptor.rs @@ -933,7 +933,7 @@ impl GossipHandler for StandardGossipHandler { let initial_neighborship_status = StandardGossipHandler::check_full_neighbor(database, gossip_source.ip()); - let patch = self.compute_patch(&agrs, database.root(), neighborhood_metadata.min_hops_count); + let patch = self.compute_patch(&agrs, database.root(), neighborhood_metadata.min_hops_count as u8); let filtered_agrs = self.filter_agrs_by_patch(agrs, patch); let mut db_changed = self.identify_and_add_non_introductory_new_nodes( @@ -2382,7 +2382,7 @@ mod tests { .build(); let agrs: Vec = gossip.try_into().unwrap(); - let result = subject.compute_patch(&agrs, node_a_db.root(), DEFAULT_MIN_HOPS_COUNT); + let result = subject.compute_patch(&agrs, node_a_db.root(), DEFAULT_MIN_HOPS_COUNT as u8); let expected_hashset = vec![ node_a.public_key().clone(), @@ -2434,7 +2434,7 @@ mod tests { .build(); let agrs: Vec = gossip.try_into().unwrap(); - let patch = subject.compute_patch(&agrs, node_a_db.root(), DEFAULT_MIN_HOPS_COUNT); + let patch = subject.compute_patch(&agrs, node_a_db.root(), DEFAULT_MIN_HOPS_COUNT as u8); let expected_hashset = vec![ node_a.public_key().clone(), @@ -2483,7 +2483,7 @@ mod tests { .build(); let agrs: Vec = gossip.try_into().unwrap(); - let patch = subject.compute_patch(&agrs, node_a_db.root(), DEFAULT_MIN_HOPS_COUNT); + let patch = subject.compute_patch(&agrs, node_a_db.root(), DEFAULT_MIN_HOPS_COUNT as u8); let expected_hashset = vec![ node_a.public_key().clone(), diff --git a/node/src/neighborhood/mod.rs b/node/src/neighborhood/mod.rs index f333f8aa7..1b653f8d4 100644 --- a/node/src/neighborhood/mod.rs +++ b/node/src/neighborhood/mod.rs @@ -46,7 +46,7 @@ use crate::sub_lib::cryptde::{CryptDE, CryptData, PlainData}; use crate::sub_lib::dispatcher::{Component, StreamShutdownMsg}; use crate::sub_lib::hopper::{ExpiredCoresPackage, NoLookupIncipientCoresPackage}; use crate::sub_lib::hopper::{IncipientCoresPackage, MessageType}; -use crate::sub_lib::neighborhood::{NeighborhoodMetadata, NodeQueryResponseMetadata}; +use crate::sub_lib::neighborhood::{HopsCount, NeighborhoodMetadata, NodeQueryResponseMetadata}; use crate::sub_lib::neighborhood::NodeRecordMetadataMessage; use crate::sub_lib::neighborhood::RemoveNeighborMessage; use crate::sub_lib::neighborhood::RouteQueryMessage; @@ -77,7 +77,7 @@ use neighborhood_database::NeighborhoodDatabase; use node_record::NodeRecord; pub const CRASH_KEY: &str = "NEIGHBORHOOD"; -pub const DEFAULT_MIN_HOPS_COUNT: u8 = 3; +pub const DEFAULT_MIN_HOPS_COUNT: HopsCount = HopsCount::ThreeHops; pub const UNREACHABLE_HOST_PENALTY: i64 = 100_000_000; pub const RESPONSE_UNDESIRABILITY_FACTOR: usize = 1_000; // assumed response length is request * this @@ -91,7 +91,7 @@ pub struct Neighborhood { gossip_producer: Box, neighborhood_database: NeighborhoodDatabase, consuming_wallet_opt: Option, - min_hops_count: u8, + min_hops_count: HopsCount, next_return_route_id: u32, overall_connection_status: OverallConnectionStatus, chain: Chain, @@ -1659,12 +1659,12 @@ mod tests { #[test] fn constants_have_correct_values() { assert_eq!(CRASH_KEY, "NEIGHBORHOOD"); - assert_eq!(DEFAULT_MIN_HOPS_COUNT, 3); + assert_eq!(DEFAULT_MIN_HOPS_COUNT, HopsCount::ThreeHops); } #[test] fn min_hops_count_is_set_inside_neighborhood() { - let min_hops_count = 6; + let min_hops_count = HopsCount::SixHops; let mode = NeighborhoodMode::Standard( NodeAddr::new(&make_ip(1), &[1234, 2345]), vec![make_node_descriptor(make_ip(2))], @@ -1685,7 +1685,7 @@ mod tests { ), ); - assert_eq!(subject.min_hops_count, 6); + assert_eq!(subject.min_hops_count, HopsCount::SixHops); } #[test] diff --git a/node/src/node_configurator/unprivileged_parse_args_configuration.rs b/node/src/node_configurator/unprivileged_parse_args_configuration.rs index af68be656..eb2dad9a0 100644 --- a/node/src/node_configurator/unprivileged_parse_args_configuration.rs +++ b/node/src/node_configurator/unprivileged_parse_args_configuration.rs @@ -215,18 +215,11 @@ pub fn make_neighborhood_config( } }; - let min_hops_count_string = - value_m!(multi_config, "min-hops", String) - .unwrap_or_else(|| DEFAULT_MIN_HOPS_COUNT.to_string()); - - let min_hops_count: u8 = match min_hops_count_string.as_str() { - "1" => 1, - "2" => 2, - "3" => 3, - "4" => 4, - "5" => 5, - "6" => 6, - _ => panic!("Invalid input string!"), + let min_hops_arg = + value_m!(multi_config, "min-hops", String); + let min_hops_count = match min_hops_arg { + None => DEFAULT_MIN_HOPS_COUNT, + Some(string) => string.try_into().unwrap_or_else(|error| panic!("{}", error)) }; match make_neighborhood_mode(multi_config, neighbor_configs, persistent_config) { @@ -638,7 +631,7 @@ mod tests { use crate::db_config::persistent_configuration::PersistentConfigurationReal; use crate::sub_lib::accountant::DEFAULT_PAYMENT_THRESHOLDS; use crate::sub_lib::cryptde::{PlainData, PublicKey}; - use crate::sub_lib::neighborhood::DEFAULT_RATE_PACK; + use crate::sub_lib::neighborhood::{DEFAULT_RATE_PACK, HopsCount}; use crate::sub_lib::utils::make_new_multi_config; use crate::sub_lib::wallet::Wallet; use crate::test_utils::persistent_configuration_mock::PersistentConfigurationMock; @@ -723,7 +716,7 @@ mod tests { ], DEFAULT_RATE_PACK ), - min_hops_count: 1, + min_hops_count: HopsCount::OneHop, }) ); } diff --git a/node/src/sub_lib/neighborhood.rs b/node/src/sub_lib/neighborhood.rs index bf8e619c9..514d1da1a 100644 --- a/node/src/sub_lib/neighborhood.rs +++ b/node/src/sub_lib/neighborhood.rs @@ -367,10 +367,37 @@ impl Display for DescriptorParsingError<'_> { } } +#[derive(Copy, Clone, Debug, PartialEq, Eq)] +pub enum HopsCount { + OneHop = 1, + TwoHops = 2, + ThreeHops = 3, // minimum for anonymity + FourHops = 4, + FiveHops = 5, + SixHops = 6, +} + +impl TryFrom for HopsCount { + type Error = String; + + fn try_from(value: String) -> Result { + + match value.as_str() { + "1" => Ok(HopsCount::OneHop), + "2" => Ok(HopsCount::TwoHops), + "3" => Ok(HopsCount::ThreeHops), + "4" => Ok(HopsCount::FourHops), + "5" => Ok(HopsCount::FiveHops), + "6" => Ok(HopsCount::SixHops), + _ => Err("Invalid value for min hops count provided".to_string()), + } + } +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct NeighborhoodConfig { pub mode: NeighborhoodMode, - pub min_hops_count: u8, + pub min_hops_count: HopsCount, } lazy_static! { @@ -555,7 +582,7 @@ impl fmt::Display for GossipFailure_0v1 { pub struct NeighborhoodMetadata { pub connection_progress_peers: Vec, pub cpm_recipient: Recipient, - pub min_hops_count: u8, + pub min_hops_count: HopsCount, } pub struct NeighborhoodTools { @@ -1226,4 +1253,22 @@ mod tests { .unwrap(); assert_eq!(subject.ask_about_gossip_interval, Duration::from_secs(10)); } + + #[test] + fn min_hops_count_can_be_converted_from_string() { + let min_hops_count = String::from("6"); + + let result: HopsCount = min_hops_count.try_into().unwrap(); + + assert_eq!(result, HopsCount::SixHops); + } + + #[test] + fn min_hops_count_conversion_from_string_panics() { + let min_hops_count = String::from("100"); + + let result: Result = min_hops_count.try_into(); + + assert_eq!(result, Err("Invalid value for min hops count provided".to_string())) + } } From 638b196374e5cff1888348bec19b3b92096ecff5 Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Thu, 20 Apr 2023 15:36:15 +0530 Subject: [PATCH 16/56] GH-690: write tests to handle the default and error case for --min-hops --- masq_lib/src/multi_config.rs | 6 +++ masq_lib/src/shared_schema.rs | 2 +- .../unprivileged_parse_args_configuration.rs | 50 +++++++++++++++++++ 3 files changed, 57 insertions(+), 1 deletion(-) diff --git a/masq_lib/src/multi_config.rs b/masq_lib/src/multi_config.rs index 99062d9e6..7392deb2f 100644 --- a/masq_lib/src/multi_config.rs +++ b/masq_lib/src/multi_config.rs @@ -88,6 +88,12 @@ impl<'a> MultiConfig<'a> { let message = format!("Invalid value: {}", &captures[2]); return ConfiguratorError::required(name, &message); } + let another_invalid_value_regex = Regex::new("error: (.*) isn't a valid value for '--(.*?) <.*>'").expect("Bad regex"); + if let Some(captures) = another_invalid_value_regex.captures(&e.message) { + let name = &captures[2]; + let message = format!("Invalid value: {}", &captures[1]); + return ConfiguratorError::required(name, &message); + } if e.message .contains("The following required arguments were not provided:") { diff --git a/masq_lib/src/shared_schema.rs b/masq_lib/src/shared_schema.rs index d8ad9c393..b3bb14d74 100644 --- a/masq_lib/src/shared_schema.rs +++ b/masq_lib/src/shared_schema.rs @@ -413,7 +413,7 @@ pub fn shared_app(head: App<'static, 'static>) -> App<'static, 'static> { .long("min-hops") .value_name("MIN_HOPS") .required(false) - .min_values(0) + .min_values(1) .max_values(1) .possible_values(&["1", "2", "3", "4", "5", "6"]) .help(MIN_HOPS_HELP) diff --git a/node/src/node_configurator/unprivileged_parse_args_configuration.rs b/node/src/node_configurator/unprivileged_parse_args_configuration.rs index eb2dad9a0..8d8125b92 100644 --- a/node/src/node_configurator/unprivileged_parse_args_configuration.rs +++ b/node/src/node_configurator/unprivileged_parse_args_configuration.rs @@ -721,6 +721,56 @@ mod tests { ); } + #[test] + fn make_neighborhood_config_standard_missing_min_hops_count() { + running_test(); + let multi_config = make_new_multi_config( + &app_node(), + vec![Box::new(CommandLineVcl::new( + ArgsBuilder::new() + .param("--neighborhood-mode", "standard") + .param( + "--neighbors", + &format!("masq://{identifier}:QmlsbA@1.2.3.4:1234/2345,masq://{identifier}:VGVk@2.3.4.5:3456/4567",identifier = DEFAULT_CHAIN.rec().literal_identifier), + ) + .param("--fake-public-key", "booga") + .into(), + ))], + ) + .unwrap(); + + let result = make_neighborhood_config( + &UnprivilegedParseArgsConfigurationDaoReal {}, + &multi_config, + &mut configure_default_persistent_config(RATE_PACK), + &mut BootstrapperConfig::new(), + ); + + let min_hops_count = result.unwrap().min_hops_count; + assert_eq!(min_hops_count, HopsCount::ThreeHops); + } + + #[test] + fn make_neighborhood_config_standard_panics_with_undesirable_min_hops_count() { + running_test(); + let args = ArgsBuilder::new() + .param("--neighborhood-mode", "standard") + .param( + "--neighbors", + &format!("masq://{identifier}:QmlsbA@1.2.3.4:1234/2345,masq://{identifier}:VGVk@2.3.4.5:3456/4567",identifier = DEFAULT_CHAIN.rec().literal_identifier), + ) + .param("--fake-public-key", "booga") + .param("--min-hops", "100"); + let vcl = CommandLineVcl::new(args.into()); + + let result = make_new_multi_config( + &app_node(), + vec![Box::new(vcl)], + ).err().unwrap(); + + assert_eq!(result, ConfiguratorError::required("min-hops", "Invalid value: '100'")); + } + #[test] fn make_neighborhood_config_standard_missing_ip() { running_test(); From c33e722c23e1c359aa2d2ed676e0e627086fccad Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Thu, 20 Apr 2023 16:11:33 +0530 Subject: [PATCH 17/56] GH-690: add a TODO for the new regex inside make_configurator_error --- masq_lib/src/multi_config.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/masq_lib/src/multi_config.rs b/masq_lib/src/multi_config.rs index 7392deb2f..ff002fa24 100644 --- a/masq_lib/src/multi_config.rs +++ b/masq_lib/src/multi_config.rs @@ -88,7 +88,7 @@ impl<'a> MultiConfig<'a> { let message = format!("Invalid value: {}", &captures[2]); return ConfiguratorError::required(name, &message); } - let another_invalid_value_regex = Regex::new("error: (.*) isn't a valid value for '--(.*?) <.*>'").expect("Bad regex"); + let another_invalid_value_regex = Regex::new("error: (.*) isn't a valid value for '--(.*?) <.*>'").expect("Bad regex"); // TODO: is this good enough? if let Some(captures) = another_invalid_value_regex.captures(&e.message) { let name = &captures[2]; let message = format!("Invalid value: {}", &captures[1]); From 7b427001f6da6929f51eeffcd63443e89a60639c Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Fri, 21 Apr 2023 12:16:32 +0530 Subject: [PATCH 18/56] GH-690: compute patch for different min hops count GH-690: write tests to test compute patch for different min hops count --- node/src/neighborhood/gossip_acceptor.rs | 46 ++++++++++++++++++++++-- 1 file changed, 43 insertions(+), 3 deletions(-) diff --git a/node/src/neighborhood/gossip_acceptor.rs b/node/src/neighborhood/gossip_acceptor.rs index 66c0a1d8c..e45dee1f1 100644 --- a/node/src/neighborhood/gossip_acceptor.rs +++ b/node/src/neighborhood/gossip_acceptor.rs @@ -1332,7 +1332,7 @@ mod tests { use crate::neighborhood::gossip_producer::GossipProducerReal; use crate::neighborhood::node_record::NodeRecord; use crate::sub_lib::cryptde_null::CryptDENull; - use crate::sub_lib::neighborhood::{ConnectionProgressEvent, ConnectionProgressMessage}; + use crate::sub_lib::neighborhood::{ConnectionProgressEvent, ConnectionProgressMessage, HopsCount}; use crate::sub_lib::utils::time_t_timestamp; use crate::test_utils::neighborhood_test_utils::{ db_from_node, make_meaningless_db, make_node_record, make_node_record_f, @@ -2565,8 +2565,48 @@ mod tests { assert_eq!(result, GossipAcceptanceResult::Ignored); } - fn patch_can_be_calculated_for_different_hop_counts() { - unimplemented!(); + fn assert_compute_patch(min_hops_count: HopsCount) { + let subject = StandardGossipHandler::new(Logger::new("assert_compute_patch")); + // Create Nodes + let nodes_count = min_hops_count as usize + 2; // one to finish hops and one extra node + let mut nodes = Vec::with_capacity(nodes_count as usize); + for i in 1..=nodes_count { + let nonce = 1000 + i; + let has_ip = if i <= 2 { true } else { false }; + nodes.push(make_node_record(nonce as u16, has_ip)) + } + // Create Database + let root_node = &nodes[0]; + let mut root_node_db = db_from_node(root_node); + for i in 1..nodes_count { + root_node_db.add_node(nodes[i].clone()).unwrap(); + root_node_db.add_arbitrary_full_neighbor(nodes[i-1].public_key(), nodes[i].public_key()); + } + // Create Gossip + let mut gossip_builder = GossipBuilder::new(&root_node_db); + for i in 1..nodes_count { + gossip_builder = gossip_builder.node(nodes[i].public_key(), false); + } + let gossip = gossip_builder.build(); + let agrs: Vec = gossip.try_into().unwrap(); + + let result = subject.compute_patch(&agrs, root_node_db.root(), min_hops_count as u8); + + let mut expected_nodes = nodes; + expected_nodes.pop(); + let expected_hashet = expected_nodes.iter().map(|node| node.public_key().clone()).collect::>(); + + assert_eq!(result, expected_hashet); + } + + #[test] + fn patch_can_be_calculated_for_different_hops() { + assert_compute_patch(HopsCount::OneHop); + assert_compute_patch(HopsCount::TwoHops); + assert_compute_patch(HopsCount::ThreeHops); + assert_compute_patch(HopsCount::FourHops); + assert_compute_patch(HopsCount::FiveHops); + assert_compute_patch(HopsCount::SixHops); } #[test] From f0053c292bdc9fc5794e9a8ca331518711ff29cd Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Mon, 24 Apr 2023 09:09:02 +0530 Subject: [PATCH 19/56] GH-690: rename HopsCount to Hops --- node/src/neighborhood/gossip_acceptor.rs | 16 ++++++------ node/src/neighborhood/mod.rs | 12 ++++----- .../unprivileged_parse_args_configuration.rs | 6 ++--- node/src/sub_lib/neighborhood.rs | 26 +++++++++---------- 4 files changed, 30 insertions(+), 30 deletions(-) diff --git a/node/src/neighborhood/gossip_acceptor.rs b/node/src/neighborhood/gossip_acceptor.rs index e45dee1f1..2953ddef8 100644 --- a/node/src/neighborhood/gossip_acceptor.rs +++ b/node/src/neighborhood/gossip_acceptor.rs @@ -1332,7 +1332,7 @@ mod tests { use crate::neighborhood::gossip_producer::GossipProducerReal; use crate::neighborhood::node_record::NodeRecord; use crate::sub_lib::cryptde_null::CryptDENull; - use crate::sub_lib::neighborhood::{ConnectionProgressEvent, ConnectionProgressMessage, HopsCount}; + use crate::sub_lib::neighborhood::{ConnectionProgressEvent, ConnectionProgressMessage, Hops}; use crate::sub_lib::utils::time_t_timestamp; use crate::test_utils::neighborhood_test_utils::{ db_from_node, make_meaningless_db, make_node_record, make_node_record_f, @@ -2565,7 +2565,7 @@ mod tests { assert_eq!(result, GossipAcceptanceResult::Ignored); } - fn assert_compute_patch(min_hops_count: HopsCount) { + fn assert_compute_patch(min_hops_count: Hops) { let subject = StandardGossipHandler::new(Logger::new("assert_compute_patch")); // Create Nodes let nodes_count = min_hops_count as usize + 2; // one to finish hops and one extra node @@ -2601,12 +2601,12 @@ mod tests { #[test] fn patch_can_be_calculated_for_different_hops() { - assert_compute_patch(HopsCount::OneHop); - assert_compute_patch(HopsCount::TwoHops); - assert_compute_patch(HopsCount::ThreeHops); - assert_compute_patch(HopsCount::FourHops); - assert_compute_patch(HopsCount::FiveHops); - assert_compute_patch(HopsCount::SixHops); + assert_compute_patch(Hops::OneHop); + assert_compute_patch(Hops::TwoHops); + assert_compute_patch(Hops::ThreeHops); + assert_compute_patch(Hops::FourHops); + assert_compute_patch(Hops::FiveHops); + assert_compute_patch(Hops::SixHops); } #[test] diff --git a/node/src/neighborhood/mod.rs b/node/src/neighborhood/mod.rs index 1b653f8d4..580ef91cb 100644 --- a/node/src/neighborhood/mod.rs +++ b/node/src/neighborhood/mod.rs @@ -46,7 +46,7 @@ use crate::sub_lib::cryptde::{CryptDE, CryptData, PlainData}; use crate::sub_lib::dispatcher::{Component, StreamShutdownMsg}; use crate::sub_lib::hopper::{ExpiredCoresPackage, NoLookupIncipientCoresPackage}; use crate::sub_lib::hopper::{IncipientCoresPackage, MessageType}; -use crate::sub_lib::neighborhood::{HopsCount, NeighborhoodMetadata, NodeQueryResponseMetadata}; +use crate::sub_lib::neighborhood::{Hops, NeighborhoodMetadata, NodeQueryResponseMetadata}; use crate::sub_lib::neighborhood::NodeRecordMetadataMessage; use crate::sub_lib::neighborhood::RemoveNeighborMessage; use crate::sub_lib::neighborhood::RouteQueryMessage; @@ -77,7 +77,7 @@ use neighborhood_database::NeighborhoodDatabase; use node_record::NodeRecord; pub const CRASH_KEY: &str = "NEIGHBORHOOD"; -pub const DEFAULT_MIN_HOPS_COUNT: HopsCount = HopsCount::ThreeHops; +pub const DEFAULT_MIN_HOPS_COUNT: Hops = Hops::ThreeHops; pub const UNREACHABLE_HOST_PENALTY: i64 = 100_000_000; pub const RESPONSE_UNDESIRABILITY_FACTOR: usize = 1_000; // assumed response length is request * this @@ -91,7 +91,7 @@ pub struct Neighborhood { gossip_producer: Box, neighborhood_database: NeighborhoodDatabase, consuming_wallet_opt: Option, - min_hops_count: HopsCount, + min_hops_count: Hops, next_return_route_id: u32, overall_connection_status: OverallConnectionStatus, chain: Chain, @@ -1659,12 +1659,12 @@ mod tests { #[test] fn constants_have_correct_values() { assert_eq!(CRASH_KEY, "NEIGHBORHOOD"); - assert_eq!(DEFAULT_MIN_HOPS_COUNT, HopsCount::ThreeHops); + assert_eq!(DEFAULT_MIN_HOPS_COUNT, Hops::ThreeHops); } #[test] fn min_hops_count_is_set_inside_neighborhood() { - let min_hops_count = HopsCount::SixHops; + let min_hops_count = Hops::SixHops; let mode = NeighborhoodMode::Standard( NodeAddr::new(&make_ip(1), &[1234, 2345]), vec![make_node_descriptor(make_ip(2))], @@ -1685,7 +1685,7 @@ mod tests { ), ); - assert_eq!(subject.min_hops_count, HopsCount::SixHops); + assert_eq!(subject.min_hops_count, Hops::SixHops); } #[test] diff --git a/node/src/node_configurator/unprivileged_parse_args_configuration.rs b/node/src/node_configurator/unprivileged_parse_args_configuration.rs index 8d8125b92..411b0e90f 100644 --- a/node/src/node_configurator/unprivileged_parse_args_configuration.rs +++ b/node/src/node_configurator/unprivileged_parse_args_configuration.rs @@ -631,7 +631,7 @@ mod tests { use crate::db_config::persistent_configuration::PersistentConfigurationReal; use crate::sub_lib::accountant::DEFAULT_PAYMENT_THRESHOLDS; use crate::sub_lib::cryptde::{PlainData, PublicKey}; - use crate::sub_lib::neighborhood::{DEFAULT_RATE_PACK, HopsCount}; + use crate::sub_lib::neighborhood::{DEFAULT_RATE_PACK, Hops}; use crate::sub_lib::utils::make_new_multi_config; use crate::sub_lib::wallet::Wallet; use crate::test_utils::persistent_configuration_mock::PersistentConfigurationMock; @@ -716,7 +716,7 @@ mod tests { ], DEFAULT_RATE_PACK ), - min_hops_count: HopsCount::OneHop, + min_hops_count: Hops::OneHop, }) ); } @@ -747,7 +747,7 @@ mod tests { ); let min_hops_count = result.unwrap().min_hops_count; - assert_eq!(min_hops_count, HopsCount::ThreeHops); + assert_eq!(min_hops_count, Hops::ThreeHops); } #[test] diff --git a/node/src/sub_lib/neighborhood.rs b/node/src/sub_lib/neighborhood.rs index 514d1da1a..3e82cbb35 100644 --- a/node/src/sub_lib/neighborhood.rs +++ b/node/src/sub_lib/neighborhood.rs @@ -368,7 +368,7 @@ impl Display for DescriptorParsingError<'_> { } #[derive(Copy, Clone, Debug, PartialEq, Eq)] -pub enum HopsCount { +pub enum Hops { OneHop = 1, TwoHops = 2, ThreeHops = 3, // minimum for anonymity @@ -377,18 +377,18 @@ pub enum HopsCount { SixHops = 6, } -impl TryFrom for HopsCount { +impl TryFrom for Hops { type Error = String; fn try_from(value: String) -> Result { match value.as_str() { - "1" => Ok(HopsCount::OneHop), - "2" => Ok(HopsCount::TwoHops), - "3" => Ok(HopsCount::ThreeHops), - "4" => Ok(HopsCount::FourHops), - "5" => Ok(HopsCount::FiveHops), - "6" => Ok(HopsCount::SixHops), + "1" => Ok(Hops::OneHop), + "2" => Ok(Hops::TwoHops), + "3" => Ok(Hops::ThreeHops), + "4" => Ok(Hops::FourHops), + "5" => Ok(Hops::FiveHops), + "6" => Ok(Hops::SixHops), _ => Err("Invalid value for min hops count provided".to_string()), } } @@ -397,7 +397,7 @@ impl TryFrom for HopsCount { #[derive(Clone, Debug, PartialEq, Eq)] pub struct NeighborhoodConfig { pub mode: NeighborhoodMode, - pub min_hops_count: HopsCount, + pub min_hops_count: Hops, } lazy_static! { @@ -582,7 +582,7 @@ impl fmt::Display for GossipFailure_0v1 { pub struct NeighborhoodMetadata { pub connection_progress_peers: Vec, pub cpm_recipient: Recipient, - pub min_hops_count: HopsCount, + pub min_hops_count: Hops, } pub struct NeighborhoodTools { @@ -1258,16 +1258,16 @@ mod tests { fn min_hops_count_can_be_converted_from_string() { let min_hops_count = String::from("6"); - let result: HopsCount = min_hops_count.try_into().unwrap(); + let result: Hops = min_hops_count.try_into().unwrap(); - assert_eq!(result, HopsCount::SixHops); + assert_eq!(result, Hops::SixHops); } #[test] fn min_hops_count_conversion_from_string_panics() { let min_hops_count = String::from("100"); - let result: Result = min_hops_count.try_into(); + let result: Result = min_hops_count.try_into(); assert_eq!(result, Err("Invalid value for min hops count provided".to_string())) } From 14708fd0f73bd321a2c71f434332c69ec2946eab Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Mon, 24 Apr 2023 14:23:16 +0530 Subject: [PATCH 20/56] GH-690: write tests for testing route query message for different hops --- node/src/neighborhood/mod.rs | 66 ++++++++++++++++++++++++++++++++++++ 1 file changed, 66 insertions(+) diff --git a/node/src/neighborhood/mod.rs b/node/src/neighborhood/mod.rs index 580ef91cb..ada07d7c9 100644 --- a/node/src/neighborhood/mod.rs +++ b/node/src/neighborhood/mod.rs @@ -5237,6 +5237,72 @@ mod tests { assert_eq!(expected_public_keys, actual_keys); } + fn assert_route_query_message(hops: Hops) { + let hops = hops as usize; + let nodes_count = hops + 1; + // Create Nodes + let nodes = (1..=nodes_count) + .map(|i| { + let nonce = 1000 + i as u16; + let has_ip = if i <= 2 {true} else {false}; + let node = if i == 1 { make_global_cryptde_node_record(nonce, has_ip) } else { make_node_record(nonce, has_ip) }; + node + }) + .collect::>(); + // Create Database + let root_node = nodes.get(0).unwrap(); + let neighbor = nodes.get(1).unwrap(); + let mut subject = neighborhood_from_nodes(root_node, Some(neighbor)); + for i in 1..nodes_count { + subject.neighborhood_database.add_node(nodes[i].clone()).unwrap(); + subject.neighborhood_database.add_arbitrary_full_neighbor(nodes[i-1].public_key(), nodes[i].public_key()); + } + + let result = subject.make_round_trip_route(RouteQueryMessage { + target_key_opt: None, + target_component: Component::ProxyClient, + minimum_hop_count: hops, + return_component_opt: Some(Component::ProxyServer), + payload_size: 10000, + hostname_opt: None, + }); + + let assert_hops = |cryptdes: Vec, route: &[CryptData]| { + assert_eq!(cryptdes.len(), route.len()); + for (cryptde, data) in cryptdes.into_iter().zip(route) { + decodex::(&cryptde, data).unwrap(); + } + }; + let mut route = result.clone().unwrap().route.hops; + let _accounting = route.pop(); + let over_route = &route[..hops]; + let back_route = &route[hops..]; + let over_cryptdes = { + let mut over_nodes = nodes.clone(); + over_nodes.pop(); + over_nodes.iter() + .map(|node| CryptDENull::from(node.public_key(), TEST_DEFAULT_CHAIN)) + .collect::>() + }; + let back_cryptdes = { + nodes.iter().rev() + .map(|node| CryptDENull::from(node.public_key(), TEST_DEFAULT_CHAIN)) + .collect::>() + }; + assert_hops(over_cryptdes, over_route); + assert_hops(back_cryptdes, back_route); + } + + #[test] + fn routes_can_be_calculated_for_different_hops() { + assert_route_query_message(Hops::OneHop); + assert_route_query_message(Hops::TwoHops); + assert_route_query_message(Hops::ThreeHops); + assert_route_query_message(Hops::FourHops); + assert_route_query_message(Hops::FiveHops); + assert_route_query_message(Hops::SixHops); + } + /* For the next two tests, the database looks like this: From 51181b8da76aac3856b19fecc8c28e1df1eac2f6 Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Tue, 25 Apr 2023 11:07:03 +0530 Subject: [PATCH 21/56] GH-690: remove a todo --- node/src/neighborhood/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/node/src/neighborhood/mod.rs b/node/src/neighborhood/mod.rs index ada07d7c9..d085b3cdf 100644 --- a/node/src/neighborhood/mod.rs +++ b/node/src/neighborhood/mod.rs @@ -824,7 +824,7 @@ impl Neighborhood { let msg = RouteQueryMessage { target_key_opt: None, target_component: Component::ProxyClient, - minimum_hop_count: self.min_hops_count as usize, // TODO: do we need to test this sepertely? + minimum_hop_count: self.min_hops_count as usize, return_component_opt: Some(Component::ProxyServer), payload_size: 10000, hostname_opt: None, From ff328115d3c602c4cd31851f1222cce50f0ae20f Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Tue, 25 Apr 2023 11:33:09 +0530 Subject: [PATCH 22/56] GH-690: write tests for connectivity check --- node/src/neighborhood/mod.rs | 56 ++++++++++++++++++++++++++++++++++-- 1 file changed, 54 insertions(+), 2 deletions(-) diff --git a/node/src/neighborhood/mod.rs b/node/src/neighborhood/mod.rs index d085b3cdf..90fadf043 100644 --- a/node/src/neighborhood/mod.rs +++ b/node/src/neighborhood/mod.rs @@ -832,7 +832,7 @@ impl Neighborhood { if self.handle_route_query_message(msg).is_some() { debug!( &self.logger, - "The connectivity check has found a 3 hops route." + "The connectivity check has found a {}-hops route.", self.min_hops_count as usize ); self.overall_connection_status .update_ocs_stage_and_send_message_to_ui( @@ -4007,11 +4007,63 @@ mod tests { } ); TestLogHandler::new().exists_log_containing(&format!( - "DEBUG: {}: The connectivity check has found a 3 hops route.", + "DEBUG: {}: The connectivity check has found a 3-hops route.", test_name )); } + fn assert_connectivity_check(hops: Hops) { + init_test_logging(); + let test_name = &format!("connectivity_check_for_{}_hops", hops as usize); + let mut subject: Neighborhood = make_neighborhood_linearly_connected_with_nodes(hops as u16); + let (ui_gateway, _, ui_gateway_arc) = make_recorder(); + let (accountant, _, _) = make_recorder(); + let node_to_ui_recipient = ui_gateway.start().recipient::(); + let connected_signal = accountant.start().recipient(); + subject.min_hops_count = hops; + subject.logger = Logger::new(test_name); + subject.node_to_ui_recipient_opt = Some(node_to_ui_recipient); + subject.connected_signal_opt = Some(connected_signal); + let system = System::new(test_name); + + subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap(), make_cpm_recipient().0); + + System::current().stop(); + system.run(); + let ui_recording = ui_gateway_arc.lock().unwrap(); + let node_to_ui_message = ui_recording.get_record::(0); + assert_eq!(ui_recording.len(), 1); + assert_eq!(subject.overall_connection_status.can_make_routes(), true); + assert_eq!( + subject.overall_connection_status.stage(), + OverallConnectionStage::ThreeHopsRouteFound + ); + assert_eq!( + node_to_ui_message, + &NodeToUiMessage { + target: MessageTarget::AllClients, + body: UiConnectionChangeBroadcast { + stage: UiConnectionStage::ThreeHopsRouteFound + } + .tmb(0), + } + ); + TestLogHandler::new().exists_log_containing(&format!( + "DEBUG: {}: The connectivity check has found a {}-hops route.", + test_name, hops as usize + )); + } + + #[test] + fn connectivity_check_for_different_hops() { + assert_connectivity_check(Hops::OneHop); + assert_connectivity_check(Hops::TwoHops); + assert_connectivity_check(Hops::ThreeHops); + assert_connectivity_check(Hops::FourHops); + assert_connectivity_check(Hops::FiveHops); + assert_connectivity_check(Hops::SixHops); + } + #[test] fn neighborhood_logs_when_three_hops_route_can_not_be_made() { init_test_logging(); From c220536e1bbf8ac1bba7c8b4d76bc393ba3ac9ea Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Tue, 25 Apr 2023 11:52:09 +0530 Subject: [PATCH 23/56] GH-690: remove the duplicate test --- node/src/neighborhood/mod.rs | 42 ------------------------------------ 1 file changed, 42 deletions(-) diff --git a/node/src/neighborhood/mod.rs b/node/src/neighborhood/mod.rs index 90fadf043..7512985ab 100644 --- a/node/src/neighborhood/mod.rs +++ b/node/src/neighborhood/mod.rs @@ -3970,48 +3970,6 @@ mod tests { .exists_log_containing(&format!("Gossip from {} ignored", peer_2_socket_addr)); } - #[test] - fn neighborhood_updates_ocs_stage_and_sends_message_to_the_ui_when_first_route_can_be_made() { - init_test_logging(); - let test_name = "neighborhood_updates_ocs_stage_and_sends_message_to_the_ui_when_first_route_can_be_made"; - let mut subject: Neighborhood = make_neighborhood_linearly_connected_with_nodes(3); - let (ui_gateway, _, ui_gateway_arc) = make_recorder(); - let (accountant, _, _) = make_recorder(); - let node_to_ui_recipient = ui_gateway.start().recipient::(); - let connected_signal = accountant.start().recipient(); - subject.logger = Logger::new(test_name); - subject.node_to_ui_recipient_opt = Some(node_to_ui_recipient); - subject.connected_signal_opt = Some(connected_signal); - let system = System::new(test_name); - - subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap(), make_cpm_recipient().0); - - System::current().stop(); - system.run(); - let ui_recording = ui_gateway_arc.lock().unwrap(); - let node_to_ui_message = ui_recording.get_record::(0); - assert_eq!(ui_recording.len(), 1); - assert_eq!(subject.overall_connection_status.can_make_routes(), true); - assert_eq!( - subject.overall_connection_status.stage(), - OverallConnectionStage::ThreeHopsRouteFound - ); - assert_eq!( - node_to_ui_message, - &NodeToUiMessage { - target: MessageTarget::AllClients, - body: UiConnectionChangeBroadcast { - stage: UiConnectionStage::ThreeHopsRouteFound - } - .tmb(0), - } - ); - TestLogHandler::new().exists_log_containing(&format!( - "DEBUG: {}: The connectivity check has found a 3-hops route.", - test_name - )); - } - fn assert_connectivity_check(hops: Hops) { init_test_logging(); let test_name = &format!("connectivity_check_for_{}_hops", hops as usize); From e8748ab57ebeb26b068410c080501c33fa71c40c Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Tue, 25 Apr 2023 11:59:36 +0530 Subject: [PATCH 24/56] GH-690: change the stage to RouteFound from ThreeHopsRouteFound --- .../src/commands/connection_status_command.rs | 14 ++++++------ .../connection_change_notification.rs | 4 ++-- masq_lib/src/messages.rs | 2 +- node/src/neighborhood/mod.rs | 8 +++---- .../neighborhood/overall_connection_status.rs | 22 +++++++++---------- 5 files changed, 25 insertions(+), 25 deletions(-) diff --git a/masq/src/commands/connection_status_command.rs b/masq/src/commands/connection_status_command.rs index b22ced228..b1c398a2e 100644 --- a/masq/src/commands/connection_status_command.rs +++ b/masq/src/commands/connection_status_command.rs @@ -25,8 +25,8 @@ const CONNECTION_STATUS_ABOUT: &str = const NOT_CONNECTED_MSG: &str = "NotConnected: No external neighbor is connected to us."; const CONNECTED_TO_NEIGHBOR_MSG: &str = "ConnectedToNeighbor: External neighbor(s) are connected to us."; -const THREE_HOPS_ROUTE_FOUND_MSG: &str = - "ThreeHopsRouteFound: You can relay data over the network."; +const ROUTE_FOUND_MSG: &str = + "RouteFound: You can relay data over the network."; pub fn connection_status_subcommand() -> App<'static, 'static> { SubCommand::with_name("connection-status").about(CONNECTION_STATUS_ABOUT) @@ -42,7 +42,7 @@ impl Command for ConnectionStatusCommand { let stdout_msg = match response.stage { UiConnectionStage::NotConnected => NOT_CONNECTED_MSG, UiConnectionStage::ConnectedToNeighbor => CONNECTED_TO_NEIGHBOR_MSG, - UiConnectionStage::ThreeHopsRouteFound => THREE_HOPS_ROUTE_FOUND_MSG, + UiConnectionStage::RouteFound => ROUTE_FOUND_MSG, }; short_writeln!(context.stdout(), "\n{}\n", stdout_msg); Ok(()) @@ -109,8 +109,8 @@ mod tests { "ConnectedToNeighbor: External neighbor(s) are connected to us." ); assert_eq!( - THREE_HOPS_ROUTE_FOUND_MSG, - "ThreeHopsRouteFound: You can relay data over the network." + ROUTE_FOUND_MSG, + "RouteFound: You can relay data over the network." ) } @@ -164,9 +164,9 @@ mod tests { #[test] fn connection_status_command_happy_path_for_three_hops_route_found() { assert_on_connection_status_response( - UiConnectionStage::ThreeHopsRouteFound, + UiConnectionStage::RouteFound, ( - "\nThreeHopsRouteFound: You can relay data over the network.\n\n", + "\nRouteFound: You can relay data over the network.\n\n", "", ), ); diff --git a/masq/src/notifications/connection_change_notification.rs b/masq/src/notifications/connection_change_notification.rs index 7377282b9..7f987b4c8 100644 --- a/masq/src/notifications/connection_change_notification.rs +++ b/masq/src/notifications/connection_change_notification.rs @@ -21,7 +21,7 @@ impl ConnectionChangeNotification { UiConnectionStage::ConnectedToNeighbor => { "\nConnectedToNeighbor: Established neighborship with an external node.\n" } - UiConnectionStage::ThreeHopsRouteFound => { + UiConnectionStage::RouteFound => { "\nThreeHopsRouteFound: You can now relay data over the network.\n" } }; @@ -63,7 +63,7 @@ mod tests { let mut stdout = ByteArrayWriter::new(); let stderr = ByteArrayWriter::new(); let msg = UiConnectionChangeBroadcast { - stage: UiConnectionStage::ThreeHopsRouteFound, + stage: UiConnectionStage::RouteFound, }; let term_interface = TerminalWrapper::new(Arc::new(TerminalPassiveMock::new())); diff --git a/masq_lib/src/messages.rs b/masq_lib/src/messages.rs index 412076e0d..b0d6ae15f 100644 --- a/masq_lib/src/messages.rs +++ b/masq_lib/src/messages.rs @@ -550,7 +550,7 @@ pub struct UiPaymentThresholds { pub enum UiConnectionStage { NotConnected, ConnectedToNeighbor, - ThreeHopsRouteFound, + RouteFound, } #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)] diff --git a/node/src/neighborhood/mod.rs b/node/src/neighborhood/mod.rs index 7512985ab..02ee17350 100644 --- a/node/src/neighborhood/mod.rs +++ b/node/src/neighborhood/mod.rs @@ -836,7 +836,7 @@ impl Neighborhood { ); self.overall_connection_status .update_ocs_stage_and_send_message_to_ui( - OverallConnectionStage::ThreeHopsRouteFound, + OverallConnectionStage::RouteFound, self.node_to_ui_recipient_opt .as_ref() .expect("UI was not bound."), @@ -3994,14 +3994,14 @@ mod tests { assert_eq!(subject.overall_connection_status.can_make_routes(), true); assert_eq!( subject.overall_connection_status.stage(), - OverallConnectionStage::ThreeHopsRouteFound + OverallConnectionStage::RouteFound ); assert_eq!( node_to_ui_message, &NodeToUiMessage { target: MessageTarget::AllClients, body: UiConnectionChangeBroadcast { - stage: UiConnectionStage::ThreeHopsRouteFound + stage: UiConnectionStage::RouteFound } .tmb(0), } @@ -5691,7 +5691,7 @@ mod tests { #[test] fn connection_status_message_is_handled_properly_for_three_hops_route_found() { - let stage = OverallConnectionStage::ThreeHopsRouteFound; + let stage = OverallConnectionStage::RouteFound; let client_id = 1236; let context_id = 4323; diff --git a/node/src/neighborhood/overall_connection_status.rs b/node/src/neighborhood/overall_connection_status.rs index 3a7e2cf2e..ebc82be62 100644 --- a/node/src/neighborhood/overall_connection_status.rs +++ b/node/src/neighborhood/overall_connection_status.rs @@ -118,7 +118,7 @@ impl ConnectionProgress { pub enum OverallConnectionStage { NotConnected = 0, ConnectedToNeighbor = 1, // When an Introduction or Standard Gossip (acceptance) is received - ThreeHopsRouteFound = 2, // Data can be relayed once this stage is reached + RouteFound = 2, // Data can be relayed once this stage is reached } impl From for UiConnectionStage { @@ -126,7 +126,7 @@ impl From for UiConnectionStage { match stage { OverallConnectionStage::NotConnected => UiConnectionStage::NotConnected, OverallConnectionStage::ConnectedToNeighbor => UiConnectionStage::ConnectedToNeighbor, - OverallConnectionStage::ThreeHopsRouteFound => UiConnectionStage::ThreeHopsRouteFound, + OverallConnectionStage::RouteFound => UiConnectionStage::RouteFound, } } } @@ -313,7 +313,7 @@ impl OverallConnectionStatus { } pub fn can_make_routes(&self) -> bool { - self.stage() == OverallConnectionStage::ThreeHopsRouteFound + self.stage() == OverallConnectionStage::RouteFound } pub fn stage(&self) -> OverallConnectionStage { @@ -408,7 +408,7 @@ mod tests { > OverallConnectionStage::NotConnected as usize ); assert!( - OverallConnectionStage::ThreeHopsRouteFound as usize + OverallConnectionStage::RouteFound as usize > OverallConnectionStage::ConnectedToNeighbor as usize ); } @@ -823,13 +823,13 @@ mod tests { #[test] fn converts_three_hops_route_found_stage_into_ui_connection_change_stage() { - let three_hops_route_found = OverallConnectionStage::ThreeHopsRouteFound; + let route_found = OverallConnectionStage::RouteFound; - let three_hops_route_found_converted: UiConnectionStage = three_hops_route_found.into(); + let route_found_converted: UiConnectionStage = route_found.into(); assert_eq!( - three_hops_route_found_converted, - UiConnectionStage::ThreeHopsRouteFound + route_found_converted, + UiConnectionStage::RouteFound ); } @@ -848,7 +848,7 @@ mod tests { let mut subject = OverallConnectionStatus::new(vec![node_descriptor]); let initial_flag = subject.can_make_routes(); - subject.stage = OverallConnectionStage::ThreeHopsRouteFound; + subject.stage = OverallConnectionStage::RouteFound; let final_flag = subject.can_make_routes(); assert_eq!(initial_flag, false); @@ -860,7 +860,7 @@ mod tests { init_test_logging(); let test_name = "updates_the_ocs_stage_to_three_hops_route_found"; let initial_stage = OverallConnectionStage::NotConnected; - let new_stage = OverallConnectionStage::ThreeHopsRouteFound; + let new_stage = OverallConnectionStage::RouteFound; let (stage, message_opt) = assert_stage_and_node_to_ui_message(initial_stage, new_stage, test_name); @@ -935,7 +935,7 @@ mod tests { ) { init_test_logging(); let test_name = "doesn_t_send_a_message_to_ui_in_case_connection_drops_from_three_hops_to_connected_to_neighbor"; - let initial_stage = OverallConnectionStage::ThreeHopsRouteFound; + let initial_stage = OverallConnectionStage::RouteFound; let new_stage = OverallConnectionStage::ConnectedToNeighbor; let (stage, message_opt) = From 50e62c488de7f9dfd169e1e50b341a03cbf1bb92 Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Tue, 25 Apr 2023 12:08:20 +0530 Subject: [PATCH 25/56] GH-690: formatting changes --- .../src/commands/connection_status_command.rs | 8 +- masq_lib/src/multi_config.rs | 3 +- masq_lib/src/shared_schema.rs | 2 +- node/src/actor_system_factory.rs | 2 +- node/src/bootstrapper.rs | 4 +- node/src/neighborhood/gossip_acceptor.rs | 140 +++++++++------ node/src/neighborhood/mod.rs | 168 +++++++++++++----- .../neighborhood/overall_connection_status.rs | 7 +- .../node_configurator_standard.rs | 2 +- .../unprivileged_parse_args_configuration.rs | 30 ++-- node/src/sub_lib/neighborhood.rs | 6 +- .../src/test_utils/neighborhood_test_utils.rs | 2 +- 12 files changed, 241 insertions(+), 133 deletions(-) diff --git a/masq/src/commands/connection_status_command.rs b/masq/src/commands/connection_status_command.rs index b1c398a2e..4d6f1b8d8 100644 --- a/masq/src/commands/connection_status_command.rs +++ b/masq/src/commands/connection_status_command.rs @@ -25,8 +25,7 @@ const CONNECTION_STATUS_ABOUT: &str = const NOT_CONNECTED_MSG: &str = "NotConnected: No external neighbor is connected to us."; const CONNECTED_TO_NEIGHBOR_MSG: &str = "ConnectedToNeighbor: External neighbor(s) are connected to us."; -const ROUTE_FOUND_MSG: &str = - "RouteFound: You can relay data over the network."; +const ROUTE_FOUND_MSG: &str = "RouteFound: You can relay data over the network."; pub fn connection_status_subcommand() -> App<'static, 'static> { SubCommand::with_name("connection-status").about(CONNECTION_STATUS_ABOUT) @@ -165,10 +164,7 @@ mod tests { fn connection_status_command_happy_path_for_three_hops_route_found() { assert_on_connection_status_response( UiConnectionStage::RouteFound, - ( - "\nRouteFound: You can relay data over the network.\n\n", - "", - ), + ("\nRouteFound: You can relay data over the network.\n\n", ""), ); } diff --git a/masq_lib/src/multi_config.rs b/masq_lib/src/multi_config.rs index ff002fa24..596929090 100644 --- a/masq_lib/src/multi_config.rs +++ b/masq_lib/src/multi_config.rs @@ -88,7 +88,8 @@ impl<'a> MultiConfig<'a> { let message = format!("Invalid value: {}", &captures[2]); return ConfiguratorError::required(name, &message); } - let another_invalid_value_regex = Regex::new("error: (.*) isn't a valid value for '--(.*?) <.*>'").expect("Bad regex"); // TODO: is this good enough? + let another_invalid_value_regex = + Regex::new("error: (.*) isn't a valid value for '--(.*?) <.*>'").expect("Bad regex"); // TODO: is this good enough? if let Some(captures) = another_invalid_value_regex.captures(&e.message) { let name = &captures[2]; let message = format!("Invalid value: {}", &captures[1]); diff --git a/masq_lib/src/shared_schema.rs b/masq_lib/src/shared_schema.rs index b3bb14d74..7a5aa5091 100644 --- a/masq_lib/src/shared_schema.rs +++ b/masq_lib/src/shared_schema.rs @@ -416,7 +416,7 @@ pub fn shared_app(head: App<'static, 'static>) -> App<'static, 'static> { .min_values(1) .max_values(1) .possible_values(&["1", "2", "3", "4", "5", "6"]) - .help(MIN_HOPS_HELP) + .help(MIN_HOPS_HELP), ) .arg( Arg::with_name("neighborhood-mode") diff --git a/node/src/actor_system_factory.rs b/node/src/actor_system_factory.rs index ca1340ab5..597d018c0 100644 --- a/node/src/actor_system_factory.rs +++ b/node/src/actor_system_factory.rs @@ -612,6 +612,7 @@ mod tests { use crate::actor_system_factory::tests::ShouldWeRunTheTest::{GoAhead, Skip}; use crate::bootstrapper::{Bootstrapper, RealUser}; use crate::database::connection_wrapper::ConnectionWrapper; + use crate::neighborhood::DEFAULT_MIN_HOPS_COUNT; use crate::node_test_utils::{ make_stream_handler_pool_subs_from, make_stream_handler_pool_subs_from_recorder, start_recorder_refcell_opt, @@ -678,7 +679,6 @@ mod tests { use std::sync::{Arc, Mutex}; use std::thread; use std::time::Duration; - use crate::neighborhood::DEFAULT_MIN_HOPS_COUNT; struct LogRecipientSetterNull {} diff --git a/node/src/bootstrapper.rs b/node/src/bootstrapper.rs index e78e017d3..34fdca65c 100644 --- a/node/src/bootstrapper.rs +++ b/node/src/bootstrapper.rs @@ -15,6 +15,7 @@ use crate::json_discriminator_factory::JsonDiscriminatorFactory; use crate::listener_handler::ListenerHandler; use crate::listener_handler::ListenerHandlerFactory; use crate::listener_handler::ListenerHandlerFactoryReal; +use crate::neighborhood::DEFAULT_MIN_HOPS_COUNT; use crate::node_configurator::node_configurator_standard::{ NodeConfiguratorStandardPrivileged, NodeConfiguratorStandardUnprivileged, }; @@ -57,7 +58,6 @@ use tokio::prelude::stream::futures_unordered::FuturesUnordered; use tokio::prelude::Async; use tokio::prelude::Future; use tokio::prelude::Stream; -use crate::neighborhood::DEFAULT_MIN_HOPS_COUNT; static mut MAIN_CRYPTDE_BOX_OPT: Option> = None; static mut ALIAS_CRYPTDE_BOX_OPT: Option> = None; @@ -720,6 +720,7 @@ mod tests { use crate::discriminator::Discriminator; use crate::discriminator::UnmaskedChunk; use crate::listener_handler::{ListenerHandler, ListenerHandlerFactory}; + use crate::neighborhood::DEFAULT_MIN_HOPS_COUNT; use crate::node_test_utils::make_stream_handler_pool_subs_from; use crate::node_test_utils::TestLogOwner; use crate::node_test_utils::{extract_log, DirsWrapperMock, IdWrapperMock}; @@ -773,7 +774,6 @@ mod tests { use tokio::executor::current_thread::CurrentThread; use tokio::prelude::stream::FuturesUnordered; use tokio::prelude::Async; - use crate::neighborhood::DEFAULT_MIN_HOPS_COUNT; lazy_static! { pub static ref INITIALIZATION: Mutex = Mutex::new(false); diff --git a/node/src/neighborhood/gossip_acceptor.rs b/node/src/neighborhood/gossip_acceptor.rs index 2953ddef8..be26aa00c 100644 --- a/node/src/neighborhood/gossip_acceptor.rs +++ b/node/src/neighborhood/gossip_acceptor.rs @@ -5,7 +5,9 @@ use crate::neighborhood::neighborhood_database::{NeighborhoodDatabase, Neighborh use crate::neighborhood::node_record::NodeRecord; use crate::neighborhood::AccessibleGossipRecord; use crate::sub_lib::cryptde::{CryptDE, PublicKey}; -use crate::sub_lib::neighborhood::{ConnectionProgressEvent, ConnectionProgressMessage, GossipFailure_0v1, NeighborhoodMetadata}; +use crate::sub_lib::neighborhood::{ + ConnectionProgressEvent, ConnectionProgressMessage, GossipFailure_0v1, NeighborhoodMetadata, +}; use crate::sub_lib::node_addr::NodeAddr; use masq_lib::logger::Logger; use std::cell::RefCell; @@ -520,7 +522,8 @@ impl GossipHandler for PassHandler { peer_addr: _gossip_source.ip(), event, }; - neighborhood_metadata.cpm_recipient + neighborhood_metadata + .cpm_recipient .try_send(connection_progress_message) .expect("System is dead."); }; @@ -537,7 +540,10 @@ impl GossipHandler for PassHandler { let mut hash_map = self.previous_pass_targets.borrow_mut(); let gossip_acceptance_result = match hash_map.get_mut(&pass_target_ip_addr) { - None => match neighborhood_metadata.connection_progress_peers.contains(&pass_target_ip_addr) { + None => match neighborhood_metadata + .connection_progress_peers + .contains(&pass_target_ip_addr) + { true => { send_cpm(ConnectionProgressEvent::PassLoopFound); GossipAcceptanceResult::Ignored @@ -655,7 +661,8 @@ impl GossipHandler for IntroductionHandler { peer_addr: introducer_ip_addr, event: ConnectionProgressEvent::IntroductionGossipReceived(introducee_ip_addr), }; - neighborhood_metadata.cpm_recipient + neighborhood_metadata + .cpm_recipient .try_send(connection_progess_message) .expect("Neighborhood is dead"); let (debut, target_key, target_node_addr) = @@ -933,7 +940,11 @@ impl GossipHandler for StandardGossipHandler { let initial_neighborship_status = StandardGossipHandler::check_full_neighbor(database, gossip_source.ip()); - let patch = self.compute_patch(&agrs, database.root(), neighborhood_metadata.min_hops_count as u8); + let patch = self.compute_patch( + &agrs, + database.root(), + neighborhood_metadata.min_hops_count as u8, + ); let filtered_agrs = self.filter_agrs_by_patch(agrs, patch); let mut db_changed = self.identify_and_add_non_introductory_new_nodes( @@ -956,7 +967,8 @@ impl GossipHandler for StandardGossipHandler { peer_addr: gossip_source.ip(), event: ConnectionProgressEvent::StandardGossipReceived, }; - neighborhood_metadata.cpm_recipient + neighborhood_metadata + .cpm_recipient .try_send(cpm) .unwrap_or_else(|e| panic!("Neighborhood is dead: {}", e)); } @@ -1263,7 +1275,7 @@ impl<'a> GossipAcceptor for GossipAcceptorReal<'a> { database, agrs, gossip_source, - neighborhood_metadata + neighborhood_metadata, ) } Qualification::Unmatched => { @@ -1275,9 +1287,7 @@ impl<'a> GossipAcceptor for GossipAcceptorReal<'a> { } impl<'a> GossipAcceptorReal<'a> { - pub fn new( - cryptde: &'a dyn CryptDE, - ) -> GossipAcceptorReal { + pub fn new(cryptde: &'a dyn CryptDE) -> GossipAcceptorReal { let logger = Logger::new("GossipAcceptor"); GossipAcceptorReal { gossip_handlers: vec![ @@ -1331,6 +1341,7 @@ mod tests { use crate::neighborhood::gossip_producer::GossipProducer; use crate::neighborhood::gossip_producer::GossipProducerReal; use crate::neighborhood::node_record::NodeRecord; + use crate::neighborhood::DEFAULT_MIN_HOPS_COUNT; use crate::sub_lib::cryptde_null::CryptDENull; use crate::sub_lib::neighborhood::{ConnectionProgressEvent, ConnectionProgressMessage, Hops}; use crate::sub_lib::utils::time_t_timestamp; @@ -1346,7 +1357,6 @@ mod tests { use std::ops::{Add, Sub}; use std::str::FromStr; use std::time::Duration; - use crate::neighborhood::DEFAULT_MIN_HOPS_COUNT; #[test] fn constants_have_correct_values() { @@ -1388,7 +1398,7 @@ mod tests { &mut db, agrs_vec, gossip_source_opt, - make_default_neighborhood_metadata() + make_default_neighborhood_metadata(), ); assert_eq!(Qualification::Matched, qualifies_result); @@ -1423,7 +1433,7 @@ mod tests { &mut db, agrs_vec, gossip_source, - make_default_neighborhood_metadata() + make_default_neighborhood_metadata(), ); assert_eq!(Qualification::Matched, qualifies_result); @@ -1476,7 +1486,7 @@ mod tests { &mut dest_db, agrs_vec, src_root.node_addr_opt().unwrap().into(), - make_default_neighborhood_metadata() + make_default_neighborhood_metadata(), ); assert_eq!(result, GossipAcceptanceResult::Accepted); @@ -1508,7 +1518,7 @@ mod tests { &mut dest_db, agrs_vec, src_root.node_addr_opt().unwrap().into(), - make_default_neighborhood_metadata() + make_default_neighborhood_metadata(), ); assert_eq!( @@ -1620,7 +1630,7 @@ mod tests { &mut dest_db, agrs_vec, dest_root.node_addr_opt().clone().unwrap().into(), - make_default_neighborhood_metadata() + make_default_neighborhood_metadata(), ); assert_eq!(result, GossipAcceptanceResult::Accepted); @@ -1640,7 +1650,7 @@ mod tests { &mut dest_db, agrs_vec, gossip_source, - make_default_neighborhood_metadata() + make_default_neighborhood_metadata(), ); assert_eq!(Qualification::Matched, qualifies_result); @@ -1897,7 +1907,7 @@ mod tests { &mut dest_db, agrs.clone(), gossip_source, - make_default_neighborhood_metadata() + make_default_neighborhood_metadata(), ); let after = time_t_timestamp(); @@ -1942,7 +1952,7 @@ mod tests { &mut dest_db, agrs.clone(), gossip_source, - make_default_neighborhood_metadata() + make_default_neighborhood_metadata(), ); assert_eq!(Qualification::Matched, qualifies_result); @@ -1990,7 +2000,7 @@ mod tests { &mut dest_db, agrs.clone(), gossip_source, - make_default_neighborhood_metadata() + make_default_neighborhood_metadata(), ); assert_eq!(handle_result, GossipAcceptanceResult::Ignored); @@ -2018,7 +2028,7 @@ mod tests { &mut dest_db, agrs.clone(), gossip_source, - make_default_neighborhood_metadata() + make_default_neighborhood_metadata(), ); assert_eq!(Qualification::Matched, qualifies_result); @@ -2073,7 +2083,7 @@ mod tests { &mut dest_db, agrs.clone(), gossip_source, - make_default_neighborhood_metadata() + make_default_neighborhood_metadata(), ); assert_eq!(Qualification::Matched, qualifies_result); @@ -2326,7 +2336,7 @@ mod tests { &mut dest_db, agrs_vec, gossip_source, - neighborhood_metadata + neighborhood_metadata, ); assert_eq!(Qualification::Matched, qualifies_result); @@ -2559,7 +2569,7 @@ mod tests { &mut node_a_db, agrs, gossip_source, - make_default_neighborhood_metadata() + make_default_neighborhood_metadata(), ); assert_eq!(result, GossipAcceptanceResult::Ignored); @@ -2580,7 +2590,8 @@ mod tests { let mut root_node_db = db_from_node(root_node); for i in 1..nodes_count { root_node_db.add_node(nodes[i].clone()).unwrap(); - root_node_db.add_arbitrary_full_neighbor(nodes[i-1].public_key(), nodes[i].public_key()); + root_node_db + .add_arbitrary_full_neighbor(nodes[i - 1].public_key(), nodes[i].public_key()); } // Create Gossip let mut gossip_builder = GossipBuilder::new(&root_node_db); @@ -2594,7 +2605,10 @@ mod tests { let mut expected_nodes = nodes; expected_nodes.pop(); - let expected_hashet = expected_nodes.iter().map(|node| node.public_key().clone()).collect::>(); + let expected_hashet = expected_nodes + .iter() + .map(|node| node.public_key().clone()) + .collect::>(); assert_eq!(result, expected_hashet); } @@ -2638,7 +2652,7 @@ mod tests { &mut root_db, agrs, src_node_socket_addr, - make_default_neighborhood_metadata() + make_default_neighborhood_metadata(), ); System::current().stop(); @@ -2678,7 +2692,7 @@ mod tests { &mut root_db, agrs, src_node_socket_addr, - neighborhood_metadata + neighborhood_metadata, ); System::current().stop(); @@ -2725,7 +2739,7 @@ mod tests { &mut root_db, agrs, src_node_socket_addr, - neighborhood_metadata + neighborhood_metadata, ); System::current().stop(); @@ -2766,7 +2780,7 @@ mod tests { &mut root_db, agrs, src_node_socket_addr, - neighborhood_metadata + neighborhood_metadata, ); System::current().stop(); @@ -2809,7 +2823,7 @@ mod tests { &mut dest_db, gossip.try_into().unwrap(), src_root.node_addr_opt().clone().unwrap().into(), - make_default_neighborhood_metadata() + make_default_neighborhood_metadata(), ); assert_eq!(result, GossipAcceptanceResult::Ignored); @@ -2893,7 +2907,7 @@ mod tests { &mut dest_db, gossip.try_into().unwrap(), src_node.node_addr_opt().unwrap().into(), - make_default_neighborhood_metadata() + make_default_neighborhood_metadata(), ); assert_eq!(GossipAcceptanceResult::Ignored, result); @@ -2912,7 +2926,7 @@ mod tests { &mut dest_db, gossip.try_into().unwrap(), gossip_source, - make_default_neighborhood_metadata() + make_default_neighborhood_metadata(), ); let after = time_t_timestamp(); @@ -2951,7 +2965,7 @@ mod tests { &mut dest_db, gossip.try_into().unwrap(), gossip_source, - make_default_neighborhood_metadata() + make_default_neighborhood_metadata(), ); let after = time_t_timestamp(); @@ -3022,7 +3036,7 @@ mod tests { &mut dest_db, gossip.try_into().unwrap(), gossip_source, - make_default_neighborhood_metadata() + make_default_neighborhood_metadata(), ); let after = time_t_timestamp(); @@ -3118,7 +3132,7 @@ mod tests { &mut dest_db, gossip.try_into().unwrap(), gossip_source, - make_default_neighborhood_metadata() + make_default_neighborhood_metadata(), ); let expected_acceptance_gossip_2 = GossipBuilder::new(&dest_db) @@ -3207,7 +3221,7 @@ mod tests { &mut dest_db, gossip.try_into().unwrap(), gossip_source, - make_default_neighborhood_metadata() + make_default_neighborhood_metadata(), ); let expected_acceptance_gossip = GossipBuilder::new(&dest_db) @@ -3262,7 +3276,7 @@ mod tests { &mut dest_db, debut.try_into().unwrap(), gossip_source, - make_default_neighborhood_metadata() + make_default_neighborhood_metadata(), ); assert_eq!(GossipAcceptanceResult::Ignored, result); @@ -3297,7 +3311,12 @@ mod tests { let subject = make_subject(main_cryptde()); let begin_at = time_t_timestamp(); - let result = subject.handle(&mut dest_db, debut_agrs, gossip_source, make_default_neighborhood_metadata()); + let result = subject.handle( + &mut dest_db, + debut_agrs, + gossip_source, + make_default_neighborhood_metadata(), + ); let end_at = time_t_timestamp(); assert_eq!(GossipAcceptanceResult::Accepted, result); @@ -3325,7 +3344,12 @@ mod tests { let gossip_source = src_node.node_addr_opt().unwrap().into(); let subject = make_subject(main_cryptde()); - let result = subject.handle(&mut dest_db, debut_agrs, gossip_source, make_default_neighborhood_metadata()); + let result = subject.handle( + &mut dest_db, + debut_agrs, + gossip_source, + make_default_neighborhood_metadata(), + ); assert_eq!(result, GossipAcceptanceResult::Accepted); assert_eq!( @@ -3355,7 +3379,12 @@ mod tests { let gossip_source = src_node.node_addr_opt().unwrap().into(); let subject = make_subject(main_cryptde()); - let result = subject.handle(&mut dest_db, debut_agrs, gossip_source, make_default_neighborhood_metadata()); + let result = subject.handle( + &mut dest_db, + debut_agrs, + gossip_source, + make_default_neighborhood_metadata(), + ); assert_eq!(result, GossipAcceptanceResult::Accepted); assert_eq!( @@ -3384,13 +3413,7 @@ mod tests { let system = System::new("introduction_gossip_handler_sends_cpm_for_neighborship_established"); - subject.handle( - cryptde, - &mut db, - agrs, - gossip_source, - neighborhood_metadata - ); + subject.handle(cryptde, &mut db, agrs, gossip_source, neighborhood_metadata); System::current().stop(); assert_eq!(system.run(), 0); @@ -3425,7 +3448,12 @@ mod tests { let (gossip, pass_target, gossip_source) = make_pass(2345); let subject = make_subject(main_cryptde()); - let result = subject.handle(&mut db, gossip.try_into().unwrap(), gossip_source, make_default_neighborhood_metadata()); + let result = subject.handle( + &mut db, + gossip.try_into().unwrap(), + gossip_source, + make_default_neighborhood_metadata(), + ); let expected_relay_gossip = GossipBuilder::new(&db) .node(root_node.public_key(), true) @@ -3459,7 +3487,7 @@ mod tests { &mut db, gossip.try_into().unwrap(), gossip_source, - neighborhood_metadata + neighborhood_metadata, ); let final_timestamp = SystemTime::now(); @@ -3513,7 +3541,7 @@ mod tests { &mut db, gossip.try_into().unwrap(), gossip_source, - neighborhood_metadata + neighborhood_metadata, ); let final_timestamp = SystemTime::now(); @@ -3555,7 +3583,7 @@ mod tests { &mut db, gossip.try_into().unwrap(), gossip_source, - neighborhood_metadata + neighborhood_metadata, ); System::current().stop(); @@ -3596,7 +3624,7 @@ mod tests { &mut db, gossip.try_into().unwrap(), gossip_source, - neighborhood_metadata + neighborhood_metadata, ); let final_timestamp = SystemTime::now(); @@ -3701,7 +3729,7 @@ mod tests { &mut dest_db, gossip.try_into().unwrap(), node_a.node_addr_opt().unwrap().into(), - make_default_neighborhood_metadata() + make_default_neighborhood_metadata(), ); let after = time_t_timestamp(); @@ -3817,7 +3845,7 @@ mod tests { &mut dest_db, gossip.try_into().unwrap(), src_node.node_addr_opt().unwrap().into(), - make_default_neighborhood_metadata() + make_default_neighborhood_metadata(), ); let after = time_t_timestamp(); @@ -3904,7 +3932,7 @@ mod tests { &mut dest_db, gossip.try_into().unwrap(), src_root.node_addr_opt().unwrap().into(), - make_default_neighborhood_metadata() + make_default_neighborhood_metadata(), ); let after = time_t_timestamp(); diff --git a/node/src/neighborhood/mod.rs b/node/src/neighborhood/mod.rs index 02ee17350..bfee74d58 100644 --- a/node/src/neighborhood/mod.rs +++ b/node/src/neighborhood/mod.rs @@ -13,12 +13,12 @@ use std::convert::TryFrom; use std::net::{IpAddr, SocketAddr}; use std::path::PathBuf; -use actix::{Addr, AsyncContext}; use actix::Context; use actix::Handler; use actix::MessageResult; use actix::Recipient; use actix::{Actor, System}; +use actix::{Addr, AsyncContext}; use itertools::Itertools; use masq_lib::messages::{ FromMessageBody, ToMessageBody, UiConnectionStage, UiConnectionStatusRequest, @@ -46,7 +46,6 @@ use crate::sub_lib::cryptde::{CryptDE, CryptData, PlainData}; use crate::sub_lib::dispatcher::{Component, StreamShutdownMsg}; use crate::sub_lib::hopper::{ExpiredCoresPackage, NoLookupIncipientCoresPackage}; use crate::sub_lib::hopper::{IncipientCoresPackage, MessageType}; -use crate::sub_lib::neighborhood::{Hops, NeighborhoodMetadata, NodeQueryResponseMetadata}; use crate::sub_lib::neighborhood::NodeRecordMetadataMessage; use crate::sub_lib::neighborhood::RemoveNeighborMessage; use crate::sub_lib::neighborhood::RouteQueryMessage; @@ -55,6 +54,7 @@ use crate::sub_lib::neighborhood::{AskAboutDebutGossipMessage, NodeDescriptor}; use crate::sub_lib::neighborhood::{ConnectionProgressEvent, ExpectedServices}; use crate::sub_lib::neighborhood::{ConnectionProgressMessage, ExpectedService}; use crate::sub_lib::neighborhood::{DispatcherNodeQueryMessage, GossipFailure_0v1}; +use crate::sub_lib::neighborhood::{Hops, NeighborhoodMetadata, NodeQueryResponseMetadata}; use crate::sub_lib::neighborhood::{NRMetadataChange, NodeQueryMessage}; use crate::sub_lib::neighborhood::{NeighborhoodSubs, NeighborhoodTools}; use crate::sub_lib::node_addr::NodeAddr; @@ -470,9 +470,7 @@ impl Neighborhood { hopper_no_lookup_opt: None, connected_signal_opt: None, node_to_ui_recipient_opt: None, - gossip_acceptor: Box::new(GossipAcceptorReal::new( - cryptde, - )), + gossip_acceptor: Box::new(GossipAcceptorReal::new(cryptde)), gossip_producer: Box::new(GossipProducerReal::new()), neighborhood_database, consuming_wallet_opt: config.consuming_wallet_opt.clone(), @@ -626,7 +624,12 @@ impl Neighborhood { ); } - fn handle_gossip(&mut self, incoming_gossip: Gossip_0v1, gossip_source: SocketAddr, cpm_recipient: Recipient) { + fn handle_gossip( + &mut self, + incoming_gossip: Gossip_0v1, + gossip_source: SocketAddr, + cpm_recipient: Recipient, + ) { let record_count = incoming_gossip.node_records.len(); info!( self.logger, @@ -714,7 +717,12 @@ impl Neighborhood { .collect() } - fn handle_gossip_agrs(&mut self, agrs: Vec, gossip_source: SocketAddr, cpm_recipient: Recipient) { + fn handle_gossip_agrs( + &mut self, + agrs: Vec, + gossip_source: SocketAddr, + cpm_recipient: Recipient, + ) { let neighbor_keys_before = self.neighbor_keys(); self.handle_agrs(agrs, gossip_source, cpm_recipient); let neighbor_keys_after = self.neighbor_keys(); @@ -730,7 +738,12 @@ impl Neighborhood { .collect() } - fn handle_agrs(&mut self, agrs: Vec, gossip_source: SocketAddr, cpm_recipient: Recipient) { + fn handle_agrs( + &mut self, + agrs: Vec, + gossip_source: SocketAddr, + cpm_recipient: Recipient, + ) { let ignored_node_name = self.gossip_source_name(&agrs, gossip_source); let gossip_record_count = agrs.len(); let neighborhood_metadata = NeighborhoodMetadata { @@ -738,14 +751,12 @@ impl Neighborhood { cpm_recipient, min_hops_count: self.min_hops_count, }; - let acceptance_result = self - .gossip_acceptor - .handle( - &mut self.neighborhood_database, - agrs, - gossip_source, - neighborhood_metadata - ); + let acceptance_result = self.gossip_acceptor.handle( + &mut self.neighborhood_database, + agrs, + gossip_source, + neighborhood_metadata, + ); match acceptance_result { GossipAcceptanceResult::Accepted => self.gossip_to_neighbors(), GossipAcceptanceResult::Reply(next_debut, target_key, target_node_addr) => { @@ -1609,11 +1620,11 @@ mod tests { use crate::sub_lib::dispatcher::Endpoint; use crate::sub_lib::hop::LiveHop; use crate::sub_lib::hopper::MessageType; - use crate::sub_lib::neighborhood::{NeighborhoodMetadata, RatePack}; use crate::sub_lib::neighborhood::{ AskAboutDebutGossipMessage, ExpectedServices, NeighborhoodMode, }; use crate::sub_lib::neighborhood::{NeighborhoodConfig, DEFAULT_RATE_PACK}; + use crate::sub_lib::neighborhood::{NeighborhoodMetadata, RatePack}; use crate::sub_lib::peer_actors::PeerActors; use crate::sub_lib::stream_handler_pool::TransmitDataMsg; use crate::sub_lib::versioned_data::VersionedData; @@ -1630,7 +1641,10 @@ mod tests { use crate::test_utils::recorder::peer_actors_builder; use crate::test_utils::recorder::Recorder; use crate::test_utils::recorder::Recording; - use crate::test_utils::unshared_test_utils::{make_node_to_ui_recipient, make_recipient_and_recording_arc, prove_that_crash_request_handler_is_hooked_up, AssertionsMessage, make_cpm_recipient}; + use crate::test_utils::unshared_test_utils::{ + make_cpm_recipient, make_node_to_ui_recipient, make_recipient_and_recording_arc, + prove_that_crash_request_handler_is_hooked_up, AssertionsMessage, + }; use crate::test_utils::vec_to_set; use crate::test_utils::{main_cryptde, make_paying_wallet}; @@ -3710,7 +3724,10 @@ mod tests { let actual_gossip_source: SocketAddr = subject_node.node_addr_opt().unwrap().into(); assert_eq!(actual_gossip_source, call_gossip_source); let neighbor_ip = neighbor.node_addr_opt().unwrap().ip_addr(); - assert_eq!(neighborhood_metadata.connection_progress_peers, vec![neighbor_ip]); + assert_eq!( + neighborhood_metadata.connection_progress_peers, + vec![neighbor_ip] + ); } #[test] @@ -3746,7 +3763,7 @@ mod tests { subject.handle_gossip( Gossip_0v1::new(vec![]), SocketAddr::from_str("1.1.1.1:1111").unwrap(), - make_cpm_recipient().0 + make_cpm_recipient().0, ); System::current().stop(); @@ -3784,7 +3801,11 @@ mod tests { subject.hopper_no_lookup_opt = Some(peer_actors.hopper.from_hopper_client_no_lookup); subject.gossip_acceptor = Box::new(gossip_acceptor); - subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap(), make_cpm_recipient().0); + subject.handle_gossip_agrs( + vec![], + SocketAddr::from_str("1.2.3.4:1234").unwrap(), + make_cpm_recipient().0, + ); System::current().stop(); system.run(); @@ -3878,7 +3899,11 @@ mod tests { let peer_actors = peer_actors_builder().accountant(accountant).build(); bind_subject(&mut subject, peer_actors); - subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap(), make_cpm_recipient().0); + subject.handle_gossip_agrs( + vec![], + SocketAddr::from_str("1.2.3.4:1234").unwrap(), + make_cpm_recipient().0, + ); System::current().stop(); system.run(); @@ -3901,7 +3926,11 @@ mod tests { let peer_actors = peer_actors_builder().accountant(accountant).build(); bind_subject(&mut subject, peer_actors); - subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap(), make_cpm_recipient().0); + subject.handle_gossip_agrs( + vec![], + SocketAddr::from_str("1.2.3.4:1234").unwrap(), + make_cpm_recipient().0, + ); System::current().stop(); system.run(); @@ -3919,7 +3948,11 @@ mod tests { bind_subject(&mut subject, peer_actors); let system = System::new("neighborhood_does_not_start_accountant_if_no_route_can_be_made"); - subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap(), make_cpm_recipient().0); + subject.handle_gossip_agrs( + vec![], + SocketAddr::from_str("1.2.3.4:1234").unwrap(), + make_cpm_recipient().0, + ); System::current().stop(); system.run(); @@ -3973,7 +4006,8 @@ mod tests { fn assert_connectivity_check(hops: Hops) { init_test_logging(); let test_name = &format!("connectivity_check_for_{}_hops", hops as usize); - let mut subject: Neighborhood = make_neighborhood_linearly_connected_with_nodes(hops as u16); + let mut subject: Neighborhood = + make_neighborhood_linearly_connected_with_nodes(hops as u16); let (ui_gateway, _, ui_gateway_arc) = make_recorder(); let (accountant, _, _) = make_recorder(); let node_to_ui_recipient = ui_gateway.start().recipient::(); @@ -3984,7 +4018,11 @@ mod tests { subject.connected_signal_opt = Some(connected_signal); let system = System::new(test_name); - subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap(), make_cpm_recipient().0); + subject.handle_gossip_agrs( + vec![], + SocketAddr::from_str("1.2.3.4:1234").unwrap(), + make_cpm_recipient().0, + ); System::current().stop(); system.run(); @@ -4003,7 +4041,7 @@ mod tests { body: UiConnectionChangeBroadcast { stage: UiConnectionStage::RouteFound } - .tmb(0), + .tmb(0), } ); TestLogHandler::new().exists_log_containing(&format!( @@ -4036,7 +4074,11 @@ mod tests { subject.connected_signal_opt = Some(connected_signal); let system = System::new(test_name); - subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap(), make_cpm_recipient().0); + subject.handle_gossip_agrs( + vec![], + SocketAddr::from_str("1.2.3.4:1234").unwrap(), + make_cpm_recipient().0, + ); System::current().stop(); system.run(); @@ -4103,7 +4145,11 @@ mod tests { subject.gossip_acceptor = Box::new(gossip_acceptor); subject.persistent_config_opt = Some(Box::new(persistent_config)); - subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap(), make_cpm_recipient().0); + subject.handle_gossip_agrs( + vec![], + SocketAddr::from_str("1.2.3.4:1234").unwrap(), + make_cpm_recipient().0, + ); let mut set_past_neighbors_params = set_past_neighbors_params_arc.lock().unwrap(); let (neighbors_opt, db_password) = set_past_neighbors_params.remove(0); @@ -4142,7 +4188,11 @@ mod tests { subject.gossip_acceptor = Box::new(gossip_acceptor); subject.persistent_config_opt = Some(Box::new(persistent_config)); - subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap(), make_cpm_recipient().0); + subject.handle_gossip_agrs( + vec![], + SocketAddr::from_str("1.2.3.4:1234").unwrap(), + make_cpm_recipient().0, + ); let mut set_past_neighbors_params = set_past_neighbors_params_arc.lock().unwrap(); let (neighbors_opt, db_password) = set_past_neighbors_params.remove(0); @@ -4173,7 +4223,11 @@ mod tests { subject.gossip_acceptor = Box::new(gossip_acceptor); subject.persistent_config_opt = Some(Box::new(persistent_config)); - subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap(), make_cpm_recipient().0); + subject.handle_gossip_agrs( + vec![], + SocketAddr::from_str("1.2.3.4:1234").unwrap(), + make_cpm_recipient().0, + ); let set_past_neighbors_params = set_past_neighbors_params_arc.lock().unwrap(); assert!(set_past_neighbors_params.is_empty()); @@ -4203,7 +4257,11 @@ mod tests { subject.persistent_config_opt = Some(Box::new(persistent_config)); subject.db_password_opt = None; - subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap(), make_cpm_recipient().0); + subject.handle_gossip_agrs( + vec![], + SocketAddr::from_str("1.2.3.4:1234").unwrap(), + make_cpm_recipient().0, + ); let set_past_neighbors_params = set_past_neighbors_params_arc.lock().unwrap(); assert!(set_past_neighbors_params.is_empty()); @@ -4232,7 +4290,11 @@ mod tests { subject.gossip_acceptor = Box::new(gossip_acceptor); subject.persistent_config_opt = Some(Box::new(persistent_config)); - subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap(), make_cpm_recipient().0); + subject.handle_gossip_agrs( + vec![], + SocketAddr::from_str("1.2.3.4:1234").unwrap(), + make_cpm_recipient().0, + ); TestLogHandler::new().exists_log_containing("WARN: Neighborhood: Could not persist immediate-neighbor changes: database locked - skipping"); } @@ -4260,7 +4322,11 @@ mod tests { subject.gossip_acceptor = Box::new(gossip_acceptor); subject.persistent_config_opt = Some(Box::new(persistent_config)); - subject.handle_gossip_agrs(vec![], SocketAddr::from_str("1.2.3.4:1234").unwrap(), make_cpm_recipient().0); + subject.handle_gossip_agrs( + vec![], + SocketAddr::from_str("1.2.3.4:1234").unwrap(), + make_cpm_recipient().0, + ); TestLogHandler::new().exists_log_containing("ERROR: Neighborhood: Could not persist immediate-neighbor changes: DatabaseError(\"Booga\")"); } @@ -4331,7 +4397,7 @@ mod tests { subject.handle_gossip( Gossip_0v1::new(vec![]), SocketAddr::from_str("1.1.1.1:1111").unwrap(), - make_cpm_recipient().0 + make_cpm_recipient().0, ); System::current().stop(); @@ -4422,7 +4488,7 @@ mod tests { subject.handle_gossip( Gossip_0v1::new(vec![]), SocketAddr::from_str("1.1.1.1:1111").unwrap(), - make_cpm_recipient().0 + make_cpm_recipient().0, ); System::current().stop(); @@ -4458,7 +4524,7 @@ mod tests { // In real life this would be Relay Gossip from gossip_source to debut_node. Gossip_0v1::new(vec![]), gossip_source, - make_cpm_recipient().0 + make_cpm_recipient().0, ); System::current().stop(); @@ -4500,7 +4566,7 @@ mod tests { subject.handle_gossip( Gossip_0v1::new(vec![]), subject_node.node_addr_opt().unwrap().into(), - make_cpm_recipient().0 + make_cpm_recipient().0, ); System::current().stop(); @@ -4527,7 +4593,7 @@ mod tests { subject.handle_gossip( Gossip_0v1::new(vec![]), subject_node.node_addr_opt().unwrap().into(), - make_cpm_recipient().0 + make_cpm_recipient().0, ); System::current().stop(); @@ -5254,8 +5320,12 @@ mod tests { let nodes = (1..=nodes_count) .map(|i| { let nonce = 1000 + i as u16; - let has_ip = if i <= 2 {true} else {false}; - let node = if i == 1 { make_global_cryptde_node_record(nonce, has_ip) } else { make_node_record(nonce, has_ip) }; + let has_ip = if i <= 2 { true } else { false }; + let node = if i == 1 { + make_global_cryptde_node_record(nonce, has_ip) + } else { + make_node_record(nonce, has_ip) + }; node }) .collect::>(); @@ -5264,8 +5334,13 @@ mod tests { let neighbor = nodes.get(1).unwrap(); let mut subject = neighborhood_from_nodes(root_node, Some(neighbor)); for i in 1..nodes_count { - subject.neighborhood_database.add_node(nodes[i].clone()).unwrap(); - subject.neighborhood_database.add_arbitrary_full_neighbor(nodes[i-1].public_key(), nodes[i].public_key()); + subject + .neighborhood_database + .add_node(nodes[i].clone()) + .unwrap(); + subject + .neighborhood_database + .add_arbitrary_full_neighbor(nodes[i - 1].public_key(), nodes[i].public_key()); } let result = subject.make_round_trip_route(RouteQueryMessage { @@ -5290,12 +5365,15 @@ mod tests { let over_cryptdes = { let mut over_nodes = nodes.clone(); over_nodes.pop(); - over_nodes.iter() + over_nodes + .iter() .map(|node| CryptDENull::from(node.public_key(), TEST_DEFAULT_CHAIN)) .collect::>() }; let back_cryptdes = { - nodes.iter().rev() + nodes + .iter() + .rev() .map(|node| CryptDENull::from(node.public_key(), TEST_DEFAULT_CHAIN)) .collect::>() }; diff --git a/node/src/neighborhood/overall_connection_status.rs b/node/src/neighborhood/overall_connection_status.rs index ebc82be62..04358f076 100644 --- a/node/src/neighborhood/overall_connection_status.rs +++ b/node/src/neighborhood/overall_connection_status.rs @@ -118,7 +118,7 @@ impl ConnectionProgress { pub enum OverallConnectionStage { NotConnected = 0, ConnectedToNeighbor = 1, // When an Introduction or Standard Gossip (acceptance) is received - RouteFound = 2, // Data can be relayed once this stage is reached + RouteFound = 2, // Data can be relayed once this stage is reached } impl From for UiConnectionStage { @@ -827,10 +827,7 @@ mod tests { let route_found_converted: UiConnectionStage = route_found.into(); - assert_eq!( - route_found_converted, - UiConnectionStage::RouteFound - ); + assert_eq!(route_found_converted, UiConnectionStage::RouteFound); } #[test] diff --git a/node/src/node_configurator/node_configurator_standard.rs b/node/src/node_configurator/node_configurator_standard.rs index 1ff0eca17..40118452e 100644 --- a/node/src/node_configurator/node_configurator_standard.rs +++ b/node/src/node_configurator/node_configurator_standard.rs @@ -280,6 +280,7 @@ mod tests { use crate::db_config::config_dao::ConfigDaoReal; use crate::db_config::persistent_configuration::PersistentConfigError; use crate::db_config::persistent_configuration::PersistentConfigurationReal; + use crate::neighborhood::DEFAULT_MIN_HOPS_COUNT; use crate::node_configurator::unprivileged_parse_args_configuration::UnprivilegedParseArgsConfigurationDaoNull; use crate::node_test_utils::DirsWrapperMock; use crate::sub_lib::cryptde::CryptDE; @@ -304,7 +305,6 @@ mod tests { use std::path::PathBuf; use std::sync::{Arc, Mutex}; use std::vec; - use crate::neighborhood::DEFAULT_MIN_HOPS_COUNT; #[test] fn node_configurator_standard_unprivileged_uses_parse_args_configurator_dao_real() { diff --git a/node/src/node_configurator/unprivileged_parse_args_configuration.rs b/node/src/node_configurator/unprivileged_parse_args_configuration.rs index 411b0e90f..5a2f7c9ec 100644 --- a/node/src/node_configurator/unprivileged_parse_args_configuration.rs +++ b/node/src/node_configurator/unprivileged_parse_args_configuration.rs @@ -4,6 +4,7 @@ use crate::accountant::DEFAULT_PENDING_TOO_LONG_SEC; use crate::blockchain::bip32::Bip32ECKeyProvider; use crate::bootstrapper::BootstrapperConfig; use crate::db_config::persistent_configuration::{PersistentConfigError, PersistentConfiguration}; +use crate::neighborhood::DEFAULT_MIN_HOPS_COUNT; use crate::sub_lib::accountant::{PaymentThresholds, ScanIntervals, DEFAULT_EARNING_WALLET}; use crate::sub_lib::cryptde::CryptDE; use crate::sub_lib::cryptde_null::CryptDENull; @@ -25,7 +26,6 @@ use masq_lib::utils::{AutomapProtocol, ExpectValue}; use rustc_hex::FromHex; use std::net::{IpAddr, Ipv4Addr}; use std::str::FromStr; -use crate::neighborhood::DEFAULT_MIN_HOPS_COUNT; pub trait UnprivilegedParseArgsConfiguration { // Only initialization that cannot be done with privilege should happen here. @@ -215,15 +215,19 @@ pub fn make_neighborhood_config( } }; - let min_hops_arg = - value_m!(multi_config, "min-hops", String); + let min_hops_arg = value_m!(multi_config, "min-hops", String); let min_hops_count = match min_hops_arg { None => DEFAULT_MIN_HOPS_COUNT, - Some(string) => string.try_into().unwrap_or_else(|error| panic!("{}", error)) + Some(string) => string + .try_into() + .unwrap_or_else(|error| panic!("{}", error)), }; match make_neighborhood_mode(multi_config, neighbor_configs, persistent_config) { - Ok(mode) => Ok(NeighborhoodConfig { mode, min_hops_count }), + Ok(mode) => Ok(NeighborhoodConfig { + mode, + min_hops_count, + }), Err(e) => Err(e), } } @@ -631,7 +635,7 @@ mod tests { use crate::db_config::persistent_configuration::PersistentConfigurationReal; use crate::sub_lib::accountant::DEFAULT_PAYMENT_THRESHOLDS; use crate::sub_lib::cryptde::{PlainData, PublicKey}; - use crate::sub_lib::neighborhood::{DEFAULT_RATE_PACK, Hops}; + use crate::sub_lib::neighborhood::{Hops, DEFAULT_RATE_PACK}; use crate::sub_lib::utils::make_new_multi_config; use crate::sub_lib::wallet::Wallet; use crate::test_utils::persistent_configuration_mock::PersistentConfigurationMock; @@ -763,12 +767,14 @@ mod tests { .param("--min-hops", "100"); let vcl = CommandLineVcl::new(args.into()); - let result = make_new_multi_config( - &app_node(), - vec![Box::new(vcl)], - ).err().unwrap(); + let result = make_new_multi_config(&app_node(), vec![Box::new(vcl)]) + .err() + .unwrap(); - assert_eq!(result, ConfiguratorError::required("min-hops", "Invalid value: '100'")); + assert_eq!( + result, + ConfiguratorError::required("min-hops", "Invalid value: '100'") + ); } #[test] @@ -799,7 +805,7 @@ mod tests { let node_addr = match result { Ok(NeighborhoodConfig { mode: NeighborhoodMode::Standard(node_addr, _, _), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: DEFAULT_MIN_HOPS_COUNT, }) => node_addr, x => panic!("Wasn't expecting {:?}", x), }; diff --git a/node/src/sub_lib/neighborhood.rs b/node/src/sub_lib/neighborhood.rs index 3e82cbb35..040a03319 100644 --- a/node/src/sub_lib/neighborhood.rs +++ b/node/src/sub_lib/neighborhood.rs @@ -381,7 +381,6 @@ impl TryFrom for Hops { type Error = String; fn try_from(value: String) -> Result { - match value.as_str() { "1" => Ok(Hops::OneHop), "2" => Ok(Hops::TwoHops), @@ -1269,6 +1268,9 @@ mod tests { let result: Result = min_hops_count.try_into(); - assert_eq!(result, Err("Invalid value for min hops count provided".to_string())) + assert_eq!( + result, + Err("Invalid value for min hops count provided".to_string()) + ) } } diff --git a/node/src/test_utils/neighborhood_test_utils.rs b/node/src/test_utils/neighborhood_test_utils.rs index e217d2889..a230edcd7 100644 --- a/node/src/test_utils/neighborhood_test_utils.rs +++ b/node/src/test_utils/neighborhood_test_utils.rs @@ -3,7 +3,7 @@ use crate::bootstrapper::BootstrapperConfig; use crate::neighborhood::gossip::GossipNodeRecord; use crate::neighborhood::neighborhood_database::NeighborhoodDatabase; use crate::neighborhood::node_record::{NodeRecord, NodeRecordInner_0v1}; -use crate::neighborhood::{AccessibleGossipRecord, DEFAULT_MIN_HOPS_COUNT, Neighborhood}; +use crate::neighborhood::{AccessibleGossipRecord, Neighborhood, DEFAULT_MIN_HOPS_COUNT}; use crate::sub_lib::cryptde::PublicKey; use crate::sub_lib::cryptde::{CryptDE, PlainData}; use crate::sub_lib::cryptde_null::CryptDENull; From 2dc04c639ffd23ce96b3235d2e7a65533d94b84c Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Tue, 25 Apr 2023 12:31:54 +0530 Subject: [PATCH 26/56] GH-690: remove unnecessary comments --- node/src/neighborhood/gossip_acceptor.rs | 8 -------- 1 file changed, 8 deletions(-) diff --git a/node/src/neighborhood/gossip_acceptor.rs b/node/src/neighborhood/gossip_acceptor.rs index be26aa00c..7cfffb84c 100644 --- a/node/src/neighborhood/gossip_acceptor.rs +++ b/node/src/neighborhood/gossip_acceptor.rs @@ -62,9 +62,6 @@ trait GossipHandler: NamedType + Send /* Send because lazily-written tests requi agrs: Vec, gossip_source: SocketAddr, neighborhood_metadata: NeighborhoodMetadata, - // connection_progress_peers: Vec, - // cpm_recipient: Recipient, - // min_hops_count: u8, ) -> GossipAcceptanceResult; } @@ -1265,11 +1262,6 @@ impl<'a> GossipAcceptor for GossipAcceptorReal<'a> { "Gossip delegated to {}", handler_ref.type_name() ); - // let neighborhood_metadata = NeighborhoodMetadata { - // connection_progress_peers, - // cpm_recipient: self.cpm_recipient.clone(), - // min_hops_count, - // }; handler_ref.handle( self.cryptde, database, From 50b30482988b1e9c66cead9303e7f39dd863eef5 Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Tue, 25 Apr 2023 12:37:00 +0530 Subject: [PATCH 27/56] GH-690: fix the multionde test --- multinode_integration_tests/tests/connection_progress_test.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/multinode_integration_tests/tests/connection_progress_test.rs b/multinode_integration_tests/tests/connection_progress_test.rs index 41172ba59..023ad4c88 100644 --- a/multinode_integration_tests/tests/connection_progress_test.rs +++ b/multinode_integration_tests/tests/connection_progress_test.rs @@ -56,9 +56,9 @@ fn connection_progress_is_properly_broadcast() { let message_body = ui_client.wait_for_specific_broadcast(vec!["connectionChange"], Duration::from_secs(5)); let (ccb, _) = UiConnectionChangeBroadcast::fmb(message_body).unwrap(); - assert_eq!(ccb.stage, UiConnectionStage::ThreeHopsRouteFound); + assert_eq!(ccb.stage, UiConnectionStage::RouteFound); } else { - assert_eq!(ccb.stage, UiConnectionStage::ThreeHopsRouteFound); + assert_eq!(ccb.stage, UiConnectionStage::RouteFound); } } From 6eb1b257a68dd34542ea257fd78bcc21c07a998e Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Wed, 26 Apr 2023 13:08:39 +0530 Subject: [PATCH 28/56] GH-690: add min_hops_count as a field inside NodeStartupConfig for multinode tests --- .../src/masq_real_node.rs | 23 ++++++++++++++++++- 1 file changed, 22 insertions(+), 1 deletion(-) diff --git a/multinode_integration_tests/src/masq_real_node.rs b/multinode_integration_tests/src/masq_real_node.rs index 0bdeb75bd..63960b834 100644 --- a/multinode_integration_tests/src/masq_real_node.rs +++ b/multinode_integration_tests/src/masq_real_node.rs @@ -20,7 +20,7 @@ use node_lib::sub_lib::accountant::{ }; use node_lib::sub_lib::cryptde::{CryptDE, PublicKey}; use node_lib::sub_lib::cryptde_null::CryptDENull; -use node_lib::sub_lib::neighborhood::{RatePack, DEFAULT_RATE_PACK, ZERO_RATE_PACK}; +use node_lib::sub_lib::neighborhood::{RatePack, DEFAULT_RATE_PACK, ZERO_RATE_PACK, Hops}; use node_lib::sub_lib::node_addr::NodeAddr; use node_lib::sub_lib::wallet::Wallet; use regex::Regex; @@ -34,6 +34,7 @@ use std::str::FromStr; use std::string::ToString; use std::thread; use std::time::Duration; +use node_lib::neighborhood::DEFAULT_MIN_HOPS_COUNT; pub const DATA_DIRECTORY: &str = "/node_root/home"; @@ -112,6 +113,7 @@ pub fn make_consuming_wallet_info(token: &str) -> ConsumingWalletInfo { #[derive(PartialEq, Eq, Clone, Debug)] pub struct NodeStartupConfig { pub neighborhood_mode: String, + pub min_hops_count: Hops, pub ip_info: LocalIpInfo, pub dns_servers_opt: Option>, pub neighbors: Vec, @@ -143,6 +145,7 @@ impl NodeStartupConfig { pub fn new() -> NodeStartupConfig { NodeStartupConfig { neighborhood_mode: "standard".to_string(), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, ip_info: LocalIpInfo::ZeroHop, dns_servers_opt: None, neighbors: Vec::new(), @@ -174,6 +177,8 @@ impl NodeStartupConfig { let mut args = vec![]; args.push("--neighborhood-mode".to_string()); args.push(self.neighborhood_mode.clone()); + args.push("--min-hops".to_string()); + args.push(format!("{}", self.min_hops_count as usize)); if let LocalIpInfo::DistributedKnown(ip_addr) = self.ip_info { args.push("--ip".to_string()); args.push(ip_addr.to_string()); @@ -403,6 +408,7 @@ impl NodeStartupConfig { pub struct NodeStartupConfigBuilder { neighborhood_mode: String, + min_hops_count: Hops, ip_info: LocalIpInfo, dns_servers_opt: Option>, neighbors: Vec, @@ -458,6 +464,7 @@ impl NodeStartupConfigBuilder { pub fn standard() -> Self { Self { neighborhood_mode: "standard".to_string(), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, ip_info: LocalIpInfo::DistributedUnknown, dns_servers_opt: None, neighbors: vec![], @@ -483,6 +490,7 @@ impl NodeStartupConfigBuilder { pub fn copy(config: &NodeStartupConfig) -> Self { Self { neighborhood_mode: config.neighborhood_mode.clone(), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, ip_info: config.ip_info, dns_servers_opt: config.dns_servers_opt.clone(), neighbors: config.neighbors.clone(), @@ -521,6 +529,11 @@ impl NodeStartupConfigBuilder { } } + pub fn min_hops_count(mut self, value: Hops) -> Self { + self.min_hops_count = value; + self + } + pub fn ip(mut self, value: IpAddr) -> Self { self.ip_info = LocalIpInfo::DistributedKnown(value); self @@ -634,6 +647,7 @@ impl NodeStartupConfigBuilder { pub fn build(self) -> NodeStartupConfig { NodeStartupConfig { neighborhood_mode: self.neighborhood_mode, + min_hops_count: self.min_hops_count, ip_info: self.ip_info, dns_servers_opt: self.dns_servers_opt, neighbors: self.neighbors, @@ -1289,6 +1303,7 @@ mod tests { #[test] fn node_startup_config_builder_settings() { + let min_hops_count = Hops::SixHops; let ip_addr = IpAddr::from_str("1.2.3.4").unwrap(); let one_neighbor_key = PublicKey::new(&[1, 2, 3, 4]); let one_neighbor_ip_addr = IpAddr::from_str("4.5.6.7").unwrap(); @@ -1317,6 +1332,7 @@ mod tests { let dns_target = IpAddr::from_str("8.9.10.11").unwrap(); let result = NodeStartupConfigBuilder::standard() + .min_hops_count(min_hops_count) .ip(ip_addr) .dns_servers(dns_servers.clone()) .neighbor(neighbors[0].clone()) @@ -1325,6 +1341,7 @@ mod tests { .dns_port(35) .build(); + assert_eq!(result.min_hops_count, min_hops_count); assert_eq!(result.ip_info, LocalIpInfo::DistributedKnown(ip_addr)); assert_eq!(result.dns_servers_opt, Some(dns_servers)); assert_eq!(result.neighbors, neighbors); @@ -1337,6 +1354,7 @@ mod tests { fn node_startup_config_builder_copy() { let original = NodeStartupConfig { neighborhood_mode: "consume-only".to_string(), + min_hops_count: DEFAULT_MIN_HOPS_COUNT, ip_info: LocalIpInfo::DistributedUnknown, dns_servers_opt: Some(vec![IpAddr::from_str("255.255.255.255").unwrap()]), neighbors: vec![NodeReference::new( @@ -1481,6 +1499,7 @@ mod tests { let subject = NodeStartupConfigBuilder::standard() .neighborhood_mode("consume-only") + .min_hops_count(Hops::SixHops) .ip(IpAddr::from_str("1.3.5.7").unwrap()) .neighbor(one_neighbor.clone()) .neighbor(another_neighbor.clone()) @@ -1496,6 +1515,8 @@ mod tests { Command::strings(vec!( "--neighborhood-mode", "consume-only", + "--min-hops", + "6", "--ip", "1.3.5.7", "--neighbors", From 61c194aca49863ec82aa6ee36ee6db9068bd94dc Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Thu, 27 Apr 2023 10:52:47 +0530 Subject: [PATCH 29/56] GH-690: allow NodeStartupConfigBuilder to copy the min_hops_count from the original config --- multinode_integration_tests/src/masq_real_node.rs | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/multinode_integration_tests/src/masq_real_node.rs b/multinode_integration_tests/src/masq_real_node.rs index 63960b834..aa3ad7b23 100644 --- a/multinode_integration_tests/src/masq_real_node.rs +++ b/multinode_integration_tests/src/masq_real_node.rs @@ -490,7 +490,7 @@ impl NodeStartupConfigBuilder { pub fn copy(config: &NodeStartupConfig) -> Self { Self { neighborhood_mode: config.neighborhood_mode.clone(), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: config.min_hops_count, ip_info: config.ip_info, dns_servers_opt: config.dns_servers_opt.clone(), neighbors: config.neighbors.clone(), @@ -1240,6 +1240,7 @@ mod tests { use masq_lib::constants::{HTTP_PORT, TLS_PORT}; use masq_lib::test_utils::utils::TEST_DEFAULT_MULTINODE_CHAIN; use masq_lib::utils::localhost; + use node_lib::sub_lib::neighborhood::Hops::TwoHops; #[test] fn node_startup_config_builder_zero_hop() { @@ -1354,7 +1355,7 @@ mod tests { fn node_startup_config_builder_copy() { let original = NodeStartupConfig { neighborhood_mode: "consume-only".to_string(), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: TwoHops, ip_info: LocalIpInfo::DistributedUnknown, dns_servers_opt: Some(vec![IpAddr::from_str("255.255.255.255").unwrap()]), neighbors: vec![NodeReference::new( @@ -1433,6 +1434,7 @@ mod tests { .build(); assert_eq!(result.neighborhood_mode, neighborhood_mode); + assert_eq!(result.min_hops_count, Hops::TwoHops); assert_eq!(result.ip_info, LocalIpInfo::DistributedKnown(ip_addr)); assert_eq!(result.dns_servers_opt, Some(dns_servers)); assert_eq!(result.neighbors, neighbors); From 99b7ee4cf3b78c926b3b9f07431846860f7f5bff Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Thu, 27 Apr 2023 12:22:13 +0530 Subject: [PATCH 30/56] GH-690: fix the problem of accidentally defaulting the min_hops_count --- node/src/bootstrapper.rs | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/node/src/bootstrapper.rs b/node/src/bootstrapper.rs index 34fdca65c..1d21cd38e 100644 --- a/node/src/bootstrapper.rs +++ b/node/src/bootstrapper.rs @@ -649,14 +649,11 @@ impl Bootstrapper { ) .expect("Failed to bind ListenerHandler to clandestine port"); self.listener_handlers.push(listener_handler); - self.config.neighborhood_config = NeighborhoodConfig { - mode: NeighborhoodMode::Standard( - NodeAddr::new(&node_addr.ip_addr(), &[clandestine_port]), - neighbor_configs.clone(), - *rate_pack, - ), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, // TODO: Verify, is this right? - }; + self.config.neighborhood_config.mode = NeighborhoodMode::Standard( + NodeAddr::new(&node_addr.ip_addr(), &[clandestine_port]), + neighbor_configs.clone(), + *rate_pack, + ); Some(clandestine_port) } else { None From 47342e3df4dfcebfb354274aeb3b42c085f3255b Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Thu, 27 Apr 2023 12:58:10 +0530 Subject: [PATCH 31/56] GH-690: write multinode test for testing Node with different min_hops_count --- .../tests/data_routing_test.rs | 55 +++++++++++++++++++ 1 file changed, 55 insertions(+) diff --git a/multinode_integration_tests/tests/data_routing_test.rs b/multinode_integration_tests/tests/data_routing_test.rs index 6be340d4e..067a29daa 100644 --- a/multinode_integration_tests/tests/data_routing_test.rs +++ b/multinode_integration_tests/tests/data_routing_test.rs @@ -19,6 +19,7 @@ use std::net::{IpAddr, SocketAddr, TcpStream}; use std::str::FromStr; use std::thread; use std::time::Duration; +use node_lib::sub_lib::neighborhood::Hops; #[test] fn http_end_to_end_routing_test() { @@ -69,6 +70,60 @@ fn http_end_to_end_routing_test() { ); } +fn assert_http_end_to_end_routing_test(min_hops_count: Hops) { + let mut cluster = MASQNodeCluster::start().unwrap(); + let config = NodeStartupConfigBuilder::standard() + .min_hops_count(min_hops_count) + .chain(cluster.chain) + .build(); + let first_node = cluster.start_real_node(config); + + let middle_nodes_count = 2 * (min_hops_count as usize); + let nodes = (0..middle_nodes_count) + .map(|_| { + cluster.start_real_node( + NodeStartupConfigBuilder::standard() + .neighbor(first_node.node_reference()) + .chain(cluster.chain) + .build(), + ) + }) + .collect::>(); + + thread::sleep(Duration::from_millis(500 * (nodes.len() as u64))); + + let last_node = cluster.start_real_node( + NodeStartupConfigBuilder::standard() + .neighbor(nodes.last().unwrap().node_reference()) + .consuming_wallet_info(make_consuming_wallet_info("last_node")) + .chain(cluster.chain) + .build(), + ); + + thread::sleep(Duration::from_millis(500)); + + let mut client = last_node.make_client(8080); + client.send_chunk(b"GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n"); + let response = client.wait_for_chunk(); + + assert_eq!( + index_of(&response, &b"

Example Domain

"[..]).is_some(), + true, + "Actual response:\n{}", + String::from_utf8(response).unwrap() + ); +} + +#[test] +fn http_end_to_end_routing_test_with_different_min_hops_count() { + assert_http_end_to_end_routing_test(Hops::OneHop); + assert_http_end_to_end_routing_test(Hops::TwoHops); + assert_http_end_to_end_routing_test(Hops::ThreeHops); + assert_http_end_to_end_routing_test(Hops::FourHops); + assert_http_end_to_end_routing_test(Hops::FiveHops); + assert_http_end_to_end_routing_test(Hops::SixHops); +} + #[test] fn http_end_to_end_routing_test_with_consume_and_originate_only_nodes() { let mut cluster = MASQNodeCluster::start().unwrap(); From 30101d335c2514647268511a4c959638e194efd2 Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Thu, 27 Apr 2023 17:41:31 +0530 Subject: [PATCH 32/56] GH-690: use Into implementation for NeighborhoodModeLight --- masq_lib/src/utils.rs | 2 ++ .../tests/data_routing_test.rs | 13 ++++---- node/src/neighborhood/mod.rs | 23 ++++++++----- .../node_configurator_standard.rs | 2 +- node/src/sub_lib/neighborhood.rs | 33 ++++++++++--------- 5 files changed, 42 insertions(+), 31 deletions(-) diff --git a/masq_lib/src/utils.rs b/masq_lib/src/utils.rs index 5196086c5..3556a720e 100644 --- a/masq_lib/src/utils.rs +++ b/masq_lib/src/utils.rs @@ -220,6 +220,8 @@ impl FromStr for NeighborhoodModeLight { } } + + pub fn plus(mut source: Vec, item: T) -> Vec { let mut result = vec![]; result.append(&mut source); diff --git a/multinode_integration_tests/tests/data_routing_test.rs b/multinode_integration_tests/tests/data_routing_test.rs index 067a29daa..b2e3a9d66 100644 --- a/multinode_integration_tests/tests/data_routing_test.rs +++ b/multinode_integration_tests/tests/data_routing_test.rs @@ -75,6 +75,7 @@ fn assert_http_end_to_end_routing_test(min_hops_count: Hops) { let config = NodeStartupConfigBuilder::standard() .min_hops_count(min_hops_count) .chain(cluster.chain) + .consuming_wallet_info(make_consuming_wallet_info("first_node")) .build(); let first_node = cluster.start_real_node(config); @@ -102,7 +103,7 @@ fn assert_http_end_to_end_routing_test(min_hops_count: Hops) { thread::sleep(Duration::from_millis(500)); - let mut client = last_node.make_client(8080); + let mut client = first_node.make_client(8080); client.send_chunk(b"GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n"); let response = client.wait_for_chunk(); @@ -117,11 +118,11 @@ fn assert_http_end_to_end_routing_test(min_hops_count: Hops) { #[test] fn http_end_to_end_routing_test_with_different_min_hops_count() { assert_http_end_to_end_routing_test(Hops::OneHop); - assert_http_end_to_end_routing_test(Hops::TwoHops); - assert_http_end_to_end_routing_test(Hops::ThreeHops); - assert_http_end_to_end_routing_test(Hops::FourHops); - assert_http_end_to_end_routing_test(Hops::FiveHops); - assert_http_end_to_end_routing_test(Hops::SixHops); + // assert_http_end_to_end_routing_test(Hops::TwoHops); + // assert_http_end_to_end_routing_test(Hops::ThreeHops); + // assert_http_end_to_end_routing_test(Hops::FourHops); + // assert_http_end_to_end_routing_test(Hops::FiveHops); + // assert_http_end_to_end_routing_test(Hops::SixHops); } #[test] diff --git a/node/src/neighborhood/mod.rs b/node/src/neighborhood/mod.rs index bfee74d58..dbcec6889 100644 --- a/node/src/neighborhood/mod.rs +++ b/node/src/neighborhood/mod.rs @@ -25,7 +25,7 @@ use masq_lib::messages::{ }; use masq_lib::messages::{UiConnectionStatusResponse, UiShutdownRequest}; use masq_lib::ui_gateway::{MessageTarget, NodeFromUiMessage, NodeToUiMessage}; -use masq_lib::utils::{exit_process, ExpectValue}; +use masq_lib::utils::{exit_process, ExpectValue, NeighborhoodModeLight}; use crate::bootstrapper::BootstrapperConfig; use crate::database::db_initializer::DbInitializationConfig; @@ -91,6 +91,7 @@ pub struct Neighborhood { gossip_producer: Box, neighborhood_database: NeighborhoodDatabase, consuming_wallet_opt: Option, + mode: NeighborhoodModeLight, min_hops_count: Hops, next_return_route_id: u32, overall_connection_status: OverallConnectionStatus, @@ -430,9 +431,12 @@ enum RouteDirection { impl Neighborhood { pub fn new(cryptde: &'static dyn CryptDE, config: &BootstrapperConfig) -> Self { let neighborhood_config = &config.neighborhood_config; - let min_hops_count = config.neighborhood_config.min_hops_count; - if neighborhood_config.mode.is_zero_hop() - && !neighborhood_config.mode.neighbor_configs().is_empty() + let min_hops_count = neighborhood_config.min_hops_count; + let neighborhood_mode = &neighborhood_config.mode; + let mode: NeighborhoodModeLight = neighborhood_mode.into(); + let neighborhood_configs = neighborhood_mode.neighbor_configs(); + if mode == NeighborhoodModeLight::ZeroHop + && !neighborhood_configs.is_empty() { panic!( "A zero-hop MASQ Node is not decentralized and cannot have a --neighbors setting" @@ -440,14 +444,12 @@ impl Neighborhood { } let neighborhood_database = NeighborhoodDatabase::new( cryptde.public_key(), - neighborhood_config.mode.clone(), + neighborhood_mode.clone(), config.earning_wallet.clone(), cryptde, ); let is_mainnet = config.blockchain_bridge_config.chain.is_mainnet(); - let initial_neighbors: Vec = neighborhood_config - .mode - .neighbor_configs() + let initial_neighbors: Vec = neighborhood_configs .iter() .map(|nc| { let mainnet_nc = nc.blockchain.is_mainnet(); @@ -474,6 +476,7 @@ impl Neighborhood { gossip_producer: Box::new(GossipProducerReal::new()), neighborhood_database, consuming_wallet_opt: config.consuming_wallet_opt.clone(), + mode, min_hops_count, next_return_route_id: 0, overall_connection_status, @@ -840,7 +843,9 @@ impl Neighborhood { payload_size: 10000, hostname_opt: None, }; - if self.handle_route_query_message(msg).is_some() { + debug!(Logger::new("Multinode"), "Searching for a {}-hops route.", self.min_hops_count as usize); + if let Some(route_query_response) = self.handle_route_query_message(msg) { + trace!(Logger::new("Multinode"), "Round Trip Route Length: {:?}", route_query_response.route.hops.len()); debug!( &self.logger, "The connectivity check has found a {}-hops route.", self.min_hops_count as usize diff --git a/node/src/node_configurator/node_configurator_standard.rs b/node/src/node_configurator/node_configurator_standard.rs index 40118452e..1fb15d546 100644 --- a/node/src/node_configurator/node_configurator_standard.rs +++ b/node/src/node_configurator/node_configurator_standard.rs @@ -252,7 +252,7 @@ fn configure_database( return Err(pce.into_configurator_error("clandestine-port")); } } - let neighborhood_mode_light = config.neighborhood_config.mode.make_light(); + let neighborhood_mode_light: NeighborhoodModeLight = (&config.neighborhood_config.mode).into(); if let Err(pce) = persistent_config.set_neighborhood_mode(neighborhood_mode_light) { return Err(pce.into_configurator_error("neighborhood-mode")); } diff --git a/node/src/sub_lib/neighborhood.rs b/node/src/sub_lib/neighborhood.rs index 040a03319..10b4ffd40 100644 --- a/node/src/sub_lib/neighborhood.rs +++ b/node/src/sub_lib/neighborhood.rs @@ -87,6 +87,17 @@ impl Display for NeighborhoodMode { } } +impl Into for &NeighborhoodMode { + fn into(self) -> NeighborhoodModeLight { + match self { + NeighborhoodMode::Standard(_, _, _) => NeighborhoodModeLight::Standard, + NeighborhoodMode::ConsumeOnly(_) => NeighborhoodModeLight::ConsumeOnly, + NeighborhoodMode::OriginateOnly(_, _) => NeighborhoodModeLight::OriginateOnly, + NeighborhoodMode::ZeroHop => NeighborhoodModeLight::ZeroHop, + } + } +} + impl NeighborhoodMode { pub fn is_decentralized(&self) -> bool { self != &NeighborhoodMode::ZeroHop @@ -142,15 +153,6 @@ impl NeighborhoodMode { pub fn is_zero_hop(&self) -> bool { matches!(self, NeighborhoodMode::ZeroHop) } - - pub fn make_light(&self) -> NeighborhoodModeLight { - match self { - NeighborhoodMode::Standard(_, _, _) => NeighborhoodModeLight::Standard, - NeighborhoodMode::ConsumeOnly(_) => NeighborhoodModeLight::ConsumeOnly, - NeighborhoodMode::OriginateOnly(_, _) => NeighborhoodModeLight::OriginateOnly, - NeighborhoodMode::ZeroHop => NeighborhoodModeLight::ZeroHop, - } - } } //TODO we could write our own impl of serde for Chain in order to optimize @@ -1220,7 +1222,7 @@ mod tests { #[test] fn neighborhood_mode_light_can_be_made_from_neighborhood_mode() { assert_make_light( - NeighborhoodMode::Standard( + &NeighborhoodMode::Standard( NodeAddr::new(&localhost(), &[1234, 2345]), vec![], rate_pack(100), @@ -1228,18 +1230,19 @@ mod tests { NeighborhoodModeLight::Standard, ); assert_make_light( - NeighborhoodMode::ConsumeOnly(vec![]), + &NeighborhoodMode::ConsumeOnly(vec![]), NeighborhoodModeLight::ConsumeOnly, ); assert_make_light( - NeighborhoodMode::OriginateOnly(vec![], rate_pack(100)), + &NeighborhoodMode::OriginateOnly(vec![], rate_pack(100)), NeighborhoodModeLight::OriginateOnly, ); - assert_make_light(NeighborhoodMode::ZeroHop, NeighborhoodModeLight::ZeroHop) + assert_make_light(&NeighborhoodMode::ZeroHop, NeighborhoodModeLight::ZeroHop) } - fn assert_make_light(heavy: NeighborhoodMode, expected_value: NeighborhoodModeLight) { - assert_eq!(heavy.make_light(), expected_value) + fn assert_make_light(heavy: &NeighborhoodMode, expected_value: NeighborhoodModeLight) { + let result: NeighborhoodModeLight = heavy.into(); + assert_eq!(result, expected_value) } #[test] From c18a839d888e97694bda0a8341cbd656b8a25ba9 Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Fri, 28 Apr 2023 12:36:07 +0530 Subject: [PATCH 33/56] GH-690: get min_hops_count from Neighborhood instad of RouteQueryMessage --- node/src/neighborhood/mod.rs | 82 ++++++++++++++++++-------------- node/src/proxy_server/mod.rs | 17 ++----- node/src/sub_lib/neighborhood.rs | 8 ++-- 3 files changed, 54 insertions(+), 53 deletions(-) diff --git a/node/src/neighborhood/mod.rs b/node/src/neighborhood/mod.rs index dbcec6889..249e4a06a 100644 --- a/node/src/neighborhood/mod.rs +++ b/node/src/neighborhood/mod.rs @@ -535,11 +535,12 @@ impl Neighborhood { fn handle_route_query_message(&mut self, msg: RouteQueryMessage) -> Option { let debug_msg_opt = self.logger.debug_enabled().then(|| format!("{:?}", msg)); - let route_result = if msg.minimum_hop_count == 0 { + let route_result = if self.mode == NeighborhoodModeLight::ZeroHop { Ok(self.zero_hop_route_response()) } else { self.make_round_trip_route(msg) }; + eprintln!("Round Trip Result: {:?}", route_result); match route_result { Ok(response) => { let msg_str = debug_msg_opt.expect("Debug Message wasn't built but expected."); @@ -838,7 +839,6 @@ impl Neighborhood { let msg = RouteQueryMessage { target_key_opt: None, target_component: Component::ProxyClient, - minimum_hop_count: self.min_hops_count as usize, return_component_opt: Some(Component::ProxyServer), payload_size: 10000, hostname_opt: None, @@ -974,7 +974,7 @@ impl Neighborhood { let over = self.make_route_segment( self.cryptde.public_key(), request_msg.target_key_opt.as_ref(), - request_msg.minimum_hop_count, + self.min_hops_count as usize, request_msg.target_component, request_msg.payload_size, RouteDirection::Over, @@ -989,7 +989,7 @@ impl Neighborhood { let back = self.make_route_segment( over.keys.last().expect("Empty segment"), Some(self.cryptde.public_key()), - request_msg.minimum_hop_count, + self.min_hops_count as usize, request_msg .return_component_opt .expect("No return component"), @@ -1067,6 +1067,7 @@ impl Neighborhood { ); match route_opt { None => { + // panic!("yes, this is the right place"); let target_str = match target_opt { Some(t) => format!(" {}", t), None => String::from("Unknown"), @@ -1234,6 +1235,10 @@ impl Neighborhood { let mut minimum_undesirability = i64::MAX; let initial_undesirability = self.compute_initial_undesirability(source, payload_size as u64, direction); + // Args passed to routing engine: [0xA59FFDC71BDB6B4F4E075C59538CB59A20EE1CC67697DF3939A1EEFBB70C897F] 0 None 2 1000 Over 9223372036854775807 None + // [0xDCDBDC19A160F7272C7A0342E2860430EEA163ECA654091AD85736B591D82EB4] 0 None 3 1000 Over 9223372036854775807 None + // panic!("Args passed to routing engine: {:?} {} {:?} {} {} {:?} {} {:?}", vec![source], initial_undesirability, target_opt, minimum_hops, payload_size, direction, minimum_undesirability, hostname_opt); + eprintln!("Minimum Hops sent to routing engine: {}", minimum_hops); let result = self .routing_engine( vec![source], @@ -1244,11 +1249,17 @@ impl Neighborhood { direction, &mut minimum_undesirability, hostname_opt, - ) + ); + eprintln!("Routing Engine Result: {:?}", result.len()); + + let result = result .into_iter() - .filter_map(|cr| match cr.undesirability <= minimum_undesirability { - true => Some(cr.nodes), - false => None, + .filter_map(|cr| { + eprintln!("Route Undesirability: {}, minimum_undesirability: {}", cr.undesirability, minimum_undesirability); + match cr.undesirability <= minimum_undesirability { + true => Some(cr.nodes), + false => None, + } }) .next(); @@ -2752,7 +2763,7 @@ mod tests { let sub: Recipient = addr.recipient::(); let future = sub.send(RouteQueryMessage::data_indefinite_route_request( - None, 5, 400, + None, 400, )); System::current().stop_with_code(0); @@ -2770,7 +2781,7 @@ mod tests { let sub: Recipient = addr.recipient::(); let future = sub.send(RouteQueryMessage::data_indefinite_route_request( - None, 2, 430, + None, 430, )); System::current().stop_with_code(0); @@ -2787,6 +2798,7 @@ mod tests { "route_query_succeeds_when_asked_for_one_hop_round_trip_route_without_consuming_wallet", ); let mut subject = make_standard_subject(); + subject.min_hops_count = Hops::OneHop; subject .neighborhood_database .root_mut() @@ -2811,7 +2823,7 @@ mod tests { } let addr: Addr = subject.start(); let sub: Recipient = addr.recipient::(); - let msg = RouteQueryMessage::data_indefinite_route_request(None, 1, 54000); + let msg = RouteQueryMessage::data_indefinite_route_request(None, 54000); let future = sub.send(msg); @@ -2884,7 +2896,7 @@ mod tests { } let addr: Addr = subject.start(); let sub: Recipient = addr.recipient::(); - let msg = RouteQueryMessage::data_indefinite_route_request(None, 1, 10000); + let msg = RouteQueryMessage::data_indefinite_route_request(None, 10000); let future = sub.send(msg); @@ -2901,7 +2913,7 @@ mod tests { let subject = make_standard_subject(); let addr: Addr = subject.start(); let sub: Recipient = addr.recipient::(); - let msg = RouteQueryMessage::data_indefinite_route_request(None, 2, 20000); + let msg = RouteQueryMessage::data_indefinite_route_request(None, 20000); let future = sub.send(msg); @@ -2915,12 +2927,13 @@ mod tests { fn route_query_responds_with_standard_zero_hop_route_when_requested() { let cryptde = main_cryptde(); let system = System::new("responds_with_standard_zero_hop_route_when_requested"); - let subject = make_standard_subject(); + let mut subject = make_standard_subject(); + subject.mode = NeighborhoodModeLight::ZeroHop; let addr: Addr = subject.start(); let sub: Recipient = addr.recipient::(); let future = sub.send(RouteQueryMessage::data_indefinite_route_request( - None, 0, 12345, + None, 12345, )); System::current().stop_with_code(0); @@ -2987,6 +3000,7 @@ mod tests { let earning_wallet = make_wallet("earning"); let system = System::new("route_query_messages"); let mut subject = make_standard_subject(); + subject.min_hops_count = Hops::TwoHops; subject .neighborhood_database .root_mut() @@ -3016,7 +3030,7 @@ mod tests { let sub: Recipient = addr.recipient::(); let data_route = sub.send(RouteQueryMessage::data_indefinite_route_request( - None, 2, 5000, + None, 5000, )); System::current().stop_with_code(0); @@ -3107,21 +3121,20 @@ mod tests { fn return_route_ids_increase() { let cryptde = main_cryptde(); let system = System::new("return_route_ids_increase"); - let (_, _, _, subject) = make_o_r_e_subject(); - + let (_, _, _, mut subject) = make_o_r_e_subject(); + subject.min_hops_count = Hops::TwoHops; let addr: Addr = subject.start(); let sub: Recipient = addr.recipient::(); let data_route_0 = sub.send(RouteQueryMessage::data_indefinite_route_request( - None, 2, 2000, + None, 2000, )); let data_route_1 = sub.send(RouteQueryMessage::data_indefinite_route_request( - None, 2, 3000, + None, 3000, )); System::current().stop_with_code(0); system.run(); - let result_0 = data_route_0.wait().unwrap().unwrap(); let result_1 = data_route_1.wait().unwrap().unwrap(); let juicy_parts = |result: RouteQueryResponse| { @@ -3143,7 +3156,8 @@ mod tests { fn can_update_consuming_wallet() { let cryptde = main_cryptde(); let system = System::new("can_update_consuming_wallet"); - let (o, r, e, subject) = make_o_r_e_subject(); + let (o, r, e, mut subject) = make_o_r_e_subject(); + subject.min_hops_count = Hops::TwoHops; let addr: Addr = subject.start(); let set_wallet_sub = addr.clone().recipient::(); let route_sub = addr.recipient::(); @@ -3168,13 +3182,13 @@ mod tests { .unwrap(); let route_request_1 = route_sub.send(RouteQueryMessage::data_indefinite_route_request( - None, 2, 1000, + None, 1000, )); let _ = set_wallet_sub.try_send(SetConsumingWalletMessage { wallet: expected_new_wallet, }); let route_request_2 = route_sub.send(RouteQueryMessage::data_indefinite_route_request( - None, 2, 2000, + None, 2000, )); System::current().stop(); @@ -4869,7 +4883,6 @@ mod tests { let three_hop_route_request = RouteQueryMessage { target_key_opt: Some(c.public_key().clone()), target_component: Component::ProxyClient, - minimum_hop_count: 3, return_component_opt: None, payload_size: 10000, hostname_opt: None, @@ -5198,10 +5211,12 @@ mod tests { #[test] fn make_round_trip_route_returns_error_when_no_non_next_door_neighbor_found() { // Make a triangle of Nodes + let min_hops_count = Hops::TwoHops; let one_next_door_neighbor = make_node_record(3333, true); let another_next_door_neighbor = make_node_record(4444, true); let subject_node = make_global_cryptde_node_record(5555, true); // 9e7p7un06eHs6frl5A let mut subject = neighborhood_from_nodes(&subject_node, Some(&one_next_door_neighbor)); + subject.min_hops_count = min_hops_count; subject .neighborhood_database @@ -5225,12 +5240,9 @@ mod tests { another_next_door_neighbor.public_key(), ); - let minimum_hop_count = 2; - let result = subject.make_round_trip_route(RouteQueryMessage { target_key_opt: None, target_component: Component::ProxyClient, - minimum_hop_count, return_component_opt: Some(Component::ProxyServer), payload_size: 10000, hostname_opt: None, @@ -5239,7 +5251,7 @@ mod tests { assert_eq!( Err(format!( "Couldn't find any routes: at least {}-hop from {} to ProxyClient at Unknown", - minimum_hop_count, + min_hops_count as usize, main_cryptde().public_key() )), result @@ -5253,6 +5265,7 @@ mod tests { let subject_node = make_global_cryptde_node_record(666, true); // 9e7p7un06eHs6frl5A let mut subject = neighborhood_from_nodes(&subject_node, Some(&next_door_neighbor)); + subject.min_hops_count = Hops::TwoHops; subject .neighborhood_database @@ -5272,12 +5285,9 @@ mod tests { .neighborhood_database .add_arbitrary_full_neighbor(next_door_neighbor.public_key(), exit_node.public_key()); - let minimum_hop_count = 2; - let result = subject.make_round_trip_route(RouteQueryMessage { target_key_opt: None, target_component: Component::ProxyClient, - minimum_hop_count, return_component_opt: Some(Component::ProxyServer), payload_size: 10000, hostname_opt: None, @@ -5318,8 +5328,8 @@ mod tests { assert_eq!(expected_public_keys, actual_keys); } - fn assert_route_query_message(hops: Hops) { - let hops = hops as usize; + fn assert_route_query_message(min_hops_count: Hops) { + let hops = min_hops_count as usize; let nodes_count = hops + 1; // Create Nodes let nodes = (1..=nodes_count) @@ -5338,6 +5348,7 @@ mod tests { let root_node = nodes.get(0).unwrap(); let neighbor = nodes.get(1).unwrap(); let mut subject = neighborhood_from_nodes(root_node, Some(neighbor)); + subject.min_hops_count = min_hops_count; for i in 1..nodes_count { subject .neighborhood_database @@ -5351,7 +5362,6 @@ mod tests { let result = subject.make_round_trip_route(RouteQueryMessage { target_key_opt: None, target_component: Component::ProxyClient, - minimum_hop_count: hops, return_component_opt: Some(Component::ProxyServer), payload_size: 10000, hostname_opt: None, @@ -5424,6 +5434,7 @@ mod tests { fn check_fee_preference(payload_size: usize, a_not_b: bool) { let mut subject = make_standard_subject(); + subject.min_hops_count = Hops::TwoHops; let db = &mut subject.neighborhood_database; let o = &db.root().public_key().clone(); let a = &db.add_node(make_node_record(2345, true)).unwrap(); @@ -5452,7 +5463,6 @@ mod tests { .handle_route_query_message(RouteQueryMessage { target_key_opt: Some(x.clone()), target_component: Component::ProxyClient, - minimum_hop_count: 2, return_component_opt: Some(Component::ProxyServer), payload_size, hostname_opt: None, diff --git a/node/src/proxy_server/mod.rs b/node/src/proxy_server/mod.rs index 2e0dd4701..5c605fd4a 100644 --- a/node/src/proxy_server/mod.rs +++ b/node/src/proxy_server/mod.rs @@ -952,11 +952,11 @@ impl IBCDHelperReal { route_source .send(RouteQueryMessage::data_indefinite_route_request( hostname_opt, - if common_args.is_decentralized { - DEFAULT_MINIMUM_HOP_COUNT - } else { - 0 - }, + // if common_args.is_decentralized { + // DEFAULT_MINIMUM_HOP_COUNT + // } else { + // 0 + // }, payload_size, )) .then(move |route_result| { @@ -1292,7 +1292,6 @@ mod tests { record, &RouteQueryMessage::data_indefinite_route_request( Some("nowhere.com".to_string()), - DEFAULT_MINIMUM_HOP_COUNT, 47 ) ); @@ -1416,7 +1415,6 @@ mod tests { neighborhood_record, &RouteQueryMessage::data_indefinite_route_request( Some("realdomain.nu".to_string()), - DEFAULT_MINIMUM_HOP_COUNT, 12 ) ); @@ -1813,7 +1811,6 @@ mod tests { &RouteQueryMessage { target_key_opt: None, target_component: Component::ProxyClient, - minimum_hop_count: 0, return_component_opt: Some(Component::ProxyServer), payload_size: 47, hostname_opt: Some("nowhere.com".to_string()) @@ -1894,7 +1891,6 @@ mod tests { &RouteQueryMessage { target_key_opt: None, target_component: Component::ProxyClient, - minimum_hop_count: 0, return_component_opt: Some(Component::ProxyServer), payload_size: 16, hostname_opt: None @@ -2209,7 +2205,6 @@ mod tests { record, &RouteQueryMessage::data_indefinite_route_request( Some("nowhere.com".to_string()), - 3, 47 ) ); @@ -2725,7 +2720,6 @@ mod tests { record, &RouteQueryMessage::data_indefinite_route_request( Some("nowhere.com".to_string()), - 3, 47 ) ); @@ -2901,7 +2895,6 @@ mod tests { record, &RouteQueryMessage::data_indefinite_route_request( Some("nowhere.com".to_string()), - 3, 47 ) ); diff --git a/node/src/sub_lib/neighborhood.rs b/node/src/sub_lib/neighborhood.rs index 10b4ffd40..faf089e45 100644 --- a/node/src/sub_lib/neighborhood.rs +++ b/node/src/sub_lib/neighborhood.rs @@ -472,7 +472,6 @@ pub struct DispatcherNodeQueryMessage { pub struct RouteQueryMessage { pub target_key_opt: Option, pub target_component: Component, - pub minimum_hop_count: usize, pub return_component_opt: Option, pub payload_size: usize, pub hostname_opt: Option, @@ -483,15 +482,15 @@ impl Message for RouteQueryMessage { } impl RouteQueryMessage { + // Earlier min_hops_count was passed to this function and stored inside RouteQueryMessage + // TODO: Make sure the entities using RouteQueryMessage can easily retieve the min_hops_count from Neighborhood pub fn data_indefinite_route_request( hostname_opt: Option, - minimum_hop_count: usize, payload_size: usize, ) -> RouteQueryMessage { RouteQueryMessage { target_key_opt: None, target_component: Component::ProxyClient, - minimum_hop_count, return_component_opt: Some(Component::ProxyServer), payload_size, hostname_opt, @@ -1039,14 +1038,13 @@ mod tests { #[test] fn data_indefinite_route_request() { - let result = RouteQueryMessage::data_indefinite_route_request(None, 2, 7500); + let result = RouteQueryMessage::data_indefinite_route_request(None, 7500); assert_eq!( result, RouteQueryMessage { target_key_opt: None, target_component: Component::ProxyClient, - minimum_hop_count: 2, return_component_opt: Some(Component::ProxyServer), payload_size: 7500, hostname_opt: None From 9b3e3406242cddf1edcd74368ba4bfffe39ed195 Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Fri, 28 Apr 2023 15:46:52 +0530 Subject: [PATCH 34/56] GH-690: remove unnecessary comments and write todos --- node/src/neighborhood/mod.rs | 15 ++++----------- node/src/proxy_server/mod.rs | 2 ++ node/src/sub_lib/neighborhood.rs | 2 +- 3 files changed, 7 insertions(+), 12 deletions(-) diff --git a/node/src/neighborhood/mod.rs b/node/src/neighborhood/mod.rs index 249e4a06a..a6506ee4b 100644 --- a/node/src/neighborhood/mod.rs +++ b/node/src/neighborhood/mod.rs @@ -1067,7 +1067,6 @@ impl Neighborhood { ); match route_opt { None => { - // panic!("yes, this is the right place"); let target_str = match target_opt { Some(t) => format!(" {}", t), None => String::from("Unknown"), @@ -1235,10 +1234,6 @@ impl Neighborhood { let mut minimum_undesirability = i64::MAX; let initial_undesirability = self.compute_initial_undesirability(source, payload_size as u64, direction); - // Args passed to routing engine: [0xA59FFDC71BDB6B4F4E075C59538CB59A20EE1CC67697DF3939A1EEFBB70C897F] 0 None 2 1000 Over 9223372036854775807 None - // [0xDCDBDC19A160F7272C7A0342E2860430EEA163ECA654091AD85736B591D82EB4] 0 None 3 1000 Over 9223372036854775807 None - // panic!("Args passed to routing engine: {:?} {} {:?} {} {} {:?} {} {:?}", vec![source], initial_undesirability, target_opt, minimum_hops, payload_size, direction, minimum_undesirability, hostname_opt); - eprintln!("Minimum Hops sent to routing engine: {}", minimum_hops); let result = self .routing_engine( vec![source], @@ -1249,13 +1244,9 @@ impl Neighborhood { direction, &mut minimum_undesirability, hostname_opt, - ); - eprintln!("Routing Engine Result: {:?}", result.len()); - - let result = result + ) .into_iter() .filter_map(|cr| { - eprintln!("Route Undesirability: {}, minimum_undesirability: {}", cr.undesirability, minimum_undesirability); match cr.undesirability <= minimum_undesirability { true => Some(cr.nodes), false => None, @@ -2880,6 +2871,7 @@ mod tests { ) { let system = System::new("route_query_responds_with_none_when_asked_for_one_hop_round_trip_route_without_consuming_wallet_when_back_route_needs_two_hops"); let mut subject = make_standard_subject(); + subject.min_hops_count = Hops::OneHop; let a = &make_node_record(1234, true); let b = &subject.neighborhood_database.root().clone(); let c = &make_node_record(3456, true); @@ -2910,7 +2902,8 @@ mod tests { fn route_query_responds_with_none_when_asked_for_two_hop_one_way_route_without_consuming_wallet( ) { let system = System::new("route_query_responds_with_none_when_asked_for_two_hop_one_way_route_without_consuming_wallet"); - let subject = make_standard_subject(); + let mut subject = make_standard_subject(); + subject.min_hops_count = Hops::TwoHops; let addr: Addr = subject.start(); let sub: Recipient = addr.recipient::(); let msg = RouteQueryMessage::data_indefinite_route_request(None, 20000); diff --git a/node/src/proxy_server/mod.rs b/node/src/proxy_server/mod.rs index 5c605fd4a..a64b29810 100644 --- a/node/src/proxy_server/mod.rs +++ b/node/src/proxy_server/mod.rs @@ -952,6 +952,7 @@ impl IBCDHelperReal { route_source .send(RouteQueryMessage::data_indefinite_route_request( hostname_opt, + // TODO: GH-690: This edge case hasn't been take care // if common_args.is_decentralized { // DEFAULT_MINIMUM_HOP_COUNT // } else { @@ -1764,6 +1765,7 @@ mod tests { #[test] fn proxy_server_receives_http_request_with_no_consuming_wallet_in_zero_hop_mode_and_handles_normally( ) { + // TODO: GH-690: Initially this test is intended for a RouteQueryMessage with a min_hop_count = 0, but it is working fine irrespective of that init_test_logging(); let main_cryptde = main_cryptde(); let alias_cryptde = alias_cryptde(); diff --git a/node/src/sub_lib/neighborhood.rs b/node/src/sub_lib/neighborhood.rs index faf089e45..1d46c8c8e 100644 --- a/node/src/sub_lib/neighborhood.rs +++ b/node/src/sub_lib/neighborhood.rs @@ -483,7 +483,7 @@ impl Message for RouteQueryMessage { impl RouteQueryMessage { // Earlier min_hops_count was passed to this function and stored inside RouteQueryMessage - // TODO: Make sure the entities using RouteQueryMessage can easily retieve the min_hops_count from Neighborhood + // TODO: GH-690: Make sure the entities using RouteQueryMessage can easily retieve the min_hops_count from Neighborhood pub fn data_indefinite_route_request( hostname_opt: Option, payload_size: usize, From 2accfee5a1f2fb07a2de6adbdaba42960a341c2a Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Fri, 28 Apr 2023 15:52:16 +0530 Subject: [PATCH 35/56] GH-690: remove warnings; all unit tests for Node/node is passing --- node/src/proxy_server/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/node/src/proxy_server/mod.rs b/node/src/proxy_server/mod.rs index a64b29810..cfd279e9a 100644 --- a/node/src/proxy_server/mod.rs +++ b/node/src/proxy_server/mod.rs @@ -34,7 +34,7 @@ use crate::sub_lib::proxy_client::{ClientResponsePayload_0v1, DnsResolveFailure_ use crate::sub_lib::proxy_server::ClientRequestPayload_0v1; use crate::sub_lib::proxy_server::ProxyServerSubs; use crate::sub_lib::proxy_server::{ - AddReturnRouteMessage, AddRouteMessage, DEFAULT_MINIMUM_HOP_COUNT, + AddReturnRouteMessage, AddRouteMessage, }; use crate::sub_lib::route::Route; use crate::sub_lib::set_consuming_wallet_message::SetConsumingWalletMessage; From 673c6391ed0898e16c7a6546283e69db2f8b7805 Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Mon, 1 May 2023 12:40:30 +0530 Subject: [PATCH 36/56] GH-690: use MIN_HOPS_COUNT_FOR_TEST instead of DEFAULT_MIN_HOPS_COUNT inside tests --- node/src/actor_system_factory.rs | 12 ++--- node/src/bootstrapper.rs | 14 ++--- node/src/neighborhood/gossip_acceptor.rs | 13 ++--- node/src/neighborhood/mod.rs | 53 +++++++++---------- .../node_configurator_standard.rs | 4 +- .../unprivileged_parse_args_configuration.rs | 15 +++--- .../src/test_utils/neighborhood_test_utils.rs | 8 +-- 7 files changed, 58 insertions(+), 61 deletions(-) diff --git a/node/src/actor_system_factory.rs b/node/src/actor_system_factory.rs index 597d018c0..cef49290a 100644 --- a/node/src/actor_system_factory.rs +++ b/node/src/actor_system_factory.rs @@ -612,7 +612,6 @@ mod tests { use crate::actor_system_factory::tests::ShouldWeRunTheTest::{GoAhead, Skip}; use crate::bootstrapper::{Bootstrapper, RealUser}; use crate::database::connection_wrapper::ConnectionWrapper; - use crate::neighborhood::DEFAULT_MIN_HOPS_COUNT; use crate::node_test_utils::{ make_stream_handler_pool_subs_from, make_stream_handler_pool_subs_from_recorder, start_recorder_refcell_opt, @@ -679,6 +678,7 @@ mod tests { use std::sync::{Arc, Mutex}; use std::thread; use std::time::Duration; + use crate::test_utils::neighborhood_test_utils::MIN_HOPS_COUNT_FOR_TEST; struct LogRecipientSetterNull {} @@ -1071,7 +1071,7 @@ mod tests { vec![], rate_pack(100), ), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }, payment_thresholds_opt: Some(PaymentThresholds::default()), when_pending_too_long_sec: DEFAULT_PENDING_TOO_LONG_SEC, @@ -1145,7 +1145,7 @@ mod tests { vec![], rate_pack(100), ), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }, payment_thresholds_opt: Default::default(), when_pending_too_long_sec: DEFAULT_PENDING_TOO_LONG_SEC @@ -1289,7 +1289,7 @@ mod tests { vec![], rate_pack(100), ), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }; let make_params_arc = Arc::new(Mutex::new(vec![])); let mut subject = make_subject_with_null_setter(); @@ -1443,7 +1443,7 @@ mod tests { real_user: RealUser::null(), neighborhood_config: NeighborhoodConfig { mode: NeighborhoodMode::ConsumeOnly(vec![]), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }, payment_thresholds_opt: Default::default(), when_pending_too_long_sec: DEFAULT_PENDING_TOO_LONG_SEC @@ -1632,7 +1632,7 @@ mod tests { vec![], rate_pack(100), ), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }, node_descriptor: Default::default(), payment_thresholds_opt: Default::default(), diff --git a/node/src/bootstrapper.rs b/node/src/bootstrapper.rs index 1d21cd38e..0f2237f66 100644 --- a/node/src/bootstrapper.rs +++ b/node/src/bootstrapper.rs @@ -717,7 +717,6 @@ mod tests { use crate::discriminator::Discriminator; use crate::discriminator::UnmaskedChunk; use crate::listener_handler::{ListenerHandler, ListenerHandlerFactory}; - use crate::neighborhood::DEFAULT_MIN_HOPS_COUNT; use crate::node_test_utils::make_stream_handler_pool_subs_from; use crate::node_test_utils::TestLogOwner; use crate::node_test_utils::{extract_log, DirsWrapperMock, IdWrapperMock}; @@ -771,6 +770,7 @@ mod tests { use tokio::executor::current_thread::CurrentThread; use tokio::prelude::stream::FuturesUnordered; use tokio::prelude::Async; + use crate::test_utils::neighborhood_test_utils::MIN_HOPS_COUNT_FOR_TEST; lazy_static! { pub static ref INITIALIZATION: Mutex = Mutex::new(false); @@ -1223,7 +1223,7 @@ mod tests { let clandestine_port_opt = Some(44444); let neighborhood_config = NeighborhoodConfig { mode: NeighborhoodMode::OriginateOnly(vec![], rate_pack(9)), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }; let earning_wallet = make_wallet("earning wallet"); let consuming_wallet_opt = Some(make_wallet("consuming wallet")); @@ -1824,7 +1824,7 @@ mod tests { ))], rate_pack(100), ), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }; config.data_directory = data_dir.clone(); config.clandestine_port_opt = Some(port); @@ -1894,7 +1894,7 @@ mod tests { ))], rate_pack(100), ), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }; config.data_directory = data_dir.clone(); config.clandestine_port_opt = None; @@ -1943,7 +1943,7 @@ mod tests { ))], rate_pack(100), ), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }; let listener_handler = ListenerHandlerNull::new(vec![]); let mut subject = BootstrapperBuilder::new() @@ -1980,7 +1980,7 @@ mod tests { Chain::EthRopsten, cryptde, ))]), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }; let listener_handler = ListenerHandlerNull::new(vec![]); let mut subject = BootstrapperBuilder::new() @@ -2010,7 +2010,7 @@ mod tests { config.clandestine_port_opt = None; config.neighborhood_config = NeighborhoodConfig { mode: NeighborhoodMode::ZeroHop, - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }; let listener_handler = ListenerHandlerNull::new(vec![]); let mut subject = BootstrapperBuilder::new() diff --git a/node/src/neighborhood/gossip_acceptor.rs b/node/src/neighborhood/gossip_acceptor.rs index 7cfffb84c..d8769f723 100644 --- a/node/src/neighborhood/gossip_acceptor.rs +++ b/node/src/neighborhood/gossip_acceptor.rs @@ -1333,13 +1333,10 @@ mod tests { use crate::neighborhood::gossip_producer::GossipProducer; use crate::neighborhood::gossip_producer::GossipProducerReal; use crate::neighborhood::node_record::NodeRecord; - use crate::neighborhood::DEFAULT_MIN_HOPS_COUNT; use crate::sub_lib::cryptde_null::CryptDENull; use crate::sub_lib::neighborhood::{ConnectionProgressEvent, ConnectionProgressMessage, Hops}; use crate::sub_lib::utils::time_t_timestamp; - use crate::test_utils::neighborhood_test_utils::{ - db_from_node, make_meaningless_db, make_node_record, make_node_record_f, - }; + use crate::test_utils::neighborhood_test_utils::{db_from_node, make_meaningless_db, make_node_record, make_node_record_f, MIN_HOPS_COUNT_FOR_TEST}; use crate::test_utils::unshared_test_utils::make_cpm_recipient; use crate::test_utils::{assert_contains, main_cryptde, vec_to_set}; use actix::System; @@ -1368,7 +1365,7 @@ mod tests { NeighborhoodMetadata { connection_progress_peers: vec![], cpm_recipient: make_cpm_recipient().0, - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, } } @@ -2384,7 +2381,7 @@ mod tests { .build(); let agrs: Vec = gossip.try_into().unwrap(); - let result = subject.compute_patch(&agrs, node_a_db.root(), DEFAULT_MIN_HOPS_COUNT as u8); + let result = subject.compute_patch(&agrs, node_a_db.root(), MIN_HOPS_COUNT_FOR_TEST as u8); let expected_hashset = vec![ node_a.public_key().clone(), @@ -2436,7 +2433,7 @@ mod tests { .build(); let agrs: Vec = gossip.try_into().unwrap(); - let patch = subject.compute_patch(&agrs, node_a_db.root(), DEFAULT_MIN_HOPS_COUNT as u8); + let patch = subject.compute_patch(&agrs, node_a_db.root(), MIN_HOPS_COUNT_FOR_TEST as u8); let expected_hashset = vec![ node_a.public_key().clone(), @@ -2485,7 +2482,7 @@ mod tests { .build(); let agrs: Vec = gossip.try_into().unwrap(); - let patch = subject.compute_patch(&agrs, node_a_db.root(), DEFAULT_MIN_HOPS_COUNT as u8); + let patch = subject.compute_patch(&agrs, node_a_db.root(), MIN_HOPS_COUNT_FOR_TEST as u8); let expected_hashset = vec![ node_a.public_key().clone(), diff --git a/node/src/neighborhood/mod.rs b/node/src/neighborhood/mod.rs index a6506ee4b..fcad32b57 100644 --- a/node/src/neighborhood/mod.rs +++ b/node/src/neighborhood/mod.rs @@ -1638,10 +1638,7 @@ mod tests { use crate::test_utils::assert_contains; use crate::test_utils::make_meaningless_route; use crate::test_utils::make_wallet; - use crate::test_utils::neighborhood_test_utils::{ - db_from_node, make_global_cryptde_node_record, make_ip, make_node, make_node_descriptor, - make_node_record, make_node_record_f, neighborhood_from_nodes, - }; + use crate::test_utils::neighborhood_test_utils::{db_from_node, make_global_cryptde_node_record, make_ip, make_node, make_node_descriptor, make_node_record, make_node_record_f, MIN_HOPS_COUNT_FOR_TEST, neighborhood_from_nodes}; use crate::test_utils::persistent_configuration_mock::PersistentConfigurationMock; use crate::test_utils::rate_pack; use crate::test_utils::recorder::make_recorder; @@ -1723,7 +1720,7 @@ mod tests { "masq://eth-ropsten:AQIDBA@1.2.3.4:1234", )) .unwrap()]), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }, earning_wallet.clone(), None, @@ -1748,7 +1745,7 @@ mod tests { "masq://eth-mainnet:AQIDBA@1.2.3.4:1234", )) .unwrap()]), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }, earning_wallet.clone(), None, @@ -1769,7 +1766,7 @@ mod tests { &bc_from_nc_plus( NeighborhoodConfig { mode: NeighborhoodMode::ZeroHop, - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }, earning_wallet.clone(), None, @@ -1798,7 +1795,7 @@ mod tests { vec![neighbor.node_descriptor(TEST_DEFAULT_CHAIN, cryptde)], DEFAULT_RATE_PACK.clone(), ), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }, earning_wallet.clone(), None, @@ -1837,7 +1834,7 @@ mod tests { &bc_from_nc_plus( NeighborhoodConfig { mode: NeighborhoodMode::ZeroHop, - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }, earning_wallet.clone(), consuming_wallet.clone(), @@ -1886,7 +1883,7 @@ mod tests { ], rate_pack(100), ), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }, earning_wallet.clone(), consuming_wallet.clone(), @@ -1966,7 +1963,7 @@ mod tests { initial_node_descriptors, rate_pack(100), ), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }; let bootstrap_config = bc_from_nc_plus(neighborhood_config, make_wallet("earning"), None, "test"); @@ -2435,7 +2432,7 @@ mod tests { initial_node_descriptors, rate_pack(100), ), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }; let mut subject = Neighborhood::new( main_cryptde(), @@ -2512,7 +2509,7 @@ mod tests { ], rate_pack(100), ), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }, earning_wallet.clone(), None, @@ -2584,7 +2581,7 @@ mod tests { ))], rate_pack(100), ), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }, earning_wallet.clone(), consuming_wallet.clone(), @@ -2620,7 +2617,7 @@ mod tests { vec![node_record_to_neighbor_config(&one_neighbor)], rate_pack(100), ), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }, earning_wallet.clone(), consuming_wallet.clone(), @@ -2673,7 +2670,7 @@ mod tests { ))], rate_pack(100), ), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }, earning_wallet.clone(), consuming_wallet.clone(), @@ -2714,7 +2711,7 @@ mod tests { ))], rate_pack(100), ), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }, node_record.earning_wallet(), None, @@ -3594,7 +3591,7 @@ mod tests { vec![], rate_pack(100), ), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }, earning_wallet.clone(), consuming_wallet.clone(), @@ -3993,7 +3990,7 @@ mod tests { initial_node_descriptors, rate_pack(100), ), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }; let bootstrap_config = bc_from_nc_plus(neighborhood_config, make_wallet("earning"), None, "test"); @@ -4715,7 +4712,7 @@ mod tests { vec![], rate_pack(100), ), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }, this_node_inside.earning_wallet(), None, @@ -4778,7 +4775,7 @@ mod tests { vec![debut_target.clone()], rate_pack(100), ), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }, NodeRecord::earning_wallet_from_key(&cryptde.public_key()), NodeRecord::consuming_wallet_from_key(&cryptde.public_key()), @@ -4969,7 +4966,7 @@ mod tests { ))], rate_pack(100), ), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }, earning_wallet.clone(), consuming_wallet.clone(), @@ -5031,7 +5028,7 @@ mod tests { vec![node_record_to_neighbor_config(&one_neighbor)], rate_pack(100), ), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }, earning_wallet.clone(), consuming_wallet.clone(), @@ -5098,7 +5095,7 @@ mod tests { ))], rate_pack(100), ), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }, earning_wallet.clone(), consuming_wallet.clone(), @@ -5162,7 +5159,7 @@ mod tests { ))], rate_pack(100), ), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }, node_record.earning_wallet(), None, @@ -5694,7 +5691,7 @@ mod tests { &bc_from_nc_plus( NeighborhoodConfig { mode: NeighborhoodMode::ZeroHop, - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }, make_wallet("earning"), None, @@ -6044,7 +6041,7 @@ mod tests { initial_node_descriptors, rate_pack(100), ), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }; let bootstrap_config = bc_from_nc_plus(neighborhood_config, make_wallet("earning"), None, test_name); @@ -6068,7 +6065,7 @@ mod tests { &bc_from_nc_plus( NeighborhoodConfig { mode: NeighborhoodMode::ConsumeOnly(vec![make_node_descriptor(make_ip(1))]), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }, make_wallet("earning"), None, diff --git a/node/src/node_configurator/node_configurator_standard.rs b/node/src/node_configurator/node_configurator_standard.rs index 1fb15d546..0a6503e8b 100644 --- a/node/src/node_configurator/node_configurator_standard.rs +++ b/node/src/node_configurator/node_configurator_standard.rs @@ -280,7 +280,6 @@ mod tests { use crate::db_config::config_dao::ConfigDaoReal; use crate::db_config::persistent_configuration::PersistentConfigError; use crate::db_config::persistent_configuration::PersistentConfigurationReal; - use crate::neighborhood::DEFAULT_MIN_HOPS_COUNT; use crate::node_configurator::unprivileged_parse_args_configuration::UnprivilegedParseArgsConfigurationDaoNull; use crate::node_test_utils::DirsWrapperMock; use crate::sub_lib::cryptde::CryptDE; @@ -305,6 +304,7 @@ mod tests { use std::path::PathBuf; use std::sync::{Arc, Mutex}; use std::vec; + use crate::test_utils::neighborhood_test_utils::MIN_HOPS_COUNT_FOR_TEST; #[test] fn node_configurator_standard_unprivileged_uses_parse_args_configurator_dao_real() { @@ -576,7 +576,7 @@ mod tests { config.neighborhood_config, NeighborhoodConfig { mode: NeighborhoodMode::ZeroHop, // not populated on the privileged side - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, } ); assert_eq!( diff --git a/node/src/node_configurator/unprivileged_parse_args_configuration.rs b/node/src/node_configurator/unprivileged_parse_args_configuration.rs index 5a2f7c9ec..ce4505408 100644 --- a/node/src/node_configurator/unprivileged_parse_args_configuration.rs +++ b/node/src/node_configurator/unprivileged_parse_args_configuration.rs @@ -654,6 +654,7 @@ mod tests { use std::str::FromStr; use std::sync::{Arc, Mutex}; use std::time::Duration; + use crate::test_utils::neighborhood_test_utils::MIN_HOPS_COUNT_FOR_TEST; #[test] fn convert_ci_configs_handles_blockchain_mismatch() { @@ -805,7 +806,7 @@ mod tests { let node_addr = match result { Ok(NeighborhoodConfig { mode: NeighborhoodMode::Standard(node_addr, _, _), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }) => node_addr, x => panic!("Wasn't expecting {:?}", x), }; @@ -863,7 +864,7 @@ mod tests { ], DEFAULT_RATE_PACK ), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }) ); } @@ -939,7 +940,7 @@ mod tests { )) .unwrap() ],), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }) ); } @@ -1003,7 +1004,7 @@ mod tests { result, Ok(NeighborhoodConfig { mode: NeighborhoodMode::ZeroHop, - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }) ); } @@ -1334,7 +1335,7 @@ mod tests { config.neighborhood_config, NeighborhoodConfig { mode: NeighborhoodMode::ZeroHop, - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, } ); let set_past_neighbors_params = set_past_neighbors_params_arc.lock().unwrap(); @@ -1381,7 +1382,7 @@ mod tests { config.neighborhood_config, NeighborhoodConfig { mode: NeighborhoodMode::ZeroHop, - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, } ); let set_past_neighbors_params = set_past_neighbors_params_arc.lock().unwrap(); @@ -1563,7 +1564,7 @@ mod tests { ], DEFAULT_RATE_PACK.clone() ), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, } ); assert_eq!(config.db_password_opt, Some(password.to_string())); diff --git a/node/src/test_utils/neighborhood_test_utils.rs b/node/src/test_utils/neighborhood_test_utils.rs index a230edcd7..3752a1bf7 100644 --- a/node/src/test_utils/neighborhood_test_utils.rs +++ b/node/src/test_utils/neighborhood_test_utils.rs @@ -7,7 +7,7 @@ use crate::neighborhood::{AccessibleGossipRecord, Neighborhood, DEFAULT_MIN_HOPS use crate::sub_lib::cryptde::PublicKey; use crate::sub_lib::cryptde::{CryptDE, PlainData}; use crate::sub_lib::cryptde_null::CryptDENull; -use crate::sub_lib::neighborhood::{NeighborhoodConfig, NeighborhoodMode, NodeDescriptor}; +use crate::sub_lib::neighborhood::{Hops, NeighborhoodConfig, NeighborhoodMode, NodeDescriptor}; use crate::sub_lib::node_addr::NodeAddr; use crate::sub_lib::wallet::Wallet; use crate::test_utils::*; @@ -18,6 +18,8 @@ use std::convert::TryFrom; use std::net::IpAddr; use std::net::Ipv4Addr; +pub const MIN_HOPS_COUNT_FOR_TEST: Hops = DEFAULT_MIN_HOPS_COUNT; + impl From<(&NeighborhoodDatabase, &PublicKey, bool)> for AccessibleGossipRecord { fn from( (database, public_key, reveal_node_addr): (&NeighborhoodDatabase, &PublicKey, bool), @@ -95,11 +97,11 @@ pub fn neighborhood_from_nodes( vec![NodeDescriptor::from((neighbor, Chain::EthRopsten, cryptde))], *root.rate_pack(), ), - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }, None => NeighborhoodConfig { mode: NeighborhoodMode::ZeroHop, - min_hops_count: DEFAULT_MIN_HOPS_COUNT, + min_hops_count: MIN_HOPS_COUNT_FOR_TEST, }, }; config.earning_wallet = root.earning_wallet(); From 433eee732826886a7a841c62ec1bc969ffff0c03 Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Mon, 1 May 2023 13:20:33 +0530 Subject: [PATCH 37/56] GH-690: the multinode test for data routing test for different min hops count is passing --- .../src/masq_node_client.rs | 2 +- .../tests/data_routing_test.rs | 16 +++++++++------- 2 files changed, 10 insertions(+), 8 deletions(-) diff --git a/multinode_integration_tests/src/masq_node_client.rs b/multinode_integration_tests/src/masq_node_client.rs index 44445dd84..23e5aa006 100644 --- a/multinode_integration_tests/src/masq_node_client.rs +++ b/multinode_integration_tests/src/masq_node_client.rs @@ -15,7 +15,7 @@ impl MASQNodeClient { let stream = TcpStream::connect(&socket_addr) .unwrap_or_else(|_| panic!("Connecting to {}", socket_addr)); stream - .set_read_timeout(Some(Duration::from_millis(250))) + .set_read_timeout(Some(Duration::from_millis(500))) .expect("Setting read timeout to 250ms"); MASQNodeClient { diff --git a/multinode_integration_tests/tests/data_routing_test.rs b/multinode_integration_tests/tests/data_routing_test.rs index b2e3a9d66..538e1449a 100644 --- a/multinode_integration_tests/tests/data_routing_test.rs +++ b/multinode_integration_tests/tests/data_routing_test.rs @@ -101,7 +101,8 @@ fn assert_http_end_to_end_routing_test(min_hops_count: Hops) { .build(), ); - thread::sleep(Duration::from_millis(500)); + // thread::sleep(Duration::from_millis(500)); + thread::sleep(Duration::from_millis(1000)); let mut client = first_node.make_client(8080); client.send_chunk(b"GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n"); @@ -117,12 +118,13 @@ fn assert_http_end_to_end_routing_test(min_hops_count: Hops) { #[test] fn http_end_to_end_routing_test_with_different_min_hops_count() { - assert_http_end_to_end_routing_test(Hops::OneHop); - // assert_http_end_to_end_routing_test(Hops::TwoHops); - // assert_http_end_to_end_routing_test(Hops::ThreeHops); - // assert_http_end_to_end_routing_test(Hops::FourHops); - // assert_http_end_to_end_routing_test(Hops::FiveHops); - // assert_http_end_to_end_routing_test(Hops::SixHops); + // TODO: This test fails sometimes due to a timeout: Couldn't read chunk: Kind(TimedOut) + assert_http_end_to_end_routing_test(Hops::OneHop); // Working fine + assert_http_end_to_end_routing_test(Hops::TwoHops); // Working fine + assert_http_end_to_end_routing_test(Hops::ThreeHops); // Working fine + assert_http_end_to_end_routing_test(Hops::FourHops); // Working fine + assert_http_end_to_end_routing_test(Hops::FiveHops); // Working fine + assert_http_end_to_end_routing_test(Hops::SixHops); // Working fine } #[test] From b07c9ccbb2313c788f40231566d9f73b1a594536 Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Mon, 1 May 2023 13:57:19 +0530 Subject: [PATCH 38/56] GH-690: optimize the data routing test for different min_hops_count --- .../src/masq_node_client.rs | 4 ++-- .../tests/data_routing_test.rs | 21 +++++-------------- 2 files changed, 7 insertions(+), 18 deletions(-) diff --git a/multinode_integration_tests/src/masq_node_client.rs b/multinode_integration_tests/src/masq_node_client.rs index 23e5aa006..1817a1a3a 100644 --- a/multinode_integration_tests/src/masq_node_client.rs +++ b/multinode_integration_tests/src/masq_node_client.rs @@ -15,12 +15,12 @@ impl MASQNodeClient { let stream = TcpStream::connect(&socket_addr) .unwrap_or_else(|_| panic!("Connecting to {}", socket_addr)); stream - .set_read_timeout(Some(Duration::from_millis(500))) + .set_read_timeout(Some(Duration::from_millis(250))) .expect("Setting read timeout to 250ms"); MASQNodeClient { stream, - timeout: Duration::from_secs(1), + timeout: Duration::from_secs(2), } } diff --git a/multinode_integration_tests/tests/data_routing_test.rs b/multinode_integration_tests/tests/data_routing_test.rs index 538e1449a..7ce23971c 100644 --- a/multinode_integration_tests/tests/data_routing_test.rs +++ b/multinode_integration_tests/tests/data_routing_test.rs @@ -79,8 +79,8 @@ fn assert_http_end_to_end_routing_test(min_hops_count: Hops) { .build(); let first_node = cluster.start_real_node(config); - let middle_nodes_count = 2 * (min_hops_count as usize); - let nodes = (0..middle_nodes_count) + let nodes_count = 2 * (min_hops_count as usize) + 1; + let nodes = (0..nodes_count) .map(|_| { cluster.start_real_node( NodeStartupConfigBuilder::standard() @@ -93,17 +93,6 @@ fn assert_http_end_to_end_routing_test(min_hops_count: Hops) { thread::sleep(Duration::from_millis(500 * (nodes.len() as u64))); - let last_node = cluster.start_real_node( - NodeStartupConfigBuilder::standard() - .neighbor(nodes.last().unwrap().node_reference()) - .consuming_wallet_info(make_consuming_wallet_info("last_node")) - .chain(cluster.chain) - .build(), - ); - - // thread::sleep(Duration::from_millis(500)); - thread::sleep(Duration::from_millis(1000)); - let mut client = first_node.make_client(8080); client.send_chunk(b"GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n"); let response = client.wait_for_chunk(); @@ -121,9 +110,9 @@ fn http_end_to_end_routing_test_with_different_min_hops_count() { // TODO: This test fails sometimes due to a timeout: Couldn't read chunk: Kind(TimedOut) assert_http_end_to_end_routing_test(Hops::OneHop); // Working fine assert_http_end_to_end_routing_test(Hops::TwoHops); // Working fine - assert_http_end_to_end_routing_test(Hops::ThreeHops); // Working fine - assert_http_end_to_end_routing_test(Hops::FourHops); // Working fine - assert_http_end_to_end_routing_test(Hops::FiveHops); // Working fine + // assert_http_end_to_end_routing_test(Hops::ThreeHops); // Working fine + // assert_http_end_to_end_routing_test(Hops::FourHops); // Working fine + // assert_http_end_to_end_routing_test(Hops::FiveHops); // Working fine assert_http_end_to_end_routing_test(Hops::SixHops); // Working fine } From 8764839aad03b70fab19d7c380bbf44ef8d8bce7 Mon Sep 17 00:00:00 2001 From: Utkarsh Gupta Date: Mon, 1 May 2023 16:33:44 +0530 Subject: [PATCH 39/56] GH-690: use higher timeout for the client inisde the data routing test for different min hops count --- .../src/masq_cores_client.rs | 2 +- .../src/masq_node_client.rs | 4 ++-- .../src/masq_real_node.rs | 5 +++-- .../tests/data_routing_test.rs | 19 ++++++++----------- 4 files changed, 14 insertions(+), 16 deletions(-) diff --git a/multinode_integration_tests/src/masq_cores_client.rs b/multinode_integration_tests/src/masq_cores_client.rs index 2722b9e24..0c89953cf 100644 --- a/multinode_integration_tests/src/masq_cores_client.rs +++ b/multinode_integration_tests/src/masq_cores_client.rs @@ -18,7 +18,7 @@ impl<'a> MASQCoresClient<'a> { pub fn new(socket_addr: SocketAddr, cryptde: &'a dyn CryptDE) -> MASQCoresClient<'a> { MASQCoresClient { cryptde, - delegate: MASQNodeClient::new(socket_addr), + delegate: MASQNodeClient::new(socket_addr, 1000), } } diff --git a/multinode_integration_tests/src/masq_node_client.rs b/multinode_integration_tests/src/masq_node_client.rs index 1817a1a3a..6df65b68a 100644 --- a/multinode_integration_tests/src/masq_node_client.rs +++ b/multinode_integration_tests/src/masq_node_client.rs @@ -11,7 +11,7 @@ pub struct MASQNodeClient { } impl MASQNodeClient { - pub fn new(socket_addr: SocketAddr) -> MASQNodeClient { + pub fn new(socket_addr: SocketAddr, timeout_millis: u64) -> MASQNodeClient { let stream = TcpStream::connect(&socket_addr) .unwrap_or_else(|_| panic!("Connecting to {}", socket_addr)); stream @@ -20,7 +20,7 @@ impl MASQNodeClient { MASQNodeClient { stream, - timeout: Duration::from_secs(2), + timeout: Duration::from_millis(timeout_millis), } } diff --git a/multinode_integration_tests/src/masq_real_node.rs b/multinode_integration_tests/src/masq_real_node.rs index aa3ad7b23..2c02909fe 100644 --- a/multinode_integration_tests/src/masq_real_node.rs +++ b/multinode_integration_tests/src/masq_real_node.rs @@ -37,6 +37,7 @@ use std::time::Duration; use node_lib::neighborhood::DEFAULT_MIN_HOPS_COUNT; pub const DATA_DIRECTORY: &str = "/node_root/home"; +pub const STANDARD_CLIENT_TIMEOUT_MILLIS: u64 = 1000; #[derive(Clone, Debug, PartialEq, Eq)] pub struct Firewall { @@ -940,9 +941,9 @@ impl MASQRealNode { } } - pub fn make_client(&self, port: u16) -> MASQNodeClient { + pub fn make_client(&self, port: u16, timeout_millis: u64) -> MASQNodeClient { let socket_addr = SocketAddr::new(self.ip_address(), port); - MASQNodeClient::new(socket_addr) + MASQNodeClient::new(socket_addr, timeout_millis) } pub fn make_server(&self, port: u16) -> MASQNodeServer { diff --git a/multinode_integration_tests/tests/data_routing_test.rs b/multinode_integration_tests/tests/data_routing_test.rs index 7ce23971c..3b8fe8f06 100644 --- a/multinode_integration_tests/tests/data_routing_test.rs +++ b/multinode_integration_tests/tests/data_routing_test.rs @@ -4,10 +4,7 @@ use itertools::Itertools; use masq_lib::utils::index_of; use multinode_integration_tests_lib::masq_node::MASQNode; use multinode_integration_tests_lib::masq_node_cluster::MASQNodeCluster; -use multinode_integration_tests_lib::masq_real_node::{ - default_consuming_wallet_info, make_consuming_wallet_info, MASQRealNode, - NodeStartupConfigBuilder, -}; +use multinode_integration_tests_lib::masq_real_node::{default_consuming_wallet_info, make_consuming_wallet_info, MASQRealNode, NodeStartupConfigBuilder, STANDARD_CLIENT_TIMEOUT_MILLIS}; use native_tls::HandshakeError; use native_tls::TlsConnector; use native_tls::TlsStream; @@ -58,7 +55,7 @@ fn http_end_to_end_routing_test() { thread::sleep(Duration::from_millis(500)); - let mut client = last_node.make_client(8080); + let mut client = last_node.make_client(8080, STANDARD_CLIENT_TIMEOUT_MILLIS); client.send_chunk(b"GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n"); let response = client.wait_for_chunk(); @@ -93,7 +90,7 @@ fn assert_http_end_to_end_routing_test(min_hops_count: Hops) { thread::sleep(Duration::from_millis(500 * (nodes.len() as u64))); - let mut client = first_node.make_client(8080); + let mut client = first_node.make_client(8080, 5000); client.send_chunk(b"GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n"); let response = client.wait_for_chunk(); @@ -150,7 +147,7 @@ fn http_end_to_end_routing_test_with_consume_and_originate_only_nodes() { thread::sleep(Duration::from_millis(1000)); - let mut client = originating_node.make_client(8080); + let mut client = originating_node.make_client(8080, STANDARD_CLIENT_TIMEOUT_MILLIS); client.send_chunk(b"GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n"); let response = client.wait_for_chunk(); @@ -280,7 +277,7 @@ fn http_routing_failure_produces_internal_error_response() { ); thread::sleep(Duration::from_millis(1000)); - let mut client = originating_node.make_client(8080); + let mut client = originating_node.make_client(8080, STANDARD_CLIENT_TIMEOUT_MILLIS); client.send_chunk(b"GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n"); let response = client.wait_for_chunk(); @@ -312,7 +309,7 @@ fn tls_routing_failure_produces_internal_error_response() { .chain(cluster.chain) .build(), ); - let mut client = originating_node.make_client(8443); + let mut client = originating_node.make_client(8443, STANDARD_CLIENT_TIMEOUT_MILLIS); let client_hello = vec![ 0x16, // content_type: Handshake 0x03, 0x03, // TLS 1.2 @@ -359,8 +356,8 @@ fn multiple_stream_zero_hop_test() { .chain(cluster.chain) .build(), ); - let mut one_client = zero_hop_node.make_client(8080); - let mut another_client = zero_hop_node.make_client(8080); + let mut one_client = zero_hop_node.make_client(8080, STANDARD_CLIENT_TIMEOUT_MILLIS); + let mut another_client = zero_hop_node.make_client(8080, STANDARD_CLIENT_TIMEOUT_MILLIS); one_client.send_chunk(b"GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n"); another_client.send_chunk(b"GET /online/ HTTP/1.1\r\nHost: whatever.neverssl.com\r\n\r\n"); From a4a664a8d193e21a4418c5f9bf1823de74961135 Mon Sep 17 00:00:00 2001 From: utkarshg6 Date: Tue, 2 May 2023 14:52:42 +0530 Subject: [PATCH 40/56] GH-690: improve the help message for the --min-hops count --- masq_lib/src/shared_schema.rs | 39 ++++++++++++++++++++++++++++++----- masq_lib/src/utils.rs | 2 -- 2 files changed, 34 insertions(+), 7 deletions(-) diff --git a/masq_lib/src/shared_schema.rs b/masq_lib/src/shared_schema.rs index 7a5aa5091..ad3bbeddb 100644 --- a/masq_lib/src/shared_schema.rs +++ b/masq_lib/src/shared_schema.rs @@ -105,7 +105,22 @@ pub const MAPPING_PROTOCOL_HELP: &str = public IP address with the --ip parameter. If the Node communicates successfully with your router, \ it will remember the protocol it used, and on its next run it will try that protocol first, unless \ you specify a different protocol on the command line."; -pub const MIN_HOPS_HELP: &str = "Enter the count as an argument. 3-hops is required for anonymity."; // TODO: rewrite this +pub const MIN_HOPS_HELP: &str = + "The Node is a system that routes data through multiple Nodes to enhance security and privacy. \ + However, the level of anonymity and security provided depends on the number of hops specified \ + by the user. By default, the system allows the user to customize the number of hops within a \ + range of 1 to 6.\n\n\ + It's important to note that if the user selects less than 3 hops, the anonymity of their data \ + cannot be guaranteed. Here's a breakdown of the different hop counts and their implications:\n\n\ + 1. A 1-hop route allows Exit Nodes to see your requests.\n\ + 2. A 2-hop route makes it harder to associate your requests with your IP address, but it's \ + not a foolproof guarantee.\n\ + 3. The minimum number of hops required to guarantee anonymity is 3.\n\ + 4. Increasing the number of hops to 4, 5, or 6 can enhance security, but it will also \ + increase the cost and latency of the route.\n\ + If you want to specify a minimum hops count, you can do so by entering a number after the \ + '--min-hops' command. For example, '--min-hops 4' would require at least 4 hops. If you fail \ + to provide this argument, the system will default to a minimum hops count of 3."; pub const REAL_USER_HELP: &str = "The user whose identity Node will assume when dropping privileges after bootstrapping. Since Node refuses to \ run with root privilege after bootstrapping, you might want to use this if you start the Node as root, or if \ @@ -724,10 +739,6 @@ mod tests { generates a lot of log traffic. This will both consume your disk space and degrade your Node's performance. \ You should probably not specify a level higher than the default unless you have security concerns about \ persistent logs being kept on your computer: if your Node crashes, it's good to know why."); - assert_eq!( - MIN_HOPS_HELP, - "Enter the count as an argument. 3-hops is required for anonymity." - ); assert_eq!( NEIGHBORS_HELP, "One or more Node descriptors for running Nodes in the MASQ \ @@ -779,6 +790,24 @@ mod tests { it will remember the protocol it used, and on its next run it will try that protocol first, unless \ you specify a different protocol on the command line." ); + assert_eq!( + MIN_HOPS_HELP, + "The Node is a system that routes data through multiple Nodes to enhance security and privacy. \ + However, the level of anonymity and security provided depends on the number of hops specified \ + by the user. By default, the system allows the user to customize the number of hops within a \ + range of 1 to 6.\n\n\ + It's important to note that if the user selects less than 3 hops, the anonymity of their data \ + cannot be guaranteed. Here's a breakdown of the different hop counts and their implications:\n\n\ + 1. A 1-hop route allows Exit Nodes to see your requests.\n\ + 2. A 2-hop route makes it harder to associate your requests with your IP address, but it's \ + not a foolproof guarantee.\n\ + 3. The minimum number of hops required to guarantee anonymity is 3.\n\ + 4. Increasing the number of hops to 4, 5, or 6 can enhance security, but it will also \ + increase the cost and latency of the route.\n\ + If you want to specify a minimum hops count, you can do so by entering a number after the \ + '--min-hops' command. For example, '--min-hops 4' would require at least 4 hops. If you fail \ + to provide this argument, the system will default to a minimum hops count of 3." + ); assert_eq!( REAL_USER_HELP, "The user whose identity Node will assume when dropping privileges after bootstrapping. Since Node refuses to \ diff --git a/masq_lib/src/utils.rs b/masq_lib/src/utils.rs index 3556a720e..5196086c5 100644 --- a/masq_lib/src/utils.rs +++ b/masq_lib/src/utils.rs @@ -220,8 +220,6 @@ impl FromStr for NeighborhoodModeLight { } } - - pub fn plus(mut source: Vec, item: T) -> Vec { let mut result = vec![]; result.append(&mut source); From ce1b9a696f9b654544a3228d92e5dbeda8f5b752 Mon Sep 17 00:00:00 2001 From: utkarshg6 Date: Tue, 2 May 2023 15:25:42 +0530 Subject: [PATCH 41/56] GH-690: remove the working fine text and improve the comment --- .../tests/data_routing_test.rs | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/multinode_integration_tests/tests/data_routing_test.rs b/multinode_integration_tests/tests/data_routing_test.rs index 3b8fe8f06..9b0e5a979 100644 --- a/multinode_integration_tests/tests/data_routing_test.rs +++ b/multinode_integration_tests/tests/data_routing_test.rs @@ -4,19 +4,22 @@ use itertools::Itertools; use masq_lib::utils::index_of; use multinode_integration_tests_lib::masq_node::MASQNode; use multinode_integration_tests_lib::masq_node_cluster::MASQNodeCluster; -use multinode_integration_tests_lib::masq_real_node::{default_consuming_wallet_info, make_consuming_wallet_info, MASQRealNode, NodeStartupConfigBuilder, STANDARD_CLIENT_TIMEOUT_MILLIS}; +use multinode_integration_tests_lib::masq_real_node::{ + default_consuming_wallet_info, make_consuming_wallet_info, MASQRealNode, + NodeStartupConfigBuilder, STANDARD_CLIENT_TIMEOUT_MILLIS, +}; use native_tls::HandshakeError; use native_tls::TlsConnector; use native_tls::TlsStream; use node_lib::proxy_server::protocol_pack::ServerImpersonator; use node_lib::proxy_server::server_impersonator_http::ServerImpersonatorHttp; +use node_lib::sub_lib::neighborhood::Hops; use node_lib::test_utils::{handle_connection_error, read_until_timeout}; use std::io::Write; use std::net::{IpAddr, SocketAddr, TcpStream}; use std::str::FromStr; use std::thread; use std::time::Duration; -use node_lib::sub_lib::neighborhood::Hops; #[test] fn http_end_to_end_routing_test() { @@ -104,13 +107,11 @@ fn assert_http_end_to_end_routing_test(min_hops_count: Hops) { #[test] fn http_end_to_end_routing_test_with_different_min_hops_count() { - // TODO: This test fails sometimes due to a timeout: Couldn't read chunk: Kind(TimedOut) - assert_http_end_to_end_routing_test(Hops::OneHop); // Working fine - assert_http_end_to_end_routing_test(Hops::TwoHops); // Working fine - // assert_http_end_to_end_routing_test(Hops::ThreeHops); // Working fine - // assert_http_end_to_end_routing_test(Hops::FourHops); // Working fine - // assert_http_end_to_end_routing_test(Hops::FiveHops); // Working fine - assert_http_end_to_end_routing_test(Hops::SixHops); // Working fine + // This test fails sometimes due to a timeout: "Couldn't read chunk: Kind(TimedOut)" + // You may fix it by increasing the timeout for the client. + assert_http_end_to_end_routing_test(Hops::OneHop); + assert_http_end_to_end_routing_test(Hops::TwoHops); + assert_http_end_to_end_routing_test(Hops::SixHops); } #[test] From 7317131b90730f14a92801050a232f3aecbe8f6c Mon Sep 17 00:00:00 2001 From: utkarshg6 Date: Tue, 2 May 2023 17:06:55 +0530 Subject: [PATCH 42/56] GH-690: refactor out functions from assert_compute_patch --- node/src/neighborhood/gossip_acceptor.rs | 48 +++++++------------ .../src/test_utils/neighborhood_test_utils.rs | 40 +++++++++++++++- 2 files changed, 55 insertions(+), 33 deletions(-) diff --git a/node/src/neighborhood/gossip_acceptor.rs b/node/src/neighborhood/gossip_acceptor.rs index d8769f723..311d0d620 100644 --- a/node/src/neighborhood/gossip_acceptor.rs +++ b/node/src/neighborhood/gossip_acceptor.rs @@ -1336,7 +1336,11 @@ mod tests { use crate::sub_lib::cryptde_null::CryptDENull; use crate::sub_lib::neighborhood::{ConnectionProgressEvent, ConnectionProgressMessage, Hops}; use crate::sub_lib::utils::time_t_timestamp; - use crate::test_utils::neighborhood_test_utils::{db_from_node, make_meaningless_db, make_node_record, make_node_record_f, MIN_HOPS_COUNT_FOR_TEST}; + use crate::test_utils::neighborhood_test_utils::{ + db_from_node, gossip_about_nodes_from_database, linearly_connect_nodes, + make_meaningless_db, make_node_record, make_node_record_f, make_node_records, + public_keys_from_node_records, MIN_HOPS_COUNT_FOR_TEST, + }; use crate::test_utils::unshared_test_utils::make_cpm_recipient; use crate::test_utils::{assert_contains, main_cryptde, vec_to_set}; use actix::System; @@ -2566,40 +2570,20 @@ mod tests { fn assert_compute_patch(min_hops_count: Hops) { let subject = StandardGossipHandler::new(Logger::new("assert_compute_patch")); - // Create Nodes - let nodes_count = min_hops_count as usize + 2; // one to finish hops and one extra node - let mut nodes = Vec::with_capacity(nodes_count as usize); - for i in 1..=nodes_count { - let nonce = 1000 + i; - let has_ip = if i <= 2 { true } else { false }; - nodes.push(make_node_record(nonce as u16, has_ip)) - } - // Create Database - let root_node = &nodes[0]; - let mut root_node_db = db_from_node(root_node); - for i in 1..nodes_count { - root_node_db.add_node(nodes[i].clone()).unwrap(); - root_node_db - .add_arbitrary_full_neighbor(nodes[i - 1].public_key(), nodes[i].public_key()); - } - // Create Gossip - let mut gossip_builder = GossipBuilder::new(&root_node_db); - for i in 1..nodes_count { - gossip_builder = gossip_builder.node(nodes[i].public_key(), false); - } - let gossip = gossip_builder.build(); + // one node to finish hops and another node that's outside the patch + let nodes_count = min_hops_count as usize + 2; + let nodes = make_node_records(nodes_count as u16); + let db = linearly_connect_nodes(&nodes); + // gossip is intended for the first node (also root), thereby it's excluded + let gossip = gossip_about_nodes_from_database(&db, &nodes[1..]); let agrs: Vec = gossip.try_into().unwrap(); - let result = subject.compute_patch(&agrs, root_node_db.root(), min_hops_count as u8); - - let mut expected_nodes = nodes; - expected_nodes.pop(); - let expected_hashet = expected_nodes - .iter() - .map(|node| node.public_key().clone()) - .collect::>(); + let result = subject.compute_patch(&agrs, db.root(), min_hops_count as u8); - assert_eq!(result, expected_hashet); + // last node is excluded because it is outside the patch + let expected_nodes = &nodes[0..nodes_count - 1]; + let expected_patch = public_keys_from_node_records(&expected_nodes); + assert_eq!(result, expected_patch); } #[test] diff --git a/node/src/test_utils/neighborhood_test_utils.rs b/node/src/test_utils/neighborhood_test_utils.rs index 3752a1bf7..7e14f7823 100644 --- a/node/src/test_utils/neighborhood_test_utils.rs +++ b/node/src/test_utils/neighborhood_test_utils.rs @@ -1,6 +1,6 @@ // Copyright (c) 2019, MASQ (https://masq.ai) and/or its affiliates. All rights reserved. use crate::bootstrapper::BootstrapperConfig; -use crate::neighborhood::gossip::GossipNodeRecord; +use crate::neighborhood::gossip::{GossipBuilder, GossipNodeRecord, Gossip_0v1}; use crate::neighborhood::neighborhood_database::NeighborhoodDatabase; use crate::neighborhood::node_record::{NodeRecord, NodeRecordInner_0v1}; use crate::neighborhood::{AccessibleGossipRecord, Neighborhood, DEFAULT_MIN_HOPS_COUNT}; @@ -297,3 +297,41 @@ pub fn make_node(nonce: u8) -> (IpAddr, NodeDescriptor) { (ip_addr, node_descriptor) } + +pub fn make_node_records(count: u16) -> Vec { + (1..=count) + .into_iter() + .map(|i| make_node_record(i, true)) + .collect::>() +} + +pub fn linearly_connect_nodes(nodes: &[NodeRecord]) -> NeighborhoodDatabase { + let root_node = nodes.first().unwrap(); + let mut database = db_from_node(root_node); + let nodes_count = nodes.len(); + for i in 1..nodes_count { + database.add_node(nodes[i].clone()).unwrap(); + database.add_arbitrary_full_neighbor(nodes[i - 1].public_key(), nodes[i].public_key()); + } + + database +} + +pub fn gossip_about_nodes_from_database( + database: &NeighborhoodDatabase, + nodes: &[NodeRecord], +) -> Gossip_0v1 { + nodes + .iter() + .fold(GossipBuilder::new(&database), |builder, node| { + builder.node(node.public_key(), false) + }) + .build() +} + +pub fn public_keys_from_node_records(nodes: &[NodeRecord]) -> HashSet { + nodes + .iter() + .map(|node| node.public_key().clone()) + .collect::>() +} From 35eb8e517a96e0647a72e7e4fbbb8d22720321d2 Mon Sep 17 00:00:00 2001 From: utkarshg6 Date: Wed, 3 May 2023 12:56:11 +0530 Subject: [PATCH 43/56] GH-690: refactor assert_route_query_message() --- node/src/neighborhood/mod.rs | 113 +++++++----------- .../src/test_utils/neighborhood_test_utils.rs | 7 ++ 2 files changed, 47 insertions(+), 73 deletions(-) diff --git a/node/src/neighborhood/mod.rs b/node/src/neighborhood/mod.rs index fcad32b57..cfeee1877 100644 --- a/node/src/neighborhood/mod.rs +++ b/node/src/neighborhood/mod.rs @@ -435,9 +435,7 @@ impl Neighborhood { let neighborhood_mode = &neighborhood_config.mode; let mode: NeighborhoodModeLight = neighborhood_mode.into(); let neighborhood_configs = neighborhood_mode.neighbor_configs(); - if mode == NeighborhoodModeLight::ZeroHop - && !neighborhood_configs.is_empty() - { + if mode == NeighborhoodModeLight::ZeroHop && !neighborhood_configs.is_empty() { panic!( "A zero-hop MASQ Node is not decentralized and cannot have a --neighbors setting" ) @@ -843,9 +841,16 @@ impl Neighborhood { payload_size: 10000, hostname_opt: None, }; - debug!(Logger::new("Multinode"), "Searching for a {}-hops route.", self.min_hops_count as usize); + debug!( + Logger::new("Multinode"), + "Searching for a {}-hops route.", self.min_hops_count as usize + ); if let Some(route_query_response) = self.handle_route_query_message(msg) { - trace!(Logger::new("Multinode"), "Round Trip Route Length: {:?}", route_query_response.route.hops.len()); + trace!( + Logger::new("Multinode"), + "Round Trip Route Length: {:?}", + route_query_response.route.hops.len() + ); debug!( &self.logger, "The connectivity check has found a {}-hops route.", self.min_hops_count as usize @@ -1246,11 +1251,9 @@ impl Neighborhood { hostname_opt, ) .into_iter() - .filter_map(|cr| { - match cr.undesirability <= minimum_undesirability { - true => Some(cr.nodes), - false => None, - } + .filter_map(|cr| match cr.undesirability <= minimum_undesirability { + true => Some(cr.nodes), + false => None, }) .next(); @@ -1638,7 +1641,12 @@ mod tests { use crate::test_utils::assert_contains; use crate::test_utils::make_meaningless_route; use crate::test_utils::make_wallet; - use crate::test_utils::neighborhood_test_utils::{db_from_node, make_global_cryptde_node_record, make_ip, make_node, make_node_descriptor, make_node_record, make_node_record_f, MIN_HOPS_COUNT_FOR_TEST, neighborhood_from_nodes}; + use crate::test_utils::neighborhood_test_utils::{ + cryptdes_from_node_records, db_from_node, linearly_connect_nodes, + make_global_cryptde_node_record, make_ip, make_node, make_node_descriptor, + make_node_record, make_node_record_f, make_node_records, neighborhood_from_nodes, + MIN_HOPS_COUNT_FOR_TEST, + }; use crate::test_utils::persistent_configuration_mock::PersistentConfigurationMock; use crate::test_utils::rate_pack; use crate::test_utils::recorder::make_recorder; @@ -2750,9 +2758,7 @@ mod tests { let addr: Addr = subject.start(); let sub: Recipient = addr.recipient::(); - let future = sub.send(RouteQueryMessage::data_indefinite_route_request( - None, 400, - )); + let future = sub.send(RouteQueryMessage::data_indefinite_route_request(None, 400)); System::current().stop_with_code(0); system.run(); @@ -2768,9 +2774,7 @@ mod tests { let addr: Addr = subject.start(); let sub: Recipient = addr.recipient::(); - let future = sub.send(RouteQueryMessage::data_indefinite_route_request( - None, 430, - )); + let future = sub.send(RouteQueryMessage::data_indefinite_route_request(None, 430)); System::current().stop_with_code(0); system.run(); @@ -2885,7 +2889,7 @@ mod tests { } let addr: Addr = subject.start(); let sub: Recipient = addr.recipient::(); - let msg = RouteQueryMessage::data_indefinite_route_request(None, 10000); + let msg = RouteQueryMessage::data_indefinite_route_request(None, 10000); let future = sub.send(msg); @@ -3019,9 +3023,7 @@ mod tests { let addr: Addr = subject.start(); let sub: Recipient = addr.recipient::(); - let data_route = sub.send(RouteQueryMessage::data_indefinite_route_request( - None, 5000, - )); + let data_route = sub.send(RouteQueryMessage::data_indefinite_route_request(None, 5000)); System::current().stop_with_code(0); system.run(); @@ -3116,12 +3118,8 @@ mod tests { let addr: Addr = subject.start(); let sub: Recipient = addr.recipient::(); - let data_route_0 = sub.send(RouteQueryMessage::data_indefinite_route_request( - None, 2000, - )); - let data_route_1 = sub.send(RouteQueryMessage::data_indefinite_route_request( - None, 3000, - )); + let data_route_0 = sub.send(RouteQueryMessage::data_indefinite_route_request(None, 2000)); + let data_route_1 = sub.send(RouteQueryMessage::data_indefinite_route_request(None, 3000)); System::current().stop_with_code(0); system.run(); @@ -3171,15 +3169,13 @@ mod tests { ) .unwrap(); - let route_request_1 = route_sub.send(RouteQueryMessage::data_indefinite_route_request( - None, 1000, - )); + let route_request_1 = + route_sub.send(RouteQueryMessage::data_indefinite_route_request(None, 1000)); let _ = set_wallet_sub.try_send(SetConsumingWalletMessage { wallet: expected_new_wallet, }); - let route_request_2 = route_sub.send(RouteQueryMessage::data_indefinite_route_request( - None, 2000, - )); + let route_request_2 = + route_sub.send(RouteQueryMessage::data_indefinite_route_request(None, 2000)); System::current().stop(); system.run(); @@ -5321,33 +5317,14 @@ mod tests { fn assert_route_query_message(min_hops_count: Hops) { let hops = min_hops_count as usize; let nodes_count = hops + 1; - // Create Nodes - let nodes = (1..=nodes_count) - .map(|i| { - let nonce = 1000 + i as u16; - let has_ip = if i <= 2 { true } else { false }; - let node = if i == 1 { - make_global_cryptde_node_record(nonce, has_ip) - } else { - make_node_record(nonce, has_ip) - }; - node - }) - .collect::>(); - // Create Database - let root_node = nodes.get(0).unwrap(); + let root_node = make_global_cryptde_node_record(4242, true); + let mut nodes = make_node_records(nodes_count as u16); + nodes[0] = root_node; let neighbor = nodes.get(1).unwrap(); - let mut subject = neighborhood_from_nodes(root_node, Some(neighbor)); + let db = linearly_connect_nodes(&nodes); + let mut subject = neighborhood_from_nodes(db.root(), Some(neighbor)); subject.min_hops_count = min_hops_count; - for i in 1..nodes_count { - subject - .neighborhood_database - .add_node(nodes[i].clone()) - .unwrap(); - subject - .neighborhood_database - .add_arbitrary_full_neighbor(nodes[i - 1].public_key(), nodes[i].public_key()); - } + subject.neighborhood_database = db; let result = subject.make_round_trip_route(RouteQueryMessage { target_key_opt: None, @@ -5364,24 +5341,14 @@ mod tests { } }; let mut route = result.clone().unwrap().route.hops; + let route_length = route.len(); let _accounting = route.pop(); let over_route = &route[..hops]; let back_route = &route[hops..]; - let over_cryptdes = { - let mut over_nodes = nodes.clone(); - over_nodes.pop(); - over_nodes - .iter() - .map(|node| CryptDENull::from(node.public_key(), TEST_DEFAULT_CHAIN)) - .collect::>() - }; - let back_cryptdes = { - nodes - .iter() - .rev() - .map(|node| CryptDENull::from(node.public_key(), TEST_DEFAULT_CHAIN)) - .collect::>() - }; + let over_cryptdes = cryptdes_from_node_records(&nodes[..nodes_count - 1]); + let mut back_cryptdes = cryptdes_from_node_records(&nodes); + back_cryptdes.reverse(); + assert_eq!(route_length, 2 * nodes_count); assert_hops(over_cryptdes, over_route); assert_hops(back_cryptdes, back_route); } diff --git a/node/src/test_utils/neighborhood_test_utils.rs b/node/src/test_utils/neighborhood_test_utils.rs index 7e14f7823..1d7e62da7 100644 --- a/node/src/test_utils/neighborhood_test_utils.rs +++ b/node/src/test_utils/neighborhood_test_utils.rs @@ -335,3 +335,10 @@ pub fn public_keys_from_node_records(nodes: &[NodeRecord]) -> HashSet .map(|node| node.public_key().clone()) .collect::>() } + +pub fn cryptdes_from_node_records(nodes: &[NodeRecord]) -> Vec { + nodes + .iter() + .map(|node| CryptDENull::from(node.public_key(), TEST_DEFAULT_CHAIN)) + .collect::>() +} From 717f29b15f52cbff45ee6bb15eb711cbfc32d4ac Mon Sep 17 00:00:00 2001 From: utkarshg6 Date: Wed, 3 May 2023 13:47:23 +0530 Subject: [PATCH 44/56] GH-690: refactor make_neighborhood_with_linearly_connected_nodes() --- node/src/neighborhood/mod.rs | 58 ++++--------------- .../src/test_utils/neighborhood_test_utils.rs | 2 +- 2 files changed, 13 insertions(+), 47 deletions(-) diff --git a/node/src/neighborhood/mod.rs b/node/src/neighborhood/mod.rs index cfeee1877..1a98e4856 100644 --- a/node/src/neighborhood/mod.rs +++ b/node/src/neighborhood/mod.rs @@ -3947,7 +3947,7 @@ mod tests { fn neighborhood_starts_accountant_when_first_route_can_be_made() { let (accountant, _, accountant_recording_arc) = make_recorder(); let (ui_gateway, _, _) = make_recorder(); - let mut subject = make_neighborhood_linearly_connected_with_nodes(3); + let mut subject = make_neighborhood_with_linearly_connected_nodes(4); subject.node_to_ui_recipient_opt = Some(ui_gateway.start().recipient()); let peer_actors = peer_actors_builder().accountant(accountant).build(); bind_subject(&mut subject, peer_actors); @@ -4011,8 +4011,9 @@ mod tests { fn assert_connectivity_check(hops: Hops) { init_test_logging(); let test_name = &format!("connectivity_check_for_{}_hops", hops as usize); + let nodes_count = hops as u16 + 1; let mut subject: Neighborhood = - make_neighborhood_linearly_connected_with_nodes(hops as u16); + make_neighborhood_with_linearly_connected_nodes(nodes_count); let (ui_gateway, _, ui_gateway_arc) = make_recorder(); let (accountant, _, _) = make_recorder(); let node_to_ui_recipient = ui_gateway.start().recipient::(); @@ -4069,7 +4070,7 @@ mod tests { fn neighborhood_logs_when_three_hops_route_can_not_be_made() { init_test_logging(); let test_name = "neighborhood_logs_when_three_hops_route_can_not_be_made"; - let mut subject: Neighborhood = make_neighborhood_linearly_connected_with_nodes(2); + let mut subject: Neighborhood = make_neighborhood_with_linearly_connected_nodes(3); let (ui_gateway, _, ui_gateway_arc) = make_recorder(); let (accountant, _, _) = make_recorder(); let node_to_ui_recipient = ui_gateway.start().recipient::(); @@ -5320,9 +5321,8 @@ mod tests { let root_node = make_global_cryptde_node_record(4242, true); let mut nodes = make_node_records(nodes_count as u16); nodes[0] = root_node; - let neighbor = nodes.get(1).unwrap(); let db = linearly_connect_nodes(&nodes); - let mut subject = neighborhood_from_nodes(db.root(), Some(neighbor)); + let mut subject = neighborhood_from_nodes(db.root(), nodes.get(1)); subject.min_hops_count = min_hops_count; subject.neighborhood_database = db; @@ -6066,47 +6066,13 @@ mod tests { message_opt } - fn make_neighborhood_linearly_connected_with_nodes(hops: u16) -> Neighborhood { - let subject_node = make_global_cryptde_node_record(1234, true); - let relay1 = make_node_record(1111, true); - let mut nodes = vec![ - subject_node.public_key().clone(), - relay1.public_key().clone(), - ]; - let mut neighborhood: Neighborhood = neighborhood_from_nodes(&subject_node, Some(&relay1)); - let mut replacement_database = neighborhood.neighborhood_database.clone(); - - fn nonce(x: u16) -> u16 { - x + (10 * x) + (100 * x) + (1000 * x) - } - - for i in 1..=hops { - match i { - 1 => { - replacement_database.add_node(relay1.clone()).unwrap(); - } - i if i < hops => { - let relay_node = make_node_record(nonce(i), false); - replacement_database.add_node(relay_node.clone()).unwrap(); - nodes.push(relay_node.public_key().clone()); - } - i if i == hops => { - let exit_node = make_node_record(nonce(i), false); - replacement_database.add_node(exit_node.clone()).unwrap(); - nodes.push(exit_node.public_key().clone()); - } - _ => panic!("The match statement should be exhaustive."), - } - replacement_database - .add_arbitrary_full_neighbor(&nodes[i as usize - 1], &nodes[i as usize]); - } - - neighborhood.gossip_acceptor = Box::new(DatabaseReplacementGossipAcceptor { - replacement_database, - }); - neighborhood.persistent_config_opt = Some(Box::new( - PersistentConfigurationMock::new().set_past_neighbors_result(Ok(())), - )); + fn make_neighborhood_with_linearly_connected_nodes(nodes_count: u16) -> Neighborhood { + let root_node = make_global_cryptde_node_record(4242, true); + let mut nodes = make_node_records(nodes_count); + nodes[0] = root_node; + let db = linearly_connect_nodes(&nodes); + let mut neighborhood = neighborhood_from_nodes(db.root(), nodes.get(1)); + neighborhood.neighborhood_database = db; neighborhood } diff --git a/node/src/test_utils/neighborhood_test_utils.rs b/node/src/test_utils/neighborhood_test_utils.rs index 1d7e62da7..e85ccc4cf 100644 --- a/node/src/test_utils/neighborhood_test_utils.rs +++ b/node/src/test_utils/neighborhood_test_utils.rs @@ -323,7 +323,7 @@ pub fn gossip_about_nodes_from_database( ) -> Gossip_0v1 { nodes .iter() - .fold(GossipBuilder::new(&database), |builder, node| { + .fold(GossipBuilder::new(database), |builder, node| { builder.node(node.public_key(), false) }) .build() From bc1216e5eecf5117c854a4cc5019b5145fb87ead Mon Sep 17 00:00:00 2001 From: utkarshg6 Date: Wed, 3 May 2023 15:04:23 +0530 Subject: [PATCH 45/56] GH-690: cleanup in connectivity check --- node/src/neighborhood/mod.rs | 16 +++------------- 1 file changed, 3 insertions(+), 13 deletions(-) diff --git a/node/src/neighborhood/mod.rs b/node/src/neighborhood/mod.rs index 1a98e4856..f0e7fbc28 100644 --- a/node/src/neighborhood/mod.rs +++ b/node/src/neighborhood/mod.rs @@ -538,7 +538,6 @@ impl Neighborhood { } else { self.make_round_trip_route(msg) }; - eprintln!("Round Trip Result: {:?}", route_result); match route_result { Ok(response) => { let msg_str = debug_msg_opt.expect("Debug Message wasn't built but expected."); @@ -841,19 +840,10 @@ impl Neighborhood { payload_size: 10000, hostname_opt: None, }; - debug!( - Logger::new("Multinode"), - "Searching for a {}-hops route.", self.min_hops_count as usize - ); - if let Some(route_query_response) = self.handle_route_query_message(msg) { - trace!( - Logger::new("Multinode"), - "Round Trip Route Length: {:?}", - route_query_response.route.hops.len() - ); + if self.handle_route_query_message(msg).is_some() { debug!( &self.logger, - "The connectivity check has found a {}-hops route.", self.min_hops_count as usize + "The connectivity check has found a {}-hop(s) route.", self.min_hops_count as usize ); self.overall_connection_status .update_ocs_stage_and_send_message_to_ui( @@ -4051,7 +4041,7 @@ mod tests { } ); TestLogHandler::new().exists_log_containing(&format!( - "DEBUG: {}: The connectivity check has found a {}-hops route.", + "DEBUG: {}: The connectivity check has found a {}-hop(s) route.", test_name, hops as usize )); } From a5ac7070a9bb65685a9b70da62c901ac9d82775e Mon Sep 17 00:00:00 2001 From: utkarshg6 Date: Wed, 3 May 2023 18:02:51 +0530 Subject: [PATCH 46/56] GH-690: make --min-hops configurable via cli --- masq_lib/src/shared_schema.rs | 3 +- node/src/daemon/setup_reporter.rs | 28 +++++++++++++++++-- .../unprivileged_parse_args_configuration.rs | 20 ++++++------- node/src/sub_lib/neighborhood.rs | 22 ++++++--------- 4 files changed, 47 insertions(+), 26 deletions(-) diff --git a/masq_lib/src/shared_schema.rs b/masq_lib/src/shared_schema.rs index ad3bbeddb..a051f87ba 100644 --- a/masq_lib/src/shared_schema.rs +++ b/masq_lib/src/shared_schema.rs @@ -427,8 +427,9 @@ pub fn shared_app(head: App<'static, 'static>) -> App<'static, 'static> { Arg::with_name("min-hops") .long("min-hops") .value_name("MIN_HOPS") + .default_value("3") .required(false) - .min_values(1) + .min_values(1) // TODO: does this keep us being able to blank out .max_values(1) .possible_values(&["1", "2", "3", "4", "5", "6"]) .help(MIN_HOPS_HELP), diff --git a/node/src/daemon/setup_reporter.rs b/node/src/daemon/setup_reporter.rs index c1ee05c65..ad64c7839 100644 --- a/node/src/daemon/setup_reporter.rs +++ b/node/src/daemon/setup_reporter.rs @@ -43,7 +43,7 @@ use std::net::{IpAddr, Ipv4Addr}; use std::path::{Path, PathBuf}; use std::str::FromStr; -const CONSOLE_DIAGNOSTICS: bool = false; +const CONSOLE_DIAGNOSTICS: bool = true; // TODO: set back to false const ERR_SENSITIVE_BLANKED_OUT_VALUE_PAIRS: &[(&str, &str)] = &[("chain", "data-directory")]; @@ -814,6 +814,13 @@ impl ValueRetriever for MappingProtocol { } } +struct MinHops {} +impl ValueRetriever for MinHops { + fn value_name(&self) -> &'static str { + "min-hops" + } +} + struct NeighborhoodMode {} impl ValueRetriever for NeighborhoodMode { fn value_name(&self) -> &'static str { @@ -1040,6 +1047,7 @@ fn value_retrievers(dirs_wrapper: &dyn DirsWrapper) -> Vec( } }; - let min_hops_arg = value_m!(multi_config, "min-hops", String); - let min_hops_count = match min_hops_arg { - None => DEFAULT_MIN_HOPS_COUNT, - Some(string) => string - .try_into() - .unwrap_or_else(|error| panic!("{}", error)), - }; + let min_hops_count = + value_m!(multi_config, "min-hops", Hops).expect("clap schema specifies no default"); + // let min_hops_count = match min_hops_arg { + // None => DEFAULT_MIN_HOPS_COUNT, + // Some(string) => string + // .try_into() + // .unwrap_or_else(|error| panic!("{}", error)), + // }; match make_neighborhood_mode(multi_config, neighbor_configs, persistent_config) { Ok(mode) => Ok(NeighborhoodConfig { @@ -638,6 +638,7 @@ mod tests { use crate::sub_lib::neighborhood::{Hops, DEFAULT_RATE_PACK}; use crate::sub_lib::utils::make_new_multi_config; use crate::sub_lib::wallet::Wallet; + use crate::test_utils::neighborhood_test_utils::MIN_HOPS_COUNT_FOR_TEST; use crate::test_utils::persistent_configuration_mock::PersistentConfigurationMock; use crate::test_utils::unshared_test_utils::{ configure_default_persistent_config, default_persistent_config_just_accountant_config, @@ -654,7 +655,6 @@ mod tests { use std::str::FromStr; use std::sync::{Arc, Mutex}; use std::time::Duration; - use crate::test_utils::neighborhood_test_utils::MIN_HOPS_COUNT_FOR_TEST; #[test] fn convert_ci_configs_handles_blockchain_mismatch() { diff --git a/node/src/sub_lib/neighborhood.rs b/node/src/sub_lib/neighborhood.rs index 1d46c8c8e..b9186732c 100644 --- a/node/src/sub_lib/neighborhood.rs +++ b/node/src/sub_lib/neighborhood.rs @@ -379,11 +379,11 @@ pub enum Hops { SixHops = 6, } -impl TryFrom for Hops { - type Error = String; +impl FromStr for Hops { + type Err = String; - fn try_from(value: String) -> Result { - match value.as_str() { + fn from_str(value: &str) -> Result { + match value { "1" => Ok(Hops::OneHop), "2" => Ok(Hops::TwoHops), "3" => Ok(Hops::ThreeHops), @@ -1038,7 +1038,7 @@ mod tests { #[test] fn data_indefinite_route_request() { - let result = RouteQueryMessage::data_indefinite_route_request(None, 7500); + let result = RouteQueryMessage::data_indefinite_route_request(None, 7500); assert_eq!( result, @@ -1255,19 +1255,15 @@ mod tests { } #[test] - fn min_hops_count_can_be_converted_from_string() { - let min_hops_count = String::from("6"); - - let result: Hops = min_hops_count.try_into().unwrap(); + fn min_hops_count_can_be_converted_from_str() { + let result = Hops::from_str("6").unwrap(); assert_eq!(result, Hops::SixHops); } #[test] - fn min_hops_count_conversion_from_string_panics() { - let min_hops_count = String::from("100"); - - let result: Result = min_hops_count.try_into(); + fn min_hops_count_conversion_from_str_returns_error() { + let result = Hops::from_str("100"); assert_eq!( result, From f6f5991a262b04562e06edf8d3228d04036164f5 Mon Sep 17 00:00:00 2001 From: utkarshg6 Date: Thu, 4 May 2023 11:45:16 +0530 Subject: [PATCH 47/56] GH-690: fix the bump script for macOS --- ci/bump_version.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ci/bump_version.sh b/ci/bump_version.sh index 1204b8173..de32eea3c 100755 --- a/ci/bump_version.sh +++ b/ci/bump_version.sh @@ -31,7 +31,7 @@ bump_version() { find_pattern='^version\s*=.*[^,]\s*$' replace_pattern='s/'$find_pattern'/version = "'"$version"'"/' - grep -q "$find_pattern" "$file" && sed -i "$replace_pattern" "$file" + grep -q "$find_pattern" "$file" && sed -i "" "$replace_pattern" "$file" exit_code="$?" if [[ "$exit_code" != "0" ]]; then final_exit_code=1 From 05ae02b881cc75666da7cae091874291786753c7 Mon Sep 17 00:00:00 2001 From: utkarshg6 Date: Thu, 4 May 2023 17:24:24 +0530 Subject: [PATCH 48/56] GH-690: add todo for the min-hops arg to default properly --- node/src/daemon/setup_reporter.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/node/src/daemon/setup_reporter.rs b/node/src/daemon/setup_reporter.rs index ad64c7839..f4de41a99 100644 --- a/node/src/daemon/setup_reporter.rs +++ b/node/src/daemon/setup_reporter.rs @@ -1267,7 +1267,7 @@ mod tests { ("ip", "4.3.2.1", Set), ("log-level", "warn", Default), ("mapping-protocol", "", Blank), - ("min-hops", "3", Configured), // TODO: Shouldn't this be default? + ("min-hops", "3", Configured), // TODO: GH-698: This should be changed to Default after this card is played ("neighborhood-mode", "standard", Default), ( "neighbors", From 65db4f2131bd9692b75ddcbcab616d2bb6cdf60a Mon Sep 17 00:00:00 2001 From: utkarshg6 Date: Thu, 4 May 2023 17:31:50 +0530 Subject: [PATCH 49/56] GH-690: add todo inisde unpriveleged args --- .../unprivileged_parse_args_configuration.rs | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/node/src/node_configurator/unprivileged_parse_args_configuration.rs b/node/src/node_configurator/unprivileged_parse_args_configuration.rs index 3dbc61873..2b6d15d73 100644 --- a/node/src/node_configurator/unprivileged_parse_args_configuration.rs +++ b/node/src/node_configurator/unprivileged_parse_args_configuration.rs @@ -215,13 +215,7 @@ pub fn make_neighborhood_config( }; let min_hops_count = - value_m!(multi_config, "min-hops", Hops).expect("clap schema specifies no default"); - // let min_hops_count = match min_hops_arg { - // None => DEFAULT_MIN_HOPS_COUNT, - // Some(string) => string - // .try_into() - // .unwrap_or_else(|error| panic!("{}", error)), - // }; + value_m!(multi_config, "min-hops", Hops).expect("clap schema specifies no default"); // TODO: GH-690: Test Drive this panic match make_neighborhood_mode(multi_config, neighbor_configs, persistent_config) { Ok(mode) => Ok(NeighborhoodConfig { From 0273dcb9199c188819323aef84e33776d84df81c Mon Sep 17 00:00:00 2001 From: utkarshg6 Date: Fri, 5 May 2023 11:24:03 +0530 Subject: [PATCH 50/56] GH-690: change the min_values to 0 for min-hops --- masq_lib/src/shared_schema.rs | 2 +- .../unprivileged_parse_args_configuration.rs | 29 ++++++++++++++++++- 2 files changed, 29 insertions(+), 2 deletions(-) diff --git a/masq_lib/src/shared_schema.rs b/masq_lib/src/shared_schema.rs index a051f87ba..4bc795d98 100644 --- a/masq_lib/src/shared_schema.rs +++ b/masq_lib/src/shared_schema.rs @@ -429,7 +429,7 @@ pub fn shared_app(head: App<'static, 'static>) -> App<'static, 'static> { .value_name("MIN_HOPS") .default_value("3") .required(false) - .min_values(1) // TODO: does this keep us being able to blank out + .min_values(0) .max_values(1) .possible_values(&["1", "2", "3", "4", "5", "6"]) .help(MIN_HOPS_HELP), diff --git a/node/src/node_configurator/unprivileged_parse_args_configuration.rs b/node/src/node_configurator/unprivileged_parse_args_configuration.rs index 2b6d15d73..b8e402bf3 100644 --- a/node/src/node_configurator/unprivileged_parse_args_configuration.rs +++ b/node/src/node_configurator/unprivileged_parse_args_configuration.rs @@ -750,7 +750,34 @@ mod tests { } #[test] - fn make_neighborhood_config_standard_panics_with_undesirable_min_hops_count() { + fn make_neighborhood_config_standard_uses_default_value_when_no_min_hops_count_value_is_provided( + ) { + running_test(); + let args = ArgsBuilder::new() + .param("--neighborhood-mode", "standard") + .param( + "--neighbors", + &format!("masq://{identifier}:QmlsbA@1.2.3.4:1234/2345,masq://{identifier}:VGVk@2.3.4.5:3456/4567",identifier = DEFAULT_CHAIN.rec().literal_identifier), + ) + .param("--fake-public-key", "booga") + .opt("--min-hops"); + let vcl = CommandLineVcl::new(args.into()); + let multi_config = make_new_multi_config(&app_node(), vec![Box::new(vcl)]).unwrap(); + + let result = make_neighborhood_config( + &UnprivilegedParseArgsConfigurationDaoReal {}, + &multi_config, + &mut configure_default_persistent_config(RATE_PACK), + &mut BootstrapperConfig::new(), + ); + + let min_hops_count = result.unwrap().min_hops_count; + assert_eq!(min_hops_count, Hops::ThreeHops); + } + + #[test] + fn make_neighborhood_config_standard_throws_err_when_undesirable_min_hops_count_value_is_provided( + ) { running_test(); let args = ArgsBuilder::new() .param("--neighborhood-mode", "standard") From 1cf77ba3cc65089f0d64c1c17507b3f67cb46cd1 Mon Sep 17 00:00:00 2001 From: utkarshg6 Date: Fri, 5 May 2023 12:42:27 +0530 Subject: [PATCH 51/56] GH-690: cleanup in node_configurator --- .../node_configurator_standard.rs | 7 +- .../unprivileged_parse_args_configuration.rs | 176 ++++++++---------- 2 files changed, 78 insertions(+), 105 deletions(-) diff --git a/node/src/node_configurator/node_configurator_standard.rs b/node/src/node_configurator/node_configurator_standard.rs index 0a6503e8b..82bbe40d3 100644 --- a/node/src/node_configurator/node_configurator_standard.rs +++ b/node/src/node_configurator/node_configurator_standard.rs @@ -284,7 +284,9 @@ mod tests { use crate::node_test_utils::DirsWrapperMock; use crate::sub_lib::cryptde::CryptDE; use crate::sub_lib::neighborhood::NeighborhoodMode::ZeroHop; - use crate::sub_lib::neighborhood::{NeighborhoodConfig, NeighborhoodMode, NodeDescriptor}; + use crate::sub_lib::neighborhood::{ + Hops, NeighborhoodConfig, NeighborhoodMode, NodeDescriptor, + }; use crate::sub_lib::wallet::Wallet; use crate::test_utils::persistent_configuration_mock::PersistentConfigurationMock; use crate::test_utils::unshared_test_utils::{ @@ -304,7 +306,6 @@ mod tests { use std::path::PathBuf; use std::sync::{Arc, Mutex}; use std::vec; - use crate::test_utils::neighborhood_test_utils::MIN_HOPS_COUNT_FOR_TEST; #[test] fn node_configurator_standard_unprivileged_uses_parse_args_configurator_dao_real() { @@ -576,7 +577,7 @@ mod tests { config.neighborhood_config, NeighborhoodConfig { mode: NeighborhoodMode::ZeroHop, // not populated on the privileged side - min_hops_count: MIN_HOPS_COUNT_FOR_TEST, + min_hops_count: Hops::ThreeHops, } ); assert_eq!( diff --git a/node/src/node_configurator/unprivileged_parse_args_configuration.rs b/node/src/node_configurator/unprivileged_parse_args_configuration.rs index b8e402bf3..586cbf368 100644 --- a/node/src/node_configurator/unprivileged_parse_args_configuration.rs +++ b/node/src/node_configurator/unprivileged_parse_args_configuration.rs @@ -632,7 +632,6 @@ mod tests { use crate::sub_lib::neighborhood::{Hops, DEFAULT_RATE_PACK}; use crate::sub_lib::utils::make_new_multi_config; use crate::sub_lib::wallet::Wallet; - use crate::test_utils::neighborhood_test_utils::MIN_HOPS_COUNT_FOR_TEST; use crate::test_utils::persistent_configuration_mock::PersistentConfigurationMock; use crate::test_utils::unshared_test_utils::{ configure_default_persistent_config, default_persistent_config_just_accountant_config, @@ -827,7 +826,7 @@ mod tests { let node_addr = match result { Ok(NeighborhoodConfig { mode: NeighborhoodMode::Standard(node_addr, _, _), - min_hops_count: MIN_HOPS_COUNT_FOR_TEST, + min_hops_count: Hops::ThreeHops, }) => node_addr, x => panic!("Wasn't expecting {:?}", x), }; @@ -860,33 +859,30 @@ mod tests { ); assert_eq!( - result, - Ok(NeighborhoodConfig { - mode: NeighborhoodMode::OriginateOnly( - vec![ - NodeDescriptor::try_from(( - main_cryptde(), - format!( - "masq://{}:QmlsbA@1.2.3.4:1234/2345", - DEFAULT_CHAIN.rec().literal_identifier - ) - .as_str() - )) - .unwrap(), - NodeDescriptor::try_from(( - main_cryptde(), - format!( - "masq://{}:VGVk@2.3.4.5:3456/4567", - DEFAULT_CHAIN.rec().literal_identifier - ) - .as_str() - )) - .unwrap() - ], - DEFAULT_RATE_PACK - ), - min_hops_count: MIN_HOPS_COUNT_FOR_TEST, - }) + result.unwrap().mode, + NeighborhoodMode::OriginateOnly( + vec![ + NodeDescriptor::try_from(( + main_cryptde(), + format!( + "masq://{}:QmlsbA@1.2.3.4:1234/2345", + DEFAULT_CHAIN.rec().literal_identifier + ) + .as_str() + )) + .unwrap(), + NodeDescriptor::try_from(( + main_cryptde(), + format!( + "masq://{}:VGVk@2.3.4.5:3456/4567", + DEFAULT_CHAIN.rec().literal_identifier + ) + .as_str() + )) + .unwrap() + ], + DEFAULT_RATE_PACK + ) ); } @@ -939,30 +935,27 @@ mod tests { ); assert_eq!( - result, - Ok(NeighborhoodConfig { - mode: NeighborhoodMode::ConsumeOnly(vec![ - NodeDescriptor::try_from(( - main_cryptde(), - format!( - "masq://{}:QmlsbA@1.2.3.4:1234/2345", - DEFAULT_CHAIN.rec().literal_identifier - ) - .as_str() - )) - .unwrap(), - NodeDescriptor::try_from(( - main_cryptde(), - format!( - "masq://{}:VGVk@2.3.4.5:3456/4567", - DEFAULT_CHAIN.rec().literal_identifier - ) - .as_str() - )) - .unwrap() - ],), - min_hops_count: MIN_HOPS_COUNT_FOR_TEST, - }) + result.unwrap().mode, + NeighborhoodMode::ConsumeOnly(vec![ + NodeDescriptor::try_from(( + main_cryptde(), + format!( + "masq://{}:QmlsbA@1.2.3.4:1234/2345", + DEFAULT_CHAIN.rec().literal_identifier + ) + .as_str() + )) + .unwrap(), + NodeDescriptor::try_from(( + main_cryptde(), + format!( + "masq://{}:VGVk@2.3.4.5:3456/4567", + DEFAULT_CHAIN.rec().literal_identifier + ) + .as_str() + )) + .unwrap() + ],), ); } @@ -1021,13 +1014,7 @@ mod tests { &mut BootstrapperConfig::new(), ); - assert_eq!( - result, - Ok(NeighborhoodConfig { - mode: NeighborhoodMode::ZeroHop, - min_hops_count: MIN_HOPS_COUNT_FOR_TEST, - }) - ); + assert_eq!(result.unwrap().mode, NeighborhoodMode::ZeroHop); } #[test] @@ -1352,13 +1339,7 @@ mod tests { ) .unwrap(); - assert_eq!( - config.neighborhood_config, - NeighborhoodConfig { - mode: NeighborhoodMode::ZeroHop, - min_hops_count: MIN_HOPS_COUNT_FOR_TEST, - } - ); + assert_eq!(config.neighborhood_config.mode, NeighborhoodMode::ZeroHop); let set_past_neighbors_params = set_past_neighbors_params_arc.lock().unwrap(); assert_eq!( *set_past_neighbors_params, @@ -1399,13 +1380,7 @@ mod tests { ) .unwrap(); - assert_eq!( - config.neighborhood_config, - NeighborhoodConfig { - mode: NeighborhoodMode::ZeroHop, - min_hops_count: MIN_HOPS_COUNT_FOR_TEST, - } - ); + assert_eq!(config.neighborhood_config.mode, NeighborhoodMode::ZeroHop); let set_past_neighbors_params = set_past_neighbors_params_arc.lock().unwrap(); assert!(set_past_neighbors_params.is_empty()) } @@ -1559,34 +1534,31 @@ mod tests { )), ); assert_eq!( - config.neighborhood_config, - NeighborhoodConfig { - mode: NeighborhoodMode::Standard( - NodeAddr::new(&IpAddr::from_str("34.56.78.90").unwrap(), &[]), - vec![ - NodeDescriptor::try_from(( - main_cryptde(), - format!( - "masq://{}:QmlsbA@1.2.3.4:1234/2345", - DEFAULT_CHAIN.rec().literal_identifier - ) - .as_str() - )) - .unwrap(), - NodeDescriptor::try_from(( - main_cryptde(), - format!( - "masq://{}:VGVk@2.3.4.5:3456/4567", - DEFAULT_CHAIN.rec().literal_identifier - ) - .as_str() - )) - .unwrap(), - ], - DEFAULT_RATE_PACK.clone() - ), - min_hops_count: MIN_HOPS_COUNT_FOR_TEST, - } + config.neighborhood_config.mode, + NeighborhoodMode::Standard( + NodeAddr::new(&IpAddr::from_str("34.56.78.90").unwrap(), &[]), + vec![ + NodeDescriptor::try_from(( + main_cryptde(), + format!( + "masq://{}:QmlsbA@1.2.3.4:1234/2345", + DEFAULT_CHAIN.rec().literal_identifier + ) + .as_str() + )) + .unwrap(), + NodeDescriptor::try_from(( + main_cryptde(), + format!( + "masq://{}:VGVk@2.3.4.5:3456/4567", + DEFAULT_CHAIN.rec().literal_identifier + ) + .as_str() + )) + .unwrap(), + ], + DEFAULT_RATE_PACK.clone() + ) ); assert_eq!(config.db_password_opt, Some(password.to_string())); assert_eq!(config.mapping_protocol_opt, Some(AutomapProtocol::Pcp)); From 91a4c1ab4915adf26680d6ea63cf5499fc33f4be Mon Sep 17 00:00:00 2001 From: utkarshg6 Date: Fri, 5 May 2023 13:19:40 +0530 Subject: [PATCH 52/56] GH-690: cleanup in proxy server --- node/src/proxy_server/mod.rs | 31 +++++-------------------------- node/src/sub_lib/neighborhood.rs | 2 -- 2 files changed, 5 insertions(+), 28 deletions(-) diff --git a/node/src/proxy_server/mod.rs b/node/src/proxy_server/mod.rs index cfd279e9a..0076b555e 100644 --- a/node/src/proxy_server/mod.rs +++ b/node/src/proxy_server/mod.rs @@ -33,9 +33,7 @@ use crate::sub_lib::peer_actors::BindMessage; use crate::sub_lib::proxy_client::{ClientResponsePayload_0v1, DnsResolveFailure_0v1}; use crate::sub_lib::proxy_server::ClientRequestPayload_0v1; use crate::sub_lib::proxy_server::ProxyServerSubs; -use crate::sub_lib::proxy_server::{ - AddReturnRouteMessage, AddRouteMessage, -}; +use crate::sub_lib::proxy_server::{AddReturnRouteMessage, AddRouteMessage}; use crate::sub_lib::route::Route; use crate::sub_lib::set_consuming_wallet_message::SetConsumingWalletMessage; use crate::sub_lib::stream_handler_pool::TransmitDataMsg; @@ -952,12 +950,6 @@ impl IBCDHelperReal { route_source .send(RouteQueryMessage::data_indefinite_route_request( hostname_opt, - // TODO: GH-690: This edge case hasn't been take care - // if common_args.is_decentralized { - // DEFAULT_MINIMUM_HOP_COUNT - // } else { - // 0 - // }, payload_size, )) .then(move |route_result| { @@ -1291,10 +1283,7 @@ mod tests { let record = recording.get_record::(0); assert_eq!( record, - &RouteQueryMessage::data_indefinite_route_request( - Some("nowhere.com".to_string()), - 47 - ) + &RouteQueryMessage::data_indefinite_route_request(Some("nowhere.com".to_string()), 47) ); let recording = proxy_server_recording_arc.lock().unwrap(); assert_eq!(recording.len(), 0); @@ -1765,7 +1754,6 @@ mod tests { #[test] fn proxy_server_receives_http_request_with_no_consuming_wallet_in_zero_hop_mode_and_handles_normally( ) { - // TODO: GH-690: Initially this test is intended for a RouteQueryMessage with a min_hop_count = 0, but it is working fine irrespective of that init_test_logging(); let main_cryptde = main_cryptde(); let alias_cryptde = alias_cryptde(); @@ -2205,10 +2193,7 @@ mod tests { let record = recording.get_record::(0); assert_eq!( record, - &RouteQueryMessage::data_indefinite_route_request( - Some("nowhere.com".to_string()), - 47 - ) + &RouteQueryMessage::data_indefinite_route_request(Some("nowhere.com".to_string()), 47) ); } @@ -2720,10 +2705,7 @@ mod tests { let record = recording.get_record::(0); assert_eq!( record, - &RouteQueryMessage::data_indefinite_route_request( - Some("nowhere.com".to_string()), - 47 - ) + &RouteQueryMessage::data_indefinite_route_request(Some("nowhere.com".to_string()), 47) ); TestLogHandler::new() .exists_log_containing("ERROR: ProxyServer: Failed to find route to nowhere.com"); @@ -2895,10 +2877,7 @@ mod tests { let record = recording.get_record::(0); assert_eq!( record, - &RouteQueryMessage::data_indefinite_route_request( - Some("nowhere.com".to_string()), - 47 - ) + &RouteQueryMessage::data_indefinite_route_request(Some("nowhere.com".to_string()), 47) ); TestLogHandler::new() .exists_log_containing("ERROR: ProxyServer: Failed to find route to nowhere.com"); diff --git a/node/src/sub_lib/neighborhood.rs b/node/src/sub_lib/neighborhood.rs index b9186732c..6fec349d0 100644 --- a/node/src/sub_lib/neighborhood.rs +++ b/node/src/sub_lib/neighborhood.rs @@ -482,8 +482,6 @@ impl Message for RouteQueryMessage { } impl RouteQueryMessage { - // Earlier min_hops_count was passed to this function and stored inside RouteQueryMessage - // TODO: GH-690: Make sure the entities using RouteQueryMessage can easily retieve the min_hops_count from Neighborhood pub fn data_indefinite_route_request( hostname_opt: Option, payload_size: usize, From 250614f3a7c3b4201390a449f2bfadacf45bd9b5 Mon Sep 17 00:00:00 2001 From: utkarshg6 Date: Fri, 5 May 2023 13:23:37 +0530 Subject: [PATCH 53/56] GH-690: formatting --- multinode_integration_tests/src/masq_real_node.rs | 4 ++-- node/src/actor_system_factory.rs | 2 +- node/src/bootstrapper.rs | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/multinode_integration_tests/src/masq_real_node.rs b/multinode_integration_tests/src/masq_real_node.rs index 2c02909fe..1027c329b 100644 --- a/multinode_integration_tests/src/masq_real_node.rs +++ b/multinode_integration_tests/src/masq_real_node.rs @@ -15,12 +15,13 @@ use masq_lib::test_utils::utils::TEST_DEFAULT_MULTINODE_CHAIN; use masq_lib::utils::localhost; use masq_lib::utils::{DEFAULT_CONSUMING_DERIVATION_PATH, DEFAULT_EARNING_DERIVATION_PATH}; use node_lib::blockchain::bip32::Bip32ECKeyProvider; +use node_lib::neighborhood::DEFAULT_MIN_HOPS_COUNT; use node_lib::sub_lib::accountant::{ PaymentThresholds, DEFAULT_EARNING_WALLET, DEFAULT_PAYMENT_THRESHOLDS, }; use node_lib::sub_lib::cryptde::{CryptDE, PublicKey}; use node_lib::sub_lib::cryptde_null::CryptDENull; -use node_lib::sub_lib::neighborhood::{RatePack, DEFAULT_RATE_PACK, ZERO_RATE_PACK, Hops}; +use node_lib::sub_lib::neighborhood::{Hops, RatePack, DEFAULT_RATE_PACK, ZERO_RATE_PACK}; use node_lib::sub_lib::node_addr::NodeAddr; use node_lib::sub_lib::wallet::Wallet; use regex::Regex; @@ -34,7 +35,6 @@ use std::str::FromStr; use std::string::ToString; use std::thread; use std::time::Duration; -use node_lib::neighborhood::DEFAULT_MIN_HOPS_COUNT; pub const DATA_DIRECTORY: &str = "/node_root/home"; pub const STANDARD_CLIENT_TIMEOUT_MILLIS: u64 = 1000; diff --git a/node/src/actor_system_factory.rs b/node/src/actor_system_factory.rs index cef49290a..537a0b3a5 100644 --- a/node/src/actor_system_factory.rs +++ b/node/src/actor_system_factory.rs @@ -630,6 +630,7 @@ mod tests { use crate::sub_lib::ui_gateway::UiGatewayConfig; use crate::test_utils::automap_mocks::{AutomapControlFactoryMock, AutomapControlMock}; use crate::test_utils::make_wallet; + use crate::test_utils::neighborhood_test_utils::MIN_HOPS_COUNT_FOR_TEST; use crate::test_utils::persistent_configuration_mock::PersistentConfigurationMock; use crate::test_utils::recorder::{ make_accountant_subs_from_recorder, make_blockchain_bridge_subs_from, @@ -678,7 +679,6 @@ mod tests { use std::sync::{Arc, Mutex}; use std::thread; use std::time::Duration; - use crate::test_utils::neighborhood_test_utils::MIN_HOPS_COUNT_FOR_TEST; struct LogRecipientSetterNull {} diff --git a/node/src/bootstrapper.rs b/node/src/bootstrapper.rs index 0f2237f66..31ff25f1c 100644 --- a/node/src/bootstrapper.rs +++ b/node/src/bootstrapper.rs @@ -732,6 +732,7 @@ mod tests { use crate::sub_lib::node_addr::NodeAddr; use crate::sub_lib::socket_server::ConfiguredByPrivilege; use crate::sub_lib::stream_connector::ConnectionInfo; + use crate::test_utils::neighborhood_test_utils::MIN_HOPS_COUNT_FOR_TEST; use crate::test_utils::persistent_configuration_mock::PersistentConfigurationMock; use crate::test_utils::recorder::make_recorder; use crate::test_utils::recorder::RecordAwaiter; @@ -770,7 +771,6 @@ mod tests { use tokio::executor::current_thread::CurrentThread; use tokio::prelude::stream::FuturesUnordered; use tokio::prelude::Async; - use crate::test_utils::neighborhood_test_utils::MIN_HOPS_COUNT_FOR_TEST; lazy_static! { pub static ref INITIALIZATION: Mutex = Mutex::new(false); From 02d77041e040d7c3463c4b0d0a73096ecac8c66d Mon Sep 17 00:00:00 2001 From: utkarshg6 Date: Fri, 5 May 2023 13:52:49 +0530 Subject: [PATCH 54/56] GH-690: allow clippy warning for from_over_into --- node/src/sub_lib/neighborhood.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/node/src/sub_lib/neighborhood.rs b/node/src/sub_lib/neighborhood.rs index 6fec349d0..be7e742a3 100644 --- a/node/src/sub_lib/neighborhood.rs +++ b/node/src/sub_lib/neighborhood.rs @@ -87,6 +87,7 @@ impl Display for NeighborhoodMode { } } +#[allow(clippy::from_over_into)] impl Into for &NeighborhoodMode { fn into(self) -> NeighborhoodModeLight { match self { From e9e4b255268e03824074dc1e79222241ef1b8fbd Mon Sep 17 00:00:00 2001 From: utkarshg6 Date: Fri, 5 May 2023 13:55:06 +0530 Subject: [PATCH 55/56] GH-690: disable console diagnostics --- node/src/daemon/setup_reporter.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/node/src/daemon/setup_reporter.rs b/node/src/daemon/setup_reporter.rs index f4de41a99..8a753bf05 100644 --- a/node/src/daemon/setup_reporter.rs +++ b/node/src/daemon/setup_reporter.rs @@ -43,7 +43,7 @@ use std::net::{IpAddr, Ipv4Addr}; use std::path::{Path, PathBuf}; use std::str::FromStr; -const CONSOLE_DIAGNOSTICS: bool = true; // TODO: set back to false +const CONSOLE_DIAGNOSTICS: bool = false; const ERR_SENSITIVE_BLANKED_OUT_VALUE_PAIRS: &[(&str, &str)] = &[("chain", "data-directory")]; @@ -1110,7 +1110,7 @@ mod tests { #[test] fn constants_have_correct_values() { - assert_eq!(CONSOLE_DIAGNOSTICS, true); + assert_eq!(CONSOLE_DIAGNOSTICS, false); } pub struct DnsInspectorMock { From b73238db26192cdbffc0513578b5a8625f7c82cf Mon Sep 17 00:00:00 2001 From: utkarshg6 Date: Fri, 5 May 2023 14:07:09 +0530 Subject: [PATCH 56/56] GH-690: improve expect message if pulling out min_hops_count fails --- .../unprivileged_parse_args_configuration.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/node/src/node_configurator/unprivileged_parse_args_configuration.rs b/node/src/node_configurator/unprivileged_parse_args_configuration.rs index 586cbf368..c4c640199 100644 --- a/node/src/node_configurator/unprivileged_parse_args_configuration.rs +++ b/node/src/node_configurator/unprivileged_parse_args_configuration.rs @@ -214,8 +214,8 @@ pub fn make_neighborhood_config( } }; - let min_hops_count = - value_m!(multi_config, "min-hops", Hops).expect("clap schema specifies no default"); // TODO: GH-690: Test Drive this panic + let min_hops_count = value_m!(multi_config, "min-hops", Hops) + .expect("Clap schema didn't specified the default value."); match make_neighborhood_mode(multi_config, neighbor_configs, persistent_config) { Ok(mode) => Ok(NeighborhoodConfig {