Trait Inspect 

pub trait Inspect: Store {
    // Required methods
    fn get_job<'life0, 'life1, 'async_trait>(
        &'life0 self,
        id: &'life1 str,
        include_payload: bool,
    ) -> Pin<Box<dyn Future<Output = Result<Option<JobSummary>, StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn list_jobs<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        filter: &'life1 JobFilter,
        cursor: Option<&'life2 str>,
        limit: u32,
    ) -> Pin<Box<dyn Future<Output = Result<JobPage, StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn counts<'life0, 'life1, 'async_trait>(
        &'life0 self,
        queue: Option<&'life1 str>,
    ) -> Pin<Box<dyn Future<Output = Result<StateCounts, StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn queue_stats<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<QueueStats>, StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn set_queue_paused<'life0, 'life1, 'async_trait>(
        &'life0 self,
        queue: &'life1 str,
        paused: bool,
    ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn set_queue_weight<'life0, 'life1, 'async_trait>(
        &'life0 self,
        queue: &'life1 str,
        weight: u32,
    ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn set_enqueue_limit<'life0, 'life1, 'async_trait>(
        &'life0 self,
        queue: &'life1 str,
        max_unfinished_jobs: Option<u64>,
    ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn rate_classes<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<RateClassState>, StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn upsert_rate_class<'life0, 'life1, 'async_trait>(
        &'life0 self,
        cfg: &'life1 RateClassConfig,
    ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn concurrency_limits<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<ConcurrencyLimitConfig>, StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn upsert_concurrency_limit<'life0, 'life1, 'async_trait>(
        &'life0 self,
        cfg: &'life1 ConcurrencyLimitConfig,
    ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn partitions<'life0, 'life1, 'async_trait>(
        &'life0 self,
        queue: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<PartitionState>, StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn quarantine_list<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<QuarantineEntry>, StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn quarantine_release<'life0, 'life1, 'async_trait>(
        &'life0 self,
        fingerprint: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<u64, StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn operator_retry<'life0, 'life1, 'async_trait>(
        &'life0 self,
        id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn operator_cancel<'life0, 'life1, 'async_trait>(
        &'life0 self,
        id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn promote_job<'life0, 'life1, 'async_trait>(
        &'life0 self,
        id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn delete_job<'life0, 'life1, 'async_trait>(
        &'life0 self,
        id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn explain_admission<'life0, 'life1, 'async_trait>(
        &'life0 self,
        id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<Option<AdmissionExplain>, StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn history<'life0, 'life1, 'async_trait>(
        &'life0 self,
        queue: &'life1 str,
        since_ms: i64,
        bucket_ms: i64,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<HistoryBucket>, StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn quarantine_sweep<'life0, 'async_trait>(
        &'life0 self,
        limit: i64,
    ) -> Pin<Box<dyn Future<Output = Result<u64, StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn reschedule_job<'life0, 'life1, 'async_trait>(
        &'life0 self,
        id: &'life1 str,
        at_ms: i64,
    ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn edit_payload<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        id: &'life1 str,
        payload: &'life2 [u8],
        schema_version: u32,
        fingerprint: &'life3 str,
    ) -> 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;
    fn upsert_schedule<'life0, 'life1, 'async_trait>(
        &'life0 self,
        s: &'life1 Schedule,
    ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn delete_schedule<'life0, 'life1, 'async_trait>(
        &'life0 self,
        id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn list_schedules<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<Schedule>, StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn due_schedules<'life0, 'async_trait>(
        &'life0 self,
        limit: i64,
    ) -> Pin<Box<dyn Future<Output = Result<(Vec<Schedule>, i64), StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn advance_schedule<'life0, 'life1, 'async_trait>(
        &'life0 self,
        id: &'life1 str,
        from_next_run_ms: i64,
        to_next_run_ms: i64,
    ) -> Pin<Box<dyn Future<Output = Result<bool, StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn record_schedule_event<'life0, 'life1, 'async_trait>(
        &'life0 self,
        event: &'life1 ScheduleEvent,
    ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn list_schedule_events<'life0, 'life1, 'async_trait>(
        &'life0 self,
        schedule_id: &'life1 str,
        before_event_id: Option<u64>,
        limit: u32,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<ScheduleEvent>, StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn heartbeat_worker<'life0, 'life1, 'async_trait>(
        &'life0 self,
        w: &'life1 WorkerMeta,
    ) -> Pin<Box<dyn Future<Output = Result<Option<String>, StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn list_workers<'life0, 'async_trait>(
        &'life0 self,
        stale_after_ms: i64,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<WorkerMeta>, StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn signal_worker<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        worker_id: &'life1 str,
        command: Option<&'life2 str>,
    ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn distinct_kinds<'life0, 'async_trait>(
        &'life0 self,
        limit: i64,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<String>, StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn create_operation<'life0, 'life1, 'async_trait>(
        &'life0 self,
        req: &'life1 BulkRequest,
    ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_operation<'life0, 'life1, 'async_trait>(
        &'life0 self,
        id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<Option<OperationStatus>, StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn run_pending_operations<'life0, 'async_trait>(
        &'life0 self,
        batch: i64,
    ) -> Pin<Box<dyn Future<Output = Result<u64, StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn delete_queue<'life0, 'life1, 'async_trait>(
        &'life0 self,
        queue: &'life1 str,
        force: bool,
    ) -> Pin<Box<dyn Future<Output = Result<Option<String>, StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn sample_queue_memory<'life0, 'async_trait>(
        &'life0 self,
        limit: u32,
    ) -> Pin<Box<dyn Future<Output = Result<u32, StoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;

    // Provided methods
    fn as_result_inspect(&self) -> Option<&dyn ResultInspect> { ... }
    fn as_output_inspect(&self) -> Option<&dyn OutputInspect> { ... }
    fn as_progress_inspect(&self) -> Option<&dyn ProgressInspect> { ... }
    fn as_checkpoint_inspect(&self) -> Option<&dyn CheckpointInspect> { ... }
}

