Struct LeaseConfig 

pub struct LeaseConfig {
    pub enabled: bool,
    pub cleanup_interval_ms: u64,
    pub max_cleanup_duration_ms: u64,
}

Lease configuration for TTL-based key expiration

When enabled = true:

• Server initializes lease manager at startup
• Background worker periodically cleans expired keys
• Client TTL requests (ttl_secs > 0) are accepted

When enabled = false (default):

• No lease components initialized (zero overhead)
• Client TTL requests (ttl_secs > 0) are rejected with error
• All keys are permanent (ttl_secs = 0 is always allowed)

Performance

Background cleanup overhead: ~0.001% CPU

• Wakes up every cleanup_interval_ms (default 1000ms)
• Scans expired keys (limited by max_cleanup_duration_ms)
• Deletes expired entries from storage

Examples

use d_engine_core::config::LeaseConfig;

// Default: disabled
let config = LeaseConfig::default();
assert!(!config.enabled);

// Enable with defaults
let config = LeaseConfig {
    enabled: true,
    ..Default::default()
};
assert_eq!(config.cleanup_interval_ms, 1000);

Fields

enabled: bool

Enable TTL feature

• true: Initialize lease manager + start background cleanup worker
• false: No TTL support, reject requests with ttl_secs > 0

Default: false (zero overhead when TTL not needed)

cleanup_interval_ms: u64

How often the background worker wakes up to scan and delete expired keys (milliseconds).

This setting controls MEMORY EFFICIENCY only, not TTL correctness. Expired keys are always rejected at read time via is_expired() regardless of cleanup timing. Cleanup only reclaims the memory occupied by stale DashMap entries.

Range: 100–60000 (100ms to 60 seconds) Default: 1000 (1 second)

Upper bound rationale: at 60s, a workload of 10K TTL writes/s with TTL=1s accumulates ~600K stale entries (~30MB) between cleanups — acceptable for most deployments. Beyond 60s, memory growth becomes unbounded in high-throughput short-TTL workloads.

Tuning guide:

• 1000ms (default): Good for most workloads
• 100-500ms: High-throughput short-TTL workloads (e.g., rate limiting, sessions)
• 5000-60000ms: Low-frequency TTL usage where memory pressure is not a concern

Only used when enabled = true

max_cleanup_duration_ms: u64

Maximum cleanup duration per cycle (milliseconds)

Limits how long a single cleanup cycle can run to prevent excessive CPU usage in the background worker.

Range: 1-100ms Default: 1ms

Tuning guide:

• 1ms (default): Safe for latency-sensitive apps
• 5-10ms: Aggressive cleanup when backlog exists

• 10ms: Not recommended (can impact foreground operations)

Only used when enabled = true

Implementations

impl LeaseConfig

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

Validates configuration parameters

Returns error if:

• cleanup_interval_ms is out of range (100-60000)
• max_cleanup_duration_ms is out of range (1-100)

Trait Implementations

impl Clone for LeaseConfig

fn clone(&self) -> LeaseConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LeaseConfig

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

Formats the value using the given formatter.

impl Default for LeaseConfig

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for LeaseConfig

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for LeaseConfig

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

where __S: Serializer,

Serialize this value into the given Serde serializer.