Struct SubscriptionStateMachine 

pub struct SubscriptionStateMachine {
    state: SubscriptionState,
}

Pure state machine for a MoQT subscription. Transitions: Idle -> Subscribing -> Active -> Done.

Fields

state: SubscriptionState

Implementations

impl SubscriptionStateMachine

pub fn on_subscribe_received(&mut self) -> Result<(), SubscriptionError>

Idle -> Subscribing (SUBSCRIBE received from the peer).

pub fn on_subscribe_ok_sent(&mut self) -> Result<(), SubscriptionError>

Subscribing -> Active (SUBSCRIBE_OK written on the peer’s stream).

pub fn on_subscribe_error_sent(&mut self) -> Result<(), SubscriptionError>

Subscribing -> Done (REQUEST_ERROR written on the peer’s stream).

pub fn on_publish_done_sent(&mut self) -> Result<(), SubscriptionError>

Active -> Done (PUBLISH_DONE written on the peer’s stream).

impl SubscriptionStateMachine

pub fn new() -> Self

Creates a new state machine in the SubscriptionState::Idle state.

pub fn state(&self) -> SubscriptionState

Returns the current state of the subscription.

pub fn on_subscribe_sent(&mut self) -> Result<(), SubscriptionError>

Idle -> Subscribing (SUBSCRIBE sent).

pub fn on_subscribe_ok(&mut self) -> Result<(), SubscriptionError>

Subscribing -> Active (SUBSCRIBE_OK received).

pub fn on_subscribe_error(&mut self) -> Result<(), SubscriptionError>

Subscribing -> Done (REQUEST_ERROR received).

pub fn on_request_cancelled(&mut self) -> Result<(), SubscriptionError>

Subscribing | Active -> Done, Done -> Done (this subscription’s request stream was cancelled).

This draft has no UNSUBSCRIBE message. Section 3.3.3: “Once a request stream has been opened, the request MAY be cancelled by either endpoint.”

Subscribing is accepted because the precondition is the stream being open, and it is open from the SUBSCRIBE that opened it: a subscription can be withdrawn before it is ever answered.

Idle is refused, on the other half of the same sentence: nothing has been written, so there is no stream to terminate. Done stays Done — nothing finishes a request stream’s send half on the ordinary path, so a caller that walks away from a request that has already ended still resets the stream, and that reset is an ordinary end rather than a fault.

pub fn on_subscribe_update(&mut self) -> Result<(), SubscriptionError>

REQUEST_UPDATE received – a self-transition, from Subscribing as well as from Active.

Section 10.9 orders an update against the request rather than against the request’s answer: the sender of a SUBSCRIBE “can later send a REQUEST_UPDATE on the same bidi stream as the request to modify it”, where later is later than the SUBSCRIBE. The stream is open from the moment the SUBSCRIBE opens it.

Draft-20 contemplates the case outright. Section 10.3.1.7 bounds how many REQUEST_UPDATEs may be outstanding on one request stream at a time, a limit that means nothing to a sender that waits for each answer before sending the next message.

So a peer that sends SUBSCRIBE and REQUEST_UPDATE back to back breaks no rule this draft states, and an update arriving before the answer leaves the subscription where it found it. Idle and Done are still refused: in neither does the subscription an update names exist.

pub fn on_publish_done(&mut self) -> Result<(), SubscriptionError>

Active -> Done (PUBLISH_DONE received).

Trait Implementations

impl Default for SubscriptionStateMachine

fn default() -> Self

Returns the “default value” for a type.