tokio_thrift/protocol/
binary_protocol.rs

1use super::{Serializer, Deserializer, ThriftSerializer, ThriftField, ThriftMessage, ThriftDeserializer, ThriftMessageType, ThriftType, Error};
2use transport::{VoidTransport, ReadTransport, WriteTransport};
3use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
4use std::iter;
5
6#[allow(overflowing_literals)]
7pub const THRIFT_VERSION_1: i32 = 0x80010000;
8#[allow(overflowing_literals)]
9pub const THRIFT_VERSION_MASK: i32 = 0xffff0000;
10#[allow(overflowing_literals)]
11pub const THRIFT_TYPE_MASK: i32 = 0x000000ff;
12
13pub struct BinaryProtocol<T>{
14    inner: T
15}
16
17impl <T>BinaryProtocol<T> {
18    pub fn into_inner(self) -> T {
19        self.inner
20    }
21}
22
23impl <T: VoidTransport>BinaryProtocol<T> {
24    pub fn new(inner: T) -> Self {
25        BinaryProtocol{
26            inner: inner,
27        }
28    }
29}
30
31impl <T: VoidTransport>From<T> for BinaryProtocol<T> {
32    fn from(w: T) -> Self {
33        Self::new(w)
34    }
35}
36
37impl <T: WriteTransport> Serializer for BinaryProtocol<T> {
38
39    fn serialize_bool(&mut self, val: bool) -> Result<(), Error> {
40        if val {
41            self.serialize_i8(1)
42        } else {
43            self.serialize_i8(0)
44        }
45    }
46
47    fn serialize_usize(&mut self, val: usize) -> Result<(), Error> {
48        self.serialize_isize(val as isize)
49    }
50
51    fn serialize_isize(&mut self, val: isize) -> Result<(), Error> {
52        self.serialize_i64(val as i64)
53    }
54
55    fn serialize_u64(&mut self, val: u64) -> Result<(), Error> {
56        self.serialize_i64(val as i64)
57    }
58
59    fn serialize_i64(&mut self, val: i64) -> Result<(), Error> {
60        try!(self.inner.write_i64::<BigEndian>(val));
61        Ok(())
62    }
63
64    fn serialize_u32(&mut self, val: u32) -> Result<(), Error> {
65        self.serialize_i32(val as i32)
66    }
67
68    fn serialize_i32(&mut self, val: i32) -> Result<(), Error> {
69        try!(self.inner.write_i32::<BigEndian>(val));
70        Ok(())
71    }
72
73    fn serialize_u16(&mut self, val: u16) -> Result<(), Error> {
74        self.serialize_i16(val as i16)
75    }
76
77    fn serialize_i16(&mut self, val: i16) -> Result<(), Error> {
78        try!(self.inner.write_i16::<BigEndian>(val));
79        Ok(())
80    }
81
82    fn serialize_u8(&mut self, val: u8) -> Result<(), Error> {
83        self.serialize_i8(val as i8)
84    }
85
86    fn serialize_i8(&mut self, val: i8) -> Result<(), Error> {
87        try!(self.inner.write_i8(val));
88        Ok(())
89    }
90
91    fn serialize_f64(&mut self, val: f64) -> Result<(), Error> {
92        try!(self.inner.write_f64::<BigEndian>(val));
93        Ok(())
94    }
95
96    fn serialize_bytes(&mut self, val: &[u8]) -> Result<(), Error> {
97        try!(self.serialize_i32(val.len() as i32));
98        try!(self.inner.write(val));
99        Ok(())
100    }
101
102    fn serialize_str(&mut self, val: &str) -> Result<(), Error> {
103        self.serialize_bytes(val.as_bytes())
104    }
105
106    fn serialize_string(&mut self, val: String) -> Result<(), Error> {
107        self.serialize_str(&*val)
108    }
109}
110
111impl <T: WriteTransport>ThriftSerializer for BinaryProtocol<T> {
112    fn write_message_begin(&mut self, name: &str, message_type: ThriftMessageType) -> Result<(), Error> {
113        let version = THRIFT_VERSION_1 | message_type as i32;
114
115        try!(self.serialize_i32(version));
116        try!(self.serialize_str(name));
117        try!(self.serialize_i16(0));
118
119        Ok(())
120    }
121
122    fn write_struct_begin(&mut self, _name: &str) -> Result<(), Error> {
123        Ok(())
124    }
125
126    fn write_struct_end(&mut self) -> Result<(), Error> {
127        Ok(())
128    }
129
130    fn write_field_begin(&mut self, _name: &str, ty: ThriftType, id: i16) -> Result<(), Error> {
131        try!(self.serialize_i8(ty as i8));
132        try!(self.serialize_i16(id));
133        Ok(())
134    }
135
136    fn write_field_end(&mut self) -> Result<(), Error> {
137        Ok(())
138    }
139
140    fn write_field_stop(&mut self) -> Result<(), Error> {
141        try!(self.serialize_i8(ThriftType::Stop as i8));
142        Ok(())
143    }
144
145    fn write_message_end(&mut self) -> Result<(), Error> {
146        Ok(())
147    }
148}
149
150
151
152impl<T: ReadTransport> Deserializer for BinaryProtocol<T> {
153    fn deserialize_bool(&mut self) -> Result<bool, Error> {
154        Ok(try!(self.inner.read_i8()) != 0)
155    }
156
157    fn deserialize_usize(&mut self) -> Result<usize, Error> {
158        Ok(try!(self.deserialize_isize()) as usize)
159    }
160
161    fn deserialize_isize(&mut self) -> Result<isize, Error> {
162        Ok(try!(self.deserialize_i64()) as isize)
163    }
164
165    fn deserialize_u64(&mut self) -> Result<u64, Error> {
166        Ok(try!(self.deserialize_i64()) as u64)
167    }
168
169    fn deserialize_i64(&mut self) -> Result<i64, Error> {
170        Ok(try!(self.inner.read_i64::<BigEndian>()))
171    }
172
173    fn deserialize_u32(&mut self) -> Result<u32, Error> {
174        Ok(try!(self.deserialize_i32()) as u32)
175    }
176
177    fn deserialize_i32(&mut self) -> Result<i32, Error> {
178        Ok(try!(self.inner.read_i32::<BigEndian>()))
179    }
180
181    fn deserialize_u16(&mut self) -> Result<u16, Error> {
182        Ok(try!(self.deserialize_i16()) as u16)
183    }
184
185    fn deserialize_i16(&mut self) -> Result<i16, Error> {
186        Ok(try!(self.inner.read_i16::<BigEndian>()))
187    }
188
189    fn deserialize_u8(&mut self) -> Result<u8, Error> {
190        Ok(try!(self.deserialize_i8()) as u8)
191    }
192
193    fn deserialize_i8(&mut self) -> Result<i8, Error> {
194        Ok(try!(self.inner.read_i8()))
195    }
196
197    fn deserialize_f64(&mut self) -> Result<f64, Error> {
198        Ok(try!(self.inner.read_f64::<BigEndian>()))
199    }
200
201
202    fn deserialize_bytes(&mut self) -> Result<Vec<u8>, Error> {
203        let len = try!(self.deserialize_i32()) as usize;
204        let mut buf = Vec::with_capacity(len);
205
206        buf.extend(iter::repeat(0).take(len));
207        try!(self.inner.read(&mut buf));
208
209        Ok(buf)
210    }
211
212    fn deserialize_str(&mut self) -> Result<String, Error> {
213        let buf = try!(self.deserialize_bytes());
214        let s = try!(String::from_utf8(buf));
215        Ok(s)
216    }
217}
218
219impl<T: ReadTransport> ThriftDeserializer for BinaryProtocol<T> {
220    fn read_message_begin(&mut self) -> Result<ThriftMessage, Error> {
221        let size: i32 = try!(self.deserialize_i32());
222
223        if size < 0 {
224            let version = size & THRIFT_VERSION_MASK;
225            if version != THRIFT_VERSION_1 {
226                Err(Error::BadVersion)
227            } else {
228                Ok(ThriftMessage {
229                    name: try!(self.deserialize_str()),
230                    ty: ThriftMessageType::from((size & THRIFT_TYPE_MASK) as i8),
231                    seq: try!(self.deserialize_i16())
232                })
233            }
234        } else {
235            Err(Error::ProtocolVersionMissing)
236        }
237    }
238
239    fn read_message_end(&mut self) -> Result<(), Error> {
240        Ok(())
241    }
242
243    fn read_struct_begin(&mut self) -> Result<String, Error> {
244        Ok("".to_string())
245    }
246
247    fn read_struct_end(&mut self) -> Result<(), Error> {
248        Ok(())
249    }
250
251    fn read_field_begin(&mut self) -> Result<ThriftField, Error> {
252        let mut field = ThriftField {
253            name: None,
254            ty: ThriftType::from(try!(self.deserialize_i8())),
255            seq: 0
256        };
257
258        if field.ty == ThriftType::Stop {
259            Ok(field)
260        } else {
261            field.seq = try!(self.deserialize_i16());
262            Ok(field)
263        }
264    }
265
266    fn read_field_end(&mut self) -> Result<(), Error> {
267        Ok(())
268    }
269}
270
271
272#[cfg(test)]
273mod tests {
274    use std::io::{Cursor, Read, Write};
275    use byteorder::{ReadBytesExt, WriteBytesExt, BigEndian};
276    use protocol::{ThriftMessageType, ThriftType, ThriftMessage, ThriftDeserializer, ThriftSerializer, Serializer, Serialize, Deserializer};
277    use super::*;
278    use ::Deserialize;
279
280
281    #[test]
282    fn deserialize_bool() {
283        let mut de = BinaryProtocol::new(Cursor::new(vec![1u8]));
284        let val: bool = Deserialize::deserialize(&mut de).unwrap();
285        assert_eq!(val, true);
286    }
287
288    #[test]
289    fn deserialize_u16() {
290        let mut buf = Vec::new();
291        buf.write_u16::<BigEndian>(32000);
292        let mut de = BinaryProtocol::new(Cursor::new(buf));
293        let val: u16 = Deserialize::deserialize(&mut de).unwrap();
294        assert_eq!(val, 32000);
295    }
296
297    #[test]
298    fn deserialize_i16() {
299        let mut buf = Vec::new();
300        buf.write_i16::<BigEndian>(-32000);
301        let mut de = BinaryProtocol::new(Cursor::new(buf));
302        let val: i16 = Deserialize::deserialize(&mut de).unwrap();
303        assert_eq!(val, -32000);
304    }
305
306    #[test]
307    fn deserialize_u32() {
308        let mut buf = Vec::new();
309        buf.write_u32::<BigEndian>(32000);
310        let mut de = BinaryProtocol::new(Cursor::new(buf));
311        let val: u32 = Deserialize::deserialize(&mut de).unwrap();
312        assert_eq!(val, 32000);
313    }
314
315    #[test]
316    fn deserialize_i32() {
317        let mut buf = Vec::new();
318        buf.write_i32::<BigEndian>(32000);
319        let mut de = BinaryProtocol::new(Cursor::new(buf));
320        let val: i32 = Deserialize::deserialize(&mut de).unwrap();
321        assert_eq!(val, 32000);
322    }
323
324    #[test]
325    fn deserialize_u64() {
326        let mut buf = Vec::new();
327        buf.write_u64::<BigEndian>(32000);
328        let mut de = BinaryProtocol::new(Cursor::new(buf));
329        let val: u64 = Deserialize::deserialize(&mut de).unwrap();
330        assert_eq!(val, 32000);
331    }
332
333    #[test]
334    fn deserialize_i64() {
335        let mut buf = Vec::new();
336        buf.write_i64::<BigEndian>(32000);
337        let mut de = BinaryProtocol::new(Cursor::new(buf));
338        let val: i64 = Deserialize::deserialize(&mut de).unwrap();
339        assert_eq!(val, 32000);
340    }
341
342    #[test]
343    fn deserialize_f64() {
344        let mut buf = Vec::new();
345        buf.write_f64::<BigEndian>(32000.0);
346        let mut de = BinaryProtocol::new(Cursor::new(buf));
347        let val: f64 = Deserialize::deserialize(&mut de).unwrap();
348        assert_eq!(val, 32000.0);
349    }
350
351    #[test]
352    fn deserialize_string() {
353        let mut buf = Vec::new();
354        let i = "foobar";
355        buf.write_i32::<BigEndian>(i.len() as i32);
356        buf.write(i.as_bytes());
357        let mut de = BinaryProtocol::new(Cursor::new(buf));
358        let val: String = Deserialize::deserialize(&mut de).unwrap();
359        assert_eq!(&*val, "foobar");
360    }
361
362   #[test]
363    fn serialize_bool_true() {
364        let mut v: Vec<u8> = Vec::new();
365        {
366            let mut s = BinaryProtocol::new(&mut v);
367            s.serialize_bool(true);
368        }
369
370        assert_eq!(v[0], 1);
371    }
372
373    #[test]
374    fn serialize_bool_false() {
375        let mut v = Vec::new();
376        {
377            let mut s = BinaryProtocol::new(&mut v);
378            s.serialize_bool(false);
379        }
380
381        assert_eq!(v[0], 0);
382    }
383
384    #[test]
385    fn serialize_i8() {
386        let mut v = Vec::new();
387        {
388            let mut s = BinaryProtocol::new(&mut v);
389            s.serialize_i8(5);
390        }
391
392        assert_eq!(v[0], 5);
393    }
394
395    #[test]
396    fn serialize_i8_neg() {
397        let mut v = Vec::new();
398        {
399            let mut s = BinaryProtocol::new(&mut v);
400            s.serialize_i8(-5);
401        }
402
403        assert_eq!(v[0] as i8, -5);
404    }
405
406    #[test]
407    fn serialize_i16() {
408        let mut v = Vec::new();
409        {
410            let mut s = BinaryProtocol::new(&mut v);
411            s.serialize_i16(900);
412        }
413
414        let mut cursor = Cursor::new(v);
415        assert_eq!(900, cursor.read_i16::<BigEndian>().unwrap());
416    }
417
418    #[test]
419    fn serialize_i16_neg() {
420        let mut v = Vec::new();
421        {
422            let mut s = BinaryProtocol::new(&mut v);
423            s.serialize_i16(-900);
424        }
425
426        let mut cursor = Cursor::new(v);
427        assert_eq!(-900, cursor.read_i16::<BigEndian>().unwrap());
428    }
429
430    #[test]
431    fn serialize_i32() {
432        let mut v = Vec::new();
433        {
434            let mut s = BinaryProtocol::new(&mut v);
435            s.serialize_i32(3000000);
436        }
437
438        let mut cursor = Cursor::new(v);
439        assert_eq!(3000000, cursor.read_i32::<BigEndian>().unwrap());
440    }
441
442    #[test]
443    fn serialize_i32_neg() {
444        let mut v = Vec::new();
445        {
446            let mut s = BinaryProtocol::new(&mut v);
447            s.serialize_i32(-3000000);
448        }
449
450        let mut cursor = Cursor::new(v);
451        assert_eq!(-3000000, cursor.read_i32::<BigEndian>().unwrap());
452    }
453
454    #[test]
455    fn serialize_i64() {
456        let mut v = Vec::new();
457        {
458            let mut s = BinaryProtocol::new(&mut v);
459            s.serialize_i64(33000000);
460        }
461
462        let mut cursor = Cursor::new(v);
463        assert_eq!(33000000, cursor.read_i64::<BigEndian>().unwrap());
464    }
465
466    #[test]
467    fn serialize_i64_neg() {
468        let mut v = Vec::new();
469        {
470            let mut s = BinaryProtocol::new(&mut v);
471            s.serialize_i64(-33000000);
472        }
473
474        let mut cursor = Cursor::new(v);
475        assert_eq!(-33000000, cursor.read_i64::<BigEndian>().unwrap());
476    }
477
478    #[test]
479    fn protocol_begin() {
480        let mut v = Vec::new();
481        {
482            let mut proto = BinaryProtocol::new(&mut v);
483            proto.write_message_begin("foobar", ThriftMessageType::Call);
484        }
485
486        let mut cursor = Cursor::new(v);
487        let version = THRIFT_VERSION_1 | ThriftMessageType::Call as i32;
488
489        assert_eq!(version, cursor.read_i32::<BigEndian>().unwrap());
490        // XXX Decode string and seqid.
491    }
492
493    #[test]
494    fn write_and_read_message_begin() {
495        let mut buf = Vec::new();
496
497        {
498            let mut se = BinaryProtocol::new(&mut buf);
499            se.write_message_begin("Foobar123", ThriftMessageType::Call);
500        }
501
502        let mut de = BinaryProtocol::new(Cursor::new(buf));
503        let msg = de.read_message_begin().unwrap();
504
505        assert_eq!(msg.name, "Foobar123");
506        assert_eq!(msg.ty, ThriftMessageType::Call);
507    }
508}
tokio_thrift/protocol/binary_protocol.rs

tokio_thrift/protocol/
binary_protocol.rs
