GH-633: Optimise routing to reduce DNS resolution 'mark'

multinode_integration_tests/src/masq_mock_node.rs

@@ -36,12 +36,15 @@ use std::net::SocketAddr;
 use std::net::TcpStream;
 use std::net::{IpAddr, Shutdown};
 use std::ops::Add;
+use std::rc::Rc;
 use std::thread;
 use std::time::{Duration, Instant};
 
 pub struct MASQMockNode {
     control_stream: RefCell<TcpStream>,
-    guts: MASQMockNodeGuts,
+    //keep this smart pointer because any drop() called on a clone of the naked structure
+    //would stop the Docker container for this Node...or redesign...
+    guts: Rc<MASQMockNodeGuts>,
 }
 
 enum CryptDEEnum {
@@ -53,7 +56,7 @@ impl Clone for MASQMockNode {
     fn clone(&self) -> Self {
         MASQMockNode {
             control_stream: RefCell::new(self.control_stream.borrow().try_clone().unwrap()),
-            guts: self.guts.clone(),
+            guts: Rc::clone(&self.guts),
         }
     }
 }
@@ -142,14 +145,19 @@ impl MASQNode for MASQMockNode {
     }
 }
 
-impl MASQMockNode {
+pub struct ConfigurableMASQMockNode {
+    pub control_stream: RefCell<TcpStream>,
+    configurable_guts: MASQMockNodeGuts,
+}
+
+impl ConfigurableMASQMockNode {
     pub fn start_with_public_key(
         ports: Vec<u16>,
         index: usize,
         host_node_parent_dir: Option<String>,
         public_key: &PublicKey,
         chain: Chain,
-    ) -> MASQMockNode {
+    ) -> ConfigurableMASQMockNode {
         let main_cryptde = CryptDENull::from(public_key, chain);
         let mut key = public_key.as_slice().to_vec();
         key.reverse();
@@ -163,7 +171,7 @@ impl MASQMockNode {
         index: usize,
         host_node_parent_dir: Option<String>,
         chain: Chain,
-    ) -> MASQMockNode {
+    ) -> ConfigurableMASQMockNode {
         let cryptde_enum = CryptDEEnum::Real(CryptDEReal::new(chain));
         Self::start_with_cryptde_enum(ports, index, host_node_parent_dir, cryptde_enum)
     }
@@ -173,17 +181,17 @@ impl MASQMockNode {
         index: usize,
         host_node_parent_dir: Option<String>,
         cryptde_enum: CryptDEEnum,
-    ) -> MASQMockNode {
+    ) -> ConfigurableMASQMockNode {
         let name = format!("mock_node_{}", index);
         let node_addr = NodeAddr::new(&IpAddr::V4(Ipv4Addr::new(172, 18, 1, index as u8)), &ports);
         let earning_wallet = make_wallet(format!("{}_earning", name).as_str());
         let consuming_wallet = Some(make_paying_wallet(format!("{}_consuming", name).as_bytes()));
         MASQNodeUtils::clean_up_existing_container(&name[..]);
-        Self::do_docker_run(&node_addr, host_node_parent_dir, &name);
+        MASQMockNode::do_docker_run(&node_addr, host_node_parent_dir, &name);
         let wait_addr = SocketAddr::new(node_addr.ip_addr(), CONTROL_STREAM_PORT);
-        let control_stream = RefCell::new(Self::wait_for_startup(wait_addr, &name));
+        let control_stream = RefCell::new(MASQMockNode::wait_for_startup(wait_addr, &name));
         let framer = RefCell::new(DataHunkFramer::new());
-        let guts = MASQMockNodeGuts {
+        let configurable_guts = MASQMockNodeGuts {
             name,
             node_addr,
             earning_wallet,
@@ -193,12 +201,27 @@ impl MASQMockNode {
             framer,
             chain: TEST_DEFAULT_MULTINODE_CHAIN,
         };
-        MASQMockNode {
+        ConfigurableMASQMockNode {
             control_stream,
-            guts,
+            configurable_guts,
         }
     }
 
+    pub fn absorb_configuration(&mut self, node_record: &NodeRecord) {
+        // Copy attributes from the NodeRecord into the MASQNode.
+        self.configurable_guts.earning_wallet = node_record.earning_wallet();
+        self.configurable_guts.rate_pack = *node_record.rate_pack();
+    }
+
+    pub fn finish_with_guts_pointer(self) -> MASQMockNode {
+        MASQMockNode {
+            control_stream: self.control_stream,
+            guts: Rc::new(self.configurable_guts),
+        }
+    }
+}
+
+impl MASQMockNode {
     pub fn cryptde_real(&self) -> Option<&CryptDEReal> {
         match &self.guts.cryptde_enum {
             CryptDEEnum::Fake(_) => None,
@@ -424,12 +447,6 @@ impl MASQMockNode {
         stream.shutdown(Shutdown::Both).unwrap();
     }
 
-    pub fn absorb_configuration(&mut self, node_record: &NodeRecord) {
-        // Copy attributes from the NodeRecord into the MASQNode.
-        self.guts.earning_wallet = node_record.earning_wallet();
-        self.guts.rate_pack = *node_record.rate_pack();
-    }
-
     fn do_docker_run(node_addr: &NodeAddr, host_node_parent_dir: Option<String>, name: &str) {
         let root = match host_node_parent_dir {
             Some(dir) => dir,
@@ -506,21 +523,3 @@ impl Drop for MASQMockNodeGuts {
         MASQNodeUtils::stop(self.name.as_str());
     }
 }
-
-impl Clone for MASQMockNodeGuts {
-    fn clone(&self) -> Self {
-        Self {
-            name: self.name.clone(),
-            node_addr: self.node_addr.clone(),
-            earning_wallet: self.earning_wallet.clone(),
-            consuming_wallet: self.consuming_wallet.clone(),
-            rate_pack: self.rate_pack,
-            cryptde_enum: match &self.cryptde_enum {
-                CryptDEEnum::Fake((m, a)) => CryptDEEnum::Fake((m.clone(), a.clone())),
-                CryptDEEnum::Real(_) => panic!("A mock Node with a real CryptDE? Seriously?"),
-            },
-            framer: self.framer.clone(),
-            chain: self.chain,
-        }
-    }
-}

multinode_integration_tests/src/masq_node_cluster.rs

@@ -1,6 +1,6 @@
 // Copyright (c) 2019, MASQ (https://masq.ai) and/or its affiliates. All rights reserved.
 use crate::command::Command;
-use crate::masq_mock_node::MASQMockNode;
+use crate::masq_mock_node::{ConfigurableMASQMockNode, MASQMockNode};
 use crate::masq_node::{MASQNode, MASQNodeUtils};
 use crate::masq_real_node::MASQRealNode;
 use crate::masq_real_node::NodeStartupConfig;
@@ -77,38 +77,58 @@ impl MASQNodeCluster {
     }
 
     pub fn start_mock_node_with_real_cryptde(&mut self, ports: Vec<u16>) -> MASQMockNode {
-        self.start_mock_node(ports, None)
+        let unfinished_node = self.start_configurable_mock_node(ports, None);
+        self.finish_mock_node(unfinished_node)
     }
 
     pub fn start_mock_node_with_public_key(
         &mut self,
         ports: Vec<u16>,
         public_key: &PublicKey,
     ) -> MASQMockNode {
-        self.start_mock_node(ports, Some(public_key))
+        let unfinished_node = self.start_configurable_mock_node(ports, Some(public_key));
+        self.finish_mock_node(unfinished_node)
     }
 
-    fn start_mock_node(
+    pub fn start_configurable_mock_node_with_public_key(
+        &mut self,
+        ports: Vec<u16>,
+        public_key: &PublicKey,
+    ) -> ConfigurableMASQMockNode {
+        self.start_configurable_mock_node(ports, Some(public_key))
+    }
+
+    fn start_configurable_mock_node(
         &mut self,
         ports: Vec<u16>,
         public_key_opt: Option<&PublicKey>,
-    ) -> MASQMockNode {
+    ) -> ConfigurableMASQMockNode {
         let index = self.next_index;
         self.next_index += 1;
-        let node = match public_key_opt {
-            Some(public_key) => MASQMockNode::start_with_public_key(
+        match public_key_opt {
+            Some(public_key) => ConfigurableMASQMockNode::start_with_public_key(
                 ports,
                 index,
                 self.host_node_parent_dir.clone(),
                 public_key,
                 self.chain,
             ),
-            None => {
-                MASQMockNode::start(ports, index, self.host_node_parent_dir.clone(), self.chain)
-            }
-        };
-        let name = node.name().to_string();
-        self.mock_nodes.insert(name.clone(), node);
+            None => ConfigurableMASQMockNode::start(
+                ports,
+                index,
+                self.host_node_parent_dir.clone(),
+                self.chain,
+            ),
+        }
+    }
+
+    pub fn finish_mock_node(
+        &mut self,
+        configurable_mock_node: ConfigurableMASQMockNode,
+    ) -> MASQMockNode {
+        let mock_node = configurable_mock_node.finish_with_guts_pointer();
+        let name = mock_node.name().to_string();
+        self.mock_nodes.insert(name.clone(), mock_node);
         self.mock_nodes.get(&name).unwrap().clone()
     }
 

multinode_integration_tests/src/neighborhood_constructor.rs

@@ -98,7 +98,9 @@ fn make_mock_node_map(
         .map(|node| (node.main_public_key().clone(), node))
         .collect::<HashMap<PublicKey, MASQMockNode>>();
     additional_keys_to_mock.iter().for_each(|key| {
-        let mock_node = cluster.start_mock_node_with_public_key(vec![10000], key);
+        let configurable_mock_node =
+            cluster.start_configurable_mock_node_with_public_key(vec![10000], key);
+        let mock_node = cluster.finish_mock_node(configurable_mock_node);
         let mock_node_key = mock_node.main_public_key().clone();
         mock_node_map.insert(mock_node_key, mock_node);
     });
@@ -187,8 +189,10 @@ fn form_mock_node_skeleton(
         .full_neighbor_keys(model_db)
         .into_iter()
         .map(|model_node_key| {
-            let mut node = cluster.start_mock_node_with_public_key(vec![10000], model_node_key);
-            node.absorb_configuration(model_db.node_by_key(model_node_key).unwrap());
+            let mut configurable_node =
+                cluster.start_configurable_mock_node_with_public_key(vec![10000], model_node_key);
+            configurable_node.absorb_configuration(model_db.node_by_key(model_node_key).unwrap());
+            let node = cluster.finish_mock_node(configurable_node);
             node.transmit_debut(real_node).unwrap();
             node.wait_for_gossip(Duration::from_secs(2)).unwrap();
             let standard_gossip = StandardBuilder::new()

multinode_integration_tests/tests/graph_connectivity_test.rs

@@ -36,8 +36,9 @@ fn graph_connects_but_does_not_over_connect() {
         })
         .collect::<Vec<MASQRealNode>>();
     let last_node = real_nodes.last().unwrap();
-    let mock_node =
-        cluster.start_mock_node_with_public_key(vec![10000], &PublicKey::new(&[1, 2, 3, 4]));
+    let configurable_mock_node = cluster
+        .start_configurable_mock_node_with_public_key(vec![10000], &PublicKey::new(&[1, 2, 3, 4]));
+    let mock_node = cluster.finish_mock_node(configurable_mock_node);
     let dont_count_these = vec![mock_node.main_public_key()];
     // Wait for Gossip to abate
     thread::sleep(Duration::from_millis(2000));
@@ -90,8 +91,9 @@ fn lots_of_stalled_nodes_dont_prevent_acceptance_of_new_node() {
     db.add_arbitrary_full_neighbor(root_node.public_key(), full_neighbor_key);
     let mut cluster = MASQNodeCluster::start().unwrap();
     let (_, root_node, _) = construct_neighborhood(&mut cluster, db, vec![]);
-    let new_node =
-        cluster.start_mock_node_with_public_key(vec![5050], &PublicKey::new(&[3, 4, 5, 6]));
+    let configurable_mock = cluster
+        .start_configurable_mock_node_with_public_key(vec![5050], &PublicKey::new(&[3, 4, 5, 6]));
+    let new_node = cluster.finish_mock_node(configurable_mock);
 
     new_node.transmit_debut(&root_node).unwrap();