Struct PgStore 

pub struct PgStore { /* private fields */ }

PostgreSQL-backed Store. Cheap to clone.

Implementations

impl PgStore

pub async fn connect(url: &str) -> Result<PgStore, StoreError>

Connect with default settings and apply the schema.

pub async fn connect_with( url: &str, cfg: PgStoreConfig, ) -> Result<PgStore, StoreError>

Connect with cfg and apply the schema.

pub async fn migrate(&self) -> Result<(), StoreError>

Apply pending schema migrations (idempotent; serialized across instances that use the same schema). PgStore::connect already does this.

pub fn pool(&self) -> &PgPool

The connection pool (its sessions use the configured schema).

pub fn config(&self) -> &PgStoreConfig

The configuration this store was opened with.

pub fn leader_lock(&self) -> (i32, i32)

The two keys of the advisory lock held by the leader (pg_locks.classid, objid), for monitoring.

pub fn epoch(&self) -> Option<u16>

Current fencing epoch, if this instance holds leadership.

pub fn is_leader(&self) -> bool

Whether this instance currently holds leadership.

pub async fn leadership_lost(&self)

Resolves once leadership held by this instance is lost (lock session gone).

pub async fn release_leadership(&self)

Give up leadership (releases the advisory lock).

pub async fn get_task( &self, target: &TaskRef, ) -> Result<Option<TaskRecord>, StoreError>

Look up a task by id or key (the most recent task with that key).

pub async fn list_finished( &self, pools: &[&str], statuses: &[TaskStatus], after: Option<TaskId>, limit: usize, ) -> Result<Vec<TaskRecord>, StoreError>

Finished tasks in id order: those in one of pools (any if empty) with one of statuses (any finished status if empty) and ids above after, at most limit.

pub async fn prune(&self, older_than: Duration) -> Result<u64, StoreError>

Delete finished tasks last updated more than older_than ago, except those that live tasks still depend on. Deletes in bounded batches; returns the number of rows removed.

Trait Implementations

impl Clone for PgStore

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Store<Bytes, Bytes> for PgStore

fn acquire_leadership<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<u16, StoreError>> + Send + 'async_trait>>

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

Block until this instance is the leader; returns the new fencing epoch.

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

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

Give up leadership (e.g. when startup fails after it was acquired).

fn commit<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, epoch: u16, base: TimeBase, batch: &'life1 [Mutation<Bytes>], outputs: &'life2 [(TaskId, &'life3 Bytes)], ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

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

Durably apply a batch, in order. Must fail with StoreError::Fenced if epoch is stale. outputs holds the outputs of tasks that succeed in this batch.

fn recover<'life0, 'async_trait>( &'life0 self, base: TimeBase, ) -> Pin<Box<dyn Future<Output = Result<Recovered<Bytes>, StoreError>> + Send + 'async_trait>>

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

Load non-terminal tasks, recent terminal statuses and schedules.

fn load_output<'life0, 'async_trait>( &'life0 self, id: TaskId, ) -> Pin<Box<dyn Future<Output = Result<Option<Bytes>, StoreError>> + Send + 'async_trait>>

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

Output of a task that succeeded earlier, if the store still has it (used for handles to tasks that finished before they were requested, e.g. duplicate submissions).

fn persists(&self) -> bool

Whether mutations should be produced at all.

impl StoreQueries<Bytes> for PgStore

fn get_task<'life0, 'life1, 'async_trait>( &'life0 self, target: &'life1 TaskRef, ) -> Pin<Box<dyn Future<Output = Result<Option<TaskRecord>, StoreError>> + Send + 'async_trait>>

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

The task target refers to: by id, or the newest task with that key.

fn prune<'life0, 'async_trait>( &'life0 self, older_than: Duration, ) -> Pin<Box<dyn Future<Output = Result<u64, StoreError>> + Send + 'async_trait>>

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

Delete finished tasks older than older_than that no live task depends on; returns how many were deleted.

fn list_finished<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, pools: &'life1 [&'life2 str], statuses: &'life3 [TaskStatus], after: Option<TaskId>, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<TaskRecord>, StoreError>> + Send + 'async_trait>>

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

Finished tasks in id order: those in one of pools (any if empty) with one of statuses (any finished status if empty) and ids above after, at most limit.

fn is_leader(&self) -> bool

Whether this instance currently holds leadership.

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

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

Resolves once leadership held by this instance is lost.