Struct polkadot_overseer::OverseerSubsystemContext

pub struct OverseerSubsystemContext<M> { /* fields omitted */ }

A context type that is given to the Subsystem upon spawning. It can be used by Subsystem to communicate with other Subsystems or to spawn it’s SubsystemJobs.

Trait Implementations

impl<M: Debug> Debug for OverseerSubsystemContext<M>

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

Formats the value using the given formatter.

impl<M: Debug + Send + 'static> SubsystemContext for OverseerSubsystemContext<M> where
    OverseerSubsystemSender: SubsystemSender<AllMessages>,
    AllMessages: From<M>, 

type Message = M

The message type of this context. Subsystems launched with this context will expect to receive messages of this type. Commonly uses the wrapping enum commonly called AllMessages.

type Signal = OverseerSignal

And the same for signals.

type Sender = OverseerSubsystemSender

The sender type as provided by sender() and underlying.

type AllMessages = AllMessages

The overarching all messages enum. In some cases can be identical to Self::Message.

type Error = SubsystemError

The error type.

fn try_recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Option<FromOverseer<M, OverseerSignal>>, ()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Try to asynchronously receive a message.

fn recv<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<FromOverseer<M, OverseerSignal>, SubsystemError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Receive a message.

fn sender(&mut self) -> &mut Self::Sender

Obtain the sender.

fn spawn(
    &mut self,
    name: &'static str,
    s: Pin<Box<dyn Future<Output = ()> + Send>>
) -> Result<(), SubsystemError>

Spawn a child task on the executor.

fn spawn_blocking(
    &mut self,
    name: &'static str,
    s: Pin<Box<dyn Future<Output = ()> + Send>>
) -> Result<(), SubsystemError>

Spawn a blocking child task on the executor’s dedicated thread pool.

fn send_message<'life0, 'async_trait, X>(
    &'life0 mut self,
    msg: X
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    X: Send + 'async_trait,
    Self: 'async_trait,
    Self::AllMessages: From<X>, 

Send a direct message to some other Subsystem, routed based on message type.

fn send_messages<'life0, 'async_trait, X, T>(
    &'life0 mut self,
    msgs: T
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    T: IntoIterator<Item = X> + Send + 'async_trait,
    X: Send + 'async_trait,
    Self: 'async_trait,
    <T as IntoIterator>::IntoIter: Send,
    Self::AllMessages: From<X>, 

Send multiple direct messages to other Subsystems, routed based on message type.

fn send_unbounded_message<X>(&mut self, msg: X) where
    X: Send,
    Self::AllMessages: From<X>, 

Send a message using the unbounded connection.