Struct PolicyEngine 

pub struct PolicyEngine;

Stateless restart policy engine.

Implementations

impl PolicyEngine

pub fn new() -> Self

Creates a policy engine.

Arguments

This function has no arguments.

Returns

Returns a PolicyEngine.

Examples

let engine = rust_supervisor::policy::decision::PolicyEngine::new();
let _ = engine;

Examples found in repository

examples/policy_failure_matrix.rs (line 30)

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 decide( &self, policy: RestartPolicy, exit: TaskExit, attempt: u64, backoff: &BackoffPolicy, ) -> RestartDecision

Decides the restart action for a typed exit.

Arguments

• policy: Restart policy configured for the child.
• exit: Typed task exit.
• attempt: One-based restart attempt used for backoff.
• backoff: Backoff policy used when a restart is allowed.

Returns

Returns a RestartDecision that the runtime can execute.

Examples found in repository

examples/policy_failure_matrix.rs (line 75)

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.
}

Trait Implementations

impl Clone for PolicyEngine

fn clone(&self) -> PolicyEngine

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PolicyEngine

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

Formats the value using the given formatter.

impl Default for PolicyEngine

fn default() -> PolicyEngine

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for PolicyEngine

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for PolicyEngine

fn eq(&self, other: &PolicyEngine) -> 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 PolicyEngine

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 PolicyEngine

impl Eq for PolicyEngine

impl StructuralPartialEq for PolicyEngine