Struct polkadot_node_subsystem::OverseerSubsystemContext

pub struct OverseerSubsystemContext<M>
where
    M: AssociateOutgoing + Send + 'static,
{ /* private fields */ }

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

Trait Implementations

impl<M> Debug for OverseerSubsystemContext<M>

where M: Debug + AssociateOutgoing + Send + 'static,

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

Formats the value using the given formatter.

impl SubsystemContext for OverseerSubsystemContext<()>

where (): AssociateOutgoing + Debug + Send + 'static, AllMessages: From<()>,

type Message = ()

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

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = ()

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<()>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message.

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,

Receive a signal or a message.

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,

Receive a signal.

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

Obtain the sender.

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

Spawn a child task on the executor.

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

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

fn send_message<'life0, 'async_trait, 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.

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

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

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = ApprovalDistributionOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<ApprovalDistributionOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message.

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,

Receive a signal or a message.

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,

Receive a signal.

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

Obtain the sender.

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

Spawn a child task on the executor.

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

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

fn send_message<'life0, 'async_trait, 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.

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

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

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = ApprovalVotingOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<ApprovalVotingOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message.

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,

Receive a signal or a message.

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,

Receive a signal.

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

Obtain the sender.

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

Spawn a child task on the executor.

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

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

fn send_message<'life0, 'async_trait, 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.

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

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

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = ApprovalVotingParallelOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<ApprovalVotingParallelOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message.

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,

Receive a signal or a message.

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,

Receive a signal.

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

Obtain the sender.

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

Spawn a child task on the executor.

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

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

fn send_message<'life0, 'async_trait, 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.

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

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

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = AvailabilityDistributionOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<AvailabilityDistributionOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message.

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,

Receive a signal or a message.

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,

Receive a signal.

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

Obtain the sender.

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

Spawn a child task on the executor.

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

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

fn send_message<'life0, 'async_trait, 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.

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

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

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = AvailabilityRecoveryOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<AvailabilityRecoveryOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message.

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,

Receive a signal or a message.

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,

Receive a signal.

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

Obtain the sender.

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

Spawn a child task on the executor.

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

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

fn send_message<'life0, 'async_trait, 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.

impl SubsystemContext for OverseerSubsystemContext<AvailabilityStoreMessage>

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

type Message = AvailabilityStoreMessage

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

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = AvailabilityStoreOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<AvailabilityStoreOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message.

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,

Receive a signal or a message.

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,

Receive a signal.

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

Obtain the sender.

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

Spawn a child task on the executor.

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

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

fn send_message<'life0, 'async_trait, 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.

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

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

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = BitfieldDistributionOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<BitfieldDistributionOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message.

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,

Receive a signal or a message.

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,

Receive a signal.

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

Obtain the sender.

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

Spawn a child task on the executor.

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

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

fn send_message<'life0, 'async_trait, 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.

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

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

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = BitfieldSigningOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<BitfieldSigningOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message.

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,

Receive a signal or a message.

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,

Receive a signal.

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

Obtain the sender.

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

Spawn a child task on the executor.

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

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

fn send_message<'life0, 'async_trait, 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.

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

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

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = CandidateBackingOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<CandidateBackingOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message.

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,

Receive a signal or a message.

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,

Receive a signal.

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

Obtain the sender.

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

Spawn a child task on the executor.

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

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

fn send_message<'life0, 'async_trait, 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.

impl SubsystemContext for OverseerSubsystemContext<CandidateValidationMessage>

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

type Message = CandidateValidationMessage

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

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = CandidateValidationOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<CandidateValidationOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message.

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,

Receive a signal or a message.

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,

Receive a signal.

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

Obtain the sender.

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

Spawn a child task on the executor.

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

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

fn send_message<'life0, 'async_trait, 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.

impl SubsystemContext for OverseerSubsystemContext<ChainApiMessage>

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

type Message = ChainApiMessage

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

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = ChainApiOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<ChainApiOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message.

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,

Receive a signal or a message.

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,

Receive a signal.

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

Obtain the sender.

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

Spawn a child task on the executor.

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

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

fn send_message<'life0, 'async_trait, 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.

impl SubsystemContext for OverseerSubsystemContext<ChainSelectionMessage>

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

type Message = ChainSelectionMessage

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

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = ChainSelectionOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<ChainSelectionOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message.

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,

