From bce6bf92d97f2694bcc70b5ed8f8b9edad9be7b8 Mon Sep 17 00:00:00 2001 From: Robert Habermeier Date: Thu, 9 Feb 2017 15:01:15 +0100 Subject: [PATCH] simplify code --- rpc/src/v1/impls/personal.rs | 33 +++++++++----------- rpc/src/v1/impls/signing.rs | 49 +++++++++++++----------------- rpc/src/v1/impls/signing_unsafe.rs | 24 +++++---------- rpc/src/v1/mod.rs | 4 ++- 4 files changed, 46 insertions(+), 64 deletions(-) diff --git a/rpc/src/v1/impls/personal.rs b/rpc/src/v1/impls/personal.rs index 774e63d13..03ce5ffeb 100644 --- a/rpc/src/v1/impls/personal.rs +++ b/rpc/src/v1/impls/personal.rs @@ -95,35 +95,30 @@ impl Personal for PersonalClient { } fn send_transaction(&self, meta: Metadata, request: TransactionRequest, password: String) -> BoxFuture { - let setup = || { - let dispatcher = self.dispatcher.clone(); - let accounts = take_weak!(self.accounts); + let dispatcher = self.dispatcher.clone(); + let accounts = take_weakf!(self.accounts); - Ok((accounts, dispatcher)) + let default = match request.from.as_ref() { + Some(account) => Ok(account.clone().into()), + None => accounts + .default_address(meta.dapp_id.unwrap_or_default().into()) + .map_err(|e| errors::account("Cannot find default account.", e)), }; - future::done(setup()) - .and_then(move |(accounts, dispatcher)| { - let default = match request.from.as_ref() { - Some(account) => Ok(account.clone().into()), - None => accounts - .default_address(meta.dapp_id.unwrap_or_default().into()) - .map_err(|e| errors::account("Cannot find default account.", e)), - }; + let default = match default { + Ok(default) => default, + Err(e) => return future::err(e).boxed(), + }; - let dis = dispatcher.clone(); - future::done(default) - .and_then(move |default| dis.fill_optional_fields(request.into(), default)) - .map(move |tx| (tx, accounts, dispatcher)) - }) - .and_then(move |(filled, accounts, dispatcher)| { + dispatcher.fill_optional_fields(request.into(), default) + .and_then(move |filled| { let condition = filled.condition.clone().map(Into::into); dispatcher.sign(&accounts, filled, SignWith::Password(password)) .map(|tx| tx.into_value()) .map(move |tx| PendingTransaction::new(tx, condition)) .map(move |tx| (tx, dispatcher)) }) - .and_then(move |(pending_tx, dispatcher)| { + .and_then(|(pending_tx, dispatcher)| { let network_id = pending_tx.network_id(); trace!(target: "miner", "send_transaction: dispatching tx: {} for network ID {:?}", ::rlp::encode(&*pending_tx).to_vec().pretty(), network_id); diff --git a/rpc/src/v1/impls/signing.rs b/rpc/src/v1/impls/signing.rs index 18833723b..e646005cd 100644 --- a/rpc/src/v1/impls/signing.rs +++ b/rpc/src/v1/impls/signing.rs @@ -82,36 +82,29 @@ impl SigningQueueClient { } fn dispatch(&self, payload: RpcConfirmationPayload, default_account: DefaultAccount) -> BoxFuture { - let setup = move || { - let accounts = take_weak!(self.accounts); - let default_account = default_account; - let default_account = match default_account { - DefaultAccount::Provided(acc) => acc, - DefaultAccount::ForDapp(dapp) => accounts.default_address(dapp).ok().unwrap_or_default(), - }; - - Ok((self.dispatcher.clone(), accounts, default_account)) + let accounts = take_weakf!(self.accounts); + let default_account = match default_account { + DefaultAccount::Provided(acc) => acc, + DefaultAccount::ForDapp(dapp) => accounts.default_address(dapp).ok().unwrap_or_default(), }; - let weak_signer = self.signer.clone(); - future::done(setup()) - .and_then(move |(dispatcher, accounts, default_account)| { - dispatch::from_rpc(payload, default_account, &dispatcher) - .and_then(move |payload| { - let sender = payload.sender(); - if accounts.is_unlocked(sender) { - dispatch::execute(dispatcher, &accounts, payload, dispatch::SignWith::Nothing) - .map(|v| v.into_value()) - .map(DispatchResult::Value) - .boxed() - } else { - future::lazy(move || - take_weak!(weak_signer).add_request(payload) - .map(DispatchResult::Promise) - .map_err(|_| errors::request_rejected_limit()) - ).boxed() - } - }) + let dispatcher = self.dispatcher.clone(); + let signer = take_weakf!(self.signer); + dispatch::from_rpc(payload, default_account, &dispatcher) + .and_then(move |payload| { + let sender = payload.sender(); + if accounts.is_unlocked(sender) { + dispatch::execute(dispatcher, &accounts, payload, dispatch::SignWith::Nothing) + .map(|v| v.into_value()) + .map(DispatchResult::Value) + .boxed() + } else { + future::done( + signer.add_request(payload) + .map(DispatchResult::Promise) + .map_err(|_| errors::request_rejected_limit()) + ).boxed() + } }) .boxed() } diff --git a/rpc/src/v1/impls/signing_unsafe.rs b/rpc/src/v1/impls/signing_unsafe.rs index 6ae1cce30..333b823f9 100644 --- a/rpc/src/v1/impls/signing_unsafe.rs +++ b/rpc/src/v1/impls/signing_unsafe.rs @@ -52,26 +52,18 @@ impl SigningUnsafeClient { } fn handle(&self, payload: RpcConfirmationPayload, account: DefaultAccount) -> BoxFuture { - let setup = move || { - let accounts = take_weak!(self.accounts); - let default_account = account; - let default_account = match default_account { - DefaultAccount::Provided(acc) => acc, - DefaultAccount::ForDapp(dapp) => accounts.default_address(dapp).ok().unwrap_or_default(), - }; - - Ok((accounts, default_account)) + let accounts = take_weakf!(self.accounts); + let default = match account { + DefaultAccount::Provided(acc) => acc, + DefaultAccount::ForDapp(dapp) => accounts.default_address(dapp).ok().unwrap_or_default(), }; let dis = self.dispatcher.clone(); - future::done(setup()) - .and_then(move |(accounts, default)| { - dispatch::from_rpc(payload, default, &dis) - .and_then(move |payload| { - dispatch::execute(dis, &accounts, payload, dispatch::SignWith::Nothing) - }) - .map(|v| v.into_value()) + dispatch::from_rpc(payload, default, &dis) + .and_then(move |payload| { + dispatch::execute(dis, &accounts, payload, dispatch::SignWith::Nothing) }) + .map(|v| v.into_value()) .boxed() } } diff --git a/rpc/src/v1/mod.rs b/rpc/src/v1/mod.rs index 44f942cb5..b54f444c1 100644 --- a/rpc/src/v1/mod.rs +++ b/rpc/src/v1/mod.rs @@ -18,6 +18,7 @@ //! //! Compliant with ethereum rpc. +// Upgrade a weak pointer, returning an error on failure. macro_rules! take_weak { ($weak: expr) => { match $weak.upgrade() { @@ -27,11 +28,12 @@ macro_rules! take_weak { } } +// Upgrade a weak pointer, returning an error leaf-future on failure. macro_rules! take_weakf { ($weak: expr) => { match $weak.upgrade() { Some(arc) => arc, - None => return ::futures::future::err(Error::internal_error()), + None => return ::futures::future::err(Error::internal_error()).boxed(), } } }