pollination 0.1.0

An experimental library exposing hybrid Raft and CRDT primitives.
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

use serde::{Deserialize, Serialize};
use std::fmt;
use uuid::Uuid;

#[derive(Clone, Debug, Serialize, Deserialize)]
pub(crate) struct PeerInfo<A> {
    pub uuid: Uuid,
    pub addr: Option<A>,
    pub status: PeerStatus,
    // topics: Vec<Topic>,
}

impl<A> PeerInfo<A> {
    pub(crate) fn new(uuid: Uuid, addr: A) -> Self {
        Self {
            addr: Some(addr),
            status: PeerStatus::Healthy,
            uuid,
        }
    }

    pub(crate) fn dead() -> Self {
        Self {
            addr: None,
            status: PeerStatus::Dead,
            uuid: Uuid::from_u128(0),
        }
    }
}

impl<A: fmt::Display> fmt::Display for PeerInfo<A> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
        write!(
            f,
            "UUID:{}, STATUS:{}, ADDR:{}",
            self.uuid,
            self.status,
            if let Some(addr) = &self.addr {
                format!("{addr}")
            } else {
                "?".to_string()
            }
        )
    }
}

#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq)]
pub enum PeerStatus {
    Healthy,
    Dead,
}

impl fmt::Display for PeerStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
        use PeerStatus::*;
        write!(
            f,
            "{}",
            match self {
                Healthy => "Healthy",
                Dead => "Dead",
            }
        )
    }
}