Crate polkadot_node_subsystem::gen

Orchestra

orchestra provides a global information flow of what a token of information. The token is arbitrary, but is used to notify all Subsystems of what is relevant and what is not.

For the motivations behind implementing the orchestra itself you should check out that guide, documentation in this crate will focus and be of technical nature.

An Orchestra is something that allows spawning/stopping and orchestrating asynchronous tasks as well as establishing a well-defined and easy to use protocol that the tasks can use to communicate with each other. It is desired that this protocol is the only way tasks communicate with each other, however at this moment there are no foolproof guards against other ways of communication.

The Orchestra is instantiated with a pre-defined set of Subsystems that share the same behavior from Orchestra’s point of view.

                             +-----------------------------+
                             |         Orchesta            |
                             +-----------------------------+

            ................|  Orchestra "holds" these and uses |.............
            .                  them to (re)start things                      .
            .                                                                .
            .  +-------------------+                +---------------------+  .
            .  |   Subsystem1      |                |   Subsystem2        |  .
            .  +-------------------+                +---------------------+  .
            .           |                                       |            .
            ..................................................................
                        |                                       |
                      start()                                 start()
                        V                                       V
            ..................| Orchestra "runs" these |.......................
            .  +--------------------+               +---------------------+  .
            .  | SubsystemInstance1 | <-- bidir --> | SubsystemInstance2  |  .
            .  +--------------------+               +---------------------+  .
            ..................................................................

Modules

• futures
  Abstractions for asynchronous programming.
• metered
  Metered variant of mpsc channels to be able to extract metrics.
• tracing
  A scoped, structured logging and diagnostics system.

Macros

• poll
  A macro which returns the result of polling a future once within the current async context.
• select
  Polls multiple futures and streams simultaneously, executing the branch for the future that finishes first. If multiple futures are ready, one will be pseudo-randomly selected at runtime. Futures directly passed to select! must be Unpin and implement FusedFuture.

Structs

• Context
  The context of an asynchronous task.
• Delay
  A future representing the notification that an elapsed duration has occurred.
• Duration
  A Duration type to represent a span of time, typically used for system timeouts.
• Fuse
  Future for the fuse method.
• FuturesUnordered
  A set of futures which may complete in any order.
• MessagePacket
  A wrapping type for messages.
• Pin
  A pinned pointer.
• SignalsReceived
  Watermark to track the received signals.
• SpawnedSubsystem
  An asynchronous subsystem task..
• SubsystemInstance
  A running instance of some Subsystem.
• SubsystemMeterReadouts
  Set of readouts of the Meters of a subsystem.
• SubsystemMeters
  Collection of meters related to a subsystem.
• Timeout
  A future that wraps another future with a Delay allowing for time-limited futures.

Enums

• FromOrchestra
  A message type that a subsystem receives from an orchestra. It wraps signals from an orchestra and messages that are circulating between subsystems.
• OrchestraError
  An error type that describes faults that may happen
• Poll
  Indicates whether a value is available or if the current task has been scheduled to receive a wakeup instead.
• PollNext
  Type to tell SelectWithStrategy which stream to poll next.
• ToOrchestra
  A type of messages that are sent from a Subsystem to the declared orchestra.

Traits

• AnnotateErrorOrigin
  A trait to support the origin annotation such that errors across subsystems can be easier tracked.
• Future
  A future represents an asynchronous computation obtained by use of async.
• FutureExt
  An extension trait for Futures that provides a variety of convenient adapters.
• MapSubsystem
  A helper trait to map a subsystem to smth. else.
• Spawner
  A spawner
• StreamExt
  An extension trait for Streams that provides a variety of convenient combinator functions.
• Subsystem
  A trait that describes the Subsystems that can run on the Orchestra.
• SubsystemContext
  A context type that is given to the Subsystem upon spawning. It can be used by Subsystem to communicate with other Subsystems or spawn jobs.
• SubsystemSender
  Sender end of a channel to interface with a subsystem.
• TimeoutExt
  Extends Future to allow time-limited futures.

Functions

• make_packet
  Create a packet from its parts.
• select
  This function will attempt to pull items from both streams. Each stream will be polled in a round-robin fashion, and whenever a stream is ready to yield an item that item is yielded.
• select_message_channel_strategy
  A functor to specify strategy of the channels selection in the SubsystemIncomingMessages
• select_with_strategy
  This function will attempt to pull items from both streams. You provide a closure to tell SelectWithStrategy which stream to poll. The closure can store state on SelectWithStrategy to which it will receive a &mut on every invocation. This allows basing the strategy on prior choices.

Type Definitions

• BoxFuture
  An owned dynamically typed Future for use in cases where you can’t statically type your result or need to add some indirection.
• OrchestraResult
  Alias for a result with error type OrchestraError.
• SubsystemIncomingMessages
  Incoming messages from both the bounded and unbounded channel.

Attribute Macros

• async_trait
• contextbounds
• orchestra
• subsystem