control plane the control API’s store surface. Separate from Store the way Transactional is (runtime capability boundary): a backend that cannot answer these does not have them. Every read here is bounded — no method may be O(queue depth) (invariant 6).

Required Methods

fn get_job<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, include_payload: bool, ) -> Pin<Box<dyn Future<Output = Result<Option<JobSummary>, StoreError>> + Send + 'async_trait>>

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

fn list_jobs<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, filter: &'life1 JobFilter, cursor: Option<&'life2 str>, limit: u32, ) -> Pin<Box<dyn Future<Output = Result<JobPage, StoreError>> + Send + 'async_trait>>

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

fn counts<'life0, 'life1, 'async_trait>( &'life0 self, queue: Option<&'life1 str>, ) -> Pin<Box<dyn Future<Output = Result<StateCounts, StoreError>> + Send + 'async_trait>>

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

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

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

fn set_queue_paused<'life0, 'life1, 'async_trait>( &'life0 self, queue: &'life1 str, paused: bool, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

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

fn set_queue_weight<'life0, 'life1, 'async_trait>( &'life0 self, queue: &'life1 str, weight: u32, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

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

Invariant 16: queue-selection weight is fleet policy, not a worker-local polling hint. weight == 0 is invalid; omitted/unconfigured queues read as weight 1.

fn set_enqueue_limit<'life0, 'life1, 'async_trait>( &'life0 self, queue: &'life1 str, max_unfinished_jobs: Option<u64>, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

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

Configure the fleet-wide enqueue bound. The store may accept a limit below the current depth; that immediately stops growth until drain catches up.

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

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

fn upsert_rate_class<'life0, 'life1, 'async_trait>( &'life0 self, cfg: &'life1 RateClassConfig, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

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

Invariant 16: any policy the gate reads, the API can write — a fleet limit you cannot change without a redeploy is not an operational feature.

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

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

fn upsert_concurrency_limit<'life0, 'life1, 'async_trait>( &'life0 self, cfg: &'life1 ConcurrencyLimitConfig, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

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

fn partitions<'life0, 'life1, 'async_trait>( &'life0 self, queue: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<PartitionState>, StoreError>> + Send + 'async_trait>>

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

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

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

fn quarantine_release<'life0, 'life1, 'async_trait>( &'life0 self, fingerprint: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<u64, StoreError>> + Send + 'async_trait>>

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

crash quarantine deliberate operator action: quarantined jobs of this fingerprint become available (operator_release) and new enqueues are accepted again. Returns how many jobs were released. A released job re-quarantines on its next crash.

fn operator_retry<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

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

archived → available (operator_retry). Any other state is an error — the transition table defines exactly which rows exist.

fn operator_cancel<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

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

scheduled|available|running → cancelled (operator_cancel). Cancelling a running job clears its lease, so the holder’s next renew/ack/checkpoint is rejected and its handler stops within a heartbeat.

fn promote_job<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

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

pending -> available. No timer or dependency watcher may perform this change.

fn delete_job<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

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

Delete a non-running job. Deleting mid-flight is refused (asynq’s rule).

fn explain_admission<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<AdmissionExplain>, StoreError>> + Send + 'async_trait>>

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

fn history<'life0, 'life1, 'async_trait>( &'life0 self, queue: &'life1 str, since_ms: i64, bucket_ms: i64, ) -> Pin<Box<dyn Future<Output = Result<Vec<HistoryBucket>, StoreError>> + Send + 'async_trait>>

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

backlog metrics time series from the incrementally-maintained counters — never a scan.

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

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

crash quarantine the quarantine sweeper (singleton duties’s duty): waiting jobs whose fingerprint is quarantined move to the terminal quarantined state, VISIBLY — without this they sit gate-excluded forever, which is an invisible skip. Returns how many moved. Bounded per call; run under a duty lease.

fn reschedule_job<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, at_ms: i64, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

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

Move a waiting job’s run time. Defined only for scheduled and retryable — no state changes, so no transition-table row is needed.

