Struct BackoffPolicy 

pub struct BackoffPolicy {
    pub initial: Duration,
    pub max: Duration,
    pub jitter_percent: u8,
    pub reset_after: Duration,
    pub jitter_mode: JitterMode,
}

Exponential backoff configuration for restart attempts.

Fields

initial: Duration

Initial delay for the first restart attempt.

max: Duration

Maximum delay allowed after exponential growth and jitter.

jitter_percent: u8

Jitter percentage in the inclusive range from zero to one hundred.

reset_after: Duration

Stable runtime duration after which attempt counters may be reset.

jitter_mode: JitterMode

Jitter mode used by the calculation.

Implementations

impl BackoffPolicy

pub fn new( initial: Duration, max: Duration, jitter_percent: u8, reset_after: Duration, ) -> Self

Creates an exponential backoff policy.

Arguments

• initial: First restart delay.
• max: Maximum restart delay.
• jitter_percent: Jitter percentage capped at one hundred.
• reset_after: Runtime duration after which counters may reset.

Returns

Returns a BackoffPolicy with jitter disabled.

Examples

use std::time::Duration;

let policy = rust_supervisor::policy::backoff::BackoffPolicy::new(
    Duration::from_millis(10),
    Duration::from_millis(100),
    0,
    Duration::from_secs(1),
);
assert_eq!(policy.delay_for_attempt(1), Duration::from_millis(10));

Examples found in repository

examples/policy_failure_matrix.rs (lines 16-26)

fn main() {
    // Build the reusable backoff policy.
    let backoff = BackoffPolicy::new(
        // Set the initial delay.
        Duration::from_millis(100),
        // Set the maximum delay.
        Duration::from_secs(5),
        // Set jitter percent.
        10,
        // Set the reset window.
        Duration::from_secs(60),
        // Finish the reusable backoff policy.
    )
    // Enable deterministic jitter for repeatable output.
    .with_deterministic_jitter(42);
    // Create the stateless policy engine.
    let engine = PolicyEngine::new();

    // Iterate over policy and exit combinations.
    for (policy, exit) in [
        // Include a permanent policy after success.
        (RestartPolicy::Permanent, TaskExit::Succeeded),
        // Include a transient external dependency failure.
        (
            // Select transient restart behavior.
            RestartPolicy::Transient,
            // Build an external dependency failure exit.
            TaskExit::Failed {
                // Set the failure category.
                kind: PolicyFailureKind::ExternalDependency,
                // Finish the failure exit.
            },
            // Finish the policy and exit pair.
        ),
        // Include a transient fatal bug failure.
        (
            // Select transient restart behavior.
            RestartPolicy::Transient,
            // Build a fatal bug failure exit.
            TaskExit::Failed {
                // Set the failure category.
                kind: PolicyFailureKind::FatalBug,
                // Finish the failure exit.
            },
            // Finish the policy and exit pair.
        ),
        // Include a temporary panic failure.
        (
            // Select temporary restart behavior.
            RestartPolicy::Temporary,
            // Build a panic failure exit.
            TaskExit::Failed {
                // Set the failure category.
                kind: PolicyFailureKind::Panic,
                // Finish the failure exit.
            },
            // Finish the policy and exit pair.
        ),
        // Finish the decision matrix.
    ] {
        // Calculate the restart decision.
        let decision = engine.decide(policy, exit, 3, &backoff);
        // Print the policy decision row.
        println!("policy={policy:?} exit={exit:?} decision={decision:?}");
        // Finish the matrix loop.
    }

    // Build the meltdown fuse policy.
    let policy = MeltdownPolicy::new(
        // Set the child restart limit.
        2,
        // Set the child restart window.
        Duration::from_secs(60),
        // Set the supervisor failure limit.
        5,
        // Set the supervisor failure window.
        Duration::from_secs(60),
        // Set the stable reset window.
        Duration::from_secs(300),
        // Finish the meltdown policy construction.
    );
    // Create the mutable meltdown tracker.
    let mut tracker = MeltdownTracker::new(policy);
    // Capture the current monotonic instant.
    let now = Instant::now();

    // Iterate over restart offsets.
    for offset_ms in [0, 10, 20] {
        // Record a child restart at the offset instant.
        let outcome = tracker.record_child_restart(now + Duration::from_millis(offset_ms));
        // Print the fuse state after the restart.
        println!(
            // Provide the output template.
            "restart_at_ms={offset_ms} child_failures={} outcome={outcome:?}",
            // Include the current child failure count.
            tracker.child_failure_count(),
            // Finish printing the fuse state.
        );
        // Finish the fuse loop.
    }
    // End the policy failure matrix example.
}

