referrerpolicy=no-referrer-when-downgrade
polkadot_overseer

Struct OverseerSubsystemContext

Source
pub struct OverseerSubsystemContext<M: AssociateOutgoing + Send + 'static> { /* private fields */ }
Expand description

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

Trait Implementations§

Source§

impl<M: Debug + AssociateOutgoing + Send + 'static> Debug for OverseerSubsystemContext<M>

Source§

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

Formats the value using the given formatter. Read more
Source§

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

Source§

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.
Source§

type Signal = OverseerSignal

And the same for signals.
Source§

type OutgoingMessages = ()

The overarching messages enum for this particular subsystem.
Source§

type Sender = OverseerSender<()>

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

type Error = SubsystemError

The error type.
Source§

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

Try to asynchronously receive a message. Read more
Source§

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

Receive a signal or a message.
Source§

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

Receive a signal. Read more
Source§

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

Obtain the sender.
Source§

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

Spawn a child task on the executor.
Source§

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.
Source§

impl SubsystemContext for OverseerSubsystemContext<ApprovalDistributionMessage>

Source§

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.
Source§

type Signal = OverseerSignal

And the same for signals.
Source§

type OutgoingMessages = ApprovalDistributionOutgoingMessages

The overarching messages enum for this particular subsystem.
Source§

type Sender = OverseerSender<ApprovalDistributionOutgoingMessages>

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

type Error = SubsystemError

The error type.
Source§

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

Try to asynchronously receive a message. Read more
Source§

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

Receive a signal or a message.
Source§

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

Receive a signal. Read more
Source§

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

Obtain the sender.
Source§

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

Spawn a child task on the executor.
Source§

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.
Source§

impl SubsystemContext for OverseerSubsystemContext<ApprovalVotingMessage>

Source§

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.
Source§

type Signal = OverseerSignal

And the same for signals.
Source§

type OutgoingMessages = ApprovalVotingOutgoingMessages

The overarching messages enum for this particular subsystem.
Source§

type Sender = OverseerSender<ApprovalVotingOutgoingMessages>

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

type Error = SubsystemError

The error type.
Source§

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

Try to asynchronously receive a message. Read more
Source§

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

Receive a signal or a message.
Source§

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

Receive a signal. Read more
Source§

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

Obtain the sender.
Source§

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

Spawn a child task on the executor.
Source§

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.
Source§

impl SubsystemContext for OverseerSubsystemContext<ApprovalVotingParallelMessage>

Source§

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.
Source§

type Signal = OverseerSignal

And the same for signals.
Source§

type OutgoingMessages = ApprovalVotingParallelOutgoingMessages

The overarching messages enum for this particular subsystem.
Source§

type Sender = OverseerSender<ApprovalVotingParallelOutgoingMessages>

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

type Error = SubsystemError

The error type.
Source§

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

Try to asynchronously receive a message. Read more
Source§

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

Receive a signal or a message.
Source§

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

Receive a signal. Read more
Source§

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

Obtain the sender.
Source§

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

Spawn a child task on the executor.
Source§

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.
Source§

impl SubsystemContext for OverseerSubsystemContext<AvailabilityDistributionMessage>

Source§

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.
Source§

type Signal = OverseerSignal

And the same for signals.
Source§

type OutgoingMessages = AvailabilityDistributionOutgoingMessages

The overarching messages enum for this particular subsystem.
Source§

type Sender = OverseerSender<AvailabilityDistributionOutgoingMessages>

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

type Error = SubsystemError

The error type.
Source§

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

Try to asynchronously receive a message. Read more
Source§

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

Receive a signal or a message.
Source§

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

Receive a signal. Read more
Source§

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

Obtain the sender.
Source§

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

Spawn a child task on the executor.
Source§

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.
Source§

impl SubsystemContext for OverseerSubsystemContext<AvailabilityRecoveryMessage>

Source§

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.
Source§

type Signal = OverseerSignal

And the same for signals.
Source§

type OutgoingMessages = AvailabilityRecoveryOutgoingMessages

The overarching messages enum for this particular subsystem.
Source§

type Sender = OverseerSender<AvailabilityRecoveryOutgoingMessages>

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

type Error = SubsystemError

The error type.
Source§

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

