From e1da97a5171a58c6c7907a675d149326b9f9e15c Mon Sep 17 00:00:00 2001 From: _ <> Date: Fri, 10 Sep 2021 14:16:38 -0500 Subject: [PATCH] add `--debug-echo` option for P4 end servers to run a simulated P5 TCP echo server This makes it possible to debug with only 4 processes instead of 5. --- docs/how-to/test-ptth-quic.md | 12 +++-- .../quic_demo/src/bin/quic_demo_end_server.rs | 47 ++++++++++++------- 2 files changed, 37 insertions(+), 22 deletions(-) diff --git a/docs/how-to/test-ptth-quic.md b/docs/how-to/test-ptth-quic.md index 3bc15a8..ff92c1f 100644 --- a/docs/how-to/test-ptth-quic.md +++ b/docs/how-to/test-ptth-quic.md @@ -4,9 +4,11 @@ - Open 3 terminals in `prototypes/quic_demo` - Use `export RUST_LOG=quic_demo_relay_server=debug` to enable debug logging -for the terminal that will run the relay server +for the terminal that will run the relay server (P3) - Use `export RUST_LOG=quic_demo_end_server=debug` for the terminal that -will run the end server +will run the end server (P4) +- Use `export RUST_LOG=quic_demo_client=debug` for the terminal that +will run the client (P2) When the relay server is running, use curl to get the list of connected end servers: `curl 127.0.0.1:4004` @@ -15,6 +17,8 @@ end servers: `curl 127.0.0.1:4004` - Start a relay `cargo run --bin quic_demo_relay_server` - Verify that the relay has no end servers connected -- Start an end server `cargo run --bin quic_demo_end_server` +- Start an end server `cargo run --bin quic_demo_end_server -- --debug-echo` - Verify that the end server connected - +- Start a client `cargo run --bin quic_demo_client` +- Connect to the client and verify that the debug echo server is running +`nc 127.0.0.1 30381` diff --git a/prototypes/quic_demo/src/bin/quic_demo_end_server.rs b/prototypes/quic_demo/src/bin/quic_demo_end_server.rs index c5a9feb..26c6c6d 100644 --- a/prototypes/quic_demo/src/bin/quic_demo_end_server.rs +++ b/prototypes/quic_demo/src/bin/quic_demo_end_server.rs @@ -10,21 +10,23 @@ struct Opt { relay_addr: Option , #[structopt (long)] server_id: Option , + #[structopt (long)] + debug_echo: bool, } #[tokio::main] async fn main () -> anyhow::Result <()> { tracing_subscriber::fmt::init (); - let opt = Opt::from_args (); + let opt = Arc::new (Opt::from_args ()); let server_cert = tokio::fs::read ("quic_server.crt").await?; - let relay_addr = opt.relay_addr.unwrap_or_else (|| String::from ("127.0.0.1:30380")).parse ()?; + let relay_addr = opt.relay_addr.clone ().unwrap_or_else (|| String::from ("127.0.0.1:30380")).parse ()?; let endpoint = make_client_endpoint ("0.0.0.0:0".parse ()?, &[&server_cert])?; trace! ("Connecting to relay server"); - let server_id = opt.server_id.unwrap_or_else (|| "bogus_server".to_string ()); + let server_id = opt.server_id.clone ().unwrap_or_else (|| "bogus_server".to_string ()); let quinn::NewConnection { mut bi_streams, @@ -37,11 +39,12 @@ async fn main () -> anyhow::Result <()> { loop { let (relay_send, relay_recv) = bi_streams.next ().await.ok_or_else (|| anyhow::anyhow! ("Relay server didn't open a bi stream"))??; - tokio::spawn (handle_bi_stream (relay_send, relay_recv)); + tokio::spawn (handle_bi_stream (Arc::clone (&opt), relay_send, relay_recv)); } } async fn handle_bi_stream ( + opt: Arc , relay_send: quinn::SendStream, mut relay_recv: quinn::RecvStream, ) -> anyhow::Result <()> @@ -50,13 +53,14 @@ async fn handle_bi_stream ( protocol::P3ToP4Stream::NewPtthConnection { client_id, .. - } => handle_new_ptth_connection (relay_send, relay_recv, client_id).await?, + } => handle_new_ptth_connection (opt, relay_send, relay_recv, client_id).await?, } Ok (()) } async fn handle_new_ptth_connection ( + opt: Arc , mut relay_send: quinn::SendStream, mut relay_recv: quinn::RecvStream, _client_id: String, @@ -73,19 +77,26 @@ async fn handle_new_ptth_connection ( debug! ("Started PTTH connection"); - let stream = TcpStream::connect (("127.0.0.1", p4_to_p5_req.port)).await?; - let (local_recv, local_send) = stream.into_split (); - - trace! ("Relaying bytes..."); - - let ptth_conn = quic_demo::connection::NewConnection { - local_send, - local_recv, - relay_send, - relay_recv, - }.build (); - - ptth_conn.wait_for_close ().await?; + if opt.debug_echo { + relay_send.write (b"Connected to P4=P5 debug echo server\n").await?; + debug! ("Relaying bytes using internal debug echo server (P4=P5)"); + tokio::io::copy (&mut relay_recv, &mut relay_send).await?; + } + else { + let stream = TcpStream::connect (("127.0.0.1", p4_to_p5_req.port)).await?; + let (local_recv, local_send) = stream.into_split (); + + trace! ("Relaying bytes..."); + + let ptth_conn = quic_demo::connection::NewConnection { + local_send, + local_recv, + relay_send, + relay_recv, + }.build (); + + ptth_conn.wait_for_close ().await?; + } Ok (()) }