fn edit_payload<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, id: &'life1 str, payload: &'life2 [u8], schema_version: u32, fingerprint: &'life3 str, ) -> 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,

Edit-then-retry (control API contract). Non-running jobs only. The fingerprint is derived caller-side (content fingerprinting) and passed in, because it must change with the payload.

fn upsert_schedule<'life0, 'life1, 'async_trait>( &'life0 self, s: &'life1 Schedule, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

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

Idempotent upsert (BullMQ’s upsertJobScheduler). next_run_ms is kept from the existing row when the spec is unchanged, so re-deploying a config does not reset the phase of a running schedule.

fn delete_schedule<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

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

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

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

fn due_schedules<'life0, 'async_trait>( &'life0 self, limit: i64, ) -> Pin<Box<dyn Future<Output = Result<(Vec<Schedule>, i64), StoreError>> + Send + 'async_trait>>

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

Due entries plus STORE time — tick math must not use a worker clock.

fn advance_schedule<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, from_next_run_ms: i64, to_next_run_ms: i64, ) -> Pin<Box<dyn Future<Output = Result<bool, StoreError>> + Send + 'async_trait>>

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

Compare-and-set advance: succeeds only if next_run_ms still equals from. Losing the race means another node already advanced — never an error.

fn record_schedule_event<'life0, 'life1, 'async_trait>( &'life0 self, event: &'life1 ScheduleEvent, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

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

Append one scheduler enqueue attempt and trim older history atomically.

fn list_schedule_events<'life0, 'life1, 'async_trait>( &'life0 self, schedule_id: &'life1 str, before_event_id: Option<u64>, limit: u32, ) -> Pin<Box<dyn Future<Output = Result<Vec<ScheduleEvent>, StoreError>> + Send + 'async_trait>>

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

Newest first. limit must be in 1..=SCHEDULE_EVENT_LIMIT.

fn heartbeat_worker<'life0, 'life1, 'async_trait>( &'life0 self, w: &'life1 WorkerMeta, ) -> Pin<Box<dyn Future<Output = Result<Option<String>, StoreError>> + Send + 'async_trait>>

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

Upsert the worker row and return any pending operator COMMAND for it — the control channel rides the heartbeat that is already happening (Faktory’s BEAT): “quiet” stops admitting, “resume” resumes, “restart” drains without a timeout, “terminate” performs a bounded shutdown, and “resign” releases singleton duties.

fn list_workers<'life0, 'async_trait>( &'life0 self, stale_after_ms: i64, ) -> Pin<Box<dyn Future<Output = Result<Vec<WorkerMeta>, StoreError>> + Send + 'async_trait>>

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

Workers whose heartbeat is within stale_after_ms of store-now.

fn signal_worker<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, worker_id: &'life1 str, command: Option<&'life2 str>, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

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

Set (or clear, with None) a worker’s pending command. It is delivered on the next heartbeat; runtimes clear it after applying it, then publish acknowledged state.

fn distinct_kinds<'life0, 'async_trait>( &'life0 self, limit: i64, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>, StoreError>> + Send + 'async_trait>>

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

typed dispatch distinct kinds currently present among waiting jobs (bounded sample), so a runner can warn at startup about kinds no registered handler answers.

fn create_operation<'life0, 'life1, 'async_trait>( &'life0 self, req: &'life1 BulkRequest, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

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

fn get_operation<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<OperationStatus>, StoreError>> + Send + 'async_trait>>

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

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

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

Execute one bounded batch of each pending operation (run under a duty lease). Returns rows affected this sweep; an operation whose batch comes back short is marked completed.

fn delete_queue<'life0, 'life1, 'async_trait>( &'life0 self, queue: &'life1 str, force: bool, ) -> Pin<Box<dyn Future<Output = Result<Option<String>, StoreError>> + Send + 'async_trait>>

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

Refuse a non-empty queue unless force; forced deletion is represented by a bounded async operation and therefore returns its operation id.

fn sample_queue_memory<'life0, 'async_trait>( &'life0 self, limit: u32, ) -> Pin<Box<dyn Future<Output = Result<u32, StoreError>> + Send + 'async_trait>>

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

Refresh bounded queue memory samples. Implementations must cap work to limit; ordinary queue reads only return the last stored sample.

Provided Methods

fn as_result_inspect(&self) -> Option<&dyn ResultInspect>

Optional explicit result-byte reader. Keeping this separate from job/list reads prevents an accidental payload leak and preserves capability honesty.

fn as_output_inspect(&self) -> Option<&dyn OutputInspect>

Optional explicit reader for mid-run output bytes. Ordinary job/list reads keep omitting them for the same PII posture as final results and payloads.

fn as_progress_inspect(&self) -> Option<&dyn ProgressInspect>

Optional explicit reader for operator-facing progress. It stays outside ordinary job/list reads because even a short application message may contain sensitive data.

fn as_checkpoint_inspect(&self) -> Option<&dyn CheckpointInspect>

Optional explicit reader for resumable-step checkpoints. Cursor bytes may carry application data, so ordinary job/list responses never include them.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors