openethereum/ethcore/src/snapshot/watcher.rs

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

222 lines
5.8 KiB
Rust
Raw Normal View History

2020-09-22 14:53:52 +02:00
// Copyright 2015-2020 Parity Technologies (UK) Ltd.
// This file is part of OpenEthereum.
2016-09-02 18:28:47 +02:00
2020-09-22 14:53:52 +02:00
// OpenEthereum is free software: you can redistribute it and/or modify
2016-09-02 18:28:47 +02:00
// 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.
2020-09-22 14:53:52 +02:00
// OpenEthereum is distributed in the hope that it will be useful,
2016-09-02 18:28:47 +02:00
// 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
2020-09-22 14:53:52 +02:00
// along with OpenEthereum. If not, see <http://www.gnu.org/licenses/>.
2016-09-02 18:28:47 +02:00
//! Watcher for snapshot-related chain events.
use client::{BlockInfo, ChainNotify, Client, ClientIoMessage, NewBlocks};
use parking_lot::Mutex;
use types::ids::BlockId;
2016-09-02 18:28:47 +02:00
use ethereum_types::H256;
2016-09-02 18:28:47 +02:00
use io::IoChannel;
use std::sync::Arc;
2016-09-02 18:28:47 +02:00
// helper trait for transforming hashes to numbers and checking if syncing.
trait Oracle: Send + Sync {
2016-09-02 18:28:47 +02:00
fn to_number(&self, hash: H256) -> Option<u64>;
fn is_major_importing(&self) -> bool;
2016-09-02 18:28:47 +02:00
}
struct StandardOracle<F>
where
F: 'static + Send + Sync + Fn() -> bool,
{
client: Arc<Client>,
sync_status: F,
}
impl<F> Oracle for StandardOracle<F>
where
F: Send + Sync + Fn() -> bool,
{
2016-09-02 18:28:47 +02:00
fn to_number(&self, hash: H256) -> Option<u64> {
self.client
.block_header(BlockId::Hash(hash))
.map(|h| h.number())
2016-09-02 18:28:47 +02:00
}
2020-08-05 06:08:03 +02:00
fn is_major_importing(&self) -> bool {
(self.sync_status)()
}
2016-09-02 18:28:47 +02:00
}
2016-09-05 12:17:21 +02:00
// helper trait for broadcasting a block to take a snapshot at.
trait Broadcast: Send + Sync {
fn take_at(&self, num: Option<u64>);
}
2016-10-30 09:56:34 +01:00
impl Broadcast for Mutex<IoChannel<ClientIoMessage>> {
2016-09-05 12:17:21 +02:00
fn take_at(&self, num: Option<u64>) {
let num = match num {
Some(n) => n,
None => return,
};
2020-08-05 06:08:03 +02:00
2016-09-05 14:25:56 +02:00
trace!(target: "snapshot_watcher", "broadcast: {}", num);
2020-08-05 06:08:03 +02:00
2016-10-30 09:56:34 +01:00
if let Err(e) = self.lock().send(ClientIoMessage::TakeSnapshot(num)) {
2016-09-05 12:17:21 +02:00
warn!("Snapshot watcher disconnected from IoService: {}", e);
}
}
}
2016-09-02 18:28:47 +02:00
/// A `ChainNotify` implementation which will trigger a snapshot event
/// at certain block numbers.
pub struct Watcher {
2020-07-29 10:36:15 +02:00
oracle: Box<dyn Oracle>,
broadcast: Box<dyn Broadcast>,
2016-09-02 18:28:47 +02:00
period: u64,
history: u64,
}
impl Watcher {
/// Create a new `Watcher` which will trigger a snapshot event
/// once every `period` blocks, but only after that block is
/// `history` blocks old.
pub fn new<F>(
client: Arc<Client>,
sync_status: F,
channel: IoChannel<ClientIoMessage>,
period: u64,
history: u64,
) -> Self
where
F: 'static + Send + Sync + Fn() -> bool,
{
2016-09-02 18:28:47 +02:00
Watcher {
oracle: Box::new(StandardOracle {
client: client,
sync_status: sync_status,
}),
2016-10-30 09:56:34 +01:00
broadcast: Box::new(Mutex::new(channel)),
2016-09-02 18:28:47 +02:00
period: period,
history: history,
}
}
}
impl ChainNotify for Watcher {
fn new_blocks(&self, new_blocks: NewBlocks) {
if self.oracle.is_major_importing() || new_blocks.has_more_blocks_to_import {
return;
}
2020-08-05 06:08:03 +02:00
trace!(target: "snapshot_watcher", "{} imported", new_blocks.imported.len());
2020-08-05 06:08:03 +02:00
let highest = new_blocks
.imported
.into_iter()
2016-09-02 18:28:47 +02:00
.filter_map(|h| self.oracle.to_number(h))
.filter(|&num| num >= self.period + self.history)
.map(|num| num - self.history)
.filter(|num| num % self.period == 0)
.fold(0, ::std::cmp::max);
2020-08-05 06:08:03 +02:00
2016-09-05 12:17:21 +02:00
match highest {
0 => self.broadcast.take_at(None),
_ => self.broadcast.take_at(Some(highest)),
2016-09-02 18:28:47 +02:00
}
}
}
#[cfg(test)]
mod tests {
use super::{Broadcast, Oracle, Watcher};
2020-08-05 06:08:03 +02:00
use client::{ChainNotify, ChainRoute, NewBlocks};
2020-08-05 06:08:03 +02:00
use ethereum_types::{H256, U256};
2020-08-05 06:08:03 +02:00
2016-09-02 18:28:47 +02:00
use std::{collections::HashMap, time::Duration};
2020-08-05 06:08:03 +02:00
2016-09-02 18:28:47 +02:00
struct TestOracle(HashMap<H256, u64>);
2020-08-05 06:08:03 +02:00
impl Oracle for TestOracle {
2016-09-02 18:28:47 +02:00
fn to_number(&self, hash: H256) -> Option<u64> {
self.0.get(&hash).cloned()
}
2020-08-05 06:08:03 +02:00
fn is_major_importing(&self) -> bool {
false
2020-08-05 06:08:03 +02:00
}
}
2020-08-05 06:08:03 +02:00
2016-09-05 12:17:21 +02:00
struct TestBroadcast(Option<u64>);
impl Broadcast for TestBroadcast {
fn take_at(&self, num: Option<u64>) {
if num != self.0 {
panic!(
"Watcher broadcast wrong number. Expected {:?}, found {:?}",
self.0, num
);
2016-09-02 18:28:47 +02:00
}
}
2020-08-05 06:08:03 +02:00
}
2016-09-05 12:17:21 +02:00
// helper harness for tests which expect a notification.
fn harness(numbers: Vec<u64>, period: u64, history: u64, expected: Option<u64>) {
const DURATION_ZERO: Duration = Duration::from_millis(0);
2020-08-05 06:08:03 +02:00
2016-09-02 18:28:47 +02:00
let hashes: Vec<_> = numbers
.clone()
.into_iter()
.map(|x| H256::from(U256::from(x)))
.collect();
2016-09-05 12:17:21 +02:00
let map = hashes.clone().into_iter().zip(numbers).collect();
2020-08-05 06:08:03 +02:00
2016-09-02 18:28:47 +02:00
let watcher = Watcher {
oracle: Box::new(TestOracle(map)),
2016-09-05 12:17:21 +02:00
broadcast: Box::new(TestBroadcast(expected)),
2016-09-02 18:28:47 +02:00
period: period,
history: history,
};
2020-08-05 06:08:03 +02:00
watcher.new_blocks(NewBlocks::new(
2016-09-02 18:28:47 +02:00
hashes,
vec![],
ChainRoute::default(),
2016-12-08 12:03:34 +01:00
vec![],
2020-08-05 06:08:03 +02:00
vec![],
DURATION_ZERO,
false,
));
2016-09-02 18:28:47 +02:00
}
2020-08-05 06:08:03 +02:00
2016-09-05 12:17:21 +02:00
// helper
2020-08-05 06:08:03 +02:00
2016-09-02 18:28:47 +02:00
#[test]
fn should_not_fire() {
2016-09-05 12:17:21 +02:00
harness(vec![0], 5, 0, None);
2016-09-02 18:28:47 +02:00
}
2020-08-05 06:08:03 +02:00
2016-09-02 18:28:47 +02:00
#[test]
fn fires_once_for_two() {
2016-09-05 12:17:21 +02:00
harness(vec![14, 15], 10, 5, Some(10));
2016-09-02 18:28:47 +02:00
}
2020-08-05 06:08:03 +02:00
2016-09-02 18:28:47 +02:00
#[test]
fn finds_highest() {
2016-09-05 12:17:21 +02:00
harness(vec![15, 25], 10, 5, Some(20));
2016-09-02 18:28:47 +02:00
}
2020-08-05 06:08:03 +02:00
2016-09-02 18:28:47 +02:00
#[test]
fn doesnt_fire_before_history() {
2016-09-05 12:17:21 +02:00
harness(vec![10, 11], 10, 5, None);
2016-09-02 18:28:47 +02:00
}
}