openethereum/sync/src/tests/helpers.rs

424 lines
12 KiB
Rust
Raw Normal View History

2016-02-05 13:40:41 +01:00
// 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 <http://www.gnu.org/licenses/>.
use util::*;
2016-02-25 16:32:34 +01:00
use ethcore::client::{BlockChainClient, BlockStatus, TreeRoute, BlockChainInfo, TransactionId, BlockId, BlockQueueInfo};
2016-01-29 15:56:06 +01:00
use ethcore::header::{Header as BlockHeader, BlockNumber};
use ethcore::error::*;
use io::SyncIo;
2016-02-24 21:23:58 +01:00
use chain::ChainSync;
use ::SyncConfig;
2016-02-04 23:24:36 +01:00
use ethcore::receipt::Receipt;
2016-02-09 18:34:06 +01:00
use ethcore::transaction::LocalizedTransaction;
use ethcore::filter::Filter;
use ethcore::log_entry::LocalizedLogEntry;
2016-02-04 19:30:31 +01:00
pub struct TestBlockChainClient {
pub blocks: RwLock<HashMap<H256, Bytes>>,
pub numbers: RwLock<HashMap<usize, H256>>,
pub genesis_hash: H256,
pub last_hash: RwLock<H256>,
pub difficulty: RwLock<U256>,
2015-12-25 14:55:55 +01:00
}
2015-12-26 15:47:07 +01:00
impl TestBlockChainClient {
2016-02-04 20:03:14 +01:00
pub fn new() -> TestBlockChainClient {
2015-12-26 15:47:07 +01:00
let mut client = TestBlockChainClient {
2016-01-22 05:20:47 +01:00
blocks: RwLock::new(HashMap::new()),
numbers: RwLock::new(HashMap::new()),
2015-12-26 15:47:07 +01:00
genesis_hash: H256::new(),
2016-01-22 05:20:47 +01:00
last_hash: RwLock::new(H256::new()),
difficulty: RwLock::new(From::from(0)),
2015-12-26 15:47:07 +01:00
};
client.add_blocks(1, true); // add genesis block
2016-01-22 05:20:47 +01:00
client.genesis_hash = client.last_hash.read().unwrap().clone();
2015-12-26 15:47:07 +01:00
client
}
pub fn add_blocks(&mut self, count: usize, empty: bool) {
2016-01-22 05:20:47 +01:00
let len = self.numbers.read().unwrap().len();
for n in len..(len + count) {
2015-12-26 15:47:07 +01:00
let mut header = BlockHeader::new();
header.difficulty = From::from(n);
2016-01-22 05:20:47 +01:00
header.parent_hash = self.last_hash.read().unwrap().clone();
header.number = n as BlockNumber;
2015-12-26 15:47:07 +01:00
let mut uncles = RlpStream::new_list(if empty {0} else {1});
if !empty {
2016-01-29 16:38:03 +01:00
let mut uncle_header = BlockHeader::new();
uncle_header.difficulty = From::from(n);
uncle_header.parent_hash = self.last_hash.read().unwrap().clone();
uncle_header.number = n as BlockNumber;
uncles.append(&uncle_header);
2016-01-08 16:00:32 +01:00
header.uncles_hash = uncles.as_raw().sha3();
2015-12-26 15:47:07 +01:00
}
let mut rlp = RlpStream::new_list(3);
rlp.append(&header);
rlp.append_raw(&rlp::NULL_RLP, 1);
2016-01-08 16:00:32 +01:00
rlp.append_raw(uncles.as_raw(), 1);
2016-01-17 23:07:58 +01:00
self.import_block(rlp.as_raw().to_vec()).unwrap();
2015-12-26 15:47:07 +01:00
}
}
2016-02-05 23:45:25 +01:00
pub fn corrupt_block(&mut self, n: BlockNumber) {
let hash = self.block_hash(BlockId::Number(n)).unwrap();
let mut header: BlockHeader = decode(&self.block_header(BlockId::Number(n)).unwrap());
header.parent_hash = H256::new();
let mut rlp = RlpStream::new_list(3);
rlp.append(&header);
rlp.append_raw(&rlp::NULL_RLP, 1);
rlp.append_raw(&rlp::NULL_RLP, 1);
self.blocks.write().unwrap().insert(hash, rlp.out());
}
2016-02-05 23:45:25 +01:00
pub fn block_hash_delta_minus(&mut self, delta: usize) -> H256 {
let blocks_read = self.numbers.read().unwrap();
let index = blocks_read.len() - delta;
blocks_read[&index].clone()
}
fn block_hash(&self, id: BlockId) -> Option<H256> {
match id {
BlockId::Hash(hash) => Some(hash),
2016-02-10 22:36:59 +01:00
BlockId::Number(n) => self.numbers.read().unwrap().get(&(n as usize)).cloned(),
BlockId::Earliest => self.numbers.read().unwrap().get(&0).cloned(),
BlockId::Latest => self.numbers.read().unwrap().get(&(self.numbers.read().unwrap().len() - 1)).cloned()
}
}
2015-12-26 15:47:07 +01:00
}
impl BlockChainClient for TestBlockChainClient {
fn block_total_difficulty(&self, _id: BlockId) -> Option<U256> {
2016-02-07 23:39:02 +01:00
Some(U256::zero())
2016-01-27 16:58:53 +01:00
}
2016-02-08 16:07:38 +01:00
fn code(&self, _address: &Address) -> Option<Bytes> {
unimplemented!();
}
2016-02-10 11:44:03 +01:00
fn transaction(&self, _id: TransactionId) -> Option<LocalizedTransaction> {
2016-02-09 18:34:06 +01:00
unimplemented!();
}
2016-02-15 17:47:01 +01:00
fn blocks_with_bloom(&self, _bloom: &H2048, _from_block: BlockId, _to_block: BlockId) -> Option<Vec<BlockNumber>> {
unimplemented!();
}
fn logs(&self, filter: Filter) -> Vec<LocalizedLogEntry> {
unimplemented!();
}
fn block_header(&self, id: BlockId) -> Option<Bytes> {
self.block_hash(id).and_then(|hash| self.blocks.read().unwrap().get(&hash).map(|r| Rlp::new(r).at(0).as_raw().to_vec()))
2015-12-26 15:47:07 +01:00
}
fn block_body(&self, id: BlockId) -> Option<Bytes> {
self.block_hash(id).and_then(|hash| self.blocks.read().unwrap().get(&hash).map(|r| {
2015-12-27 00:48:03 +01:00
let mut stream = RlpStream::new_list(2);
2016-01-08 16:00:32 +01:00
stream.append_raw(Rlp::new(&r).at(1).as_raw(), 1);
stream.append_raw(Rlp::new(&r).at(2).as_raw(), 1);
2015-12-27 00:48:03 +01:00
stream.out()
}))
2015-12-26 15:47:07 +01:00
}
fn block(&self, id: BlockId) -> Option<Bytes> {
self.block_hash(id).and_then(|hash| self.blocks.read().unwrap().get(&hash).cloned())
2015-12-26 15:47:07 +01:00
}
fn block_status(&self, id: BlockId) -> BlockStatus {
match id {
BlockId::Number(number) if (number as usize) < self.blocks.read().unwrap().len() => BlockStatus::InChain,
BlockId::Hash(ref hash) if self.blocks.read().unwrap().get(hash).is_some() => BlockStatus::InChain,
_ => BlockStatus::Unknown
2015-12-26 15:47:07 +01:00
}
}
2016-02-05 23:45:25 +01:00
// works only if blocks are one after another 1 -> 2 -> 3
fn tree_route(&self, from: &H256, to: &H256) -> Option<TreeRoute> {
2016-01-10 23:37:09 +01:00
Some(TreeRoute {
2015-12-26 15:47:07 +01:00
ancestor: H256::new(),
2016-02-05 23:45:25 +01:00
index: 0,
blocks: {
let numbers_read = self.numbers.read().unwrap();
let mut adding = false;
let mut blocks = Vec::new();
for (_, hash) in numbers_read.iter().sort_by(|tuple1, tuple2| tuple1.0.cmp(tuple2.0)) {
if hash == to {
if adding {
blocks.push(hash.clone());
}
adding = false;
break;
}
if hash == from {
adding = true;
}
if adding {
blocks.push(hash.clone());
}
}
if adding { Vec::new() } else { blocks }
}
2016-01-10 23:37:09 +01:00
})
2015-12-26 15:47:07 +01:00
}
2016-02-05 00:57:51 +01:00
// TODO: returns just hashes instead of node state rlp(?)
fn state_data(&self, hash: &H256) -> Option<Bytes> {
// starts with 'f' ?
if *hash > H256::from("f000000000000000000000000000000000000000000000000000000000000000") {
let mut rlp = RlpStream::new();
rlp.append(&hash.clone());
return Some(rlp.out());
}
2015-12-26 15:47:07 +01:00
None
}
2016-02-04 23:24:36 +01:00
fn block_receipts(&self, hash: &H256) -> Option<Bytes> {
// starts with 'f' ?
if *hash > H256::from("f000000000000000000000000000000000000000000000000000000000000000") {
let receipt = Receipt::new(
H256::zero(),
U256::zero(),
vec![]);
let mut rlp = RlpStream::new();
rlp.append(&receipt);
return Some(rlp.out());
}
2015-12-26 15:47:07 +01:00
None
}
2016-01-22 05:20:47 +01:00
fn import_block(&self, b: Bytes) -> ImportResult {
2015-12-26 15:47:07 +01:00
let header = Rlp::new(&b).val_at::<BlockHeader>(0);
let h = header.hash();
let number: usize = header.number as usize;
2016-01-22 05:20:47 +01:00
if number > self.blocks.read().unwrap().len() {
panic!("Unexpected block number. Expected {}, got {}", self.blocks.read().unwrap().len(), number);
2015-12-26 15:47:07 +01:00
}
2015-12-27 00:48:03 +01:00
if number > 0 {
2016-01-22 05:20:47 +01:00
match self.blocks.read().unwrap().get(&header.parent_hash) {
2015-12-27 00:48:03 +01:00
Some(parent) => {
let parent = Rlp::new(parent).val_at::<BlockHeader>(0);
if parent.number != (header.number - 1) {
2015-12-27 00:48:03 +01:00
panic!("Unexpected block parent");
}
},
None => {
panic!("Unknown block parent {:?} for block {}", header.parent_hash, number);
}
2015-12-26 15:47:07 +01:00
}
}
let len = self.numbers.read().unwrap().len();
if number == len {
2016-02-19 00:50:23 +01:00
{
let mut difficulty = self.difficulty.write().unwrap();
*difficulty.deref_mut() = *difficulty.deref() + header.difficulty;
}
mem::replace(self.last_hash.write().unwrap().deref_mut(), h.clone());
self.blocks.write().unwrap().insert(h.clone(), b);
self.numbers.write().unwrap().insert(number, h.clone());
2015-12-27 00:48:03 +01:00
let mut parent_hash = header.parent_hash;
if number > 0 {
let mut n = number - 1;
2016-01-22 05:20:47 +01:00
while n > 0 && self.numbers.read().unwrap()[&n] != parent_hash {
*self.numbers.write().unwrap().get_mut(&n).unwrap() = parent_hash.clone();
2015-12-27 00:48:03 +01:00
n -= 1;
2016-01-22 05:20:47 +01:00
parent_hash = Rlp::new(&self.blocks.read().unwrap()[&parent_hash]).val_at::<BlockHeader>(0).parent_hash;
2015-12-27 00:48:03 +01:00
}
}
}
else {
self.blocks.write().unwrap().insert(h.clone(), b.to_vec());
2015-12-27 00:48:03 +01:00
}
Ok(h)
2015-12-26 15:47:07 +01:00
}
2016-01-22 05:20:47 +01:00
fn queue_info(&self) -> BlockQueueInfo {
BlockQueueInfo {
verified_queue_size: 0,
unverified_queue_size: 0,
2016-01-25 23:24:51 +01:00
verifying_queue_size: 0,
2016-02-25 16:32:34 +01:00
max_queue_size: 0,
max_mem_use: 0,
2016-02-25 14:09:39 +01:00
mem_used: 0,
2015-12-26 15:47:07 +01:00
}
}
2016-01-22 05:20:47 +01:00
fn clear_queue(&self) {
2015-12-26 15:47:07 +01:00
}
2016-01-07 20:43:37 +01:00
fn chain_info(&self) -> BlockChainInfo {
2015-12-26 15:47:07 +01:00
BlockChainInfo {
2016-01-22 05:20:47 +01:00
total_difficulty: *self.difficulty.read().unwrap(),
pending_total_difficulty: *self.difficulty.read().unwrap(),
2016-01-04 13:25:32 +01:00
genesis_hash: self.genesis_hash.clone(),
2016-01-22 05:20:47 +01:00
best_block_hash: self.last_hash.read().unwrap().clone(),
best_block_number: self.blocks.read().unwrap().len() as BlockNumber - 1,
2015-12-26 15:47:07 +01:00
}
}
}
2016-02-04 19:30:31 +01:00
pub struct TestIo<'p> {
pub chain: &'p mut TestBlockChainClient,
pub queue: &'p mut VecDeque<TestPacket>,
pub sender: Option<PeerId>,
2015-12-26 15:47:07 +01:00
}
impl<'p> TestIo<'p> {
2016-02-04 20:03:14 +01:00
pub fn new(chain: &'p mut TestBlockChainClient, queue: &'p mut VecDeque<TestPacket>, sender: Option<PeerId>) -> TestIo<'p> {
2015-12-26 15:47:07 +01:00
TestIo {
chain: chain,
queue: queue,
sender: sender
}
}
}
impl<'p> SyncIo for TestIo<'p> {
fn disable_peer(&mut self, _peer_id: PeerId) {
2015-12-26 15:47:07 +01:00
}
2016-02-02 14:54:46 +01:00
fn disconnect_peer(&mut self, _peer_id: PeerId) {
}
2016-01-10 15:08:57 +01:00
fn respond(&mut self, packet_id: PacketId, data: Vec<u8>) -> Result<(), UtilError> {
2015-12-26 15:47:07 +01:00
self.queue.push_back(TestPacket {
data: data,
packet_id: packet_id,
recipient: self.sender.unwrap()
});
Ok(())
}
2016-01-10 15:08:57 +01:00
fn send(&mut self, peer_id: PeerId, packet_id: PacketId, data: Vec<u8>) -> Result<(), UtilError> {
2015-12-26 15:47:07 +01:00
self.queue.push_back(TestPacket {
data: data,
packet_id: packet_id,
recipient: peer_id,
});
Ok(())
}
fn chain(&self) -> &BlockChainClient {
2015-12-26 15:47:07 +01:00
self.chain
}
}
2016-02-04 19:30:31 +01:00
pub struct TestPacket {
pub data: Bytes,
pub packet_id: PacketId,
pub recipient: PeerId,
2015-12-26 15:47:07 +01:00
}
2016-02-04 19:30:31 +01:00
pub struct TestPeer {
pub chain: TestBlockChainClient,
pub sync: ChainSync,
pub queue: VecDeque<TestPacket>,
2015-12-26 15:47:07 +01:00
}
2016-02-04 19:30:31 +01:00
pub struct TestNet {
pub peers: Vec<TestPeer>,
pub started: bool,
2015-12-26 15:47:07 +01:00
}
impl TestNet {
pub fn new(n: usize) -> TestNet {
let mut net = TestNet {
peers: Vec::new(),
2016-02-03 21:42:30 +01:00
started: false,
2015-12-26 15:47:07 +01:00
};
for _ in 0..n {
net.peers.push(TestPeer {
chain: TestBlockChainClient::new(),
2016-02-24 21:23:58 +01:00
sync: ChainSync::new(SyncConfig::default()),
2015-12-26 15:47:07 +01:00
queue: VecDeque::new(),
});
}
net
}
2015-12-27 00:48:03 +01:00
pub fn peer(&self, i: usize) -> &TestPeer {
self.peers.get(i).unwrap()
}
pub fn peer_mut(&mut self, i: usize) -> &mut TestPeer {
2015-12-26 15:47:07 +01:00
self.peers.get_mut(i).unwrap()
}
pub fn start(&mut self) {
for peer in 0..self.peers.len() {
for client in 0..self.peers.len() {
if peer != client {
let mut p = self.peers.get_mut(peer).unwrap();
p.sync.on_peer_connected(&mut TestIo::new(&mut p.chain, &mut p.queue, Some(client as PeerId)), client as PeerId);
2015-12-26 15:47:07 +01:00
}
}
}
}
pub fn sync_step(&mut self) {
for peer in 0..self.peers.len() {
2016-01-19 13:47:30 +01:00
if let Some(packet) = self.peers[peer].queue.pop_front() {
let mut p = self.peers.get_mut(packet.recipient).unwrap();
trace!("--- {} -> {} ---", peer, packet.recipient);
p.sync.on_packet(&mut TestIo::new(&mut p.chain, &mut p.queue, Some(peer as PeerId)), peer as PeerId, packet.packet_id, &packet.data);
trace!("----------------");
2015-12-26 15:47:07 +01:00
}
let mut p = self.peers.get_mut(peer).unwrap();
2016-02-04 03:10:05 +01:00
p.sync.maintain_sync(&mut TestIo::new(&mut p.chain, &mut p.queue, None));
2015-12-26 15:47:07 +01:00
}
}
2016-02-05 18:34:08 +01:00
pub fn sync_step_peer(&mut self, peer_num: usize) {
let mut peer = self.peer_mut(peer_num);
peer.sync.maintain_sync(&mut TestIo::new(&mut peer.chain, &mut peer.queue, None));
}
2016-02-03 21:42:30 +01:00
pub fn restart_peer(&mut self, i: usize) {
let peer = self.peer_mut(i);
peer.sync.restart(&mut TestIo::new(&mut peer.chain, &mut peer.queue, None));
}
pub fn sync(&mut self) -> u32 {
2015-12-26 15:47:07 +01:00
self.start();
2016-02-03 21:42:30 +01:00
let mut total_steps = 0;
2015-12-26 15:47:07 +01:00
while !self.done() {
2016-02-03 21:42:30 +01:00
self.sync_step();
total_steps = total_steps + 1;
}
total_steps
}
pub fn sync_steps(&mut self, count: usize) {
if !self.started {
self.start();
self.started = true;
}
for _ in 0..count {
self.sync_step();
2015-12-26 15:47:07 +01:00
}
}
pub fn done(&self) -> bool {
self.peers.iter().all(|p| p.queue.is_empty())
}
2016-02-07 01:00:43 +01:00
pub fn trigger_block_verified(&mut self, peer_id: usize) {
let mut peer = self.peer_mut(peer_id);
peer.sync.chain_blocks_verified(&mut TestIo::new(&mut peer.chain, &mut peer.queue, None));
}
2015-12-26 15:47:07 +01:00
}