sparkles-core 0.1.8

Core crate for sparkles
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

use sha2_const_stable::Sha256;
use crate::protocol::headers::{LocalPacketHeader, SparklesMachineInfo};
use crate::protocol::sender::Sender;

#[derive(Copy, Clone, Debug, PartialEq)]
#[repr(u8)]
pub enum PacketType {
    MachineInfo,
    DataBytes,
    FailedPages,
    TimestampFreq,
    GracefulShutdown,
    ConnectionAccepted,
}

impl PacketType {
    /// This string is used to calculate hash of the packet type
    pub const fn get_str(&self) -> &str {
        match self {
            PacketType::MachineInfo => "MachineInfo",
            PacketType::DataBytes => "DataBytes",
            PacketType::FailedPages => "FailedPages",
            PacketType::TimestampFreq => "TimestampFreq",
            PacketType::GracefulShutdown => "GracefulShutdown",
            PacketType::ConnectionAccepted => "ConnectionAccepted",
        }
    }
    pub const fn pattern(&self) -> [u8; 32] {
        let str = self.get_str();
        Sha256::new().update(str.as_bytes()).finalize()
    }
    
    pub fn try_from_pattern(pattern: &[u8]) -> Option<Self> {
        if pattern == Self::MachineInfo.pattern() {
            Some(Self::MachineInfo)
        }
        else if pattern == Self::DataBytes.pattern() {
            Some(Self::DataBytes)
        }
        else if pattern == Self::FailedPages.pattern() {
            Some(Self::FailedPages)
        }
        else if pattern == Self::TimestampFreq.pattern() {
            Some(Self::TimestampFreq)
        }
        else if pattern == Self::GracefulShutdown.pattern() {
            Some(Self::GracefulShutdown)
        }
        else if pattern == Self::ConnectionAccepted.pattern() {
            Some(Self::ConnectionAccepted)
        }
        else {
            None
        }
    }
}

#[derive(Copy, Clone, Debug)]
#[repr(u8)]
pub enum RequestPacketType {
    Subscribe,
}
impl RequestPacketType {
    pub const fn get_str(&self) -> &str {
        match self {
            RequestPacketType::Subscribe => "Subscribe",
        }
    }
    pub const fn pattern(&self) -> [u8; 32] {
        let str = self.get_str();
        Sha256::new().update(str.as_bytes()).finalize()
    }
}
pub fn send_machine_info(sender: &mut impl Sender, sparkles_encoder_info: SparklesMachineInfo) {
    let encoded_info = bincode::encode_to_vec(&sparkles_encoder_info, bincode::config::standard()).unwrap();
    sender.send_packet(PacketType::MachineInfo, &[&encoded_info]);
}
pub fn send_trace_data(sender: &mut impl Sender, slice1: &[u8], slice2: &[u8]) {
    sender.send_packet(PacketType::DataBytes, &[slice1, slice2]);
}

pub fn send_failed_pages(sender: &mut impl Sender, failed_pages: &[LocalPacketHeader]) {
    let header = bincode::encode_to_vec(failed_pages, bincode::config::standard()).unwrap();
    sender.send_packet(PacketType::FailedPages, &[&header]);
}
pub fn send_timestamp_freq(sender: &mut impl Sender, ticks_per_sec: u64, cur_tm: u64) {
    let freq_bytes = ticks_per_sec.to_be_bytes();
    let tm_bytes = cur_tm.to_be_bytes();
    sender.send_packet(PacketType::TimestampFreq, &[&freq_bytes, &tm_bytes]);
}
pub fn send_graceful_shutdown(sender: &mut impl Sender) {
    sender.send_packet(PacketType::GracefulShutdown, &[]);
}