Trait polkadot_node_subsystem_util::reexports::SubsystemContext

source ·

pub trait SubsystemContext: Send + 'static {
    type Message: Debug + Send + 'static;
    type Signal: Debug + Send + 'static;
    type OutgoingMessages: Debug + Send + 'static;
    type Sender: Clone + Send + 'static + SubsystemSender<Self::OutgoingMessages>;
    type Error: Error + From<OrchestraError> + Sync + Send + 'static;

    // Required methods
    fn try_recv<'life0, 'async_trait>(
        &'life0 mut self
    ) -> Pin<Box<dyn Future<Output = Result<Option<FromOrchestra<Self::Message, Self::Signal>>, ()>> + Send + 'async_trait, Global>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn recv<'life0, 'async_trait>(
        &'life0 mut self
    ) -> Pin<Box<dyn Future<Output = Result<FromOrchestra<Self::Message, Self::Signal>, Self::Error>> + Send + 'async_trait, Global>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn spawn(
        &mut self,
        name: &'static str,
        s: Pin<Box<dyn Future<Output = ()> + Send, Global>>
    ) -> Result<(), Self::Error>;
    fn spawn_blocking(
        &mut self,
        name: &'static str,
        s: Pin<Box<dyn Future<Output = ()> + Send, Global>>
    ) -> Result<(), Self::Error>;
    fn sender(&mut self) -> &mut Self::Sender;

    // Provided methods
    fn send_message<'life0, 'async_trait, T>(
        &'life0 mut self,
        msg: T
    ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait, Global>>
       where 'life0: 'async_trait,
             Self::OutgoingMessages: From<T> + Send,
             T: Send + 'async_trait,
             Self: 'async_trait { ... }
    fn send_messages<'life0, 'async_trait, T, I>(
        &'life0 mut self,
        msgs: I
    ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait, Global>>
       where 'life0: 'async_trait,
             Self::OutgoingMessages: From<T> + Send,
             I: IntoIterator<Item = T> + Send + 'async_trait,
             <I as IntoIterator>::IntoIter: Send,
             T: Send + 'async_trait,
             Self: 'async_trait { ... }
    fn send_unbounded_message<X>(&mut self, msg: X)
       where Self::OutgoingMessages: From<X> + Send,
             X: Send { ... }
}

Expand description

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

Required Associated Types§

source

type Message: Debug + Send + 'static

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.

Trait polkadot_node_subsystem_util::reexports::SubsystemContext

Required Associated Types§

type Message: Debug + Send + 'static

type Signal: Debug + Send + 'static

type OutgoingMessages: Debug + Send + 'static

type Sender: Clone + Send + 'static + SubsystemSender<Self::OutgoingMessages>

type Error: Error + From<OrchestraError> + Sync + Send + 'static

Required Methods§

fn try_recv<'life0, 'async_trait>( &'life0 mut self ) -> Pin<Box<dyn Future<Output = Result<Option<FromOrchestra<Self::Message, Self::Signal>>, ()>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, Self: 'async_trait,

fn recv<'life0, 'async_trait>( &'life0 mut self ) -> Pin<Box<dyn Future<Output = Result<FromOrchestra<Self::Message, Self::Signal>, Self::Error>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, Self: 'async_trait,

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

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

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

Provided Methods§

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

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

Implementations on Foreign Types§

type Message = NetworkBridgeRxMessage

type Signal = OverseerSignal

type OutgoingMessages = NetworkBridgeRxOutgoingMessages

type Sender = OverseerSender<NetworkBridgeRxOutgoingMessages>

type Error = SubsystemError

fn sender( &mut self ) -> &mut <OverseerSubsystemContext<NetworkBridgeRxMessage> as SubsystemContext>::Sender

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

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

type Message = GossipSupportMessage

type Signal = OverseerSignal

type OutgoingMessages = GossipSupportOutgoingMessages

type Sender = OverseerSender<GossipSupportOutgoingMessages>

type Error = SubsystemError

fn sender( &mut self ) -> &mut <OverseerSubsystemContext<GossipSupportMessage> as SubsystemContext>::Sender

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

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

impl SubsystemContext for OverseerSubsystemContext<()>where (): AssociateOutgoing + Debug + Send + 'static, AllMessages: From<()>,

type Message = ()

type Signal = OverseerSignal

type OutgoingMessages = ()

type Sender = OverseerSender<()>

type Error = SubsystemError

fn try_recv<'life0, 'async_trait>( &'life0 mut self ) -> Pin<Box<dyn Future<Output = Result<Option<FromOrchestra<<OverseerSubsystemContext<()> as SubsystemContext>::Message, OverseerSignal>>, ()>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, OverseerSubsystemContext<()>: 'async_trait,

fn recv<'life0, 'async_trait>( &'life0 mut self ) -> Pin<Box<dyn Future<Output = Result<FromOrchestra<<OverseerSubsystemContext<()> as SubsystemContext>::Message, OverseerSignal>, SubsystemError>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, OverseerSubsystemContext<()>: 'async_trait,

fn sender( &mut self ) -> &mut <OverseerSubsystemContext<()> as SubsystemContext>::Sender

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

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

type Message = ApprovalDistributionMessage

type Signal = OverseerSignal

type OutgoingMessages = ApprovalDistributionOutgoingMessages

type Sender = OverseerSender<ApprovalDistributionOutgoingMessages>

type Error = SubsystemError

fn sender( &mut self ) -> &mut <OverseerSubsystemContext<ApprovalDistributionMessage> as SubsystemContext>::Sender

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

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

type Message = CandidateValidationMessage

type Signal = OverseerSignal

type OutgoingMessages = CandidateValidationOutgoingMessages

type Sender = OverseerSender<CandidateValidationOutgoingMessages>

type Error = SubsystemError

fn sender( &mut self ) -> &mut <OverseerSubsystemContext<CandidateValidationMessage> as SubsystemContext>::Sender

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

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

type Message = StatementDistributionMessage

type Signal = OverseerSignal

type OutgoingMessages = StatementDistributionOutgoingMessages

type Sender = OverseerSender<StatementDistributionOutgoingMessages>

type Error = SubsystemError

fn sender( &mut self ) -> &mut <OverseerSubsystemContext<StatementDistributionMessage> as SubsystemContext>::Sender

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

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

type Message = BitfieldSigningMessage

type Signal = OverseerSignal

type OutgoingMessages = BitfieldSigningOutgoingMessages

type Sender = OverseerSender<BitfieldSigningOutgoingMessages>

type Error = SubsystemError

fn sender( &mut self ) -> &mut <OverseerSubsystemContext<BitfieldSigningMessage> as SubsystemContext>::Sender

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

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

type Message = AvailabilityRecoveryMessage

type Signal = OverseerSignal

type OutgoingMessages = AvailabilityRecoveryOutgoingMessages

type Sender = OverseerSender<AvailabilityRecoveryOutgoingMessages>