Struct TimeoutConfig 

pub struct TimeoutConfig {
    pub default_timeout_ms: u64,
    pub connection_timeout_ms: u64,
    pub read_timeout_ms: u64,
    pub write_timeout_ms: u64,
    pub idle_timeout_ms: u64,
    pub keepalive_interval_ms: u64,
}

Timeout configuration for operations

Examples

Using the default configuration:

use chie_shared::TimeoutConfig;

let config = TimeoutConfig::default();
assert_eq!(config.default_timeout_ms, 30_000);
assert_eq!(config.connection_timeout_ms, 10_000);
assert!(config.keepalive_enabled());
assert!(config.idle_timeout_enabled());
assert!(config.validate().is_ok());

Using preset configurations for different scenarios:

use chie_shared::TimeoutConfig;

// Fast configuration for low-latency operations
let fast_config = TimeoutConfig::fast();
assert_eq!(fast_config.default_timeout_ms, 5_000);
assert_eq!(fast_config.connection_timeout_ms, 3_000);

// Slow configuration for batch/background operations
let slow_config = TimeoutConfig::slow();
assert_eq!(slow_config.default_timeout_ms, 120_000);
assert_eq!(slow_config.read_timeout_ms, 300_000);

Building a custom configuration:

use chie_shared::TimeoutConfigBuilder;

let config = TimeoutConfigBuilder::new()
    .default_timeout_ms(45_000)
    .connection_timeout_ms(15_000)
    .read_timeout_ms(90_000)
    .write_timeout_ms(90_000)
    .idle_timeout_ms(0)  // Disable idle timeout
    .keepalive_interval_ms(30_000)
    .build();

assert_eq!(config.default_timeout_ms, 45_000);
assert!(!config.idle_timeout_enabled());
assert!(config.keepalive_enabled());

Fields

default_timeout_ms: u64

Default operation timeout in milliseconds

connection_timeout_ms: u64

Connection timeout in milliseconds

read_timeout_ms: u64

Read timeout in milliseconds

write_timeout_ms: u64

Write timeout in milliseconds

idle_timeout_ms: u64

Idle timeout in milliseconds (0 = no timeout)

keepalive_interval_ms: u64

Keepalive interval in milliseconds (0 = disabled)

Implementations

impl TimeoutConfig

pub const fn fast() -> Self

Create a new configuration for fast operations

pub const fn slow() -> Self

Create a new configuration for slow operations

pub const fn keepalive_enabled(&self) -> bool

Check if keepalive is enabled

pub const fn idle_timeout_enabled(&self) -> bool

Check if idle timeout is enabled

pub fn validate(&self) -> ChieResult<()>

Validate the timeout configuration

Errors

Returns error if configuration is invalid

Trait Implementations

impl Clone for TimeoutConfig

fn clone(&self) -> TimeoutConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TimeoutConfig

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

Formats the value using the given formatter.

impl Default for TimeoutConfig

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for TimeoutConfig

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for TimeoutConfig

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

where __S: Serializer,

Serialize this value into the given Serde serializer.