ishikari 0.1.1

Atomic, transaction-safe job queueing for Rust applications. Backed by PostgreSQL. Features include reliable background job execution, queue management, retry mechanisms, and flexible backoff strategies.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

use ishikari::prelude::*;
use tracing::{info, instrument};

#[derive(Debug)]
pub struct AppState {
    #[allow(dead_code)]
    pub pool: sqlx::PgPool,
}

#[ishikari::job]
pub struct Sum {
    pub a: i32,
    pub b: i32,
}

#[ishikari::worker]
impl Worker for Sum {
    #[instrument(skip(_ctx))]
    async fn perform(&self, _ctx: Context) -> PerformResult {
        let result = self.a + self.b;
        info!("{} + {} = {}", self.a, self.b, &result);

        Complete::default().message(result).into()
    }
}

#[ishikari::job]
pub struct Fail;

#[ishikari::worker(queue = "low_latency", max_attempts = 3)]
impl Worker for Fail {
    #[instrument(skip(ctx))]
    async fn perform(&self, ctx: Context) -> PerformResult {
        let state = ctx.state::<AppState>()?;

        info!("Job ID: {}", ctx.job().id);
        info!("State: {:?}", state);

        "this will fail".parse::<i32>()?;

        Complete::default().into()
    }
}

#[allow(dead_code)]
fn main() {}