confitdb 0.1.4

ConfitDB is an experimental, distributed, real-time database, giving full control on conflict resolution.
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

use crate::server_error::ServerError;
use crate::server_status::ServerStatus;
use tokio::sync::oneshot::{channel, Receiver, Sender};

#[derive(Debug)]
pub struct ServerControl {
    shutdown_sender: Option<Sender<String>>,
    ready_receiver: Option<Receiver<Result<(), ServerError>>>,
    done_receiver: Option<Receiver<Result<(), ServerError>>>,
    pub current_status: ServerStatus,
    pub last_error: Result<(), ServerError>,
}

impl ServerControl {
    pub fn new() -> Self {
        ServerControl {
            shutdown_sender: None,
            ready_receiver: None,
            done_receiver: None,
            current_status: ServerStatus::Stopped,
            last_error: Ok({}),
        }
    }

    pub fn get_ready(
        &mut self,
    ) -> Result<
        (
            Receiver<String>,
            Sender<Result<(), ServerError>>,
            Sender<Result<(), ServerError>>,
        ),
        ServerError,
    > {
        match self.current_status {
            ServerStatus::Stopped => {
                let (shutdown_sender, shutdown_receiver) = channel::<String>();
                let (ready_sender, ready_receiver) = channel::<Result<(), ServerError>>();
                let (done_sender, done_receiver) = channel::<Result<(), ServerError>>();
                self.shutdown_sender = Some(shutdown_sender);
                self.ready_receiver = Some(ready_receiver);
                self.done_receiver = Some(done_receiver);
                self.last_error = Ok({});
                self.current_status = ServerStatus::Bootstrapping;
                Ok((shutdown_receiver, ready_sender, done_sender))
            }
            other => Err(ServerError::new(
                format!("invalid status {}", other).as_str(),
            )),
        }
    }

    pub fn stop(&mut self, msg: &str) -> Result<(), ServerError> {
        match self.current_status {
            ServerStatus::Running => {
                self.current_status = ServerStatus::Terminating;
                let ss = self.shutdown_sender.take().unwrap();
                ss.send(msg.to_string()).unwrap();
                Ok(())
            }
            other => Err(ServerError::new(
                format!("invalid status {}", other).as_str(),
            )),
        }
    }

    pub fn update_status(&mut self) {
        match self.current_status {
            ServerStatus::Stopped => {}
            ServerStatus::Bootstrapping => {
                let mut trier = self.ready_receiver.take();
                match &mut trier {
                    Some(tr) => match &tr.try_recv() {
                        Ok(e) => match e {
                            Ok(()) => {
                                self.current_status = ServerStatus::Running;
                            }
                            Err(ref err) => {
                                self.last_error = Err(err.clone());
                                self.current_status = ServerStatus::Stopped;
                            }
                        },
                        Err(_) => (),
                    },
                    None => {}
                }
                self.ready_receiver = trier;
            }
            ServerStatus::Running => {}
            ServerStatus::Terminating => {
                let mut trier = self.done_receiver.take();
                match &mut trier {
                    Some(tr) => match &tr.try_recv() {
                        Ok(e) => {
                            match e {
                                Ok(()) => (),
                                Err(ref err) => {
                                    self.last_error = Err(err.clone());
                                }
                            }
                            self.current_status = ServerStatus::Stopped;
                        }
                        Err(_) => (),
                    },
                    None => {}
                }
                self.done_receiver = trier;
            }
        }
    }
}