Merge pull request #265 from DMDcoin/0.11

release 0.11.7

Author: SurfingNerd

CHANGELOG.md

@@ -1,3 +1,10 @@
+## Diamond Node Software 3.3.5-hbbft-0.11.7
+- [Handshake and Session Management improvements](https://github.com/DMDcoin/diamond-node/issues/262)
+- [Reliable Message Broadcast Protocol: message_cache of SyncProtocolHandler does not get cleaned up](https://github.com/DMDcoin/diamond-node/issues/261)
+- reduced log outputs for RMBP cached messages
+- Fix possible deadlock in deregister_session_stream in combination with session_readable
+- reduce timings for shutdown from 90 seconds to 5 seconds, so auto restart of nodes in deadlock cases is faster
+
 ## Diamond Node Software 3.3.5-hbbft-0.11.6
 - [session double kill problem.](https://github.com/DMDcoin/diamond-node/issues/252)
 - [Network Host logic: peer_id to NodeID consistency](https://github.com/DMDcoin/diamond-node/issues/251)

Cargo.lock

@@ -2,7 +2,7 @@
 description = "Diamond Node"
 name = "diamond-node"
 # NOTE Make sure to update util/version/Cargo.toml as well
-version = "3.3.5-hbbft-0.11.6"
+version = "3.3.5-hbbft-0.11.7"
 license = "GPL-3.0"
 authors = [
 	"bit.diamonds developers",

Cargo.toml

@@ -716,15 +716,13 @@ impl RunningClient {
                 std::thread::Builder::new()
                     .name("diamond-node-force-quit".to_string())
                     .spawn(move || {
+
+                        let duration_soft = 5;
                         // we make a force quit if after 90 seconds, if this shutdown routine 
-                        std::thread::sleep(Duration::from_secs(30));
-                        warn!(target: "shutdown", "shutdown not happened within 30 seconds, waiting for 60 seconds before force exiting the process.");
-                        std::thread::sleep(Duration::from_secs(50));
-                        warn!(target: "shutdown", "force exit in 10 seconds.");
-                        std::thread::sleep(Duration::from_secs(10));
-                        warn!(target: "shutdown", "force exiting now.");
+                        std::thread::sleep(Duration::from_secs(duration_soft));
+                        warn!(target: "shutdown", "shutdown not happened within {duration_soft} seconds, starting force exiting the process.");
+                        std::thread::sleep(Duration::from_secs(1));
                         std::process::exit(1);
-                        // Wait for the shutdown manager to finish
                     })
                     .expect("Failed to spawn Force shutdown thread");
 

bin/oe/run.rs

@@ -22,7 +22,7 @@ use std::{collections::HashMap, time::Duration};
 /// Messages to broadcast via chain
 pub enum ChainMessageType {
     /// Consensus message
-    Consensus(Vec<u8>),
+    Consensus(u64, Vec<u8>),
 }
 
 /// Route type to indicate whether it is enacted or retracted.

crates/ethcore/src/client/chain_notify.rs

@@ -3288,18 +3288,23 @@ impl super::traits::EngineClient for Client {
         }
     }
 
-    fn broadcast_consensus_message(&self, message: Bytes) {
+    fn broadcast_consensus_message(&self, future_block_id: u64, message: Bytes) {
         self.statistics
             .broadcasted_consensus_messages
             .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
         self.statistics
             .broadcasted_consensus_messages_bytes
             .fetch_add(message.len() as u64, std::sync::atomic::Ordering::Relaxed);
 
-        self.notify(|notify| notify.broadcast(ChainMessageType::Consensus(message.clone())));
+        self.notify(|notify| {
+            notify.broadcast(ChainMessageType::Consensus(
+                future_block_id,
+                message.clone(),
+            ))
+        });
     }
 
-    fn send_consensus_message(&self, message: Bytes, node_id: Option<H512>) {
+    fn send_consensus_message(&self, future_block_id: u64, message: Bytes, node_id: Option<H512>) {
         self.statistics
             .sent_consensus_messages
             .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
@@ -3308,7 +3313,12 @@ impl super::traits::EngineClient for Client {
             .fetch_add(message.len() as u64, std::sync::atomic::Ordering::Relaxed);
 
         if let Some(n) = node_id {
-            self.notify(|notify| notify.send(ChainMessageType::Consensus(message.clone()), &n));
+            self.notify(|notify| {
+                notify.send(
+                    ChainMessageType::Consensus(future_block_id, message.clone()),
+                    &n,
+                )
+            });
         }
     }
 

crates/ethcore/src/client/client.rs

@@ -1232,9 +1232,14 @@ impl super::traits::EngineClient for TestBlockChainClient {
         }
     }
 
-    fn broadcast_consensus_message(&self, _message: Bytes) {}
+    fn broadcast_consensus_message(&self, _future_block_id: u64, _message: Bytes) {}
 
-    fn send_consensus_message(&self, _message: Bytes, _node_id: Option<H512>) {
+    fn send_consensus_message(
+        &self,
+        _future_block_id: u64,
+        _message: Bytes,
+        _node_id: Option<H512>,
+    ) {
         // TODO: allow test to intercept the message to relay it to other test clients
     }
 

crates/ethcore/src/client/test_client.rs

@@ -668,10 +668,10 @@ pub trait EngineClient: Sync + Send + ChainInfo {
     fn submit_seal(&self, block_hash: H256, seal: Vec<Bytes>);
 
     /// Broadcast a consensus message to the network.
-    fn broadcast_consensus_message(&self, message: Bytes);
+    fn broadcast_consensus_message(&self, future_block_id: u64, message: Bytes);
 
     /// Send a consensus message to the specified peer
-    fn send_consensus_message(&self, message: Bytes, node_id: Option<H512>);
+    fn send_consensus_message(&self, future_block_id: u64, message: Bytes, node_id: Option<H512>);
 
     /// Get the transition to the epoch the given parent hash is part of
     /// or transitions to.

crates/ethcore/src/client/traits.rs

@@ -1158,7 +1158,7 @@ impl AuthorityRound {
         self.empty_steps.lock().insert(empty_step);
     }
 
-    fn generate_empty_step(&self, parent_hash: &H256) {
+    fn generate_empty_step(&self, future_block_id: u64, parent_hash: &H256) {
         let step = self.step.inner.load();
         let empty_step_rlp = empty_step_rlp(step, parent_hash);
 
@@ -1173,16 +1173,16 @@ impl AuthorityRound {
             };
 
             trace!(target: "engine", "broadcasting empty step message: {:?}", empty_step);
-            self.broadcast_message(message_rlp);
+            self.broadcast_message(future_block_id, message_rlp);
             self.handle_empty_step_message(empty_step);
         } else {
             warn!(target: "engine", "generate_empty_step: FAIL: accounts secret key unavailable");
         }
     }
 
-    fn broadcast_message(&self, message: Vec<u8>) {
+    fn broadcast_message(&self, future_block_id: u64, message: Vec<u8>) {
         if let Ok(c) = self.upgrade_client_or(None) {
-            c.broadcast_consensus_message(message);
+            c.broadcast_consensus_message(future_block_id, message);
         }
     }
 
@@ -1759,7 +1759,7 @@ impl Engine<EthereumMachine> for AuthorityRound {
                     .compare_exchange(true, false, AtomicOrdering::SeqCst, AtomicOrdering::SeqCst)
                     .is_ok()
                 {
-                    self.generate_empty_step(header.parent_hash());
+                    self.generate_empty_step(header.number(), header.parent_hash());
                 }
 
                 return Seal::None;

crates/ethcore/src/engines/authority_round/mod.rs

@@ -72,6 +72,16 @@ enum Message {
     Sealing(BlockNumber, sealing::Message),
 }
 
+impl Message {
+    /// Returns the epoch (block number) of the message.
+    pub fn block_number(&self) -> BlockNumber {
+        match self {
+            Message::HoneyBadger(_, msg) => msg.epoch(),
+            Message::Sealing(block_num, _) => *block_num,
+        }
+    }
+}
+
 /// The Honey Badger BFT Engine.
 pub struct HoneyBadgerBFT {
     transition_service: IoService<()>,
@@ -727,7 +737,11 @@ impl HoneyBadgerBFT {
                     trace!(target: "consensus", "Dispatching message {:?} to {:?}", m.message, set);
                     for node_id in set.into_iter().filter(|p| p != net_info.our_id()) {
                         trace!(target: "consensus", "Sending message to {}", node_id.0);
-                        client.send_consensus_message(ser.clone(), Some(node_id.0));
+                        client.send_consensus_message(
+                            m.message.block_number(),
+                            ser.clone(),
+                            Some(node_id.0),
+                        );
                     }
                 }
                 Target::AllExcept(set) => {
@@ -737,7 +751,11 @@ impl HoneyBadgerBFT {
                         .filter(|p| (p != &net_info.our_id() && !set.contains(p)))
                     {
                         trace!(target: "consensus", "Sending exclusive message to {}", node_id.0);
-                        client.send_consensus_message(ser.clone(), Some(node_id.0));
+                        client.send_consensus_message(
+                            m.message.block_number(),
+                            ser.clone(),
+                            Some(node_id.0),
+                        );
                     }
                 }
             }
@@ -780,6 +798,7 @@ impl HoneyBadgerBFT {
                 message: Message::HoneyBadger(*message_counter, msg.message),
             }
         });
+
         self.dispatch_messages(&client, messages, network_info);
         std::mem::drop(message_counter);
         self.process_output(client, step.output, network_info);
@@ -813,7 +832,7 @@ impl HoneyBadgerBFT {
 
         let step = match self
             .hbbft_state
-            .try_write_for(std::time::Duration::from_millis(10))
+            .try_write_for(std::time::Duration::from_millis(100))
         {
             Some(mut state_lock) => state_lock.try_send_contribution(client.clone(), &self.signer),
             None => {