risq 0.4.1

Re-implementation of Bisq (https://github.com/bisq-network/bisq) in rust
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

use super::{bootstrap::BootstrapState, connection::ConnectionId};
use crate::bisq::NodeAddress;
use std::{
    collections::HashMap,
    sync::{Arc, RwLock, RwLockReadGuard},
    time::SystemTime,
};

#[derive(Clone)]
pub struct ConnectionStatus {
    pub addr: Option<NodeAddress>,
    pub alive_at: SystemTime,
}

#[derive(Clone)]
pub struct Status {
    bootstrap_state: Arc<RwLock<BootstrapState>>,
    connections: Arc<RwLock<HashMap<ConnectionId, ConnectionStatus>>>,
}

impl Status {
    pub fn new(bootstrap_state: Arc<RwLock<BootstrapState>>) -> Self {
        Self {
            bootstrap_state,
            connections: Arc::new(RwLock::new(HashMap::new())),
        }
    }
    pub fn bootstrap_state(&self) -> BootstrapState {
        *self
            .bootstrap_state
            .read()
            .expect("Corrupted lock in status")
    }

    pub fn connections(&self) -> RwLockReadGuard<HashMap<ConnectionId, ConnectionStatus>> {
        self.connections.read().expect("Corrupted lock in status")
    }

    pub fn connection_added(&mut self, id: ConnectionId, addr: Option<NodeAddress>) {
        self.connections
            .write()
            .expect("Corrupted lock in status")
            .insert(
                id,
                ConnectionStatus {
                    addr,
                    alive_at: SystemTime::now(),
                },
            );
    }

    pub fn connection_removed(&mut self, id: &ConnectionId) {
        self.connections
            .write()
            .expect("Corrupted lock in status")
            .remove(id);
    }

    pub fn connection_identified(&mut self, id: &ConnectionId, addr: &NodeAddress) {
        let mut connections = self.connections.write().expect("Corrupted lock in status");
        let status = connections.get_mut(id).expect("Connection not in status");
        if status.addr.is_none() {
            status.addr = Some(addr.to_owned());
        }
        status.alive_at = SystemTime::now();
    }

    pub fn connection_alive(&mut self, id: &ConnectionId, at: SystemTime) {
        self.connections
            .write()
            .expect("Corrupted lock in status")
            .get_mut(id)
            .expect("Connection not in status")
            .alive_at = at;
    }
}