Merge branch 'update-master'

Author: dnwiebe

ci/publish_results.sh

@@ -52,9 +52,12 @@ cat README.md.clean | sed -n '/\(Results Marker\)/,$p' | tail -n+2 >> README.md
 
 mkdir -p "results/$RESULTS_LABEL"
 cp ../generated.tar.gz "results/$RESULTS_LABEL/$GENERATED_NAME.tar.gz"
-git add README.md "results/$RESULTS_LABEL/$GENERATED_NAME.tar.gz"
+git checkout --orphan new-master
+git add README.md results
 git commit -m "Latest results for $RESULTS_LABEL ($GENERATED_TYPE) - $STATUS"
-git pull
-git push
+git branch -D master
+git branch -M new-master master
+git checkout master
+git push -f -u origin HEAD
 
 popd

multinode_integration_tests/Cargo.toml

@@ -13,6 +13,7 @@ base64 = "0.10.1"
 ethereum-types = "0.6.0"
 ethsign-crypto = "0.1.0"
 futures = "0.1.28"
+itertools = "0.8.0"
 pretty-hex = "0.1.0"
 primitive-types = {version = "0.5.0", default-features = false, features = ["default", "rlp", "serde"] }
 regex = "1.2.1"

multinode_integration_tests/src/multinode_gossip.rs

@@ -1,14 +1,11 @@
 // Copyright (c) 2017-2019, Substratum LLC (https://substratum.net) and/or its affiliates. All rights reserved.
 use crate::substratum_node::SubstratumNode;
 use node_lib::neighborhood::gossip::{Gossip, GossipNodeRecord};
-use node_lib::neighborhood::node_record::NodeRecordInner;
 use node_lib::neighborhood::AccessibleGossipRecord;
-use node_lib::sub_lib::cryptde::CryptData;
-use node_lib::sub_lib::cryptde::PlainData;
 use node_lib::sub_lib::cryptde::PublicKey;
 use node_lib::sub_lib::cryptde_null::CryptDENull;
 use node_lib::test_utils::{vec_to_set, DEFAULT_CHAIN_ID};
-use std::collections::{BTreeSet, HashSet};
+use std::collections::HashSet;
 use std::convert::{TryFrom, TryInto};
 use std::net::IpAddr;
 
@@ -383,24 +380,3 @@ fn nodes_of_degree(nodes: &Vec<AccessibleGossipRecord>, degree: usize) -> Vec<Pu
         .map(|node| node.inner.public_key.clone())
         .collect::<Vec<PublicKey>>()
 }
-
-impl From<&dyn SubstratumNode> for AccessibleGossipRecord {
-    fn from(substratum_node: &dyn SubstratumNode) -> Self {
-        let cryptde = substratum_node.signing_cryptde().unwrap_or_else (|| panic! ("You can only make an AccessibleGossipRecord from a SubstratumRealNode if it has a CryptDENull, not a CryptDEReal."));
-        let mut agr = AccessibleGossipRecord {
-            inner: NodeRecordInner {
-                data_version: NodeRecordInner::data_version(),
-                public_key: substratum_node.public_key().clone(),
-                earning_wallet: substratum_node.earning_wallet(),
-                rate_pack: substratum_node.rate_pack(),
-                neighbors: BTreeSet::new(),
-                version: 0,
-            },
-            node_addr_opt: Some(substratum_node.node_addr()),
-            signed_gossip: PlainData::new(b""),
-            signature: CryptData::new(b""),
-        };
-        agr.regenerate_signed_gossip(cryptde);
-        agr
-    }
-}

multinode_integration_tests/src/neighborhood_constructor.rs

@@ -6,15 +6,13 @@ use crate::substratum_node::SubstratumNode;
 use crate::substratum_node_cluster::SubstratumNodeCluster;
 use crate::substratum_real_node::SubstratumRealNode;
 use crate::substratum_real_node::{make_consuming_wallet_info, NodeStartupConfigBuilder};
-use node_lib::blockchain::blockchain_interface::chain_id_from_name;
 use node_lib::neighborhood::gossip::Gossip;
 use node_lib::neighborhood::gossip_producer::{GossipProducer, GossipProducerReal};
 use node_lib::neighborhood::neighborhood_database::NeighborhoodDatabase;
 use node_lib::neighborhood::neighborhood_test_utils::db_from_node;
