Struct reth_stages::Pipeline

pub struct Pipeline<N>
where
    N: NodeTypesWithDB,
{ /* private fields */ }

A staged sync pipeline.

The pipeline executes queued stages serially. An external component determines the tip of the chain and the pipeline then executes each stage in order from the current local chain tip and the external chain tip. When a stage is executed, it will run until it reaches the chain tip.

After the entire pipeline has been run, it will run again unless asked to stop (see [Pipeline::set_max_block]).

include_mmd!("docs/mermaid/pipeline.mmd“)

Unwinding

In case of a validation error (as determined by the consensus engine) in one of the stages, the pipeline will unwind the stages in reverse order of execution. It is also possible to request an unwind manually (see Pipeline::unwind).

Defaults

The DefaultStages are used to fully sync reth.

Implementations

impl<N> Pipeline<N>

where N: ProviderNodeTypes,

pub fn builder() -> PipelineBuilder<<N as NodeTypesWithDB>::DB>

Construct a pipeline using a PipelineBuilder.

pub const fn minimum_block_number(&self) -> Option<u64>

Return the minimum block number achieved by any stage during the execution of the pipeline.

pub fn set_tip(&self, tip: FixedBytes<32>)

Set tip for reverse sync.

pub fn events(&self) -> EventStream<PipelineEvent>

Listen for events on the pipeline.

impl<N> Pipeline<N>

where N: ProviderNodeTypes,

pub fn register_metrics(&mut self) -> Result<(), PipelineError>

Registers progress metrics for each registered stage

pub fn run_as_fut( self, target: Option<PipelineTarget>, ) -> Pin<Box<dyn Future<Output = (Pipeline<N>, Result<ControlFlow, PipelineError>)> + Send>>

Consume the pipeline and run it until it reaches the provided tip, if set. Return the pipeline and its result as a future.

pub async fn run(&mut self) -> Result<(), PipelineError>

Run the pipeline in an infinite loop. Will terminate early if the user has specified a max_block in the pipeline.

pub async fn run_loop(&mut self) -> Result<ControlFlow, PipelineError>

Performs one pass of the pipeline across all stages. After successful execution of each stage, it proceeds to commit it to the database.

If any stage is unsuccessful at execution, we proceed to unwind. This will undo the progress across the entire pipeline up to the block that caused the error.

Returns the control flow after it ran the pipeline. This will be ControlFlow::Continue or ControlFlow::NoProgress of the last stage in the pipeline (for example the Finish stage). Or ControlFlow::Unwind of the stage that caused the unwind.

pub fn move_to_static_files(&self) -> Result<(), RethError>

Run static file producer and pruner to move all data from the database to static files for corresponding segments, according to their stage checkpoints:

• StaticFileSegment::Headers -> StageId::Headers
• StaticFileSegment::Receipts -> StageId::Execution
• StaticFileSegment::Transactions -> StageId::Bodies

CAUTION: This method locks the static file producer Mutex, hence can block the thread if the lock is occupied.

pub fn unwind( &mut self, to: u64, bad_block: Option<u64>, ) -> Result<(), PipelineError>

Unwind the stages to the target block.

If the unwind is due to a bad block the number of that block should be specified.

Trait Implementations

impl<N> Debug for Pipeline<N>

where N: NodeTypesWithDB,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.