faktory 0.13.1

API bindings for the language-agnostic Faktory work server
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
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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

#[cfg(doc)]
use super::Worker;

use crate::Job;
use std::future::Future;

/// Implementations of this trait can be registered to run jobs in a [`Worker`](Worker).
///
/// # Example
///
/// Create a worker with all default options, register a single handler (for the `foo` job
/// type), connect to the Faktory server, and start accepting jobs.
/// The handler is a struct that implements [`JobRunner`].
///
/// ```no_run
/// # tokio_test::block_on(async {
/// use async_trait::async_trait;
/// use faktory::{Job, JobRunner, WorkerBuilder};
/// use std::io;
///
/// struct MyHandler {
///     config: String,
/// }
///
/// #[async_trait]
/// impl JobRunner for MyHandler {
///    type Error = io::Error;
///    async fn run(&self, job: Job) -> Result<(), Self::Error> {
///       println!("config: {}", self.config);
///       println!("job: {:?}", job);
///       Ok(())
///   }
/// }
///
/// let handler = MyHandler {
///    config: "bar".to_string(),
/// };
///
/// let mut w = WorkerBuilder::default()
///     .register("foo", handler)
///     .connect()
///     .await
///     .unwrap();
///
/// if let Err(e) = w.run(&["default"]).await {
///     println!("worker failed: {}", e);
/// }
/// });
/// ```
#[async_trait::async_trait]
pub trait JobRunner: Send + Sync {
    /// The error type that the handler may return.
    type Error;
    /// A handler function that runs a job.
    async fn run(&self, job: Job) -> Result<(), Self::Error>;
}

// Implements JobRunner for a closure that takes a Job and returns a Result<(), E>
#[async_trait::async_trait]
impl<E, F, Fut> JobRunner for Box<F>
where
    F: Send + Sync + Fn(Job) -> Fut,
    Fut: Future<Output = Result<(), E>> + Send,
{
    type Error = E;
    async fn run(&self, job: Job) -> Result<(), E> {
        self(job).await
    }
}

// Additional Blanket Implementations
#[async_trait::async_trait]
impl<'a, E, F, Fut> JobRunner for &'a F
where
    F: Send + Sync + Fn(Job) -> Fut,
    Fut: Future<Output = Result<(), E>> + Send,
{
    type Error = E;
    async fn run(&self, job: Job) -> Result<(), E> {
        self(job).await
    }
}

#[async_trait::async_trait]
impl<'a, E, F, Fut> JobRunner for &'a mut F
where
    F: Send + Sync + Fn(Job) -> Fut,
    Fut: Future<Output = Result<(), E>> + Send,
{
    type Error = E;
    async fn run(&self, job: Job) -> Result<(), E> {
        (self as &F)(job).await
    }
}

/// A closure that implements [`JobRunner`].
///
/// The `Closure` newtype is introduced to avoid having to box a job handler:
/// we can now use `Closure(handler)` instead of `Box::new(handler)` and make
/// the compiler happy.
///
/// The `repr(transparent)` macro is to guarantee that this single-field struct
/// and the wrapped handler have the same layout and so it is safe to operate on
/// the in-memory representations of _the_ handler (submitted to us
/// from the user code) and its enclosed (by us) self.
///
/// Ref: https://github.com/jonhoo/faktory-rs/pull/51
#[repr(transparent)]
pub(crate) struct Closure<F>(pub F);

#[async_trait::async_trait]
impl<E, F, Fut> JobRunner for Closure<F>
where
    F: Send + Sync + Fn(Job) -> Fut,
    Fut: Future<Output = Result<(), E>> + Send,
{
    type Error = E;
    async fn run(&self, job: Job) -> Result<(), E> {
        (self.0)(job).await
    }
}

pub(crate) type BoxedJobRunner<E> = Box<dyn JobRunner<Error = E>>;