练习：Protobuf 解析

练习：Protobuf 解析

在本练习中，您将为 protobuf 二进制编码构建一个解析器。别担心，其实非常简单！这展示了一种常见的解析模式，即传递数据 slice。底层数据本身永远不会被复制。

如要完整解析 protobuf 消息，需要知道字段的类型（按字段编号编入索引）。这通常会在 proto 文件中提供。在本练习中，我们将把这些信息编码成处理每个字段所调用的函数中的 match 语句。

我们将使用以下 proto：

1. message PhoneNumber {
2. optional string number = 1;
3. optional string type = 2;
4. }

6. message Person {
7. optional string name = 1;
8. optional int32 id = 2;
9. repeated PhoneNumber phones = 3;
10. }

proto 消息被编码为连续的一系列字段。每个字段都通过 “标签”后面紧跟值的形式来实现。标签包含一个字段编号（例如Person 消息的 id 字段的值为 2）和线型（用于定义应如何从字节流确定载荷）。

整数（包括标签）使用名为 VARINT 的可变长度编码表示。幸运的是，下面为您提供了 parse_varint 的定义。该指定代码还定义了一些回调，用于处理 Person 和 PhoneNumber 字段，并将消息解析为对这些回调的一系列调用。

What remains for you is to implement the parse_field function and the ProtoMessage trait for Person and PhoneNumber.

1. use std::convert::TryFrom;
2. use thiserror::Error;

4. #[derive(Debug, Error)]
5. enum Error {
6. #[error("Invalid varint")]
7. InvalidVarint,
8. #[error("Invalid wire-type")]
9. InvalidWireType,
10. #[error("Unexpected EOF")]
11. UnexpectedEOF,
12. #[error("Invalid length")]
13. InvalidSize(#[from] std::num::TryFromIntError),
14. #[error("Unexpected wire-type)")]
15. UnexpectedWireType,
16. #[error("Invalid string (not UTF-8)")]
17. InvalidString,
18. }

20. /// A wire type as seen on the wire.
21. enum WireType {
22. /// Varint WireType 表明该值为单个 VARINT。
23. Varint,
24. //I64,  -- not needed for this exercise
25. /// The Len WireType indicates that the value is a length represented as a
26. /// VARINT followed by exactly that number of bytes.
27. Len,
28. /// The I32 WireType indicates that the value is precisely 4 bytes in
29. /// little-endian order containing a 32-bit signed integer.
30. I32,
31. }

33. #[derive(Debug)]
34. /// A field's value, typed based on the wire type.
35. enum FieldValue<'a> {
36. Varint(u64),
37. //I64(i64),  -- not needed for this exercise
38. Len(&'a [u8]),
39. I32(i32),
40. }

42. #[derive(Debug)]
43. /// A field, containing the field number and its value.
44. struct Field<'a> {
45. field_num: u64,
46. value: FieldValue<'a>,
47. }

49. trait ProtoMessage<'a>: Default + 'a {
50. fn add_field(&mut self, field: Field<'a>) -> Result<(), Error>;
51. }

53. impl TryFrom<u64> for WireType {
54. type Error = Error;

56. fn try_from(value: u64) -> Result<WireType, Error> {
57. Ok(match value {
58. 0 => WireType::Varint,
59. //1 => WireType::I64,  -- not needed for this exercise
60. 2 => WireType::Len,
61. 5 => WireType::I32,
62. _ => return Err(Error::InvalidWireType),
63. })
64. }
65. }

67. impl<'a> FieldValue<'a> {
68. fn as_string(&self) -> Result<&'a str, Error> {
69. let FieldValue::Len(data) = self else {
70. return Err(Error::UnexpectedWireType);
71. };
72. std::str::from_utf8(data).map_err(|_| Error::InvalidString)
73. }

75. fn as_bytes(&self) -> Result<&'a [u8], Error> {
76. let FieldValue::Len(data) = self else {
77. return Err(Error::UnexpectedWireType);
78. };
79. Ok(data)
80. }

82. fn as_u64(&self) -> Result<u64, Error> {
83. let FieldValue::Varint(value) = self else {
84. return Err(Error::UnexpectedWireType);
85. };
86. Ok(*value)
87. }
88. }

90. /// Parse a VARINT, returning the parsed value and the remaining bytes.
91. fn parse_varint(data: &[u8]) -> Result<(u64, &[u8]), Error> {
92. for i in 0..7 {
93. let Some(b) = data.get(i) else {
94. return Err(Error::InvalidVarint);
95. };
96. if b & 0x80 == 0 {
97. // This is the last byte of the VARINT, so convert it to
98. // a u64 and return it.
99. let mut value = 0u64;
100. for b in data[..=i].iter().rev() {
101. value = (value << 7) | (b & 0x7f) as u64;
102. }
103. return Ok((value, &data[i + 1..]));
104. }
105. }

107. // More than 7 bytes is invalid.
108. Err(Error::InvalidVarint)
109. }

111. /// Convert a tag into a field number and a WireType.
112. fn unpack_tag(tag: u64) -> Result<(u64, WireType), Error> {
113. let field_num = tag >> 3;
114. let wire_type = WireType::try_from(tag & 0x7)?;
115. Ok((field_num, wire_type))
116. }

118. /// Parse a field, returning the remaining bytes
119. fn parse_field(data: &[u8]) -> Result<(Field, &[u8]), Error> {
120. let (tag, remainder) = parse_varint(data)?;
121. let (field_num, wire_type) = unpack_tag(tag)?;
122. let (fieldvalue, remainder) = match wire_type {
123. _ => todo!("Based on the wire type, build a Field, consuming as many bytes as necessary.")
124. };
125. todo!("Return the field, and any un-consumed bytes.")
126. }

128. /// Parse a message in the given data, calling `T::add_field` for each field in
129. /// the message.
130. ///
131. /// The entire input is consumed.
132. fn parse_message<'a, T: ProtoMessage<'a>>(mut data: &'a [u8]) -> Result<T, Error> {
133. let mut result = T::default();
134. while !data.is_empty() {
135. let parsed = parse_field(data)?;
136. result.add_field(parsed.0)?;
137. data = parsed.1;
138. }
139. Ok(result)
140. }

142. #[derive(Debug, Default)]
143. struct PhoneNumber<'a> {
144. number: &'a str,
145. type_: &'a str,
146. }

148. #[derive(Debug, Default)]
149. struct Person<'a> {
150. name: &'a str,
151. id: u64,
152. phone: Vec<PhoneNumber<'a>>,
153. }

155. // TODO: Implement ProtoMessage for Person and PhoneNumber.

157. fn main() {
158. let person: Person = parse_message(&[
159. 0x0a, 0x07, 0x6d, 0x61, 0x78, 0x77, 0x65, 0x6c, 0x6c, 0x10, 0x2a, 0x1a,
160. 0x16, 0x0a, 0x0e, 0x2b, 0x31, 0x32, 0x30, 0x32, 0x2d, 0x35, 0x35, 0x35,
161. 0x2d, 0x31, 0x32, 0x31, 0x32, 0x12, 0x04, 0x68, 0x6f, 0x6d, 0x65, 0x1a,
162. 0x18, 0x0a, 0x0e, 0x2b, 0x31, 0x38, 0x30, 0x30, 0x2d, 0x38, 0x36, 0x37,
163. 0x2d, 0x35, 0x33, 0x30, 0x38, 0x12, 0x06, 0x6d, 0x6f, 0x62, 0x69, 0x6c,
164. 0x65,
165. ])
166. .unwrap();
167. println!("{:#?}", person);
168. }

23.4. 练习：Protobuf 解析

练习：Protobuf 解析