grassrootseconomics/openethereum
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

[beta] Using pending block only if is not old (#2515)

Browse Source 
* Using pending block only if not old

Conflicts:
	ethcore/src/miner/miner.rs
	rpc/src/v1/impls/eth.rs
	rpc/src/v1/impls/eth_filter.rs

* Fixing compilation issues
This commit is contained in:
Tomasz Drwięga
2016-10-07 12:46:17 +02:00
committed by Gav Wood
parent bbaf5ed4f5
commit 73a3dac38c
9 changed files with 164 additions and 84 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
rpc/src/v1/impls/eth.rs
View File

@@ -32,7 +32,7 @@ use util::rlp::{encode, decode, UntrustedRlp, View};
use util::{FromHex, Mutex};
use ethcore::account_provider::AccountProvider;
use ethcore::client::{MiningBlockChainClient, BlockID, TransactionID, UncleID};
use ethcore::header::Header as BlockHeader;
use ethcore::header::{Header as BlockHeader, BlockNumber as EthBlockNumber};
use ethcore::block::IsBlock;
use ethcore::views::*;
use ethcore::ethereum::Ethash;
@@ -193,8 +193,8 @@ impl<C, S: ?Sized, M, EM> EthClient<C, S, M, EM> where
}
}
pub fn pending_logs<M>(miner: &M, filter: &EthcoreFilter) -> Vec<Log> where M: MinerService {
let receipts = miner.pending_receipts();
pub fn pending_logs<M>(miner: &M, best_block: EthBlockNumber, filter: &EthcoreFilter) -> Vec<Log> where M: MinerService {
let receipts = miner.pending_receipts(best_block);
let pending_logs = receipts.into_iter()
.flat_map(|(hash, r)| r.logs.into_iter().map(|l| (hash.clone(), l)).collect::<Vec<(H256, LogEntry)>>())
@@ -437,7 +437,7 @@ impl<C, S: ?Sized, M, EM> Eth for EthClient<C, S, M, EM> where
let miner = take_weak!(self.miner);
let client = take_weak!(self.client);
let maybe_tx = client.transaction(TransactionID::Hash(hash)).map(Transaction::from)
.or_else(|| miner.transaction(&hash).map(Transaction::from));
.or_else(|| miner.transaction(client.chain_info().best_block_number, &hash).map(Transaction::from));
match maybe_tx {
Some(t) => to_value(&t),
None => Ok(Value::Null),
@@ -462,8 +462,9 @@ impl<C, S: ?Sized, M, EM> Eth for EthClient<C, S, M, EM> where
from_params::<(RpcH256,)>(params)
.and_then(|(hash,)| {
let miner = take_weak!(self.miner);
let best_block = take_weak!(self.client).chain_info().best_block_number;
let hash: H256 = hash.into();
match (miner.pending_receipt(&hash), self.options.allow_pending_receipt_query) {
match (miner.pending_receipt(best_block, &hash), self.options.allow_pending_receipt_query) {
(Some(receipt), true) => to_value(&Receipt::from(receipt)),
_ => {
let client = take_weak!(self.client);
@@ -509,7 +510,8 @@ impl<C, S: ?Sized, M, EM> Eth for EthClient<C, S, M, EM> where
.collect::<Vec<Log>>();
if include_pending {
let pending = pending_logs(&*take_weak!(self.miner), &filter);
let best_block = take_weak!(self.client).chain_info().best_block_number;
let pending = pending_logs(&*take_weak!(self.miner), best_block, &filter);
logs.extend(pending);
}

12
rpc/src/v1/impls/eth_filter.rs
View File

@@ -88,7 +88,8 @@ impl<C, M> EthFilter for EthFilterClient<C, M> where
try!(expect_no_params(params));
let mut polls = self.polls.lock();
let pending_transactions = take_weak!(self.miner).pending_transactions_hashes();
let best_block = take_weak!(self.client).chain_info().best_block_number;
let pending_transactions = take_weak!(self.miner).pending_transactions_hashes(best_block);
let id = polls.create_poll(PollFilter::PendingTransaction(pending_transactions));
to_value(&RpcU256::from(id))
@@ -118,7 +119,8 @@ impl<C, M> EthFilter for EthFilterClient<C, M> where
},
PollFilter::PendingTransaction(ref mut previous_hashes) => {
// get hashes of pending transactions
let current_hashes = take_weak!(self.miner).pending_transactions_hashes();
let current_number = client.chain_info().best_block_number;
let current_hashes = take_weak!(self.miner).pending_transactions_hashes(current_number);
let new_hashes =
{
@@ -159,7 +161,7 @@ impl<C, M> EthFilter for EthFilterClient<C, M> where
// additionally retrieve pending logs
if include_pending {
let pending_logs = pending_logs(&*take_weak!(self.miner), &filter);
let pending_logs = pending_logs(&*take_weak!(self.miner), current_number, &filter);
// remove logs about which client was already notified about
let new_pending_logs: Vec<_> = pending_logs.iter()
@@ -177,7 +179,6 @@ impl<C, M> EthFilter for EthFilterClient<C, M> where
// save the number of the next block as a first block from which
// we want to get logs
*block_number = current_number + 1;
to_value(&logs)
}
}
@@ -200,7 +201,8 @@ impl<C, M> EthFilter for EthFilterClient<C, M> where
.collect::<Vec<Log>>();
if include_pending {
logs.extend(pending_logs(&*take_weak!(self.miner), &filter));
let best_block = take_weak!(self.client).chain_info().best_block_number;
logs.extend(pending_logs(&*take_weak!(self.miner), best_block, &filter));
}
to_value(&logs)

3
rpc/src/v1/tests/eth.rs
View File

@@ -25,7 +25,7 @@ use ethcore::spec::{Genesis, Spec};
use ethcore::block::Block;
use ethcore::views::BlockView;
use ethcore::ethereum;
use ethcore::miner::{MinerOptions, GasPricer, MinerService, ExternalMiner, Miner, PendingSet};
use ethcore::miner::{MinerOptions, GasPricer, MinerService, ExternalMiner, Miner, PendingSet, PrioritizationStrategy};
use ethcore::account_provider::AccountProvider;
use devtools::RandomTempPath;
use util::Hashable;
@@ -58,6 +58,7 @@ fn miner_service(spec: &Spec, accounts: Arc<AccountProvider>) -> Arc<Miner> {
reseal_on_external_tx: true,
reseal_on_own_tx: true,
tx_queue_size: 1024,
tx_queue_strategy: PrioritizationStrategy::GasPriceOnly,
tx_gas_limit: !U256::zero(),
pending_set: PendingSet::SealingOrElseQueue,
reseal_min_period: Duration::from_secs(0),

13
rpc/src/v1/tests/helpers/miner_service.rs
View File

@@ -21,6 +21,7 @@ use util::standard::*;
use ethcore::error::{Error, CallError};
use ethcore::client::{MiningBlockChainClient, Executed, CallAnalytics};
use ethcore::block::{ClosedBlock, IsBlock};
use ethcore::header::BlockNumber;
use ethcore::transaction::SignedTransaction;
use ethcore::receipt::{Receipt, RichReceipt};
use ethcore::miner::{MinerService, MinerStatus, TransactionImportResult};
@@ -162,7 +163,7 @@ impl MinerService for TestMinerService {
}
/// Returns hashes of transactions currently in pending
fn pending_transactions_hashes(&self) -> Vec<H256> {
fn pending_transactions_hashes(&self, _best_block: BlockNumber) -> Vec<H256> {
vec![]
}
@@ -186,7 +187,7 @@ impl MinerService for TestMinerService {
Some(f(&open_block.close()))
}
fn transaction(&self, hash: &H256) -> Option<SignedTransaction> {
fn transaction(&self, _best_block: BlockNumber, hash: &H256) -> Option<SignedTransaction> {
self.pending_transactions.lock().get(hash).cloned()
}
@@ -194,13 +195,13 @@ impl MinerService for TestMinerService {
self.pending_transactions.lock().values().cloned().collect()
}
fn pending_transactions(&self) -> Vec<SignedTransaction> {
fn pending_transactions(&self, _best_block: BlockNumber) -> Vec<SignedTransaction> {
self.pending_transactions.lock().values().cloned().collect()
}
fn pending_receipt(&self, hash: &H256) -> Option<RichReceipt> {
fn pending_receipt(&self, _best_block: BlockNumber, hash: &H256) -> Option<RichReceipt> {
// Not much point implementing this since the logic is complex and the only thing it relies on is pending_receipts, which is already tested.
self.pending_receipts().get(hash).map(|r|
self.pending_receipts(0).get(hash).map(|r|
RichReceipt {
transaction_hash: Default::default(),
transaction_index: Default::default(),
@@ -212,7 +213,7 @@ impl MinerService for TestMinerService {
)
}
fn pending_receipts(&self) -> BTreeMap<H256, Receipt> {
fn pending_receipts(&self, _best_block: BlockNumber) -> BTreeMap<H256, Receipt> {
self.pending_receipts.lock().clone()
}