chore(websocket): add comments in code

src/tcp/client.rs

@@ -26,10 +26,13 @@ impl Client {
         let mut buf = [0; MAX_PACKET_LEN];
 
         // read buffer from stream
-        self.stream.read(&mut buf)?;
+        let len = self.stream.read(&mut buf)?;
 
-        // encode &[u8] to a String and delete null bytes (empty `\0` bytes)
+        // select only used bytes from the buffer
-        let decoded = String::from_utf8(buf.to_vec())?.replace('\0', "");
+        let recv_buf = &buf[0..len];
+
+        // encode buffer (&[u8]) to a String
+        let decoded = String::from_utf8(recv_buf.to_vec())?;
 
         Ok(decoded)
     }

src/tcp/handle_websocket.rs

@@ -11,31 +11,48 @@ use super::MAX_PACKET_LEN;
 
 /// Handle WebSocket connection
 pub async fn handle_websocket(stream: TcpStream, tcp_port: String) -> anyhow::Result<()> {
+    // accept connection as WebSocket
     let ws_stream = tokio_tungstenite::accept_async(stream).await?;
+
+    // connect to Tcp server
     let tcp_stream = TcpStream::connect(format!("0.0.0.0:{}", tcp_port)).await?;
 
+    // split streams
     let (mut tcp_read, mut tcp_write) = tcp_stream.into_split();
     let (mut ws_write, mut ws_read) = ws_stream.split();
 
+    // tcp read -> ws write
     tokio::spawn(async move {
+        // allocate an empty buffer
         let mut buf = [0; MAX_PACKET_LEN];
 
         loop {
+            // read buffer from tcp
             let len = tcp_read.read(&mut buf).await.unwrap();
 
             if len > 0 {
-                let recv_buffer = &buf[0..len];
+                // select only used bytes from the buffer
-                let recv_vec: Vec<u8> = recv_buffer.to_vec();
+                let recv_buf = &buf[0..len];
+                // covert &[u8] buffer to a vector
+                let recv_vec = recv_buf.to_vec();
+                // create a `Message` type from buffer Vec<u8>
                 let msg = Message::Binary(recv_vec);
+
+                // write buffer to websocket
                 ws_write.send(msg).await.unwrap();
             }
         }
     });
 
+    // ws read -> tcp write
     while let Some(msg) = ws_read.next().await {
+        // handle error in the message
         let msg = msg?;
-        let buffer: &[u8] = &msg.into_data();
+        // create a buffer from a message
-        tcp_write.write(buffer).await?;
+        let buf = msg.into_data();
+
+        // write buffer to tcp
+        tcp_write.write(&buf).await?;
     }
 
     Ok(())