Trait polkadot_node_subsystem_util::reexports::SubsystemContext

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>>
       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>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn recv_signal<'life0, 'async_trait>(
        &'life0 mut self,
    ) -> Pin<Box<dyn Future<Output = Result<Self::Signal, Self::Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn spawn(
        &mut self,
        name: &'static str,
        s: Pin<Box<dyn Future<Output = ()> + Send>>,
    ) -> Result<(), Self::Error>;
    fn spawn_blocking(
        &mut self,
        name: &'static str,
        s: Pin<Box<dyn Future<Output = ()> + Send>>,
    ) -> 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>>
       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>>
       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 { ... }
}

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

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.

type Signal: Debug + Send + 'static

And the same for signals.

type OutgoingMessages: Debug + Send + 'static

The overarching messages enum for this particular subsystem.

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

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

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

The error type.

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>>

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

Try to asynchronously receive a message.

Has to be used with caution, if you loop over this without using pending!() macro you will end up with a busy loop!

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

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

Receive a signal or a message.

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

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

Receive a signal.

This method allows the subsystem to process signals while being blocked on processing messages. See examples/backpressure.rs for an example.

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

Spawn a child task on the executor.

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

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

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

Obtain the sender.

Provided Methods

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

where 'life0: 'async_trait, Self::OutgoingMessages: From<T> + Send, T: Send + 'async_trait, Self: 'async_trait,

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

