Struct SimpleRetryConfig 

pub struct SimpleRetryConfig { /* private fields */ }

Simple retry configuration implementation

This is the simplest RetryConfig implementation, with all configuration fields stored directly in the struct, without depending on an external configuration system. Suitable for scenarios requiring direct control over all configurations.

Features

• Simple and Direct: All fields stored directly, no configuration system needed
• Type Safe: Use Rust’s type system to ensure correct configuration
• High Performance: No configuration queries, direct field access
• Easy to Understand: Clear structure, simple code

Example

use prism3_retry::{SimpleRetryConfig, RetryConfig, RetryDelayStrategy};
use std::time::Duration;

let mut config = SimpleRetryConfig::new();
config
    .set_max_attempts(3)
    .set_max_duration(Some(Duration::from_secs(30)))
    .set_fixed_delay_strategy(Duration::from_secs(1));

assert_eq!(config.max_attempts(), 3);
assert_eq!(config.max_duration(), Some(Duration::from_secs(30)));

Author

Haixing Hu

Implementations

impl SimpleRetryConfig

pub fn new() -> Self

Create a new SimpleRetryConfig instance with default configuration

Returns

Returns a new SimpleRetryConfig instance with default configuration

Example

use prism3_retry::{SimpleRetryConfig, RetryConfig};

let config = SimpleRetryConfig::new();
assert_eq!(config.max_attempts(), 5);

pub fn with_params( max_attempts: u32, delay_strategy: RetryDelayStrategy, jitter_factor: f64, max_duration: Option<Duration>, operation_timeout: Option<Duration>, ) -> Self

Create a new SimpleRetryConfig instance with specified parameters

Parameters

• max_attempts - Maximum number of attempts
• delay_strategy - Delay strategy
• jitter_factor - Jitter factor
• max_duration - Maximum duration
• operation_timeout - Single operation timeout

Returns

Returns a new SimpleRetryConfig instance with the specified parameters

Example

use prism3_retry::{SimpleRetryConfig, RetryDelayStrategy};
use std::time::Duration;

let config = SimpleRetryConfig::with_params(
    3,
    RetryDelayStrategy::fixed(Duration::from_secs(1)),
    0.1,
    Some(Duration::from_secs(30)),
    Some(Duration::from_secs(5)),
);

Trait Implementations

impl Clone for SimpleRetryConfig

fn clone(&self) -> SimpleRetryConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SimpleRetryConfig

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

Formats the value using the given formatter.

impl Default for SimpleRetryConfig

fn default() -> Self

Returns the “default value” for a type.

impl RetryConfig for SimpleRetryConfig

fn max_attempts(&self) -> u32

Get maximum number of attempts

fn set_max_attempts(&mut self, max_attempts: u32) -> &mut Self

Set maximum number of attempts

fn max_duration(&self) -> Option<Duration>

Get maximum duration for retry execution

fn set_max_duration(&mut self, max_duration: Option<Duration>) -> &mut Self

Set maximum duration for retry execution

fn operation_timeout(&self) -> Option<Duration>

Get single operation timeout

fn set_operation_timeout(&mut self, timeout: Option<Duration>) -> &mut Self

Set single operation timeout

fn delay_strategy(&self) -> RetryDelayStrategy

Get delay strategy type

fn set_delay_strategy( &mut self, delay_strategy: RetryDelayStrategy, ) -> &mut Self

Set delay strategy type

fn jitter_factor(&self) -> f64

Get jitter factor

fn set_jitter_factor(&mut self, jitter_factor: f64) -> &mut Self

Set jitter factor

const KEY_MAX_ATTEMPTS: &'static str = "retry.max_attempts"

Configuration key for maximum number of attempts

const KEY_DELAY_STRATEGY: &'static str = "retry.delay_strategy"

Configuration key for delay strategy

const KEY_FIXED_DELAY: &'static str = "retry.fixed_delay_millis"

Configuration key for fixed delay time

const KEY_RANDOM_MIN_DELAY: &'static str = "retry.random_min_delay_millis"

Configuration key for random delay minimum value

const KEY_RANDOM_MAX_DELAY: &'static str = "retry.random_max_delay_millis"

Configuration key for random delay maximum value

const KEY_BACKOFF_INITIAL_DELAY: &'static str = "retry.backoff_initial_delay_millis"

Configuration key for exponential backoff initial delay

const KEY_BACKOFF_MAX_DELAY: &'static str = "retry.backoff_max_delay_millis"

Configuration key for exponential backoff maximum delay

const KEY_BACKOFF_MULTIPLIER: &'static str = "retry.backoff_multiplier"

Configuration key for exponential backoff multiplier

const KEY_JITTER_FACTOR: &'static str = "retry.jitter_factor"

Configuration key for jitter factor

const KEY_MAX_DURATION: &'static str = "retry.max_duration_millis"

Configuration key for maximum duration of retry execution

const KEY_OPERATION_TIMEOUT: &'static str = "retry.operation_timeout_millis"

Configuration key for single operation timeout

const DEFAULT_MAX_ATTEMPTS: u32 = 5u32

Default maximum number of attempts for retry mechanism

const DEFAULT_DELAY_STRATEGY: RetryDelayStrategy = _

Default delay strategy

const DEFAULT_FIXED_DELAY_MILLIS: u64 = 1_000u64

Default fixed delay time in milliseconds

const DEFAULT_RANDOM_MIN_DELAY_MILLIS: u64 = 1_000u64

Default random delay minimum value in milliseconds

const DEFAULT_RANDOM_MAX_DELAY_MILLIS: u64 = 10_000u64

Default random delay maximum value in milliseconds

const DEFAULT_BACKOFF_INITIAL_DELAY_MILLIS: u64 = 1_000u64

Default exponential backoff initial delay in milliseconds

const DEFAULT_BACKOFF_MAX_DELAY_MILLIS: u64 = 60_000u64

Default exponential backoff maximum delay in milliseconds

const DEFAULT_BACKOFF_MULTIPLIER: f64 = 2f64

Default exponential backoff multiplier

const DEFAULT_JITTER_FACTOR: f64 = 0f64

Default value for jitter factor

const DEFAULT_MAX_DURATION_MILLIS: u64 = 0u64

Default maximum duration for retry execution in milliseconds, 0 means unlimited

const DEFAULT_OPERATION_TIMEOUT_MILLIS: u64 = 0u64

Default value for single operation timeout in milliseconds, 0 means unlimited

fn set_random_delay_strategy( &mut self, min_delay: Duration, max_delay: Duration, ) -> &mut Self

Set random delay range

fn set_fixed_delay_strategy(&mut self, delay: Duration) -> &mut Self

Set fixed delay

fn set_exponential_backoff_strategy( &mut self, initial_delay: Duration, max_delay: Duration, multiplier: f64, ) -> &mut Self

Set exponential backoff strategy parameters

fn set_no_delay_strategy(&mut self) -> &mut Self

Set no delay strategy

fn set_unlimited_duration(&mut self) -> &mut Self

Set unlimited duration

fn set_unlimited_operation_timeout(&mut self) -> &mut Self

Set unlimited operation timeout