srvzio 1.1.1

An helpful crate to implement services
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

use super::*;
use std::{time::{Duration, Instant}, thread};
use crossbeam_channel::{Sender, bounded};

struct ExampleService {
  id: String,
  pub delay: Duration,
  sender: Sender<String>,
  flag: ServiceStatusFlag
}

impl ExampleService {
  fn new(id: String, delay: Duration, sender: Sender<String>) -> ExampleService {
    ExampleService {
      id,
      delay,
      sender,
      flag: ServiceStatusFlag::default()
    }
  }
}

impl Service for ExampleService {

  fn name(&self) -> &'static str {
    "ExampleService"
  }

  fn start(&mut self) {
    self.flag.starting();

    let id = self.id.clone();
    let delay = self.delay.clone();
    let sender = self.sender.clone();
    let flag = self.flag.clone();
    thread::spawn(move || {
      thread::sleep(delay);
      sender.send(format!("Service {} STARTED", id).to_string()).unwrap();

      flag.started();
    });
  }

  fn await_started(&mut self) {
    while !self.flag.is_started() {}
  }


  fn stop(&mut self) {
    self.flag.stopping();

    let id = self.id.clone();
    let delay = self.delay.clone();
    let sender = self.sender.clone();
    let flag = self.flag.clone();
    thread::spawn(move || {
      thread::sleep(delay);
      sender.send(format!("Service {} STOPPED", id).to_string()).unwrap();

      flag.stopped();
    });
  }

  fn await_stopped(&mut self) {
    while !self.flag.is_stopped() {}
  }

}

#[test]
fn should_start_then_stop() {
  let (sender, receiver) = bounded(2);
  let mut sm = ServiceManager::new();
  let sa_delay = 1000;
  let sb_delay = 2000;

  sm.register(Box::new(ExampleService::new("SA".to_string(), Duration::from_millis(sa_delay), sender.clone())));
  sm.register(Box::new(ExampleService::new("SB".to_string(), Duration::from_millis(sb_delay), sender.clone())));

  let now = Instant::now();
  sm.start();
  sm.await_started();
  let start_time = now.elapsed().as_millis();
  assert!(start_time >= sb_delay as u128);
  assert!(start_time < (sb_delay + sa_delay) as u128);
  assert_eq!("Service SA STARTED", receiver.recv().unwrap());
  assert_eq!("Service SB STARTED", receiver.recv().unwrap());

  let now = Instant::now();
  sm.stop();
  sm.await_stopped();
  let stop_time = now.elapsed().as_millis();
  assert!(stop_time >= sb_delay as u128);
  assert!(start_time < (sb_delay + sa_delay) as u128);
  assert_eq!("Service SA STOPPED", receiver.recv().unwrap());
  assert_eq!("Service SB STOPPED", receiver.recv().unwrap());
}

#[test]
fn should_start_and_await_then_stop_and_await() {
  let (sender, receiver) = bounded(2);
  let mut sm = ServiceManager::new();
  let sa_delay = 1000;
  let sb_delay = 2000;

  sm.register(Box::new(ExampleService::new("SA".to_string(), Duration::from_millis(sa_delay), sender.clone())));
  sm.register(Box::new(ExampleService::new("SB".to_string(), Duration::from_millis(sb_delay), sender.clone())));

  let now = Instant::now();
  sm.start_and_await();
  assert!(now.elapsed().as_millis() >= (sa_delay + sb_delay) as u128);
  assert_eq!("Service SA STARTED", receiver.recv().unwrap());
  assert_eq!("Service SB STARTED", receiver.recv().unwrap());

  let now = Instant::now();
  sm.stop_and_await();
  assert!(now.elapsed().as_millis() >= (sa_delay + sb_delay) as u128);
  assert_eq!("Service SB STOPPED", receiver.recv().unwrap());
  assert_eq!("Service SA STOPPED", receiver.recv().unwrap());
}