Struct Jobs 

pub struct Jobs { /* private fields */ }

Runs jobs one at a time in the order they came, and keeps their records.

Implementations

impl Jobs

pub fn new(store: Arc<dyn JobStore>, out: Arc<dyn EventSink>) -> Jobs

Jobs a stopped server left are paused when they can continue, else interrupted; while another server still runs one (a deploy), they are its to pause.

pub fn running(&self) -> Option<Arc<Running>>

The running job, if any.

pub fn queued(&self) -> Vec<JobRecord>

Waiting jobs, the next to run first.

pub fn position(&self, id: &str) -> Option<usize>

Place of job id in the queue, 1 for the next to run.

pub fn latest(&self) -> Option<(JobRecord, Vec<Event>)>

The most recent job that ran: the running one, else the last kept that is not waiting.

pub fn get(&self, id: &str) -> Option<(JobRecord, Vec<Event>)>

pub fn live(&self, id: &str) -> Option<Arc<Running>>

The running or waiting job id, to follow its events.

pub fn list(&self, limit: usize) -> Vec<JobRecord>

pub fn submit( &self, kind: &str, key: &str, started_by: Option<String>, request_id: Option<String>, work: impl FnOnce(Arc<Running>) -> BoxFuture<'static, Result<()>> + Send + 'static, ) -> Result<Submitted>

Run work as a job of kind now, or queue it while another runs. A request with the same kind and key as a waiting one returns that job instead of queueing another.

pub fn submit_resumable( &self, kind: &str, key: &str, started_by: Option<String>, request_id: Option<String>, request: Option<Value>, work: impl FnOnce(Arc<Running>) -> BoxFuture<'static, Result<()>> + Send + 'static, ) -> Result<Submitted>

Jobs::submit, keeping request so a restart can continue the job.

pub fn resume( &self, key: &str, (job, events): (JobRecord, Vec<Event>), work: impl FnOnce(Arc<Running>) -> BoxFuture<'static, Result<()>> + Send + 'static, ) -> Result<Submitted>

Continue job, which a restart paused, under its own id: it runs now or waits its turn.

pub fn resumable(&self) -> Vec<(JobRecord, Vec<Event>)>

Jobs a restart paused, and running ones whose server went quiet, oldest first: the ones this server should continue.

pub fn cancel(&self, id: &str) -> Option<Status>

Cancel job id: the running one stops at its next check, a waiting one leaves the queue. Returns the status it had, None when it is neither.

pub fn shutdown(&self) -> Option<Arc<Running>>

Stop starting jobs; the waiting ones are paused, or interrupted when they cannot continue. Returns the running one, which pauses too when it stops at its next check.