Struct StorageSynchronizer 

pub struct StorageSynchronizer<T, R> {
    pub turso: Arc<T>,
    pub redb: Arc<R>,
    /* private fields */
}

Storage synchronizer for coordinating Turso and redb

Fields

turso: Arc<T>

Source storage (typically Turso - durable)

redb: Arc<R>

Cache storage (typically redb - fast)

Implementations

impl<T, R> StorageSynchronizer<T, R>

pub fn new(turso: Arc<T>, redb: Arc<R>) -> Self

Create a new storage synchronizer

pub async fn get_sync_state(&self) -> SyncState

Get the current synchronization state

impl<T, R> StorageSynchronizer<T, R>

where T: StorageBackend + 'static, R: StorageBackend + 'static,

pub async fn sync_episode_to_cache(&self, episode_id: Uuid) -> Result<()>

Sync a single episode from Turso (source) to redb (cache)

Fetches the episode from the source storage and stores it in the cache storage.

Arguments

• episode_id - UUID of the episode to sync

Errors

Returns error if episode not found or storage operation fails

pub async fn sync_all_recent_episodes( &self, since: DateTime<Utc>, ) -> Result<SyncStats>

Sync all episodes modified since a given timestamp

Queries the source storage for recent episodes and syncs them to the cache.

Arguments

• since - Only sync episodes with start_time >= this timestamp

Returns

Statistics about the sync operation (episodes synced, errors)

Errors

Returns error if query fails, but continues syncing other episodes if individual stores fail

pub fn start_periodic_sync( self: Arc<Self>, interval: Duration, ) -> JoinHandle<()>

Start a periodic background sync task

Spawns a background task that syncs recent episodes at the specified interval. The task will continue running until the returned JoinHandle is dropped or aborted.

Arguments

• interval - How often to run the sync

Returns

JoinHandle that can be used to cancel the background task

Example

use std::time::Duration;
use std::sync::Arc;

let sync = Arc::new(StorageSynchronizer::new(turso, redb));
let handle = sync.start_periodic_sync(Duration::from_secs(300));

// Later, to stop the sync:
handle.abort();