Struct SledStateBackend 

pub struct SledStateBackend { /* private fields */ }

Sled-based persistent state backend

This backend uses the Sled embedded database for persistent state storage. It’s designed for production use where state must survive process restarts.

Features

• Persistent: State survives restarts
• ACID: Atomic operations with durability guarantees
• Efficient: Lock-free data structures and zero-copy operations
• Compression: Optional compression to save disk space
• Crash recovery: Automatic recovery from crashes

Example

use processor::state::{SledStateBackend, SledConfig, StateBackend};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Create configuration with best compression
    let config = SledConfig::new("/var/lib/optimizer/state")
        .with_cache_capacity(256 * 1024 * 1024) // 256MB
        .with_best_compression(); // Use Zstd for maximum compression

    // Open database
    let backend = SledStateBackend::open(config).await?;

    // Use like any other backend
    backend.put(b"window:123", b"aggregated_data").await?;

    // Data persists across restarts
    backend.flush().await?;

    Ok(())
}

Implementations

impl SledStateBackend

pub async fn open(config: SledConfig) -> StateResult<Self>

Open a Sled database with the given configuration

Arguments

• config - Database configuration

Returns

• Ok(SledStateBackend) - Successfully opened database
• Err(StateError) - Failed to open database

Example

let config = SledConfig::new("/tmp/test_db");
let backend = SledStateBackend::open(config).await?;

pub async fn temporary() -> StateResult<Self>

Create a temporary Sled backend for testing

This creates a database in a temporary directory that will be cleaned up when the backend is dropped.

Returns

A new temporary Sled backend

Example

let backend = SledStateBackend::temporary().await?;
// Use for testing...

pub async fn flush(&self) -> StateResult<usize>

Flush all pending writes to disk

This ensures that all writes are persisted to disk. It’s called automatically after every N operations (configured by flush_every), but can also be called manually for critical checkpoints.

Returns

• Ok(usize) - Number of bytes flushed
• Err(StateError) - Flush failed

Example

backend.put(b"important", b"data").await?;
let flushed = backend.flush().await?;
println!("Flushed {} bytes", flushed);

pub async fn stats(&self) -> SledBackendStats

Get database statistics

Returns

Current backend statistics

pub async fn compression_ratio(&self) -> Option<f64>

Get compression ratio as a percentage

Returns

Compression ratio (0.0-100.0), or None if no data has been compressed yet

Example

A ratio of 30.0 means compressed data is 30% of the original size

pub async fn space_saved(&self) -> u64

Get total space saved by compression in bytes

Returns

Number of bytes saved by compression

pub async fn size_on_disk(&self) -> StateResult<u64>

Get the size of the database on disk in bytes

Returns

Database size in bytes

pub async fn checkpoint(&self) -> StateResult<Vec<(Vec<u8>, Vec<u8>)>>

Create a checkpoint of the current database state

This exports all key-value pairs for backup or migration.

Returns

Vector of (key, value) pairs

pub async fn restore( &self, checkpoint: Vec<(Vec<u8>, Vec<u8>)>, ) -> StateResult<()>

Restore from a checkpoint

This clears the current database and restores from the provided checkpoint.

Arguments

• checkpoint - Vector of (key, value) pairs to restore

Returns

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

Trait Implementations

impl Drop for SledStateBackend

fn drop(&mut self)

Executes the destructor for this type.

impl StateBackend for SledStateBackend

fn get<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 [u8], ) -> Pin<Box<dyn Future<Output = StateResult<Option<Vec<u8>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieve a value for the given key

fn put<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, key: &'life1 [u8], value: &'life2 [u8], ) -> Pin<Box<dyn Future<Output = StateResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Store a value for the given key

fn delete<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 [u8], ) -> Pin<Box<dyn Future<Output = StateResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete a key and its associated value

fn list_keys<'life0, 'life1, 'async_trait>( &'life0 self, prefix: &'life1 [u8], ) -> Pin<Box<dyn Future<Output = StateResult<Vec<Vec<u8>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List all keys with the given prefix

fn clear<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = StateResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Clear all state from the backend

fn count<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = StateResult<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get the number of keys in the backend

fn contains<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 [u8], ) -> Pin<Box<dyn Future<Output = StateResult<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Check if a key exists