Replace tokio_core with tokio (ring -> 0.13) (#9657)

* Replace `tokio_core` with `tokio`.

* Remove `tokio-core` and replace with `tokio` in

    - `ethcore/stratum`

    - `secret_store`

    - `util/fetch`

    - `util/reactor`

* Bump hyper to 0.12 in

    - `miner`

    - `util/fake-fetch`

    - `util/fetch`

    - `secret_store`

* Bump `jsonrpc-***` to 0.9 in

    - `parity`

    - `ethcore/stratum`

    - `ipfs`

    - `rpc`

    - `rpc_client`

    - `whisper`

* Bump `ring` to 0.13

* Use a more graceful shutdown process in `secret_store` tests.

* Convert some mutexes to rwlocks in `secret_store`.

* Consolidate Tokio Runtime use, remove `CpuPool`.

* Rename and move the `tokio_reactor` crate (`util/reactor`) to
  `tokio_runtime` (`util/runtime`).

* Rename `EventLoop` to `Runtime`.

    - Rename `EventLoop::spawn` to `Runtime::with_default_thread_count`.

    - Add the `Runtime::with_thread_count` method.

    - Rename `Remote` to `Executor`.

* Remove uses of `CpuPool` and spawn all tasks via the `Runtime` executor
  instead.

* Other changes related to `CpuPool` removal:

    - Remove `Reservations::with_pool`. `::new` now takes an `Executor` as an argument.

    - Remove `SenderReservations::with_pool`. `::new` now takes an `Executor` as an argument.

rpc/src/v1/impls/eth_pubsub.rs

@@ -39,7 +39,7 @@ use sync::LightSync;
 use light::cache::Cache;
 use light::on_demand::OnDemand;
 use light::client::{LightChainClient, LightChainNotify};
-use parity_reactor::Remote;
+use parity_runtime::Executor;
 use ethereum_types::H256;
 use bytes::Bytes;
 use parking_lot::{RwLock, Mutex};
@@ -56,7 +56,7 @@ pub struct EthPubSubClient<C> {
 
 impl<C> EthPubSubClient<C> {
 	/// Creates new `EthPubSubClient`.
-	pub fn new(client: Arc<C>, remote: Remote) -> Self {
+	pub fn new(client: Arc<C>, executor: Executor) -> Self {
 		let heads_subscribers = Arc::new(RwLock::new(Subscribers::default()));
 		let logs_subscribers = Arc::new(RwLock::new(Subscribers::default()));
 		let transactions_subscribers = Arc::new(RwLock::new(Subscribers::default()));
@@ -64,7 +64,7 @@ impl<C> EthPubSubClient<C> {
 		EthPubSubClient {
 			handler: Arc::new(ChainNotificationHandler {
 				client,
-				remote,
+				executor,
 				heads_subscribers: heads_subscribers.clone(),
 				logs_subscribers: logs_subscribers.clone(),
 				transactions_subscribers: transactions_subscribers.clone(),
@@ -77,8 +77,8 @@ impl<C> EthPubSubClient<C> {
 
 	/// Creates new `EthPubSubCient` with deterministic subscription ids.
 	#[cfg(test)]
-	pub fn new_test(client: Arc<C>, remote: Remote) -> Self {
-		let client = Self::new(client, remote);
+	pub fn new_test(client: Arc<C>, executor: Executor) -> Self {
+		let client = Self::new(client, executor);
 		*client.heads_subscribers.write() = Subscribers::new_test();
 		*client.logs_subscribers.write() = Subscribers::new_test();
 		*client.transactions_subscribers.write() = Subscribers::new_test();
@@ -98,7 +98,7 @@ impl EthPubSubClient<LightFetch> {
 		on_demand: Arc<OnDemand>,
 		sync: Arc<LightSync>,
 		cache: Arc<Mutex<Cache>>,
-		remote: Remote,
+		executor: Executor,
 		gas_price_percentile: usize,
 	) -> Self {
 		let fetch = LightFetch {
@@ -108,22 +108,22 @@ impl EthPubSubClient<LightFetch> {
 			cache,
 			gas_price_percentile,
 		};
-		EthPubSubClient::new(Arc::new(fetch), remote)
+		EthPubSubClient::new(Arc::new(fetch), executor)
 	}
 }
 
 /// PubSub Notification handler.
 pub struct ChainNotificationHandler<C> {
 	client: Arc<C>,
-	remote: Remote,
+	executor: Executor,
 	heads_subscribers: Arc<RwLock<Subscribers<Client>>>,
 	logs_subscribers: Arc<RwLock<Subscribers<(Client, EthFilter)>>>,
 	transactions_subscribers: Arc<RwLock<Subscribers<Client>>>,
 }
 
 impl<C> ChainNotificationHandler<C> {
-	fn notify(remote: &Remote, subscriber: &Client, result: pubsub::Result) {
-		remote.spawn(subscriber
+	fn notify(executor: &Executor, subscriber: &Client, result: pubsub::Result) {
+		executor.spawn(subscriber
 			.notify(Ok(result))
 			.map(|_| ())
 			.map_err(|e| warn!(target: "rpc", "Unable to send notification: {}", e))
@@ -133,7 +133,7 @@ impl<C> ChainNotificationHandler<C> {
 	fn notify_heads(&self, headers: &[(encoded::Header, BTreeMap<String, String>)]) {
 		for subscriber in self.heads_subscribers.read().values() {
 			for &(ref header, ref extra_info) in headers {
-				Self::notify(&self.remote, subscriber, pubsub::Result::Header(RichHeader {
+				Self::notify(&self.executor, subscriber, pubsub::Result::Header(RichHeader {
 					inner: header.into(),
 					extra_info: extra_info.clone(),
 				}));
@@ -159,14 +159,14 @@ impl<C> ChainNotificationHandler<C> {
 				.collect::<Vec<_>>()
 			);
 			let limit = filter.limit;
-			let remote = self.remote.clone();
+			let executor = self.executor.clone();
 			let subscriber = subscriber.clone();
-			self.remote.spawn(logs
+			self.executor.spawn(logs
 				.map(move |logs| {
 					let logs = logs.into_iter().flat_map(|log| log).collect();
 
 					for log in limit_logs(logs, limit) {
-						Self::notify(&remote, &subscriber, pubsub::Result::Log(log))
+						Self::notify(&executor, &subscriber, pubsub::Result::Log(log))
 					}
 				})
 				.map_err(|e| warn!("Unable to fetch latest logs: {:?}", e))
@@ -178,7 +178,7 @@ impl<C> ChainNotificationHandler<C> {
 	pub fn notify_new_transactions(&self, hashes: &[H256]) {
 		for subscriber in self.transactions_subscribers.read().values() {
 			for hash in hashes {
-				Self::notify(&self.remote, subscriber, pubsub::Result::TransactionHash((*hash).into()));
+				Self::notify(&self.executor, subscriber, pubsub::Result::TransactionHash((*hash).into()));
 			}
 		}
 	}

rpc/src/v1/impls/light/parity_set.rs

@@ -22,7 +22,6 @@ use std::sync::Arc;
 
 use sync::ManageNetwork;
 use fetch::{self, Fetch};
-use futures_cpupool::CpuPool;
 use hash::keccak_buffer;
 
 use jsonrpc_core::{Result, BoxFuture};
@@ -35,16 +34,14 @@ use v1::types::{Bytes, H160, H256, U256, ReleaseInfo, Transaction};
 pub struct ParitySetClient<F> {
 	net: Arc<ManageNetwork>,
 	fetch: F,
-	pool: CpuPool,
 }
 
 impl<F: Fetch> ParitySetClient<F> {
 	/// Creates new `ParitySetClient` with given `Fetch`.
-	pub fn new(net: Arc<ManageNetwork>, fetch: F, p: CpuPool) -> Self {
+	pub fn new(net: Arc<ManageNetwork>, fetch: F) -> Self {
 		ParitySetClient {
 			net: net,
 			fetch: fetch,
-			pool: p,
 		}
 	}
 }
@@ -134,7 +131,7 @@ impl<F: Fetch> ParitySet for ParitySetClient<F> {
 				})
 				.map(Into::into)
 		});
-		Box::new(self.pool.spawn(future))
+		Box::new(future)
 	}
 
 	fn upgrade_ready(&self) -> Result<Option<ReleaseInfo>> {

rpc/src/v1/impls/parity_set.rs

@@ -23,7 +23,6 @@ use ethcore::client::{BlockChainClient, Mode};
 use ethcore::miner::MinerService;
 use sync::ManageNetwork;
 use fetch::{self, Fetch};
-use futures_cpupool::CpuPool;
 use hash::keccak_buffer;
 use updater::{Service as UpdateService};
 
@@ -40,7 +39,6 @@ pub struct ParitySetClient<C, M, U, F = fetch::Client> {
 	updater: Arc<U>,
 	net: Arc<ManageNetwork>,
 	fetch: F,
-	pool: CpuPool,
 }
 
 impl<C, M, U, F> ParitySetClient<C, M, U, F>
@@ -53,7 +51,6 @@ impl<C, M, U, F> ParitySetClient<C, M, U, F>
 		updater: &Arc<U>,
 		net: &Arc<ManageNetwork>,
 		fetch: F,
-		pool: CpuPool,
 	) -> Self {
 		ParitySetClient {
 			client: client.clone(),
@@ -61,7 +58,6 @@ impl<C, M, U, F> ParitySetClient<C, M, U, F>
 			updater: updater.clone(),
 			net: net.clone(),
 			fetch: fetch,
-			pool: pool,
 		}
 	}
 }
@@ -177,7 +173,7 @@ impl<C, M, U, F> ParitySet for ParitySetClient<C, M, U, F> where
 				})
 				.map(Into::into)
 		});
-		Box::new(self.pool.spawn(future))
+		Box::new(future)
 	}
 
 	fn upgrade_ready(&self) -> Result<Option<ReleaseInfo>> {

rpc/src/v1/impls/pubsub.rs

@@ -27,7 +27,7 @@ use jsonrpc_macros::pubsub::Subscriber;
 use jsonrpc_pubsub::SubscriptionId;
 use tokio_timer;
 
-use parity_reactor::Remote;
+use parity_runtime::Executor;
 use v1::helpers::GenericPollManager;
 use v1::metadata::Metadata;
 use v1::traits::PubSub;
@@ -35,12 +35,12 @@ use v1::traits::PubSub;
 /// Parity PubSub implementation.
 pub struct PubSubClient<S: core::Middleware<Metadata>> {
 	poll_manager: Arc<RwLock<GenericPollManager<S>>>,
-	remote: Remote,
+	executor: Executor,
 }
 
 impl<S: core::Middleware<Metadata>> PubSubClient<S> {
 	/// Creates new `PubSubClient`.
-	pub fn new(rpc: MetaIoHandler<Metadata, S>, remote: Remote) -> Self {
+	pub fn new(rpc: MetaIoHandler<Metadata, S>, executor: Executor) -> Self {
 		let poll_manager = Arc::new(RwLock::new(GenericPollManager::new(rpc)));
 		let pm2 = poll_manager.clone();
 
@@ -50,14 +50,14 @@ impl<S: core::Middleware<Metadata>> PubSubClient<S> {
 
 		// Start ticking
 		let interval = timer.interval(Duration::from_millis(1000));
-		remote.spawn(interval
+		executor.spawn(interval
 			.map_err(|e| warn!("Polling timer error: {:?}", e))
 			.for_each(move |_| pm2.read().tick())
 		);
 
 		PubSubClient {
 			poll_manager,
-			remote,
+			executor,
 		}
 	}
 }
@@ -65,8 +65,8 @@ impl<S: core::Middleware<Metadata>> PubSubClient<S> {
 impl PubSubClient<core::NoopMiddleware> {
 	/// Creates new `PubSubClient` with deterministic ids.
 	#[cfg(test)]
-	pub fn new_test(rpc: MetaIoHandler<Metadata, core::NoopMiddleware>, remote: Remote) -> Self {
-		let client = Self::new(MetaIoHandler::with_middleware(Default::default()), remote);
+	pub fn new_test(rpc: MetaIoHandler<Metadata, core::NoopMiddleware>, executor: Executor) -> Self {
+		let client = Self::new(MetaIoHandler::with_middleware(Default::default()), executor);
 		*client.poll_manager.write() = GenericPollManager::new_test(rpc);
 		client
 	}
@@ -84,7 +84,7 @@ impl<S: core::Middleware<Metadata>> PubSub for PubSubClient<S> {
 		let (id, receiver) = poll_manager.subscribe(meta, method, params);
 		match subscriber.assign_id(id.clone()) {
 			Ok(sink) => {
-				self.remote.spawn(receiver.forward(sink.sink_map_err(|e| {
+				self.executor.spawn(receiver.forward(sink.sink_map_err(|e| {
 					warn!("Cannot send notification: {:?}", e);
 				})).map(|_| ()));
 			},

rpc/src/v1/impls/signer.rs

@@ -20,7 +20,7 @@ use std::sync::Arc;
 
 use ethcore::account_provider::AccountProvider;
 use ethkey;
-use parity_reactor::Remote;
+use parity_runtime::Executor;
 use parking_lot::Mutex;
 use rlp::Rlp;
 use transaction::{SignedTransaction, PendingTransaction};
@@ -50,7 +50,7 @@ impl<D: Dispatcher + 'static> SignerClient<D> {
 		store: &Arc<AccountProvider>,
 		dispatcher: D,
 		signer: &Arc<SignerService>,
-		remote: Remote,
+		executor: Executor,
 	) -> Self {
 		let subscribers = Arc::new(Mutex::new(Subscribers::default()));
 		let subs = Arc::downgrade(&subscribers);
@@ -60,7 +60,7 @@ impl<D: Dispatcher + 'static> SignerClient<D> {
 				let requests = s.requests().into_iter().map(Into::into).collect::<Vec<ConfirmationRequest>>();
 				for subscription in subs.lock().values() {
 					let subscription: &Sink<_> = subscription;
-					remote.spawn(subscription
+					executor.spawn(subscription
 						.notify(Ok(requests.clone()))
 						.map(|_| ())
 						.map_err(|e| warn!(target: "rpc", "Unable to send notification: {}", e))

rpc/src/v1/impls/signing.rs

@@ -44,7 +44,7 @@ use v1::types::{
 	Origin,
 };
 
-use parity_reactor::Remote;
+use parity_runtime::Executor;
 
 /// After 60s entries that are not queried with `check_request` will get garbage collected.
 const MAX_PENDING_DURATION_SEC: u32 = 60;
@@ -67,7 +67,7 @@ impl Future for DispatchResult {
 	}
 }
 
-fn schedule(remote: Remote,
+fn schedule(executor: Executor,
 	confirmations: Arc<Mutex<TransientHashMap<U256, Option<RpcConfirmationResult>>>>,
 	id: U256,
 	future: RpcConfirmationReceiver) {
@@ -83,7 +83,7 @@ fn schedule(remote: Remote,
 		confirmations.insert(id, Some(result));
 		Ok(())
 	});
-	remote.spawn(future);
+	executor.spawn(future);
 }
 
 /// Implementation of functions that require signing when no trusted signer is used.
@@ -91,19 +91,19 @@ pub struct SigningQueueClient<D> {
 	signer: Arc<SignerService>,
 	accounts: Arc<AccountProvider>,
 	dispatcher: D,
-	remote: Remote,
+	executor: Executor,
 	// None here means that the request hasn't yet been confirmed
 	confirmations: Arc<Mutex<TransientHashMap<U256, Option<RpcConfirmationResult>>>>,
 }
 
 impl<D: Dispatcher + 'static> SigningQueueClient<D> {
 	/// Creates a new signing queue client given shared signing queue.
-	pub fn new(signer: &Arc<SignerService>, dispatcher: D, remote: Remote, accounts: &Arc<AccountProvider>) -> Self {
+	pub fn new(signer: &Arc<SignerService>, dispatcher: D, executor: Executor, accounts: &Arc<AccountProvider>) -> Self {
 		SigningQueueClient {
 			signer: signer.clone(),
 			accounts: accounts.clone(),
 			dispatcher,
-			remote,
+			executor,
 			confirmations: Arc::new(Mutex::new(TransientHashMap::new(MAX_PENDING_DURATION_SEC))),
 		}
 	}
@@ -143,7 +143,7 @@ impl<D: Dispatcher + 'static> ParitySigning for SigningQueueClient<D> {
 	}
 
 	fn post_sign(&self, meta: Metadata, address: RpcH160, data: RpcBytes) -> BoxFuture<RpcEither<RpcU256, RpcConfirmationResponse>> {
-		let remote = self.remote.clone();
+		let executor = self.executor.clone();
 		let confirmations = self.confirmations.clone();
 
 		Box::new(self.dispatch(
@@ -153,21 +153,21 @@ impl<D: Dispatcher + 'static> ParitySigning for SigningQueueClient<D> {
 		).map(move |result| match result {
 			DispatchResult::Value(v) => RpcEither::Or(v),
 			DispatchResult::Future(id, future) => {
-				schedule(remote, confirmations, id, future);
+				schedule(executor, confirmations, id, future);
 				RpcEither::Either(id.into())
 			},
 		}))
 	}
 
 	fn post_transaction(&self, meta: Metadata, request: RpcTransactionRequest) -> BoxFuture<RpcEither<RpcU256, RpcConfirmationResponse>> {
-		let remote = self.remote.clone();
+		let executor = self.executor.clone();
 		let confirmations = self.confirmations.clone();
 
 		Box::new(self.dispatch(RpcConfirmationPayload::SendTransaction(request), DefaultAccount::Provided(self.accounts.default_account().ok().unwrap_or_default()), meta.origin)
 			.map(|result| match result {
 				DispatchResult::Value(v) => RpcEither::Or(v),
 				DispatchResult::Future(id, future) => {
-					schedule(remote, confirmations, id, future);
+					schedule(executor, confirmations, id, future);
 					RpcEither::Either(id.into())
 				},
 			}))