jleony/nanoreth
1
0
Fork 0
mirror of https://github.com/hl-archive-node/nanoreth.git synced 2025-12-06 10:59:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore: remove empty EngineHookAction (#6019)

Browse Source
This commit is contained in:
Dan Cline
2024-01-10 17:42:47 -05:00
committed by GitHub
parent 26e31f3197
commit 08dff3642d
5 changed files with 43 additions and 80 deletions
Download Patch File Download Diff File Expand all files Collapse all files

59
crates/consensus/beacon/src/engine/hooks/controller.rs
View File

@ -1,6 +1,6 @@
use crate::hooks::{
EngineContext, EngineHook, EngineHookAction, EngineHookDBAccessLevel, EngineHookError,
EngineHookEvent, EngineHooks,
EngineContext, EngineHook, EngineHookDBAccessLevel, EngineHookError, EngineHookEvent,
EngineHooks,
};
use std::{
collections::VecDeque,
@ -13,7 +13,6 @@ pub(crate) struct PolledHook {
#[allow(dead_code)]
pub(crate) name: &'static str,
pub(crate) event: EngineHookEvent,
pub(crate) action: Option<EngineHookAction>,
pub(crate) db_access_level: EngineHookDBAccessLevel,
}
@ -41,8 +40,7 @@ impl EngineHooksController {
/// Polls currently running hook with DB write access, if any.
///
/// Returns [`Poll::Ready`] if currently running hook with DB write access returned
/// an [event][`crate::hooks::EngineHookEvent`] that resulted in [action][`EngineHookAction`] or
/// error.
/// an [event][`crate::hooks::EngineHookEvent`].
///
/// Returns [`Poll::Pending`] in all other cases:
/// 1. No hook with DB write access is running.
@ -57,11 +55,10 @@ impl EngineHooksController {
let Some(mut hook) = self.active_db_write_hook.take() else { return Poll::Pending };
match hook.poll(cx, args)? {
Poll::Ready((event, action)) => {
Poll::Ready(event) => {
let result = PolledHook {
name: hook.name(),
event,
action,
db_access_level: hook.db_access_level(),
};
@ -90,8 +87,7 @@ impl EngineHooksController {
/// Polls next engine from the collection.
///
/// Returns [`Poll::Ready`] if next hook returned an [event][`crate::hooks::EngineHookEvent`]
/// that resulted in [action][`EngineHookAction`].
/// Returns [`Poll::Ready`] if next hook returned an [event][`crate::hooks::EngineHookEvent`].
///
/// Returns [`Poll::Pending`] in all other cases:
/// 1. Next hook is [`Option::None`], i.e. taken, meaning it's currently running and has a DB
@ -143,13 +139,9 @@ impl EngineHooksController {
return Poll::Pending
}
if let Poll::Ready((event, action)) = hook.poll(cx, args)? {
let result = PolledHook {
name: hook.name(),
event,
action,
db_access_level: hook.db_access_level(),
};
if let Poll::Ready(event) = hook.poll(cx, args)? {
let result =
PolledHook { name: hook.name(), event, db_access_level: hook.db_access_level() };
debug!(
target: "consensus::engine::hooks",
@ -173,8 +165,8 @@ impl EngineHooksController {
#[cfg(test)]
mod tests {
use crate::hooks::{
EngineContext, EngineHook, EngineHookAction, EngineHookDBAccessLevel, EngineHookEvent,
EngineHooks, EngineHooksController,
EngineContext, EngineHook, EngineHookDBAccessLevel, EngineHookEvent, EngineHooks,
EngineHooksController,
};
use futures::poll;
use reth_interfaces::{RethError, RethResult};
@ -185,7 +177,7 @@ mod tests {
};
struct TestHook {
results: VecDeque<RethResult<(EngineHookEvent, Option<EngineHookAction>)>>,
results: VecDeque<RethResult<EngineHookEvent>>,
name: &'static str,
access_level: EngineHookDBAccessLevel,
}
@ -206,7 +198,7 @@ mod tests {
}
}
fn add_result(&mut self, result: RethResult<(EngineHookEvent, Option<EngineHookAction>)>) {
fn add_result(&mut self, result: RethResult<EngineHookEvent>) {
self.results.push_back(result);
}
}
@ -220,7 +212,7 @@ mod tests {
&mut self,
_cx: &mut Context<'_>,
_ctx: EngineContext,
) -> Poll<RethResult<(EngineHookEvent, Option<EngineHookAction>)>> {
) -> Poll<RethResult<EngineHookEvent>> {
self.results.pop_front().map_or(Poll::Pending, Poll::Ready)
}
@ -249,16 +241,14 @@ mod tests {
// return `EngineHookEvent::Finished` yet.
// Currently running hooks with DB write should still be set.
let mut hook = TestHook::new_rw("read-write");
hook.add_result(Ok((EngineHookEvent::Started, None)));
hook.add_result(Ok(EngineHookEvent::Started));
controller.active_db_write_hook = Some(Box::new(hook));
let result = poll!(poll_fn(|cx| controller.poll_active_db_write_hook(cx, context)));
assert_eq!(
result.map(|result| {
let polled_hook = result.unwrap();
polled_hook.event.is_started() &&
polled_hook.action.is_none() &&
polled_hook.db_access_level.is_read_write()
polled_hook.event.is_started() && polled_hook.db_access_level.is_read_write()
}),
Poll::Ready(true)
);
@ -269,16 +259,14 @@ mod tests {
// `EngineHookEvent::Finished` inside.
// Currently running hooks with DB write should be moved to collection of hooks.
let mut hook = TestHook::new_rw("read-write");
hook.add_result(Ok((EngineHookEvent::Finished(Ok(())), None)));
hook.add_result(Ok(EngineHookEvent::Finished(Ok(()))));
controller.active_db_write_hook = Some(Box::new(hook));
let result = poll!(poll_fn(|cx| controller.poll_active_db_write_hook(cx, context)));
assert_eq!(
result.map(|result| {
let polled_hook = result.unwrap();
polled_hook.event.is_finished() &&
polled_hook.action.is_none() &&
polled_hook.db_access_level.is_read_write()
polled_hook.event.is_finished() && polled_hook.db_access_level.is_read_write()
}),
Poll::Ready(true)
);
@ -291,11 +279,11 @@ mod tests {
let context = EngineContext { tip_block_number: 2, finalized_block_number: Some(1) };
let mut hook_rw = TestHook::new_rw("read-write");
hook_rw.add_result(Ok((EngineHookEvent::Started, None)));
hook_rw.add_result(Ok(EngineHookEvent::Started));
let hook_ro_name = "read-only";
let mut hook_ro = TestHook::new_ro(hook_ro_name);
hook_ro.add_result(Ok((EngineHookEvent::Started, None)));
hook_ro.add_result(Ok(EngineHookEvent::Started));
let mut hooks = EngineHooks::new();
hooks.add(hook_rw);
@ -314,7 +302,6 @@ mod tests {
let polled_hook = result.unwrap();
polled_hook.name == hook_ro_name &&
polled_hook.event.is_started() &&
polled_hook.action.is_none() &&
polled_hook.db_access_level.is_read_only()
}),
Poll::Ready(true)
@ -327,15 +314,15 @@ mod tests {
let hook_rw_1_name = "read-write-1";
let mut hook_rw_1 = TestHook::new_rw(hook_rw_1_name);
hook_rw_1.add_result(Ok((EngineHookEvent::Started, None)));
hook_rw_1.add_result(Ok(EngineHookEvent::Started));
let hook_rw_2_name = "read-write-2";
let mut hook_rw_2 = TestHook::new_rw(hook_rw_2_name);
hook_rw_2.add_result(Ok((EngineHookEvent::Started, None)));
hook_rw_2.add_result(Ok(EngineHookEvent::Started));
let hook_ro_name = "read-only";
let mut hook_ro = TestHook::new_ro(hook_ro_name);
hook_ro.add_result(Ok((EngineHookEvent::Started, None)));
hook_ro.add_result(Ok(EngineHookEvent::Started));
hook_ro.add_result(Err(RethError::Custom("something went wrong".to_string())));
let mut hooks = EngineHooks::new();
@ -354,7 +341,6 @@ mod tests {
let polled_hook = result.unwrap();
polled_hook.name == hook_rw_1_name &&
polled_hook.event.is_started() &&
polled_hook.action.is_none() &&
polled_hook.db_access_level.is_read_write()
}),
Poll::Ready(true)
@ -377,7 +363,6 @@ mod tests {
let polled_hook = result.unwrap();
polled_hook.name == hook_ro_name &&
polled_hook.event.is_started() &&
polled_hook.action.is_none() &&
polled_hook.db_access_level.is_read_only()
}),
Poll::Ready(true)

9
crates/consensus/beacon/src/engine/hooks/mod.rs
View File

@ -44,13 +44,12 @@ pub trait EngineHook: Send + Sync + 'static {
/// Returns a human-readable name for the hook.
fn name(&self) -> &'static str;
/// Advances the hook execution, emitting an [event][`EngineHookEvent`] and an optional
/// [action][`EngineHookAction`].
/// Advances the hook execution, emitting an [event][`EngineHookEvent`].
fn poll(
&mut self,
cx: &mut Context<'_>,
ctx: EngineContext,
) -> Poll<RethResult<(EngineHookEvent, Option<EngineHookAction>)>>;
) -> Poll<RethResult<EngineHookEvent>>;
/// Returns [db access level][`EngineHookDBAccessLevel`] the hook needs.
fn db_access_level(&self) -> EngineHookDBAccessLevel;
@ -94,10 +93,6 @@ impl EngineHookEvent {
}
}
/// An action that the caller of [hook][`EngineHook`] should act upon.
#[derive(Debug, Copy, Clone)]
pub enum EngineHookAction {}
/// An error returned by [hook][`EngineHook`].
#[derive(Debug, thiserror::Error)]
pub enum EngineHookError {

26
crates/consensus/beacon/src/engine/hooks/prune.rs
View File

@ -1,9 +1,7 @@
//! Prune hook for the engine implementation.
use crate::{
engine::hooks::{
EngineContext, EngineHook, EngineHookAction, EngineHookError, EngineHookEvent,
},
engine::hooks::{EngineContext, EngineHook, EngineHookError, EngineHookEvent},
hooks::EngineHookDBAccessLevel,
};
use futures::FutureExt;
@ -52,10 +50,7 @@ impl<DB: Database + 'static> PruneHook<DB> {
/// Advances the pruner state.
///
/// This checks for the result in the channel, or returns pending if the pruner is idle.
fn poll_pruner(
&mut self,
cx: &mut Context<'_>,
) -> Poll<RethResult<(EngineHookEvent, Option<EngineHookAction>)>> {
fn poll_pruner(&mut self, cx: &mut Context<'_>) -> Poll<RethResult<EngineHookEvent>> {
let result = match self.pruner_state {
PrunerState::Idle(_) => return Poll::Pending,
PrunerState::Running(ref mut fut) => {
@ -78,7 +73,7 @@ impl<DB: Database + 'static> PruneHook<DB> {
}
};
Poll::Ready(Ok((event, None)))
Poll::Ready(Ok(event))
}
/// This will try to spawn the pruner if it is idle:
@ -89,10 +84,7 @@ impl<DB: Database + 'static> PruneHook<DB> {
/// 2. If pruning is not needed, set pruner state back to [PrunerState::Idle].
///
/// If pruner is already running, do nothing.
fn try_spawn_pruner(
&mut self,
tip_block_number: BlockNumber,
) -> Option<(EngineHookEvent, Option<EngineHookAction>)> {
fn try_spawn_pruner(&mut self, tip_block_number: BlockNumber) -> Option<EngineHookEvent> {
match &mut self.pruner_state {
PrunerState::Idle(pruner) => {
let mut pruner = pruner.take()?;
@ -110,10 +102,10 @@ impl<DB: Database + 'static> PruneHook<DB> {
self.metrics.runs.increment(1);
self.pruner_state = PrunerState::Running(rx);
Some((EngineHookEvent::Started, None))
Some(EngineHookEvent::Started)
} else {
self.pruner_state = PrunerState::Idle(Some(pruner));
Some((EngineHookEvent::NotReady, None))
Some(EngineHookEvent::NotReady)
}
}
PrunerState::Running(_) => None,
@ -130,11 +122,11 @@ impl<DB: Database + 'static> EngineHook for PruneHook<DB> {
&mut self,
cx: &mut Context<'_>,
ctx: EngineContext,
) -> Poll<RethResult<(EngineHookEvent, Option<EngineHookAction>)>> {
) -> Poll<RethResult<EngineHookEvent>> {
// Try to spawn a pruner
match self.try_spawn_pruner(ctx.tip_block_number) {
Some((EngineHookEvent::NotReady, _)) => return Poll::Pending,
Some((event, action)) => return Poll::Ready(Ok((event, action))),
Some(EngineHookEvent::NotReady) => return Poll::Pending,
Some(event) => return Poll::Ready(Ok(event)),
None => (),
}

25
crates/consensus/beacon/src/engine/hooks/snapshot.rs
View File

@ -1,9 +1,7 @@
//! Snapshot hook for the engine implementation.
use crate::{
engine::hooks::{
EngineContext, EngineHook, EngineHookAction, EngineHookError, EngineHookEvent,
},
engine::hooks::{EngineContext, EngineHook, EngineHookError, EngineHookEvent},
hooks::EngineHookDBAccessLevel,
};
use futures::FutureExt;
@ -35,10 +33,7 @@ impl<DB: Database + 'static> SnapshotHook<DB> {
/// Advances the snapshotter state.
///
/// This checks for the result in the channel, or returns pending if the snapshotter is idle.
fn poll_snapshotter(
&mut self,
cx: &mut Context<'_>,
) -> Poll<RethResult<(EngineHookEvent, Option<EngineHookAction>)>> {
fn poll_snapshotter(&mut self, cx: &mut Context<'_>) -> Poll<RethResult<EngineHookEvent>> {
let result = match self.state {
SnapshotterState::Idle(_) => return Poll::Pending,
SnapshotterState::Running(ref mut fut) => {
@ -61,7 +56,7 @@ impl<DB: Database + 'static> SnapshotHook<DB> {
}
};
Poll::Ready(Ok((event, None)))
Poll::Ready(Ok(event))
}
/// This will try to spawn the snapshotter if it is idle:
@ -77,7 +72,7 @@ impl<DB: Database + 'static> SnapshotHook<DB> {
fn try_spawn_snapshotter(
&mut self,
finalized_block_number: BlockNumber,
) -> RethResult<Option<(EngineHookEvent, Option<EngineHookAction>)>> {
) -> RethResult<Option<EngineHookEvent>> {
Ok(match &mut self.state {
SnapshotterState::Idle(snapshotter) => {
let Some(mut snapshotter) = snapshotter.take() else { return Ok(None) };
@ -96,10 +91,10 @@ impl<DB: Database + 'static> SnapshotHook<DB> {
);
self.state = SnapshotterState::Running(rx);
Some((EngineHookEvent::Started, None))
Some(EngineHookEvent::Started)
} else {
self.state = SnapshotterState::Idle(Some(snapshotter));
Some((EngineHookEvent::NotReady, None))
Some(EngineHookEvent::NotReady)
}
}
SnapshotterState::Running(_) => None,
@ -116,15 +111,15 @@ impl<DB: Database + 'static> EngineHook for SnapshotHook<DB> {
&mut self,
cx: &mut Context<'_>,
ctx: EngineContext,
) -> Poll<RethResult<(EngineHookEvent, Option<EngineHookAction>)>> {
) -> Poll<RethResult<EngineHookEvent>> {
let Some(finalized_block_number) = ctx.finalized_block_number else {
return Poll::Ready(Ok((EngineHookEvent::NotReady, None)))
return Poll::Ready(Ok(EngineHookEvent::NotReady))
};
// Try to spawn a snapshotter
match self.try_spawn_snapshotter(finalized_block_number)? {
Some((EngineHookEvent::NotReady, _)) => return Poll::Pending,
Some((event, action)) => return Poll::Ready(Ok((event, action))),
Some(EngineHookEvent::NotReady) => return Poll::Pending,
Some(event) => return Poll::Ready(Ok(event)),
None => (),
}

4
crates/consensus/beacon/src/engine/mod.rs
View File

@ -1699,10 +1699,6 @@ where
}
fn on_hook_result(&self, result: PolledHook) -> Result<(), BeaconConsensusEngineError> {
if let Some(action) = result.action {
match action {}
}
if result.db_access_level.is_read_write() {
match result.event {
EngineHookEvent::NotReady => {}