From 459dcbcef17fbc7d74ddf2103717297eb5ac712b Mon Sep 17 00:00:00 2001 From: Nikolay Volf Date: Tue, 19 Jul 2016 09:21:41 +0200 Subject: [PATCH] Removing unused client code (#1645) * moving ipc deriving to trait * refactoring of the client --- ethcore/build.rs | 8 +- ethcore/src/client/client.rs | 20 +-- ethcore/src/client/mod.rs | 200 +--------------------------- ethcore/src/client/traits.rs | 224 ++++++++++++++++++++++++++++++++ ethcore/src/json_tests/chain.rs | 2 +- ethcore/src/service.rs | 4 +- ethcore/src/tests/client.rs | 8 +- ethcore/src/tests/helpers.rs | 4 +- ipc/rpc/src/binary.rs | 28 ++++ rpc/rpctest/src/main.rs | 2 +- rpc/src/v1/tests/eth.rs | 2 +- 11 files changed, 276 insertions(+), 226 deletions(-) create mode 100644 ethcore/src/client/traits.rs diff --git a/ethcore/build.rs b/ethcore/build.rs index 25b559b43..b9b884fac 100644 --- a/ethcore/build.rs +++ b/ethcore/build.rs @@ -31,15 +31,15 @@ fn main() { registry.expand("", &src, &dst).unwrap(); } - // client interface + // blockchain client interface { - let src = Path::new("src/client/client.rs"); - let intermediate = Path::new(&out_dir).join("client.intermediate.rs.in"); + let src = Path::new("src/client/traits.rs"); + let intermediate = Path::new(&out_dir).join("traits.intermediate.rs.in"); let mut registry = syntex::Registry::new(); codegen::register(&mut registry); registry.expand("", &src, &intermediate).unwrap(); - let dst = Path::new(&out_dir).join("client.ipc.rs"); + let dst = Path::new(&out_dir).join("traits.ipc.rs"); let mut registry = syntex::Registry::new(); codegen::register(&mut registry); registry.expand("", &intermediate, &dst).unwrap(); diff --git a/ethcore/src/client/client.rs b/ethcore/src/client/client.rs index 92832837a..e9421b64c 100644 --- a/ethcore/src/client/client.rs +++ b/ethcore/src/client/client.rs @@ -14,10 +14,8 @@ // You should have received a copy of the GNU General Public License // along with Parity. If not, see . -use std::collections::{HashSet, HashMap}; +use std::collections::{HashSet, HashMap, VecDeque}; use std::ops::Deref; -use std::mem; -use std::collections::VecDeque; use std::sync::{Arc, Weak}; use std::path::{Path, PathBuf}; use std::fmt; @@ -67,8 +65,6 @@ use trace; use evm::Factory as EvmFactory; use miner::{Miner, MinerService}; use util::TrieFactory; -use ipc::IpcConfig; -use ipc::binary::{BinaryConvertError}; // re-export pub use types::blockchain_info::BlockChainInfo; @@ -141,7 +137,6 @@ pub struct Client { io_channel: IoChannel, notify: RwLock>>, queue_transactions: AtomicUsize, - previous_enode: Mutex>, skipped: AtomicUsize, last_import: Mutex, last_hashes: RwLock>, @@ -236,7 +231,6 @@ impl Client { io_channel: message_channel, notify: RwLock::new(None), queue_transactions: AtomicUsize::new(0), - previous_enode: Mutex::new(None), skipped: AtomicUsize::new(0), last_import: Mutex::new(Instant::now()), last_hashes: RwLock::new(VecDeque::new()), @@ -358,7 +352,7 @@ impl Client { } /// This is triggered by a message coming from a block queue when the block is ready for insertion - pub fn import_verified_blocks(&self, io: &IoChannel) -> usize { + pub fn import_verified_blocks(&self) -> usize { let max_blocks_to_import = 64; let (imported_blocks, import_results, invalid_blocks, original_best, imported) = { let mut imported_blocks = Vec::with_capacity(max_blocks_to_import); @@ -402,7 +396,7 @@ impl Client { if Instant::now() > *last_import + Duration::from_secs(1) { let queue_info = self.queue_info(); let importing = queue_info.unverified_queue_size + queue_info.verified_queue_size > 3; - if !importing { + if !importing { let skipped = self.skipped.load(AtomicOrdering::Relaxed); info!(target: "import", "Imported {} {} ({} txs, {} Mgas, {} ms, {} KiB){}", Colour::White.bold().paint(format!("#{}", header.number())), @@ -411,13 +405,13 @@ impl Client { Colour::Yellow.bold().paint(format!("{:.2}", header.gas_used.low_u64() as f32 / 1000000f32)), Colour::Purple.bold().paint(format!("{:.2}", duration_ns as f32 / 1000000f32)), Colour::Blue.bold().paint(format!("{:.2}", size as f32 / 1024f32)), - if skipped > 0 { format!(" + another {} block(s)", Colour::Red.bold().paint(format!("{}", skipped))) } else { String::new() } + if skipped > 0 { format!(" + another {} block(s)", Colour::Red.bold().paint(format!("{}", skipped))) } else { String::new() } ); *last_import = Instant::now(); } self.skipped.store(0, AtomicOrdering::Relaxed); } else { - self.skipped.fetch_add(1, AtomicOrdering::Relaxed); + self.skipped.fetch_add(1, AtomicOrdering::Relaxed); } } @@ -668,8 +662,6 @@ impl Client { } } -#[derive(Ipc)] -#[ipc(client_ident="RemoteClient")] impl BlockChainClient for Client { fn call(&self, t: &SignedTransaction, analytics: CallAnalytics) -> Result { let header = self.block_header(BlockID::Latest).unwrap(); @@ -1072,5 +1064,3 @@ impl MayPanic for Client { self.panic_handler.on_panic(closure); } } - -impl IpcConfig for BlockChainClient { } diff --git a/ethcore/src/client/mod.rs b/ethcore/src/client/mod.rs index b8426c9f3..0d5f2a941 100644 --- a/ethcore/src/client/mod.rs +++ b/ethcore/src/client/mod.rs @@ -20,6 +20,7 @@ mod config; mod error; mod test_client; mod trace; +mod client; pub use self::client::*; pub use self::config::{Mode, ClientConfig, DatabaseCompactionProfile, BlockQueueConfig, BlockChainConfig, Switch, VMType}; @@ -31,32 +32,15 @@ pub use executive::{Executed, Executive, TransactOptions}; pub use env_info::{LastHashes, EnvInfo}; pub use self::chain_notify::ChainNotify; -use util::bytes::Bytes; -use util::hash::{Address, H256, H2048}; -use util::numbers::U256; -use util::Itertools; -use blockchain::TreeRoute; -use block_queue::BlockQueueInfo; -use block::{OpenBlock, SealedBlock}; -use header::{BlockNumber}; -use transaction::{LocalizedTransaction, SignedTransaction}; -use log_entry::LocalizedLogEntry; -use filter::Filter; -use views::{BlockView}; -use error::{ImportResult, ExecutionError}; -use receipt::LocalizedReceipt; -use trace::LocalizedTrace; -use evm::Factory as EvmFactory; pub use types::call_analytics::CallAnalytics; pub use block_import_error::BlockImportError; pub use transaction_import::TransactionImportResult; pub use transaction_import::TransactionImportError; +pub use self::traits::{BlockChainClient, MiningBlockChainClient, RemoteClient}; -pub mod client { - //! Blockchain database client. - +mod traits { #![allow(dead_code, unused_assignments, unused_variables, missing_docs)] // codegen issues - include!(concat!(env!("OUT_DIR"), "/client.ipc.rs")); + include!(concat!(env!("OUT_DIR"), "/traits.ipc.rs")); } pub mod chain_notify { @@ -66,179 +50,3 @@ pub mod chain_notify { include!(concat!(env!("OUT_DIR"), "/chain_notify.ipc.rs")); } -/// Blockchain database client. Owns and manages a blockchain and a block queue. -pub trait BlockChainClient : Sync + Send { - - /// Should be called by any external-facing interface when actively using the client. - /// To minimise chatter, there's no need to call more than once every 30s. - fn keep_alive(&self) {} - - /// Get raw block header data by block id. - fn block_header(&self, id: BlockID) -> Option; - - /// Get raw block body data by block id. - /// Block body is an RLP list of two items: uncles and transactions. - fn block_body(&self, id: BlockID) -> Option; - - /// Get raw block data by block header hash. - fn block(&self, id: BlockID) -> Option; - - /// Get block status by block header hash. - fn block_status(&self, id: BlockID) -> BlockStatus; - - /// Get block total difficulty. - fn block_total_difficulty(&self, id: BlockID) -> Option; - - /// Attempt to get address nonce at given block. - /// May not fail on BlockID::Latest. - fn nonce(&self, address: &Address, id: BlockID) -> Option; - - /// Get address nonce at the latest block's state. - fn latest_nonce(&self, address: &Address) -> U256 { - self.nonce(address, BlockID::Latest) - .expect("nonce will return Some when given BlockID::Latest. nonce was given BlockID::Latest. \ - Therefore nonce has returned Some; qed") - } - - /// Get block hash. - fn block_hash(&self, id: BlockID) -> Option; - - /// Get address code. - fn code(&self, address: &Address) -> Option; - - /// Get address balance at the given block's state. - /// - /// May not return None if given BlockID::Latest. - /// Returns None if and only if the block's root hash has been pruned from the DB. - fn balance(&self, address: &Address, id: BlockID) -> Option; - - /// Get address balance at the latest block's state. - fn latest_balance(&self, address: &Address) -> U256 { - self.balance(address, BlockID::Latest) - .expect("balance will return Some if given BlockID::Latest. balance was given BlockID::Latest \ - Therefore balance has returned Some; qed") - } - - /// Get value of the storage at given position at the given block's state. - /// - /// May not return None if given BlockID::Latest. - /// Returns None if and only if the block's root hash has been pruned from the DB. - fn storage_at(&self, address: &Address, position: &H256, id: BlockID) -> Option; - - /// Get value of the storage at given position at the latest block's state. - fn latest_storage_at(&self, address: &Address, position: &H256) -> H256 { - self.storage_at(address, position, BlockID::Latest) - .expect("storage_at will return Some if given BlockID::Latest. storage_at was given BlockID::Latest. \ - Therefore storage_at has returned Some; qed") - } - - /// Get transaction with given hash. - fn transaction(&self, id: TransactionID) -> Option; - - /// Get uncle with given id. - fn uncle(&self, id: UncleID) -> Option; - - /// Get transaction receipt with given hash. - fn transaction_receipt(&self, id: TransactionID) -> Option; - - /// Get a tree route between `from` and `to`. - /// See `BlockChain::tree_route`. - fn tree_route(&self, from: &H256, to: &H256) -> Option; - - /// Get all possible uncle hashes for a block. - fn find_uncles(&self, hash: &H256) -> Option>; - - /// Get latest state node - fn state_data(&self, hash: &H256) -> Option; - - /// Get raw block receipts data by block header hash. - fn block_receipts(&self, hash: &H256) -> Option; - - /// Import a block into the blockchain. - fn import_block(&self, bytes: Bytes) -> Result; - - /// Get block queue information. - fn queue_info(&self) -> BlockQueueInfo; - - /// Clear block queue and abort all import activity. - fn clear_queue(&self); - - /// Get blockchain information. - fn chain_info(&self) -> BlockChainInfo; - - /// Get the best block header. - fn best_block_header(&self) -> Bytes { - // TODO: lock blockchain only once - self.block_header(BlockID::Hash(self.chain_info().best_block_hash)).unwrap() - } - - /// Returns numbers of blocks containing given bloom. - fn blocks_with_bloom(&self, bloom: &H2048, from_block: BlockID, to_block: BlockID) -> Option>; - - /// Returns logs matching given filter. - fn logs(&self, filter: Filter) -> Vec; - - /// Makes a non-persistent transaction call. - // TODO: should be able to accept blockchain location for call. - fn call(&self, t: &SignedTransaction, analytics: CallAnalytics) -> Result; - - /// Returns traces matching given filter. - fn filter_traces(&self, filter: TraceFilter) -> Option>; - - /// Returns trace with given id. - fn trace(&self, trace: TraceId) -> Option; - - /// Returns traces created by transaction. - fn transaction_traces(&self, trace: TransactionID) -> Option>; - - /// Returns traces created by transaction from block. - fn block_traces(&self, trace: BlockID) -> Option>; - - /// Get last hashes starting from best block. - fn last_hashes(&self) -> LastHashes; - - /// Queue transactions for importing. - fn queue_transactions(&self, transactions: Vec); - - /// list all transactions - fn pending_transactions(&self) -> Vec; - - /// Get the gas price distribution. - fn gas_price_statistics(&self, sample_size: usize, distribution_size: usize) -> Result, ()> { - let mut h = self.chain_info().best_block_hash; - let mut corpus = Vec::new(); - for _ in 0..sample_size { - let block_bytes = self.block(BlockID::Hash(h)).expect("h is either the best_block_hash or an ancestor; qed"); - let block = BlockView::new(&block_bytes); - let header = block.header_view(); - if header.number() == 0 { - break; - } - block.transaction_views().iter().foreach(|t| corpus.push(t.gas_price())); - h = header.parent_hash().clone(); - } - corpus.sort(); - let n = corpus.len(); - if n > 0 { - Ok((0..(distribution_size + 1)) - .map(|i| corpus[i * (n - 1) / distribution_size]) - .collect::>() - ) - } else { - Err(()) - } - } -} - -/// Extended client interface used for mining -pub trait MiningBlockChainClient : BlockChainClient { - /// Returns OpenBlock prepared for closing. - fn prepare_open_block(&self, author: Address, gas_range_target: (U256, U256), extra_data: Bytes) - -> OpenBlock; - - /// Returns EvmFactory. - fn vm_factory(&self) -> &EvmFactory; - - /// Import sealed block. Skips all verifications. - fn import_sealed_block(&self, block: SealedBlock) -> ImportResult; -} diff --git a/ethcore/src/client/traits.rs b/ethcore/src/client/traits.rs new file mode 100644 index 000000000..ad4c4a193 --- /dev/null +++ b/ethcore/src/client/traits.rs @@ -0,0 +1,224 @@ +// Copyright 2015, 2016 Ethcore (UK) Ltd. +// This file is part of Parity. + +// Parity is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// Parity is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with Parity. If not, see . + +use util::bytes::Bytes; +use util::hash::{Address, H256, H2048}; +use util::numbers::U256; +use util::Itertools; +use blockchain::TreeRoute; +use block_queue::BlockQueueInfo; +use block::{OpenBlock, SealedBlock}; +use header::{BlockNumber}; +use transaction::{LocalizedTransaction, SignedTransaction}; +use log_entry::LocalizedLogEntry; +use filter::Filter; +use views::{BlockView}; +use error::{ImportResult, ExecutionError}; +use receipt::LocalizedReceipt; +use trace::LocalizedTrace; +use evm::Factory as EvmFactory; +use types::ids::*; +use types::trace_filter::Filter as TraceFilter; +use executive::Executed; +use env_info::LastHashes; +use types::call_analytics::CallAnalytics; +use block_import_error::BlockImportError; +use std::mem; +use std::collections::VecDeque; +use ipc::{IpcConfig, BinaryConvertError}; +use types::blockchain_info::BlockChainInfo; +use types::block_status::BlockStatus; + +#[derive(Ipc)] +#[ipc(client_ident="RemoteClient")] +/// Blockchain database client. Owns and manages a blockchain and a block queue. +pub trait BlockChainClient : Sync + Send { + + /// Should be called by any external-facing interface when actively using the client. + /// To minimise chatter, there's no need to call more than once every 30s. + fn keep_alive(&self) {} + + /// Get raw block header data by block id. + fn block_header(&self, id: BlockID) -> Option; + + /// Get raw block body data by block id. + /// Block body is an RLP list of two items: uncles and transactions. + fn block_body(&self, id: BlockID) -> Option; + + /// Get raw block data by block header hash. + fn block(&self, id: BlockID) -> Option; + + /// Get block status by block header hash. + fn block_status(&self, id: BlockID) -> BlockStatus; + + /// Get block total difficulty. + fn block_total_difficulty(&self, id: BlockID) -> Option; + + /// Attempt to get address nonce at given block. + /// May not fail on BlockID::Latest. + fn nonce(&self, address: &Address, id: BlockID) -> Option; + + /// Get address nonce at the latest block's state. + fn latest_nonce(&self, address: &Address) -> U256 { + self.nonce(address, BlockID::Latest) + .expect("nonce will return Some when given BlockID::Latest. nonce was given BlockID::Latest. \ + Therefore nonce has returned Some; qed") + } + + /// Get block hash. + fn block_hash(&self, id: BlockID) -> Option; + + /// Get address code. + fn code(&self, address: &Address) -> Option; + + /// Get address balance at the given block's state. + /// + /// May not return None if given BlockID::Latest. + /// Returns None if and only if the block's root hash has been pruned from the DB. + fn balance(&self, address: &Address, id: BlockID) -> Option; + + /// Get address balance at the latest block's state. + fn latest_balance(&self, address: &Address) -> U256 { + self.balance(address, BlockID::Latest) + .expect("balance will return Some if given BlockID::Latest. balance was given BlockID::Latest \ + Therefore balance has returned Some; qed") + } + + /// Get value of the storage at given position at the given block's state. + /// + /// May not return None if given BlockID::Latest. + /// Returns None if and only if the block's root hash has been pruned from the DB. + fn storage_at(&self, address: &Address, position: &H256, id: BlockID) -> Option; + + /// Get value of the storage at given position at the latest block's state. + fn latest_storage_at(&self, address: &Address, position: &H256) -> H256 { + self.storage_at(address, position, BlockID::Latest) + .expect("storage_at will return Some if given BlockID::Latest. storage_at was given BlockID::Latest. \ + Therefore storage_at has returned Some; qed") + } + + /// Get transaction with given hash. + fn transaction(&self, id: TransactionID) -> Option; + + /// Get uncle with given id. + fn uncle(&self, id: UncleID) -> Option; + + /// Get transaction receipt with given hash. + fn transaction_receipt(&self, id: TransactionID) -> Option; + + /// Get a tree route between `from` and `to`. + /// See `BlockChain::tree_route`. + fn tree_route(&self, from: &H256, to: &H256) -> Option; + + /// Get all possible uncle hashes for a block. + fn find_uncles(&self, hash: &H256) -> Option>; + + /// Get latest state node + fn state_data(&self, hash: &H256) -> Option; + + /// Get raw block receipts data by block header hash. + fn block_receipts(&self, hash: &H256) -> Option; + + /// Import a block into the blockchain. + fn import_block(&self, bytes: Bytes) -> Result; + + /// Get block queue information. + fn queue_info(&self) -> BlockQueueInfo; + + /// Clear block queue and abort all import activity. + fn clear_queue(&self); + + /// Get blockchain information. + fn chain_info(&self) -> BlockChainInfo; + + /// Get the best block header. + fn best_block_header(&self) -> Bytes { + // TODO: lock blockchain only once + self.block_header(BlockID::Hash(self.chain_info().best_block_hash)).unwrap() + } + + /// Returns numbers of blocks containing given bloom. + fn blocks_with_bloom(&self, bloom: &H2048, from_block: BlockID, to_block: BlockID) -> Option>; + + /// Returns logs matching given filter. + fn logs(&self, filter: Filter) -> Vec; + + /// Makes a non-persistent transaction call. + // TODO: should be able to accept blockchain location for call. + fn call(&self, t: &SignedTransaction, analytics: CallAnalytics) -> Result; + + /// Returns traces matching given filter. + fn filter_traces(&self, filter: TraceFilter) -> Option>; + + /// Returns trace with given id. + fn trace(&self, trace: TraceId) -> Option; + + /// Returns traces created by transaction. + fn transaction_traces(&self, trace: TransactionID) -> Option>; + + /// Returns traces created by transaction from block. + fn block_traces(&self, trace: BlockID) -> Option>; + + /// Get last hashes starting from best block. + fn last_hashes(&self) -> LastHashes; + + /// Queue transactions for importing. + fn queue_transactions(&self, transactions: Vec); + + /// list all transactions + fn pending_transactions(&self) -> Vec; + + /// Get the gas price distribution. + fn gas_price_statistics(&self, sample_size: usize, distribution_size: usize) -> Result, ()> { + let mut h = self.chain_info().best_block_hash; + let mut corpus = Vec::new(); + for _ in 0..sample_size { + let block_bytes = self.block(BlockID::Hash(h)).expect("h is either the best_block_hash or an ancestor; qed"); + let block = BlockView::new(&block_bytes); + let header = block.header_view(); + if header.number() == 0 { + break; + } + block.transaction_views().iter().foreach(|t| corpus.push(t.gas_price())); + h = header.parent_hash().clone(); + } + corpus.sort(); + let n = corpus.len(); + if n > 0 { + Ok((0..(distribution_size + 1)) + .map(|i| corpus[i * (n - 1) / distribution_size]) + .collect::>() + ) + } else { + Err(()) + } + } +} + +/// Extended client interface used for mining +pub trait MiningBlockChainClient : BlockChainClient { + /// Returns OpenBlock prepared for closing. + fn prepare_open_block(&self, author: Address, gas_range_target: (U256, U256), extra_data: Bytes) + -> OpenBlock; + + /// Returns EvmFactory. + fn vm_factory(&self) -> &EvmFactory; + + /// Import sealed block. Skips all verifications. + fn import_sealed_block(&self, block: SealedBlock) -> ImportResult; +} + +impl IpcConfig for BlockChainClient { } diff --git a/ethcore/src/json_tests/chain.rs b/ethcore/src/json_tests/chain.rs index 8a2b802e1..6f218c335 100644 --- a/ethcore/src/json_tests/chain.rs +++ b/ethcore/src/json_tests/chain.rs @@ -69,7 +69,7 @@ pub fn json_chain_test(json_data: &[u8], era: ChainEra) -> Vec { if Block::is_good(&b) { let _ = client.import_block(b.clone()); client.flush_queue(); - client.import_verified_blocks(&IoChannel::disconnected()); + client.import_verified_blocks(); } } fail_unless(client.chain_info().best_block_hash == blockchain.best_block.into()); diff --git a/ethcore/src/service.rs b/ethcore/src/service.rs index a09e9c887..1567e77e4 100644 --- a/ethcore/src/service.rs +++ b/ethcore/src/service.rs @@ -121,9 +121,9 @@ impl IoHandler for ClientIoHandler { } #[cfg_attr(feature="dev", allow(single_match))] - fn message(&self, io: &IoContext, net_message: &ClientIoMessage) { + fn message(&self, _io: &IoContext, net_message: &ClientIoMessage) { match *net_message { - ClientIoMessage::BlockVerified => { self.client.import_verified_blocks(&io.channel()); } + ClientIoMessage::BlockVerified => { self.client.import_verified_blocks(); } ClientIoMessage::NewTransactions(ref transactions) => { self.client.import_queued_transactions(&transactions); } _ => {} // ignore other messages } diff --git a/ethcore/src/tests/client.rs b/ethcore/src/tests/client.rs index 63302cb30..bb6fcfdbd 100644 --- a/ethcore/src/tests/client.rs +++ b/ethcore/src/tests/client.rs @@ -25,7 +25,7 @@ use miner::Miner; fn imports_from_empty() { let dir = RandomTempPath::new(); let client = Client::new(ClientConfig::default(), get_test_spec(), dir.as_path(), Arc::new(Miner::with_spec(get_test_spec())), IoChannel::disconnected()).unwrap(); - client.import_verified_blocks(&IoChannel::disconnected()); + client.import_verified_blocks(); client.flush_queue(); } @@ -48,7 +48,7 @@ fn imports_good_block() { panic!("error importing block being good by definition"); } client.flush_queue(); - client.import_verified_blocks(&IoChannel::disconnected()); + client.import_verified_blocks(); let block = client.block_header(BlockID::Number(1)).unwrap(); assert!(!block.is_empty()); @@ -130,7 +130,7 @@ fn can_handle_long_fork() { let client_result = generate_dummy_client(1200); let client = client_result.reference(); for _ in 0..20 { - client.import_verified_blocks(&IoChannel::disconnected()); + client.import_verified_blocks(); } assert_eq!(1200, client.chain_info().best_block_number); @@ -139,7 +139,7 @@ fn can_handle_long_fork() { push_blocks_to_client(client, 53, 1201, 600); for _ in 0..40 { - client.import_verified_blocks(&IoChannel::disconnected()); + client.import_verified_blocks(); } assert_eq!(2000, client.chain_info().best_block_number); } diff --git a/ethcore/src/tests/helpers.rs b/ethcore/src/tests/helpers.rs index 880326cad..6e94d2ee3 100644 --- a/ethcore/src/tests/helpers.rs +++ b/ethcore/src/tests/helpers.rs @@ -192,7 +192,7 @@ pub fn generate_dummy_client_with_spec_and_data(get_test_spec: F, block_numbe db = b.drain(); } client.flush_queue(); - client.import_verified_blocks(&IoChannel::disconnected()); + client.import_verified_blocks(); GuardedTempResult::> { _temp: dir, @@ -238,7 +238,7 @@ pub fn get_test_client_with_blocks(blocks: Vec) -> GuardedTempResult> { _temp: dir, diff --git a/ipc/rpc/src/binary.rs b/ipc/rpc/src/binary.rs index 299e5ee73..e9cefe642 100644 --- a/ipc/rpc/src/binary.rs +++ b/ipc/rpc/src/binary.rs @@ -95,6 +95,34 @@ impl BinaryConvertable for Result<(), E> { } +impl BinaryConvertable for Result { + fn size(&self) -> usize { + match *self { + Ok(ref r) => r.size(), + Err(_) => 0, + } + } + + fn to_bytes(&self, buffer: &mut [u8], length_stack: &mut VecDeque) -> Result<(), BinaryConvertError> { + match *self { + Ok(ref r) => Ok(try!(r.to_bytes(buffer, length_stack))), + Err(_) => Err(BinaryConvertError), + } + } + + fn from_bytes(buffer: &[u8], length_stack: &mut VecDeque) -> Result { + Ok(Ok(try!(R::from_bytes(&buffer, length_stack)))) + } + + fn from_empty_bytes() -> Result { + Ok(Err(())) + } + + fn len_params() -> usize { + 1 + } +} + impl BinaryConvertable for Result { fn size(&self) -> usize { 1usize + match *self { diff --git a/rpc/rpctest/src/main.rs b/rpc/rpctest/src/main.rs index 7078793c2..dd4a9a355 100644 --- a/rpc/rpctest/src/main.rs +++ b/rpc/rpctest/src/main.rs @@ -111,7 +111,7 @@ impl Configuration { for b in &blockchain.blocks_rlp() { let _ = client.import_block(b.clone()); client.flush_queue(); - client.import_verified_blocks(&IoChannel::disconnected()); + client.import_verified_blocks(); } let sync = Arc::new(TestSyncProvider::new(SyncConfig { protocol_version: 65, diff --git a/rpc/src/v1/tests/eth.rs b/rpc/src/v1/tests/eth.rs index a1083b978..8656a4e49 100644 --- a/rpc/src/v1/tests/eth.rs +++ b/rpc/src/v1/tests/eth.rs @@ -95,7 +95,7 @@ impl EthTester { if Block::is_good(&b) { let _ = tester.client.import_block(b.clone()); tester.client.flush_queue(); - tester.client.import_verified_blocks(&IoChannel::disconnected()); + tester.client.import_verified_blocks(); } }