gsp/
signal.rs

1//! GSP signal codec. Six CBOR keys.
2
3use gbp::CodecError;
4use gbp_core::PayloadCodec;
5use serde::{Deserialize, Serialize};
6use serde_bytes::ByteBuf;
7
8/// GSP signal envelope. `args` carries opcode-specific CBOR bytes.
9#[derive(Clone, Debug, Serialize, Deserialize)]
10pub struct GspSignal {
11    /// `SignalType` widened to `u32` for CBOR uint compatibility.
12    #[serde(rename = "t")]
13    pub signal_type: u32,
14    /// Request identifier (echoed in ACK / NACK and used for deduplication).
15    #[serde(rename = "rid")]
16    pub request_id: u32,
17    /// Sender member id.
18    #[serde(rename = "sid")]
19    pub sender_id: u32,
20    /// Role claim (used by `ROLE_CHANGE`).
21    #[serde(rename = "rc")]
22    pub role_claim: u32,
23    /// Declared length of [`args`](Self::args).
24    #[serde(rename = "alen")]
25    pub args_length: u32,
26    /// Opcode-specific CBOR-encoded arguments.
27    #[serde(rename = "args")]
28    pub args: ByteBuf,
29}
30
31impl GspSignal {
32    /// Builds a signal with no arguments.
33    pub fn bare(signal_type: u32, request_id: u32, sender_id: u32) -> Self {
34        Self {
35            signal_type,
36            request_id,
37            sender_id,
38            role_claim: 0,
39            args_length: 0,
40            args: ByteBuf::new(),
41        }
42    }
43
44    /// CBOR-encodes the signal.
45    pub fn to_cbor(&self) -> Vec<u8> {
46        let mut buf = Vec::new();
47        ciborium::into_writer(self, &mut buf).expect("cbor encode");
48        buf
49    }
50
51    /// Decodes a CBOR-encoded signal and validates `args_length`.
52    pub fn from_cbor(data: &[u8]) -> Result<Self, CodecError> {
53        let s: Self = ciborium::from_reader(data).map_err(|e| CodecError::Decode(e.to_string()))?;
54        if s.args_length as usize != s.args.len() {
55            return Err(CodecError::PayloadSizeMismatch);
56        }
57        Ok(s)
58    }
59
60    /// Encodes using the given codec.
61    pub fn to_bytes(&self, codec: PayloadCodec) -> Vec<u8> {
62        match codec {
63            PayloadCodec::Cbor => self.to_cbor(),
64            PayloadCodec::Protobuf => {
65                use prost::Message as _;
66                gbp_proto::gsp::GspSignal::from(self).encode_to_vec()
67            }
68            PayloadCodec::FlatBuffers => {
69                let mut b = gbp_flat::planus::Builder::new();
70                b.finish(gbp_flat::gsp::GspSignal::from(self), None).to_vec()
71            }
72        }
73    }
74
75    /// Decodes from the given codec.
76    pub fn from_bytes(data: &[u8], codec: PayloadCodec) -> Result<Self, CodecError> {
77        match codec {
78            PayloadCodec::Cbor => Self::from_cbor(data),
79            PayloadCodec::Protobuf => {
80                use prost::Message as _;
81                let p = gbp_proto::gsp::GspSignal::decode(data)
82                    .map_err(|e| CodecError::Decode(e.to_string()))?;
83                Self::try_from(p).map_err(|_| CodecError::PayloadSizeMismatch)
84            }
85            PayloadCodec::FlatBuffers => {
86                use gbp_flat::planus::ReadAsRoot as _;
87                let r = gbp_flat::gsp::GspSignalRef::read_as_root(data)
88                    .map_err(|e| CodecError::Decode(e.to_string()))?;
89                Self::try_from(r).map_err(|_| CodecError::PayloadSizeMismatch)
90            }
91        }
92    }
93}
94
95// ── Proto conversions ─────────────────────────────────────────────────────────
96
97impl From<&GspSignal> for gbp_proto::gsp::GspSignal {
98    fn from(s: &GspSignal) -> Self {
99        Self {
100            signal_type: s.signal_type,
101            request_id: s.request_id,
102            sender_id: s.sender_id,
103            role_claim: s.role_claim,
104            args_length: s.args_length,
105            args: s.args.to_vec(),
106        }
107    }
108}
109
110impl TryFrom<gbp_proto::gsp::GspSignal> for GspSignal {
111    type Error = ();
112    fn try_from(p: gbp_proto::gsp::GspSignal) -> Result<Self, ()> {
113        if p.args_length as usize != p.args.len() {
114            return Err(());
115        }
116        Ok(Self {
117            signal_type: p.signal_type,
118            request_id: p.request_id,
119            sender_id: p.sender_id,
120            role_claim: p.role_claim,
121            args_length: p.args_length,
122            args: ByteBuf::from(p.args),
123        })
124    }
125}
126
127// ── FlatBuffers conversions ───────────────────────────────────────────────────
128
129impl From<&GspSignal> for gbp_flat::gsp::GspSignal {
130    fn from(s: &GspSignal) -> Self {
131        Self {
132            signal_type: s.signal_type,
133            request_id: s.request_id,
134            sender_id: s.sender_id,
135            role_claim: s.role_claim,
136            args_length: s.args_length,
137            args: if s.args.is_empty() {
138                None
139            } else {
140                Some(s.args.to_vec())
141            },
142        }
143    }
144}
145
146impl<'a> TryFrom<gbp_flat::gsp::GspSignalRef<'a>> for GspSignal {
147    type Error = ();
148    fn try_from(r: gbp_flat::gsp::GspSignalRef<'a>) -> Result<Self, ()> {
149        let args = r.args().map_err(|_| ())?.unwrap_or(&[]).to_vec();
150        let args_length = r.args_length().map_err(|_| ())?;
151        if args_length as usize != args.len() {
152            return Err(());
153        }
154        Ok(Self {
155            signal_type: r.signal_type().map_err(|_| ())?,
156            request_id: r.request_id().map_err(|_| ())?,
157            sender_id: r.sender_id().map_err(|_| ())?,
158            role_claim: r.role_claim().map_err(|_| ())?,
159            args_length,
160            args: ByteBuf::from(args),
161        })
162    }
163}
164
165#[cfg(test)]
166mod tests {
167    use super::*;
168
169    fn sample() -> GspSignal {
170        GspSignal::bare(1, 99, 5)
171    }
172
173    #[test]
174    fn cbor_roundtrip() {
175        let orig = sample();
176        let bytes = orig.to_bytes(PayloadCodec::Cbor);
177        let decoded = GspSignal::from_bytes(&bytes, PayloadCodec::Cbor).unwrap();
178        assert_eq!(decoded.signal_type, orig.signal_type);
179        assert_eq!(decoded.request_id, orig.request_id);
180        assert_eq!(decoded.sender_id, orig.sender_id);
181    }
182
183    #[test]
184    fn protobuf_roundtrip() {
185        let orig = sample();
186        let bytes = orig.to_bytes(PayloadCodec::Protobuf);
187        let decoded = GspSignal::from_bytes(&bytes, PayloadCodec::Protobuf).unwrap();
188        assert_eq!(decoded.signal_type, orig.signal_type);
189        assert_eq!(decoded.request_id, orig.request_id);
190        assert_eq!(decoded.sender_id, orig.sender_id);
191    }
192
193    #[test]
194    fn flatbuffers_roundtrip() {
195        let orig = sample();
196        let bytes = orig.to_bytes(PayloadCodec::FlatBuffers);
197        let decoded = GspSignal::from_bytes(&bytes, PayloadCodec::FlatBuffers).unwrap();
198        assert_eq!(decoded.signal_type, orig.signal_type);
199        assert_eq!(decoded.request_id, orig.request_id);
200        assert_eq!(decoded.sender_id, orig.sender_id);
201    }
202
203    #[test]
204    fn codec_bytes_differ() {
205        let sig = sample();
206        let cbor = sig.to_bytes(PayloadCodec::Cbor);
207        let proto = sig.to_bytes(PayloadCodec::Protobuf);
208        let flat = sig.to_bytes(PayloadCodec::FlatBuffers);
209        assert_ne!(cbor, proto);
210        assert_ne!(cbor, flat);
211        assert_ne!(proto, flat);
212    }
213}
gsp/signal.rs

gsp/
signal.rs
