Struct RetryPermit 

pub struct RetryPermit<'controller, 'request, 'subject> { /* private fields */ }

Non-cloneable authorization for one exact prepared replay.

The permit exclusively borrows controller monotonic state until it is consumed. Safe code therefore cannot retain two permits from one owner. Execution is performed by the permit and never returns a reusable request.

use cloud_sdk::retry::RetryPermit;

fn duplicate(permit: RetryPermit<'_, '_, '_>) {
    let _second = permit.clone();
}

use cloud_sdk::retry::{
    MonotonicDuration, MonotonicInstant, RetryController, RetryEvent,
    RetrySubject,
};
use cloud_sdk::transport::DeliveryPhase;

fn fan_out<'initial, 'binding, 'replay, 'subject>(
    controller: &mut RetryController<'initial, 'binding>,
    replay: RetrySubject<'replay, 'subject>,
) {
    let first = controller.decide_retry(
        RetryEvent::Transport(DeliveryPhase::NotSent),
        replay,
        MonotonicDuration::new(0),
        MonotonicInstant::new(1),
    );
    let _second = controller.decide_retry(
        RetryEvent::Transport(DeliveryPhase::NotSent),
        replay,
        MonotonicDuration::new(0),
        MonotonicInstant::new(1),
    );
    drop(first);
}

Implementations

impl<'controller, 'request, 'subject> RetryPermit<'controller, 'request, 'subject>

pub const fn attempt(&self) -> u16

Returns the authorized attempt number, including the initial attempt.

pub const fn delay(&self) -> MonotonicDuration

Returns the exact caller-selected delay charged to retry budgets.

pub fn execute_blocking<'buffer, T>( self, now: MonotonicInstant, transport: &T, response_storage: &'buffer mut [u8], response_header_storage: &'buffer mut [u8], ) -> Result<CheckedResponseGuard<'buffer>, RetryExecutionError<T::Error>>

where T: BlockingAuthenticatedTransport + BoundTransport,

Authorizes and executes the exact replay once on a blocking transport.

pub async fn execute_async<'transport, 'buffer, T>( self, now: MonotonicInstant, transport: &'transport T, response_storage: &'buffer mut [u8], response_header_storage: &'buffer mut [u8], ) -> Result<CheckedResponseGuard<'buffer>, RetryExecutionError<T::Error>>

where T: AsyncAuthenticatedTransport + BoundTransport, 'request: 'transport, 'subject: 'transport,

Authorizes and executes the exact replay once without owning an executor.

pub async fn execute_local_async<'transport, 'buffer, T>( self, now: MonotonicInstant, transport: &'transport T, response_storage: &'buffer mut [u8], response_header_storage: &'buffer mut [u8], ) -> Result<CheckedResponseGuard<'buffer>, RetryExecutionError<T::Error>>

where T: LocalAsyncAuthenticatedTransport + BoundTransport, 'request: 'transport, 'subject: 'transport,

Authorizes and executes the exact replay once on a local async transport without owning an executor.

Trait Implementations

impl Debug for RetryPermit<'_, '_, '_>

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

Formats the value using the given formatter.