Framing

We will now apply what we just learned about I/O and implement the Mini-Redis framing layer. Framing is the process of taking a byte stream and converting it to a stream of frames. A frame is a unit of data transmitted between two peers. The Redis protocol frame is as follows:

1. use bytes::Bytes;

3. enum Frame {
4. Simple(String),
5. Error(String),
6. Integer(u64),
7. Bulk(Bytes),
8. Null,
9. Array(Vec<Frame>),
10. }

Note how the frame only consists of data without any semantics. The command parsing and implementation happen at a higher level.

For HTTP, a frame might look like:

1. enum HttpFrame {
2. RequestHead {
3. method: Method,
4. uri: Uri,
5. version: Version,
6. headers: HeaderMap,
7. },
8. ResponseHead {
9. status: StatusCode,
10. version: Version,
11. headers: HeaderMap,
12. },
13. BodyChunk {
14. chunk: Bytes,
15. },
16. }

To implement framing for Mini-Redis, we will implement a Connection struct that wraps a TcpStream and reads/writes mini_redis::Frame values.

1. use tokio::net::TcpStream;
2. use mini_redis::{Frame, Result};

4. struct Connection {
5. stream: TcpStream,
6. // ... other fields here
7. }

9. impl Connection {
10. /// Read a frame from the connection.
11. ///
12. /// Returns `None` if EOF is reached
13. pub async fn read_frame(&mut self)
14. -> Result<Option<Frame>>
15. {
16. // implementation here
17. }

19. /// Write a frame to the connection.
20. pub async fn write_frame(&mut self, frame: &Frame)
21. -> Result<()>
22. {
23. // implementation here
24. }
25. }

You can find the details of the Redis wire protocol here. The full Connection code is found here.