wip: function example of the problem

* Related #20

[ci skip]

Author: tegefaulkes

src/bin/clientTest.rs

@@ -36,9 +36,12 @@ const MAX_DATAGRAM_SIZE: usize = 1350;
 const HTTP_REQ_STREAM_ID: u64 = 4;
 
 struct TestData {
-    num_messages: u8,
+    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];
@@ -204,50 +207,67 @@ fn main() {
         if conn.is_established() && !req_sent {
             println!("Init data");
             // init application data
-            match conn.stream_send(0, b"", false) {
+            for n in 0..STREAMS {
+              let stream_id = n * 4;
+              match conn.stream_send(stream_id, b"", false) {
                 Ok(_) => {},
                 Err(quiche::Error::Done) => {},
                 Err(e) => {
                     error!("{} stream send failed {:?}", conn.trace_id(), e);
                     return;
                 },
             };
-            match conn.stream_init_application_data(0, TestData {num_messages: 0}) {
+            match conn.stream_init_application_data(stream_id, TestData {num_messages: MESSAGES}) {
                 Ok(_) => {},
                 Err(quiche::Error::Done) => {},
                 Err(e) => {
                     error!("{} stream init failed {:?}", conn.trace_id(), e);
                     return;
                 },
             };
-
+            }
             req_sent = true;
         }
 
         // Process all readable streams.
         for s in conn.readable() {
             while let Ok((read, fin)) = conn.stream_recv(s, &mut buf) {
-                println!("received {} bytes", read);
+                // println!("received {} bytes", 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)
+                // });
 
             }
         }
 
         for s in conn.writable() {
-            println!("Writing stream {}", s);
-            let written = match conn.stream_send(s, b"Hello!", true) {
+            // println!("Writing stream {}", s);
+            // get the application data
+            let app_data = conn.stream_application_data(s)
+              .unwrap()
+              .downcast_mut::<TestData>()
+              .unwrap();
+
+            // println!("numruns {}", app_data.num_messages);
+            // dec the number of messages
+            app_data.num_messages = app_data.num_messages - 1;
+
+            let fin = app_data.num_messages <= 1;
+            if (fin) {
+              println!{"finishing {}", s};
+            }
+            if (app_data.num_messages > 0) {
+              let written = match conn.stream_send(s, b"Hello!", fin) {
                 Ok(v) => v,
 
                 Err(quiche::Error::Done) => 0,
@@ -257,7 +277,7 @@ fn main() {
                     return;
                 },
             };
-            println!("Written {} bytes", written);
+            }
         }
 
         // Generate outgoing QUIC packets and send them on the UDP socket, until

src/bin/serverTest.rs

@@ -30,6 +30,7 @@ extern crate log;
 use std::net;
 
 use std::collections::HashMap;
+use std::collections::BTreeSet;
 
 use ring::rand::*;
 
@@ -52,6 +53,7 @@ type ClientMap = HashMap<quiche::ConnectionId<'static>, Client>;
 fn main() {
     let mut buf = [0; 65535];
     let mut out = [0; MAX_DATAGRAM_SIZE];
+    let mut active_count: BTreeSet<u64> = BTreeSet::new();
 
     let mut args = std::env::args();
 
@@ -101,8 +103,8 @@ fn main() {
     config.set_initial_max_stream_data_bidi_local(1_000_000);
     config.set_initial_max_stream_data_bidi_remote(1_000_000);
     config.set_initial_max_stream_data_uni(1_000_000);
-    config.set_initial_max_streams_bidi(100);
-    config.set_initial_max_streams_uni(100);
+    config.set_initial_max_streams_bidi(10000);
+    config.set_initial_max_streams_uni(10000);
     config.set_disable_active_migration(true);
     config.enable_early_data();
 
@@ -311,26 +313,18 @@ fn main() {
 
                 // Process all readable streams.
                 for s in client.conn.readable() {
-                    println!("reading stream {}", s);
-                    while let Ok((read, fin)) =
-                        client.conn.stream_recv(s, &mut buf)
-                    {
-                        println!(
-                            "{} received {} bytes",
-                            client.conn.trace_id(),
-                            read
-                        );
-
-                        let stream_buf = &buf[..read];
-
-                        debug!(
-                            "{} stream {} has {} bytes (fin? {})",
-                            client.conn.trace_id(),
-                            s,
-                            stream_buf.len(),
-                            fin
-                        );
-                    }
+                  active_count.insert(s);
+                  // println!("reading stream {}", s);
+                  while let Ok((read, fin)) =
+                      client.conn.stream_recv(s, &mut buf)
+                  {
+                      let stream_buf = &buf[..read];
+
+                      if (fin) {
+                        active_count.remove(&s);
+                        println!("stream finished! {}, left {}", s, active_count.len());
+                      }
+                  }
                 }
             }
         }