[][src]Crate dbq

Job queueing and processing library with queues stored in Postgres 9.5+

Example

extern crate dbq;
extern crate postgres;
extern crate serde_json;

use std::error::Error;
use std::result::Result;
use std::thread;
use std::time::Duration;

// A simple handler that prints "Hello!" for any job it runs
#[derive(Clone)]
struct HelloHandler {}

fn main() -> Result<(), Box<Error>> {
    let db_conn_params = "postgres://postgres:password@localhost/db";
    let conn = postgres::Connection::connect(db_conn_params, postgres::TlsMode::None)?;

    // Schema config allows for changing the database schema and table names
    // Defaults are no schema (default is used) and tables are prefixed with "dbq_"
    let schema_config = dbq::SchemaConfig::default();
    // Run the migrations on start. Migrations are idempotent and should be run
    // on startup
    dbq::run_migrations(&schema_config, &conn, Some(646_271)).unwrap();

    let queue = dbq::Queue::new(schema_config, "de_lancie_q".to_string());

    // Enqueue a job
    queue.enqueue("job_a", serde_json::Value::Null, 3, &conn)?;

    // Start a worker pool
    let workers_config =
        dbq::WorkerPoolConfig::new(queue, db_conn_params, HelloHandler {})?;
    let workers = dbq::WorkerPool::start(workers_config);

    // Give a worker time to find and start the job
    thread::sleep(Duration::new(1, 0));
    // Shutdown the worker pool waiting for all currently executing jobs to finish
    workers.join();
    Ok(())
}

impl dbq::Handler for HelloHandler {
    type Error = std::io::Error;

    fn handle(&self, _ctx: dbq::JobContext) -> Result<(), Self::Error> {
        println!("Hello!");
        Ok(())
    }
}

Structs

Job

Specification and status of a job

JobContext

Contains the job and the transaction for use from within a handler

Queue

Represents a job queue stored in the database. Because the queue is stored in the database, the queue should be considered to have internal mutability

SchemaConfig

Configures the tables for storing the job queue and dead letters. The default SchemaConfig uses the default schema and prefixes the tables with dbq_

WorkerPool

A group of workers that process jobs from a Queue

WorkerPoolConfig

Configuration options for creating a WorkerPool. See WorkerPool documentation for examples

Enums

Error

Wrapper type for errors that may occur in dbq

Traits

Handler

Implement to run jobs from a Queue in a WorkerPool

Functions

run_migrations

Create the database objects used by dbq. This function is idempotent and should be run on every startup to ensure that the database objects are up to date.

Type Definitions

Result

Result type for dbq::Error