Struct Retry 

pub struct Retry;

The marker of a registration’s deferred-retry slot: .out(Retry, policy) names the publish policy a retry_after copy leaves through.

The slot is an ordinary Out position, so the chain after the call takes the steps every slot takes: .codec(..) names the position’s codec, .transform(..) composes a PublishTransform the copy travels through, and a broker’s own publisher settings reach the policy through map_publisher. The deferred copy is already serialized - it is the delivery’s own bytes with the retry count incremented - so it passes the codec by, the way a Serialized value does on any slot.

The position is filled before the call: every registration whose subscription declares AddressedCopies or NamedCopies gets a publisher from the broker’s own DefaultPublish policy, and this call replaces it. On a descriptor that declares BrokerMoves the call does not compile: the broker moves the delivery itself and there is nothing of this process’s to publish. It comes after the registration’s declaration, max_attempts and dead_letter.

Where a copy goes is the subscription’s own answer, read at startup from RedeliveryAddressed: a subscription name and a publish destination are one string on a subject or a topic, and separate resources on Google Pub/Sub. A registration over a subscription which publishes its copies here and reports no address refuses to start, naming the subscription and its descriptor, instead of publishing copies into nothing once a handler asks for a delay. The slot therefore never lets a transform name the destination, and the generated AsyncAPI document ignores the position: a copy goes to the subscription’s own address, or to the declared dead-letter destination, and neither is this position’s to name.

Brokers with native delayed redelivery do not need the position: the runtime uses their nack_after instead, and no copy is published there.

Cancel safety

The deferred copy is at-most-once over the delay window: see HandlerOutcome::retry_after.

Examples

use std::time::Duration;

use ruststream::memory::prelude::*;

#[subscriber("orders")]
async fn reconcile(order: &Order) -> HandlerOutcome {
    let _ = order.id;
    HandlerOutcome::retry_after(Duration::from_secs(30))
}

fn app() -> RustStream {
    RustStream::new(AppInfo::new("orders", "0.1.0")).with_broker(MemoryBroker::new(), |b| {
        b.include(reconcile).out(Retry, Publish);
    })
}

Trait Implementations

impl Clone for Retry

fn clone(&self) -> Retry

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Retry

impl Debug for Retry

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

Formats the value using the given formatter.

impl Default for Retry

fn default() -> Retry

Returns the “default value” for a type.

impl Eq for Retry

impl Hash for Retry

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl OutSlot for Retry

const NAME: &'static str = "Retry"

The human-readable slot name, used by diagnostics and test assertions.

type Destination = Reads

The most a transform on this slot may do to a message’s destination.

fn outgoing() -> Vec<OutgoingMessageMetadata>

The slot’s publish dictionary as AsyncAPI metadata, one entry per #[publishes(..)] type. The derive fills this in; the default (a marker without a dictionary) publishes nothing declared. Called once at registration; never on the publish path.

impl PartialEq for Retry

fn eq(&self, other: &Retry) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Retry