Struct MainTask

pub struct MainTask<T, B, I, S, PB, C> { /* private fields */ }

Implementations

impl<T, B, I, S, PB, C> MainTask<T, B, I, S, PB, C>

where T: TransactionPool, I: BlockImporter, PB: PredefinedBlocks, C: GetTime,

pub fn new<P: P2pPort>( last_block: &BlockHeader, config: Config, txpool: T, block_producer: B, block_importer: I, p2p_port: P, signer: S, predefined_blocks: PB, clock: C, ) -> Self

Trait Implementations

impl<T, B, I, S, PB, C> RunnableService for MainTask<T, B, I, S, PB, C>

where Self: RunnableTask,

const NAME: &'static str = "PoA"

The name of the runnable service, used for namespacing error messages.

type SharedData = SharedState

Service specific shared data. This is used when you have data that needs to be shared by one or more tasks. It is the implementors responsibility to ensure cloning this type is shallow and doesn’t provide a full duplication of data that is meant to be shared between asynchronous processes.

type Task = MainTask<T, B, I, S, PB, C>

The initialized runnable task type.

type TaskParams = ()

Optional parameters used to when initializing into task.

fn shared_data(&self) -> Self::SharedData

A cloned instance of the shared data

fn into_task<'life0, 'async_trait>( self, _: &'life0 StateWatcher, __arg2: Self::TaskParams, ) -> Pin<Box<dyn Future<Output = Result<Self::Task>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Converts the service into a runnable task before the main run loop.

impl<T, B, I, S, PB, C> RunnableTask for MainTask<T, B, I, S, PB, C>

where T: TransactionPool, B: BlockProducer, I: BlockImporter, S: BlockSigner, PB: PredefinedBlocks, C: GetTime,

fn run<'life0, 'life1, 'async_trait>( &'life0 mut self, watcher: &'life1 mut StateWatcher, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

This function should contain the main business logic of the service task. It will run until the service either returns false, panics or a stop signal is received. If the service returns an error, it will be logged and execution will resume. This is intended to be called only by the ServiceRunner.

fn shutdown<'async_trait>( self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait,

Gracefully shutdowns the task after the end of the execution cycle.