Merge commit '3194714f6fa1c78108b2a6353bd3e2af95ce1152' into multipath-quinn-0.11.x-b2b930a-merges

Author: divagant-martian

.github/workflows/codecov.yml

@@ -27,7 +27,7 @@ jobs:
         #       | paste -sd ',' -
         run: |
           cargo llvm-cov \
-            --features="arbitrary,async-io,async-std,aws-lc-rs,bloom,direct-log,fast-apple-datapath,futures-io,json-output,lock_tracking,log,platform-verifier,__qlog,ring,runtime-async-std,runtime-smol,runtime-tokio,rustls,rustls-aws-lc-rs,rustls-log,rustls-ring,serde,serde_json,smol,tracing" \
+            --features="arbitrary,async-io,async-std,aws-lc-rs,bloom,direct-log,fast-apple-datapath,futures-io,json-output,lock_tracking,log,platform-verifier,qlog,ring,runtime-async-std,runtime-smol,runtime-tokio,rustls,rustls-aws-lc-rs,rustls-log,rustls-ring,serde,serde_json,smol,tracing" \
             --workspace --lcov --output-path lcov.info
       - name: Upload coverage to Codecov
         uses: codecov/codecov-action@v5

.github/workflows/rust.yml

@@ -245,7 +245,7 @@ on:
       uses: actions/checkout@v5
 
     - name: Install JDK
-      uses: actions/setup-java@v4
+      uses: actions/setup-java@v5
       with:
         distribution: 'zulu'
         java-version: '21'

Cargo.lock

@@ -177,14 +177,14 @@ pub struct Opt {
     pub max_streams: usize,
     /// Number of bytes to transmit from server to client
     ///
-    /// This can use SI prefixes for sizes. E.g. 1M will transfer 1MiB, 10G
-    /// will transfer 10GiB.
+    /// This can use SI suffixes for sizes. For example, 1M will transfer
+    /// 1MiB, 10G will transfer 10GiB.
     #[clap(long, default_value = "1G", value_parser = parse_byte_size)]
     pub download_size: u64,
     /// Number of bytes to transmit from client to server
     ///
-    /// This can use SI prefixes for sizes. E.g. 1M will transfer 1MiB, 10G
-    /// will transfer 10GiB.
+    /// This can use SI suffixes for sizes. For example, 1M will transfer
+    /// 1MiB, 10G will transfer 10GiB.
     #[clap(long, default_value = "0", value_parser = parse_byte_size)]
     pub upload_size: u64,
     /// Show connection stats the at the end of the benchmark
@@ -214,15 +214,12 @@ fn parse_byte_size(s: &str) -> Result<u64, ParseIntError> {
         _ => 1,
     };
 
-    let s = if multiplier != 1 {
-        &s[..s.len() - 1]
-    } else {
-        s
+    let s = match multiplier {
+        1 => s,
+        _ => &s[..s.len() - 1],
     };
 
-    let base: u64 = u64::from_str(s)?;
-
-    Ok(base * multiplier)
+    Ok(u64::from_str(s)? * multiplier)
 }
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]

bench/src/lib.rs

@@ -5,6 +5,10 @@ edition = "2021"
 license = "MIT OR Apache-2.0"
 publish = false
 
+[[bin]]
+name = "quinn-perf"
+path = "src/bin/perf.rs"
+
 [features]
 # NOTE: Please keep this in sync with the feature list in `.github/workflows/codecov.yml`, see
 # comment in that file for more information.

perf/Cargo.toml

@@ -0,0 +1,42 @@
+use clap::{Parser, Subcommand};
+use tracing::error;
+use tracing_subscriber::{EnvFilter, fmt, layer::SubscriberExt, util::SubscriberInitExt};
+
+use perf::{client, server};
+
+#[derive(Parser)]
+#[clap(long_about = None)]
+struct Cli {
+    #[command(subcommand)]
+    command: Commands,
+}
+
+#[derive(Subcommand)]
+enum Commands {
+    /// Run as a perf server
+    Server(server::Opt),
+    /// Run as a perf client
+    Client(client::Opt),
+}
+
+#[tokio::main(flavor = "current_thread")]
+async fn main() {
+    let opt = Cli::parse();
+
+    tracing_subscriber::registry()
+        .with(
+            EnvFilter::try_from_default_env()
+                .or_else(|_| EnvFilter::try_new("warn"))
+                .unwrap(),
+        )
+        .with(fmt::layer())
+        .init();
+
+    let r = match opt.command {
+        Commands::Server(opt) => server::run(opt).await,
+        Commands::Client(opt) => client::run(opt).await,
+    };
+    if let Err(e) = r {
+        error!("{:#}", e);
+    }
+}

