discret 0.6.2

A backend to create peer to peer (P2P) applications, using a GraphQL inspired syntax
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

use std::sync::Arc;

use serde::{Deserialize, Serialize};

use crate::{
    database::{node::Node, room::Room},
    security::{self, Uid},
};
use thiserror::Error;
pub mod peer_inbound_service;
pub mod peer_outbound_service;
pub mod room_locking_service;

#[derive(Serialize, Deserialize, Debug, Error)]
pub enum Error {
    #[error("Authorisation for Query {0}")]
    Authorisation(String),

    #[error("RemoteTechnical for Query {0}")]
    RemoteTechnical(String),

    #[error("TimeOut ")]
    TimeOut,

    #[error("Parsing")]
    Parsing,

    #[error("Technical")]
    Technical,
}

/// Queries have 10 seconds to returns before closing connection
pub static NETWORK_TIMEOUT_SEC: u64 = 10;

#[derive(Serialize, Deserialize)]
pub enum Query {
    ProveIdentity(Vec<u8>),
    HardwareFingerprint(),
    RoomList,
    RoomDefinition(Uid),
    RoomNode(Uid),
    RoomLog(Uid),
    RoomLogAt(Uid, i64),
    EdgeDeletionLog(Uid, String, i64),
    NodeDeletionLog(Uid, String, i64),
    RoomDailyNodes(Uid, String, i64),
    Nodes(Uid, Vec<Uid>),
    Edges(Uid, Vec<(Uid, i64)>),
    PeersForRoom(Uid),
}

#[derive(Serialize, Deserialize)]
pub struct QueryProtocol {
    pub id: u64,
    pub query: Query,
}

#[derive(Serialize, Deserialize)]
pub struct Answer {
    pub id: u64,
    pub success: bool,
    pub complete: bool,
    pub serialized: Vec<u8>,
}

#[derive(Clone)]
pub enum LocalEvent {
    RoomDefinitionChanged(Arc<Room>),
    RoomDataChanged(Vec<Uid>),
}

#[derive(Serialize, Deserialize)]
pub enum RemoteEvent {
    Ready,            //indicate that this end of the connection is ready to synchronize
    ReadyFingerprint, //indicate that this end of the connection is ready to perform a hardware fingerprint check
    RoomDefinitionChanged(Uid),
    RoomDataChanged(Uid),
}

#[derive(Serialize, Deserialize)]
pub struct IdentityAnswer {
    pub peer: Node,
    pub chall_signature: Vec<u8>,
}
impl IdentityAnswer {
    pub fn verify(&self, challenge: &[u8]) -> Result<(), security::Error> {
        let pub_key = security::import_verifying_key(&self.peer.verifying_key)?;
        pub_key.verify(challenge, &self.chall_signature)?;
        Ok(())
    }
}