GH-598: merged master in

Author: Bert

masq/src/command_factory.rs

@@ -11,6 +11,7 @@ use crate::commands::descriptor_command::DescriptorCommand;
 use crate::commands::exit_location_command::SetExitLocationCommand;
 use crate::commands::financials_command::FinancialsCommand;
 use crate::commands::generate_wallets_command::GenerateWalletsCommand;
+use crate::commands::neighborhood_graph_command::GetNeighborhoodGraphCommand;
 use crate::commands::recover_wallets_command::RecoverWalletsCommand;
 use crate::commands::scan_command::ScanCommand;
 use crate::commands::set_configuration_command::SetConfigurationCommand;
@@ -65,6 +66,10 @@ impl CommandFactory for CommandFactoryReal {
                 Ok(command) => Box::new(command),
                 Err(msg) => return Err(CommandSyntax(msg)),
             },
+            "neighborhood-graph" => match GetNeighborhoodGraphCommand::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)),
@@ -292,6 +297,21 @@ mod tests {
         );
     }
 
+    #[test]
+    fn factory_produces_neighborhood_graph() {
+        let subject = CommandFactoryReal::new();
+
+        let command = subject.make(&["neighborhood-graph".to_string()]).unwrap();
+
+        assert_eq!(
+            command
+                .as_any()
+                .downcast_ref::<GetNeighborhoodGraphCommand>()
+                .unwrap(),
+            &GetNeighborhoodGraphCommand {}
+        );
+    }
+
     #[test]
     fn complains_about_set_configuration_command_with_no_parameters() {
         let subject = CommandFactoryReal::new();

masq/src/commands/mod.rs

@@ -17,3 +17,5 @@ pub mod setup_command;
 pub mod shutdown_command;
 pub mod start_command;
 pub mod wallet_addresses_command;
+
+pub mod neighborhood_graph_command;

masq/src/commands/neighborhood_graph_command.rs

@@ -0,0 +1,93 @@
+use clap::{App, SubCommand};
+use masq_lib::{as_any_ref_in_trait_impl, short_writeln};
+
+use crate::command_context::CommandContext;
+use crate::commands::commands_common::CommandError::Payload;
+use crate::commands::commands_common::{
+    transaction, Command, CommandError, STANDARD_COMMAND_TIMEOUT_MILLIS,
+};
+use masq_lib::messages::{UiGetNeighborhoodGraphRequest, UiGetNeighborhoodGraphResponse};
+
+const NEIGHBORHOOD_GRAPH_HELP: &str = "Use this command plainly, without any flags or arguments. The result will be delivered in digraph format, documentation at https://graphviz.org/documentation/";
+
+pub fn get_neighborhood_graph_subcommand() -> App<'static, 'static> {
+    SubCommand::with_name("neighborhood-graph").about(NEIGHBORHOOD_GRAPH_HELP)
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct GetNeighborhoodGraphCommand {}
+
+impl GetNeighborhoodGraphCommand {
+    pub fn new(pieces: &[String]) -> Result<Self, String> {
+        match get_neighborhood_graph_subcommand().get_matches_from_safe(pieces) {
+            Ok(_) => Ok(GetNeighborhoodGraphCommand {}),
+            Err(e) => Err(format!("GetNeighborhoodGraphCommand {}", e)),
+        }
+    }
+}
+
+impl Command for GetNeighborhoodGraphCommand {
+    fn execute(&self, context: &mut dyn CommandContext) -> Result<(), CommandError> {
+        let input = UiGetNeighborhoodGraphRequest {};
+        let output: Result<UiGetNeighborhoodGraphResponse, CommandError> =
+            transaction(input, context, STANDARD_COMMAND_TIMEOUT_MILLIS);
+        match output {
+            Ok(neighborhood_graph) => {
+                short_writeln!(
+                    context.stdout(),
+                    "Graph of the Node's neighborhood database: {}",
+                    neighborhood_graph.graph.as_str()
+                );
+                Ok(())
+            }
+            Err(Payload(code, message)) => {
+                short_writeln!(context.stderr(), "code: {}\nmessage: {}", code, message);
+                Err(Payload(code, message))
+            }
+            Err(err) => {
+                short_writeln!(context.stderr(), "Error: {}", err);
+                Err(err)
+            }
+        }
+    }
+
+    as_any_ref_in_trait_impl!();
+}
+
+#[cfg(test)]
+pub mod tests {
+    use super::*;
+    use crate::test_utils::mocks::CommandContextMock;
+    use masq_lib::messages::ToMessageBody;
+    use std::sync::{Arc, Mutex};
+
+    #[test]
+    fn can_deserialize_ui_get_neighborhood_graph() {
+        let transact_params_arc = Arc::new(Mutex::new(vec![]));
+        let mut context = CommandContextMock::new()
+            .transact_params(&transact_params_arc)
+            .transact_result(Ok(UiGetNeighborhoodGraphResponse {
+                graph: "digraph db { \"AQIDBA\" [label=\"AR v0 AU\\nAQIDBA\\n1.2.3.4:1234\"]; \"HZ5vwwJPhfUZVy85E76GZUUam9SMgyaw+QaZvAMuizo\" [label=\"AR v0 ZZ\\nHZ5vwwJP\\n9.9.9.9:9999\"] [style=filled]; \"AgMEBQ\" [label=\"AR v0 FR\\nAgMEBQ\\n2.3.4.5:2345\"]; \"AwQFBg\" [label=\"AR v0 CN\\nAwQFBg\\n3.4.5.6:3456\"]; \"BAUGBw\" [label=\"AR v0 US\\nBAUGBw\\n4.5.6.7:4567\"]; \"AQIDBA\" -> \"HZ5vwwJPhfUZVy85E76GZUUam9SMgyaw+QaZvAMuizo\"; \"AQIDBA\" -> \"AgMEBQ\"; \"HZ5vwwJPhfUZVy85E76GZUUam9SMgyaw+QaZvAMuizo\" -> \"AQIDBA\"; \"AgMEBQ\" -> \"AwQFBg\"; \"AgMEBQ\" -> \"AQIDBA\"; \"AwQFBg\" -> \"BAUGBw\"; \"AwQFBg\" -> \"AgMEBQ\"; \"BAUGBw\" -> \"AwQFBg\"; }".to_string()
+            }.tmb(0)));
+        let stderr_arc = context.stderr_arc();
+        let stdout_arc = context.stdout_arc();
+        let subject =
+            GetNeighborhoodGraphCommand::new(&["neighborhood-graph".to_string()]).unwrap();
+
+        let result = subject.execute(&mut context);
+
+        assert_eq!(result, Ok(()));
+        let expected_request = UiGetNeighborhoodGraphRequest {};
+        let transact_params = transact_params_arc.lock().unwrap();
+        let expected_message_body = expected_request.tmb(0);
+        assert_eq!(
+            transact_params.as_slice(),
+            &[(expected_message_body, STANDARD_COMMAND_TIMEOUT_MILLIS)]
+        );
+        let stdout = stdout_arc.lock().unwrap();
+        let graph_str = "Graph of the Node's neighborhood database: digraph db { \"AQIDBA\" [label=\"AR v0 AU\\nAQIDBA\\n1.2.3.4:1234\"]; \"HZ5vwwJPhfUZVy85E76GZUUam9SMgyaw+QaZvAMuizo\" [label=\"AR v0 ZZ\\nHZ5vwwJP\\n9.9.9.9:9999\"] [style=filled]; \"AgMEBQ\" [label=\"AR v0 FR\\nAgMEBQ\\n2.3.4.5:2345\"]; \"AwQFBg\" [label=\"AR v0 CN\\nAwQFBg\\n3.4.5.6:3456\"]; \"BAUGBw\" [label=\"AR v0 US\\nBAUGBw\\n4.5.6.7:4567\"]; \"AQIDBA\" -> \"HZ5vwwJPhfUZVy85E76GZUUam9SMgyaw+QaZvAMuizo\"; \"AQIDBA\" -> \"AgMEBQ\"; \"HZ5vwwJPhfUZVy85E76GZUUam9SMgyaw+QaZvAMuizo\" -> \"AQIDBA\"; \"AgMEBQ\" -> \"AwQFBg\"; \"AgMEBQ\" -> \"AQIDBA\"; \"AwQFBg\" -> \"BAUGBw\"; \"AwQFBg\" -> \"AgMEBQ\"; \"BAUGBw\" -> \"AwQFBg\"; }\n";
+        assert_eq!(&stdout.get_string(), graph_str);
+        let stderr = stderr_arc.lock().unwrap();
+        assert_eq!(&stderr.get_string(), "");
+    }
+}

masq/src/schema.rs

@@ -11,6 +11,7 @@ use crate::commands::descriptor_command::descriptor_subcommand;
 use crate::commands::exit_location_command::exit_location_subcommand;
 use crate::commands::financials_command::args_validation::financials_subcommand;
 use crate::commands::generate_wallets_command::generate_wallets_subcommand;
+use crate::commands::neighborhood_graph_command::get_neighborhood_graph_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;
@@ -71,6 +72,7 @@ pub fn app() -> App<'static, 'static> {
         .subcommand(exit_location_subcommand())
         .subcommand(financials_subcommand())
         .subcommand(generate_wallets_subcommand())
+        .subcommand(get_neighborhood_graph_subcommand())
         .subcommand(recover_wallets_subcommand())
         .subcommand(scan_subcommand())
         .subcommand(set_configuration_subcommand())

masq_lib/src/blockchains/chains.rs

@@ -7,6 +7,7 @@ use crate::constants::{
     POLYGON_AMOY_FULL_IDENTIFIER, POLYGON_MAINNET_FULL_IDENTIFIER,
 };
 use serde_derive::{Deserialize, Serialize};
+use std::fmt::{Display, Formatter};
 
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub enum Chain {
@@ -47,6 +48,21 @@ impl From<&str> for Chain {
     }
 }
 
+impl Display for Chain {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let chain_name = match self {
+            Chain::EthMainnet => ETH_MAINNET_FULL_IDENTIFIER,
+            Chain::EthRopsten => ETH_ROPSTEN_FULL_IDENTIFIER,
+            Chain::PolyMainnet => POLYGON_MAINNET_FULL_IDENTIFIER,
+            Chain::PolyAmoy => POLYGON_AMOY_FULL_IDENTIFIER,
+            Chain::BaseMainnet => BASE_MAINNET_FULL_IDENTIFIER,
+            Chain::BaseSepolia => BASE_SEPOLIA_FULL_IDENTIFIER,
+            Chain::Dev => DEV_CHAIN_FULL_IDENTIFIER,
+        };
+        write!(f, "{}", chain_name)
+    }
+}
+
 impl Chain {
     pub fn rec(&self) -> &BlockchainRecord {
         CHAINS
@@ -160,6 +176,37 @@ mod tests {
         })
     }
 
+    #[test]
+    fn display_is_properly_implemented() {
+        let chains = [
+            Chain::EthMainnet,
+            Chain::EthRopsten,
+            Chain::PolyMainnet,
+            Chain::PolyAmoy,
+            Chain::BaseMainnet,
+            Chain::BaseSepolia,
+            Chain::Dev,
+        ];
+
+        let strings = chains
+            .iter()
+            .map(|chain| chain.to_string())
+            .collect::<Vec<_>>();
+
+        assert_eq!(
+            strings,
+            vec![
+                ETH_MAINNET_FULL_IDENTIFIER.to_string(),
+                ETH_ROPSTEN_FULL_IDENTIFIER.to_string(),
+                POLYGON_MAINNET_FULL_IDENTIFIER.to_string(),
+                POLYGON_AMOY_FULL_IDENTIFIER.to_string(),
+                BASE_MAINNET_FULL_IDENTIFIER.to_string(),
+                BASE_SEPOLIA_FULL_IDENTIFIER.to_string(),
+                DEV_CHAIN_FULL_IDENTIFIER.to_string(),
+            ]
+        );
+    }
+
     fn assert_mainnet_exist() {
         assert!(CHAINS
             .iter()

masq_lib/src/constants.rs

@@ -5,7 +5,7 @@ use crate::data_version::DataVersion;
 use const_format::concatcp;
 
 pub const DEFAULT_CHAIN: Chain = Chain::PolyMainnet;
-pub const CURRENT_SCHEMA_VERSION: usize = 11;
+pub const CURRENT_SCHEMA_VERSION: usize = 12;
 
 pub const HIGHEST_RANDOM_CLANDESTINE_PORT: u16 = 9999;
 pub const HTTP_PORT: u16 = 80;

masq_lib/src/messages.rs

@@ -911,6 +911,18 @@ pub struct UiSetExitLocationResponse {
 }
 conversation_message!(UiSetExitLocationResponse, "exitLocation");
 
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
+pub struct UiGetNeighborhoodGraphRequest {}
+
+conversation_message!(UiGetNeighborhoodGraphRequest, "neighborhoodGraph");
+
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
+pub struct UiGetNeighborhoodGraphResponse {
+    pub graph: String,
+}
+
+conversation_message!(UiGetNeighborhoodGraphResponse, "neighborhoodGraph");
+
 #[cfg(test)]
 mod tests {
     use super::*;

masq_lib/src/test_utils/environment_guard.rs

@@ -3,9 +3,11 @@
 use lazy_static::lazy_static;
 use std::ffi::OsString;
 use std::sync::{Mutex, MutexGuard};
+use std::thread::ThreadId;
 
 lazy_static! {
     static ref ENVIRONMENT_GUARD_MUTEX: Mutex<()> = Mutex::new(());
+    static ref ENVIRONMENT_GUARD_THREAD_ID: Mutex<Option<ThreadId>> = Mutex::new(None);
     static ref CLAP_GUARD_MUTEX: Mutex<()> = Mutex::new(());
     static ref LOGFILE_NAME_GUARD_MUTEX: Mutex<()> = Mutex::new(());
 }
@@ -17,10 +19,9 @@ pub struct ConcurrencyPreventer<'a> {
 impl<'a> ConcurrencyPreventer<'a> {
     pub fn new(mutex: &'a Mutex<()>) -> ConcurrencyPreventer<'a> {
         ConcurrencyPreventer {
-            _lock: match mutex.lock() {
-                Ok(guard) => guard,
-                Err(poisoned) => poisoned.into_inner(),
-            },
+            _lock: mutex
+                .lock()
+                .unwrap_or_else(|poisoned| poisoned.into_inner()),
         }
     }
 }
@@ -43,16 +44,50 @@ impl<'a> Drop for EnvironmentGuard<'a> {
         self.environment
             .iter()
             .for_each(|(name, value)| std::env::set_var(name, value));
+        let mut thread_id_guard = ENVIRONMENT_GUARD_THREAD_ID
+            .lock()
+            .unwrap_or_else(|e| e.into_inner());
+        *thread_id_guard = None; // Clear the thread ID guard
     }
 }
 
 impl<'a> EnvironmentGuard<'a> {
     pub fn new() -> EnvironmentGuard<'a> {
-        EnvironmentGuard {
-            _preventer: ConcurrencyPreventer::new(&ENVIRONMENT_GUARD_MUTEX),
-            environment: std::env::vars_os().collect(),
+        // TODO: Consider a #[cfg(not(test))] line here to panic if production code tries this
+        loop {
+            {
+                let mut thread_id_guard = Self::thread_id_guard();
+                let current_thread_id = std::thread::current().id();
+                match *thread_id_guard {
+                    Some(id) => {
+                        if id == current_thread_id {
+                            panic!(
+                                "Thread {:?} is trying to claim multiple EnvironmentGuards",
+                                current_thread_id
+                            );
+                        }
+                    }
+                    None => {
+                        // Set thread ID, claim environment guard, release thread ID lock
+                        *thread_id_guard = Some(current_thread_id);
+                        return EnvironmentGuard {
+                            _preventer: ConcurrencyPreventer::new(&ENVIRONMENT_GUARD_MUTEX),
+                            environment: std::env::vars_os().collect(),
+                        };
+                    }
+                }
+            }
+            // Somebody else has the EnvironmentGuard. We've released the thread ID lock; now
+            // wait for a little while and try again.
+            std::thread::sleep(std::time::Duration::from_millis(10));
         }
     }
+
+    pub fn thread_id_guard() -> MutexGuard<'a, Option<ThreadId>> {
+        ENVIRONMENT_GUARD_THREAD_ID
+            .lock()
+            .unwrap_or_else(|poisoned| poisoned.into_inner())
+    }
 }
 
 impl<'a> Default for EnvironmentGuard<'a> {

multinode_integration_tests/src/masq_node_server.rs

@@ -2,23 +2,24 @@
 
 use crate::masq_node_cluster::DockerHostSocketAddr;
 use crate::utils;
-use std::io;
+use crossbeam_channel::{unbounded, Receiver, Sender};
 use std::net::{Shutdown, SocketAddr, TcpListener, TcpStream};
 use std::time::Duration;
+use std::{io, thread};
 
 pub struct MASQNodeServer {
+    docker_host_addr: Option<DockerHostSocketAddr>,
     local_addr: SocketAddr,
-    listener: TcpListener,
     stream_opt: Option<TcpStream>,
 }
 
 impl MASQNodeServer {
     pub fn new(port: u16) -> MASQNodeServer {
-        let socket_addr = DockerHostSocketAddr::new(port);
-        let listener = TcpListener::bind(socket_addr).unwrap();
+        let dummy_listener = TcpListener::bind(DockerHostSocketAddr::new(port)).unwrap();
+        let local_addr = dummy_listener.local_addr().unwrap();
         MASQNodeServer {
-            local_addr: listener.local_addr().unwrap(),
-            listener,
+            docker_host_addr: Some(DockerHostSocketAddr::new(port)),
+            local_addr,
             stream_opt: None,
         }
     }
@@ -37,10 +38,17 @@ impl MASQNodeServer {
     pub fn wait_for_chunk(&mut self, duration: Duration) -> Result<Vec<u8>, io::Error> {
         match &mut self.stream_opt {
             None => {
-                let (stream, _) = self.listener.accept().unwrap();
-                stream
-                    .set_read_timeout(Some(Duration::from_millis(250)))
-                    .unwrap();
+                let (tx, rx): (Sender<TcpStream>, Receiver<TcpStream>) = unbounded();
+                let local_addr = self.docker_host_addr.take().unwrap();
+                let listener = TcpListener::bind(local_addr).unwrap();
+                thread::spawn(move || {
+                    let (stream, _) = listener.accept().unwrap();
+                    stream
+                        .set_read_timeout(Some(Duration::from_millis(250)))
+                        .unwrap();
+                    tx.send(stream).unwrap();
+                });
+                let stream = rx.recv_timeout(duration).unwrap();
                 self.stream_opt = Some(stream);
                 self.wait_for_chunk(duration)
             }