Auto-updater improvements (#8078)

* updater: refactor updater flow into state machine

* updater: delay update randomly within max range

* updater: configurable update delay

* updater: split polling and updater state machine step

* updater: drop state to avoid deadlocking

* updater: fix fetch backoff

* updater: fix overflow in update delay calculation

* updater: configurable update check frequency

* updater: fix update policy frequency comparison

* updater: use lazy_static for platform and platform_id_hash

* updater: refactor operations contract calls into OperationsClient

* updater: make updater generic over operations and fetch client

* updater: fix compilation

* updater: add testing infrastructure and minimal test

* updater: fix minor grumbles

* updater: add test for successful updater flow

* updater: add test for update delay

* updater: add test for update check frequency

* updater: mock time and rng for deterministic tests

* updater: test backoff on failure

* updater: add test for backoff short-circuit on new release

* updater: refactor to increase readability

* updater: cap maximum backoff to one month

* updater: add test for detecting already downloaded update

* updater: add test for updater disable on fatal errors

* updater: add test for pending outdated fetch

* updater: test auto install of updates

* updater: add test for capability updates

* updater: fix capability update

* updater: use ethabi to create event topic filter

* updater: decrease maximum backoff to 1 day

* updater: cap maximum update delay with upcoming fork block number

* updater: receive state mutex guard in updater_step

* updater: overload execute_upgrade to take state mutex guard

* updater: remove unnecessary clone of latest operations info

* updater: remove latest operations info clone when triggering fetch

ethcore/src/client/test_client.rs

@@ -16,7 +16,7 @@
 
 //! Test client.
 
-use std::sync::atomic::{AtomicUsize, Ordering as AtomicOrder};
+use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering as AtomicOrder};
 use std::sync::Arc;
 use std::collections::{HashMap, BTreeMap};
 use std::mem;
@@ -114,6 +114,8 @@ pub struct TestBlockChainClient {
 	pub traces: RwLock<Option<Vec<LocalizedTrace>>>,
 	/// Pruning history size to report.
 	pub history: RwLock<Option<u64>>,
+	/// Is disabled
+	pub disabled: AtomicBool,
 }
 
 /// Used for generating test client blocks.
@@ -180,6 +182,7 @@ impl TestBlockChainClient {
 			first_block: RwLock::new(None),
 			traces: RwLock::new(None),
 			history: RwLock::new(None),
+			disabled: AtomicBool::new(false),
 		};
 
 		// insert genesis hash.
@@ -356,6 +359,11 @@ impl TestBlockChainClient {
 	pub fn set_history(&self, h: Option<u64>) {
 		*self.history.write() = h;
 	}
+
+	/// Returns true if the client has been disabled.
+	pub fn is_disabled(&self) -> bool {
+		self.disabled.load(AtomicOrder::Relaxed)
+	}
 }
 
 pub fn get_temp_state_db() -> StateDB {
@@ -679,8 +687,14 @@ impl BlockChainClient for TestBlockChainClient {
 		unimplemented!();
 	}
 
-	fn block_number(&self, _id: BlockId) -> Option<BlockNumber> {
-		unimplemented!()
+	fn block_number(&self, id: BlockId) -> Option<BlockNumber> {
+		match id {
+			BlockId::Number(number) => Some(number),
+			BlockId::Earliest => Some(0),
+			BlockId::Latest => Some(self.chain_info().best_block_number),
+			BlockId::Hash(ref h) =>
+				self.numbers.read().iter().find(|&(_, hash)| hash == h).map(|e| *e.0 as u64)
+		}
 	}
 
 	fn block_body(&self, id: BlockId) -> Option<encoded::Body> {
@@ -827,7 +841,7 @@ impl BlockChainClient for TestBlockChainClient {
 
 	fn set_spec_name(&self, _: String) { unimplemented!(); }
 
-	fn disable(&self) { unimplemented!(); }
+	fn disable(&self) { self.disabled.store(true, AtomicOrder::Relaxed); }
 
 	fn pruning_info(&self) -> PruningInfo {
 		let best_num = self.chain_info().best_block_number;