Struct Waker 

pub struct Waker { /* private fields */ }

Periodic task that wakes Sleeping runs whose scheduled_at has passed.

Examples

use std::sync::Arc;
use std::time::Duration;
use ironflow_api::waker::Waker;
use ironflow_core::providers::claude::ClaudeCodeProvider;
use ironflow_engine::engine::Engine;
use ironflow_store::memory::InMemoryStore;
use ironflow_store::store::Store;
use tokio_util::sync::CancellationToken;

let store: Arc<dyn Store> = Arc::new(InMemoryStore::new());
let engine = Arc::new(Engine::new(store, Arc::new(ClaudeCodeProvider::new())));

let waker = Waker::new(engine).interval(Duration::from_secs(5));
tokio::spawn(waker.run(CancellationToken::new()));

Implementations

impl Waker

pub fn new(engine: Arc<Engine>) -> Self

Create a waker with the default interval and batch size.

Examples

use std::sync::Arc;
use ironflow_api::waker::Waker;
use ironflow_core::providers::claude::ClaudeCodeProvider;
use ironflow_engine::engine::Engine;
use ironflow_store::memory::InMemoryStore;
use ironflow_store::store::Store;

let store: Arc<dyn Store> = Arc::new(InMemoryStore::new());
let engine = Arc::new(Engine::new(store, Arc::new(ClaudeCodeProvider::new())));
let waker = Waker::new(engine);

pub fn interval(self, interval: Duration) -> Self

Set how often due runs are collected.

Examples

use std::sync::Arc;
use std::time::Duration;
use ironflow_api::waker::Waker;
use ironflow_core::providers::claude::ClaudeCodeProvider;
use ironflow_engine::engine::Engine;
use ironflow_store::memory::InMemoryStore;
use ironflow_store::store::Store;

let store: Arc<dyn Store> = Arc::new(InMemoryStore::new());
let engine = Arc::new(Engine::new(store, Arc::new(ClaudeCodeProvider::new())));
let waker = Waker::new(engine).interval(Duration::from_secs(5));

pub fn batch_size(self, batch_size: u32) -> Self

Set how many runs a single tick wakes.

Examples

use std::sync::Arc;
use ironflow_api::waker::Waker;
use ironflow_core::providers::claude::ClaudeCodeProvider;
use ironflow_engine::engine::Engine;
use ironflow_store::memory::InMemoryStore;
use ironflow_store::store::Store;

let store: Arc<dyn Store> = Arc::new(InMemoryStore::new());
let engine = Arc::new(Engine::new(store, Arc::new(ClaudeCodeProvider::new())));
let waker = Waker::new(engine).batch_size(10);

pub async fn run(self, shutdown: CancellationToken)

Run the wake-up loop until shutdown is cancelled.

Store errors are logged and the loop keeps going: a transient database failure must not leave runs asleep forever.

Examples

use ironflow_api::waker::Waker;
use tokio_util::sync::CancellationToken;

let shutdown = CancellationToken::new();
tokio::spawn(waker.run(shutdown.clone()));
shutdown.cancel();

pub async fn tick(&self)

Wake one batch of due runs.

Exposed for tests and for callers that drive the schedule themselves.

Examples

use ironflow_api::waker::Waker;

waker.tick().await;