Struct FaultRuntime 

pub struct FaultRuntime { /* private fields */ }

The validated fault-tolerance capability installed on a chunk step.

The bundle owns the policy, the injected monotonic sleeper, the reservation store, and the declared delivery mode. Capabilities are validated at construction so a statically impossible combination cannot reach user work.

use std::sync::Arc;
use std::time::Duration;

use oxide_batch::{
    BackoffOutcome, BackoffPolicy, BackoffSleeper, BoxFuture, ChunkDeliveryMode,
    ClassifierRevision, FailureCategory, FaultAction, FaultClassifier, FaultPhase, FaultPolicy,
    FaultRule, FaultRuntime, InMemoryFaultState, RetryLimit, RetryStateLimit, SkipLimit,
    StopToken,
};

struct ImmediateSleeper;

impl BackoffSleeper for ImmediateSleeper {
    fn sleep<'a>(
        &'a self,
        _delay: Duration,
        stop: &'a StopToken,
    ) -> BoxFuture<'a, BackoffOutcome> {
        let stopped = stop.is_stop_requested();
        Box::pin(async move {
            if stopped { BackoffOutcome::Stopped } else { BackoffOutcome::Elapsed }
        })
    }
}

let policy = FaultPolicy::new(
    FaultClassifier::new(
        ClassifierRevision::new("import_v1")?,
        [FaultRule::new(
            FaultPhase::Write,
            FailureCategory::Timeout,
            FaultAction::retry(),
        )?],
    )?,
    RetryLimit::new(2)?,
    RetryStateLimit::new(16)?,
    SkipLimit::NONE,
    BackoffPolicy::fixed(Duration::from_millis(10))?,
)?;
let state = Arc::new(InMemoryFaultState::new(policy.retry_state_limit()));
let runtime = FaultRuntime::new(
    policy,
    Arc::new(ImmediateSleeper),
    state,
    ChunkDeliveryMode::AtLeastOnce,
)?;
assert_eq!(runtime.delivery_mode(), ChunkDeliveryMode::AtLeastOnce);

Implementations

impl FaultRuntime

pub fn new( policy: FaultPolicy, sleeper: Arc<dyn BackoffSleeper>, state: Arc<dyn FaultStateStore>, delivery_mode: ChunkDeliveryMode, ) -> Result<Self, FaultPolicyError>

Validates and installs the fault-tolerance capability.

Errors

Returns crate::FaultPolicyError::CommitSafeSkipUnsupported when the policy accepts a commit-safe skip that the declared delivery mode cannot commit atomically.

pub fn policy(&self) -> &FaultPolicy

Borrows the validated step policy.

pub fn sleeper(&self) -> &dyn BackoffSleeper

Borrows the injected monotonic sleeper.

pub fn state(&self) -> &dyn FaultStateStore

Borrows the reservation store.

pub const fn delivery_mode(&self) -> ChunkDeliveryMode

Returns the delivery mode declared for this step.

Trait Implementations

impl Clone for FaultRuntime

fn clone(&self) -> FaultRuntime

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FaultRuntime

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

Formats the value using the given formatter.