tari-project · CjS77 · Apr 14, 2020 · Apr 11, 2020
diff --git a/comms/dht/src/dht.rs b/comms/dht/src/dht.rs
@@ -315,7 +315,7 @@ mod test {
     use futures::{channel::mpsc, StreamExt};
     use std::{sync::Arc, time::Duration};
     use tari_comms::{
-        message::{MessageExt, MessageFlags},
+        message::MessageExt,
         pipeline::SinkService,
         test_utils::mocks::create_connection_manager_mock,
         wrap_in_envelope_body,
@@ -354,11 +354,8 @@ mod test {
             msg.to_encoded_bytes().unwrap(),
             DhtMessageFlags::empty(),
         );
-        let inbound_message = make_comms_inbound_message(
-            &node_identity,
-            dht_envelope.to_encoded_bytes().unwrap().into(),
-            MessageFlags::empty(),
-        );
+        let inbound_message =
+            make_comms_inbound_message(&node_identity, dht_envelope.to_encoded_bytes().unwrap().into());
 
         let msg = {
             service.call(inbound_message).await.unwrap();
@@ -400,11 +397,8 @@ mod test {
         let ecdh_key = crypt::generate_ecdh_secret(node_identity.secret_key(), node_identity.public_key());
         let encrypted_bytes = crypt::encrypt(&ecdh_key, &msg.to_encoded_bytes().unwrap()).unwrap();
         let dht_envelope = make_dht_envelope(&node_identity, encrypted_bytes, DhtMessageFlags::ENCRYPTED);
-        let inbound_message = make_comms_inbound_message(
-            &node_identity,
-            dht_envelope.to_encoded_bytes().unwrap().into(),
-            MessageFlags::empty(),
-        );
+        let inbound_message =
+            make_comms_inbound_message(&node_identity, dht_envelope.to_encoded_bytes().unwrap().into());
 
         let msg = {
             service.call(inbound_message).await.unwrap();
@@ -460,11 +454,8 @@ mod test {
             .unwrap()
             .signature
             .clone();
-        let inbound_message = make_comms_inbound_message(
-            &node_identity,
-            dht_envelope.to_encoded_bytes().unwrap().into(),
-            MessageFlags::empty(),
-        );
+        let inbound_message =
+            make_comms_inbound_message(&node_identity, dht_envelope.to_encoded_bytes().unwrap().into());
 
         service.call(inbound_message).await.unwrap();
 
@@ -513,11 +504,8 @@ mod test {
             header.message_type = DhtMessageType::SafStoredMessages as i32;
             Some(header)
         });
-        let inbound_message = make_comms_inbound_message(
-            &node_identity,
-            dht_envelope.to_encoded_bytes().unwrap().into(),
-            MessageFlags::empty(),
-        );
+        let inbound_message =
+            make_comms_inbound_message(&node_identity, dht_envelope.to_encoded_bytes().unwrap().into());
 
         service.call(inbound_message).await.unwrap_err();
         // This seems like the best way to tell that an open channel is empty without the test blocking indefinitely

diff --git a/comms/dht/src/inbound/deserialize.rs b/comms/dht/src/inbound/deserialize.rs
@@ -132,7 +132,7 @@ mod test {
         test_utils::{make_comms_inbound_message, make_dht_envelope, make_node_identity, service_spy},
     };
     use futures::executor::block_on;
-    use tari_comms::message::{MessageExt, MessageFlags};
+    use tari_comms::message::MessageExt;
     use tari_test_utils::panic_context;
 
     #[test]
@@ -148,7 +148,6 @@ mod test {
         block_on(deserialize.call(make_comms_inbound_message(
             &node_identity,
             dht_envelope.to_encoded_bytes().unwrap().into(),
-            MessageFlags::empty(),
         )))
         .unwrap();
 

diff --git a/comms/dht/src/outbound/broadcast.rs b/comms/dht/src/outbound/broadcast.rs
@@ -43,7 +43,6 @@ use futures::{
 use log::*;
 use std::{sync::Arc, task::Poll};
 use tari_comms::{
-    message::MessageFlags,
     peer_manager::{NodeId, NodeIdentity, Peer},
     pipeline::PipelineError,
     types::CommsPublicKey,
@@ -433,15 +432,7 @@ where S: Service<DhtOutboundMessage, Response = (), Error = PipelineError>
         // Construct a MessageEnvelope for each recipient
         let messages = selected_peers
             .into_iter()
-            .map(|peer| {
-                DhtOutboundMessage::new(
-                    peer,
-                    dht_header.clone(),
-                    encryption.clone(),
-                    MessageFlags::NONE,
-                    body.clone(),
-                )
-            })
+            .map(|peer| DhtOutboundMessage::new(peer, dht_header.clone(), encryption.clone(), body.clone()))
             .collect::<Vec<_>>();
 
         Ok(messages)

diff --git a/comms/dht/src/outbound/encryption.rs b/comms/dht/src/outbound/encryption.rs
@@ -118,7 +118,6 @@ mod test {
     };
     use futures::executor::block_on;
     use tari_comms::{
-        message::MessageFlags,
         net_address::MultiaddressesWithStats,
         peer_manager::{NodeId, Peer, PeerFeatures, PeerFlags},
         types::CommsPublicKey,
@@ -146,7 +145,6 @@ mod test {
             ),
             make_dht_header(&node_identity, &body, DhtMessageFlags::empty()),
             OutboundEncryption::None,
-            MessageFlags::empty(),
             body.clone(),
         );
         block_on(encryption.call(msg)).unwrap();
@@ -177,7 +175,6 @@ mod test {
             ),
             make_dht_header(&node_identity, &body, DhtMessageFlags::ENCRYPTED),
             OutboundEncryption::EncryptFor(Box::new(CommsPublicKey::default())),
-            MessageFlags::empty(),
             body.clone(),
         );
         block_on(encryption.call(msg)).unwrap();

diff --git a/comms/dht/src/outbound/message.rs b/comms/dht/src/outbound/message.rs
@@ -26,11 +26,7 @@ use crate::{
 };
 use futures::channel::oneshot;
 use std::{fmt, fmt::Display};
-use tari_comms::{
-    message::{MessageFlags, MessageTag},
-    peer_manager::Peer,
-    types::CommsPublicKey,
-};
+use tari_comms::{message::MessageTag, peer_manager::Peer, types::CommsPublicKey};
 use tari_crypto::tari_utilities::hex::Hex;
 
 /// Determines if an outbound message should be Encrypted and, if so, for which public key
@@ -142,7 +138,6 @@ pub struct DhtOutboundMessage {
     pub tag: MessageTag,
     pub destination_peer: Peer,
     pub dht_header: DhtMessageHeader,
-    pub comms_flags: MessageFlags,
     pub encryption: OutboundEncryption,
     pub body: Vec<u8>,
 }
@@ -153,7 +148,6 @@ impl DhtOutboundMessage {
         destination_peer: Peer,
         dht_header: DhtMessageHeader,
         encryption: OutboundEncryption,
-        comms_flags: MessageFlags,
         body: Vec<u8>,
     ) -> Self
     {
@@ -162,7 +156,6 @@ impl DhtOutboundMessage {
             destination_peer,
             dht_header,
             encryption,
-            comms_flags,
             body,
         }
     }

diff --git a/comms/dht/src/outbound/serialize.rs b/comms/dht/src/outbound/serialize.rs
@@ -84,7 +84,6 @@ where S: Service<OutboundMessage, Response = (), Error = PipelineError>
             mut dht_header,
             body,
             destination_peer,
-            comms_flags,
             ..
         } = message;
 
@@ -115,12 +114,7 @@ where S: Service<OutboundMessage, Response = (), Error = PipelineError>
         let body = Bytes::from(envelope.to_encoded_bytes().map_err(PipelineError::from_debug)?);
 
         next_service
-            .oneshot(OutboundMessage::with_tag(
-                message.tag,
-                destination_peer.node_id,
-                comms_flags,
-                body,
-            ))
+            .oneshot(OutboundMessage::with_tag(message.tag, destination_peer.node_id, body))
             .await
     }
 }
@@ -154,7 +148,6 @@ mod test {
     use futures::executor::block_on;
     use prost::Message;
     use tari_comms::{
-        message::MessageFlags,
         net_address::MultiaddressesWithStats,
         peer_manager::{NodeId, Peer, PeerFeatures, PeerFlags},
         types::CommsPublicKey,
@@ -182,7 +175,6 @@ mod test {
             ),
             make_dht_header(&node_identity, &body, DhtMessageFlags::empty()),
             OutboundEncryption::None,
-            MessageFlags::empty(),
             body,
         );
         block_on(serialize.call(msg)).unwrap();

diff --git a/comms/dht/src/test_utils/makers.rs b/comms/dht/src/test_utils/makers.rs
@@ -27,7 +27,7 @@ use crate::{
 use rand::rngs::OsRng;
 use std::sync::Arc;
 use tari_comms::{
-    message::{InboundMessage, MessageEnvelopeHeader, MessageFlags},
+    message::InboundMessage,
     multiaddr::Multiaddr,
     peer_manager::{NodeIdentity, Peer, PeerFeatures, PeerFlags, PeerManager},
     types::CommsDatabase,
@@ -72,7 +72,7 @@ pub fn make_client_identity() -> Arc<NodeIdentity> {
     )
 }
 
-pub fn make_comms_inbound_message(node_identity: &NodeIdentity, message: Bytes, flags: MessageFlags) -> InboundMessage {
+pub fn make_comms_inbound_message(node_identity: &NodeIdentity, message: Bytes) -> InboundMessage {
     InboundMessage::new(
         Arc::new(Peer::new(
             node_identity.public_key().clone(),
@@ -82,11 +82,6 @@ pub fn make_comms_inbound_message(node_identity: &NodeIdentity, message: Bytes,
             PeerFeatures::COMMUNICATION_NODE,
             &[],
         )),
-        MessageEnvelopeHeader {
-            public_key: node_identity.public_key().clone(),
-            signature: Bytes::new(),
-            flags,
-        },
         message,
     )
 }

diff --git a/comms/examples/tor.rs b/comms/examples/tor.rs
@@ -112,7 +112,6 @@ async fn run() -> Result<(), Error> {
     outbound_tx1
         .send(OutboundMessage::new(
             comms_node2.node_identity().node_id().clone(),
-            Default::default(),
             Bytes::from_static(b"START"),
         ))
         .await?;
@@ -272,5 +271,5 @@ async fn start_ping_ponger(
 
 fn make_msg(node_id: &NodeId, msg: String) -> OutboundMessage {
     let msg = Bytes::copy_from_slice(msg.as_bytes());
-    OutboundMessage::new(node_id.clone(), Default::default(), msg)
+    OutboundMessage::new(node_id.clone(), msg)
 }
diff --git a/comms/src/builder/tests.rs b/comms/src/builder/tests.rs
@@ -206,7 +206,6 @@ async fn peer_to_peer_messaging() {
     for i in 0..NUM_MSGS {
         let outbound_msg = OutboundMessage::new(
             node_identity2.node_id().clone(),
-            Default::default(),
             format!("#{:0>3} - comms messaging is so hot right now!", i).into(),
         );
         outbound_tx1.send(outbound_msg).await.unwrap();
@@ -227,7 +226,6 @@ async fn peer_to_peer_messaging() {
     for i in 0..NUM_MSGS {
         let outbound_msg = OutboundMessage::new(
             node_identity1.node_id().clone(),
-            Default::default(),
             format!("#{:0>3} - comms messaging is so hot right now!", i).into(),
         );
         outbound_tx2.send(outbound_msg).await.unwrap();
@@ -295,7 +293,6 @@ async fn peer_to_peer_messaging_simultaneous() {
         for i in 0..NUM_MSGS {
             let outbound_msg = OutboundMessage::new(
                 node_identity2.node_id().clone(),
-                Default::default(),
                 format!("#{:0>3} - comms messaging is so hot right now!", i).into(),
             );
             outbound_tx1.send(outbound_msg).await.unwrap();
@@ -306,7 +303,6 @@ async fn peer_to_peer_messaging_simultaneous() {
         for i in 0..NUM_MSGS {
             let outbound_msg = OutboundMessage::new(
                 node_identity1.node_id().clone(),
-                Default::default(),
                 format!("#{:0>3} - comms messaging is so hot right now!", i).into(),
             );
             outbound_tx2.send(outbound_msg).await.unwrap();

diff --git a/comms/src/consts.rs b/comms/src/consts.rs
@@ -28,7 +28,3 @@ pub const PEER_MANAGER_MAX_FLOOD_PEERS: usize = 1000;
 /// The amount of time to consider a peer to be offline (i.e. dial to peer will fail without trying) after a failed
 /// connection attempt
 pub const PEER_OFFLINE_COOLDOWN_PERIOD: Duration = Duration::from_secs(60);
-
-/// The envelope version. This should be increased any time a change is made to the
-/// envelope proto files.
-pub const ENVELOPE_VERSION: u32 = 0;