Crate actix_redis_jobs

actix-redis-jobs

Simple and reliable background processing for Rust using Actix and Redis

Getting Started

To get started, just add to Cargo.toml

[dependencies]
actix-redis-jobs = { version = "0.2.0-beta.1" }

Prerequisites

A running redis server is required. You can quickly use docker:

docker run --name some-redis -d redis

Usage

use actix::prelude::*;
use futures::future::BoxFuture;
use log::info;
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use std::sync::Mutex;
struct MyData {
    counter: usize,
}
use actix_redis_jobs::{
    JobContext, JobHandler, JobResult, Producer, RedisConsumer, RedisStorage, ScheduleJob,
    WorkManager,
};
#[derive(Serialize, Deserialize, Message, Clone)]
#[rtype(result = "()")]
enum Math {
    Sum(isize, isize),
    Multiply(isize, isize),
}
impl JobHandler for Math {
    fn handle(&self, ctx: &JobContext) -> BoxFuture<JobResult> {
        let counter = ctx.data_opt::<Arc<Mutex<MyData>>>().unwrap();
        let mut data = counter.lock().unwrap();
        data.counter += 1;
        info!("Done like {} jobs", data.counter);
        let fut = async move {
            match self {
                Math::Sum(first, second) => {
                    info!(
                        "Sum result for {} and {} is {}",
                        first,
                        second,
                        first + second
                    );
                    JobResult::Result(Ok(()))
                }
                Math::Multiply(first, second) => {
                    info!(
                        "Multiply result for {} and {} is {}",
                        first,
                        second,
                        first * second
                    );
                    JobResult::Result(Ok(()))
                }
            }
        };
        Box::pin(fut)
    }
}
#[actix_rt::main]
async fn main() {
    std::env::set_var("RUST_LOG", "info");
    env_logger::init();
    let storage = RedisStorage::new("redis://127.0.0.1/");
    let producer = Producer::start(&storage, "math");
    let multiply = Math::Multiply(9, 8);
    producer.do_send(multiply); //Handled instantly
    let sum = Math::Sum(1, 2);
    let scheduled = ScheduleJob::new(sum).in_minutes(1); //Scheduled into the future
    producer.do_send(scheduled);
    let counter = Arc::new(Mutex::new(MyData { counter: 0 }));
    WorkManager::create(move |worker| {
        worker.consumer(
            RedisConsumer::<Math>::new(&storage, "math")
                .data(counter.clone()) //Actix ideas
                .workers(2),
        )
    })
    .run()
    .await;
}

Structs

Job
JobContext
Producer	Actix Scheduler queue actor.
PushJob	Actix message implements request Redis to push job
RedisConsumer
RedisStorage
ScheduleJob	Actix message implements request Redis to schedule job
WorkManager

Enums

JobResult
JobStatus	Status of pushing a job.
TaskError

Traits

Consumer
JobHandler