Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
6 changes: 4 additions & 2 deletions rs/moq-c/src/api.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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;
Expand Down
2 changes: 1 addition & 1 deletion rs/moq-c/src/client.rs
Original file line number Diff line number Diff line change
Expand Up @@ -96,7 +96,7 @@ pub unsafe fn parse_client(config: Option<&moq_client_config>) -> Result<Config,
out.connect.backoff.max = std::time::Duration::from_micros(config.backoff_max_us);
}
if config.has_backoff_timeout {
out.connect.backoff.timeout = std::time::Duration::from_micros(config.backoff_timeout_us);
out.connect.backoff.timeout = Some(std::time::Duration::from_micros(config.backoff_timeout_us));
}

// QUIC
Expand Down
8 changes: 4 additions & 4 deletions rs/moq-c/src/test.rs
Original file line number Diff line number Diff line change
Expand Up @@ -4266,8 +4266,8 @@ fn defaults_report_what_a_zeroed_config_dials() {
assert_eq!(config.backoff_max_us, expected.connect.backoff.max.as_micros() as u64);
assert!(config.has_backoff_timeout);
assert_eq!(
config.backoff_timeout_us,
expected.connect.backoff.timeout.as_micros() as u64
expected.connect.backoff.timeout,
Some(std::time::Duration::from_micros(config.backoff_timeout_us))
);

let websocket = expected.connect.websocket.resolve();
Expand Down Expand Up @@ -4313,12 +4313,12 @@ fn zero_with_a_flag_set_is_a_real_value() {
config.has_quic_keep_alive = true;

let explicit = parsed(&config);
assert_eq!(explicit.connect.backoff.timeout, std::time::Duration::ZERO);
assert_eq!(explicit.connect.backoff.timeout, Some(std::time::Duration::ZERO));
assert_eq!(explicit.quic.keep_alive, std::time::Duration::ZERO);

// Without the flags the same zeroes mean nothing at all.
let defaults = parsed(&client_config());
assert_ne!(defaults.connect.backoff.timeout, std::time::Duration::ZERO);
assert_ne!(defaults.connect.backoff.timeout, Some(std::time::Duration::ZERO));
assert_eq!(defaults.quic.keep_alive, std::time::Duration::from_secs(3));
}

Expand Down
2 changes: 1 addition & 1 deletion rs/moq-ffi/src/session.rs
Original file line number Diff line number Diff line change
Expand Up @@ -181,7 +181,7 @@ impl Client {
connect.backoff.max = std::time::Duration::from_micros(max);
}
if let Some(timeout) = backoff.timeout_us {
connect.backoff.timeout = std::time::Duration::from_micros(timeout);
connect.backoff.timeout = Some(std::time::Duration::from_micros(timeout));
}

let mut quic = moq_tokio::quic::Config::default();
Expand Down
2 changes: 1 addition & 1 deletion rs/moq-gst/src/sink/session.rs
Original file line number Diff line number Diff line change
Expand Up @@ -146,7 +146,7 @@ pub struct ResolvedSettings {
pub(super) fn connect_config(settings: &ResolvedSettings) -> 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
}

Expand Down
2 changes: 1 addition & 1 deletion rs/moq-relay/src/cluster.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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);
Expand Down
4 changes: 2 additions & 2 deletions rs/moq-relay/tests/drills.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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
}

Expand Down Expand Up @@ -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")];
}
Expand Down
25 changes: 25 additions & 0 deletions rs/moq-tokio/src/cli/duration.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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<S>(value: &Option<Duration>, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
match value {
Some(value) => super::serialize(value, serializer),
None => serializer.serialize_none(),
}
}

pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<Duration>, D::Error>
where
D: Deserializer<'de>,
{
Option::<String>::deserialize(deserializer)?
.map(|value| humantime::parse_duration(&value).map_err(::serde::de::Error::custom))
.transpose()
}
}
}
93 changes: 75 additions & 18 deletions rs/moq-tokio/src/connection.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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<Duration>,

// 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")]
Expand All @@ -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]
Expand Down Expand Up @@ -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
Expand Down Expand Up @@ -1655,31 +1674,69 @@ 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();
assert_eq!(parsed.backoff.multiplier, DEFAULT_MULTIPLIER);
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 =
Wrapper::parse_from(&[std::ffi::OsStr::new("--backoff-initial"), std::ffi::OsStr::new("3s")]).unwrap();
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() {
Expand Down Expand Up @@ -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]
Expand Down Expand Up @@ -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/"));
Expand All @@ -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/",
Expand Down Expand Up @@ -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");
Expand Down
4 changes: 2 additions & 2 deletions rs/moq-tokio/tests/broadcast.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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())
Expand Down Expand Up @@ -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);
Expand Down
4 changes: 2 additions & 2 deletions rs/moq-tokio/tests/reconnect.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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");
Expand Down Expand Up @@ -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")
}
Expand Down
Loading