-use node_lib::neighborhood::node_record::{NodeRecord, NodeRecordInner, NodeRecordMetadata};
-use node_lib::sub_lib::cryptde::{CryptData, PlainData, PublicKey};
-use node_lib::sub_lib::cryptde_null::CryptDENull;
-use node_lib::test_utils::DEFAULT_CHAIN_ID;
+use node_lib::neighborhood::node_record::{NodeRecord, NodeRecordMetadata};
+use node_lib::neighborhood::AccessibleGossipRecord;
+use node_lib::sub_lib::cryptde::PublicKey;
 use std::collections::{BTreeSet, HashMap};
 use std::convert::TryInto;
 use std::time::Duration;
@@ -239,29 +237,15 @@ impl From<&SubstratumRealNode> for NodeRecord {
 }
 
 fn from_substratum_node_to_node_record(substratum_node: &dyn SubstratumNode) -> NodeRecord {
-    let mut result = NodeRecord {
-        inner: NodeRecordInner {
-            data_version: NodeRecordInner::data_version(),
-            public_key: substratum_node.public_key().clone(),
-            earning_wallet: substratum_node.earning_wallet(),
-            rate_pack: substratum_node.rate_pack(),
-            neighbors: BTreeSet::new(),
-            version: 0,
-        },
+    let agr = AccessibleGossipRecord::from(substratum_node);
+    let result = NodeRecord {
+        inner: agr.inner.clone(),
         metadata: NodeRecordMetadata {
             desirable: true,
-            node_addr_opt: Some(substratum_node.node_addr()),
+            node_addr_opt: agr.node_addr_opt.clone(),
         },
-        signed_gossip: PlainData::new(b""),
-        signature: CryptData::new(b""),
+        signed_gossip: agr.signed_gossip.clone(),
+        signature: agr.signature.clone(),
     };
-    let cryptde = CryptDENull::from(
-        substratum_node.public_key(),
-        substratum_node
-            .chain()
-            .map(|chain_name| chain_id_from_name(chain_name.as_str()))
-            .unwrap_or(DEFAULT_CHAIN_ID),
-    );
-    result.regenerate_signed_gossip(&cryptde);
     result
 }

multinode_integration_tests/src/substratum_cores_server.rs

@@ -132,7 +132,10 @@ impl SubstratumCoresServer {
     pub fn node_reference(&self) -> NodeReference {
         NodeReference {
             public_key: self.cryptde.public_key().clone(),
-            node_addr: NodeAddr::new(&self.socket_addr.ip(), &vec![self.socket_addr.port()]),
+            node_addr_opt: Some(NodeAddr::new(
+                &self.socket_addr.ip(),
+                &vec![self.socket_addr.port()],
+            )),
         }
     }
 
@@ -144,8 +147,8 @@ impl SubstratumCoresServer {
         self.node_reference().public_key.clone()
     }
 
-    pub fn node_addr(&self) -> NodeAddr {
-        self.node_reference().node_addr.clone()
+    pub fn node_addr_opt(&self) -> Option<NodeAddr> {
+        self.node_reference().node_addr_opt.clone()
     }
 
     pub fn private_key(&self) -> &PrivateKey {

multinode_integration_tests/src/substratum_mock_node.rs

@@ -65,7 +65,7 @@ impl SubstratumNode for SubstratumMockNode {
     fn node_reference(&self) -> NodeReference {
         NodeReference::new(
             self.signing_cryptde().unwrap().public_key().clone(),
-            self.node_addr().ip_addr(),
+            Some(self.node_addr().ip_addr()),
             self.node_addr().ports(),
         )
     }
@@ -119,6 +119,14 @@ impl SubstratumNode for SubstratumMockNode {
     fn chain(&self) -> Option<String> {
         self.guts.chain.clone()
     }
+
+    fn accepts_connections(&self) -> bool {
+        true // just a guess
+    }
+
+    fn routes_data(&self) -> bool {
+        true // just a guess
+    }
 }
 
 impl SubstratumMockNode {
@@ -343,7 +351,7 @@ impl SubstratumMockNode {
         match self.wait_for_package(&masquerader, timeout) {
             Ok((from, _, package)) => {
                 let incoming_cores_package = package
-                    .to_expired(from.ip(), self.signing_cryptde().unwrap())
+                    .to_expired(from, self.signing_cryptde().unwrap())
                     .unwrap();
                 match incoming_cores_package.payload {
                     MessageType::Gossip(g) => Some((g, from.ip())),

multinode_integration_tests/src/substratum_node.rs

@@ -28,7 +28,7 @@ use std::time::Instant;
 #[derive(PartialEq, Clone, Debug)]
 pub struct NodeReference {
     pub public_key: PublicKey,
-    pub node_addr: NodeAddr,
+    pub node_addr_opt: Option<NodeAddr>,
 }
 
 impl FromStr for NodeReference {
@@ -49,14 +49,19 @@ impl FromStr for NodeReference {
 impl fmt::Display for NodeReference {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let public_key_string = base64::encode_config(&self.public_key.as_slice(), STANDARD_NO_PAD);
-        let ip_addr_string = format!("{}", self.node_addr.ip_addr());
-        let port_list_string = self
-            .node_addr
-            .ports()
-            .iter()
-            .map(|port| port.to_string())
-            .collect::<Vec<String>>()
-            .join(",");
+        let ip_addr_string = match &self.node_addr_opt {
+            Some(node_addr) => format!("{}", node_addr.ip_addr()),
+            None => String::new(),
+        };
+        let port_list_string = match &self.node_addr_opt {
+            Some(node_addr) => node_addr
+                .ports()
+                .iter()
+                .map(|port| port.to_string())
+                .collect::<Vec<String>>()
+                .join(","),
+            None => String::new(),
+        };
         write!(
             f,
             "{}:{}:{}",
@@ -68,10 +73,20 @@ impl fmt::Display for NodeReference {
 }
 
 impl NodeReference {
-    pub fn new(public_key: PublicKey, ip_addr: IpAddr, ports: Vec<u16>) -> NodeReference {
-        NodeReference {
-            public_key,
-            node_addr: NodeAddr::new(&ip_addr, &ports),
+    pub fn new(
+        public_key: PublicKey,
+        ip_addr_opt: Option<IpAddr>,
+        ports: Vec<u16>,
+    ) -> NodeReference {
+        match ip_addr_opt {
+            Some(ip_addr) => NodeReference {
+                public_key,
+                node_addr_opt: Some(NodeAddr::new(&ip_addr, &ports)),
+            },
+            None => NodeReference {
+                public_key,
+                node_addr_opt: None,
+            },
         }
     }
 
@@ -82,14 +97,18 @@ impl NodeReference {
         }
     }
 
-    fn extract_ip_addr(slice: &str) -> Result<IpAddr, String> {
-        match IpAddr::from_str(slice) {
-            Ok(ip_addr) => Ok(ip_addr),
-            Err(_) => {
-                return Err(format!(
-                    "The IP address of a NodeReference must be valid, not '{}'",
-                    slice
-                ));
+    fn extract_ip_addr(slice: &str) -> Result<Option<IpAddr>, String> {
+        if slice.is_empty() {
+            Ok(None)
+        } else {
+            match IpAddr::from_str(slice) {
+                Ok(ip_addr) => Ok(Some(ip_addr)),
+                Err(_) => {
+                    return Err(format!(
+                        "The IP address of a NodeReference must be valid, not '{}'",
+                        slice
+                    ));
+                }
             }
         }
     }
@@ -159,6 +178,8 @@ pub trait SubstratumNode: Any {
     fn rate_pack(&self) -> RatePack;
     // Valid values are "dev, "ropsten" for now. Add "mainnet" when it's time.
     fn chain(&self) -> Option<String>;
+    fn accepts_connections(&self) -> bool;
+    fn routes_data(&self) -> bool;
 }
 
 pub struct SubstratumNodeUtils {}
@@ -319,8 +340,11 @@ mod tests {
 
         assert_eq!(result.public_key, key);
         assert_eq!(
-            result.node_addr,
-            NodeAddr::new(&IpAddr::from_str("12.34.56.78").unwrap(), &vec!(1234, 2345))
+            result.node_addr_opt,
+            Some(NodeAddr::new(
+                &IpAddr::from_str("12.34.56.78").unwrap(),
+                &vec!(1234, 2345)
+            ))
         );
     }
 
@@ -333,16 +357,19 @@ mod tests {
 
         assert_eq!(result.public_key, key);
         assert_eq!(
-            result.node_addr,
-            NodeAddr::new(&IpAddr::from_str("12.34.56.78").unwrap(), &vec!())
+            result.node_addr_opt,
+            Some(NodeAddr::new(
+                &IpAddr::from_str("12.34.56.78").unwrap(),
+                &vec!()
+            ))
         );
     }
 
     #[test]
     fn node_reference_can_display_itself() {
         let subject = NodeReference::new(
             PublicKey::new(&b"Booga"[..]),
-            IpAddr::from_str("12.34.56.78").unwrap(),
+            Some(IpAddr::from_str("12.34.56.78").unwrap()),
             vec![1234, 5678],
         );