wip: cleaned up example

* Related #20

[ci skip]

Author: tegefaulkes

src/bin/clientTest.rs renamed to src/bin/client_test.rs

@@ -33,15 +33,14 @@ use ring::rand::*;
 
 const MAX_DATAGRAM_SIZE: usize = 1350;
 
-const HTTP_REQ_STREAM_ID: u64 = 4;
-
 struct TestData {
     num_messages: i64,
 }
 
 const STREAMS: u64 = 10000;
 const MESSAGES: i64 = 400;
 
+
 fn main() {
     let mut buf = [0; 65535];
     let mut out = [0; MAX_DATAGRAM_SIZE];
@@ -141,7 +140,7 @@ fn main() {
 
     debug!("written {}", write);
 
-    let req_start = std::time::Instant::now();
+    // let req_start = std::time::Instant::now();
 
     let mut req_sent = false;
 
@@ -188,7 +187,7 @@ fn main() {
                 Ok(v) => v,
 
                 Err(e) => {
-                    error!("recv failed: {:?}", e);
+                    println!("recv failed: {:?}", e);
                     continue 'read;
                 },
             };
@@ -231,21 +230,22 @@ fn main() {
 
         // Process all readable streams.
         for s in conn.readable() {
-            while let Ok((read, fin)) = conn.stream_recv(s, &mut buf) {
-                // println!("received {} bytes", read);
+            while let Ok((_read, _fin)) = conn.stream_recv(s, &mut buf) {
+              // ignore messages, just consume.
+              // println!("received {} bytes", read);
 
-                let stream_buf = &buf[..read];
+              // let stream_buf = &buf[..read];
 
-                // println!(
-                //     "stream {} has {} bytes (fin? {})",
-                //     s,
-                //     stream_buf.len(),
-                //     fin
-                // );
+              // println!(
+              //     "stream {} has {} bytes (fin? {})",
+              //     s,
+              //     stream_buf.len(),
+              //     fin
+              // );
 
-                // println!("{}", unsafe {
-                //     std::str::from_utf8_unchecked(stream_buf)
-                // });
+              // println!("{}", unsafe {
+              //     std::str::from_utf8_unchecked(stream_buf)
+              // });
 
             }
         }
@@ -263,17 +263,17 @@ fn main() {
             app_data.num_messages = app_data.num_messages - 1;
 
             let fin = app_data.num_messages <= 1;
-            if (fin) {
+            if fin {
               println!{"finishing {}", s};
             }
-            if (app_data.num_messages > 0) {
-              let written = match conn.stream_send(s, b"Hello!", fin) {
+            if app_data.num_messages > 0 {
+              let _written = match conn.stream_send(s, b"Hello!", fin) {
                 Ok(v) => v,
 
                 Err(quiche::Error::Done) => 0,
 
                 Err(e) => {
-                    error!("{} stream send failed {:?}", conn.trace_id(), e);
+                    println!("{} stream send failed {:?}", conn.trace_id(), e);
                     return;
                 },
             };
@@ -292,7 +292,7 @@ fn main() {
                 },
 
                 Err(e) => {
-                    error!("send failed: {:?}", e);
+                    println!("send failed: {:?}", e);
 
                     conn.close(false, 0x1, b"fail").ok();
                     break;
@@ -312,7 +312,7 @@ fn main() {
         }
 
         if conn.is_closed() {
-            info!("connection closed, {:?}", conn.stats());
+            println!("connection closed, {:?}", conn.stats());
             break;
         }
     }

src/bin/serverTest.rs renamed to src/bin/server_test.rs

@@ -36,16 +36,8 @@ use ring::rand::*;
 
 const MAX_DATAGRAM_SIZE: usize = 1350;
 
-struct PartialResponse {
-    body: Vec<u8>,
-
-    written: usize,
-}
-
 struct Client {
     conn: quiche::Connection,
-
-    partial_responses: HashMap<u64, PartialResponse>,
 }
 
 type ClientMap = HashMap<quiche::ConnectionId<'static>, Client>;
@@ -165,7 +157,7 @@ fn main() {
                 Ok(v) => v,
 
                 Err(e) => {
-                    error!("Parsing packet header failed: {:?}", e);
+                    println!("Parsing packet header failed: {:?}", e);
                     continue 'read;
                 },
             };
@@ -182,7 +174,7 @@ fn main() {
                 !clients.contains_key(&conn_id)
             {
                 if hdr.ty != quiche::Type::Initial {
-                    error!("Packet is not Initial");
+                    println!("Packet is not Initial");
                     continue 'read;
                 }
 
@@ -248,12 +240,12 @@ fn main() {
                 // The token was not valid, meaning the retry failed, so
                 // drop the packet.
                 if odcid.is_none() {
-                    error!("Invalid address validation token");
+                    println!("Invalid address validation token");
                     continue 'read;
                 }
 
                 if scid.len() != hdr.dcid.len() {
-                    error!("Invalid destination connection ID");
+                    println!("Invalid destination connection ID");
                     continue 'read;
                 }
 
@@ -274,7 +266,6 @@ fn main() {
 
                 let client = Client {
                     conn,
-                    partial_responses: HashMap::new(),
                 };
 
                 clients.insert(scid.clone(), client);
@@ -298,7 +289,7 @@ fn main() {
                 Ok(v) => v,
 
                 Err(e) => {
-                    error!("{} recv failed: {:?}", client.conn.trace_id(), e);
+                    println!("{} recv failed: {:?}", client.conn.trace_id(), e);
                     continue 'read;
                 },
             };
@@ -315,12 +306,12 @@ fn main() {
                 for s in client.conn.readable() {
                   active_count.insert(s);
                   // println!("reading stream {}", s);
-                  while let Ok((read, fin)) =
+                  while let Ok((_read, fin)) =
                       client.conn.stream_recv(s, &mut buf)
                   {
-                      let stream_buf = &buf[..read];
+                      // let stream_buf = &buf[..read];
 
-                      if (fin) {
+                      if fin {
                         active_count.remove(&s);
                         println!("stream finished! {}, left {}", s, active_count.len());
                       }
@@ -343,7 +334,7 @@ fn main() {
                     },
 
                     Err(e) => {
-                        error!("{} send failed: {:?}", client.conn.trace_id(), e);
+                        println!("{} send failed: {:?}", client.conn.trace_id(), e);
 
                         client.conn.close(false, 0x1, b"fail").ok();
                         break;
@@ -446,7 +437,7 @@ fn handle_writable(client: &mut Client, stream_id: u64) {
       Err(quiche::Error::Done) => (),
 
       Err(e) => {
-        error!("{} stream send failed {:?}", conn.trace_id(), e);
+        println!("{} stream send failed {:?}", conn.trace_id(), e);
 
       },
     }