dbeel 0.1.0

dbeel is a fast and minimal distributed thread-per-core document database.
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
121

use async_channel::Sender;
use serde::{Deserialize, Serialize};
use time::OffsetDateTime;

use crate::{
    error::{Error, ErrorKind},
    gossip::GossipEvent,
    storage_engine::EntryValue,
};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ShardEvent {
    Gossip(GossipEvent),
    Set(String, Vec<u8>, Vec<u8>, OffsetDateTime),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ShardRequest {
    Ping,
    GetMetadata,
    GetCollections,
    CreateCollection(String, u16),
    DropCollection(String),
    Set(String, Vec<u8>, Vec<u8>, OffsetDateTime),
    Delete(String, Vec<u8>, OffsetDateTime),
    Get(String, Vec<u8>),
}

#[derive(Clone, Serialize, Deserialize, Debug, PartialEq, Eq)]
pub struct NodeMetadata {
    pub name: String,
    pub ip: String,
    pub remote_shard_base_port: u16,
    pub ids: Vec<u16>,
    pub gossip_port: u16,
    pub db_port: u16,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ShardResponse {
    Pong,
    GetMetadata(Vec<NodeMetadata>),
    GetCollections(Vec<(String, u16)>),
    CreateCollection,
    DropCollection,
    Set,
    Delete,
    Get(Option<EntryValue>),
    Error(ErrorKind, String),
}

impl ShardResponse {
    pub fn new_err(e: &Error) -> Self {
        Self::Error(e.kind(), e.to_string())
    }
}

/// Map a `ShardResponse` with a value to Result<T>.
/// Must also import `ShardResponse` to compile.
#[macro_export]
macro_rules! response_to_result {
    ($response:expr, $identifier:path) => {
        match $response {
            $identifier(inner_value) => Ok(inner_value),
            ShardResponse::Error(kind, e) => Err(Error::ResponseError(kind, e)),
            _ => Err(Error::ResponseWrongType),
        }
    };
}

/// Map a `ShardResponse` with no value to Result<()>.
/// Must also import `ShardResponse` to compile.
#[macro_export]
macro_rules! response_to_empty_result {
    ($response:expr, $identifier:path) => {
        match $response {
            $identifier => Ok(()),
            ShardResponse::Error(kind, e) => Err(Error::ResponseError(kind, e)),
            _ => Err(Error::ResponseWrongType),
        }
    };
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ShardMessage {
    Event(ShardEvent),
    Request(ShardRequest),
    Response(ShardResponse),
}

/// A packet that is sent between local shards.
#[derive(Debug)]
pub struct ShardPacket {
    pub source_id: u16,
    pub message: ShardMessage,
    pub response_sender: Option<Sender<ShardResponse>>,
}

impl ShardPacket {
    #[must_use]
    pub fn new(id: u16, message: ShardMessage) -> Self {
        Self {
            source_id: id,
            message,
            response_sender: None,
        }
    }

    #[must_use]
    pub fn new_request(
        id: u16,
        message: ShardMessage,
        sender: Sender<ShardResponse>,
    ) -> Self {
        Self {
            source_id: id,
            message,
            response_sender: Some(sender),
        }
    }
}