From cfdc2efa4d9d4fb0c79a28224b392d0c6ba29ae5 Mon Sep 17 00:00:00 2001
From: Jesper van den Ende <jespertheend@gmail.com>
Date: Wed, 26 Jun 2024 17:31:44 +0200
Subject: [PATCH] Add some logging

---
 src/lib.rs       | 15 +++++++++++++++
 tests/upgrade.rs | 16 ++++++++++++++++
 2 files changed, 31 insertions(+)

diff --git a/src/lib.rs b/src/lib.rs
index 976663e..0c6e9b5 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -523,17 +523,20 @@ impl<'f, S> WebSocket<S> {
   where
     S: AsyncReadExt + AsyncWriteExt + Unpin,
   {
+    eprintln!("read_frame call");
     loop {
       let (res, obligated_send) =
         self.read_half.read_frame_inner(&mut self.stream).await;
       let is_closed = self.write_half.closed;
       if let Some(frame) = obligated_send {
         if !is_closed {
+          eprintln!("writing obligated send");
           self.write_half.write_frame(&mut self.stream, frame).await?;
         }
       }
       if let Some(frame) = res? {
         if is_closed && frame.opcode != OpCode::Close {
+          eprintln!("return connection closed");
           return Err(WebSocketError::ConnectionClosed);
         }
         break Ok(frame);
@@ -572,6 +575,7 @@ impl ReadHalf {
   where
     S: AsyncReadExt + Unpin,
   {
+    eprintln!("read_frame_inner call");
     let mut frame = match self.parse_frame_header(stream).await {
       Ok(frame) => frame,
       Err(e) => return (Err(e), None),
@@ -581,8 +585,10 @@ impl ReadHalf {
       frame.unmask()
     };
 
+    eprintln!("here 1");
     match frame.opcode {
       OpCode::Close if self.auto_close => {
+        eprintln!("here 2");
         match frame.payload.len() {
           0 => {}
           1 => return (Err(WebSocketError::InvalidCloseFrame), None),
@@ -614,9 +620,11 @@ impl ReadHalf {
         (Ok(Some(frame)), Some(obligated_send))
       }
       OpCode::Ping if self.auto_pong => {
+        eprintln!("here 3");
         (Ok(None), Some(Frame::pong(frame.payload)))
       }
       OpCode::Text => {
+        eprintln!("here 4");
         if frame.fin && !frame.is_utf8() {
           (Err(WebSocketError::InvalidUTF8), None)
         } else {
@@ -634,6 +642,7 @@ impl ReadHalf {
   where
     S: AsyncReadExt + Unpin,
   {
+    eprintln!("parse_frame_header call");
     macro_rules! eof {
       ($n:expr) => {{
         if $n == 0 {
@@ -741,24 +750,30 @@ impl WriteHalf {
   where
     S: AsyncWriteExt + Unpin,
   {
+    eprintln!("write_frame");
     if self.role == Role::Client && self.auto_apply_mask {
       frame.mask();
     }
 
     if frame.opcode == OpCode::Close {
+      eprintln!("close opcode, setting self.closed");
       self.closed = true;
     } else if self.closed {
+      eprintln!("already closed, throw");
       return Err(WebSocketError::ConnectionClosed);
     }
 
     if self.vectored && frame.payload.len() > self.writev_threshold {
+      eprintln!("writev");
       frame.writev(stream).await?;
     } else {
+      eprintln!("write_all text");
       let text = frame.write(&mut self.write_buffer);
       stream.write_all(text).await?;
     }
 
     if frame.opcode == OpCode::Close {
+      eprintln!("shutdown!");
       stream.shutdown().await?;
     }
 
diff --git a/tests/upgrade.rs b/tests/upgrade.rs
index 2611b0b..6b7a087 100644
--- a/tests/upgrade.rs
+++ b/tests/upgrade.rs
@@ -78,6 +78,7 @@ async fn hyper() {
   assert!(message.opcode == fastwebsockets::OpCode::Text);
   assert!(message.payload == b"Hello!");
 
+  eprintln!("saying goodbye");
   let_assert!(
     Ok(()) = stream
       .write_frame(fastwebsockets::Frame::text(b"Goodbye!".to_vec().into()))
@@ -85,6 +86,20 @@ async fn hyper() {
   );
   let_assert!(Ok(close_frame) = stream.read_frame().await);
   assert!(close_frame.opcode == fastwebsockets::OpCode::Close);
+  // let frame = stream.read_frame().await;
+  // // match frame {
+  // //   Err(e) => {
+  // //     eprintln!("frame is error {}", e);
+  // //   },
+  // //   Ok(result) => {
+  // //     eprintln!("frame is ok");
+  // //   }
+  // // }
+  // // let_assert!(Err(error) = frame);
+  // // let_assert!(error = WebSocketError::)
+  // // let_assert!(Ok(()) = Err({}));
+  // let_assert!(Ok(close_frame) = frame);
+  // assert!(close_frame.opcode == fastwebsockets::OpCode::Close);
 }
 
 async fn upgrade_websocket(
@@ -100,6 +115,7 @@ async fn upgrade_websocket(
     assert!(reply.opcode == fastwebsockets::OpCode::Text);
     assert!(reply.payload == b"Goodbye!");
 
+    eprintln!("server sending close frame");
     assert!(let Ok(()) = stream.write_frame(fastwebsockets::Frame::close_raw(vec![].into())).await);
   });