Try to asynchronously receive a message. Read more
Source§

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

Receive a signal or a message.
Source§

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

Receive a signal. Read more
Source§

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

Obtain the sender.
Source§

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

Spawn a child task on the executor.
Source§

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.
Source§

impl SubsystemContext for OverseerSubsystemContext<AvailabilityStoreMessage>

Source§

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.
Source§

type Signal = OverseerSignal

And the same for signals.
Source§

type OutgoingMessages = AvailabilityStoreOutgoingMessages

The overarching messages enum for this particular subsystem.
Source§

type Sender = OverseerSender<AvailabilityStoreOutgoingMessages>

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

type Error = SubsystemError

The error type.
Source§

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

Try to asynchronously receive a message. Read more
Source§

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

Receive a signal or a message.
Source§

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

Receive a signal. Read more
Source§

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

Obtain the sender.
Source§

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

Spawn a child task on the executor.
Source§

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.
Source§

impl SubsystemContext for OverseerSubsystemContext<BitfieldDistributionMessage>

Source§

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.
Source§

type Signal = OverseerSignal

And the same for signals.
Source§

type OutgoingMessages = BitfieldDistributionOutgoingMessages

The overarching messages enum for this particular subsystem.
Source§

type Sender = OverseerSender<BitfieldDistributionOutgoingMessages>

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

type Error = SubsystemError

The error type.
Source§

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

Try to asynchronously receive a message. Read more
Source§

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

Receive a signal or a message.
Source§

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

Receive a signal. Read more
Source§

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

Obtain the sender.
Source§

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

Spawn a child task on the executor.
Source§

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.
Source§

impl SubsystemContext for OverseerSubsystemContext<BitfieldSigningMessage>

Source§

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.
Source§

type Signal = OverseerSignal

And the same for signals.
Source§

type OutgoingMessages = BitfieldSigningOutgoingMessages

The overarching messages enum for this particular subsystem.
Source§

type Sender = OverseerSender<BitfieldSigningOutgoingMessages>

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

type Error = SubsystemError

The error type.
Source§

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

Try to asynchronously receive a message. Read more
Source§

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

Receive a signal or a message.
Source§

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

Receive a signal. Read more
Source§

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

Obtain the sender.
Source§

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

Spawn a child task on the executor.
Source§

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.
Source§

impl SubsystemContext for OverseerSubsystemContext<CandidateBackingMessage>

Source§

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.
Source§

type Signal = OverseerSignal

And the same for signals.
Source§

type OutgoingMessages = CandidateBackingOutgoingMessages

The overarching messages enum for this particular subsystem.
Source§

type Sender = OverseerSender<CandidateBackingOutgoingMessages>

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

type Error = SubsystemError

The error type.
Source§

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

Try to asynchronously receive a message. Read more
Source§

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

Receive a signal or a message.
Source§

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

Receive a signal. Read more
Source§

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

Obtain the sender.
Source§

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

Spawn a child task on the executor.
Source§

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.
Source§

impl SubsystemContext for OverseerSubsystemContext<CandidateValidationMessage>

Source§

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.
Source§

type Signal = OverseerSignal

And the same for signals.
Source§

type OutgoingMessages = CandidateValidationOutgoingMessages

The overarching messages enum for this particular subsystem.
Source§

type Sender = OverseerSender<CandidateValidationOutgoingMessages>

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

type Error = SubsystemError

The error type.
Source§

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

Try to asynchronously receive a message. Read more
Source§

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

Receive a signal or a message.
Source§

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

Receive a signal. Read more
Source§

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

Obtain the sender.
Source§

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

Spawn a child task on the executor.
Source§

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.
Source§

impl SubsystemContext for OverseerSubsystemContext<ChainApiMessage>

Source§

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.
Source§

type Signal = OverseerSignal

And the same for signals.
Source§

type OutgoingMessages = ChainApiOutgoingMessages

The overarching messages enum for this particular subsystem.
Source§

type Sender = OverseerSender<ChainApiOutgoingMessages>

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

type Error = SubsystemError

The error type.
Source§

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

Try to asynchronously receive a message. Read more
Source§

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

Receive a signal or a message.
Source§

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

Receive a signal. Read more
Source§

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

Obtain the sender.
Source§

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

Spawn a child task on the executor.
Source§

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.
Source§

