execution-policy 0.0.1

Closure-first, runtime-light reliability policies (retry, timeout, circuit breaking, bounded concurrency, retry budgets) for any async Rust operation.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

//! The hero type: a reusable, cheaply-cloneable reliability policy.

use std::sync::Arc;

use crate::attempt::Attempt;
use crate::builder::ExecutionPolicyBuilder;
use crate::core::Core;
use crate::engine::run_pipeline;
use crate::error::ExecutionError;
use crate::plan::Plan;

/// A reusable reliability policy. Cheap to clone (shares a compiled `Plan`).
pub struct ExecutionPolicy<C, T, E> {
    core: C,
    plan: Arc<Plan<T, E>>,
}

impl<C: std::fmt::Debug, T, E> std::fmt::Debug for ExecutionPolicy<C, T, E> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("ExecutionPolicy")
            .field("core", &self.core)
            .field("plan", &self.plan)
            .finish()
    }
}

impl<C: Clone, T, E> Clone for ExecutionPolicy<C, T, E> {
    fn clone(&self) -> Self {
        Self {
            core: self.core.clone(),
            plan: Arc::clone(&self.plan),
        }
    }
}

impl ExecutionPolicy<(), (), ()> {
    /// Start configuring a policy. The `T`/`E` types are inferred at the first
    /// `retry(..)` or execute call site.
    pub fn builder<T, E>() -> ExecutionPolicyBuilder<T, E> {
        ExecutionPolicyBuilder::new()
    }
}

impl<C, T, E> ExecutionPolicy<C, T, E> {
    pub(crate) fn from_parts(core: C, plan: Arc<Plan<T, E>>) -> Self {
        Self { core, plan }
    }

    /// Current circuit-breaker state, or `None` if no breaker is configured.
    pub fn circuit_state(&self) -> Option<crate::error::BreakerState> {
        self.plan.breaker.as_ref().map(|b| b.runtime.state())
    }
}

impl<C, T, E> ExecutionPolicy<C, T, E>
where
    C: Core,
{
    /// Run an operation that needs neither application state nor attempt metadata.
    pub async fn run<F>(&self, mut op: F) -> Result<T, ExecutionError<E>>
    where
        F: AsyncFnMut() -> Result<T, E>,
    {
        run_pipeline(
            &self.core,
            &self.plan,
            async move |_attempt: Attempt<'_>| op().await,
        )
        .await
    }

    /// Run an operation that wants attempt metadata.
    pub async fn execute<F>(&self, op: F) -> Result<T, ExecutionError<E>>
    where
        F: AsyncFnMut(Attempt<'_>) -> Result<T, E>,
    {
        run_pipeline(&self.core, &self.plan, op).await
    }

    /// Run an operation with injected application state.
    pub async fn run_with<S, F>(&self, state: &S, mut op: F) -> Result<T, ExecutionError<E>>
    where
        S: Sync + ?Sized,
        F: AsyncFnMut(&S) -> Result<T, E>,
    {
        run_pipeline(
            &self.core,
            &self.plan,
            async move |_attempt: Attempt<'_>| op(state).await,
        )
        .await
    }

    /// Run an operation with injected state and attempt metadata.
    pub async fn execute_with<S, F>(&self, state: &S, mut op: F) -> Result<T, ExecutionError<E>>
    where
        S: Sync + ?Sized,
        F: AsyncFnMut(&S, Attempt<'_>) -> Result<T, E>,
    {
        run_pipeline(&self.core, &self.plan, async move |attempt: Attempt<'_>| {
            op(state, attempt).await
        })
        .await
    }
}