Receive a signal or a message.

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,

Receive a signal.

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

Obtain the sender.

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

Spawn a child task on the executor.

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

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

fn send_message<'life0, 'async_trait, 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.

impl SubsystemContext for OverseerSubsystemContext<CollationGenerationMessage>

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

type Message = CollationGenerationMessage

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

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = CollationGenerationOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<CollationGenerationOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message.

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,

Receive a signal or a message.

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,

Receive a signal.

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

Obtain the sender.

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

Spawn a child task on the executor.

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

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

fn send_message<'life0, 'async_trait, 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.

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

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

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = CollatorProtocolOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<CollatorProtocolOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message.

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,

Receive a signal or a message.

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,

Receive a signal.

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

Obtain the sender.

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

Spawn a child task on the executor.

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

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

fn send_message<'life0, 'async_trait, 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.

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

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

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = DisputeCoordinatorOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<DisputeCoordinatorOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message.

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,

Receive a signal or a message.

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,

Receive a signal.

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

Obtain the sender.

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

Spawn a child task on the executor.

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

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

fn send_message<'life0, 'async_trait, 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.

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

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

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = DisputeDistributionOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<DisputeDistributionOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message.

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,

Receive a signal or a message.

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,

Receive a signal.

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

Obtain the sender.

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

Spawn a child task on the executor.

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

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

fn send_message<'life0, 'async_trait, 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.

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

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

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = GossipSupportOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<GossipSupportOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message.

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,

Receive a signal or a message.

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,

Receive a signal.

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

Obtain the sender.

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

Spawn a child task on the executor.

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

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

fn send_message<'life0, 'async_trait, 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.

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

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

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = NetworkBridgeRxOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<NetworkBridgeRxOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message.

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,

Receive a signal or a message.

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,

Receive a signal.

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

Obtain the sender.

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

Spawn a child task on the executor.

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

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

fn send_message<'life0, 'async_trait, 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.

impl SubsystemContext for OverseerSubsystemContext<NetworkBridgeTxMessage>

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

type Message = NetworkBridgeTxMessage

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

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = NetworkBridgeTxOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<NetworkBridgeTxOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message.

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,

Receive a signal or a message.

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,

Receive a signal.

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

Obtain the sender.

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

Spawn a child task on the executor.

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

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

fn send_message<'life0, 'async_trait, 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.

impl SubsystemContext for OverseerSubsystemContext<ProspectiveParachainsMessage>

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

type Message = ProspectiveParachainsMessage

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

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = ProspectiveParachainsOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<ProspectiveParachainsOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message.

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,

Receive a signal or a message.

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,

Receive a signal.

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

Obtain the sender.

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

Spawn a child task on the executor.

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

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

fn send_message<'life0, 'async_trait, 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.

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

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

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = ProvisionerOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<ProvisionerOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message.

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,

Receive a signal or a message.

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,

Receive a signal.

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

Obtain the sender.

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

Spawn a child task on the executor.

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

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

fn send_message<'life0, 'async_trait, 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.

impl SubsystemContext for OverseerSubsystemContext<PvfCheckerMessage>

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

type Message = PvfCheckerMessage

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

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = PvfCheckerOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<PvfCheckerOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message.

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,

Receive a signal or a message.

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,

Receive a signal.

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

Obtain the sender.

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

Spawn a child task on the executor.

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

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

fn send_message<'life0, 'async_trait, 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.

impl SubsystemContext for OverseerSubsystemContext<RuntimeApiMessage>

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

type Message = RuntimeApiMessage

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

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = RuntimeApiOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<RuntimeApiOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message.

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,

Receive a signal or a message.

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,

Receive a signal.

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

Obtain the sender.

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

Spawn a child task on the executor.

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

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

fn send_message<'life0, 'async_trait, 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.

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

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

type Signal = OverseerSignal

And the same for signals.

type OutgoingMessages = StatementDistributionOutgoingMessages

The overarching messages enum for this particular subsystem.

type Sender = OverseerSender<StatementDistributionOutgoingMessages>

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

type Error = SubsystemError

The error type.

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,

Try to asynchronously receive a message.

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,

Receive a signal or a message.

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,

Receive a signal.

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

Obtain the sender.

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

Spawn a child task on the executor.

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

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

fn send_message<'life0, 'async_trait, 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.