impl SubsystemContext for OverseerSubsystemContext<ChainSelectionMessage>

Source§

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.
Source§

type Signal = OverseerSignal

And the same for signals.
Source§

type OutgoingMessages = ChainSelectionOutgoingMessages

The overarching messages enum for this particular subsystem.
Source§

type Sender = OverseerSender<ChainSelectionOutgoingMessages>

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

type Error = SubsystemError

The error type.
Source§

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

Try to asynchronously receive a message. Read more
Source§

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

Receive a signal or a message.
Source§

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

Receive a signal. Read more
Source§

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

Obtain the sender.
Source§

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

Spawn a child task on the executor.
Source§

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.
Source§

impl SubsystemContext for OverseerSubsystemContext<CollationGenerationMessage>

Source§

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.
Source§

type Signal = OverseerSignal

And the same for signals.
Source§

type OutgoingMessages = CollationGenerationOutgoingMessages

The overarching messages enum for this particular subsystem.
Source§

type Sender = OverseerSender<CollationGenerationOutgoingMessages>

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

type Error = SubsystemError

The error type.
Source§

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

Try to asynchronously receive a message. Read more
Source§

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

Receive a signal or a message.
Source§

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

Receive a signal. Read more
Source§

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

Obtain the sender.
Source§

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

Spawn a child task on the executor.
Source§

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.
Source§

impl SubsystemContext for OverseerSubsystemContext<CollatorProtocolMessage>

Source§

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.
Source§

type Signal = OverseerSignal

And the same for signals.
Source§

type OutgoingMessages = CollatorProtocolOutgoingMessages

The overarching messages enum for this particular subsystem.
Source§

type Sender = OverseerSender<CollatorProtocolOutgoingMessages>

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

type Error = SubsystemError

The error type.
Source§

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

Try to asynchronously receive a message. Read more
Source§

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

Receive a signal or a message.
Source§

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

Receive a signal. Read more
Source§

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

Obtain the sender.
Source§

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

Spawn a child task on the executor.
Source§

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.
Source§

impl SubsystemContext for OverseerSubsystemContext<DisputeCoordinatorMessage>

Source§

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.
Source§

type Signal = OverseerSignal

And the same for signals.
Source§

type OutgoingMessages = DisputeCoordinatorOutgoingMessages

The overarching messages enum for this particular subsystem.
Source§

type Sender = OverseerSender<DisputeCoordinatorOutgoingMessages>

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

type Error = SubsystemError

The error type.
Source§

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

Try to asynchronously receive a message. Read more
Source§

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

Receive a signal or a message.
Source§

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

Receive a signal. Read more
Source§

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

Obtain the sender.
Source§

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

Spawn a child task on the executor.
Source§

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.
Source§

impl SubsystemContext for OverseerSubsystemContext<DisputeDistributionMessage>

Source§

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.
Source§

type Signal = OverseerSignal

And the same for signals.
Source§

type OutgoingMessages = DisputeDistributionOutgoingMessages

The overarching messages enum for this particular subsystem.
Source§

type Sender = OverseerSender<DisputeDistributionOutgoingMessages>

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

type Error = SubsystemError

The error type.
Source§

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

Try to asynchronously receive a message. Read more
Source§

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

Receive a signal or a message.
Source§

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

Receive a signal. Read more
Source§

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

Obtain the sender.
Source§

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

Spawn a child task on the executor.
Source§

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.
Source§

impl SubsystemContext for OverseerSubsystemContext<GossipSupportMessage>

Source§

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.
Source§

type Signal = OverseerSignal

And the same for signals.
Source§

type OutgoingMessages = GossipSupportOutgoingMessages

The overarching messages enum for this particular subsystem.
Source§

type Sender = OverseerSender<GossipSupportOutgoingMessages>

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

type Error = SubsystemError

The error type.
Source§

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

Try to asynchronously receive a message. Read more
Source§

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

Receive a signal or a message.
Source§

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

Receive a signal. Read more
Source§

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

Obtain the sender.
Source§

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

Spawn a child task on the executor.
Source§

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.
Source§

impl SubsystemContext for OverseerSubsystemContext<NetworkBridgeRxMessage>

Source§

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.
Source§

type Signal = OverseerSignal

