diff --git a/rs/moq-c/src/api.rs b/rs/moq-c/src/api.rs index 4dbea6607b6..13d08eaadfc 100644 --- a/rs/moq-c/src/api.rs +++ b/rs/moq-c/src/api.rs @@ -1116,8 +1116,10 @@ pub extern "C" fn moq_client_defaults() -> moq_client_config { dst.has_backoff_multiplier = true; dst.backoff_max_us = micros(config.connect.backoff.max); dst.has_backoff_max = true; - dst.backoff_timeout_us = micros(config.connect.backoff.timeout); - dst.has_backoff_timeout = true; + if let Some(timeout) = config.connect.backoff.timeout { + dst.backoff_timeout_us = micros(timeout); + dst.has_backoff_timeout = true; + } let quic = config.quic.resolve(); dst.quic_max_streams = quic.max_streams; diff --git a/rs/moq-c/src/client.rs b/rs/moq-c/src/client.rs index 0538df377f2..48e4dcad540 100644 --- a/rs/moq-c/src/client.rs +++ b/rs/moq-c/src/client.rs @@ -96,7 +96,7 @@ pub unsafe fn parse_client(config: Option<&moq_client_config>) -> Result moq_tokio::connect::Config { let mut config = moq_tokio::connect::Config::default(); config.tls.insecure = Some(settings.tls_disable_verify); - config.backoff.timeout = std::time::Duration::ZERO; + config.backoff.timeout = Some(std::time::Duration::ZERO); config } diff --git a/rs/moq-relay/src/cluster.rs b/rs/moq-relay/src/cluster.rs index 8b056a3402d..6c17218af85 100644 --- a/rs/moq-relay/src/cluster.rs +++ b/rs/moq-relay/src/cluster.rs @@ -1758,7 +1758,7 @@ impl Cluster { .connect .clone() .context("internal: LAN dial without Cluster::with_connect")?; - connect.backoff.timeout = std::time::Duration::ZERO; + connect.backoff.timeout = Some(std::time::Duration::ZERO); connect.once = Some(false); let mut bind = connect.resolve().bind; bind.set_port(0); diff --git a/rs/moq-relay/tests/drills.rs b/rs/moq-relay/tests/drills.rs index 6b7aeb02838..f3a6e0e9643 100644 --- a/rs/moq-relay/tests/drills.rs +++ b/rs/moq-relay/tests/drills.rs @@ -329,7 +329,7 @@ fn dial() -> moq_tokio::connect::Config { // budget, paced enough that the loop is still a backoff. config.backoff.initial = Duration::from_millis(50); config.backoff.max = Duration::from_millis(200); - config.backoff.timeout = Duration::from_secs(5); + config.backoff.timeout = Some(Duration::from_secs(5)); config } @@ -999,7 +999,7 @@ async fn cross_cluster(lane: Lane, link: PeerLink) { config.connect = dial(); // Retry forever: a give-up after a slow impaired handshake would look exactly // like the never-redialed regression, and a stall still fails the drill. - config.connect.backoff.timeout = Duration::ZERO; + config.connect.backoff.timeout = Some(Duration::ZERO); if link == PeerLink::Transport { config.connect.version = vec!["moq-transport-19".parse().expect("parse version")]; } diff --git a/rs/moq-tokio/src/cli/duration.rs b/rs/moq-tokio/src/cli/duration.rs index 1bc0a0e748e..2ba6ce2b3ab 100644 --- a/rs/moq-tokio/src/cli/duration.rs +++ b/rs/moq-tokio/src/cli/duration.rs @@ -111,4 +111,29 @@ pub(crate) mod serde_duration { let value = String::deserialize(deserializer)?; humantime::parse_duration(&value).map_err(::serde::de::Error::custom) } + + /// The same format for an optional duration. + pub mod option { + use ::serde::{Deserialize, Deserializer, Serializer}; + use std::time::Duration; + + pub fn serialize(value: &Option, serializer: S) -> Result + where + S: Serializer, + { + match value { + Some(value) => super::serialize(value, serializer), + None => serializer.serialize_none(), + } + } + + pub fn deserialize<'de, D>(deserializer: D) -> Result, D::Error> + where + D: Deserializer<'de>, + { + Option::::deserialize(deserializer)? + .map(|value| humantime::parse_duration(&value).map_err(::serde::de::Error::custom)) + .transpose() + } + } } diff --git a/rs/moq-tokio/src/connection.rs b/rs/moq-tokio/src/connection.rs index 914804f2d3b..e7059ec9584 100644 --- a/rs/moq-tokio/src/connection.rs +++ b/rs/moq-tokio/src/connection.rs @@ -146,18 +146,26 @@ pub struct Backoff { /// Maximum time to spend retrying before giving up. Defaults to 10s. /// /// Resets after a stable connection (one that outlives the initial backoff), so a flapping - /// session that reconnects then immediately drops still counts toward the timeout. Set to 0 for - /// unlimited retries. + /// session that reconnects then immediately drops still counts toward the timeout. Set to + /// `Some(Duration::ZERO)` for unlimited retries. `None` takes the default. When this config was + /// parsed from the command line, a `--backoff-timeout` given there wins over this field. + /// + /// An `Option` because zero is a real setting: a command-line parse leaves this field at its + /// type's default, and only `None` tells "unset" apart from "retry forever". #[usage(skip)] - #[serde(with = "crate::cli::duration::serde_duration")] - pub timeout: Duration, + #[serde( + default, + with = "crate::cli::duration::serde_duration::option", + skip_serializing_if = "Option::is_none" + )] + pub timeout: Option, + // No parser default: the parser stores one as if it were given, and it would then beat a + // window set in code. The default lives in [`Backoff::window`] instead. #[usage( name = "backoff-timeout", long, env = "MOQ_BACKOFF_TIMEOUT", - default_value_t = CliDuration::fallback(DEFAULT_TIMEOUT), - default = "10s", setting = "connect.backoff.timeout" )] #[serde(default, rename = "__cli_timeout", skip_serializing_if = "Option::is_none")] @@ -172,12 +180,23 @@ impl Default for Backoff { multiplier: DEFAULT_MULTIPLIER, max: DEFAULT_MAX, max_arg: None, - timeout: DEFAULT_TIMEOUT, + timeout: Some(DEFAULT_TIMEOUT), timeout_arg: None, } } } +impl Backoff { + /// The retry window in effect, where zero means unlimited: the flag, then the typed field, then + /// the default. + fn window(&self) -> Duration { + self.timeout_arg + .map(Into::into) + .or(self.timeout) + .unwrap_or(DEFAULT_TIMEOUT) + } +} + /// A connection lifecycle transition reported by [`Connection::status`]. #[derive(Clone, Copy, Debug, PartialEq, Eq)] #[non_exhaustive] @@ -847,7 +866,7 @@ impl Connection { let backoff = client.backoff.clone(); let goaway = client.goaway.resolve(); let pacing = Pacing::new(&backoff); - let timeout = CliDuration::resolve(backoff.timeout_arg, backoff.timeout); + let timeout = backoff.window(); let initial = pacing.initial; let mut retry = Retry::new(initial); // Sticky across migrations: a redirect is an assignment, not a detour, so a @@ -1655,13 +1674,13 @@ mod tests { parsed.backoff.initial = Duration::from_secs(7); parsed.backoff.multiplier = 5; parsed.backoff.max = Duration::from_secs(11); - parsed.backoff.timeout = Duration::ZERO; + parsed.backoff.timeout = Some(Duration::ZERO); parsed.update_from(&[]); assert_eq!(parsed.backoff.initial, Duration::from_secs(7)); assert_eq!(parsed.backoff.multiplier, 5); assert_eq!(parsed.backoff.max, Duration::from_secs(11)); - assert_eq!(parsed.backoff.timeout, Duration::ZERO, "0 means retry forever"); + assert_eq!(parsed.backoff.window(), Duration::ZERO, "0 means retry forever"); // With no flags, the parser defaults resolve to the typed defaults. let parsed = Wrapper::parse_from(&[]).unwrap(); @@ -1669,10 +1688,7 @@ mod tests { let pacing = Pacing::new(&parsed.backoff); assert_eq!(pacing.initial, DEFAULT_INITIAL); assert_eq!(pacing.max, DEFAULT_MAX); - assert_eq!( - CliDuration::resolve(parsed.backoff.timeout_arg, parsed.backoff.timeout), - DEFAULT_TIMEOUT - ); + assert_eq!(parsed.backoff.window(), DEFAULT_TIMEOUT); // And a flag still lands where the merge can see it. let parsed = @@ -1680,6 +1696,47 @@ mod tests { assert_eq!(Pacing::new(&parsed.backoff).initial, Duration::from_secs(3)); } + /// A window set in code wins on a config the command line built, including zero. + /// + /// The parser stored its 10s default exactly as if `--backoff-timeout 10s` had been given, so + /// it beat the typed field, and a zero there was indistinguishable from the field left unset. + #[test] + fn a_timeout_set_in_code_beats_the_parser_default() { + #[derive(usage::Cli)] + #[usage(unknown_flags = "error", args_override_self = false)] + #[usage(settings)] + struct Wrapper { + #[usage(flatten)] + backoff: Backoff, + } + + let mut parsed = Wrapper::parse_from(&[]).unwrap().backoff; + assert_eq!(parsed.window(), DEFAULT_TIMEOUT); + parsed.timeout = Some(Duration::ZERO); + assert_eq!(parsed.window(), Duration::ZERO, "a parsed config"); + + let merged = |backoff: &Backoff| -> Backoff { toml::Value::try_from(backoff).unwrap().try_into().unwrap() }; + let mut config = merged(&Wrapper::parse_from(&[]).unwrap().backoff); + assert_eq!(config.window(), DEFAULT_TIMEOUT, "the default survives the round-trip"); + config.timeout = Some(Duration::ZERO); + assert_eq!(config.window(), Duration::ZERO, "a merged config"); + config.timeout = Some(Duration::from_secs(3)); + assert_eq!(config.window(), Duration::from_secs(3), "a merged config, nonzero"); + + // An explicit flag still wins, through the round-trip too. + let flag = [std::ffi::OsStr::new("--backoff-timeout"), std::ffi::OsStr::new("0s")]; + let mut config = merged(&Wrapper::parse_from(&flag).unwrap().backoff); + config.timeout = Some(Duration::from_secs(3)); + assert_eq!(config.window(), Duration::ZERO, "the flag beats the field"); + + // A config built in code was never affected. + let config = Backoff { + timeout: Some(Duration::ZERO), + ..Default::default() + }; + assert_eq!(config.window(), Duration::ZERO); + } + /// GOAWAY typed defaults remain overrideable by a standing TOML layer. #[test] fn cli_does_not_clobber_toml_goaway() { @@ -2087,7 +2144,7 @@ mod tests { assert_eq!(backoff.initial, Duration::from_secs(1)); assert_eq!(backoff.multiplier, 2); assert_eq!(backoff.max, Duration::from_secs(5)); - assert_eq!(backoff.timeout, Duration::from_secs(10)); + assert_eq!(backoff.timeout, Some(Duration::from_secs(10))); } #[test] @@ -2272,7 +2329,7 @@ mod tests { async fn an_unsupported_scheme_ends_unlimited_reconnects() { let mut config = crate::connect::Config::default(); config.tls.insecure = Some(true); - config.backoff.timeout = Duration::ZERO; + config.backoff.timeout = Some(Duration::ZERO); let client = config.init(Default::default()).expect("build client"); let started = tokio::time::Instant::now(); let connection = client.connect(url("moqz://localhost/")); @@ -2290,7 +2347,7 @@ mod tests { async fn an_invalid_tls_server_name_ends_unlimited_reconnects() { let mut config = crate::connect::Config::default(); config.tls.insecure = Some(true); - config.backoff.timeout = Duration::ZERO; + config.backoff.timeout = Some(Duration::ZERO); let client = config.init(Default::default()).expect("build client"); for target in [ "https://a!b:1/", @@ -2321,7 +2378,7 @@ mod tests { let mut client = client(); client.backoff.initial = Duration::from_millis(50); client.backoff.max = Duration::from_millis(50); - client.backoff.timeout = Duration::from_millis(200); + client.backoff.timeout = Some(Duration::from_millis(200)); let started = tokio::time::Instant::now(); let connection = client.connect(target); let err = connection.closed().await.expect_err("refused socket connected"); diff --git a/rs/moq-tokio/tests/broadcast.rs b/rs/moq-tokio/tests/broadcast.rs index df8403a7f1f..f21f3f1303c 100644 --- a/rs/moq-tokio/tests/broadcast.rs +++ b/rs/moq-tokio/tests/broadcast.rs @@ -2963,7 +2963,7 @@ async fn a_dead_session_unannounces_while_the_reconnect_retries() { client_config.tls.insecure = Some(true); // Retry forever with a fast cadence: the worst case for a stale announce. client_config.backoff.initial = Duration::from_millis(10); - client_config.backoff.timeout = Duration::ZERO; + client_config.backoff.timeout = Some(Duration::ZERO); let client = client_config.init(Default::default()).expect("failed to init client"); let connection = tokio::time::timeout(TIMEOUT, client.with_subscriber(sub_origin).connect(url).established()) @@ -3639,7 +3639,7 @@ async fn zero_initial_backoff_still_gives_up_on_a_flapping_peer() { let mut client_config = moq_tokio::connect::Config::default(); client_config.tls.insecure = Some(true); client_config.backoff.initial = Duration::ZERO; - client_config.backoff.timeout = Duration::from_millis(500); + client_config.backoff.timeout = Some(Duration::from_millis(500)); let client = client_config.init(Default::default()).expect("failed to init client"); let connection = client.connect(url); diff --git a/rs/moq-tokio/tests/reconnect.rs b/rs/moq-tokio/tests/reconnect.rs index 6515721fb96..7cb8a44bd99 100644 --- a/rs/moq-tokio/tests/reconnect.rs +++ b/rs/moq-tokio/tests/reconnect.rs @@ -24,7 +24,7 @@ async fn a_transient_failure_retries_until_the_budget_runs_out() { let mut backoff = moq_tokio::Backoff::default(); backoff.initial = Duration::from_millis(20); backoff.max = Duration::from_millis(40); - backoff.timeout = Duration::from_millis(200); + backoff.timeout = Some(Duration::from_millis(200)); // Nothing listens on port 1, so every attempt is refused: transient as far as this layer knows. let url: url::Url = "tcp://127.0.0.1:1".parse().expect("failed to parse url"); @@ -138,7 +138,7 @@ fn quick_client(redirect: moq_tokio::Redirect) -> moq_tokio::Client { let mut config = moq_tokio::connect::Config::default(); config.backoff.initial = Duration::from_millis(20); config.backoff.max = Duration::from_millis(40); - config.backoff.timeout = Duration::ZERO; + config.backoff.timeout = Some(Duration::ZERO); config.goaway.redirect = redirect; config.init(Default::default()).expect("failed to init client") }