Struct DistributedLockConfig 

pub struct DistributedLockConfig {
    pub enabled: bool,
    pub ttl: Duration,
    pub refresh_interval: Duration,
    pub retry_interval: Duration,
}

Configuration for distributed locking in multi-instance deployments.

Distributed locking ensures that only one pipeline instance processes events for a given collection at any time, preventing duplicate processing.

How It Works

• Each collection is protected by a distributed lock (stored in Redis)
• Only the instance holding the lock processes events for that collection
• If an instance crashes, its locks expire after TTL
• Other instances automatically take over expired locks

Example

use rigatoni_core::pipeline::DistributedLockConfig;
use std::time::Duration;

let lock_config = DistributedLockConfig {
    enabled: true,
    ttl: Duration::from_secs(30),
    refresh_interval: Duration::from_secs(10),
    retry_interval: Duration::from_secs(5),
};

Fields

enabled: bool

Enable distributed locking (requires StateStore with lock support).

When enabled (default), the pipeline will acquire locks before starting workers. This is required for multi-instance deployments to prevent duplicate event processing.

Disable only for:

• Single-instance deployments
• Development/testing scenarios
• When using a StateStore without lock support

ttl: Duration

Lock time-to-live (expiry time).

If an instance crashes without releasing its locks, the locks will expire after this duration, allowing other instances to take over.

Tradeoff:

• Short TTL (10s): Fast failover, but needs frequent refresh
• Long TTL (60s): Less refresh overhead, but slow failover

Recommended: 30 seconds (default)

refresh_interval: Duration

How often to refresh the lock (heartbeat interval).

The lock owner must refresh the lock periodically to prevent expiry. This interval should be significantly less than the TTL.

Rule of thumb: refresh_interval < ttl / 2

Recommended: TTL / 3 (e.g., 10s for 30s TTL) (default)

retry_interval: Duration

How long to wait before retrying lock acquisition.

If a lock is held by another instance, this instance will wait this duration before attempting to acquire the lock again.

Recommended: 5-10 seconds (default: 5s)

Implementations

impl DistributedLockConfig

pub fn builder() -> DistributedLockConfigBuilder

Creates a new builder for DistributedLockConfig.

pub fn disabled() -> Self

Creates a disabled lock configuration.

Use this for single-instance deployments where locking is not needed.

Trait Implementations

impl Clone for DistributedLockConfig

fn clone(&self) -> DistributedLockConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DistributedLockConfig

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

Formats the value using the given formatter.

impl Default for DistributedLockConfig

fn default() -> Self

Returns the “default value” for a type.