Early Epoch End decision making (ConnectivityTracker) is now based on ANY Hbbft Message send by the Partner Node, and node just judging by sealing Messages.

In some cases the Nodes do not even send their Sealing Messages late, because the Block finalization is faster than their Sealing Message Communication.
Probably due their geographical location.
This also means we can reduce the grace periods again:
Switched the treshhold_time from 60 minutes to 22 minutes,
and reduced it from 10 blocks to 2 blocks.
see: DMDcoin#87

Author: SurfingNerd

crates/ethcore/src/client/client.rs

@@ -203,15 +203,33 @@ struct ClientStatistics {
     sent_consensus_messages_bytes: AtomicU64,
 }
 
-
 impl PrometheusMetrics for ClientStatistics {
-
     fn prometheus_metrics(&self, r: &mut PrometheusRegistry) {
         if self.logging_enabled {
-            r.register_counter("consens_messages_sent", "count", self.sent_consensus_messages.load(std::sync::atomic::Ordering::Relaxed) as i64);
-            r.register_counter("consens_messages_sent_bytes", "bytes", self.sent_consensus_messages_bytes.load(std::sync::atomic::Ordering::Relaxed) as i64);
-            r.register_counter("consens_messages_broadcasted", "count", self.broadcasted_consensus_messages.load(std::sync::atomic::Ordering::Relaxed) as i64);
-            r.register_counter("consens_messages_broadcasted_bytes", "bytes", self.broadcasted_consensus_messages_bytes.load(std::sync::atomic::Ordering::Relaxed) as i64);
+            r.register_counter(
+                "consens_messages_sent",
+                "count",
+                self.sent_consensus_messages
+                    .load(std::sync::atomic::Ordering::Relaxed) as i64,
+            );
+            r.register_counter(
+                "consens_messages_sent_bytes",
+                "bytes",
+                self.sent_consensus_messages_bytes
+                    .load(std::sync::atomic::Ordering::Relaxed) as i64,
+            );
+            r.register_counter(
+                "consens_messages_broadcasted",
+                "count",
+                self.broadcasted_consensus_messages
+                    .load(std::sync::atomic::Ordering::Relaxed) as i64,
+            );
+            r.register_counter(
+                "consens_messages_broadcasted_bytes",
+                "bytes",
+                self.broadcasted_consensus_messages_bytes
+                    .load(std::sync::atomic::Ordering::Relaxed) as i64,
+            );
         }
     }
 }
