sierradb-server 0.2.3

SierraDB server - distributed event store server with Redis RESP3 protocol
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

use combine::Parser;
use indexmap::indexmap;
use libp2p::PeerId;
use redis_protocol::resp3::types::BytesFrame;

use crate::parser::{FrameStream, number_i64};
use crate::request::{HandleRequest, blob_str, map, number};
use crate::server::Conn;

pub struct Hello {
    pub version: i64,
}

impl Hello {
    pub fn parser<'a>() -> impl Parser<FrameStream<'a>, Output = Hello> + 'a {
        number_i64().map(|version| Hello { version })
    }
}

impl HandleRequest for Hello {
    type Error = String;
    type Ok = HelloResp;

    async fn handle_request(self, conn: &mut Conn) -> Result<Option<Self::Ok>, Self::Error> {
        if self.version != 3 {
            return Err(format!(
                "unsupported version {}, only 3 is supported",
                self.version
            ));
        }

        Ok(Some(HelloResp {
            server: "sierradb",
            version: env!("CARGO_PKG_VERSION"),
            peer_id: *conn.cluster_ref.id().peer_id().unwrap(),
            num_partitions: conn.num_partitions,
        }))
    }
}

pub struct HelloResp {
    server: &'static str,
    version: &'static str,
    peer_id: PeerId,
    num_partitions: u16,
}

impl From<HelloResp> for BytesFrame {
    fn from(resp: HelloResp) -> Self {
        map(indexmap! {
            blob_str("server") => blob_str(resp.server),
            blob_str("version") => blob_str(resp.version),
            blob_str("peer_id") => blob_str(resp.peer_id.to_base58()),
            blob_str("num_partitions") => number(resp.num_partitions.into()),
        })
    }
}