pub fn with_deterministic_jitter(self, seed: u64) -> Self

Returns this policy with deterministic jitter enabled.

Arguments

• seed: Stable seed used to derive jitter.

Returns

Returns a new BackoffPolicy that keeps the same timing bounds.

Examples found in repository

examples/policy_failure_matrix.rs (line 28)

fn main() {
    // Build the reusable backoff policy.
    let backoff = BackoffPolicy::new(
        // Set the initial delay.
        Duration::from_millis(100),
        // Set the maximum delay.
        Duration::from_secs(5),
        // Set jitter percent.
        10,
        // Set the reset window.
        Duration::from_secs(60),
        // Finish the reusable backoff policy.
    )
    // Enable deterministic jitter for repeatable output.
    .with_deterministic_jitter(42);
    // Create the stateless policy engine.
    let engine = PolicyEngine::new();

    // Iterate over policy and exit combinations.
    for (policy, exit) in [
        // Include a permanent policy after success.
        (RestartPolicy::Permanent, TaskExit::Succeeded),
        // Include a transient external dependency failure.
        (
            // Select transient restart behavior.
            RestartPolicy::Transient,
            // Build an external dependency failure exit.
            TaskExit::Failed {
                // Set the failure category.
                kind: PolicyFailureKind::ExternalDependency,
                // Finish the failure exit.
            },
            // Finish the policy and exit pair.
        ),
        // Include a transient fatal bug failure.
        (
            // Select transient restart behavior.
            RestartPolicy::Transient,
            // Build a fatal bug failure exit.
            TaskExit::Failed {
                // Set the failure category.
                kind: PolicyFailureKind::FatalBug,
                // Finish the failure exit.
            },
            // Finish the policy and exit pair.
        ),
        // Include a temporary panic failure.
        (
            // Select temporary restart behavior.
            RestartPolicy::Temporary,
            // Build a panic failure exit.
            TaskExit::Failed {
                // Set the failure category.
                kind: PolicyFailureKind::Panic,
                // Finish the failure exit.
            },
            // Finish the policy and exit pair.
        ),
        // Finish the decision matrix.
    ] {
        // Calculate the restart decision.
        let decision = engine.decide(policy, exit, 3, &backoff);
        // Print the policy decision row.
        println!("policy={policy:?} exit={exit:?} decision={decision:?}");
        // Finish the matrix loop.
    }

    // Build the meltdown fuse policy.
    let policy = MeltdownPolicy::new(
        // Set the child restart limit.
        2,
        // Set the child restart window.
        Duration::from_secs(60),
        // Set the supervisor failure limit.
        5,
        // Set the supervisor failure window.
        Duration::from_secs(60),
        // Set the stable reset window.
        Duration::from_secs(300),
        // Finish the meltdown policy construction.
    );
    // Create the mutable meltdown tracker.
    let mut tracker = MeltdownTracker::new(policy);
    // Capture the current monotonic instant.
    let now = Instant::now();

    // Iterate over restart offsets.
    for offset_ms in [0, 10, 20] {
        // Record a child restart at the offset instant.
        let outcome = tracker.record_child_restart(now + Duration::from_millis(offset_ms));
        // Print the fuse state after the restart.
        println!(
            // Provide the output template.
            "restart_at_ms={offset_ms} child_failures={} outcome={outcome:?}",
            // Include the current child failure count.
            tracker.child_failure_count(),
            // Finish printing the fuse state.
        );
        // Finish the fuse loop.
    }
    // End the policy failure matrix example.
}

pub fn delay_for_attempt(&self, attempt: u64) -> Duration

Calculates a restart delay for a one-based attempt number.

Arguments

• attempt: One-based restart attempt. Zero is treated as one.

Returns

Returns a delay capped by BackoffPolicy::max.

pub fn should_reset(&self, stable_for: Duration) -> bool

Reports whether a stable runtime duration should reset counters.

Arguments

• stable_for: Duration for which the child has run without failure.

Returns

Returns true when stable_for reaches BackoffPolicy::reset_after.

Trait Implementations

impl Clone for BackoffPolicy

fn clone(&self) -> BackoffPolicy

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BackoffPolicy

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for BackoffPolicy

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for BackoffPolicy

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for BackoffPolicy

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for BackoffPolicy

impl Eq for BackoffPolicy

impl StructuralPartialEq for BackoffPolicy