foxglove 0.18.0

Foxglove SDK
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

use std::borrow::Cow;

use bytes::{Buf, BufMut};

use crate::protocol::{BinaryMessage, BinaryPayload, ParseError};

/// Service call response message.
///
/// Spec: <https://github.com/foxglove/ws-protocol/blob/main/docs/spec.md#service-call-response>
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ServiceCallResponse<'a> {
    /// Service ID.
    pub service_id: u32,
    /// Call ID.
    pub call_id: u32,
    /// Encoding.
    pub encoding: Cow<'a, str>,
    /// Payload.
    pub payload: Cow<'a, [u8]>,
}

impl ServiceCallResponse<'_> {
    /// Gives the message a static lifetime by cloning borrowed references.
    pub fn into_owned(self) -> ServiceCallResponse<'static> {
        ServiceCallResponse {
            service_id: self.service_id,
            call_id: self.call_id,
            encoding: Cow::Owned(self.encoding.into_owned()),
            payload: Cow::Owned(self.payload.into_owned()),
        }
    }
}

impl<'a> BinaryPayload<'a> for ServiceCallResponse<'a> {
    fn parse_payload(mut data: &'a [u8]) -> Result<Self, ParseError> {
        if data.len() < 4 + 4 + 4 {
            return Err(ParseError::BufferTooShort);
        }
        let service_id = data.get_u32_le();
        let call_id = data.get_u32_le();
        let encoding_len = data.get_u32_le() as usize;
        if data.len() < encoding_len {
            return Err(ParseError::BufferTooShort);
        }
        let encoding = Cow::Borrowed(std::str::from_utf8(&data[..encoding_len])?);
        data.advance(encoding_len);
        Ok(Self {
            service_id,
            call_id,
            encoding,
            payload: Cow::Borrowed(data),
        })
    }

    fn payload_size(&self) -> usize {
        4 + 4 + 4 + self.encoding.len() + self.payload.len()
    }

    fn write_payload(&self, buf: &mut impl BufMut) {
        buf.put_u32_le(self.service_id);
        buf.put_u32_le(self.call_id);
        buf.put_u32_le(self.encoding.len() as u32);
        buf.put_slice(self.encoding.as_bytes());
        buf.put_slice(&self.payload);
    }
}

impl<'a> BinaryMessage<'a> for ServiceCallResponse<'a> {
    const OPCODE: u8 = 3;
}

#[cfg(test)]
mod tests {
    use assert_matches::assert_matches;

    use super::*;

    fn message() -> ServiceCallResponse<'static> {
        ServiceCallResponse {
            service_id: 10,
            call_id: 12,
            encoding: "json".into(),
            payload: br#"{"key": "value"}"#.into(),
        }
    }

    #[test]
    fn test_parse() {
        assert_matches!(
            ServiceCallResponse::parse_payload(b""),
            Err(ParseError::BufferTooShort)
        );
        assert_matches!(
            ServiceCallResponse::parse_payload(&[0; 11]),
            Err(ParseError::BufferTooShort)
        );
        let mut buf = Vec::new();
        buf.put_u32_le(10);
        buf.put_u32_le(12);
        buf.put_u32_le(1);
        assert_matches!(
            ServiceCallResponse::parse_payload(&buf),
            Err(ParseError::BufferTooShort)
        );
    }

    #[test]
    fn test_roundtrip() {
        let orig = message();
        let mut buf = Vec::new();
        BinaryPayload::write_payload(&orig, &mut buf);
        let parsed = ServiceCallResponse::parse_payload(&buf).unwrap();
        assert_eq!(parsed, orig);
    }
}