execution_policy/lib.rs
1//! `execution-policy` — closure-first reliability policies for any async operation.
2//!
3//! Wrap any async operation with retry, backoff, jitter, and per-attempt / total
4//! timeouts (circuit breaking, bounded concurrency, and retry budgets build on
5//! this foundation). The operation is a **factory** — re-invoked per attempt — so
6//! requests are freshly constructed and never need `Clone`, and `!Send`
7//! operations are accepted.
8//!
9//! ```
10//! # #[cfg(feature = "tokio")]
11//! # {
12//! use std::time::Duration;
13//! use execution_policy::{ExecutionPolicyBuilder, Retry};
14//!
15//! # #[tokio::main(flavor = "current_thread")]
16//! # async fn main() {
17//! let policy = ExecutionPolicyBuilder::<u32, &str>::new()
18//! .retry(Retry::exponential().max_attempts(3))
19//! .attempt_timeout(Duration::from_secs(2))
20//! .build();
21//!
22//! let value = policy.run(async || Ok::<_, &str>(7u32)).await.unwrap();
23//! assert_eq!(value, 7);
24//! # }
25//! # }
26//! ```
27
28#![forbid(unsafe_code)]
29
30pub mod attempt;
31pub mod breaker;
32pub mod builder;
33pub mod classify;
34pub mod concurrency;
35pub mod core;
36pub mod error;
37pub mod event;
38pub mod policy;
39pub mod retry;
40
41pub(crate) mod engine;
42pub(crate) mod plan;
43
44pub use crate::attempt::Attempt;
45pub use crate::breaker::CircuitBreaker;
46pub use crate::builder::{BuildError, ExecutionPolicyBuilder};
47pub use crate::classify::{FailureClass, RetryDecision};
48pub use crate::concurrency::{ConcurrencyLimit, SaturationPolicy};
49#[cfg(feature = "tokio")]
50pub use crate::core::DefaultCore;
51pub use crate::core::{BoxFuture, Core};
52pub use crate::error::{BreakerState, ErrorContext, ExecutionError};
53pub use crate::event::Event;
54pub use crate::policy::ExecutionPolicy;
55pub use crate::retry::{Backoff, Jitter, Retry, RetryBudget};