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

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so 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> + From<ChainApiMessage>,

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

impl<Context, Fil> SubsystemContext for InterceptedContext<Context, Fil>

where Context: SubsystemContext<Error = SubsystemError, Signal = OverseerSignal>, <Context as SubsystemContext>::Message: AssociateOutgoing, <Context as SubsystemContext>::Sender: SubsystemSender<<<Context as SubsystemContext>::Message as AssociateOutgoing>::OutgoingMessages>, InterceptedSender<<Context as SubsystemContext>::Sender, Fil>: SubsystemSender<<<Context as SubsystemContext>::Message as AssociateOutgoing>::OutgoingMessages>, Fil: MessageInterceptor<<Context as SubsystemContext>::Sender, Message = <Context as SubsystemContext>::Message>,

impl<M, Spawner> SubsystemContext for TestSubsystemContext<M, Spawner>

where M: AssociateOutgoing + Debug + Send + 'static, AllMessages: From<<M as AssociateOutgoing>::OutgoingMessages> + From<M>, Spawner: Spawner + Send + 'static,