And the same for signals.
Source§

type OutgoingMessages = NetworkBridgeRxOutgoingMessages

The overarching messages enum for this particular subsystem.
Source§

type Sender = OverseerSender<NetworkBridgeRxOutgoingMessages>

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

type Error = SubsystemError

The error type.
Source§

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

Try to asynchronously receive a message. Read more
Source§

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

Receive a signal or a message.
Source§

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

Receive a signal. Read more
Source§

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

Obtain the sender.
Source§

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

Spawn a child task on the executor.
Source§

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.
Source§

impl SubsystemContext for OverseerSubsystemContext<NetworkBridgeTxMessage>

Source§

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.
Source§

type Signal = OverseerSignal

And the same for signals.
Source§

type OutgoingMessages = NetworkBridgeTxOutgoingMessages

The overarching messages enum for this particular subsystem.
Source§

type Sender = OverseerSender<NetworkBridgeTxOutgoingMessages>

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

type Error = SubsystemError

The error type.
Source§

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

Try to asynchronously receive a message. Read more
Source§

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

Receive a signal or a message.
Source§

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

Receive a signal. Read more
Source§

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

Obtain the sender.
Source§

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

Spawn a child task on the executor.
Source§

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.
Source§

impl SubsystemContext for OverseerSubsystemContext<ProspectiveParachainsMessage>

Source§

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.
Source§

type Signal = OverseerSignal

And the same for signals.
Source§

type OutgoingMessages = ProspectiveParachainsOutgoingMessages

The overarching messages enum for this particular subsystem.
Source§

type Sender = OverseerSender<ProspectiveParachainsOutgoingMessages>

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

type Error = SubsystemError

The error type.
Source§

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

Try to asynchronously receive a message. Read more
Source§

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

Receive a signal or a message.
Source§

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

Receive a signal. Read more
Source§

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

Obtain the sender.
Source§

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

Spawn a child task on the executor.
Source§

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.
Source§

impl SubsystemContext for OverseerSubsystemContext<ProvisionerMessage>

Source§

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.
Source§

type Signal = OverseerSignal

And the same for signals.
Source§

type OutgoingMessages = ProvisionerOutgoingMessages

The overarching messages enum for this particular subsystem.
Source§

type Sender = OverseerSender<ProvisionerOutgoingMessages>

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

type Error = SubsystemError

The error type.
Source§

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

Try to asynchronously receive a message. Read more
Source§

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

Receive a signal or a message.
Source§

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

Receive a signal. Read more
Source§

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

Obtain the sender.
Source§

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

Spawn a child task on the executor.
Source§

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.
Source§

impl SubsystemContext for OverseerSubsystemContext<PvfCheckerMessage>

Source§

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.
Source§

type Signal = OverseerSignal

And the same for signals.
Source§

type OutgoingMessages = PvfCheckerOutgoingMessages

The overarching messages enum for this particular subsystem.
Source§

type Sender = OverseerSender<PvfCheckerOutgoingMessages>

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

type Error = SubsystemError

The error type.
Source§

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

Try to asynchronously receive a message. Read more
Source§

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

Receive a signal or a message.
Source§

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

Receive a signal. Read more
Source§

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

Obtain the sender.
Source§

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

Spawn a child task on the executor.
Source§

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.
Source§

impl SubsystemContext for OverseerSubsystemContext<RuntimeApiMessage>

Source§

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.
Source§

type Signal = OverseerSignal

And the same for signals.
Source§

type OutgoingMessages = RuntimeApiOutgoingMessages

The overarching messages enum for this particular subsystem.
Source§

type Sender = OverseerSender<RuntimeApiOutgoingMessages>

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

type Error = SubsystemError

The error type.
Source§

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

Try to asynchronously receive a message. Read more
Source§

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

Receive a signal or a message.
Source§

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

Receive a signal. Read more
Source§

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

Obtain the sender.
Source§

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

Spawn a child task on the executor.
Source§

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.
Source§

impl SubsystemContext for OverseerSubsystemContext<StatementDistributionMessage>

Source§

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.
Source§

type Signal = OverseerSignal

And the same for signals.
Source§

type OutgoingMessages = StatementDistributionOutgoingMessages

The overarching messages enum for this particular subsystem.
Source§