perf/src/bin/perf.rs

@@ -1,5 +1,5 @@
 #[cfg(feature = "json-output")]
-use std::{fs::File, path::PathBuf};
+use std::path::PathBuf;
 use std::{
     net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr},
     sync::Arc,
@@ -14,92 +14,60 @@ use rustls::pki_types::{CertificateDer, ServerName, UnixTime};
 use tokio::sync::Semaphore;
 use tracing::{debug, error, info};
 
-use perf::{
-    CongestionAlgorithm, bind_socket,
+use crate::{
+    CommonOpt, PERF_CIPHER_SUITES,
     noprotection::NoProtectionClientConfig,
+    parse_byte_size,
     stats::{OpenStreamStats, Stats},
 };
 
 /// Connects to a QUIC perf server and maintains a specified pattern of requests until interrupted
 #[derive(Parser)]
 #[clap(name = "client")]
-struct Opt {
+pub struct Opt {
     /// Host to connect to
     #[clap(default_value = "localhost:4433")]
     host: String,
     /// Override DNS resolution for host
     #[clap(long)]
     ip: Option<IpAddr>,
+    /// Specify the local socket address
+    #[clap(long)]
+    local_addr: Option<SocketAddr>,
     /// Number of unidirectional requests to maintain concurrently
     #[clap(long, default_value = "0")]
     uni_requests: u64,
     /// Number of bidirectional requests to maintain concurrently
     #[clap(long, default_value = "1")]
     bi_requests: u64,
     /// Number of bytes to request
-    #[clap(long, default_value = "1048576")]
+    ///
+    /// This can use SI suffixes for sizes. For example, 1M will transfer
+    /// 1MiB, 10G will transfer 10GiB.
+    #[clap(long, default_value = "1M", value_parser = parse_byte_size)]
     download_size: u64,
     /// Number of bytes to transmit, in addition to the request header
-    #[clap(long, default_value = "1048576")]
+    ///
+    /// This can use SI suffixes for sizes. For example, 1M will transfer
+    /// 1MiB, 10G will transfer 10GiB.
+    #[clap(long, default_value = "1M", value_parser = parse_byte_size)]
     upload_size: u64,
     /// The time to run in seconds
     #[clap(long, default_value = "60")]
     duration: u64,
     /// The interval in seconds at which stats are reported
     #[clap(long, default_value = "1")]
     interval: u64,
-    /// Send buffer size in bytes
-    #[clap(long, default_value = "2097152")]
-    send_buffer_size: usize,
-    /// Receive buffer size in bytes
-    #[clap(long, default_value = "2097152")]
-    recv_buffer_size: usize,
-    /// Specify the local socket address
-    #[clap(long)]
-    local_addr: Option<SocketAddr>,
-    /// Whether to print connection statistics
-    #[clap(long)]
-    conn_stats: bool,
     /// File path to output JSON statistics to. If the file is '-', stdout will be used
     #[cfg(feature = "json-output")]
     #[clap(long)]
     json: Option<PathBuf>,
-    /// Perform NSS-compatible TLS key logging to the file specified in `SSLKEYLOGFILE`.
-    #[clap(long = "keylog")]
-    keylog: bool,
-    /// UDP payload size that the network must be capable of carrying
-    #[clap(long, default_value = "1200")]
-    initial_mtu: u16,
-    /// Disable packet encryption/decryption (for debugging purpose)
-    #[clap(long = "no-protection")]
-    no_protection: bool,
-    /// The initial round-trip-time (in msecs)
-    #[clap(long)]
-    initial_rtt: Option<u64>,
-    /// Ack Frequency mode
-    #[clap(long = "ack-frequency")]
-    ack_frequency: bool,
-    /// Congestion algorithm to use
-    #[clap(long = "congestion")]
-    cong_alg: Option<CongestionAlgorithm>,
-    /// qlog output file
-    #[cfg(feature = "qlog")]
-    #[clap(long = "qlog")]
-    qlog_file: Option<PathBuf>,
-}
-
-#[tokio::main(flavor = "current_thread")]
-async fn main() {
-    let opt = Opt::parse();
-
-    tracing_subscriber::fmt::init();
-
-    if let Err(e) = run(opt).await {
-        error!("{:#}", e);
-    }
+    /// Common options
+    #[command(flatten)]
+    common: CommonOpt,
 }
 
-async fn run(opt: Opt) -> Result<()> {
+pub async fn run(opt: Opt) -> Result<()> {
     let mut host_parts = opt.host.split(':');
     let host_name = host_parts.next().unwrap();
     let host_port = host_parts
@@ -128,13 +96,16 @@ async fn run(opt: Opt) -> Result<()> {
 
     info!("local addr {:?}", bind_addr);
 
-    let socket = bind_socket(bind_addr, opt.send_buffer_size, opt.recv_buffer_size)?;
+    let socket = opt.common.bind_socket(bind_addr)?;
+
+    let mut endpoint_cfg = quinn::EndpointConfig::default();
+    endpoint_cfg.max_udp_payload_size(opt.common.max_udp_payload_size)?;
 
-    let endpoint = quinn::Endpoint::new(Default::default(), None, socket, Arc::new(TokioRuntime))?;
+    let endpoint = quinn::Endpoint::new(endpoint_cfg, None, socket, Arc::new(TokioRuntime))?;
 
     let default_provider = rustls::crypto::ring::default_provider();
     let provider = Arc::new(rustls::crypto::CryptoProvider {
-        cipher_suites: perf::PERF_CIPHER_SUITES.into(),
+        cipher_suites: PERF_CIPHER_SUITES.into(),
         ..default_provider
     });
 
@@ -146,35 +117,17 @@ async fn run(opt: Opt) -> Result<()> {
         .with_no_client_auth();
     crypto.alpn_protocols = vec![b"perf".to_vec()];
 
-    if opt.keylog {
+    if opt.common.keylog {
         crypto.key_log = Arc::new(rustls::KeyLogFile::new());
     }
 
-    let mut transport = quinn::TransportConfig::default();
-    transport.initial_mtu(opt.initial_mtu);
-
-    if let Some(initial_rtt) = opt.initial_rtt {
-        transport.initial_rtt(Duration::from_millis(initial_rtt));
-    }
-
-    if opt.ack_frequency {
-        transport.ack_frequency_config(Some(quinn::AckFrequencyConfig::default()));
-    }
-
-    if let Some(cong_alg) = opt.cong_alg {
-        transport.congestion_controller_factory(cong_alg.build());
-    }
-
-    #[cfg(feature = "qlog")]
-    if let Some(qlog_file) = &opt.qlog_file {
-        let mut qlog = quinn::QlogConfig::default();
-        qlog.writer(Box::new(File::create(qlog_file)?))
-            .title(Some("perf-client".into()));
-        transport.qlog_stream(qlog.into_stream());
-    }
+    let transport = opt.common.build_transport_config(
+        #[cfg(feature = "qlog")]
+        "perf-client",
+    )?;
 
     let crypto = Arc::new(QuicClientConfig::try_from(crypto)?);
-    let mut config = quinn::ClientConfig::new(match opt.no_protection {
+    let mut config = quinn::ClientConfig::new(match opt.common.no_protection {
         true => Arc::new(NoProtectionClientConfig::new(crypto)),
         false => crypto,
     });
@@ -220,7 +173,7 @@ async fn run(opt: Opt) -> Result<()> {
                 stats.on_interval(start, &stream_stats);
 
                 stats.print();
-                if opt.conn_stats {
+                if opt.common.conn_stats {
                     println!("{:?}\n", connection.stats());
                 }
             }