@@ -3637,16 +3655,14 @@ impl PrometheusMetrics for Client {
 
         let lockd = Duration::from_millis(50);
 
-        self.state_db
-            .try_read_for(lockd)
-            .map(|state_db| {
-                let state_db_size = state_db.cache_size();
-                r.register_gauge(
-                    "statedb_cache_size",
-                    "State DB cache size",
-                    state_db_size as i64,
-                );
-            });
+        self.state_db.try_read_for(lockd).map(|state_db| {
+            let state_db_size = state_db.cache_size();
+            r.register_gauge(
+                "statedb_cache_size",
+                "State DB cache size",
+                state_db_size as i64,
+            );
+        });
 
         // blockchain cache
         let blockchain_cache_info = self.blockchain_cache_info();

crates/ethcore/src/engines/hbbft/hbbft_early_epoch_end_manager.rs

@@ -243,6 +243,8 @@ impl HbbftEarlyEpochEndManager {
         client: &dyn EngineClient,
         other_validator_address: &Address,
     ) -> bool {
+        // todo: for performance improvements, we could apply caching here,
+        // once we are up to date with the contract information and track the inclusion of our own reports.
         let result = is_connectivity_loss_reported(
             client,
             BlockId::Latest,
@@ -291,11 +293,11 @@ impl HbbftEarlyEpochEndManager {
             return;
         };
 
-        let treshold: u64 = 10;
+        let treshold: u64 = 2;
         // todo: read this out from contracts: ConnectivityTrackerHbbft -> reportDisallowPeriod
         // requires us to update the Contracts ABIs:
         // https://github.com/DMDcoin/diamond-node/issues/115
-        let treshold_time = Duration::from_secs(60 * 60);
+        let treshold_time = Duration::from_secs(22 * 60); // 22 Minutes = 2 times the heartbeat + 2 minutes as grace period.
 
         if self.start_time.elapsed() < treshold_time {
             debug!(target: "engine", "early-epoch-end: no decision: Treshold time not reached.");
@@ -324,9 +326,9 @@ impl HbbftEarlyEpochEndManager {
                 };
 
                 if let Some(node_history) = epoch_history.get_history_for_node(validator) {
-                    let last_sealing_message_time = node_history.get_last_sealing_message_time();
-                    let last_sealing_message_lateness = last_sealing_message_time.elapsed();
-                    if last_sealing_message_lateness > treshold_time {
+                    let last_message_time = node_history.get_last_good_message_time();
+                    let last_message_time_lateness = last_message_time.elapsed();
+                    if last_message_time_lateness > treshold_time {
                         // we do not have to send notification, if we already did so.
                         if !self.is_reported(client, validator_address) {
                             // this function will also add the validator to the list of flagged validators.

crates/ethcore/src/engines/hbbft/hbbft_message_memorium.rs

@@ -63,6 +63,7 @@ pub(crate) struct NodeStakingEpochHistory {
     // messages.
     last_message_faulty: u64,
     last_message_good: u64,
+    last_message_good_time: Instant,
 
     num_faulty_messages: u64,
     num_good_messages: u64, // total_contributions_good: u64,
@@ -86,6 +87,7 @@ impl NodeStakingEpochHistory {
             sealing_blocks_bad: Vec::new(),
             last_message_faulty: 0,
             last_message_good: 0,
+            last_message_good_time: now,
             num_faulty_messages: 0,
             num_good_messages: 0,
         }
@@ -215,6 +217,7 @@ impl NodeStakingEpochHistory {
           // warn!(target: "hbbft_message_memorium", "add_message_event_good: ! event.block_num {block_num} > last_message_good {last_message_good}");
           // }
         self.num_good_messages += 1;
+        self.last_message_good_time = Instant::now();
     }
 
     /// GETTERS
@@ -251,6 +254,10 @@ impl NodeStakingEpochHistory {
         )
     }
 
+    pub fn get_last_good_message_time(&self) -> Instant {
+        self.last_message_good_time
+    }
+
     pub fn get_last_late_sealing_message(&self) -> u64 {
         self.last_late_sealing_message
     }

crates/net/network-devp2p/src/host.rs

@@ -131,13 +131,24 @@ impl NetworkingStatistics {
     }
 }
 
-
 impl PrometheusMetrics for NetworkingStatistics {
-
     fn prometheus_metrics(&self, registry: &mut PrometheusRegistry) {
-        registry.register_counter("p2p_bytes_sent","total", self.bytes_sent.load(std::sync::atomic::Ordering::Relaxed) as i64);
-        registry.register_counter("p2p_packages_sent","count", self.packages_send.load(std::sync::atomic::Ordering::Relaxed) as i64);
-        registry.register_counter("p2p_peer_losses","count", self.peer_losses.load(std::sync::atomic::Ordering::Relaxed) as i64);   
+        registry.register_counter(
+            "p2p_bytes_sent",
+            "total",
+            self.bytes_sent.load(std::sync::atomic::Ordering::Relaxed) as i64,
+        );
+        registry.register_counter(
+            "p2p_packages_sent",
+            "count",
+            self.packages_send
+                .load(std::sync::atomic::Ordering::Relaxed) as i64,
+        );
+        registry.register_counter(
+            "p2p_peer_losses",
+            "count",
+            self.peer_losses.load(std::sync::atomic::Ordering::Relaxed) as i64,
+        );
     }
 }
 
@@ -1545,7 +1556,6 @@ impl IoHandler<NetworkIoMessage> for Host {
 
 impl PrometheusMetrics for Host {
     fn prometheus_metrics(&self, r: &mut PrometheusRegistry) {
-        
         let lockdur = Duration::from_millis(20);
 
         if let Some((handshakes, egress, ingress)) =
@@ -1565,7 +1575,6 @@ impl PrometheusMetrics for Host {
             r.register_gauge("p2p_uselessnodes", "count", nodes.count_useless() as i64);
         }
 
-
         self.statistics.prometheus_metrics(r);
     }