mechanics-core 0.1.0

mechanics automation framework (core)
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

use crate::{error::MechanicsError, job::MechanicsJob};
use crossbeam_channel::Sender;
use serde_json::Value;
use std::{
    sync::{
        Arc,
        atomic::{AtomicBool, Ordering},
    },
    thread,
};

#[derive(Debug)]
pub(crate) struct PoolJob {
    job: MechanicsJob,
    reply: Sender<Result<Value, MechanicsError>>,
    canceled: Arc<AtomicBool>,
}

impl PoolJob {
    pub(crate) fn new(
        job: MechanicsJob,
        reply: Sender<Result<Value, MechanicsError>>,
        canceled: Arc<AtomicBool>,
    ) -> Self {
        Self {
            job,
            reply,
            canceled,
        }
    }

    pub(crate) fn is_canceled(&self) -> bool {
        self.canceled.load(Ordering::Acquire)
    }

    pub(crate) fn mark_canceled(&self) {
        self.canceled.store(true, Ordering::Release);
    }

    pub(crate) fn send_result(&self, result: Result<Value, MechanicsError>) {
        let _ = self.reply.send(result);
    }

    pub(crate) fn reply_sender(&self) -> Sender<Result<Value, MechanicsError>> {
        self.reply.clone()
    }

    pub(crate) fn into_job(self) -> MechanicsJob {
        self.job
    }
}

#[derive(Debug)]
pub(crate) enum PoolMessage {
    Run(PoolJob),
}

#[derive(Debug)]
pub(crate) struct WorkerExit {
    worker_id: usize,
}

impl WorkerExit {
    pub(crate) fn new(worker_id: usize) -> Self {
        Self { worker_id }
    }

    pub(crate) fn worker_id(&self) -> usize {
        self.worker_id
    }
}

#[derive(Debug)]
pub(crate) struct WorkerHandle {
    join: thread::JoinHandle<()>,
    shutdown_tx: Sender<()>,
}

impl WorkerHandle {
    pub(crate) fn new(join: thread::JoinHandle<()>, shutdown_tx: Sender<()>) -> Self {
        Self { join, shutdown_tx }
    }

    pub(crate) fn is_finished(&self) -> bool {
        self.join.is_finished()
    }

    #[cfg(test)]
    pub(crate) fn from_join_for_test(join: thread::JoinHandle<()>) -> Self {
        let (shutdown_tx, _shutdown_rx) = crossbeam_channel::bounded::<()>(1);
        Self { join, shutdown_tx }
    }

    pub(crate) fn request_shutdown(&self) {
        let _ = self.shutdown_tx.send(());
    }

    pub(crate) fn join(self) {
        let _ = self.join.join();
    }
}