Enum StateRequest

pub enum StateRequest {
    Start(Rpc<(), ()>),
    Stop(Rpc<(), ()>),
    Reset(FailableRpc<(), ()>),
    Save(FailableRpc<(), Option<SavedStateBlob>>),
    Restore(FailableRpc<SavedStateBlob, ()>),
    PostRestore(FailableRpc<(), ()>),
    Inspect(Deferred),
}

A state change request.

Variants

Start(Rpc<(), ()>)

Start asynchronous operations.

Stop(Rpc<(), ()>)

Stop asynchronous operations.

Reset(FailableRpc<(), ()>)

Reset a stopped unit to initial state.

Save(FailableRpc<(), Option<SavedStateBlob>>)

Save state of a stopped unit.

Restore(FailableRpc<SavedStateBlob, ()>)

Restore state of a stopped unit.

PostRestore(FailableRpc<(), ()>)

Perform any post-restore actions.

Sent after all dependencies have been restored but before starting.

Inspect(Deferred)

Inspect state.

Implementations

impl StateRequest

pub async fn apply_with_concurrent_inspects<'a, T>( self, unit: &mut &'a T, recv: &mut Receiver<StateRequest>, )

where &'a T: StateUnit,

Runs this state request against unit, polling recv for incoming inspect requests and applying them while any state transition is in flight.

For this to work, your state unit T should implement StateUnit for &'_ T.

Panics if a state transition arrives on recv while this one is being processed. This would indicate a contract violation with StateUnits.

pub async fn apply(self, unit: &mut impl StateUnit)

Runs this state request against unit.

Trait Implementations

impl Debug for StateRequest

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

Formats the value using the given formatter.

impl DefaultEncoding for StateRequest

type Encoding = OneofEncoder

The encoding to use for the serialization.

impl<'encoding> OneofDecode<'encoding, Resource> for StateRequest

fn read_variant( item: &mut InplaceOption<'_, Self>, n: u32, field: FieldReader<'encoding, '_, Resource>, ) -> Result<()>

Read the specified variant from the reader.

impl OneofEncode<Resource> for StateRequest

fn write_variant(self, writer: MessageWriter<'_, '_, Resource>)

Write the variant to the writer.

fn compute_variant_size(&mut self, sizer: MessageSizer<'_>)

Compute the size of the variant.