batch 0.1.1

Distributed task queue library based on RabbitMQ
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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

//! A trait representing an executable task.

use serde::Serialize;
use serde::de::DeserializeOwned;
use std::time::Duration;

use error::Result;

/// An executable task and its related metadata (name, queue, timeout, etc.)
///
/// In most cases, you should be deriving this trait instead of implementing it manually yourself.
///
/// # Examples
///
/// Using the provided defaults:
///
/// ```rust
/// #[macro_use]
/// extern crate batch;
/// extern crate serde;
/// #[macro_use]
/// extern crate serde_derive;
///
/// #[derive(Deserialize, Serialize, Task)]
/// #[task_routing_key = "emails"]
/// struct SendConfirmationEmail;
///
/// #
/// # fn main() {}
/// ```
///
/// Overriding the provided defaults:
///
/// ```rust
/// #[macro_use]
/// extern crate batch;
/// extern crate serde;
/// #[macro_use]
/// extern crate serde_derive;
///
/// struct App;
///
/// #[derive(Deserialize, Serialize, Task)]
/// #[task_name = "batch-rs:send-password-reset-email"]
/// #[task_routing_key = "emails"]
/// #[task_timeout = "120"]
/// #[task_retries = "0"]
/// struct SendPasswordResetEmail;
///
/// #
/// # fn main() {}
/// ```
pub trait Task: DeserializeOwned + Serialize {
    /// A should-be-unique human-readable ID for this task.
    fn name() -> &'static str;

    /// The exchange the task will be published to.
    fn exchange() -> &'static str;

    /// The routing key associated to this task.
    fn routing_key() -> &'static str;

    /// The number of times this task must be retried in case of error.
    fn retries() -> u32;

    /// An optional duration representing the time allowed for this task's handler to complete.
    fn timeout() -> Option<Duration>;
}

/// The `Perform` trait allow marking a `Task` as executable.
///
/// # Example
///
/// ```
/// #[macro_use]
/// extern crate batch;
/// extern crate serde;
/// #[macro_use]
/// extern crate serde_derive;
///
/// use batch::Perform;
///
/// #[derive(Serialize, Deserialize, Task)]
/// #[task_routing_key = "emails"]
/// struct SendPasswordResetEmail;
///
/// impl Perform for SendPasswordResetEmail {
///     type Context = ();
///
///     fn perform(&self, _ctx: Self::Context) {
///         println!("Sending password reset email...");
///     }
/// }
///
/// # fn main() {}
/// ```
pub trait Perform {
    /// The type of the context value that will be given to this task's handler.
    type Context;

    /// Perform the task's duty.
    fn perform(&self, Self::Context);
}