type Sender = OverseerSender<StatementDistributionOutgoingMessages>

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

type Error = SubsystemError

The error type.
Source§

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

Try to asynchronously receive a message. Read more
Source§

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

Receive a signal or a message.
Source§

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

Receive a signal. Read more
Source§

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

Obtain the sender.
Source§

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

Spawn a child task on the executor.
Source§

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.

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
§

impl<T> Any for T
where T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

§

fn type_name(&self) -> &'static str

§

impl<T> AnySync for T
where T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Source§

impl<T> ApprovalDistributionContextTrait for T

Source§

type Sender = <T as SubsystemContext>::Sender

Sender.
Source§

impl<T> ApprovalVotingContextTrait for T

Source§

type Sender = <T as SubsystemContext>::Sender

Sender.
Source§

impl<T> ApprovalVotingParallelContextTrait for T

Source§

type Sender = <T as SubsystemContext>::Sender

Sender.
Source§

impl<T> AvailabilityDistributionContextTrait for T

Source§

type Sender = <T as SubsystemContext>::Sender

Sender.
Source§

impl<T> AvailabilityRecoveryContextTrait for T

Source§

type Sender = <T as SubsystemContext>::Sender

Sender.
Source§

impl<T> AvailabilityStoreContextTrait for T

Source§

type Sender = <T as SubsystemContext>::Sender

Sender.
Source§

impl<T> BitfieldDistributionContextTrait for T

Source§

type Sender = <T as SubsystemContext>::Sender

Sender.
Source§

impl<T> BitfieldSigningContextTrait for T

Source§

type Sender = <T as SubsystemContext>::Sender

Sender.
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CandidateBackingContextTrait for T

Source§

type Sender = <T as SubsystemContext>::Sender

Sender.
Source§

impl<T> CandidateValidationContextTrait for T

Source§

type Sender = <T as SubsystemContext>::Sender

Sender.
Source§

impl<T> ChainApiContextTrait for T

Source§

type Sender = <T as SubsystemContext>::Sender

Sender.
Source§

impl<T> ChainSelectionContextTrait for T

Source§

type Sender = <T as SubsystemContext>::Sender

Sender.
Source§

impl<T> CheckedConversion for T

Source§

fn checked_from<T>(t: T) -> Option<Self>
where Self: TryFrom<T>,

Convert from a value of T into an equivalent instance of Option<Self>. Read more
Source§

fn checked_into<T>(self) -> Option<T>
where Self: TryInto<T>,

Consume self to return Some equivalent value of Option<T>. Read more
Source§

impl<T> CollationGenerationContextTrait for T

Source§

type Sender = <T as SubsystemContext>::Sender

Sender.
Source§

impl<T> CollatorProtocolContextTrait for T

Source§

type Sender = <T as SubsystemContext>::Sender

Sender.
§

impl<T> Conv for T

§

fn conv<T>(self) -> T
where Self: Into<T>,

Converts self into T using Into<T>. Read more
Source§

impl<T> DisputeCoordinatorContextTrait for T

Source§

type Sender = <T as SubsystemContext>::Sender

Sender.
Source§

impl<T> DisputeDistributionContextTrait for T

Source§

type Sender = <T as SubsystemContext>::Sender

Sender.
§

impl<T> FmtForward for T

§

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

Causes self to use its Binary implementation when Debug-formatted.
§

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

Causes self to use its Display implementation when Debug-formatted.
§

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

Causes self to use its LowerExp implementation when Debug-formatted.
§

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

Causes self to use its LowerHex implementation when Debug-formatted.
§

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

Causes self to use its Octal implementation when Debug-formatted.
§

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

Causes self to use its Pointer implementation when Debug-formatted.
§

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

Causes self to use its UpperExp implementation when Debug-formatted.
§

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

Causes self to use its UpperHex implementation when Debug-formatted.
§

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

Formats each item in a sequence. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T> GossipSupportContextTrait for T

Source§

type Sender = <T as SubsystemContext>::Sender

Sender.
§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T> Instrument for T

Source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
Source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
§

impl<Src, Dest> IntoTuple<Dest> for Src
where Dest: FromTuple<Src>,

§

fn into_tuple(self) -> Dest

Source§

