liminal-server 0.3.1

Standalone server for the liminal messaging bus
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

//! Checked big-endian primitives for the Unit 2 canonical codec.

use super::super::OutboxLogError;

pub(super) struct Encoder {
    bytes: Vec<u8>,
}

impl Encoder {
    pub(super) const fn new() -> Self {
        Self { bytes: Vec::new() }
    }

    pub(super) fn u8(&mut self, value: u8) {
        self.bytes.push(value);
    }

    fn u32(&mut self, value: u32) {
        self.bytes.extend_from_slice(&value.to_be_bytes());
    }

    pub(super) fn u64(&mut self, value: u64) {
        self.bytes.extend_from_slice(&value.to_be_bytes());
    }

    pub(super) fn length(
        &mut self,
        field: &'static str,
        length: usize,
    ) -> Result<(), OutboxLogError> {
        let value =
            u32::try_from(length).map_err(|_| OutboxLogError::LengthOverflow { field, length })?;
        self.u32(value);
        Ok(())
    }

    pub(super) fn bytes(&mut self, value: &[u8]) {
        self.bytes.extend_from_slice(value);
    }

    pub(super) fn finish(self) -> Vec<u8> {
        self.bytes
    }
}

pub(super) struct Decoder<'a> {
    input: &'a [u8],
    offset: usize,
}

impl<'a> Decoder<'a> {
    pub(super) const fn new(input: &'a [u8]) -> Self {
        Self { input, offset: 0 }
    }

    fn take(&mut self, field: &'static str, length: usize) -> Result<&'a [u8], OutboxLogError> {
        let end = self
            .offset
            .checked_add(length)
            .ok_or(OutboxLogError::UnexpectedEnd { field })?;
        let bytes = self
            .input
            .get(self.offset..end)
            .ok_or(OutboxLogError::UnexpectedEnd { field })?;
        self.offset = end;
        Ok(bytes)
    }

    pub(super) fn u8(&mut self, field: &'static str) -> Result<u8, OutboxLogError> {
        let bytes = self.take(field, 1)?;
        bytes
            .first()
            .copied()
            .ok_or(OutboxLogError::UnexpectedEnd { field })
    }

    fn u32(&mut self, field: &'static str) -> Result<u32, OutboxLogError> {
        let bytes = self.take(field, 4)?;
        let mut value = [0_u8; 4];
        value.copy_from_slice(bytes);
        Ok(u32::from_be_bytes(value))
    }

    pub(super) fn u64(&mut self, field: &'static str) -> Result<u64, OutboxLogError> {
        let bytes = self.take(field, 8)?;
        let mut value = [0_u8; 8];
        value.copy_from_slice(bytes);
        Ok(u64::from_be_bytes(value))
    }

    pub(super) fn length(&mut self, field: &'static str) -> Result<usize, OutboxLogError> {
        usize::try_from(self.u32(field)?).map_err(|_| OutboxLogError::LengthOverflow {
            field,
            length: usize::MAX,
        })
    }

    pub(super) fn bytes(
        &mut self,
        field: &'static str,
        length: usize,
    ) -> Result<&'a [u8], OutboxLogError> {
        self.take(field, length)
    }

    pub(super) const fn finish(self) -> Result<(), OutboxLogError> {
        let remaining = self.input.len().saturating_sub(self.offset);
        if remaining == 0 {
            Ok(())
        } else {
            Err(OutboxLogError::TrailingBytes { remaining })
        }
    }
}