Stop authoring blocks when offline (#1655)

* Don't author blocks when offline

* Increased canonicalization delay

* Fixed test

substrate/core/client/db/src/lib.rs

@@ -56,7 +56,7 @@ use crate::storage_cache::{CachingState, SharedCache, new_shared_cache};
 use log::{trace, debug, warn};
 pub use state_db::PruningMode;
 
-const CANONICALIZATION_DELAY: u64 = 256;
+const CANONICALIZATION_DELAY: u64 = 4096;
 const MIN_BLOCKS_TO_KEEP_CHANGES_TRIES_FOR: u64 = 32768;
 const STATE_CACHE_SIZE_BYTES: usize = 16 * 1024 * 1024;
 

substrate/core/consensus/aura/src/lib.rs

@@ -272,6 +272,11 @@ pub fn start_aura<B, C, E, I, SO, Error>(
 					}
 				};
 
+				if sync_oracle.is_offline() && authorities.len() > 1 {
+					debug!(target: "aura", "Skipping proposal slot. Waiting for the netork.");
+					return Either::B(future::ok(()));
+				}
+
 				let proposal_work = match slot_author(slot_num, &authorities) {
 					None => return Either::B(future::ok(())),
 					Some(author) => if author.0 == public_key.0 {

substrate/core/consensus/common/src/lib.rs

@@ -88,6 +88,9 @@ pub trait SyncOracle {
 	/// Whether the synchronization service is undergoing major sync.
 	/// Returns true if so.
 	fn is_major_syncing(&self) -> bool;
+	/// Whether the synchronization service is offline.
+	/// Returns true if so.
+	fn is_offline(&self) -> bool;
 }
 
 /// A synchronization oracle for when there is no network.
@@ -96,10 +99,14 @@ pub struct NoNetwork;
 
 impl SyncOracle for NoNetwork {
 	fn is_major_syncing(&self) -> bool { false }
+	fn is_offline(&self) -> bool { false }
 }
 
 impl<T: SyncOracle> SyncOracle for Arc<T> {
 	fn is_major_syncing(&self) -> bool {
 		T::is_major_syncing(&*self)
 	}
+	fn is_offline(&self) -> bool {
+		T::is_offline(&*self)
+	}
 }

substrate/core/network/src/protocol.rs

@@ -433,7 +433,7 @@ impl<B: BlockT, S: NetworkSpecialization<B>, H: ExHashT> Protocol<B, S, H> {
 		}
 
 		debug!(target: "sync", "{} clogging messages:", clogging_messages.len());
-		for msg_bytes in clogging_messages {
+		for msg_bytes in clogging_messages.take(5) {
 			if let Some(msg) = <Message<B> as Decode>::decode(&mut Cursor::new(msg_bytes)) {
 				debug!(target: "sync", "{:?}", msg);
 			} else {

substrate/core/network/src/service.rs

@@ -234,6 +234,9 @@ impl<B: BlockT + 'static, S: NetworkSpecialization<B>, H: ExHashT> ::consensus::
 	fn is_major_syncing(&self) -> bool {
 		self.handler.sync().read().status().is_major_syncing()
 	}
+	fn is_offline(&self) -> bool {
+		self.handler.sync().read().status().is_offline()
+	}
 }
 
 impl<B: BlockT + 'static, S: NetworkSpecialization<B>, H:ExHashT> Drop for Service<B, S, H> {

substrate/core/network/src/sync.rs

@@ -263,6 +263,8 @@ pub struct Status<B: BlockT> {
 	pub state: SyncState,
 	/// Target sync block number.
 	pub best_seen_block: Option<NumberFor<B>>,
+	/// Number of peers participating in syncing.
+	pub num_peers: u32,
 }
 
 impl<B: BlockT> Status<B> {
@@ -274,6 +276,11 @@ impl<B: BlockT> Status<B> {
 			SyncState::Downloading => true,
 		}
 	}
+
+	/// Are we all alone?
+	pub fn is_offline(&self) -> bool {
+		self.num_peers == 0
+	}
 }
 
 impl<B: BlockT> ChainSync<B> {
@@ -315,6 +322,7 @@ impl<B: BlockT> ChainSync<B> {
 		Status {
 			state: state,
 			best_seen_block: best_seen,
+			num_peers: self.peers.len() as u32,
 		}
 	}
 

substrate/core/rpc/src/system/tests.rs

@@ -33,6 +33,7 @@ impl network::SyncProvider<Block> for Status {
 			sync: SyncStatus {
 				state: if self.is_syncing { SyncState::Downloading } else { SyncState::Idle },
 				best_seen_block: None,
+				num_peers: self.peers as u32,
 			},
 			num_peers: self.peers,
 			num_active_peers: 0,