faktory 0.13.0

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

use crate::proto::{Fail, JobId};
use std::{
    ops::{Deref, DerefMut},
    sync::Mutex,
};

#[derive(Default)]
pub(crate) struct WorkerState {
    last_job_result: Option<Result<JobId, Fail>>,
    running_job: Option<JobId>,
}

impl WorkerState {
    pub(crate) fn take_last_result(&mut self) -> Option<Result<JobId, Fail>> {
        self.last_job_result.take()
    }

    pub(crate) fn take_currently_running(&mut self) -> Option<JobId> {
        self.running_job.take()
    }

    pub(crate) fn save_last_result(&mut self, res: Result<JobId, Fail>) {
        self.last_job_result = Some(res)
    }
}

pub(crate) struct WorkerStatesRegistry(Vec<Mutex<WorkerState>>);

impl Deref for WorkerStatesRegistry {
    type Target = Vec<Mutex<WorkerState>>;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl DerefMut for WorkerStatesRegistry {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

impl<'a> IntoIterator for &'a WorkerStatesRegistry {
    type Item = &'a Mutex<WorkerState>;
    type IntoIter = <&'a Vec<Mutex<WorkerState>> as IntoIterator>::IntoIter;

    fn into_iter(self) -> Self::IntoIter {
        self.0.iter()
    }
}

impl<'a> IntoIterator for &'a mut WorkerStatesRegistry {
    type Item = &'a mut Mutex<WorkerState>;
    type IntoIter = <&'a mut Vec<Mutex<WorkerState>> as IntoIterator>::IntoIter;

    fn into_iter(self) -> Self::IntoIter {
        self.0.iter_mut()
    }
}

impl WorkerStatesRegistry {
    pub(crate) fn new(workers_count: usize) -> Self {
        Self((0..workers_count).map(|_| Default::default()).collect())
    }

    pub(crate) fn register_running(&self, worker: usize, jid: JobId) {
        self[worker].lock().expect("lock acquired").running_job = Some(jid);
    }

    pub(crate) fn register_success(&self, worker: usize, jid: JobId) {
        self[worker]
            .lock()
            .expect("lock acquired")
            .save_last_result(Ok(jid));
    }

    pub(crate) fn register_failure(&self, worker: usize, f: Fail) {
        self[worker]
            .lock()
            .expect("lock acquired")
            .save_last_result(Err(f));
    }

    pub(crate) fn reset(&self, worker: usize) {
        let mut state = self[worker].lock().expect("lock acquired");
        state.last_job_result = None;
        state.running_job = None;
    }
}