fn send_messages<'life0, 'async_trait, T, I>( &'life0 mut self, msgs: I, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

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,

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

fn send_unbounded_message<X>(&mut self, msg: X)

where Self::OutgoingMessages: From<X> + Send, X: Send,

Send a message using the unbounded connection.

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl SubsystemContext for OverseerSubsystemContext<ApprovalDistributionMessage>

where ApprovalDistributionMessage: AssociateOutgoing + Debug + Send + 'static, AllMessages: From<ApprovalDistributionOutgoingMessages> + From<ApprovalDistributionMessage>, ApprovalDistributionOutgoingMessages: From<NetworkBridgeTxMessage> + From<ApprovalVotingMessage> + From<RuntimeApiMessage>,

type Message = ApprovalDistributionMessage

type Signal = OverseerSignal

type OutgoingMessages = ApprovalDistributionOutgoingMessages

type Sender = OverseerSender<ApprovalDistributionOutgoingMessages>

type Error = SubsystemError

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

where 'life0: 'async_trait, OverseerSubsystemContext<ApprovalDistributionMessage>: 'async_trait,

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

where 'life0: 'async_trait, OverseerSubsystemContext<ApprovalDistributionMessage>: 'async_trait,

fn recv_signal<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<OverseerSignal, SubsystemError>> + Send + 'async_trait>>

where 'life0: 'async_trait, OverseerSubsystemContext<ApprovalDistributionMessage>: 'async_trait,

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

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

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

impl SubsystemContext for OverseerSubsystemContext<ApprovalVotingMessage>

where ApprovalVotingMessage: AssociateOutgoing + Debug + Send + 'static, AllMessages: From<ApprovalVotingOutgoingMessages> + From<ApprovalVotingMessage>, ApprovalVotingOutgoingMessages: From<ApprovalDistributionMessage> + From<AvailabilityRecoveryMessage> + From<CandidateValidationMessage> + From<ChainApiMessage> + From<ChainSelectionMessage> + From<DisputeCoordinatorMessage> + From<RuntimeApiMessage>,

type Message = ApprovalVotingMessage

type Signal = OverseerSignal

type OutgoingMessages = ApprovalVotingOutgoingMessages

type Sender = OverseerSender<ApprovalVotingOutgoingMessages>

type Error = SubsystemError

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

where 'life0: 'async_trait, OverseerSubsystemContext<ApprovalVotingMessage>: 'async_trait,

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

where 'life0: 'async_trait, OverseerSubsystemContext<ApprovalVotingMessage>: 'async_trait,

fn recv_signal<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<OverseerSignal, SubsystemError>> + Send + 'async_trait>>

where 'life0: 'async_trait, OverseerSubsystemContext<ApprovalVotingMessage>: 'async_trait,

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

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

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

impl SubsystemContext for OverseerSubsystemContext<ApprovalVotingParallelMessage>

where ApprovalVotingParallelMessage: AssociateOutgoing + Debug + Send + 'static, AllMessages: From<ApprovalVotingParallelOutgoingMessages> + From<ApprovalVotingParallelMessage>, ApprovalVotingParallelOutgoingMessages: From<AvailabilityRecoveryMessage> + From<CandidateValidationMessage> + From<ChainApiMessage> + From<ChainSelectionMessage> + From<DisputeCoordinatorMessage> + From<RuntimeApiMessage> + From<NetworkBridgeTxMessage> + From<ApprovalVotingMessage> + From<ApprovalDistributionMessage> + From<ApprovalVotingParallelMessage>,

type Message = ApprovalVotingParallelMessage

type Signal = OverseerSignal

type OutgoingMessages = ApprovalVotingParallelOutgoingMessages

type Sender = OverseerSender<ApprovalVotingParallelOutgoingMessages>

type Error = SubsystemError

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

where 'life0: 'async_trait, OverseerSubsystemContext<ApprovalVotingParallelMessage>: 'async_trait,

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

where 'life0: 'async_trait, OverseerSubsystemContext<ApprovalVotingParallelMessage>: 'async_trait,

fn recv_signal<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<OverseerSignal, SubsystemError>> + Send + 'async_trait>>

where 'life0: 'async_trait, OverseerSubsystemContext<ApprovalVotingParallelMessage>: 'async_trait,

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

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

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

impl SubsystemContext for OverseerSubsystemContext<AvailabilityDistributionMessage>

where AvailabilityDistributionMessage: AssociateOutgoing + Debug + Send + 'static, AllMessages: From<AvailabilityDistributionOutgoingMessages> + From<AvailabilityDistributionMessage>, AvailabilityDistributionOutgoingMessages: From<AvailabilityStoreMessage> + From<ChainApiMessage> + From<RuntimeApiMessage> + From<NetworkBridgeTxMessage>,

type Message = AvailabilityDistributionMessage

type Signal = OverseerSignal

type OutgoingMessages = AvailabilityDistributionOutgoingMessages

type Sender = OverseerSender<AvailabilityDistributionOutgoingMessages>

type Error = SubsystemError

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

where 'life0: 'async_trait, OverseerSubsystemContext<AvailabilityDistributionMessage>: 'async_trait,

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

where 'life0: 'async_trait, OverseerSubsystemContext<AvailabilityDistributionMessage>: 'async_trait,

fn recv_signal<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<OverseerSignal, SubsystemError>> + Send + 'async_trait>>

where 'life0: 'async_trait, OverseerSubsystemContext<AvailabilityDistributionMessage>: 'async_trait,

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

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

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

impl SubsystemContext for OverseerSubsystemContext<AvailabilityRecoveryMessage>

where AvailabilityRecoveryMessage: AssociateOutgoing + Debug + Send + 'static, AllMessages: From<AvailabilityRecoveryOutgoingMessages> + From<AvailabilityRecoveryMessage>, AvailabilityRecoveryOutgoingMessages: From<NetworkBridgeTxMessage> + From<RuntimeApiMessage> + From<AvailabilityStoreMessage>,

type Message = AvailabilityRecoveryMessage

type Signal = OverseerSignal

type OutgoingMessages = AvailabilityRecoveryOutgoingMessages

type Sender = OverseerSender<AvailabilityRecoveryOutgoingMessages>

type Error = SubsystemError

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

where 'life0: 'async_trait, OverseerSubsystemContext<AvailabilityRecoveryMessage>: 'async_trait,

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

where 'life0: 'async_trait, OverseerSubsystemContext<AvailabilityRecoveryMessage>: 'async_trait,

fn recv_signal<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<OverseerSignal, SubsystemError>> + Send + 'async_trait>>

where 'life0: 'async_trait, OverseerSubsystemContext<AvailabilityRecoveryMessage>: 'async_trait,

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

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

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

impl SubsystemContext for OverseerSubsystemContext<AvailabilityStoreMessage>

where AvailabilityStoreMessage: AssociateOutgoing + Debug + Send + 'static, AllMessages: From<AvailabilityStoreOutgoingMessages> + From<AvailabilityStoreMessage>, AvailabilityStoreOutgoingMessages: From<ChainApiMessage> + From<RuntimeApiMessage>,

type Message = AvailabilityStoreMessage

type Signal = OverseerSignal

type OutgoingMessages = AvailabilityStoreOutgoingMessages

type Sender = OverseerSender<AvailabilityStoreOutgoingMessages>

type Error = SubsystemError

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

where 'life0: 'async_trait, OverseerSubsystemContext<AvailabilityStoreMessage>: 'async_trait,

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

where 'life0: 'async_trait, OverseerSubsystemContext<AvailabilityStoreMessage>: 'async_trait,

fn recv_signal<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<OverseerSignal, SubsystemError>> + Send + 'async_trait>>

where 'life0: 'async_trait, OverseerSubsystemContext<AvailabilityStoreMessage>: 'async_trait,

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

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

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

impl SubsystemContext for OverseerSubsystemContext<BitfieldDistributionMessage>

where BitfieldDistributionMessage: AssociateOutgoing + Debug + Send + 'static, AllMessages: From<BitfieldDistributionOutgoingMessages> + From<BitfieldDistributionMessage>, BitfieldDistributionOutgoingMessages: From<RuntimeApiMessage> + From<NetworkBridgeTxMessage> + From<ProvisionerMessage>,

type Message = BitfieldDistributionMessage

type Signal = OverseerSignal

type OutgoingMessages = BitfieldDistributionOutgoingMessages

type Sender = OverseerSender<BitfieldDistributionOutgoingMessages>

type Error = SubsystemError

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

where 'life0: 'async_trait, OverseerSubsystemContext<BitfieldDistributionMessage>: 'async_trait,

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

where 'life0: 'async_trait, OverseerSubsystemContext<BitfieldDistributionMessage>: 'async_trait,

fn recv_signal<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<OverseerSignal, SubsystemError>> + Send + 'async_trait>>

where 'life0: 'async_trait, OverseerSubsystemContext<BitfieldDistributionMessage>: 'async_trait,

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

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

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

impl SubsystemContext for OverseerSubsystemContext<CandidateBackingMessage>

where CandidateBackingMessage: AssociateOutgoing + Debug + Send + 'static, AllMessages: From<CandidateBackingOutgoingMessages> + From<CandidateBackingMessage>, CandidateBackingOutgoingMessages: From<CandidateValidationMessage> + From<CollatorProtocolMessage> + From<ChainApiMessage> + From<AvailabilityDistributionMessage> + From<AvailabilityStoreMessage> + From<StatementDistributionMessage> + From<ProvisionerMessage> + From<RuntimeApiMessage> + From<ProspectiveParachainsMessage>,

type Message = CandidateBackingMessage

type Signal = OverseerSignal

type OutgoingMessages = CandidateBackingOutgoingMessages

type Sender = OverseerSender<CandidateBackingOutgoingMessages>

type Error = SubsystemError

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

where 'life0: 'async_trait, OverseerSubsystemContext<CandidateBackingMessage>: 'async_trait,

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

where 'life0: 'async_trait, OverseerSubsystemContext<CandidateBackingMessage>: 'async_trait,

fn recv_signal<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<OverseerSignal, SubsystemError>> + Send + 'async_trait>>

where 'life0: 'async_trait, OverseerSubsystemContext<CandidateBackingMessage>: 'async_trait,

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

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

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

impl SubsystemContext for OverseerSubsystemContext<CandidateValidationMessage>

where CandidateValidationMessage: AssociateOutgoing + Debug + Send + 'static, AllMessages: From<CandidateValidationOutgoingMessages> + From<CandidateValidationMessage>, CandidateValidationOutgoingMessages: From<ChainApiMessage> + From<RuntimeApiMessage>,

type Message = CandidateValidationMessage

type Signal = OverseerSignal

type OutgoingMessages = CandidateValidationOutgoingMessages

type Sender = OverseerSender<CandidateValidationOutgoingMessages>

type Error = SubsystemError

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

where 'life0: 'async_trait, OverseerSubsystemContext<CandidateValidationMessage>: 'async_trait,

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

where 'life0: 'async_trait, OverseerSubsystemContext<CandidateValidationMessage>: 'async_trait,

fn recv_signal<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<OverseerSignal, SubsystemError>> + Send + 'async_trait>>

where 'life0: 'async_trait, OverseerSubsystemContext<CandidateValidationMessage>: 'async_trait,

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

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

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

impl SubsystemContext for OverseerSubsystemContext<ChainApiMessage>

where ChainApiMessage: AssociateOutgoing + Debug + Send + 'static, AllMessages: From<ChainApiOutgoingMessages> + From<ChainApiMessage>,

type Message = ChainApiMessage

type Signal = OverseerSignal

type OutgoingMessages = ChainApiOutgoingMessages

type Sender = OverseerSender<ChainApiOutgoingMessages>

type Error = SubsystemError

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

where 'life0: 'async_trait, OverseerSubsystemContext<ChainApiMessage>: 'async_trait,

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

where 'life0: 'async_trait, OverseerSubsystemContext<ChainApiMessage>: 'async_trait,

fn recv_signal<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<OverseerSignal, SubsystemError>> + Send + 'async_trait>>

where 'life0: 'async_trait, OverseerSubsystemContext<ChainApiMessage>: 'async_trait,

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

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

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

impl SubsystemContext for OverseerSubsystemContext<ChainSelectionMessage>

where ChainSelectionMessage: AssociateOutgoing + Debug + Send + 'static, AllMessages: From<ChainSelectionOutgoingMessages> + From<ChainSelectionMessage>, ChainSelectionOutgoingMessages: From<ChainApiMessage>,

type Message = ChainSelectionMessage

type Signal = OverseerSignal

type OutgoingMessages = ChainSelectionOutgoingMessages

type Sender = OverseerSender<ChainSelectionOutgoingMessages>

type Error = SubsystemError

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

where 'life0: 'async_trait, OverseerSubsystemContext<ChainSelectionMessage>: 'async_trait,

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

where 'life0: 'async_trait, OverseerSubsystemContext<ChainSelectionMessage>: 'async_trait,

fn recv_signal<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<OverseerSignal, SubsystemError>> + Send + 'async_trait>>

where 'life0: 'async_trait, OverseerSubsystemContext<ChainSelectionMessage>: 'async_trait,

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

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

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

impl SubsystemContext for OverseerSubsystemContext<CollationGenerationMessage>

where CollationGenerationMessage: AssociateOutgoing + Debug + Send + 'static, AllMessages: From<CollationGenerationOutgoingMessages> + From<CollationGenerationMessage>, CollationGenerationOutgoingMessages: From<RuntimeApiMessage> + From<CollatorProtocolMessage>,

type Message = CollationGenerationMessage

type Signal = OverseerSignal

type OutgoingMessages = CollationGenerationOutgoingMessages

type Sender = OverseerSender<CollationGenerationOutgoingMessages>

type Error = SubsystemError

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

where 'life0: 'async_trait, OverseerSubsystemContext<CollationGenerationMessage>: 'async_trait,

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

where 'life0: 'async_trait, OverseerSubsystemContext<CollationGenerationMessage>: 'async_trait,

fn recv_signal<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<OverseerSignal, SubsystemError>> + Send + 'async_trait>>

where 'life0: 'async_trait, OverseerSubsystemContext<CollationGenerationMessage>: 'async_trait,

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

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

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

impl SubsystemContext for OverseerSubsystemContext<CollatorProtocolMessage>

where CollatorProtocolMessage: AssociateOutgoing + Debug + Send + 'static, AllMessages: From<CollatorProtocolOutgoingMessages> + From<CollatorProtocolMessage>, CollatorProtocolOutgoingMessages: From<NetworkBridgeTxMessage> + From<RuntimeApiMessage> + From<CandidateBackingMessage> + From<ChainApiMessage> + From<ProspectiveParachainsMessage>,

type Message = CollatorProtocolMessage

type Signal = OverseerSignal

type OutgoingMessages = CollatorProtocolOutgoingMessages

type Sender = OverseerSender<CollatorProtocolOutgoingMessages>

type Error = SubsystemError

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

where 'life0: 'async_trait, OverseerSubsystemContext<CollatorProtocolMessage>: 'async_trait,

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

where 'life0: 'async_trait, OverseerSubsystemContext<CollatorProtocolMessage>: 'async_trait,

fn recv_signal<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<OverseerSignal, SubsystemError>> + Send + 'async_trait>>

where 'life0: 'async_trait, OverseerSubsystemContext<CollatorProtocolMessage>: 'async_trait,

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

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

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

impl SubsystemContext for OverseerSubsystemContext<DisputeCoordinatorMessage>

where DisputeCoordinatorMessage: AssociateOutgoing + Debug + Send + 'static, AllMessages: From<DisputeCoordinatorOutgoingMessages> + From<DisputeCoordinatorMessage>, DisputeCoordinatorOutgoingMessages: From<RuntimeApiMessage> + From<ChainApiMessage> + From<DisputeDistributionMessage> + From<CandidateValidationMessage> + From<ApprovalVotingMessage> + From<AvailabilityStoreMessage> + From<AvailabilityRecoveryMessage> + From<ChainSelectionMessage> + From<ApprovalVotingParallelMessage>,

type Message = DisputeCoordinatorMessage

type Signal = OverseerSignal

type OutgoingMessages = DisputeCoordinatorOutgoingMessages

type Sender = OverseerSender<DisputeCoordinatorOutgoingMessages>

type Error = SubsystemError

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

where 'life0: 'async_trait, OverseerSubsystemContext<DisputeCoordinatorMessage>: 'async_trait,

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

where 'life0: 'async_trait, OverseerSubsystemContext<DisputeCoordinatorMessage>: 'async_trait,

fn recv_signal<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<OverseerSignal, SubsystemError>> + Send + 'async_trait>>

where 'life0: 'async_trait, OverseerSubsystemContext<DisputeCoordinatorMessage>: 'async_trait,

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

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

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

impl SubsystemContext for OverseerSubsystemContext<DisputeDistributionMessage>

where DisputeDistributionMessage: AssociateOutgoing + Debug + Send + 'static, AllMessages: From<DisputeDistributionOutgoingMessages> + From<DisputeDistributionMessage>, DisputeDistributionOutgoingMessages: From<RuntimeApiMessage> + From<DisputeCoordinatorMessage> + From<NetworkBridgeTxMessage>,

type Message = DisputeDistributionMessage

type Signal = OverseerSignal

type OutgoingMessages = DisputeDistributionOutgoingMessages

type Sender = OverseerSender<DisputeDistributionOutgoingMessages>

type Error = SubsystemError

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

where 'life0: 'async_trait, OverseerSubsystemContext<DisputeDistributionMessage>: 'async_trait,

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

where 'life0: 'async_trait, OverseerSubsystemContext<DisputeDistributionMessage>: 'async_trait,

fn recv_signal<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<OverseerSignal, SubsystemError>> + Send + 'async_trait>>

where 'life0: 'async_trait, OverseerSubsystemContext<DisputeDistributionMessage>: 'async_trait,

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

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

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

impl SubsystemContext for OverseerSubsystemContext<GossipSupportMessage>

where GossipSupportMessage: AssociateOutgoing + Debug + Send + 'static, AllMessages: From<GossipSupportOutgoingMessages> + From<GossipSupportMessage>, GossipSupportOutgoingMessages: From<NetworkBridgeTxMessage> + From<NetworkBridgeRxMessage> + From<RuntimeApiMessage> + From<ChainSelectionMessage>,

type Message = GossipSupportMessage

type Signal = OverseerSignal

type OutgoingMessages = GossipSupportOutgoingMessages

type Sender = OverseerSender<GossipSupportOutgoingMessages>

type Error = SubsystemError

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

where 'life0: 'async_trait, OverseerSubsystemContext<GossipSupportMessage>: 'async_trait,

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

where 'life0: 'async_trait, OverseerSubsystemContext<GossipSupportMessage>: 'async_trait,

fn recv_signal<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<OverseerSignal, SubsystemError>> + Send + 'async_trait>>

where 'life0: 'async_trait, OverseerSubsystemContext<GossipSupportMessage>: 'async_trait,

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

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

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

impl SubsystemContext for OverseerSubsystemContext<NetworkBridgeRxMessage>

where NetworkBridgeRxMessage: AssociateOutgoing + Debug + Send + 'static, AllMessages: From<NetworkBridgeRxOutgoingMessages> + From<NetworkBridgeRxMessage>, NetworkBridgeRxOutgoingMessages: From<BitfieldDistributionMessage> + From<StatementDistributionMessage> + From<ApprovalDistributionMessage> + From<ApprovalVotingParallelMessage> + From<GossipSupportMessage> + From<DisputeDistributionMessage> + From<CollationGenerationMessage> + From<CollatorProtocolMessage>,

type Message = NetworkBridgeRxMessage

type Signal = OverseerSignal

type OutgoingMessages = NetworkBridgeRxOutgoingMessages

type Sender = OverseerSender<NetworkBridgeRxOutgoingMessages>

type Error = SubsystemError

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

where 'life0: 'async_trait, OverseerSubsystemContext<NetworkBridgeRxMessage>: 'async_trait,

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

where 'life0: 'async_trait, OverseerSubsystemContext<NetworkBridgeRxMessage>: 'async_trait,

fn recv_signal<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<OverseerSignal, SubsystemError>> + Send + 'async_trait>>

where 'life0: 'async_trait, OverseerSubsystemContext<NetworkBridgeRxMessage>: 'async_trait,

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

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

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

impl SubsystemContext for OverseerSubsystemContext<NetworkBridgeTxMessage>

where NetworkBridgeTxMessage: AssociateOutgoing + Debug + Send + 'static, AllMessages: From<NetworkBridgeTxOutgoingMessages> + From<NetworkBridgeTxMessage>,

type Message = NetworkBridgeTxMessage

type Signal = OverseerSignal

type OutgoingMessages = NetworkBridgeTxOutgoingMessages

type Sender = OverseerSender<NetworkBridgeTxOutgoingMessages>

type Error = SubsystemError

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

where 'life0: 'async_trait, OverseerSubsystemContext<NetworkBridgeTxMessage>: 'async_trait,

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

where 'life0: 'async_trait, OverseerSubsystemContext<NetworkBridgeTxMessage>: 'async_trait,

fn recv_signal<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<OverseerSignal, SubsystemError>> + Send + 'async_trait>>

where 'life0: 'async_trait, OverseerSubsystemContext<NetworkBridgeTxMessage>: 'async_trait,

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

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

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

impl SubsystemContext for OverseerSubsystemContext<ProspectiveParachainsMessage>

where ProspectiveParachainsMessage: AssociateOutgoing + Debug + Send + 'static, AllMessages: From<ProspectiveParachainsOutgoingMessages> + From<ProspectiveParachainsMessage>, ProspectiveParachainsOutgoingMessages: From<RuntimeApiMessage> + From<ChainApiMessage>,

type Message = ProspectiveParachainsMessage

type Signal = OverseerSignal

type OutgoingMessages = ProspectiveParachainsOutgoingMessages

type Sender = OverseerSender<ProspectiveParachainsOutgoingMessages>

type Error = SubsystemError

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

where 'life0: 'async_trait, OverseerSubsystemContext<ProspectiveParachainsMessage>: 'async_trait,

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

where 'life0: 'async_trait, OverseerSubsystemContext<ProspectiveParachainsMessage>: 'async_trait,

fn recv_signal<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<OverseerSignal, SubsystemError>> + Send + 'async_trait>>

where 'life0: 'async_trait, OverseerSubsystemContext<ProspectiveParachainsMessage>: 'async_trait,

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

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

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

impl SubsystemContext for OverseerSubsystemContext<ProvisionerMessage>

where ProvisionerMessage: AssociateOutgoing + Debug + Send + 'static, AllMessages: From<ProvisionerOutgoingMessages> + From<ProvisionerMessage>, ProvisionerOutgoingMessages: From<RuntimeApiMessage> + From<CandidateBackingMessage> + From<ChainApiMessage> + From<DisputeCoordinatorMessage> + From<ProspectiveParachainsMessage>,

type Message = ProvisionerMessage

type Signal = OverseerSignal

type OutgoingMessages = ProvisionerOutgoingMessages

type Sender = OverseerSender<ProvisionerOutgoingMessages>

type Error = SubsystemError

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

where 'life0: 'async_trait, OverseerSubsystemContext<ProvisionerMessage>: 'async_trait,

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

where 'life0: 'async_trait, OverseerSubsystemContext<ProvisionerMessage>: 'async_trait,

fn recv_signal<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<OverseerSignal, SubsystemError>> + Send + 'async_trait>>

where 'life0: 'async_trait, OverseerSubsystemContext<ProvisionerMessage>: 'async_trait,

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

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

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

impl SubsystemContext for OverseerSubsystemContext<RuntimeApiMessage>

where RuntimeApiMessage: AssociateOutgoing + Debug + Send + 'static, AllMessages: From<RuntimeApiOutgoingMessages> + From<RuntimeApiMessage>,

type Message = RuntimeApiMessage

type Signal = OverseerSignal

type OutgoingMessages = RuntimeApiOutgoingMessages

type Sender = OverseerSender<RuntimeApiOutgoingMessages>

type Error = SubsystemError

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

where 'life0: 'async_trait, OverseerSubsystemContext<RuntimeApiMessage>: 'async_trait,

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

where 'life0: 'async_trait, OverseerSubsystemContext<RuntimeApiMessage>: 'async_trait,

fn recv_signal<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<OverseerSignal, SubsystemError>> + Send + 'async_trait>>

where 'life0: 'async_trait, OverseerSubsystemContext<RuntimeApiMessage>: 'async_trait,

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

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

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

impl SubsystemContext for OverseerSubsystemContext<StatementDistributionMessage>

where StatementDistributionMessage: AssociateOutgoing + Debug + Send + 'static, AllMessages: From<StatementDistributionOutgoingMessages> + From<StatementDistributionMessage>, StatementDistributionOutgoingMessages: From<NetworkBridgeTxMessage> + From<CandidateBackingMessage> + From<RuntimeApiMessage> + From<ProspectiveParachainsMessage> + From<ChainApiMessage>,

type Message = StatementDistributionMessage

type Signal = OverseerSignal

type OutgoingMessages = StatementDistributionOutgoingMessages

type Sender = OverseerSender<StatementDistributionOutgoingMessages>

type Error = SubsystemError

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

where 'life0: 'async_trait, OverseerSubsystemContext<StatementDistributionMessage>: 'async_trait,

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

where 'life0: 'async_trait, OverseerSubsystemContext<StatementDistributionMessage>: 'async_trait,

fn recv_signal<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<OverseerSignal, SubsystemError>> + Send + 'async_trait>>

where 'life0: 'async_trait, OverseerSubsystemContext<StatementDistributionMessage>: 'async_trait,

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

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

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

impl SubsystemContext for OverseerSubsystemContext<BitfieldSigningMessage>

where BitfieldSigningMessage: AssociateOutgoing + Debug + Send + 'static, AllMessages: From<BitfieldSigningOutgoingMessages> + From<BitfieldSigningMessage>, BitfieldSigningOutgoingMessages: From<AvailabilityStoreMessage> + From<RuntimeApiMessage> + From<BitfieldDistributionMessage>,

type Message = BitfieldSigningMessage

type Signal = OverseerSignal

type OutgoingMessages = BitfieldSigningOutgoingMessages

type Sender = OverseerSender<BitfieldSigningOutgoingMessages>

type Error = SubsystemError

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

where 'life0: 'async_trait, OverseerSubsystemContext<BitfieldSigningMessage>: 'async_trait,

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

where 'life0: 'async_trait, OverseerSubsystemContext<BitfieldSigningMessage>: 'async_trait,

fn recv_signal<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<OverseerSignal, SubsystemError>> + Send + 'async_trait>>

where 'life0: 'async_trait, OverseerSubsystemContext<BitfieldSigningMessage>: 'async_trait,

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

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

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

impl SubsystemContext for OverseerSubsystemContext<PvfCheckerMessage>

where PvfCheckerMessage: AssociateOutgoing + Debug + Send + 'static, AllMessages: From<PvfCheckerOutgoingMessages> + From<PvfCheckerMessage>, PvfCheckerOutgoingMessages: From<CandidateValidationMessage> + From<RuntimeApiMessage>,

type Message = PvfCheckerMessage

type Signal = OverseerSignal

type OutgoingMessages = PvfCheckerOutgoingMessages

type Sender = OverseerSender<PvfCheckerOutgoingMessages>

type Error = SubsystemError

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

where 'life0: 'async_trait, OverseerSubsystemContext<PvfCheckerMessage>: 'async_trait,

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

where 'life0: 'async_trait, OverseerSubsystemContext<PvfCheckerMessage>: 'async_trait,

fn recv_signal<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<OverseerSignal, SubsystemError>> + Send + 'async_trait>>

where 'life0: 'async_trait, OverseerSubsystemContext<PvfCheckerMessage>: 'async_trait,

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

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

fn spawn_blocking( &mut self, name: &'static str, s: Pin<Box<dyn Future<Output = ()> + Send>>, ) -> 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>>

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>>

where 'life0: 'async_trait, OverseerSubsystemContext<()>: 'async_trait,

fn recv_signal<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<OverseerSignal, SubsystemError>> + Send + 'async_trait>>

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>>, ) -> Result<(), SubsystemError>

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

Implementors