Derive macros for Queue and Worker

[tyt2y3]

Queue

Basic queue:

#[derive(Serialize, oxanus::Queue)]
struct DefaultQueue;

assert_eq!(DefaultQueue.key(), "default_queue");

With options:

#[derive(Serialize, oxanus::Queue)]
#[oxanus(key = "queue_with_throttle")]
#[oxanus(concurrency = 2)]
#[oxanus(throttle(window_ms = 3, limit = 4))]
struct QueueWithThrottle;

assert_eq!(QueueWithThrottle.key(), "queue_with_throttle");
assert_eq!(QueueWithThrottle.config().concurrency, 2);
assert_eq!(QueueWithThrottle.config().throttle.unwrap().window_ms, 3);
assert_eq!(QueueWithThrottle.config().throttle.unwrap().limit, 4);

Dynamic queue:

#[derive(Serialize, oxanus::Queue)]
#[oxanus(prefix = "dyn_queue", concurrency = 2)]
struct DynQueue {
    i: i32,
}

assert_eq!(DynQueue { i: 2 }.key(), "dyn_queue#i=2");
assert_eq!(DynQueue::to_config().concurrency, 2);

Using key on dynamic queue would result in compile error, and vice versa.

Worker

Basic worker:

#[derive(Serialize, oxanus::Worker)]
struct TestWorker {}

impl TestWorker {
    async fn process(&self, ctx: &Context<WorkerContext>) -> Result<(), WorkerError> {
        Ok(())
    }
}

With options:

#[derive(Serialize, oxanus::Worker)]
#[oxanus(context = crate::WorkerContext, error = std::io::Error)]
#[oxanus(max_retries = 3, on_conflict = Replace)]
struct TestWorkerCustom {}

assert_eq!(TestWorkerCustom {}.max_retries(), 3);
assert_eq!(TestWorkerCustom {}.on_conflict(), JobConflictStrategy::Replace);

With unique_id:

#[derive(Serialize, oxanus::Worker)]
#[oxanus(unique_id = "test_worker_{id}")]
struct TestWorkerUniqueId {
    id: i32,
}

assert_eq!(
    TestWorkerUniqueId { id: 1 }.unique_id().unwrap(),
    "test_worker_1"
);

[reneklacan]

love it ❤️