Crate job_runner

Source
Expand description

A simple JobRunner which gives each job a dedicated thread and allows for configurable delays between each invocation of the job’s logic.

§Example

A program using the JobRunner is expected to have this basic outline:

use job_runner::{Job, JobRunner, fixed_delay};
 
fn main() {
    // At program startup, create the JobRunner and register your tasks.
    let mut job_runner = JobRunner::new();
    job_runner.start(Job::new(
        "cool_job",
        fixed_delay(std::time::Duration::from_secs(5)),
        my_cool_job));
 
    // Do other things in your program...
 
    // Then, when shutting down your program, signal all the job threads
    // to stop running.
    job_runner.stop_all();
 
    // Maybe signal other parts of your program to gracefully shut down too...
 
    // Finally (and optionally) wait for the job threads to actually exit.
    job_runner.join_all();
}
 
fn my_cool_job() {
    // Do cool things..
}

Structs§

  • A description of a job that can be registered with a JobRunner.
  • The main coordinator for running jobs. It exposes methods to start and stop jobs, as well as to get the status of a job or all jobs.
  • A snapshot of the current status of a job.

Traits§

  • A Schedule implementation controls when jobs are executed. All that the JobRunner does is invoke a job in an infinite loop (until the JobRunner is shut down), with a delay between runs. The delay is controlled by the Schedule, and schedules can specify either fixed or varying delays.

Functions§

  • Returns a Schedule which inserts a fixed delay between the end of one job execution and the start of the next. Note that this means that how often jobs execute depends on how long jobs take to run.
  • Returns a Schedule which runs the job constantly, as fast as possible.