Struct CheckpointCoordinator 

pub struct CheckpointCoordinator<B: StateBackend> { /* private fields */ }

Checkpoint coordinator

Manages periodic checkpoint creation and restoration for a state backend.

Features

• Periodic checkpoints: Automatically creates checkpoints at regular intervals
• Retention policy: Keeps only the N most recent checkpoints
• Graceful shutdown: Ensures final checkpoint on shutdown
• Recovery: Can restore from the latest valid checkpoint

Example

use processor::state::{
    CheckpointCoordinator, CheckpointOptions, MemoryStateBackend
};
use std::sync::Arc;
use std::time::Duration;
use std::path::PathBuf;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let backend = Arc::new(MemoryStateBackend::new(None));

    let options = CheckpointOptions {
        checkpoint_dir: PathBuf::from("/var/lib/optimizer/checkpoints"),
        max_checkpoints: 10,
        compress: true,
        min_interval: Duration::from_secs(300),
    };

    let coordinator = CheckpointCoordinator::new(
        backend.clone(),
        Duration::from_secs(300),
        options,
    );

    // Start periodic checkpointing
    coordinator.start().await?;

    // Work with state...

    // Shutdown with final checkpoint
    coordinator.shutdown().await?;

    Ok(())
}

Implementations

impl<B: StateBackend + 'static> CheckpointCoordinator<B>

pub fn new( backend: Arc<B>, interval: Duration, options: CheckpointOptions, ) -> Self

Create a new checkpoint coordinator

Arguments

• backend - The state backend to checkpoint
• interval - How often to create checkpoints
• options - Checkpoint configuration options

Returns

A new coordinator instance

pub async fn start(&self) -> StateResult<()>

Start periodic checkpointing

Spawns a background task that creates checkpoints at the configured interval.

Returns

• Ok(()) - Checkpointing started
• Err(StateError) - Failed to start

pub async fn create_checkpoint(&self) -> StateResult<String>

Create a checkpoint immediately

Returns

• Ok(checkpoint_id) - Checkpoint created successfully
• Err(StateError) - Checkpoint failed

pub async fn restore_latest(&self) -> StateResult<String>

Restore from the latest checkpoint

Returns

• Ok(checkpoint_id) - Successfully restored
• Err(StateError) - No checkpoint found or restore failed

pub async fn stats(&self) -> CheckpointStats

Get checkpoint statistics

Returns

Current checkpoint statistics

pub async fn shutdown(&self) -> StateResult<()>

Shutdown the coordinator

Stops the background task and creates a final checkpoint.

Returns

• Ok(()) - Shutdown successful
• Err(StateError) - Shutdown failed