impl<T, Outer> IsWrappedBy<Outer> for T
where Outer: AsRef<T> + AsMut<T> + From<T>, T: From<Outer>,

Source§

fn from_ref(outer: &Outer) -> &T

Get a reference to the inner from the outer.

Source§

fn from_mut(outer: &mut Outer) -> &mut T

Get a mutable reference to the inner from the outer.

Source§

impl<T> NetworkBridgeRxContextTrait for T

Source§

type Sender = <T as SubsystemContext>::Sender

Sender.
Source§

impl<T> NetworkBridgeTxContextTrait for T

Source§

type Sender = <T as SubsystemContext>::Sender

Sender.
§

impl<T> Pipe for T
where T: ?Sized,

§

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

Pipes by value. This is generally the method you want to use. Read more
§

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

Borrows self and passes that borrow into the pipe function. Read more
§

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

Mutably borrows self and passes that borrow into the pipe function. Read more
§

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

Borrows self, then passes self.borrow() into the pipe function. Read more
§

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more
§

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

Borrows self, then passes self.as_ref() into the pipe function.
§

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.as_mut() into the pipe function.
§

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

Borrows self, then passes self.deref() into the pipe function.
§

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.deref_mut() into the pipe function.
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

impl<T> ProspectiveParachainsContextTrait for T

Source§

type Sender = <T as SubsystemContext>::Sender

Sender.
Source§

impl<T> ProvisionerContextTrait for T

Source§

type Sender = <T as SubsystemContext>::Sender

Sender.
Source§

impl<T> PvfCheckerContextTrait for T

Source§

type Sender = <T as SubsystemContext>::Sender

Sender.
Source§

impl<T> RuntimeApiContextTrait for T

Source§

type Sender = <T as SubsystemContext>::Sender

Sender.
Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

impl<T> SaturatedConversion for T

Source§

fn saturated_from<T>(t: T) -> Self
where Self: UniqueSaturatedFrom<T>,

Convert from a value of T into an equivalent instance of Self. Read more
Source§

fn saturated_into<T>(self) -> T
where Self: UniqueSaturatedInto<T>,

Consume self to return an equivalent value of T. Read more
Source§

impl<T> StatementDistributionContextTrait for T

Source§

type Sender = <T as SubsystemContext>::Sender

Sender.
§

impl<T> Tap for T

§

fn tap(self, func: impl FnOnce(&Self)) -> Self

Immutable access to a value. Read more
§

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Mutable access to a value. Read more
§

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Immutable access to the Borrow<B> of a value. Read more
§

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Mutable access to the BorrowMut<B> of a value. Read more
§

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Immutable access to the AsRef<R> view of a value. Read more
§

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Mutable access to the AsMut<R> view of a value. Read more
§

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Immutable access to the Deref::Target of a value. Read more
§

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Mutable access to the Deref::Target of a value. Read more
§

fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

Calls .tap() only in debug builds, and is erased in release builds.
§

fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

Calls .tap_mut() only in debug builds, and is erased in release builds.
§

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Calls .tap_borrow() only in debug builds, and is erased in release builds.
§

fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds.
§

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Calls .tap_ref() only in debug builds, and is erased in release builds.
§

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Calls .tap_ref_mut() only in debug builds, and is erased in release builds.
§

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Calls .tap_deref() only in debug builds, and is erased in release builds.
§

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Calls .tap_deref_mut() only in debug builds, and is erased in release builds.
§

impl<T> TryConv for T

§

fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

Attempts to convert self into T using TryInto<T>. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<S, T> UncheckedInto<T> for S
where T: UncheckedFrom<S>,

Source§

fn unchecked_into(self) -> T

The counterpart to unchecked_from.
Source§

impl<T, S> UniqueSaturatedInto<T> for S
where T: Bounded, S: TryInto<T>,

Source§

fn unique_saturated_into(self) -> T

Consume self to return an equivalent value of T.
§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a [WithDispatch] wrapper. Read more
Source§

impl<T> WithSubscriber for T

Source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
§

impl<T> ErasedDestructor for T
where T: 'static,

§

impl<T> JsonSchemaMaybe for T

§

impl<T> MaybeDebug for T
where T: Debug,

§

impl<T> MaybeSend for T
where T: Send,

§

impl<T> MaybeSendSync for T