teleop 0.4.1

Teleoperate Rust Processes
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

//! Dummy attacher which listens immediately.

use crate::attach::attacher::{Attacher, AttacherSignal};

/// Dummy attacher.
///
/// It does nothing and considers the signal as signaled from the very beginning.
pub struct DummyAttacher;

impl Attacher for DummyAttacher {
    type Signal = DummyAttacherSignal;

    fn signal(_pid: u32) -> Result<Self::Signal, Box<dyn std::error::Error>> {
        Ok(DummyAttacherSignal)
    }

    async fn signaled() -> Result<(), Box<dyn std::error::Error>> {
        Ok(())
    }
}

/// Dummy attacher signal.
///
/// It does nothing.
pub struct DummyAttacherSignal;

impl AttacherSignal for DummyAttacherSignal {
    async fn send(&mut self) -> Result<(), Box<dyn std::error::Error>> {
        Ok(())
    }
}

#[cfg(test)]
#[cfg_attr(coverage_nightly, coverage(off))]
mod tests {
    use std::time::Duration;

    use async_io::Timer;
    use futures::{select, FutureExt};

    use super::DummyAttacher;
    use crate::attach::attacher::{Attacher, AttacherSignal};

    #[test]
    fn test_dummy_attacher() {
        let mut exec = futures::executor::LocalPool::new();

        let res = exec.run_until(async {
            let job = async {
                DummyAttacher::signaled().await?;
                DummyAttacher::signal(std::process::id())?.send().await?;
                Ok::<_, Box<dyn std::error::Error>>(())
            };

            let timeout =
                Timer::after(Duration::from_secs(5)).then(async |_| Err("Test timeout".into()));

            select! {
                a = job.fuse() => a,
                b = timeout.fuse() => b,
            }
        });

        exec.run();

        res.unwrap();
    }
}