Enum Store 

pub enum Store {
    Sqlite(SqliteStore),
    Postgres(PgStore),
}

The storage backend used by the engine.

Variants

Sqlite(SqliteStore)

Postgres(PgStore)

Implementations

impl Store

pub fn connect(location: &str) -> Result<Store>

Open a backend from a location: a postgres:// / postgresql:// URL, or a SQLite file path.

pub fn open(path: &Path) -> Result<Store>

Open (or create) a SQLite database file.

pub fn in_memory() -> Result<Store>

pub fn backend(&self) -> &'static str

pub fn put_definition(&self, ir: &WorkflowIr, now: u64) -> Result<PutDefinition>

pub fn definitions(&self) -> Result<Vec<WorkflowIr>>

pub fn execution_exists(&self, id: &str) -> Result<bool>

pub fn append( &mut self, state: &ExecutionState, events: &[HistoryEvent], ) -> Result<()>

Atomically append events and update the execution projection.

pub fn history(&self, id: &str) -> Result<Vec<HistoryEvent>>

pub fn append_rollover( &mut self, state: &ExecutionState, events: &[HistoryEvent], rollover: Rollover<'_>, ) -> Result<()>

Continue-as-new in one transaction: archive the finished run (its stored history plus rollover.events) under its run number, then write the next run’s first events and point the projection at it.

pub fn run_history(&self, id: &str, run: u32) -> Result<Vec<HistoryEvent>>

The history of an earlier (archived) run; empty if there is none.

pub fn execution_status(&self, id: &str) -> Result<Option<String>>

The projected status of an execution (its latest run), if it exists.

pub fn read_only(&self) -> bool

True when this store cannot write (a cluster standby).

pub fn shared(&self) -> bool

True for a shared-mode store (several servers write).

pub fn release_schedule_claims(&self) -> Result<u64>

Drop every claim on a schedule occurrence. Only for a server that is the only writer (single server, cluster leader): claims left behind are from a process that is gone.

pub fn insert_schedule(&self, row: &ScheduleRow) -> Result<bool>

Insert a new schedule; false if the id is taken.

pub fn update_schedule(&self, row: &ScheduleRow) -> Result<bool>

Overwrite a schedule’s spec, paused flag and next occurrence, and drop any claim on it; false if it does not exist.

pub fn schedule(&self, id: &str) -> Result<Option<ScheduleRow>>

pub fn schedules(&self) -> Result<Vec<ScheduleRow>>

pub fn delete_schedule(&self, id: &str) -> Result<bool>

pub fn due_schedules(&self, now: u64) -> Result<Vec<ScheduleRow>>

Unpaused schedules whose next occurrence is due at now and that no server holds a live claim on.

pub fn claim_schedule( &self, id: &str, next_fire_ms: u64, node: &str, now: u64, until: u64, ) -> Result<bool>

Claim the occurrence next_fire_ms of a schedule for node until until: a compare-and-set on the row, so of several servers that find the same occurrence due exactly one gets it.

pub fn finish_schedule_fire( &self, id: &str, next_fire_ms: u64, node: &str, now: u64, record: &FireRecord, ) -> Result<bool>

Record a handled occurrence and release the claim, if node still holds it on occurrence next_fire_ms. False when the row changed meanwhile (updated, paused, deleted or claimed by another server).

pub fn release_schedule_claim( &self, id: &str, node: &str, retry_at: u64, error: &str, now: u64, ) -> Result<()>

Give up a claim without advancing the schedule: the occurrence is tried again from retry_at by any server.

pub fn record_schedule_trigger( &self, id: &str, execution_id: &str, now: u64, ) -> Result<()>

Note an execution started by POST /v1/schedules/{id}/trigger.

pub fn active_execution_ids(&self) -> Result<Vec<String>>

Ids of executions that have not reached a terminal status.

pub fn list_executions( &self, status: Option<&str>, workflow: Option<&str>, limit: u32, ) -> Result<Vec<ExecutionSummary>>

pub fn count_by_status(&self) -> Result<Vec<(String, u64)>>

pub fn upsert_worker(&self, w: &WorkerRecord) -> Result<()>

pub fn touch_worker(&self, worker_id: &str, now: u64) -> Result<()>

pub fn workers(&self) -> Result<Vec<WorkerRecord>>