From 0e45532b955470451eb467cd82ab2ae6771f7059 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sat, 24 Oct 2026 09:17:22 -0700 Subject: [PATCH 01/67] chore(quest): claim quest/m1/empty-segments.md Quest-Claim: 010ff1ce60a7e739 From a3fbe3b28d9c2ea22b38d988e17d14809038c7bf Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sat, 24 Oct 2026 09:35:40 -0700 Subject: [PATCH 02/67] fix(net): refuse empty segments in published names create_broadcast and dynamic refuse a string name with a leading, trailing, or doubled slash instead of collapsing it, in Rust (Error::EmptySegment, via AsPath::is_normalized) and @moq/net (createBroadcast/dynamic now take the raw string). Co-Authored-By: Claude Opus 5.5 --- js/net/MIGRATE.md | 6 ++++++ js/net/src/origin.test.ts | 17 +++++++++++++++++ js/net/src/origin.ts | 23 ++++++++++++++++------ quest/m1/README.md | 1 - quest/m1/empty-segments.md | 19 ------------------ rs/moq-net/MIGRATE.md | 6 ++++++ rs/moq-net/src/error.rs | 8 +++++++- rs/moq-net/src/model/origin.rs | 35 ++++++++++++++++++++++++++++++++++ rs/moq-net/src/path/mod.rs | 22 +++++++++++++++++++++ 9 files changed, 110 insertions(+), 27 deletions(-) delete mode 100644 quest/m1/empty-segments.md diff --git a/js/net/MIGRATE.md b/js/net/MIGRATE.md index 77990b90505..bee7414ee87 100644 --- a/js/net/MIGRATE.md +++ b/js/net/MIGRATE.md @@ -4,6 +4,12 @@ How to update your code for each breaking change, newest first. ## Unreleased +### Published names refuse empty segments + +`Origin.Producer.createBroadcast` and `dynamic` take the name as a plain `string` and throw on a leading, trailing, or doubled `/` rather than relying on `Path.from` to collapse it, so a name has one spelling. +Pass the canonical name (`room/cam`, not `/room/cam/` or `room//cam`); a `Path.Valid` is already canonical and still works. +Scope roots and subscription paths keep normalizing. + ### Published names refuse navigation segments Broadcast creation and route publication now refuse literal `.` and `..` segments, including segments in the producer's root. diff --git a/js/net/src/origin.test.ts b/js/net/src/origin.test.ts index bd20ace5bc6..08b4deedb4a 100644 --- a/js/net/src/origin.test.ts +++ b/js/net/src/origin.test.ts @@ -2534,3 +2534,20 @@ test("published names refuse navigation segments", () => { origin.close(); } }); + +test("published names refuse empty segments", () => { + const origin = new Producer(); + try { + for (const name of ["/room/cam", "room/cam/", "room//cam", "/"]) { + expect(() => origin.createBroadcast(name)).toThrow("empty segment"); + expect(() => origin.dynamic(name)).toThrow("empty segment"); + } + // A scope root is a prefix, normalized like a subscription, so it never refuses a name below it. + const scoped = origin.scope(Path.from("room/"), new Path.Patterns([Path.Pattern.all()])); + scoped.createBroadcast("cam").close(); + // The root path has no segments, so none of them is empty. + origin.createBroadcast("").close(); + } finally { + origin.close(); + } +}); diff --git a/js/net/src/origin.ts b/js/net/src/origin.ts index 41e9c0bf545..cf3e2a7c79f 100644 --- a/js/net/src/origin.ts +++ b/js/net/src/origin.ts @@ -480,6 +480,15 @@ function publishPath(path: Path.Valid): void { } } +// Checked before normalization, which would otherwise give one name several spellings. +// Normalization only removes slashes, so a string without an empty segment is already valid. +function publishInput(path: string): Path.Valid { + if (path.startsWith("/") || path.endsWith("/") || path.includes("//")) { + throw new Error("broadcast path contains an empty segment"); + } + return path as Path.Valid; +} + /** Reactive backing state shared by origin producers and consumers. */ class OriginState { // Both tables decouple the application producing into the origin from the @@ -1057,7 +1066,7 @@ export interface Table { readonly discovery: Getter; /** Create an unannounced broadcast at `path`; see {@link Producer.createBroadcast}. */ - createBroadcast(path: Path.Valid): broadcast.Producer; + createBroadcast(path: string): broadcast.Producer; /** Resolve `path`, optionally waiting for an announcement; see {@link Consumer.request}. */ request(path: Path.Valid, options?: RequestOptions): Requesting; @@ -1066,7 +1075,7 @@ export interface Table { announced(scope?: Path.Pattern, options?: announce.Options): announce.Consumer; /** Advertise a prefix and serve requests under it; see {@link Producer.dynamic}. */ - dynamic(prefix: Path.Valid): Dynamic; + dynamic(prefix: string): Dynamic; /** Insert a route with protocol metadata. @internal */ dynamicRoute( @@ -1168,9 +1177,11 @@ export class Producer implements Table { * application still holds a consumer clone. Announce with a {@link Route.epoch} * (`Epoch.mint()` per run) so a restart replaces the old broadcast rather than resuming * into it; at the same epoch, a local broadcast competes on cost and wins ties. + * + * Throws when `name` has a leading, trailing, or doubled `/`, or a `.` or `..` segment. */ - createBroadcast(path: Path.Valid): broadcast.Producer { - path = this.#scope.path(path); + createBroadcast(name: string): broadcast.Producer { + const path = this.#scope.path(publishInput(name)); publishPath(path); const created = this.#state.created; if (!created) throw new Error("origin is closed"); @@ -1242,8 +1253,8 @@ export class Producer implements Table { * the returned {@link Dynamic} lives. A consumer resolving a path under it that * no announced local broadcast wins is handed to the handle as a {@link Request}. */ - dynamic(prefix: Path.Valid): Dynamic { - return this.#insertRoute(prefix, Route.default, true, true); + dynamic(prefix: string): Dynamic { + return this.#insertRoute(publishInput(prefix), Route.default, true, true); } /** Insert an originated claim with route metadata that answers through `accept`, for tests and benches. @internal */ diff --git a/quest/m1/README.md b/quest/m1/README.md index b94fb4ecc84..40e9695df01 100644 --- a/quest/m1/README.md +++ b/quest/m1/README.md @@ -91,7 +91,6 @@ audit's receive-memory, priority, and lease bugs rank ahead of that reshape. - [SUBSCRIBE setup sees a cancel](/quest/m1/ietf-setup-cancel.md) - a subscriber that cancels mid-setup releases upstream demand and its slot at once - [JS qmux stream credit](/quest/m1/js-qmux-credit.md) - credit returns when both halves close, so `@moq/net` drops its caps - [Every close records its cause](/quest/m1/close-cause.md) - protocol-violation closes and abandoned SETUP replies record why -- [Empty segments refused](/quest/m1/empty-segments.md) - `room//cam` fails loud instead of naming `room/cam` - [Readers follow restarts](/quest/m1/sink-restart-follow.md) - every moq-cli and moq-gst reader, moqsrc and `moq play` included, follows instances through `announced_broadcast` and an epochless `Restart` where its output can mark it; otherwise it stays on the old instance and fails once that route dies - [Readers follow a moved rendition](/quest/m1/rendition-move-follow.md) - moq-rtc, moq-ffi, moq-gst and `moq play` follow a rendition the catalog moves to a new track - [In-band auth](/quest/m1/auth/README.md) - a session tells its peer what it may publish and subscribe to, unions tokens presented in band, and fails loud on an out-of-scope publish diff --git a/quest/m1/empty-segments.md b/quest/m1/empty-segments.md deleted file mode 100644 index ff1f3bc4b37..00000000000 --- a/quest/m1/empty-segments.md +++ /dev/null @@ -1,19 +0,0 @@ -# [S] Publication paths refuse empty segments - -## Goal - -A publication path with an empty segment, such as `room//cam`, is refused -in Rust and JS instead of being silently collapsed to `room/cam`. - -## Plan - -[moq-dev/moq#6441](https://github.com/moq-dev/moq/pull/6441) refuses `.` and -`..` segments. `Path` normalization (`rs/moq-net/src/path/mod.rs`) still -collapses empty ones, so two different inputs name the same broadcast. - -Decided 2026-10-23 (maintainer): fail loud. Refuse empty publication segments -before normalization, at the same point #6441 refuses navigation segments, -in Rust and `@moq/net`, with tests for leading, trailing, and doubled -slashes. Start after #6441 merges. - -Public API: inputs that were accepted now fail. Wire: none. diff --git a/rs/moq-net/MIGRATE.md b/rs/moq-net/MIGRATE.md index a2d342bdfe6..1af20d022e9 100644 --- a/rs/moq-net/MIGRATE.md +++ b/rs/moq-net/MIGRATE.md @@ -9,6 +9,12 @@ How to update your code for each breaking change, newest first. Rename `moq_net::stats::Refusal` to `moq_net::stats::RefusalKind`, so it no longer shares a name with `moq_auth::Refusal`; its variants and `Refusals` are unchanged. Replace `moq_net::time::now()` with `moq_net::time::Instant::now()`, the one way to read the clock. +### Published names refuse empty segments + +`origin::Producer::create_broadcast` and `dynamic` refuse a string name with a leading, trailing, or doubled `/` with `Error::EmptySegment`, instead of collapsing it, so a name has one spelling. +Pass the canonical name (`room/cam`, not `/room/cam/` or `room//cam`); a `Path` is already canonical and still works. +`AsPath` gains a provided `is_normalized` method. Scope roots and subscription paths keep normalizing. + ### Published names refuse navigation segments Broadcast creation and route publication now refuse literal `.` and `..` segments, including segments in the producer's root. diff --git a/rs/moq-net/src/error.rs b/rs/moq-net/src/error.rs index c838bcdbd2f..d1784757b1b 100644 --- a/rs/moq-net/src/error.rs +++ b/rs/moq-net/src/error.rs @@ -372,6 +372,10 @@ pub enum Error { #[error("broadcast path contains a navigation segment")] NavigationSegment, + /// A published broadcast or route was given with a leading, trailing, or doubled `/`. + #[error("broadcast path contains an empty segment")] + EmptySegment, + /// A duplicate ID was used // The broadcast/track is a duplicate #[error("duplicate")] @@ -645,7 +649,8 @@ impl From<&Error> for SessionError { | Error::WrongSize | Error::BoundsExceeded(_) | Error::InvalidPath(_) - | Error::NavigationSegment => Self::ProtocolViolation, + | Error::NavigationSegment + | Error::EmptySegment => Self::ProtocolViolation, Error::App(app) => Self::App(*app), // A code we did not recognize, so we cannot say which space it came from. // Forwarding it into this one risks landing on a value that IS registered here @@ -710,6 +715,7 @@ impl From<&Error> for StreamError { | Error::BoundsExceeded(_) | Error::InvalidPath(_) | Error::NavigationSegment + | Error::EmptySegment | Error::MalformedTrack => Self::MalformedTrack, Error::App(app) => Self::App(*app), // See the SessionError impl: an unregistered code carries no registry, so diff --git a/rs/moq-net/src/model/origin.rs b/rs/moq-net/src/model/origin.rs index e1787be71de..6c1dd5d1532 100644 --- a/rs/moq-net/src/model/origin.rs +++ b/rs/moq-net/src/model/origin.rs @@ -1344,6 +1344,14 @@ fn publish_path(path: &Path) -> Result<(), Error> { Ok(()) } +// Checked before normalization, which would otherwise give one name several spellings. +fn publish_input(path: &impl AsPath) -> Result<(), Error> { + if !path.is_normalized() { + return Err(Error::EmptySegment); + } + Ok(()) +} + /// What `scope` lets a route at `claim` serve: see [`RouteEntry::reach`]. fn reach(scope: &Patterns, claim: &Pattern) -> Vec { scope @@ -2152,9 +2160,11 @@ impl Producer { /// [`Error::BoundsExceeded`] if the full rooted path exceeds /// [`Path::MAX_PARTS`], [`Error::InvalidPath`] if it holds a segment no /// pattern can spell (`*` or `**`), [`Error::NavigationSegment`] for a literal `.` or `..`, + /// [`Error::EmptySegment`] for a string with a leading, trailing, or doubled `/`, /// or [`Error::Closed`] once the origin's /// [`Driver`] has been dropped. pub fn create_broadcast(&self, path: impl AsPath) -> Result { + publish_input(&path)?; let full = self.root.join(path.as_path()).to_owned(); let (broadcast, announcer) = self.create_withheld(full)?; Ok(broadcast.with_announcer(announcer)) @@ -2519,6 +2529,7 @@ struct Announcing { impl Announcing { /// The requested prefix as-is, refused when its subtree does not overlap the scope. fn new(producer: &Producer, prefix: impl AsPath) -> Result { + publish_input(&prefix)?; let requested = producer.root.join(prefix.as_path()).to_owned(); publish_path(&requested)?; if requested.parts().count() > Path::MAX_PARTS { @@ -13066,6 +13077,30 @@ mod tests { } } + #[moq_clock::test] + async fn published_names_refuse_empty_segments() { + let producer = origin(1).produce(); + for path in ["/room/cam", "room/cam/", "room//cam", "/"] { + assert!( + matches!(producer.create_broadcast(path), Err(Error::EmptySegment)), + "created {path}" + ); + assert!( + matches!(producer.create_broadcast(path.to_string()), Err(Error::EmptySegment)), + "created owned {path}" + ); + assert!( + matches!(producer.dynamic(path), Err(Error::EmptySegment)), + "served {path}" + ); + } + // A scope root is a prefix, normalized like a subscription, so it never refuses a name below it. + let scoped = producer.scope("room/", &Patterns::from_iter([Pattern::all()])).unwrap(); + scoped.create_broadcast("cam").unwrap(); + // The root path has no segments, so none of them is empty. + producer.create_broadcast("").unwrap(); + } + #[moq_clock::test] async fn create_broadcast_refuses_a_path_no_pattern_can_spell() { let producer = origin(1).produce(); diff --git a/rs/moq-net/src/path/mod.rs b/rs/moq-net/src/path/mod.rs index 7b74707f8f0..6b7e5e8a14d 100644 --- a/rs/moq-net/src/path/mod.rs +++ b/rs/moq-net/src/path/mod.rs @@ -26,12 +26,26 @@ pub type PathOwned = Path<'static>; pub trait AsPath { /// Borrow `self` as a [`Path`], normalizing slashes only when needed. fn as_path(&self) -> Path<'_>; + + /// Whether [`as_path`](Self::as_path) keeps the input as written, with no leading, trailing, or doubled `/` to drop. + fn is_normalized(&self) -> bool { + true + } +} + +// Normalization only removes slashes, so a string without an empty segment is already normal. +fn is_normalized(s: &str) -> bool { + !(s.starts_with('/') || s.ends_with('/') || s.contains("//")) } impl<'a> AsPath for &'a str { fn as_path(&self) -> Path<'a> { Path::new(self) } + + fn is_normalized(&self) -> bool { + is_normalized(self) + } } impl<'a> AsPath for &'a Path<'a> { @@ -51,12 +65,20 @@ impl AsPath for String { fn as_path(&self) -> Path<'_> { Path::new(self) } + + fn is_normalized(&self) -> bool { + is_normalized(self) + } } impl<'a> AsPath for &'a String { fn as_path(&self) -> Path<'a> { Path::new(self) } + + fn is_normalized(&self) -> bool { + is_normalized(self) + } } /// A borrowed slice of the path, or a suffix of a shared reference-counted buffer. From 8ad51ec126fac4e36402b7f297e99b2c8c2c87a2 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sat, 24 Oct 2026 21:37:15 -0700 Subject: [PATCH 03/67] wip: strict Path construction in moq-net --- rs/moq-net/src/discovery.rs | 2 +- rs/moq-net/src/error.rs | 4 +- rs/moq-net/src/ietf/namespace.rs | 2 +- rs/moq-net/src/lite/compress.rs | 2 +- rs/moq-net/src/lite/publisher.rs | 4 +- rs/moq-net/src/model/origin.rs | 41 +- rs/moq-net/src/path/mod.rs | 737 ++++++++----------------------- 7 files changed, 200 insertions(+), 592 deletions(-) diff --git a/rs/moq-net/src/discovery.rs b/rs/moq-net/src/discovery.rs index 299603420c8..496186e2574 100644 --- a/rs/moq-net/src/discovery.rs +++ b/rs/moq-net/src/discovery.rs @@ -309,6 +309,6 @@ fn covering(path: &Path) -> Vec { std::iter::successors(Some(path.as_str()), |path| { (!path.is_empty()).then(|| path.rfind('/').map_or("", |slash| &path[..slash])) }) - .map(|path| Path::new(path).to_owned()) + .map(|path| Path::from_valid(path).to_owned()) .collect() } diff --git a/rs/moq-net/src/error.rs b/rs/moq-net/src/error.rs index d1784757b1b..0a6f863acff 100644 --- a/rs/moq-net/src/error.rs +++ b/rs/moq-net/src/error.rs @@ -372,8 +372,8 @@ pub enum Error { #[error("broadcast path contains a navigation segment")] NavigationSegment, - /// A published broadcast or route was given with a leading, trailing, or doubled `/`. - #[error("broadcast path contains an empty segment")] + /// A path was spelled with a leading, trailing, or doubled `/`. + #[error("path contains an empty segment")] EmptySegment, /// A duplicate ID was used diff --git a/rs/moq-net/src/ietf/namespace.rs b/rs/moq-net/src/ietf/namespace.rs index 4d89af79d81..e9c4af1f676 100644 --- a/rs/moq-net/src/ietf/namespace.rs +++ b/rs/moq-net/src/ietf/namespace.rs @@ -73,7 +73,7 @@ fn decode_fields(r: &mut Decoder<'_>) -> Result<(Path<'static>, usize), DecodeEr let count = r.varint()?; if count == 0 { - return Ok((Path::from(String::new()), 0)); + return Ok((Path::empty(), 0)); } if count > Path::MAX_PARTS as u64 { diff --git a/rs/moq-net/src/lite/compress.rs b/rs/moq-net/src/lite/compress.rs index 282a898da88..2b7f7432207 100644 --- a/rs/moq-net/src/lite/compress.rs +++ b/rs/moq-net/src/lite/compress.rs @@ -83,7 +83,7 @@ fn head<'a>(path: &'a Path<'_>, keep: usize) -> Option> { .match_indices('/') .map(|(i, _)| i) .chain((!s.is_empty()).then_some(s.len())); - ends.nth(keep - 1).map(|end| Path::new(&s[..end])) + ends.nth(keep - 1).map(|end| Path::from_valid(&s[..end])) } /// Resolves the bases on a received announce stream. Only used on versions with diff --git a/rs/moq-net/src/lite/publisher.rs b/rs/moq-net/src/lite/publisher.rs index c6760a44464..01094d1971e 100644 --- a/rs/moq-net/src/lite/publisher.rs +++ b/rs/moq-net/src/lite/publisher.rs @@ -917,10 +917,10 @@ impl AnnounceServe { | Error::Session(crate::SessionError::Cancel) | Error::Transport(_) | Error::IdleTimeout => { - tracing::debug!(prefix = %origin.absolute(""), "announcing cancelled"); + tracing::debug!(prefix = %origin.absolute(crate::Path::empty()), "announcing cancelled"); } err => { - tracing::warn!(%err, prefix = %origin.absolute(""), "announcing error"); + tracing::warn!(%err, prefix = %origin.absolute(crate::Path::empty()), "announcing error"); } } self.stream.take().expect("stream present").writer.abort(&err); diff --git a/rs/moq-net/src/model/origin.rs b/rs/moq-net/src/model/origin.rs index 2bfabe3de90..ccee267434a 100644 --- a/rs/moq-net/src/model/origin.rs +++ b/rs/moq-net/src/model/origin.rs @@ -1350,14 +1350,6 @@ fn publish_path(path: &Path) -> Result<(), Error> { Ok(()) } -// Checked before normalization, which would otherwise give one name several spellings. -fn publish_input(path: &impl AsPath) -> Result<(), Error> { - if !path.is_normalized() { - return Err(Error::EmptySegment); - } - Ok(()) -} - /// What `scope` lets a route at `claim` serve: see [`RouteEntry::reach`]. fn reach(scope: &Patterns, claim: &Pattern) -> Vec { scope @@ -1847,7 +1839,7 @@ impl Default for OriginScope { pub(crate) fn interest_prefixes(allowed: &Patterns) -> Vec { let mut heads: Vec = allowed .iter() - .map(|pattern| Path::new(pattern.head()).to_owned()) + .map(|pattern| Path::from_valid(pattern.head()).to_owned()) .collect(); heads.sort(); heads.dedup(); @@ -2166,11 +2158,9 @@ impl Producer { /// [`Error::BoundsExceeded`] if the full rooted path exceeds /// [`Path::MAX_PARTS`], [`Error::InvalidPath`] if it holds a segment no /// pattern can spell (`*` or `**`), [`Error::NavigationSegment`] for a literal `.` or `..`, - /// [`Error::EmptySegment`] for a string with a leading, trailing, or doubled `/`, /// or [`Error::Closed`] once the origin's /// [`Driver`] has been dropped. pub fn create_broadcast(&self, path: impl AsPath) -> Result { - publish_input(&path)?; let full = self.root.join(path.as_path()).to_owned(); let (broadcast, announcer) = self.create_withheld(full)?; Ok(broadcast.with_announcer(announcer)) @@ -2535,7 +2525,6 @@ struct Announcing { impl Announcing { /// The requested prefix as-is, refused when its subtree does not overlap the scope. fn new(producer: &Producer, prefix: impl AsPath) -> Result { - publish_input(&prefix)?; let requested = producer.root.join(prefix.as_path()).to_owned(); publish_path(&requested)?; if requested.parts().count() > Path::MAX_PARTS { @@ -4540,7 +4529,7 @@ impl RouteNode { if child.interests_below == 0 { continue; } - let path = at.join(part.as_str()); + let path = at.join(Path::from_valid(part)); match child.interests > 0 { true => out.push(path), false => child.collect_interests(&path, out), @@ -6285,7 +6274,7 @@ impl Consumer { // the rest of the origin never wakes it, and a route claiming only paths beneath it // (a scoped dynamic at the same prefix) never masks the one that serves it, just as a // request skips it. - let consumer = self.scope("", &Patterns::from(Pattern::literal(path.as_str())?))?; + let consumer = self.scope(Path::empty(), &Patterns::from(Pattern::literal(path.as_str())?))?; // `scope` keeps narrower permissions intact: on a consumer limited to // `foo/specific`, no route can ever cover `foo`. @@ -12941,30 +12930,6 @@ mod tests { } } - #[moq_clock::test] - async fn published_names_refuse_empty_segments() { - let producer = origin(1).produce(); - for path in ["/room/cam", "room/cam/", "room//cam", "/"] { - assert!( - matches!(producer.create_broadcast(path), Err(Error::EmptySegment)), - "created {path}" - ); - assert!( - matches!(producer.create_broadcast(path.to_string()), Err(Error::EmptySegment)), - "created owned {path}" - ); - assert!( - matches!(producer.dynamic(path), Err(Error::EmptySegment)), - "served {path}" - ); - } - // A scope root is a prefix, normalized like a subscription, so it never refuses a name below it. - let scoped = producer.scope("room/", &Patterns::from_iter([Pattern::all()])).unwrap(); - scoped.create_broadcast("cam").unwrap(); - // The root path has no segments, so none of them is empty. - producer.create_broadcast("").unwrap(); - } - #[moq_clock::test] async fn create_broadcast_refuses_a_path_no_pattern_can_spell() { let producer = origin(1).produce(); diff --git a/rs/moq-net/src/path/mod.rs b/rs/moq-net/src/path/mod.rs index 1e4b2261473..0935f4f4059 100644 --- a/rs/moq-net/src/path/mod.rs +++ b/rs/moq-net/src/path/mod.rs @@ -5,8 +5,7 @@ //! wildcards, and [`Patterns`] is a union of them reduced by containment. The //! grammar and algebra live in [`moq-pattern`](moq_pattern); this module //! re-exports them beside [`Path`] so grants, origin scopes, and announce -//! interests can share one dialect. Literal path construction and wire -//! decoding retain their existing behavior. +//! interests can share one dialect. pub use moq_pattern::{InvalidPattern, Pattern, Patterns, Segment, Specificity}; @@ -14,43 +13,31 @@ use std::borrow::Cow; use std::fmt::{self, Display}; use std::sync::Arc; +use crate::Error; use crate::coding::{Decode, DecodeError, Decoder, Encode, EncodeError, Encoder}; +// An empty segment would give one path several spellings, so it is refused rather than collapsed. +fn validate(s: &str) -> Result<(), Error> { + if !s.is_empty() && (s.starts_with('/') || s.ends_with('/') || s.contains("//")) { + return Err(Error::EmptySegment); + } + Ok(()) +} + /// An owned version of [`Path`] with a `'static` lifetime. pub type PathOwned = Path<'static>; -/// A trait for types that can be converted to a `Path`. +/// A trait for types that can be borrowed as a [`Path`]. /// -/// When providing a String/str, any leading/trailing slashes are trimmed and multiple consecutive slashes are collapsed. -/// When already a Path, normalization is skipped and the underlying buffer is reused without copying. +/// Only paths implement it, so a string goes through [`Path::new`] and its +/// validation before it can name a broadcast. pub trait AsPath { - /// Borrow `self` as a [`Path`], normalizing slashes only when needed. + /// Borrow `self` as a [`Path`] without copying. fn as_path(&self) -> Path<'_>; - - /// Whether [`as_path`](Self::as_path) keeps the input as written, with no leading, trailing, or doubled `/` to drop. - fn is_normalized(&self) -> bool { - true - } -} - -// Normalization only removes slashes, so a string without an empty segment is already normal. -fn is_normalized(s: &str) -> bool { - !(s.starts_with('/') || s.ends_with('/') || s.contains("//")) -} - -impl<'a> AsPath for &'a str { - fn as_path(&self) -> Path<'a> { - Path::new(self) - } - - fn is_normalized(&self) -> bool { - is_normalized(self) - } } impl<'a> AsPath for &'a Path<'a> { fn as_path(&self) -> Path<'a> { - // We don't normalize again nor do we copy the bytes. self.borrow() } } @@ -61,26 +48,6 @@ impl AsPath for Path<'_> { } } -impl AsPath for String { - fn as_path(&self) -> Path<'_> { - Path::new(self) - } - - fn is_normalized(&self) -> bool { - is_normalized(self) - } -} - -impl<'a> AsPath for &'a String { - fn as_path(&self) -> Path<'a> { - Path::new(self) - } - - fn is_normalized(&self) -> bool { - is_normalized(self) - } -} - /// A borrowed slice of the path, or a suffix of a shared reference-counted buffer. /// /// The `Shared` variant is what makes owned paths cheap: cloning bumps a refcount and @@ -97,11 +64,12 @@ enum Repr<'a> { /// This type wraps a string but provides path-aware operations that respect /// delimiter boundaries, preventing issues like "foo" matching "foobar". /// -/// Paths are automatically trimmed of leading and trailing slashes on creation, -/// making all slashes implicit at boundaries. A path names a point in the origin's -/// tree from its root; a leading slash never escapes that root. The same type names -/// an exact broadcast and the prefix a route or announcement covers, so a broadcast's -/// own path is the prefix it announces. See [`Relative`] for `..`-style references. +/// A path is a sequence of non-empty segments joined by `/`, so it has one spelling: +/// [`Path::new`] refuses a leading, trailing, or doubled `/` rather than collapsing it. +/// The empty path has no segments; it is the origin's root and prefixes every other +/// path. The same type names an exact broadcast and the prefix a route or announcement +/// covers, so a broadcast's own path is the prefix it announces, and a prefix needs no +/// trailing `/`. See [`Relative`] for `..`-style references. /// /// Owned paths ([`PathOwned`]) share one reference-counted allocation: cloning, converting /// a shared path with [`Path::to_owned`], and suffix operations like [`Path::strip_prefix`] @@ -111,18 +79,17 @@ enum Repr<'a> { /// ``` /// use moq_net::{Path}; /// -/// // Creation automatically trims slashes -/// let path1 = Path::new("/foo/bar/"); -/// let path2 = Path::new("foo/bar"); -/// assert_eq!(path1, path2); +/// // An empty segment is refused, not collapsed. +/// assert!(Path::new("/foo/bar/").is_err()); +/// assert!(Path::new("foo//bar").is_err()); /// -/// // Methods accept both &str and Path -/// let base = Path::new("api/v1"); -/// assert!(base.has_prefix("api")); -/// assert!(base.has_prefix(&Path::new("api/v1"))); +/// let base = Path::new("api/v1")?; +/// assert!(base.has_prefix(Path::new("api")?)); +/// assert!(base.has_prefix(Path::empty())); /// -/// let joined = base.join("users"); +/// let joined = base.join(Path::new("users")?); /// assert_eq!(joined.as_str(), "api/v1/users"); +/// # Ok::<(), moq_net::Error>(()) /// ``` #[derive(Clone)] pub struct Path<'a>(Repr<'a>); @@ -135,29 +102,19 @@ impl<'a> Path<'a> { /// and publishing one to an origin is rejected. pub const MAX_PARTS: usize = 32; - /// Create a new Path from a string slice. + /// Borrow a string as a path, without copying. /// - /// Leading and trailing slashes are automatically trimmed. - /// Multiple consecutive internal slashes are collapsed to single slashes. - pub fn new(s: &'a str) -> Self { - let trimmed = s.trim_start_matches('/').trim_end_matches('/'); + /// The empty string is the root path. Anything else must be non-empty segments + /// joined by `/`: a leading, trailing, or doubled `/` returns [`Error::EmptySegment`]. + pub fn new(s: &'a str) -> Result { + validate(s)?; + Ok(Self(Repr::Borrowed(s))) + } - // Check if we need to normalize (has multiple consecutive slashes) - if trimmed.contains("//") { - // Only allocate if we actually need to normalize - let normalized = trimmed - .split('/') - .filter(|s| !s.is_empty()) - .collect::>() - .join("/"); - Self(Repr::Shared { - buf: normalized.into(), - start: 0, - }) - } else { - // No normalization needed - use borrowed string - Self(Repr::Borrowed(trimmed)) - } + // A string the caller already knows is valid, such as a run of another path's segments. + pub(crate) fn from_valid(s: &'a str) -> Self { + debug_assert!(validate(s).is_ok(), "invalid path {s:?}"); + Self(Repr::Borrowed(s)) } #[cfg_attr(not(feature = "async"), allow(dead_code, reason = "async-only"))] @@ -195,14 +152,13 @@ impl<'a> Path<'a> { /// ``` /// use moq_net::Path; /// - /// let path = Path::new("foo/bar"); - /// assert!(path.has_prefix("foo")); - /// assert!(path.has_prefix(&Path::new("foo"))); - /// assert!(path.has_prefix("foo/")); - /// assert!(!path.has_prefix("fo")); + /// let path = Path::new("foo/bar")?; + /// assert!(path.has_prefix(Path::new("foo")?)); + /// assert!(!path.has_prefix(Path::new("fo")?)); /// - /// let path = Path::new("foobar"); - /// assert!(!path.has_prefix("foo")); + /// let path = Path::new("foobar")?; + /// assert!(!path.has_prefix(Path::new("foo")?)); + /// # Ok::<(), moq_net::Error>(()) /// ``` pub fn has_prefix(&self, prefix: impl AsPath) -> bool { let prefix = prefix.as_path(); @@ -262,14 +218,15 @@ impl<'a> Path<'a> { /// ``` /// use moq_net::Path; /// - /// let path = Path::new("foo/bar/baz"); + /// let path = Path::new("foo/bar/baz")?; /// assert_eq!(path.parts().collect::>(), ["foo", "bar", "baz"]); /// assert_eq!(Path::empty().parts().count(), 0); + /// # Ok::<(), moq_net::Error>(()) /// ``` pub fn parts(&self) -> impl Iterator { - // Paths are normalized on creation so there are no empty parts to filter, - // except that splitting the empty path yields one empty item. - self.as_str().split('/').filter(|part| !part.is_empty()) + // Segments are never empty, but splitting the empty path would yield one. + let s = self.as_str(); + (!s.is_empty()).then(|| s.split('/')).into_iter().flatten() } /// Strip the directory component of the path, if any, and return the rest of the path. @@ -292,7 +249,7 @@ impl<'a> Path<'a> { self.parts().any(|part| part.starts_with('.')) } - /// The normalized path as a string, with no leading or trailing slash. + /// The path as a string, with no leading or trailing slash. pub fn as_str(&self) -> &str { match &self.0 { Repr::Borrowed(s) => s, @@ -353,12 +310,12 @@ impl<'a> Path<'a> { /// ``` /// use moq_net::Path; /// - /// let base = Path::new("foo"); - /// let joined = base.join("bar"); - /// assert_eq!(joined.as_str(), "foo/bar"); + /// let base = Path::new("foo")?; + /// assert_eq!(base.join(Path::new("bar")?).as_str(), "foo/bar"); /// - /// let joined = base.join(&Path::new("bar")); - /// assert_eq!(joined.as_str(), "foo/bar"); + /// // The empty path is the identity. + /// assert_eq!(base.join(Path::empty()).as_str(), "foo"); + /// # Ok::<(), moq_net::Error>(()) /// ``` pub fn join(&self, other: impl AsPath) -> PathOwned { let other = other.as_path(); @@ -368,7 +325,7 @@ impl<'a> Path<'a> { } else if other.is_empty() { self.to_owned() } else { - // Since paths are trimmed, we always need to add a slash + // Neither side has a leading or trailing slash, so exactly one joins them. Path(Repr::Shared { buf: format!("{}/{}", self.as_str(), other.as_str()).into(), start: 0, @@ -390,10 +347,11 @@ impl<'a> Path<'a> { /// ``` /// use moq_net::{Path, path::Relative}; /// - /// let base = Path::new("a/b/c"); + /// let base = Path::new("a/b/c")?; /// assert_eq!(base.resolve(&Relative::new("./d")).as_str(), "a/b/d"); /// assert_eq!(base.resolve(&Relative::new(".")).as_str(), "a/b"); /// assert_eq!(base.resolve(&Relative::new("../d")).as_str(), "a/d"); + /// # Ok::<(), moq_net::Error>(()) /// ``` pub fn resolve(&self, rel: &Relative<'_>) -> PathOwned { if rel.is_empty() { @@ -477,19 +435,20 @@ impl<'a> Path<'a> { /// use moq_net::Path; /// /// // The base names a broadcast, so its last segment is replaced, not descended into. - /// let base = Path::new("a/b"); - /// assert_eq!(Path::new("a/b/c").relative(&base).unwrap().as_str(), "b/c"); - /// assert_eq!(Path::new("a/c").relative(&base).unwrap().as_str(), "c"); - /// assert_eq!(Path::new("c").relative(&base).unwrap().as_str(), "../c"); + /// let base = Path::new("a/b")?; + /// assert_eq!(Path::new("a/b/c")?.relative(&base).unwrap().as_str(), "b/c"); + /// assert_eq!(Path::new("a/c")?.relative(&base).unwrap().as_str(), "c"); + /// assert_eq!(Path::new("c")?.relative(&base).unwrap().as_str(), "../c"); /// /// // The lone `.` names the base's parent, which the empty reference cannot. - /// assert_eq!(Path::new("a").relative(&base).unwrap().as_str(), "."); + /// assert_eq!(Path::new("a")?.relative(&base).unwrap().as_str(), "."); /// /// // The base itself. - /// assert_eq!(Path::new("a/b").relative(&base).unwrap().as_str(), ""); + /// assert_eq!(Path::new("a/b")?.relative(&base).unwrap().as_str(), ""); /// /// // A segment named `..` is a legal path component but an unnameable target. - /// assert!(Path::new("a/..").relative(&base).is_none()); + /// assert!(Path::new("a/..")?.relative(&base).is_none()); + /// # Ok::<(), moq_net::Error>(()) /// ``` pub fn relative(&self, base: impl AsPath) -> Option { let base = base.as_path(); @@ -565,28 +524,47 @@ impl serde::Serialize for Path<'_> { } } -impl<'a> From<&'a str> for Path<'a> { - fn from(s: &'a str) -> Self { +impl<'a> TryFrom<&'a str> for Path<'a> { + type Error = Error; + + fn try_from(s: &'a str) -> Result { Self::new(s) } } -impl<'a> From<&'a String> for Path<'a> { - fn from(s: &'a String) -> Self { - // TODO avoid making a copy here +impl<'a> TryFrom<&'a String> for Path<'a> { + type Error = Error; + + fn try_from(s: &'a String) -> Result { Self::new(s) } } -impl Default for Path<'_> { - fn default() -> Self { - Path::empty() +impl TryFrom for Path<'_> { + type Error = Error; + + /// Take ownership of the string as a path, refusing it like [`Path::new`]. + fn try_from(s: String) -> Result { + validate(&s)?; + Ok(if s.is_empty() { + Path::empty() + } else { + Path(Repr::Shared { buf: s.into(), start: 0 }) + }) } } -impl From for Path<'_> { - fn from(s: String) -> Self { - Path::new(&s).into_owned() +impl std::str::FromStr for PathOwned { + type Err = Error; + + fn from_str(s: &str) -> Result { + Ok(Path::new(s)?.into_owned()) + } +} + +impl Default for Path<'_> { + fn default() -> Self { + Path::empty() } } @@ -604,7 +582,7 @@ impl Display for Path<'_> { impl Decode for Path<'_> { fn decode(r: &mut Decoder<'_>, _: V) -> Result { - let path: Path = r.string()?.into(); + let path = Path::try_from(r.string()?).map_err(|_| DecodeError::InvalidValue)?; if path.parts().count() > Path::MAX_PARTS { return Err(DecodeError::BoundsExceeded); } @@ -677,11 +655,12 @@ pub type RelativeOwned = Relative<'static>; /// use moq_net::{Path, path::Relative}; /// /// let rel = Relative::new("./source"); -/// assert_eq!(Path::new("a/b").resolve(&rel).as_str(), "a/source"); +/// assert_eq!(Path::new("a/b")?.resolve(&rel).as_str(), "a/source"); /// /// // Redundant `.` segments are stripped on creation. /// assert_eq!(Relative::new("./a/./b").as_str(), "a/b"); /// assert_eq!(Relative::new(".").as_str(), "."); +/// # Ok::<(), moq_net::Error>(()) /// ``` #[derive(Debug, PartialEq, Eq, Hash, Clone, serde::Serialize)] pub struct Relative<'a>(Cow<'a, str>); @@ -816,433 +795,100 @@ impl<'de> serde::Deserialize<'de> for Relative<'static> { mod tests { use super::*; - #[test] - fn test_has_prefix() { - let path = Path::new("foo/bar/baz"); - - // Valid prefixes - test with both &str and &Path - assert!(path.has_prefix("")); - assert!(path.has_prefix("foo")); - assert!(path.has_prefix(Path::new("foo"))); - assert!(path.has_prefix("foo/")); - assert!(path.has_prefix("foo/bar")); - assert!(path.has_prefix(Path::new("foo/bar/"))); - assert!(path.has_prefix("foo/bar/baz")); - - // Invalid prefixes - should not match partial components - assert!(!path.has_prefix("f")); - assert!(!path.has_prefix(Path::new("fo"))); - assert!(!path.has_prefix("foo/b")); - assert!(!path.has_prefix("foo/ba")); - assert!(!path.has_prefix(Path::new("foo/bar/ba"))); - - // Edge case: "foobar" should not match "foo" - let path = Path::new("foobar"); - assert!(!path.has_prefix("foo")); - assert!(path.has_prefix(Path::new("foobar"))); - } - - #[test] - fn test_strip_prefix() { - let path = Path::new("foo/bar/baz"); - - // Test with both &str and &Path - assert_eq!(path.strip_prefix("").unwrap().as_str(), "foo/bar/baz"); - assert_eq!(path.strip_prefix("foo").unwrap().as_str(), "bar/baz"); - assert_eq!(path.strip_prefix(Path::new("foo/")).unwrap().as_str(), "bar/baz"); - assert_eq!(path.strip_prefix("foo/bar").unwrap().as_str(), "baz"); - assert_eq!(path.strip_prefix(Path::new("foo/bar/")).unwrap().as_str(), "baz"); - assert_eq!(path.strip_prefix("foo/bar/baz").unwrap().as_str(), ""); - - // Should fail for invalid prefixes - assert!(path.strip_prefix("fo").is_none()); - assert!(path.strip_prefix(Path::new("bar")).is_none()); + fn p(s: &str) -> Path<'_> { + Path::new(s).unwrap() } #[test] - fn test_join() { - // Test with both &str and &Path - assert_eq!(Path::new("foo").join("bar").as_str(), "foo/bar"); - assert_eq!(Path::new("foo/").join(Path::new("bar")).as_str(), "foo/bar"); - assert_eq!(Path::new("").join("bar").as_str(), "bar"); - assert_eq!(Path::new("foo/bar").join(Path::new("baz")).as_str(), "foo/bar/baz"); - } - - #[test] - fn test_from_conversions() { - let path1 = Path::from("foo/bar"); - let path2 = Path::from("foo/bar"); - let s = String::from("foo/bar"); - let path3 = Path::from(&s); - - assert_eq!(path1.as_str(), "foo/bar"); - assert_eq!(path2.as_str(), "foo/bar"); - assert_eq!(path3.as_str(), "foo/bar"); - } - - #[test] - fn test_path_prefix_join() { - let prefix = Path::new("foo"); - let suffix = Path::new("bar/baz"); - let path = prefix.join(&suffix); - assert_eq!(path.as_str(), "foo/bar/baz"); - - let prefix = Path::new("foo/"); - let suffix = Path::new("bar/baz"); - let path = prefix.join(&suffix); - assert_eq!(path.as_str(), "foo/bar/baz"); - - let prefix = Path::new("foo"); - let suffix = Path::new("/bar/baz"); - let path = prefix.join(&suffix); - assert_eq!(path.as_str(), "foo/bar/baz"); - - let prefix = Path::new(""); - let suffix = Path::new("bar/baz"); - let path = prefix.join(&suffix); - assert_eq!(path.as_str(), "bar/baz"); - } - - #[test] - fn test_path_prefix_conversions() { - let prefix1 = Path::from("foo/bar"); - let prefix2 = Path::from(String::from("foo/bar")); - let s = String::from("foo/bar"); - let prefix3 = Path::from(&s); - - assert_eq!(prefix1.as_str(), "foo/bar"); - assert_eq!(prefix2.as_str(), "foo/bar"); - assert_eq!(prefix3.as_str(), "foo/bar"); - } - - #[test] - fn test_path_suffix_conversions() { - let suffix1 = Path::from("foo/bar"); - let suffix2 = Path::from(String::from("foo/bar")); - let s = String::from("foo/bar"); - let suffix3 = Path::from(&s); - - assert_eq!(suffix1.as_str(), "foo/bar"); - assert_eq!(suffix2.as_str(), "foo/bar"); - assert_eq!(suffix3.as_str(), "foo/bar"); - } - - #[test] - fn test_path_types_basic_operations() { - let prefix = Path::new("foo/bar"); - assert_eq!(prefix.as_str(), "foo/bar"); - assert!(!prefix.is_empty()); - assert_eq!(prefix.len(), 7); - - let suffix = Path::new("baz/qux"); - assert_eq!(suffix.as_str(), "baz/qux"); - assert!(!suffix.is_empty()); - assert_eq!(suffix.len(), 7); - - let empty_prefix = Path::new(""); - assert!(empty_prefix.is_empty()); - assert_eq!(empty_prefix.len(), 0); - - let empty_suffix = Path::new(""); - assert!(empty_suffix.is_empty()); - assert_eq!(empty_suffix.len(), 0); - } - - #[test] - fn test_prefix_has_prefix() { - // Test empty prefix (should match everything) - let prefix = Path::new("foo/bar"); - assert!(prefix.has_prefix("")); - - // Test exact matches - let prefix = Path::new("foo/bar"); - assert!(prefix.has_prefix("foo/bar")); - - // Test valid prefixes - assert!(prefix.has_prefix("foo")); - assert!(prefix.has_prefix("foo/")); - - // Test invalid prefixes - partial matches should fail - assert!(!prefix.has_prefix("f")); - assert!(!prefix.has_prefix("fo")); - assert!(!prefix.has_prefix("foo/b")); - assert!(!prefix.has_prefix("foo/ba")); - - // Test edge cases - let prefix = Path::new("foobar"); - assert!(!prefix.has_prefix("foo")); - assert!(prefix.has_prefix("foobar")); - - // Test trailing slash handling - let prefix = Path::new("foo/bar/"); - assert!(prefix.has_prefix("foo")); - assert!(prefix.has_prefix("foo/")); - assert!(prefix.has_prefix("foo/bar")); - assert!(prefix.has_prefix("foo/bar/")); - - // Test single component - let prefix = Path::new("foo"); - assert!(prefix.has_prefix("")); - assert!(prefix.has_prefix("foo")); - assert!(prefix.has_prefix("foo/")); // "foo/" becomes "foo" after trimming - assert!(!prefix.has_prefix("f")); - - // Test empty prefix - let prefix = Path::new(""); - assert!(prefix.has_prefix("")); - assert!(!prefix.has_prefix("foo")); - } + fn test_refuses_empty_segments() { + for s in ["/", "//", "/foo", "foo/", "/foo/", "foo//bar", "foo/bar/", "a///b"] { + assert!(matches!(Path::new(s), Err(Error::EmptySegment)), "accepted {s:?}"); + assert!(Path::try_from(s.to_string()).is_err(), "accepted owned {s:?}"); + assert!(s.parse::().is_err(), "parsed {s:?}"); + } - #[test] - fn test_prefix_join() { - // Basic joining - let prefix = Path::new("foo"); - let suffix = Path::new("bar"); - assert_eq!(prefix.join(suffix).as_str(), "foo/bar"); - - // Trailing slash on prefix - let prefix = Path::new("foo/"); - let suffix = Path::new("bar"); - assert_eq!(prefix.join(suffix).as_str(), "foo/bar"); - - // Leading slash on suffix - let prefix = Path::new("foo"); - let suffix = Path::new("/bar"); - assert_eq!(prefix.join(suffix).as_str(), "foo/bar"); - - // Trailing slash on suffix - let prefix = Path::new("foo"); - let suffix = Path::new("bar/"); - assert_eq!(prefix.join(suffix).as_str(), "foo/bar"); // trailing slash is trimmed - - // Both have slashes - let prefix = Path::new("foo/"); - let suffix = Path::new("/bar"); - assert_eq!(prefix.join(suffix).as_str(), "foo/bar"); - - // Empty suffix - let prefix = Path::new("foo"); - let suffix = Path::new(""); - assert_eq!(prefix.join(suffix).as_str(), "foo"); - - // Empty prefix - let prefix = Path::new(""); - let suffix = Path::new("bar"); - assert_eq!(prefix.join(suffix).as_str(), "bar"); - - // Both empty - let prefix = Path::new(""); - let suffix = Path::new(""); - assert_eq!(prefix.join(suffix).as_str(), ""); - - // Complex paths - let prefix = Path::new("foo/bar"); - let suffix = Path::new("baz/qux"); - assert_eq!(prefix.join(suffix).as_str(), "foo/bar/baz/qux"); - - // Complex paths with slashes - let prefix = Path::new("foo/bar/"); - let suffix = Path::new("/baz/qux/"); - assert_eq!(prefix.join(suffix).as_str(), "foo/bar/baz/qux"); // all slashes are trimmed - } + // The root has no segments, so none of them is empty. + assert!(Path::new("").unwrap().is_empty()); + assert_eq!(Path::try_from(String::new()).unwrap(), Path::empty()); - #[test] - fn test_path_ref() { - // Test PathRef creation and normalization - let ref1 = Path::new("/foo/bar/"); - assert_eq!(ref1.as_str(), "foo/bar"); - - let ref2 = Path::from("///foo///"); - assert_eq!(ref2.as_str(), "foo"); - - // Test PathRef normalizes multiple slashes - let ref3 = Path::new("foo//bar///baz"); - assert_eq!(ref3.as_str(), "foo/bar/baz"); - - // Test conversions - let path = Path::new("foo/bar"); - let path_ref = path; - assert_eq!(path_ref.as_str(), "foo/bar"); - - // Test that Path methods work with PathRef - let path2 = Path::new("foo/bar/baz"); - assert!(path2.has_prefix(&path_ref)); - assert_eq!(path2.strip_prefix(path_ref).unwrap().as_str(), "baz"); - - // Test empty PathRef - let empty = Path::new(""); - assert!(empty.is_empty()); - assert_eq!(empty.len(), 0); + // Borrowed and owned construction agree on everything else. + for s in ["foo", "foo/bar", ".hidden/x", "a/../b"] { + assert_eq!(p(s), Path::try_from(s.to_string()).unwrap()); + assert_eq!(p(s), s.parse::().unwrap()); + } } #[test] - fn test_multiple_consecutive_slashes() { - let path = Path::new("foo//bar///baz"); - // Multiple consecutive slashes are collapsed to single slashes - assert_eq!(path.as_str(), "foo/bar/baz"); - - // Test with leading and trailing slashes too - let path2 = Path::new("//foo//bar///baz//"); - assert_eq!(path2.as_str(), "foo/bar/baz"); + fn test_decode_refuses_empty_segments() { + use crate::lite::Version; - // Test empty segments are handled correctly - let path3 = Path::new("foo///bar"); - assert_eq!(path3.as_str(), "foo/bar"); + for s in ["/foo", "foo/", "foo//bar"] { + let mut buf = Vec::new(); + Encoder::new(&mut buf, Version::Lite04.into()).string(s).unwrap(); + assert!(matches!( + crate::coding::decode_buf(&mut bytes::Bytes::from(buf), Version::Lite04, Path::decode), + Err(DecodeError::InvalidValue) + )); + } } #[test] - fn test_removes_multiple_slashes_comprehensively() { - // Test various multiple slash scenarios - assert_eq!(Path::new("foo//bar").as_str(), "foo/bar"); - assert_eq!(Path::new("foo///bar").as_str(), "foo/bar"); - assert_eq!(Path::new("foo////bar").as_str(), "foo/bar"); - - // Multiple occurrences of double slashes - assert_eq!(Path::new("foo//bar//baz").as_str(), "foo/bar/baz"); - assert_eq!(Path::new("a//b//c//d").as_str(), "a/b/c/d"); - - // Mixed slash counts - assert_eq!(Path::new("foo//bar///baz////qux").as_str(), "foo/bar/baz/qux"); - - // With leading and trailing slashes - assert_eq!(Path::new("//foo//bar//").as_str(), "foo/bar"); - assert_eq!(Path::new("///foo///bar///").as_str(), "foo/bar"); + fn test_has_prefix() { + let path = p("foo/bar/baz"); - // Edge case: only slashes - assert_eq!(Path::new("//").as_str(), ""); - assert_eq!(Path::new("////").as_str(), ""); + assert!(path.has_prefix(Path::empty())); + assert!(path.has_prefix(p("foo"))); + assert!(path.has_prefix(p("foo/bar"))); + assert!(path.has_prefix(p("foo/bar/baz"))); - // Test that operations work correctly with normalized paths - let path_with_slashes = Path::new("foo//bar///baz"); - assert!(path_with_slashes.has_prefix("foo/bar")); - assert_eq!(path_with_slashes.strip_prefix("foo").unwrap().as_str(), "bar/baz"); - assert_eq!(path_with_slashes.join("qux").as_str(), "foo/bar/baz/qux"); + // Only whole segments match. + assert!(!path.has_prefix(p("f"))); + assert!(!path.has_prefix(p("fo"))); + assert!(!path.has_prefix(p("foo/b"))); + assert!(!path.has_prefix(p("foo/ba"))); + assert!(!path.has_prefix(p("foo/bar/ba"))); + assert!(!p("foobar").has_prefix(p("foo"))); + assert!(p("foobar").has_prefix(p("foobar"))); - // Test PathRef to Path conversion - let path_ref = Path::new("foo//bar///baz"); - assert_eq!(path_ref.as_str(), "foo/bar/baz"); // PathRef now normalizes too - let path_from_ref = path_ref.to_owned(); - assert_eq!(path_from_ref.as_str(), "foo/bar/baz"); // Both are normalized + // The root prefixes everything, and is prefixed only by itself. + assert!(Path::empty().has_prefix(Path::empty())); + assert!(!Path::empty().has_prefix(p("foo"))); } #[test] - fn test_path_ref_multiple_slashes() { - // PathRef now normalizes multiple slashes using Cow - let path_ref = Path::new("//foo//bar///baz//"); - assert_eq!(path_ref.as_str(), "foo/bar/baz"); // Fully normalized - - // Various multiple slash scenarios are normalized in PathRef - assert_eq!(Path::new("foo//bar").as_str(), "foo/bar"); - assert_eq!(Path::new("foo///bar").as_str(), "foo/bar"); - assert_eq!(Path::new("a//b//c//d").as_str(), "a/b/c/d"); - - // Conversion to Path maintains normalized form - assert_eq!(Path::new("foo//bar").to_owned().as_str(), "foo/bar"); - assert_eq!(Path::new("foo///bar").to_owned().as_str(), "foo/bar"); - assert_eq!(Path::new("a//b//c//d").to_owned().as_str(), "a/b/c/d"); + fn test_strip_prefix() { + let path = p("foo/bar/baz"); - // Edge cases - assert_eq!(Path::new("//").as_str(), ""); - assert_eq!(Path::new("////").as_str(), ""); - assert_eq!(Path::new("//").to_owned().as_str(), ""); - assert_eq!(Path::new("////").to_owned().as_str(), ""); + assert_eq!(path.strip_prefix(Path::empty()).unwrap().as_str(), "foo/bar/baz"); + assert_eq!(path.strip_prefix(p("foo")).unwrap().as_str(), "bar/baz"); + assert_eq!(path.strip_prefix(p("foo/bar")).unwrap().as_str(), "baz"); + assert_eq!(path.strip_prefix(p("foo/bar/baz")).unwrap().as_str(), ""); - // Test that PathRef avoids allocation when no normalization needed - let normal_path = Path::new("foo/bar/baz"); - assert_eq!(normal_path.as_str(), "foo/bar/baz"); - // This should use Cow::Borrowed internally (no allocation) + assert!(path.strip_prefix(p("fo")).is_none()); + assert!(path.strip_prefix(p("bar")).is_none()); + assert!(path.strip_prefix(p("foo/ba")).is_none()); + assert!(p("foobar").strip_prefix(p("foo")).is_none()); - let needs_norm = Path::new("foo//bar"); - assert_eq!(needs_norm.as_str(), "foo/bar"); - // This should use Cow::Owned internally (allocation only when needed) + assert_eq!(Path::empty().strip_prefix(Path::empty()).unwrap().as_str(), ""); + assert!(Path::empty().strip_prefix(p("foo")).is_none()); } #[test] - fn test_ergonomic_conversions() { - // Test that all these work ergonomically in function calls - fn takes_path_ref<'a>(p: impl Into>) -> String { - p.into().as_str().to_string() - } - - // Alternative API using the trait alias for better error messages - fn takes_path_ref_with_trait<'a>(p: impl Into>) -> String { - p.into().as_str().to_string() - } - - // String literal - assert_eq!(takes_path_ref("foo//bar"), "foo/bar"); - - // String (owned) - this should now work without & - let owned_string = String::from("foo//bar///baz"); - assert_eq!(takes_path_ref(owned_string), "foo/bar/baz"); - - // &String - let string_ref = String::from("foo//bar"); - assert_eq!(takes_path_ref(string_ref), "foo/bar"); - - // PathRef - let path_ref = Path::new("foo//bar"); - assert_eq!(takes_path_ref(path_ref), "foo/bar"); - - // Path - let path = Path::new("foo//bar"); - assert_eq!(takes_path_ref(path), "foo/bar"); - - // Test that Path::new works with all these types - let _path1 = Path::new("foo/bar"); // &str - let _path2 = Path::new("foo/bar"); // String - should now work - let _path3 = Path::new("foo/bar"); // &String - let _path4 = Path::new("foo/bar"); // PathRef - - // Test the trait alias version works the same - assert_eq!(takes_path_ref_with_trait("foo//bar"), "foo/bar"); - assert_eq!(takes_path_ref_with_trait(String::from("foo//bar")), "foo/bar"); - } + fn test_join() { + assert_eq!(p("foo").join(p("bar")).as_str(), "foo/bar"); + assert_eq!(p("foo/bar").join(p("baz/qux")).as_str(), "foo/bar/baz/qux"); - #[test] - fn test_prefix_strip_prefix() { - // Test basic stripping - let prefix = Path::new("foo/bar/baz"); - assert_eq!(prefix.strip_prefix("").unwrap().as_str(), "foo/bar/baz"); - assert_eq!(prefix.strip_prefix("foo").unwrap().as_str(), "bar/baz"); - assert_eq!(prefix.strip_prefix("foo/").unwrap().as_str(), "bar/baz"); - assert_eq!(prefix.strip_prefix("foo/bar").unwrap().as_str(), "baz"); - assert_eq!(prefix.strip_prefix("foo/bar/").unwrap().as_str(), "baz"); - assert_eq!(prefix.strip_prefix("foo/bar/baz").unwrap().as_str(), ""); - - // Test invalid prefixes - assert!(prefix.strip_prefix("fo").is_none()); - assert!(prefix.strip_prefix("bar").is_none()); - assert!(prefix.strip_prefix("foo/ba").is_none()); - - // Test edge cases - let prefix = Path::new("foobar"); - assert!(prefix.strip_prefix("foo").is_none()); - assert_eq!(prefix.strip_prefix("foobar").unwrap().as_str(), ""); - - // Test empty prefix - let prefix = Path::new(""); - assert_eq!(prefix.strip_prefix("").unwrap().as_str(), ""); - assert!(prefix.strip_prefix("foo").is_none()); - - // Test single component - let prefix = Path::new("foo"); - assert_eq!(prefix.strip_prefix("foo").unwrap().as_str(), ""); - assert_eq!(prefix.strip_prefix("foo/").unwrap().as_str(), ""); // "foo/" becomes "foo" after trimming - - // Test trailing slash handling - let prefix = Path::new("foo/bar/"); - assert_eq!(prefix.strip_prefix("foo").unwrap().as_str(), "bar"); - assert_eq!(prefix.strip_prefix("foo/").unwrap().as_str(), "bar"); - assert_eq!(prefix.strip_prefix("foo/bar").unwrap().as_str(), ""); - assert_eq!(prefix.strip_prefix("foo/bar/").unwrap().as_str(), ""); + // The root is the identity on either side. + assert_eq!(p("foo").join(Path::empty()).as_str(), "foo"); + assert_eq!(Path::empty().join(p("bar")).as_str(), "bar"); + assert_eq!(Path::empty().join(Path::empty()).as_str(), ""); } // Pointer-equality checks that owned paths share one allocation through the // clone / to_owned / strip_prefix flow used by origin announce fan-out. #[test] fn test_owned_paths_share_allocation() { - let path = Path::new("customer/room/broadcast").to_owned(); + let path = p("customer/room/broadcast").to_owned(); // Cloning an owned path shares the buffer. let cloned = path.clone(); @@ -1253,7 +899,7 @@ mod tests { assert_eq!(path.as_str().as_ptr(), requeued.as_str().as_ptr()); // Stripping a prefix from an owned path is offset arithmetic, not a copy. - let stripped = path.strip_prefix("customer").unwrap().to_owned(); + let stripped = path.strip_prefix(p("customer")).unwrap().to_owned(); assert_eq!(stripped.as_str(), "room/broadcast"); assert_eq!(stripped.as_str().as_ptr(), path.as_str()["customer/".len()..].as_ptr()); @@ -1264,7 +910,7 @@ mod tests { assert_eq!(rest.as_str().as_ptr(), stripped.as_str().as_ptr()); // join produces an owned path whose clones share. - let joined = path.join("alice"); + let joined = path.join(p("alice")); let joined2 = joined.clone(); assert_eq!(joined.as_str(), "customer/room/broadcast/alice"); assert_eq!(joined.as_str().as_ptr(), joined2.as_str().as_ptr()); @@ -1273,8 +919,7 @@ mod tests { #[test] fn test_parts() { assert_eq!(Path::empty().parts().count(), 0); - assert_eq!(Path::new("foo").parts().collect::>(), ["foo"]); - assert_eq!(Path::new("/foo//bar/").parts().collect::>(), ["foo", "bar"]); + assert_eq!(p("foo").parts().collect::>(), ["foo"]); } #[test] @@ -1289,11 +934,11 @@ mod tests { // Encode enforces the limit. let mut buf = Vec::new(); - Path::new(&ok) + p(&ok) .encode(&mut Encoder::new(&mut buf, Version::Lite04.into()), Version::Lite04) .unwrap(); assert!(matches!( - Path::new(&too_deep).encode_bytes(Version::Lite04), + p(&too_deep).encode_bytes(Version::Lite04), Err(EncodeError::BoundsExceeded) )); @@ -1315,12 +960,12 @@ mod tests { #[test] fn test_owned_empty_paths() { // Empty paths never allocate and stay well-behaved. - let empty = Path::new("").to_owned(); + let empty = p("").to_owned(); assert!(empty.is_empty()); assert_eq!(empty, Path::empty()); - let path = Path::new("foo").to_owned(); - let rest = path.strip_prefix("foo").unwrap().to_owned(); + let path = p("foo").to_owned(); + let rest = path.strip_prefix(p("foo")).unwrap().to_owned(); assert!(rest.is_empty()); } @@ -1348,11 +993,11 @@ mod tests { #[test] fn test_resolve_replaces_base_name() { - let base = Path::new("a/b"); + let base = p("a/b"); assert_eq!(base.resolve(&Relative::new("c")).as_str(), "a/c"); assert_eq!(base.resolve(&Relative::new("c/d")).as_str(), "a/c/d"); assert_eq!( - Path::new("foo.hang/catalog.pro") + p("foo.hang/catalog.pro") .resolve(&Relative::new("./transcode.pro")) .as_str(), "foo.hang/transcode.pro" @@ -1361,27 +1006,27 @@ mod tests { #[test] fn test_resolve_empty_rel_returns_base() { - let base = Path::new("a/b"); + let base = p("a/b"); assert_eq!(base.resolve(&Relative::new("")).as_str(), "a/b"); } #[test] fn test_resolve_single_dotdot() { - let base = Path::new("a/b/c"); + let base = p("a/b/c"); assert_eq!(base.resolve(&Relative::new("../d")).as_str(), "a/d"); assert_eq!(base.resolve(&Relative::new("..")).as_str(), "a"); } #[test] fn test_resolve_multiple_dotdot() { - let base = Path::new("a/b/c"); + let base = p("a/b/c"); assert_eq!(base.resolve(&Relative::new("../../x")).as_str(), "x"); assert_eq!(base.resolve(&Relative::new("../../../x")).as_str(), "x"); } #[test] fn test_resolve_dotdot_clamps_at_root() { - let base = Path::new("a"); + let base = p("a"); // Excess `..` clamps at the root instead of escaping it. assert_eq!(base.resolve(&Relative::new("../../../foo")).as_str(), "foo"); assert_eq!(base.resolve(&Relative::new("..")).as_str(), ""); @@ -1396,7 +1041,7 @@ mod tests { #[test] fn test_resolve_dot_names_parent() { - let base = Path::new("a/b"); + let base = p("a/b"); assert_eq!(base.resolve(&Relative::new(".")).as_str(), "a"); assert_eq!(base.resolve(&Relative::new("./c")).as_str(), "a/c"); assert_eq!(base.resolve(&Relative::new("./../c")).as_str(), "c"); @@ -1406,24 +1051,24 @@ mod tests { fn test_resolve_self_reference_via_sibling_name() { // Naming the base within its parent yields the base unchanged, which lets the // caller compare resolved == base to detect a self-reference. - let base = Path::new("a/b"); + let base = p("a/b"); assert_eq!(base.resolve(&Relative::new("./b")).as_str(), "a/b"); } #[test] fn test_try_resolve_distinguishes_root_from_escape() { - let base = Path::new("top"); + let base = p("top"); assert_eq!(base.try_resolve(&Relative::new(".")).unwrap().as_str(), ""); assert!(base.try_resolve(&Relative::new("..")).is_none()); - let nested = Path::new("a/b"); + let nested = p("a/b"); assert_eq!(nested.try_resolve(&Relative::new("..")).unwrap().as_str(), ""); assert!(nested.try_resolve(&Relative::new("../..")).is_none()); } #[test] fn test_relative() { - let rel = |target: &str, base: &str| Path::new(target).relative(base).unwrap(); + let rel = |target: &str, base: &str| p(target).relative(p(base)).unwrap(); // Nested under the base: the base's own last segment is replaced, so it repeats. assert_eq!(rel("foo/bar/baz", "foo/bar").as_str(), "bar/baz"); @@ -1440,25 +1085,23 @@ mod tests { // The base itself, which only the empty reference names. assert_eq!(rel("a/b", "a/b").as_str(), ""); assert_eq!(rel("", "").as_str(), ""); - // Slashes are normalized first. - assert_eq!(rel("/a//b/", "//a/b/dir//").as_str(), "."); } #[test] fn test_relative_rejects_unnameable_targets() { // A segment literally named `.` or `..` is a legal path component, but resolution // would walk on it instead of naming it. - assert!(Path::new("a/../b").relative("").is_none()); - assert!(Path::new("x/./y").relative("x/z").is_none()); - assert!(Path::new("a/..").relative("a/b").is_none()); + assert!(p("a/../b").relative(p("")).is_none()); + assert!(p("x/./y").relative(p("x/z")).is_none()); + assert!(p("a/..").relative(p("a/b")).is_none()); // A base is always nameable by itself, however its last segment is spelled. - assert_eq!(Path::new("a/..").relative("a/..").unwrap().as_str(), ""); + assert_eq!(p("a/..").relative(p("a/..")).unwrap().as_str(), ""); // Dot segments inside the shared prefix are never emitted, so they are fine. - let rel = Path::new("a/../b/x").relative("a/../b/c").unwrap(); + let rel = p("a/../b/x").relative(p("a/../b/c")).unwrap(); assert_eq!(rel.as_str(), "x"); - assert_eq!(Path::new("a/../b/c").resolve(&rel).as_str(), "a/../b/x"); + assert_eq!(p("a/../b/c").resolve(&rel).as_str(), "a/../b/x"); } #[test] @@ -1469,8 +1112,8 @@ mod tests { for base in paths { for target in paths { - let base = Path::new(base); - let target = Path::new(target); + let base = p(base); + let target = p(target); let Some(rel) = target.relative(&base) else { // Only an unnameable target may be refused, and never the base itself. assert!( From a0977b1e02d6a0312fbb0e1002523bff16d590af Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sat, 24 Oct 2026 21:58:43 -0700 Subject: [PATCH 04/67] wip: migrate moq-net callers to strict Path --- rs/moq-net/benches/announce.rs | 7 +- rs/moq-net/benches/auth.rs | 5 +- rs/moq-net/benches/interests.rs | 3 +- rs/moq-net/benches/memory.rs | 7 +- rs/moq-net/benches/origin.rs | 111 +- rs/moq-net/benches/retirement.rs | 6 +- rs/moq-net/benches/session.rs | 13 +- rs/moq-net/benches/stats.rs | 26 +- rs/moq-net/benches/synced.rs | 10 +- rs/moq-net/benches/viewers.rs | 7 +- rs/moq-net/src/auth.rs | 12 +- rs/moq-net/src/client.rs | 5 +- rs/moq-net/src/coding/reader.rs | 3 +- rs/moq-net/src/coding/writer.rs | 7 +- rs/moq-net/src/fuzz.rs | 41 +- rs/moq-net/src/ietf/adapter.rs | 23 +- rs/moq-net/src/ietf/fetch.rs | 14 +- rs/moq-net/src/ietf/namespace.rs | 2 +- rs/moq-net/src/ietf/publish.rs | 22 +- rs/moq-net/src/ietf/publish_namespace.rs | 10 +- rs/moq-net/src/ietf/publisher.rs | 214 +-- rs/moq-net/src/ietf/publisher/tracks.rs | 19 +- rs/moq-net/src/ietf/request_stream.rs | 3 +- rs/moq-net/src/ietf/session.rs | 33 +- rs/moq-net/src/ietf/subscribe.rs | 26 +- rs/moq-net/src/ietf/subscribe_namespace.rs | 32 +- rs/moq-net/src/ietf/subscribe_tracks.rs | 4 +- rs/moq-net/src/ietf/subscriber.rs | 218 +-- rs/moq-net/src/ietf/subscriber/tracks.rs | 10 +- rs/moq-net/src/ietf/track.rs | 12 +- rs/moq-net/src/ietf/version.rs | 8 +- rs/moq-net/src/lite/announce.rs | 30 +- rs/moq-net/src/lite/compress.rs | 24 +- rs/moq-net/src/lite/fetch.rs | 4 +- rs/moq-net/src/lite/ietf.rs | 19 +- rs/moq-net/src/lite/publisher.rs | 119 +- rs/moq-net/src/lite/subscribe.rs | 2 +- rs/moq-net/src/lite/subscriber.rs | 132 +- rs/moq-net/src/lite/track.rs | 6 +- rs/moq-net/src/lite/tracks.rs | 6 +- rs/moq-net/src/model/follow.rs | 83 +- rs/moq-net/src/model/group.rs | 5 +- rs/moq-net/src/model/origin.rs | 1420 ++++++++--------- rs/moq-net/src/server.rs | 11 +- rs/moq-net/src/stats.rs | 201 +-- rs/moq-net/src/test_interop.rs | 4 +- rs/moq-net/tests/announce_allocs.rs | 7 +- .../integration/announce_covering_route.rs | 9 +- .../tests/integration/announce_to_serve.rs | 5 +- rs/moq-net/tests/integration/auth.rs | 111 +- .../tests/integration/broadcast_close.rs | 9 +- .../tests/integration/catalog_acquisition.rs | 7 +- rs/moq-net/tests/integration/catalog_churn.rs | 7 +- .../tests/integration/catalog_handover.rs | 9 +- rs/moq-net/tests/integration/compress.rs | 23 +- rs/moq-net/tests/integration/control_stats.rs | 15 +- rs/moq-net/tests/integration/datagram.rs | 19 +- .../tests/integration/dial_split_horizon.rs | 7 +- rs/moq-net/tests/integration/drained_claim.rs | 5 +- rs/moq-net/tests/integration/empty_group.rs | 7 +- .../tests/integration/empty_replacement.rs | 7 +- rs/moq-net/tests/integration/extensions.rs | 5 +- rs/moq-net/tests/integration/fetch_cancel.rs | 9 +- rs/moq-net/tests/integration/fetch_fanout.rs | 5 +- .../tests/integration/fetch_from_feed.rs | 7 +- rs/moq-net/tests/integration/fetch_only.rs | 9 +- .../integration/finished_broadcast_mock.rs | 7 +- rs/moq-net/tests/integration/finite_relay.rs | 7 +- rs/moq-net/tests/integration/goaway.rs | 11 +- rs/moq-net/tests/integration/group_order.rs | 9 +- .../tests/integration/history_groups.rs | 17 +- .../tests/integration/idle_cancel_refetch.rs | 7 +- rs/moq-net/tests/integration/idle_session.rs | 5 +- .../tests/integration/ietf_conformance.rs | 7 +- .../tests/integration/late_lower_group.rs | 9 +- .../tests/integration/lazy_discovery.rs | 29 +- rs/moq-net/tests/integration/mesh_withdraw.rs | 21 +- rs/moq-net/tests/integration/model.rs | 13 +- rs/moq-net/tests/integration/multi_cdn.rs | 5 +- rs/moq-net/tests/integration/partial_group.rs | 7 +- rs/moq-net/tests/integration/quiet_catalog.rs | 7 +- rs/moq-net/tests/integration/range_anchors.rs | 9 +- .../tests/integration/received_rewind.rs | 13 +- rs/moq-net/tests/integration/refresh.rs | 13 +- rs/moq-net/tests/integration/rejoin.rs | 61 +- .../tests/integration/relay_upstream_close.rs | 7 +- rs/moq-net/tests/integration/replacement.rs | 17 +- rs/moq-net/tests/integration/request_caps.rs | 13 +- rs/moq-net/tests/integration/restart.rs | 25 +- rs/moq-net/tests/integration/route_change.rs | 41 +- rs/moq-net/tests/integration/session_close.rs | 23 +- rs/moq-net/tests/integration/session_panic.rs | 7 +- .../integration/settled_end_survives_abort.rs | 3 +- rs/moq-net/tests/integration/source_errors.rs | 7 +- rs/moq-net/tests/integration/stream_credit.rs | 5 +- .../tests/integration/subscribe_priority.rs | 7 +- .../tests/integration/subscribe_ranges.rs | 7 +- .../tests/integration/subscribe_tracks.rs | 7 +- .../tests/integration/subscriber_max_age.rs | 7 +- .../integration/subscription_end_integrity.rs | 13 +- rs/moq-net/tests/integration/synced.rs | 9 +- .../integration/track_abort_over_session.rs | 11 +- .../tests/integration/track_info_cancel.rs | 9 +- .../tests/integration/track_stream_demand.rs | 13 +- rs/moq-net/tests/integration/track_tail.rs | 7 +- rs/moq-net/tests/integration/tracks.rs | 15 +- rs/moq-net/tests/integration/tracks_ietf.rs | 27 +- .../tests/integration/unannounce_release.rs | 7 +- rs/moq-net/tests/integration/untimed.rs | 15 +- rs/moq-net/tests/integration/wide_hop.rs | 7 +- rs/moq-net/tests/integration/wide_sequence.rs | 23 +- rs/moq-net/tests/integration/zero_copy.rs | 7 +- 112 files changed, 1979 insertions(+), 1878 deletions(-) diff --git a/rs/moq-net/benches/announce.rs b/rs/moq-net/benches/announce.rs index 42b4c870891..99aa70a1d19 100644 --- a/rs/moq-net/benches/announce.rs +++ b/rs/moq-net/benches/announce.rs @@ -16,6 +16,7 @@ //! //! Run with `cargo bench -p moq-net --features fuzz --bench announce`. +use moq_net::Path; use criterion::{BatchSize, BenchmarkId, Criterion, Throughput, criterion_group, criterion_main}; use moq_net::{ Hop, Hops, PathOwned, announce, @@ -52,7 +53,7 @@ fn initial(c: &mut Criterion) { .flat_map(|cost| { (0..routes).map(move |route| { announce::Event::Update(announce::Announce { - prefix: format!("route/{route}").into(), + prefix: Path::try_from(format!("route/{route}")).unwrap(), captures: None, route: moq_net::origin::Route::default().with_cost(cost), }) @@ -129,12 +130,12 @@ fn health(n: u64) -> (PathOwned, Hops) { n % 16, 1_700_000_000 + n ); - (path.into(), hops(&[id(origin), id(100), id(101)])) + (Path::try_from(path).unwrap(), hops(&[id(origin), id(100), id(101)])) } fn unique(n: u64) -> (PathOwned, Hops) { ( - format!("{:x}", id(n)).into(), + Path::try_from(format!("{:x}", id(n))).unwrap(), hops(&[id(n + 1_000_000), id(n + 2_000_000)]), ) } diff --git a/rs/moq-net/benches/auth.rs b/rs/moq-net/benches/auth.rs index 584fbdefece..b653ba084b9 100644 --- a/rs/moq-net/benches/auth.rs +++ b/rs/moq-net/benches/auth.rs @@ -13,6 +13,7 @@ #[path = "../tests/integration/support/mod.rs"] mod support; +use moq_net::Path; use bytes::Bytes; use criterion::{BenchmarkId, Criterion, Throughput, criterion_group, criterion_main}; use futures::future::join_all; @@ -186,7 +187,7 @@ fn renewal(c: &mut Criterion) { let auths = runtime .block_on(async { [handle.add("a").await.unwrap().0, handle.add("b").await.unwrap().0] }); let broadcasts: Vec<_> = (0..routes) - .map(|route| origin.create_broadcast(format!("room/{route}").as_str()).unwrap()) + .map(|route| origin.create_broadcast(Path::new(format!("room/{route}").as_str()).unwrap()).unwrap()) .collect(); let mut swap = |auth: &auth::Auth, touched: usize| { for broadcast in broadcasts.iter().take(touched) { @@ -267,7 +268,7 @@ fn waiting(c: &mut Criterion) { let broadcasts: Vec<_> = (0..paths) .map(|path| { let broadcast = - publish.create_broadcast(format!("{prefix}{path}").as_str()).unwrap(); + publish.create_broadcast(Path::new(format!("{prefix}{path}").as_str()).unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); broadcast }) diff --git a/rs/moq-net/benches/interests.rs b/rs/moq-net/benches/interests.rs index 505aecf666e..d6ca426af99 100644 --- a/rs/moq-net/benches/interests.rs +++ b/rs/moq-net/benches/interests.rs @@ -14,6 +14,7 @@ //! //! Run with `cargo bench -p moq-net --features fuzz --bench interests`. +use moq_net::Path; use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main}; use moq_net::{Hop, Pattern, Patterns, announce, fuzz, origin}; @@ -51,7 +52,7 @@ fn table(watches: usize, sessions: usize) -> Table { fn scoped(producer: &origin::Producer, prefix: &str) -> origin::Consumer { producer .consume() - .scope(prefix, &Patterns::from(Pattern::all())) + .scope(Path::new(prefix).unwrap(), &Patterns::from(Pattern::all())) .unwrap() } diff --git a/rs/moq-net/benches/memory.rs b/rs/moq-net/benches/memory.rs index 84caeb0f528..fff061188a2 100644 --- a/rs/moq-net/benches/memory.rs +++ b/rs/moq-net/benches/memory.rs @@ -18,6 +18,7 @@ reason = "custom timings measure the real time the work took, not the ambient clock" )] +use moq_net::Path; use std::alloc::{GlobalAlloc, Layout, System}; use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; use std::time::{Duration, Instant}; @@ -134,7 +135,7 @@ impl Link { } ); - let broadcast = publisher.create_broadcast("bench").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bench").unwrap()).unwrap(); let info = track::Info::default().with_timescale(moq_net::Timescale::MILLI); let tracks: Vec<_> = (0..streams) .map(|index| broadcast.create_track(format!("{index}"), info.clone()).unwrap()) @@ -142,8 +143,8 @@ impl Link { broadcast.announce(Default::default()).unwrap(); let consumer = subscriber.consume(); - consumer.routed("bench").await.unwrap(); - let remote = consumer.request_broadcast("bench", None).await.unwrap(); + consumer.routed(Path::new("bench").unwrap()).await.unwrap(); + let remote = consumer.request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); let mut subscribers = Vec::new(); for index in 0..streams { let track = remote.track(&format!("{index}")).unwrap(); diff --git a/rs/moq-net/benches/origin.rs b/rs/moq-net/benches/origin.rs index a293163e86d..23b6cfc5057 100644 --- a/rs/moq-net/benches/origin.rs +++ b/rs/moq-net/benches/origin.rs @@ -39,6 +39,7 @@ #[path = "../tests/integration/support/mod.rs"] mod support; +use moq_net::Path; use std::pin::Pin; use std::sync::{Arc, Mutex}; use std::task::{Context, Poll, Wake, Waker}; @@ -77,7 +78,7 @@ fn fanout(publishers: usize, subscribers: usize) -> Fanout { let (producer, driver) = origin::Producer::new(origin::Config::default()); let consumer = producer.consume(); let publishers = (0..publishers) - .map(|i| producer.publish(format!("room/{i}"), origin::Route::default()).unwrap()) + .map(|i| producer.publish(Path::try_from(format!("room/{i}")).unwrap(), origin::Route::default()).unwrap()) .collect(); let mut subscribers: Vec = (0..subscribers).map(|_| consumer.announced()).collect(); // Drain the replay so each iteration measures only what it adds. @@ -104,7 +105,7 @@ fn bench_announce(c: &mut Criterion) { b.iter(|| { let handle = fleet .producer - .publish("room/incoming", origin::Route::default()) + .publish(Path::new("room/incoming").unwrap(), origin::Route::default()) .unwrap(); for cursor in &mut fleet.subscribers { cursor.next().now_or_never().flatten().expect("announce delivered"); @@ -127,7 +128,7 @@ fn bench_pending_churn(c: &mut Criterion) { group.bench_function(format!("{routes}routes_{readers}readers"), |b| { let (producer, _driver) = origin::Producer::new(origin::Config::default()); let _routes: Vec<_> = (0..routes) - .map(|i| producer.publish(format!("z/{i}"), origin::Route::default()).unwrap()) + .map(|i| producer.publish(Path::try_from(format!("z/{i}")).unwrap(), origin::Route::default()).unwrap()) .collect(); let mut cursors: Vec<_> = (0..readers).map(|_| producer.consume().announced()).collect(); let mut sequence = 0u64; @@ -135,7 +136,7 @@ fn bench_pending_churn(c: &mut Criterion) { sequence += 1; drop( producer - .publish(format!("a/{sequence}"), origin::Route::default()) + .publish(Path::try_from(format!("a/{sequence}")).unwrap(), origin::Route::default()) .unwrap(), ); }); @@ -165,7 +166,7 @@ fn bench_withdraw(c: &mut Criterion) { .poll(moq_net::time::Instant::now(), &kio::Waiter::noop()) .unwrap(); let routes: Vec<_> = (0..publishers) - .map(|i| producer.dynamic_route(format!("room/{i}"), peer_route(9, 1)).unwrap()) + .map(|i| producer.dynamic_route(Path::try_from(format!("room/{i}")).unwrap(), peer_route(9, 1)).unwrap()) .collect(); let mut cursors: Vec<_> = (0..subscribers).map(|_| producer.consume().announced()).collect(); for cursor in &mut cursors { @@ -219,10 +220,10 @@ fn bench_withdraw_wave(c: &mut Criterion) { .poll(moq_net::time::Instant::now(), &kio::Waiter::noop()) .unwrap(); let near: Vec<_> = (0..broadcasts) - .map(|i| producer.dynamic_route(format!("room/{i}"), route(&[9, 2])).unwrap()) + .map(|i| producer.dynamic_route(Path::try_from(format!("room/{i}")).unwrap(), route(&[9, 2])).unwrap()) .collect(); let far: Vec<_> = (0..broadcasts) - .map(|i| producer.dynamic_route(format!("room/{i}"), route(&[9, 3, 4])).unwrap()) + .map(|i| producer.dynamic_route(Path::try_from(format!("room/{i}")).unwrap(), route(&[9, 3, 4])).unwrap()) .collect(); let mut cursors: Vec<_> = (0..subscribers).map(|_| producer.consume().announced()).collect(); for cursor in &mut cursors { @@ -266,13 +267,13 @@ fn bench_route_churn(c: &mut Criterion) { group.bench_function(id, |b| { let (producer, _driver) = origin::Producer::new(origin::Config::default()); let _routes: Vec<_> = (0..broadcasts) - .map(|i| producer.dynamic_route(format!("room/{i}"), peer_route(1, 1)).unwrap()) + .map(|i| producer.dynamic_route(Path::try_from(format!("room/{i}")).unwrap(), peer_route(1, 1)).unwrap()) .collect(); let mut cursors: Vec<_> = (0..subscribers).map(|_| producer.consume().announced()).collect(); for cursor in &mut cursors { while cursor.try_next().is_some() {} } - b.iter(|| drop(producer.dynamic_route("room/0", peer_route(2, 5)).unwrap())); + b.iter(|| drop(producer.dynamic_route(Path::new("room/0").unwrap(), peer_route(2, 5)).unwrap())); for cursor in &mut cursors { assert!(cursor.try_next().is_none(), "the winner is unchanged"); } @@ -296,16 +297,16 @@ fn bench_announce_mounted(c: &mut Criterion) { let _publishers: Vec<_> = (0..publishers) .map(|i| { producer - .publish(format!(".svc/p0/{i}"), origin::Route::default()) + .publish(Path::try_from(format!(".svc/p0/{i}")).unwrap(), origin::Route::default()) .unwrap() }) .collect(); let mut cursors: Vec = (0..subscribers) .map(|project| { producer - .mount(format!("p{project}/.svc"), ".svc/p0") + .mount(Path::try_from(format!("p{project}/.svc")).unwrap(), Path::new(".svc/p0").unwrap()) .unwrap() - .scope(format!("p{project}"), &Patterns::from(Pattern::all())) + .scope(Path::try_from(format!("p{project}")).unwrap(), &Patterns::from(Pattern::all())) .unwrap() .consume() .with_hidden(true) @@ -317,7 +318,7 @@ fn bench_announce_mounted(c: &mut Criterion) { } b.iter(|| { - let handle = producer.publish(".svc/p0/incoming", origin::Route::default()).unwrap(); + let handle = producer.publish(Path::new(".svc/p0/incoming").unwrap(), origin::Route::default()).unwrap(); for cursor in &mut cursors { cursor.next().now_or_never().flatten().expect("announce delivered"); } @@ -347,7 +348,7 @@ fn bench_announce_fleet(c: &mut Criterion) { .flat_map(|project| (0..nodes).map(move |node| (project, node))) .map(|(project, node)| { producer - .publish(format!(".stats/p{project}/node/edge{node}"), origin::Route::default()) + .publish(Path::try_from(format!(".stats/p{project}/node/edge{node}")).unwrap(), origin::Route::default()) .unwrap() }) .collect(); @@ -356,12 +357,12 @@ fn bench_announce_fleet(c: &mut Criterion) { let patterns: Patterns = [Pattern::subtree(&format!(".stats/p{}", peer % projects)).unwrap()] .into_iter() .collect(); - consumer.scope("", &patterns).unwrap().announced() + consumer.scope(Path::new("").unwrap(), &patterns).unwrap().announced() }) .collect(); b.iter(|| { let handle = producer - .publish(".stats/p0/node/incoming", origin::Route::default()) + .publish(Path::new(".stats/p0/node/incoming").unwrap(), origin::Route::default()) .unwrap(); drop(handle); }); @@ -398,7 +399,7 @@ fn bench_announce_duplicate(c: &mut Criterion) { let _routes: Vec<_> = (1..=duplicates) .map(|peer| { producer - .dynamic_route(PATH, peer_route(peer as u64, INCUMBENT_COST)) + .dynamic_route(Path::new(PATH).unwrap(), peer_route(peer as u64, INCUMBENT_COST)) .unwrap() }) .collect(); @@ -411,7 +412,7 @@ fn bench_announce_duplicate(c: &mut Criterion) { b.iter(|| { let handle = producer - .dynamic_route(PATH, peer_route(duplicates as u64 + 1, INCUMBENT_COST - 1)) + .dynamic_route(Path::new(PATH).unwrap(), peer_route(duplicates as u64 + 1, INCUMBENT_COST - 1)) .unwrap(); for cursor in &mut cursors { cursor.next().now_or_never().flatten().expect("announce delivered"); @@ -443,24 +444,24 @@ fn bench_reprice_duplicate(c: &mut Criterion) { .map(|peer| { producer .scope( - "", + Path::new("").unwrap(), &Patterns::from(Pattern::subtree(&format!("{PATH}/p{}", (peer - 1) % 2)).unwrap()), ) .unwrap() - .dynamic_route(PATH, peer_route(peer as u64, incumbent_cost)) + .dynamic_route(Path::new(PATH).unwrap(), peer_route(peer as u64, incumbent_cost)) .unwrap() }) .collect(); let challenger = duplicates as u64 + 1; let route = producer - .dynamic_route(PATH, peer_route(challenger, incumbent_cost + 1)) + .dynamic_route(Path::new(PATH).unwrap(), peer_route(challenger, incumbent_cost + 1)) .unwrap(); let mut cursors: Vec = (0..subscribers) .map(|peer| { producer .consume() .scope( - "", + Path::new("").unwrap(), &Patterns::from(Pattern::subtree(&format!("{PATH}/p{}", peer % 2)).unwrap()), ) .unwrap() @@ -515,15 +516,15 @@ fn bench_announce_fronts(c: &mut Criterion) { let (producer, mut driver) = origin::Producer::new(origin::Config::default()); let consumer = producer.consume(); // Served but never answered: every request under it parks a front. - let _served = producer.dynamic_route("room", origin::Route::default()).unwrap(); + let _served = producer.dynamic_route(Path::new("room").unwrap(), origin::Route::default()).unwrap(); let _requests: Vec<_> = (0..fronts) - .map(|i| consumer.request_broadcast(format!("room/{i}"), None)) + .map(|i| consumer.request_broadcast(Path::try_from(format!("room/{i}")).unwrap(), None)) .collect(); let waiter = kio::Waiter::noop(); // Run each front once so it parks on its upstream request. driver.poll(moq_net::time::Instant::now(), &waiter).unwrap(); b.iter(|| { - let handle = producer.publish("other/incoming", origin::Route::default()).unwrap(); + let handle = producer.publish(Path::new("other/incoming").unwrap(), origin::Route::default()).unwrap(); driver.poll(moq_net::time::Instant::now(), &waiter).unwrap(); drop(handle); driver.poll(moq_net::time::Instant::now(), &waiter).unwrap(); @@ -557,7 +558,7 @@ fn bench_serve_idle(c: &mut Criterion) { let dynamics: Vec<_> = (0..routes) .map(|i| { producer - .dynamic_route(format!(".stats/p{}/node/edge{i}", i % 8), origin::Route::default()) + .dynamic_route(Path::try_from(format!(".stats/p{}/node/edge{i}", i % 8)).unwrap(), origin::Route::default()) .unwrap() }) .collect(); @@ -607,11 +608,11 @@ fn bench_request(c: &mut Criterion) { for publishers in [100, 1_000] { let mut fleet = fanout(publishers, 0); // A broadcast above the misses covers them without serving them. - let _covering = fleet.producer.publish("room", origin::Route::default()).unwrap(); + let _covering = fleet.producer.publish(Path::new("room").unwrap(), origin::Route::default()).unwrap(); let waiter = kio::Waiter::noop(); group.bench_function(BenchmarkId::new("local", publishers), |b| { b.iter(|| { - let pending = fleet.consumer.request_broadcast("room/0", None); + let pending = fleet.consumer.request_broadcast(Path::new("room/0").unwrap(), None); // The front's driver resolves the first request; later ones join it. fleet.driver.poll(moq_net::time::Instant::now(), &waiter).unwrap(); pending @@ -624,7 +625,7 @@ fn bench_request(c: &mut Criterion) { b.iter(|| { let result = fleet .consumer - .request_broadcast("room/missing", None) + .request_broadcast(Path::new("room/missing").unwrap(), None) .now_or_never() .expect("fails synchronously"); assert!(matches!(result, Err(moq_net::Error::Unroutable))); @@ -714,12 +715,12 @@ fn bench_unroutable_churn(c: &mut Criterion) { group.bench_function(id, |b| { let (producer, mut driver) = origin::Producer::new(origin::Config::default()); let consumer = producer.consume(); - let server = producer.dynamic_route("room", origin::Route::default()).unwrap(); - let unrelated = producer.dynamic_route("other", origin::Route::default()).unwrap(); + let server = producer.dynamic_route(Path::new("room").unwrap(), origin::Route::default()).unwrap(); + let unrelated = producer.dynamic_route(Path::new("other").unwrap(), origin::Route::default()).unwrap(); let mut waiting = Waiting::new( (0..requesters) .map(|i| { - consumer.routed_broadcast(format!("room/job-{}", if distinct { i } else { 0 })) + consumer.routed_broadcast(Path::try_from(format!("room/job-{}", if distinct { i } else { 0 })).unwrap()) }) .collect(), ); @@ -781,7 +782,7 @@ fn bench_retire(c: &mut Criterion) { let mut fleet = fanout(fronts + 1, 0); let waiter = kio::Waiter::noop(); let held: Vec<_> = (0..fronts) - .map(|i| fleet.consumer.request_broadcast(format!("room/{i}"), None)) + .map(|i| fleet.consumer.request_broadcast(Path::try_from(format!("room/{i}")).unwrap(), None)) .collect(); fleet.driver.poll(moq_net::time::Instant::now(), &waiter).unwrap(); let _held: Vec<_> = held @@ -790,7 +791,7 @@ fn bench_retire(c: &mut Criterion) { .collect(); let path = format!("room/{fronts}"); b.iter(|| { - let pending = fleet.consumer.request_broadcast(&path, None); + let pending = fleet.consumer.request_broadcast(Path::new(&path).unwrap(), None); fleet.driver.poll(moq_net::time::Instant::now(), &waiter).unwrap(); drop(pending.now_or_never().expect("resolved once driven").expect("local")); // Nothing holds it and a local source keeps no track, so it retires here. @@ -839,12 +840,12 @@ fn pool(members: usize, paths: usize, cursors: usize) -> Pool { let consumer = producer.consume(); let cursors = (0..cursors).map(|_| consumer.announced()).collect(); let members: Vec<_> = (0..members) - .map(|i| producer.dynamic_route("pool", pool_route(POOL_HOP + i as u64)).unwrap()) + .map(|i| producer.dynamic_route(Path::new("pool").unwrap(), pool_route(POOL_HOP + i as u64)).unwrap()) .collect(); let waiter = kio::Waiter::noop(); let requests: Vec<_> = (0..paths) - .map(|i| consumer.request_broadcast(format!("pool/job-{i}"), None)) + .map(|i| consumer.request_broadcast(Path::try_from(format!("pool/job-{i}")).unwrap(), None)) .collect(); driver.poll(moq_net::time::Instant::now(), &waiter).unwrap(); let mut producers = Vec::with_capacity(paths); @@ -898,7 +899,7 @@ fn bench_pool_churn(c: &mut Criterion) { let waiter = kio::Waiter::noop(); let hop = POOL_HOP + members as u64; b.iter(|| { - let joined = pool.producer.dynamic_route("pool", pool_route(hop)).unwrap(); + let joined = pool.producer.dynamic_route(Path::new("pool").unwrap(), pool_route(hop)).unwrap(); pool.driver.poll(moq_net::time::Instant::now(), &waiter).unwrap(); drop(joined); pool.driver.poll(moq_net::time::Instant::now(), &waiter).unwrap(); @@ -926,7 +927,7 @@ fn bench_pool_cursors(c: &mut Criterion) { let waiter = kio::Waiter::noop(); let hop = POOL_HOP + members as u64; b.iter(|| { - let joined = pool.producer.dynamic_route("pool", pool_route(hop)).unwrap(); + let joined = pool.producer.dynamic_route(Path::new("pool").unwrap(), pool_route(hop)).unwrap(); pool.driver.poll(moq_net::time::Instant::now(), &waiter).unwrap(); drop(joined); pool.driver.poll(moq_net::time::Instant::now(), &waiter).unwrap(); @@ -958,32 +959,32 @@ fn bench_handoff(c: &mut Criterion) { runtime.spawn(moq_net::time::run(driver)); let consumer = producer.consume(); let _others: Vec<_> = (0..publishers) - .map(|i| producer.publish(format!("room/{i}"), origin::Route::default()).unwrap()) + .map(|i| producer.publish(Path::try_from(format!("room/{i}")).unwrap(), origin::Route::default()).unwrap()) .collect(); b.iter_custom(|iterations| { runtime.block_on(async { let mut total = Duration::ZERO; for _ in 0..iterations { - let incumbent = producer.publish("room/live", origin::Route::default()).unwrap(); + let incumbent = producer.publish(Path::new("room/live").unwrap(), origin::Route::default()).unwrap(); let track = incumbent.create_track("video", timed()).unwrap(); let mut first = track.append_group().unwrap(); first.write_frame(Timestamp::ZERO, b"one".as_ref()).unwrap(); first.finish().unwrap(); - let resolved = consumer.request_broadcast("room/live", None).await.unwrap(); + let resolved = consumer.request_broadcast(Path::new("room/live").unwrap(), None).await.unwrap(); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); subscription.recv_group().await.unwrap().expect("first group"); let started = std::time::Instant::now(); - let standby = producer.create_broadcast("room/live").unwrap(); + let standby = producer.create_broadcast(Path::new("room/live").unwrap()).unwrap(); let track = standby.create_track("video", timed()).unwrap(); let mut second = track.create_group(moq_net::group::Info { sequence: 1 }).unwrap(); second.write_frame(Timestamp::ZERO, b"two".as_ref()).unwrap(); second.finish().unwrap(); // Announcing is what makes the standby a route the front can take. standby.announce(origin::Route::default()).unwrap(); - let replaced = consumer.request_broadcast("room/live", None).await.unwrap(); + let replaced = consumer.request_broadcast(Path::new("room/live").unwrap(), None).await.unwrap(); let mut replacement = replaced.track("video").unwrap().subscribe(None).await.unwrap(); let group = replacement.recv_group().await.unwrap().expect("standby group"); total += started.elapsed(); @@ -1040,7 +1041,7 @@ async fn watching(routes: usize, subscribers: usize) -> Watching { let mut broadcasts = Vec::new(); let mut tracks = Vec::new(); for index in 0..routes { - let broadcast = relay.publish(watched_path(index), origin::Route::default()).unwrap(); + let broadcast = relay.publish(Path::try_from(watched_path(index)).unwrap(), origin::Route::default()).unwrap(); tracks.push(broadcast.create_track("video", timed()).unwrap()); broadcasts.push(broadcast); } @@ -1052,7 +1053,7 @@ async fn watching(routes: usize, subscribers: usize) -> Watching { let mut subscriptions = Vec::new(); for index in 0..subscribers { - let remote = received.consume().routed_broadcast(watched_path(index)).await.unwrap(); + let remote = received.consume().routed_broadcast(Path::try_from(watched_path(index)).unwrap()).await.unwrap(); let subscription = remote.track("video").unwrap().subscribe(None).await.unwrap(); subscriptions.push(subscription); } @@ -1173,12 +1174,12 @@ fn bench_relay(c: &mut Criterion) { .unwrap(); let (producer, driver) = origin::Producer::new(origin::Config::default()); runtime.spawn(moq_net::time::run(driver)); - let broadcast = producer.publish("room/live", origin::Route::default()).unwrap(); + let broadcast = producer.publish(Path::new("room/live").unwrap(), origin::Route::default()).unwrap(); let sources: Vec<_> = (0..tracks) .map(|i| broadcast.create_track(format!("{i}"), timed()).unwrap()) .collect(); let mut subscriptions = runtime.block_on(async { - let resolved = producer.consume().request_broadcast("room/live", None).await.unwrap(); + let resolved = producer.consume().request_broadcast(Path::new("room/live").unwrap(), None).await.unwrap(); let mut subscriptions = Vec::new(); for i in 0..tracks { let track = resolved.track(&format!("{i}")).unwrap(); @@ -1233,10 +1234,10 @@ fn bench_passthrough(c: &mut Criterion) { .unwrap(); let (producer, driver) = origin::Producer::new(origin::Config::default()); runtime.spawn(moq_net::time::run(driver)); - let broadcast = producer.publish("room/live", origin::Route::default()).unwrap(); + let broadcast = producer.publish(Path::new("room/live").unwrap(), origin::Route::default()).unwrap(); let source = broadcast.create_track("0", timed()).unwrap(); let mut subscriptions = runtime.block_on(async { - let resolved = producer.consume().request_broadcast("room/live", None).await.unwrap(); + let resolved = producer.consume().request_broadcast(Path::new("room/live").unwrap(), None).await.unwrap(); let track = resolved.track("0").unwrap(); let mut subscriptions = Vec::with_capacity(readers); for _ in 0..readers { @@ -1288,13 +1289,13 @@ fn bench_parked(c: &mut Criterion) { .unwrap(); let (producer, driver) = origin::Producer::new(origin::Config::default()); runtime.spawn(moq_net::time::run(driver)); - let broadcast = producer.publish("room/live", origin::Route::default()).unwrap(); + let broadcast = producer.publish(Path::new("room/live").unwrap(), origin::Route::default()).unwrap(); let sources: Vec<_> = (0..tracks) .map(|i| broadcast.create_track(format!("{i}"), None).unwrap()) .collect(); let _writers: Vec<_> = sources.iter().map(|source| source.append_group().unwrap()).collect(); let (subscriptions, mut groups) = runtime.block_on(async { - let resolved = producer.consume().request_broadcast("room/live", None).await.unwrap(); + let resolved = producer.consume().request_broadcast(Path::new("room/live").unwrap(), None).await.unwrap(); let mut subscriptions = Vec::new(); let mut groups = Vec::new(); for i in 0..tracks { @@ -1341,7 +1342,7 @@ impl Generation { /// Create a hidden generation and leave a finished group on every track, so a /// reader that does look has something to resume. fn build(producer: &origin::Producer, tracks: usize) -> Self { - let broadcast = producer.create_broadcast(COPY_PATH).unwrap(); + let broadcast = producer.create_broadcast(Path::new(COPY_PATH).unwrap()).unwrap(); let mut held = Vec::with_capacity(tracks); for i in 0..tracks { let track = broadcast.create_track(format!("{i}"), timed()).unwrap(); @@ -1402,7 +1403,7 @@ async fn copy_walk(tracks: usize, copies: usize) -> CopyWalk { let epoch = Epoch::mint(); let first = Generation::build(&producer, tracks); first.route(&epoch); - let resolved = moq_clock::timeout(COPY_WAIT, producer.consume().request_broadcast(COPY_PATH, None)) + let resolved = moq_clock::timeout(COPY_WAIT, producer.consume().request_broadcast(Path::new(COPY_PATH).unwrap(), None)) .await .expect("front did not resolve") .expect("front refused"); @@ -1546,7 +1547,7 @@ async fn resume_overlap(shape: ResumeShape, ordered: bool) -> ResumeOverlap { tokio::spawn(moq_net::time::run(driver)); let epoch = Epoch::mint(); let generation = |order: &mut dyn Iterator| { - let broadcast = producer.create_broadcast(COPY_PATH).unwrap(); + let broadcast = producer.create_broadcast(Path::new(COPY_PATH).unwrap()).unwrap(); let track = broadcast.create_track("0", timed()).unwrap(); for sequence in order { let mut group = track @@ -1563,7 +1564,7 @@ async fn resume_overlap(shape: ResumeShape, ordered: bool) -> ResumeOverlap { (broadcast, track) }; let mut generations = vec![generation(&mut (0..retained))]; - let resolved = moq_clock::timeout(COPY_WAIT, producer.consume().request_broadcast(COPY_PATH, None)) + let resolved = moq_clock::timeout(COPY_WAIT, producer.consume().request_broadcast(Path::new(COPY_PATH).unwrap(), None)) .await .expect("front did not resolve") .expect("front refused"); diff --git a/rs/moq-net/benches/retirement.rs b/rs/moq-net/benches/retirement.rs index fdc5281f03a..759330fc01e 100644 --- a/rs/moq-net/benches/retirement.rs +++ b/rs/moq-net/benches/retirement.rs @@ -22,7 +22,7 @@ fn retirement(c: &mut Criterion) { || { let (origin, driver) = origin::Producer::new(origin::Config::default()); let routes: Vec<_> = (0..routes) - .map(|i| origin.dynamic(format!("route/{i}")).unwrap()) + .map(|i| origin.dynamic(Path::try_from(format!("route/{i}")).unwrap()).unwrap()) .collect(); let mut watches = Vec::new(); let mut controls = Vec::new(); @@ -32,7 +32,7 @@ fn retirement(c: &mut Criterion) { if selected { let watch = RequestValidity::new( route, - &Path::new(&format!("route/{i}/jobs/{reader}")), + &Path::new(&format!("route/{i}/jobs/{reader}")).unwrap(), ); pending.push(watch.start()); watches.push(watch); @@ -46,7 +46,7 @@ fn retirement(c: &mut Criterion) { (origin, driver, routes, watches, controls, pending) }, |fixture| { - let replacement = fixture.0.dynamic("route/0/jobs").unwrap(); + let replacement = fixture.0.dynamic(Path::new("route/0/jobs").unwrap()).unwrap(); let refused = fixture .5 .iter() diff --git a/rs/moq-net/benches/session.rs b/rs/moq-net/benches/session.rs index 76f7ec95a94..1c36b620ab2 100644 --- a/rs/moq-net/benches/session.rs +++ b/rs/moq-net/benches/session.rs @@ -55,6 +55,7 @@ #[path = "../tests/integration/support/mod.rs"] mod support; +use moq_net::Path; use std::alloc::{GlobalAlloc, Layout, System}; use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; use std::time::{Duration, Instant}; @@ -377,7 +378,7 @@ impl Cluster { this.pools.push(pool); for index in 0..shape.broadcasts { let broadcast = origin - .publish(path(publisher * shape.broadcasts + index), Default::default()) + .publish(Path::try_from(path(publisher * shape.broadcasts + index)).unwrap(), Default::default()) .unwrap(); this.tracks.push( broadcast @@ -448,7 +449,7 @@ struct Viewer { impl Viewer { /// Resolve `path` and subscribe to each of its `tracks`. async fn watch(&mut self, path: &str, tracks: &[impl AsRef], subscription: Option) { - let broadcast = self.origin.consume().routed_broadcast(path).await.unwrap(); + let broadcast = self.origin.consume().routed_broadcast(Path::new(path).unwrap()).await.unwrap(); for track in tracks { self.subscribers.push( broadcast @@ -511,7 +512,7 @@ impl Room { let mut viewer = cluster.join((viewer + 1) % shape.relays).await; for broadcast in broadcasts { if shape.fetch { - let source = viewer.origin.consume().routed_broadcast(path(broadcast)).await.unwrap(); + let source = viewer.origin.consume().routed_broadcast(Path::try_from(path(broadcast)).unwrap()).await.unwrap(); viewer.fetches.push((broadcast, source.track(TRACK).unwrap())); } else { viewer.watch(&path(broadcast), &[TRACK], shape.subscription()).await; @@ -907,7 +908,7 @@ impl DashRoom { for node in 1..shape.relays { for project in 0..shape.projects { let path = format!(".stats/{project}/node/{node}"); - let broadcast = cluster.relays[node].publish(path.as_str(), Default::default()).unwrap(); + let broadcast = cluster.relays[node].publish(Path::new(path.as_str()).unwrap(), Default::default()).unwrap(); for name in &names { tracks.push(broadcast.create_track(name.as_str(), timed()).unwrap()); } @@ -1055,7 +1056,7 @@ impl ChurnRoom { for _ in 0..shape.sessions { let mut viewer = cluster.join(0).await; viewer.watch(&path(0), &held, None).await; - broadcasts.push(viewer.origin.consume().routed_broadcast(path(0)).await.unwrap()); + broadcasts.push(viewer.origin.consume().routed_broadcast(Path::try_from(path(0)).unwrap()).await.unwrap()); viewers.push(viewer); } Self { @@ -1203,7 +1204,7 @@ fn withdrawal(c: &mut Criterion) { let live: Vec<_> = (0..broadcasts) .map(|i| { cluster.relays[i % (relays - 1)] - .publish(path(i), Default::default()) + .publish(Path::try_from(path(i)).unwrap(), Default::default()) .unwrap() }) .collect(); diff --git a/rs/moq-net/benches/stats.rs b/rs/moq-net/benches/stats.rs index 255078ef208..047c1880ae0 100644 --- a/rs/moq-net/benches/stats.rs +++ b/rs/moq-net/benches/stats.rs @@ -4,6 +4,7 @@ //! //! Run with `cargo bench -p moq-net --bench stats`. +use moq_net::Path; use criterion::{BenchmarkId, Criterion, Throughput, criterion_group, criterion_main}; use futures::FutureExt; use moq_net::{announce, broadcast, fuzz, origin, stats, transport}; @@ -24,11 +25,11 @@ fn registry(broadcasts: usize, tiers: usize) -> Registry { let registry = stats::Registry::new(stats::Config::new()); let (producer, driver) = origin::Producer::new(origin::Config::default()); let publishers = (0..broadcasts) - .map(|i| producer.publish(format!("room/{i}"), origin::Route::default()).unwrap()) + .map(|i| producer.publish(Path::try_from(format!("room/{i}")).unwrap(), origin::Route::default()).unwrap()) .collect(); let cursors = (0..tiers) .map(|t| { - let session = registry.tier(stats::Tier::new(format!("tier{t}"))).session("root"); + let session = registry.tier(stats::Tier::new(Path::try_from(format!("tier{t}")).unwrap())).session(Path::new("root").unwrap()); let mut cursor = producer.consume().with_stats(session).announced(); // Each announce the cursor replays records under its tier. while cursor.next().now_or_never().flatten().is_some() {} @@ -71,15 +72,15 @@ fn request(c: &mut Criterion) { let registry = stats::Registry::new(stats::Config::new()); let mut contexts = Vec::new(); for tier in 0..tiers { - let handle = registry.tier(stats::Tier::new(format!("tier{tier}"))); + let handle = registry.tier(stats::Tier::new(Path::try_from(format!("tier{tier}")).unwrap())); for root in 0..roots { - contexts.push(handle.request(format!("room/{root}"))); + contexts.push(handle.request(Path::try_from(format!("room/{root}")).unwrap())); } } - let handle = registry.tier(stats::Tier::new(format!("tier{}", tiers - 1))); + let handle = registry.tier(stats::Tier::new(Path::try_from(format!("tier{}", tiers - 1)).unwrap())); let root = format!("room/{}", roots - 1); group.bench_function(BenchmarkId::from_parameter(format!("{roots}x{tiers}")), |b| { - b.iter(|| std::hint::black_box(handle.request(&root))); + b.iter(|| std::hint::black_box(handle.request(Path::new(&root).unwrap()))); }); std::hint::black_box(contexts); } @@ -90,8 +91,9 @@ fn request(c: &mut Criterion) { fn write(c: &mut Criterion) { let registry = stats::Registry::new(stats::Config::new()); let tier = stats::Tier::default(); - let path = fuzz::path_meter(®istry, &tier, "room/live"); - let session = fuzz::session_meter(®istry, tier, "root", "room/live"); + let live = Path::new("room/live").unwrap(); + let path = fuzz::path_meter(®istry, &tier, &live); + let session = fuzz::session_meter(®istry, tier, &Path::new("root").unwrap(), &live); c.bench_function("stats/write/path-bytes", |b| b.iter(|| path.bytes(1))); c.bench_function("stats/write/session-bytes", |b| b.iter(|| session.bytes(1))); } @@ -107,7 +109,7 @@ fn session_report(c: &mut Criterion) { let contexts: Vec<_> = (0..labels) .flat_map(|label| { let handle = handle.clone(); - (0..sessions).map(move |_| handle.session(format!("project/key/{label}"))) + (0..sessions).map(move |_| handle.session(Path::try_from(format!("project/key/{label}")).unwrap())) }) .collect(); let wires: Vec<_> = contexts @@ -153,7 +155,7 @@ fn retag(c: &mut Criterion) { let mut contexts: Vec<_> = (0..labels) .flat_map(|label| { let handle = handle.clone(); - (0..sessions).map(move |_| handle.session(format!("project/key/{label}"))) + (0..sessions).map(move |_| handle.session(Path::try_from(format!("project/key/{label}")).unwrap())) }) .collect(); let moving = contexts.split_off(contexts.len() - sessions); @@ -161,10 +163,10 @@ fn retag(c: &mut Criterion) { group.bench_function(BenchmarkId::from_parameter(format!("{labels}x{sessions}")), |b| { b.iter(|| { for session in moving.iter().rev() { - session.retag(tier.clone(), "project/moved"); + session.retag(tier.clone(), Path::new("project/moved").unwrap()); } for session in moving.iter().rev() { - session.retag(tier.clone(), format!("project/key/{}", labels - 1)); + session.retag(tier.clone(), Path::try_from(format!("project/key/{}", labels - 1)).unwrap()); } }); }); diff --git a/rs/moq-net/benches/synced.rs b/rs/moq-net/benches/synced.rs index a648e25131e..6cb229faf0f 100644 --- a/rs/moq-net/benches/synced.rs +++ b/rs/moq-net/benches/synced.rs @@ -13,6 +13,7 @@ //! //! Run with `cargo bench -p moq-net --features fuzz --bench synced`. +use moq_net::Path; use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main}; use moq_net::{Hop, Pattern, Patterns, announce, fuzz, origin}; @@ -31,7 +32,7 @@ struct Table { fn table(streams: usize, consumers: usize) -> Table { let (producer, driver) = origin::Producer::new(origin::Config::new(Hop::new(1).unwrap())); let streams = (0..streams) - .map(|i| fuzz::snapshot(&producer, &format!("room/{i}"))) + .map(|i| fuzz::snapshot(&producer, &Path::try_from(format!("room/{i}")).unwrap())) .collect(); let consumers = (0..consumers) .map(|i| scoped(&producer, &format!("other/{i}")).announced()) @@ -47,7 +48,7 @@ fn table(streams: usize, consumers: usize) -> Table { fn scoped(producer: &origin::Producer, prefix: &str) -> origin::Consumer { producer .consume() - .scope(prefix, &Patterns::from(Pattern::all())) + .scope(Path::new(prefix).unwrap(), &Patterns::from(Pattern::all())) .unwrap() } @@ -58,8 +59,9 @@ fn bench_land(c: &mut Criterion) { group.bench_function(id, |b| { let table = table(streams, consumers); let watcher = scoped(&table.producer, "room/incoming").announced(); + let prefix = Path::new("room/incoming").unwrap(); b.iter(|| { - let snapshot = fuzz::snapshot(&table.producer, "room/incoming"); + let snapshot = fuzz::snapshot(&table.producer, &prefix); assert!(!watcher.is_synced()); drop(snapshot); assert!(watcher.is_synced()); @@ -76,7 +78,7 @@ fn bench_register(c: &mut Criterion) { group.bench_function(id, |b| { let table = table(streams, consumers); let incoming = scoped(&table.producer, "room/incoming"); - let _held = fuzz::snapshot(&table.producer, "room/incoming"); + let _held = fuzz::snapshot(&table.producer, &Path::new("room/incoming").unwrap()); b.iter(|| { let watcher = incoming.announced(); assert!(!watcher.is_synced()); diff --git a/rs/moq-net/benches/viewers.rs b/rs/moq-net/benches/viewers.rs index fcd617a9646..bd502f677a8 100644 --- a/rs/moq-net/benches/viewers.rs +++ b/rs/moq-net/benches/viewers.rs @@ -9,6 +9,7 @@ //! //! Run with `cargo bench -p moq-net --features fuzz --bench viewers`. +use moq_net::Path; use std::alloc::{GlobalAlloc, Layout, System}; use std::sync::atomic::{AtomicBool, AtomicIsize, Ordering}; @@ -75,7 +76,7 @@ impl Room { let (producer, driver) = origin::Producer::new(origin::Config::default()); let _sources = (0..broadcasts) .map(|i| { - let broadcast = producer.publish(format!("room/{i}"), origin::Route::default()).unwrap(); + let broadcast = producer.publish(Path::try_from(format!("room/{i}")).unwrap(), origin::Route::default()).unwrap(); let track = broadcast.create_track("video", timed()).unwrap(); let mut group = track.append_group().unwrap(); group.write_frame(Timestamp::ZERO, b"frame".as_ref()).unwrap(); @@ -112,7 +113,7 @@ impl Room { fn join(&mut self, n: usize) -> moq_net::track::Subscriber { let session = moq_net::fuzz::excluding(self.producer.consume(), Hop::random()); let path = format!("room/{}", n % self.broadcasts); - let resolved = self.drive(session.request_broadcast(path, None)).unwrap(); + let resolved = self.drive(session.request_broadcast(Path::try_from(path).unwrap(), None)).unwrap(); let mut subscription = self.drive(resolved.track("video").unwrap().subscribe(None)).unwrap(); self.drive(subscription.recv_group()) .unwrap() @@ -181,7 +182,7 @@ fn bench_churn(c: &mut Criterion) { room.leave(subscription); } b.iter(|| { - let covering = room.producer.dynamic("room").unwrap(); + let covering = room.producer.dynamic(Path::new("room").unwrap()).unwrap(); room.poll(); drop(covering); room.poll(); diff --git a/rs/moq-net/src/auth.rs b/rs/moq-net/src/auth.rs index 92bab3af116..0bdd8654470 100644 --- a/rs/moq-net/src/auth.rs +++ b/rs/moq-net/src/auth.rs @@ -2430,7 +2430,7 @@ mod tests { let token = handle.present(Bytes::from_static(b"new"), false).unwrap(); let mut gate = Gate::new( handle.clone(), - crate::Path::new("room").to_owned(), + crate::Path::new("room").unwrap().to_owned(), Direction::Subscribe, ); let waiter = kio::Waiter::noop(); @@ -2454,7 +2454,7 @@ mod tests { let busy = Error::Session(SessionError::TooManyRequests); assert_eq!(handle.retry(id, &busy), Some(RETRY_INITIAL)); - let mut gate = Gate::new(handle.clone(), crate::Path::new("room").to_owned(), Direction::Publish); + let mut gate = Gate::new(handle.clone(), crate::Path::new("room").unwrap().to_owned(), Direction::Publish); let waiter = kio::Waiter::noop(); assert!( gate.poll_ready(&waiter).is_pending(), @@ -2477,7 +2477,7 @@ mod tests { let route = kio::Producer::<()>::default(); let mut gate = Gate::announced( handle, - crate::Path::new("room").to_owned(), + crate::Path::new("room").unwrap().to_owned(), Direction::Subscribe, route.consume(), ); @@ -2492,7 +2492,7 @@ mod tests { fn an_empty_token_never_holds_a_request() { let handle = Link::new(true); let _setup = handle.present(Bytes::new(), true).unwrap(); - let mut gate = Gate::new(handle, crate::Path::new("room").to_owned(), Direction::Subscribe); + let mut gate = Gate::new(handle, crate::Path::new("room").unwrap().to_owned(), Direction::Subscribe); assert!(gate.poll_ready(&kio::Waiter::noop()).is_ready()); } @@ -2502,7 +2502,7 @@ mod tests { let first = handle.present(Bytes::from_static(b"first"), false).unwrap(); handle.granted(first.presented.id, Grant::all()); let _unanswered = handle.present(Bytes::from_static(b"renewal"), false).unwrap(); - let mut gate = Gate::new(handle, crate::Path::new("room").to_owned(), Direction::Subscribe); + let mut gate = Gate::new(handle, crate::Path::new("room").unwrap().to_owned(), Direction::Subscribe); assert!(gate.poll_ready(&kio::Waiter::noop()).is_ready()); } @@ -2944,7 +2944,7 @@ mod request_token_tests { } fn subscribe_path() -> crate::PathOwned { - crate::Path::new("room/alice").to_owned() + crate::Path::new("room/alice").unwrap().to_owned() } /// A request token reaches the app's acceptor like any other token, and the grant the diff --git a/rs/moq-net/src/client.rs b/rs/moq-net/src/client.rs index be90008de04..e327f36386c 100644 --- a/rs/moq-net/src/client.rs +++ b/rs/moq-net/src/client.rs @@ -578,6 +578,7 @@ impl Client { #[cfg(test)] mod tests { use super::*; + use crate::Path; use crate::model::ProduceTest; use std::{ collections::VecDeque, @@ -1059,7 +1060,7 @@ mod tests { let fake = FakeSession::new(Some(ALPN_LITE_04), Vec::new()); let client = Client::new() .with_versions(Version::Lite(lite::Version::Lite04).into()) - .with_stats(registry.tier(Tier::default()).session("root")); + .with_stats(registry.tier(Tier::default()).session(Path::new("root").unwrap())); let runtime = crate::time::Deadlines::new(crate::time::Instant::now()); let (session, mut driver) = futures::executor::block_on(client.connect(runtime.now(), fake)).unwrap(); session.abort(abort); @@ -1091,7 +1092,7 @@ mod tests { let registry = Registry::new(Default::default()); let client = Client::new() .with_versions(Version::Lite(lite::Version::Lite04).into()) - .with_stats(registry.tier(Tier::default()).session("root")); + .with_stats(registry.tier(Tier::default()).session(Path::new("root").unwrap())); let runtime = crate::time::Deadlines::new(crate::time::Instant::now()); let mut task = Transport::new(FakeSession::new(Some(ALPN_LITE_04), Vec::new())); let (session, mut driver) = diff --git a/rs/moq-net/src/coding/reader.rs b/rs/moq-net/src/coding/reader.rs index 77f60c36862..2bceaf0f926 100644 --- a/rs/moq-net/src/coding/reader.rs +++ b/rs/moq-net/src/coding/reader.rs @@ -460,6 +460,7 @@ impl Reader { #[cfg(test)] mod tests { + use crate::Path; use std::{collections::VecDeque, sync::Arc}; use futures::FutureExt; @@ -499,7 +500,7 @@ mod tests { stats::{Bytes, Control, Registry, Tier}, }; let registry = Registry::new(Default::default()); - let session = registry.tier(Tier::default()).session(""); + let session = registry.tier(Tier::default()).session(Path::new("").unwrap()); let version = lite::Version::Lite07; let msg = lite::Probe { bitrate: Some(123), diff --git a/rs/moq-net/src/coding/writer.rs b/rs/moq-net/src/coding/writer.rs index 3ef57596fbf..12261b482a8 100644 --- a/rs/moq-net/src/coding/writer.rs +++ b/rs/moq-net/src/coding/writer.rs @@ -282,6 +282,7 @@ impl Drop for Writer { #[cfg(test)] mod tests { use super::*; + use crate::Path; use crate::lite::test_transport::{Log, SinkSend}; use std::task::Waker; @@ -416,7 +417,7 @@ mod tests { stats::{Bytes, Control, Registry, Tier}, }; let stats = Registry::new(Default::default()); - let session = stats.tier(Tier::new("internal")).session(""); + let session = stats.tier(Tier::new(Path::new("internal").unwrap())).session(Path::new("").unwrap()); let gate = kio::Producer::new(false); let mut writer = Writer::new(SinkSend::gated(Log::default(), gate.consume()), lite::Version::Lite07).with_stats(&session); @@ -432,11 +433,11 @@ mod tests { assert!(writer.poll_flush(&mut Context::from_waker(Waker::noop())).is_pending()); assert_eq!( stats.snapshot().control(), - vec![(Tier::new("internal"), Control::Probe, Bytes { tx: size, rx: 0 })] + vec![(Tier::new(Path::new("internal").unwrap()), Control::Probe, Bytes { tx: size, rx: 0 })] ); writer .buffer(&lite::Track { - broadcast: "test".into(), + broadcast: Path::new("test").unwrap(), epoch: None, track: "video".into(), }) diff --git a/rs/moq-net/src/fuzz.rs b/rs/moq-net/src/fuzz.rs index 8ab9c80d086..70a15d7db21 100644 --- a/rs/moq-net/src/fuzz.rs +++ b/rs/moq-net/src/fuzz.rs @@ -303,7 +303,7 @@ pub fn excluding(origin: crate::origin::Consumer, peer: crate::Hop) -> crate::or pub struct Snapshot(#[allow(dead_code, reason = "held for its drop, which lands the snapshot")] crate::model::Snapshot); /// Start a snapshot under `prefix`, as a session requesting announcements there does. -pub fn snapshot(origin: &crate::origin::Producer, prefix: &str) -> Snapshot { +pub fn snapshot(origin: &crate::origin::Producer, prefix: &Path) -> Snapshot { Snapshot(origin.snapshot(prefix)) } @@ -369,13 +369,13 @@ impl Meter { } /// Build a session-local payload meter without exposing the model's private stats carriers. -pub fn session_meter(registry: &crate::stats::Registry, tier: crate::stats::Tier, label: &str, path: &str) -> Meter { +pub fn session_meter(registry: &crate::stats::Registry, tier: crate::stats::Tier, label: &Path, path: &Path) -> Meter { let session = registry.tier(tier).session(label); Meter(session.egress(path).meter()) } /// Build the original per-path-only payload meter as the benchmark baseline. -pub fn path_meter(registry: &crate::stats::Registry, tier: &crate::stats::Tier, path: &str) -> Meter { +pub fn path_meter(registry: &crate::stats::Registry, tier: &crate::stats::Tier, path: &Path) -> Meter { Meter(registry.publisher_meter(path, tier)) } @@ -484,7 +484,7 @@ impl LiteSample { order: crate::track::Order::Descending, epoch: None, id: 3, - broadcast: Path::new("room/alice"), + broadcast: Path::new("room/alice").unwrap(), track: "video".into(), priority: 2, max_delay: std::time::Duration::from_secs(10), @@ -678,7 +678,7 @@ impl Default for Messages { order: crate::track::Order::Descending, epoch: None, id: 7, - broadcast: Path::new("room/alice"), + broadcast: Path::new("room/alice").unwrap(), track: "video".into(), priority: 3, max_delay: Duration::from_millis(500), @@ -717,7 +717,7 @@ impl Default for Messages { max_age: None, new_group: None, request_id: ietf::RequestId(2), - track_namespace: Path::new("room/alice"), + track_namespace: Path::new("room/alice").unwrap(), track_name: "video".into(), subscriber_priority: 128, group_order: ietf::GroupOrder::Descending, @@ -839,12 +839,19 @@ pub fn path(data: &[u8]) -> bool { }; let (target, base) = text.split_once('\n').unwrap_or((text, "")); - let target = Path::new(target); - let base = Path::new(base); - // Normalization is a fixed point: re-parsing what `as_str` printed changes nothing, - // or every path that made a round trip through the wire would drift. - assert_eq!(Path::new(target.as_str()), target, "normalization is not idempotent"); + // A spelling is refused exactly when it has an empty segment, so each path has one. + for s in [target, base] { + let empty = !s.is_empty() && s.split('/').any(str::is_empty); + assert_eq!(Path::new(s).is_err(), empty, "{s:?} was refused wrongly"); + } + let (Ok(target), Ok(base)) = (Path::new(target), Path::new(base)) else { + return false; + }; + + // A path's own spelling parses back to it, or every path that made a round trip + // through the wire would drift. + assert_eq!(Path::new(target.as_str()).expect("a path's spelling is valid"), target); assert_eq!(target.to_owned(), target, "owning a path changed it"); assert_eq!(target.borrow(), target, "borrowing a path changed it"); assert_eq!(target.parts().collect::>().join("/"), target.as_str()); @@ -1040,7 +1047,7 @@ pub fn seeds() -> Vec { group_id: 0, }, ietf::FetchType::Filtered { - namespace: crate::Path::new("a"), + namespace: crate::Path::new("a").unwrap(), track: "b".into(), filter: ietf::Filter::Relative(1), }, @@ -1103,7 +1110,7 @@ pub fn seeds() -> Vec { let mut announced = Vec::new(); let hop = |id: u64| crate::Hop::new(id).expect("a valid hop"); for n in 0..12u64 { - let suffix = PathOwned::from(format!("pid{}/private/channel_{}/health-{n}", n % 3, n % 2)); + let suffix = PathOwned::try_from(format!("pid{}/private/channel_{}/health-{n}", n % 3, n % 2)).unwrap(); let hops = Hops::try_from(vec![hop(100 + n % 3), hop(1 << 40), hop(1 << 41)]).expect("valid hops"); announced.push(Announced::Start(suffix, hops)); if n % 4 == 3 { @@ -1363,13 +1370,13 @@ mod tests { let registry = crate::stats::Registry::new(crate::stats::Config::new()); let (origin, driver) = crate::origin::Producer::new(crate::origin::Config::default()); let _driver = driver; - let tier = crate::stats::Tier::new("t"); - let session = registry.tier(tier.clone()).session("root"); - let _broadcast = origin.publish("room/1", crate::origin::Route::default()).unwrap(); + let tier = crate::stats::Tier::new(Path::new("t").unwrap()); + let session = registry.tier(tier.clone()).session(Path::new("root").unwrap()); + let _broadcast = origin.publish(Path::new("room/1").unwrap(), crate::origin::Route::default()).unwrap(); let mut cursor = origin.consume().with_stats(session).announced(); while cursor.next().now_or_never().flatten().is_some() {} - bump_publisher_bytes(®istry, "room/1", &tier, 5); + bump_publisher_bytes(®istry, Path::new("room/1").unwrap(), &tier, 5); let mut report = crate::stats::Report::default(); registry.report(&mut report); registry.report(&mut report); diff --git a/rs/moq-net/src/ietf/adapter.rs b/rs/moq-net/src/ietf/adapter.rs index fe84ae1fdee..5c61c6cd389 100644 --- a/rs/moq-net/src/ietf/adapter.rs +++ b/rs/moq-net/src/ietf/adapter.rs @@ -1632,6 +1632,7 @@ fn decode_publish_namespace_body(body: &Bytes, version: Version) -> Result ietf::PublishNamespace<'_> { ietf::PublishNamespace { request_id, - track_namespace: crate::Path::new(namespace), + track_namespace: crate::Path::new(namespace).unwrap(), params: Default::default(), authorization_token: None, } @@ -2071,11 +2072,11 @@ mod tests { #[test] fn test_namespace_reverse_lookup_v14() { let namespaces = Namespaces::default(); - namespaces.register(Direction::Incoming, crate::Path::new("test/ns"), RequestId(42)); + namespaces.register(Direction::Incoming, crate::Path::new("test/ns").unwrap(), RequestId(42)); let body = encode_body( &ietf::PublishNamespaceDone { - track_namespace: crate::Path::new("test/ns"), + track_namespace: crate::Path::new("test/ns").unwrap(), request_id: RequestId(0), }, Version::Draft14, @@ -2093,7 +2094,7 @@ mod tests { let (shared, mut ours, mut theirs) = mesh("cluster/ns", version, Direction::Outgoing).await; let done = ietf::PublishNamespaceDone { - track_namespace: crate::Path::new("cluster/ns"), + track_namespace: crate::Path::new("cluster/ns").unwrap(), request_id: RequestId(0), }; let route = classify( @@ -2119,7 +2120,7 @@ mod tests { let (shared, mut ours, mut theirs) = mesh("cluster/ns", version, Direction::Incoming).await; let cancel = ietf::PublishNamespaceCancel { - track_namespace: crate::Path::new("cluster/ns"), + track_namespace: crate::Path::new("cluster/ns").unwrap(), request_id: RequestId(0), error_code: 0, reason_phrase: "".into(), @@ -2142,7 +2143,7 @@ mod tests { /// Classify the peer withdrawing its own advertisement of `namespace`. fn done(shared: &Arc, namespace: &str, version: Version) -> Route { let msg = ietf::PublishNamespaceDone { - track_namespace: crate::Path::new(namespace), + track_namespace: crate::Path::new(namespace).unwrap(), request_id: RequestId(0), }; classify( @@ -2157,7 +2158,7 @@ mod tests { /// Classify the peer rejecting our advertisement of `namespace`. fn cancel(shared: &Arc, namespace: &str, version: Version) -> Route { let msg = ietf::PublishNamespaceCancel { - track_namespace: crate::Path::new(namespace), + track_namespace: crate::Path::new(namespace).unwrap(), request_id: RequestId(0), error_code: 0, reason_phrase: "".into(), @@ -2205,7 +2206,7 @@ mod tests { let mut theirs = receive(&shared, "cluster/ns", version, RequestId(7)).await; let msg = ietf::PublishNamespaceDone { - track_namespace: crate::Path::new("cluster/ns"), + track_namespace: crate::Path::new("cluster/ns").unwrap(), request_id: RequestId(0), }; shared.close(RequestId(7), encode_msg(&msg, version)); @@ -2239,7 +2240,7 @@ mod tests { /// The peer withdrawing `namespace` on `request_id`, as the read loop routes it. fn withdraw(shared: &Arc, namespace: &str, version: Version, request_id: RequestId) { let msg = ietf::PublishNamespaceDone { - track_namespace: crate::Path::new(namespace), + track_namespace: crate::Path::new(namespace).unwrap(), request_id, }; let route = classify( @@ -2363,7 +2364,7 @@ mod tests { } let fourth = (0..4).find(|id| *id != first && *id != second && *id != third).unwrap(); let namespaces = Namespaces::default(); - let name = crate::Path::new("ns"); + let name = crate::Path::new("ns").unwrap(); for id in 0..4 { namespaces.register(direction, name.clone(), RequestId(id)); } @@ -2432,7 +2433,7 @@ mod tests { }; for version in [Version::Draft14, Version::Draft15, Version::Draft16] { let registry = Registry::new(Default::default()); - let stats = registry.tier(Tier::default()).session(""); + let stats = registry.tier(Tier::default()).session(Path::new("").unwrap()); let msg = ietf::FetchCancel { request_id: RequestId(0), }; diff --git a/rs/moq-net/src/ietf/fetch.rs b/rs/moq-net/src/ietf/fetch.rs index 2cb61e3ebad..f6823eb348e 100644 --- a/rs/moq-net/src/ietf/fetch.rs +++ b/rs/moq-net/src/ietf/fetch.rs @@ -715,7 +715,7 @@ mod tests { subscriber_priority: 128, group_order: GroupOrder::Descending, fetch_type: FetchType::Standalone { - namespace: Path::new("test"), + namespace: Path::new("test").unwrap(), track: "video".into(), start: Location { group: 0, object: 0 }, end: Location { group: 10, object: 5 }, @@ -740,7 +740,7 @@ mod tests { subscriber_priority: 128, group_order: GroupOrder::Descending, fetch_type: FetchType::Standalone { - namespace: Path::new("test"), + namespace: Path::new("test").unwrap(), track: "video".into(), start: Location { group: 0, object: 0 }, end: Location { group: 10, object: 5 }, @@ -783,7 +783,7 @@ mod tests { subscriber_priority: 128, group_order: GroupOrder::Descending, fetch_type: FetchType::Standalone { - namespace: Path::new("test"), + namespace: Path::new("test").unwrap(), track: "video".into(), start: Location { group: 0, object: 0 }, end: Location { group: 10, object: 5 }, @@ -808,7 +808,7 @@ mod tests { subscriber_priority: 128, group_order: GroupOrder::Descending, fetch_type: FetchType::Standalone { - namespace: Path::new("test"), + namespace: Path::new("test").unwrap(), track: "video".into(), start: Location { group: 0, object: 0 }, end: Location { group: 10, object: 5 }, @@ -887,7 +887,7 @@ mod tests { subscriber_priority: 128, group_order: GroupOrder::Descending, fetch_type: FetchType::Standalone { - namespace: Path::new("test"), + namespace: Path::new("test").unwrap(), track: "video".into(), start: Location { group: 0, object: 0 }, end: Location { group: 10, object: 5 }, @@ -989,7 +989,7 @@ mod tests { assert_eq!( fetch.fetch_type, FetchType::Filtered { - namespace: Path::new("live"), + namespace: Path::new("live").unwrap(), track: "video".into(), filter: Filter::Absolute { start: Location { group: 128, object: 0 }, @@ -1013,7 +1013,7 @@ mod tests { subscriber_priority: 128, group_order: GroupOrder::Descending, fetch_type: FetchType::Filtered { - namespace: Path::new("live"), + namespace: Path::new("live").unwrap(), track: "video".into(), filter: Filter::Unfiltered, }, diff --git a/rs/moq-net/src/ietf/namespace.rs b/rs/moq-net/src/ietf/namespace.rs index e9c4af1f676..dfee33d57bb 100644 --- a/rs/moq-net/src/ietf/namespace.rs +++ b/rs/moq-net/src/ietf/namespace.rs @@ -173,7 +173,7 @@ mod tests { const FORM: Form = Form::LeadingOnes { seven: false }; fn encode_ns(path: &str) -> Vec { - encode_path(&Path::from(path.to_string())) + encode_path(&Path::new(path).unwrap().to_owned()) } fn encode_path(path: &Path<'_>) -> Vec { diff --git a/rs/moq-net/src/ietf/publish.rs b/rs/moq-net/src/ietf/publish.rs index a388cdec298..5ee89b50198 100644 --- a/rs/moq-net/src/ietf/publish.rs +++ b/rs/moq-net/src/ietf/publish.rs @@ -557,7 +557,7 @@ mod tests { let mut body = Vec::new(); let w = &mut Encoder::new(&mut body, version.into()); RequestId(1).encode(w, version)?; - super::super::namespace::encode_namespace(w, &crate::Path::new("broadcast"))?; + super::super::namespace::encode_namespace(w, &crate::Path::new("broadcast").unwrap())?; w.string("video")?; w.varint(1u64)?; // track alias @@ -580,7 +580,7 @@ mod tests { let mut body = Vec::new(); let w = &mut Encoder::new(&mut body, version.into()); RequestId(1).encode(w, version)?; - super::super::namespace::encode_namespace(w, &crate::Path::new("broadcast"))?; + super::super::namespace::encode_namespace(w, &crate::Path::new("broadcast").unwrap())?; w.string("video")?; w.varint(1u64)?; encode_params!(w, version, 0x20 => 128u8); @@ -606,7 +606,7 @@ mod tests { fn test_publish_v14_round_trip() { let msg = Publish { request_id: RequestId(1), - track_namespace: Path::new("test/ns"), + track_namespace: Path::new("test/ns").unwrap(), track_name: "video".into(), track_alias: 42, largest_location: Some(Location { group: 10, object: 5 }), @@ -635,7 +635,7 @@ mod tests { fn test_publish_v15_round_trip() { let msg = Publish { request_id: RequestId(1), - track_namespace: Path::new("test/ns"), + track_namespace: Path::new("test/ns").unwrap(), track_name: "video".into(), track_alias: 42, largest_location: Some(Location { group: 10, object: 5 }), @@ -702,7 +702,7 @@ mod tests { fn test_publish_v17_round_trip() { let msg = Publish { request_id: RequestId(1), - track_namespace: Path::new("test/ns"), + track_namespace: Path::new("test/ns").unwrap(), track_name: "video".into(), track_alias: 42, largest_location: Some(Location { group: 10, object: 5 }), @@ -753,7 +753,7 @@ mod tests { if version == Version::Draft17 { w.varint(0).unwrap(); } - encode_namespace(w, &Path::new("t")).unwrap(); + encode_namespace(w, &Path::new("t").unwrap()).unwrap(); w.string("v").unwrap(); w.varint(1).unwrap(); w.varint(1).unwrap(); @@ -866,7 +866,7 @@ mod tests { fn test_publish_v18_round_trip() { let msg = Publish { request_id: RequestId(1), - track_namespace: Path::new("test/ns"), + track_namespace: Path::new("test/ns").unwrap(), track_name: "video".into(), track_alias: 42, largest_location: Some(Location { group: 10, object: 5 }), @@ -906,7 +906,7 @@ mod tests { ] { let mut msg = Publish { request_id: RequestId(1), - track_namespace: Path::new("ns"), + track_namespace: Path::new("ns").unwrap(), track_name: "video".into(), track_alias: 42, largest_location: None, @@ -942,7 +942,7 @@ mod tests { fn test_publish_v18_group_order_is_a_property() { let msg = Publish { request_id: RequestId(1), - track_namespace: Path::new("ns"), + track_namespace: Path::new("ns").unwrap(), track_name: "video".into(), track_alias: 42, largest_location: None, @@ -984,7 +984,7 @@ mod tests { fn test_publish_v15_group_order_is_a_parameter() { let msg = Publish { request_id: RequestId(1), - track_namespace: Path::new("ns"), + track_namespace: Path::new("ns").unwrap(), track_name: "video".into(), track_alias: 42, largest_location: None, @@ -1026,7 +1026,7 @@ mod tests { fn test_publish_v18_is_one_byte_shorter_than_v17() { let msg = Publish { request_id: RequestId(1), - track_namespace: Path::new("test/ns"), + track_namespace: Path::new("test/ns").unwrap(), track_name: "video".into(), track_alias: 42, largest_location: None, diff --git a/rs/moq-net/src/ietf/publish_namespace.rs b/rs/moq-net/src/ietf/publish_namespace.rs index d0e6ffa3996..75e8a66e424 100644 --- a/rs/moq-net/src/ietf/publish_namespace.rs +++ b/rs/moq-net/src/ietf/publish_namespace.rs @@ -451,7 +451,7 @@ mod tests { fn test_announce_round_trip() { let msg = PublishNamespace { request_id: RequestId(1), - track_namespace: Path::new("test/broadcast"), + track_namespace: Path::new("test/broadcast").unwrap(), params: Default::default(), authorization_token: None, }; @@ -480,7 +480,7 @@ mod tests { #[test] fn test_unannounce_v14() { let msg = PublishNamespaceDone { - track_namespace: Path::new("old/stream"), + track_namespace: Path::new("old/stream").unwrap(), request_id: RequestId(0), }; @@ -506,7 +506,7 @@ mod tests { #[test] fn test_announce_cancel_v14() { let msg = PublishNamespaceCancel { - track_namespace: Path::new("canceled"), + track_namespace: Path::new("canceled").unwrap(), request_id: RequestId(0), error_code: 1, reason_phrase: "Shutdown".into(), @@ -541,7 +541,7 @@ mod tests { fn test_publish_namespace_v17_round_trip() { let msg = PublishNamespace { request_id: RequestId(5), - track_namespace: Path::new("v17/broadcast"), + track_namespace: Path::new("v17/broadcast").unwrap(), params: Default::default(), authorization_token: None, }; @@ -557,7 +557,7 @@ mod tests { fn test_publish_namespace_v18_round_trip() { let msg = PublishNamespace { request_id: RequestId(5), - track_namespace: Path::new("v18/broadcast"), + track_namespace: Path::new("v18/broadcast").unwrap(), params: Default::default(), authorization_token: None, }; diff --git a/rs/moq-net/src/ietf/publisher.rs b/rs/moq-net/src/ietf/publisher.rs index 8eef9575a41..9050c2002ba 100644 --- a/rs/moq-net/src/ietf/publisher.rs +++ b/rs/moq-net/src/ietf/publisher.rs @@ -6841,6 +6841,7 @@ mod subscribe_cursor_test { #[cfg(test)] mod serve_tests { use super::*; + use crate::Path; use crate::coding::{Decode, Decoder}; use crate::lite::test_transport::{Log, ScriptedSession, Sent, SinkSession}; use crate::model::ProduceTest; @@ -6852,7 +6853,7 @@ mod serve_tests { let stream = Stream::open(&mut crate::driver::Transport::new(session.clone()), version) .await .unwrap(); - let suffix: crate::PathOwned = "room".into(); + let suffix: crate::PathOwned = Path::new("room").unwrap(); let mut requests = HashMap::new(); requests.insert( suffix.clone(), @@ -7019,7 +7020,7 @@ mod serve_tests { session: ScriptedSession, ) -> Serve { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let broadcast = origin.publish("room", route).unwrap(); + let broadcast = origin.publish(Path::new("room").unwrap(), route).unwrap(); let track = broadcast.create_track("video", info).unwrap(); let log = session.log.clone(); @@ -7155,12 +7156,12 @@ mod serve_tests { // Draft-20 dropped the Fetch Type tag, leaving only the filtered form. fetch_type: match version { Version::Draft20 => FetchType::Filtered { - namespace: crate::Path::new("missing"), + namespace: crate::Path::new("missing").unwrap(), track: "video".into(), filter: Filter::Unfiltered, }, _ => FetchType::Standalone { - namespace: crate::Path::new("missing"), + namespace: crate::Path::new("missing").unwrap(), track: "video".into(), start: Location { group: 0, object: 0 }, end: Location { group: 0, object: 1 }, @@ -8539,7 +8540,7 @@ mod serve_tests { .unwrap(); let msg = ietf::SubscribeNamespace { request_id: RequestId(0), - namespace: crate::Path::new("room"), + namespace: crate::Path::new("room").unwrap(), hidden: false, }; let mut running = std::pin::pin!(h.publisher.clone().run_subscribe_namespace_stream(stream, msg)); @@ -8571,11 +8572,11 @@ mod serve_tests { let h = serve(version); let _old = h ._origin - .announce("old/first", crate::origin::Route::default()) + .announce(Path::new("old/first").unwrap(), crate::origin::Route::default()) .unwrap(); let _new = h ._origin - .announce("new/second", crate::origin::Route::default()) + .announce(Path::new("new/second").unwrap(), crate::origin::Route::default()) .unwrap(); settle().await; let session = ScriptedSession::new(Vec::new()); @@ -8584,7 +8585,7 @@ mod serve_tests { .unwrap(); let msg = ietf::SubscribeNamespace { request_id: RequestId(0), - namespace: crate::Path::new("old"), + namespace: crate::Path::new("old").unwrap(), hidden: false, }; let mut running = std::pin::pin!(h.publisher.clone().run_subscribe_namespace_stream(stream, msg)); @@ -8640,7 +8641,7 @@ mod serve_tests { .unwrap(); let msg = ietf::SubscribeNamespace { request_id: RequestId(0), - namespace: crate::Path::new(""), + namespace: crate::Path::new("").unwrap(), hidden: false, }; let mut run = std::pin::pin!(h.publisher.clone().run_subscribe_namespace_stream(stream, msg)); @@ -8660,7 +8661,7 @@ mod serve_tests { max_age: None, new_group: None, request_id: RequestId(REQUEST_ID), - track_namespace: crate::Path::new("room"), + track_namespace: crate::Path::new("room").unwrap(), track_name: "video".into(), subscriber_priority: 128, group_order: GroupOrder::Descending, @@ -8735,7 +8736,7 @@ mod serve_tests { .unwrap(); let mut msg = subscribe(Filter::NextObject, None); - msg.track_namespace = crate::Path::new("absent"); + msg.track_namespace = crate::Path::new("absent").unwrap(); h.publisher.clone().run_subscribe_stream(stream, msg).await.unwrap(); @@ -8827,7 +8828,7 @@ mod serve_tests { }; let status = ietf::TrackStatus { request_id: RequestId(REQUEST_ID), - track_namespace: crate::Path::new("room"), + track_namespace: crate::Path::new("room").unwrap(), track_name: "video".into(), properties_wanted: true, epoch: Some(epoch.clone()), @@ -8913,7 +8914,7 @@ mod serve_tests { if version == Version::Draft17 { w.varint(0)?; // required_request_id_delta } - super::super::namespace::encode_namespace(w, &crate::Path::new("room"))?; + super::super::namespace::encode_namespace(w, &crate::Path::new("room").unwrap())?; w.string("video")?; encode_params!(w, version, 0x04 => 7u64, @@ -8979,7 +8980,7 @@ mod serve_tests { fn track_status(namespace: &str, wanted: bool, version: Version) -> Vec { let msg = ietf::TrackStatus { request_id: RequestId(REQUEST_ID), - track_namespace: crate::Path::new(namespace), + track_namespace: crate::Path::new(namespace).unwrap(), track_name: "video".into(), properties_wanted: wanted, epoch: None, @@ -9066,7 +9067,7 @@ mod serve_tests { let mut h = serve(version); let claim = h ._origin - .dynamic_route("live", crate::origin::Route::default()) + .dynamic_route(Path::new("live").unwrap(), crate::origin::Route::default()) .unwrap(); let auth = crate::auth::Link::new(false); auth.handle().authorize(¬hing()); @@ -9089,7 +9090,7 @@ mod serve_tests { let mut h = serve(version); let claim = h ._origin - .dynamic_route("live", crate::origin::Route::default()) + .dynamic_route(Path::new("live").unwrap(), crate::origin::Route::default()) .unwrap(); let auth = crate::auth::Link::new(false); h.publisher = h.publisher.clone().with_auth(auth.clone()); @@ -9156,7 +9157,7 @@ mod serve_tests { async fn track_status_narrowed_while_answering_is_reset() { for version in ALL_VERSIONS { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let broadcast = origin.publish("room", crate::origin::Route::default()).unwrap(); + let broadcast = origin.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); let _track = broadcast.create_track("video", None).unwrap(); settle().await; @@ -9190,7 +9191,7 @@ mod serve_tests { stream, ietf::TrackStatus { request_id: RequestId(REQUEST_ID), - track_namespace: crate::Path::new("room"), + track_namespace: crate::Path::new("room").unwrap(), track_name: "video".into(), properties_wanted: true, epoch: None, @@ -9354,13 +9355,13 @@ mod serve_tests { group_order: GroupOrder::Descending, fetch_type: if Filter::is_draft20(version) { FetchType::Filtered { - namespace: crate::Path::new("room"), + namespace: crate::Path::new("room").unwrap(), track: "video".into(), filter: Filter::Unfiltered, } } else { FetchType::Standalone { - namespace: crate::Path::new("room"), + namespace: crate::Path::new("room").unwrap(), track: "video".into(), start: Location { group: 0, object: 0 }, end: Location { group: 0, object: 0 }, @@ -9398,7 +9399,7 @@ mod serve_tests { let mut body = Vec::new(); let mut w = Encoder::new(&mut body, version.into()); RequestId(REQUEST_ID).encode(&mut w, version).unwrap(); - super::super::namespace::encode_namespace(&mut w, &crate::Path::new(namespace)).unwrap(); + super::super::namespace::encode_namespace(&mut w, &crate::Path::new(namespace).unwrap()).unwrap(); w.string(track).unwrap(); w.varint(u64::from(wait.is_some())).unwrap(); if let Some(wait) = wait { @@ -9424,7 +9425,7 @@ mod serve_tests { for version in [Version::Draft21, Version::Draft22] { for path in [".", "./child", ".session", ".session/extension"] { let h = serve(version); - let claim = h._origin.dynamic_route("", crate::origin::Route::default()).unwrap(); + let claim = h._origin.dynamic_route(Path::new("").unwrap(), crate::origin::Route::default()).unwrap(); settle().await; let stream = Stream::open(&mut crate::driver::Transport::new(h.session.clone()), version) .await @@ -9532,7 +9533,7 @@ mod serve_tests { Some(subscribe_options) => { ietf::SubscribeNamespaceLegacy { request_id: RequestId(REQUEST_ID), - namespace: crate::Path::new(""), + namespace: crate::Path::new("").unwrap(), subscribe_options, hidden: false, } @@ -9543,7 +9544,7 @@ mod serve_tests { None => { ietf::SubscribeNamespace { request_id: RequestId(REQUEST_ID), - namespace: crate::Path::new(""), + namespace: crate::Path::new("").unwrap(), hidden: false, } .encode_msg(&mut w, version) @@ -10502,7 +10503,7 @@ mod serve_tests { /// A standalone FETCH of `room/`, spelled as [`standalone_fetch`] describes. fn fetch_range(version: Version, track: &'static str, start: Location, end: Location) -> FetchType<'static> { - let namespace = crate::Path::new("room"); + let namespace = crate::Path::new("room").unwrap(); let track = track.into(); match Filter::is_draft20(version) { true => FetchType::Filtered { @@ -10832,10 +10833,10 @@ mod serve_tests { /// published with `info`. async fn across_a_hop(info: track::Info) -> track::Info { let upstream = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); - let broadcast = upstream.publish("room", crate::origin::Route::default()).unwrap(); + let broadcast = upstream.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); let _track = broadcast.create_track("video", info).unwrap(); let (downstream, _sessions) = crate::lite::ietf::test_hop(&upstream, "room", [true, true]).await; - let broadcast = downstream.consume().request_broadcast("room", None).await.unwrap(); + let broadcast = downstream.consume().request_broadcast(Path::new("room").unwrap(), None).await.unwrap(); broadcast.track("video").unwrap().query().await.unwrap() } @@ -11230,7 +11231,7 @@ mod serve_tests { settle().await; let fetch_type = FetchType::Filtered { - namespace: crate::Path::new("room"), + namespace: crate::Path::new("room").unwrap(), track: "video".into(), filter, }; @@ -11414,7 +11415,7 @@ mod serve_tests { async fn a_standalone_fetch_narrowed_while_responding_stops() { for version in FETCH_DRAFTS { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let broadcast = origin.publish("room", crate::origin::Route::default()).unwrap(); + let broadcast = origin.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); let mut group = track.create_group(group::Info { sequence: 0 }).unwrap(); group.write_frame(timestamp(), b"0-0".to_vec()).unwrap(); @@ -11451,7 +11452,7 @@ mod serve_tests { subscriber_priority: 128, group_order: GroupOrder::Ascending, fetch_type: FetchType::Standalone { - namespace: crate::Path::new("room"), + namespace: crate::Path::new("room").unwrap(), track: "video".into(), start: location, end: Location { group: 0, object: 1 }, @@ -11510,7 +11511,7 @@ mod serve_tests { }, ] { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let broadcast = origin.publish("room", crate::origin::Route::default()).unwrap(); + let broadcast = origin.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); let mut group = track.create_group(group::Info { sequence: 0 }).unwrap(); group.write_frame(timestamp(), PAYLOAD.to_vec()).unwrap(); @@ -11619,7 +11620,7 @@ mod serve_tests { .flat_map(|version| [false, true].map(|token| (version, token))) { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let broadcast = origin.publish("room", crate::origin::Route::default()).unwrap(); + let broadcast = origin.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); let mut group = track.create_group(group::Info { sequence: 0 }).unwrap(); group.write_frame(timestamp(), b"joined-prefix".to_vec()).unwrap(); @@ -11756,11 +11757,11 @@ mod serve_tests { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let (claim, published) = match parked { Parked::Resolving => ( - Some(origin.dynamic_route("room", crate::origin::Route::default()).unwrap()), + Some(origin.dynamic_route(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap()), None, ), Parked::Acking | Parked::Ending => { - let broadcast = origin.publish("room", crate::origin::Route::default()).unwrap(); + let broadcast = origin.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); match parked { // One published group, so the subscription parks at the live edge. @@ -11946,7 +11947,7 @@ mod serve_tests { let mut idle = None; match setup { Setup::Resolving => { - let route = origin.dynamic_route("room", crate::origin::Route::default()).unwrap(); + let route = origin.dynamic_route(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); let request = { let requested = std::pin::pin!(route.requested_broadcast()); match futures::future::select(requested, serving.as_mut()).await { @@ -11957,7 +11958,7 @@ mod serve_tests { claim = Some((route, request)); } Setup::Subscribing => { - let broadcast = origin.publish("room", crate::origin::Route::default()).unwrap(); + let broadcast = origin.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); let mut dynamic = broadcast.dynamic(); let request = { let requested = std::pin::pin!(dynamic.requested_track()); @@ -11969,7 +11970,7 @@ mod serve_tests { asked = Some((broadcast, dynamic, request)); } Setup::Live => { - let broadcast = origin.publish("room", crate::origin::Route::default()).unwrap(); + let broadcast = origin.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); let mut track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); track.set_idle(); serve_until(serving.as_mut(), "the upstream subscription", || { @@ -12427,7 +12428,7 @@ mod serve_tests { /// its script. fn serve_on(version: Version, auth: crate::auth::Link, session: ScriptedSession) -> Serve { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let broadcast = origin.publish("room", crate::origin::Route::default()).unwrap(); + let broadcast = origin.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); let log = session.log.clone(); @@ -14210,6 +14211,7 @@ mod serve_tests { #[cfg(test)] mod tests { use super::*; + use crate::Path; use crate::coding::Decode; use crate::lite::test_transport::SinkSession; use crate::model::ProduceTest; @@ -14322,7 +14324,7 @@ mod tests { echoed_hops.push(crate::Hop::UNKNOWN).unwrap(); let echoed = origin .announce( - "from/peer", + Path::new("from/peer").unwrap(), crate::origin::Route::default() .with_hops(echoed_hops) .with_via(assigned), @@ -14332,7 +14334,7 @@ mod tests { let mut local_hops = crate::Hops::new(); local_hops.push(other).unwrap(); let local = origin - .announce("from/us", crate::origin::Route::default().with_hops(local_hops)) + .announce(Path::new("from/us").unwrap(), crate::origin::Route::default().with_hops(local_hops)) .unwrap(); (publisher, consumer, vec![echoed, local]) @@ -14351,7 +14353,7 @@ mod tests { // The cursor is what filters: an excluded consumer never sees the echoed route. let mut announced = consumer.excluding(assigned).announced(); - let local = announced.assert_next_active("from/us"); + let local = announced.assert_next_active(Path::new("from/us").unwrap()); announced.assert_next_wait(); assert_eq!(publisher.select(&local, &peer, false), Advert::Some(Default::default())); @@ -14381,7 +14383,7 @@ mod tests { hops.push(r1).unwrap(); let _echoed = origin .announce( - "from/peer", + Path::new("from/peer").unwrap(), crate::origin::Route::default().with_hops(hops.clone()).with_via(r1), ) .unwrap(); @@ -14453,7 +14455,7 @@ mod tests { hops.push(crate::Hop::UNKNOWN).unwrap(); let _echoed = origin .announce( - "from/peer", + Path::new("from/peer").unwrap(), crate::origin::Route::default().with_hops(hops).with_via(assigned), ) .unwrap(); @@ -14498,13 +14500,13 @@ mod tests { let mut clean = crate::Hops::new(); clean.push(crate::Hop::new(778).unwrap()).unwrap(); let _clean = origin - .announce("cam-clean", crate::origin::Route::default().with_hops(clean)) + .announce(Path::new("cam-clean").unwrap(), crate::origin::Route::default().with_hops(clean)) .unwrap(); // A chain with no room left for our own hop cannot be forwarded. let mut full = crate::Hops::new(); while full.push(crate::Hop::new(100 + full.len() as u64).unwrap()).is_ok() {} let _full = origin - .announce("cam-full", crate::origin::Route::default().with_hops(full)) + .announce(Path::new("cam-full").unwrap(), crate::origin::Route::default().with_hops(full)) .unwrap(); settle().await; @@ -14513,7 +14515,7 @@ mod tests { .unwrap(); let msg = ietf::SubscribeNamespace { request_id: RequestId(1), - namespace: crate::Path::new(""), + namespace: crate::Path::new("").unwrap(), hidden: false, }; let mut run = std::pin::pin!(publisher.run_subscribe_namespace_stream(stream, msg)); @@ -14572,7 +14574,7 @@ mod tests { tainted_hops.push(crate::Hop::UNKNOWN).unwrap(); let _tainted = origin .announce( - "route-flip-cam", + Path::new("route-flip-cam").unwrap(), crate::origin::Route::default() .with_hops(tainted_hops) .with_via(assigned), @@ -14585,7 +14587,7 @@ mod tests { .unwrap(); let msg = ietf::SubscribeNamespace { request_id: RequestId(1), - namespace: crate::Path::new(""), + namespace: crate::Path::new("").unwrap(), hidden: false, }; let mut run = std::pin::pin!(publisher.run_subscribe_namespace_stream(stream, msg)); @@ -14600,7 +14602,7 @@ mod tests { let mut clean_hops = crate::Hops::new(); clean_hops.push(clean_publisher).unwrap(); let clean = origin - .announce("route-flip-cam", crate::origin::Route::default().with_hops(clean_hops)) + .announce(Path::new("route-flip-cam").unwrap(), crate::origin::Route::default().with_hops(clean_hops)) .unwrap(); settle().await; assert!(futures::poll!(run.as_mut()).is_pending()); @@ -14656,7 +14658,7 @@ mod tests { const VERSION: Version = Version::Draft17; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _cam = origin.announce("lonely-cam", crate::origin::Route::default()).unwrap(); + let _cam = origin.announce(Path::new("lonely-cam").unwrap(), crate::origin::Route::default()).unwrap(); settle().await; // Every stream is answered with the same refusal, so a retry would show up as a @@ -14711,7 +14713,7 @@ mod tests { for epochs in [true, false] { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let _old = origin - .announce("cam", crate::origin::Route::default().with_epoch(crate::Epoch::mint())) + .announce(Path::new("cam").unwrap(), crate::origin::Route::default().with_epoch(crate::Epoch::mint())) .unwrap(); settle().await; @@ -14748,7 +14750,7 @@ mod tests { if count == 1 { // A newer epoch outranks the old at the same path: a restart. let route = crate::origin::Route::default().with_epoch(crate::Epoch::mint()); - _new = Some(origin.announce("cam", route).unwrap()); + _new = Some(origin.announce(Path::new("cam").unwrap(), route).unwrap()); } } for _ in 0..10 { @@ -14840,7 +14842,7 @@ mod tests { let consumer = origin.consume(); // Announced before the peer subscribes: it must only hit the wire after. - let early = origin.announce("early-cam", crate::origin::Route::default()).unwrap(); + let early = origin.announce(Path::new("early-cam").unwrap(), crate::origin::Route::default()).unwrap(); settle().await; // Stream 1 is the peer's SUBSCRIBE_NAMESPACE (the peer stays quiet after); @@ -14864,7 +14866,7 @@ mod tests { .unwrap(); let msg = ietf::SubscribeNamespace { request_id: RequestId(1), - namespace: crate::Path::new(""), + namespace: crate::Path::new("").unwrap(), hidden: false, }; let mut run = std::pin::pin!(publisher.run_subscribe_namespace_stream(stream, msg)); @@ -14884,7 +14886,7 @@ mod tests { ); // A later announce reaches the same subscription. - let _late = origin.announce("late-cam", crate::origin::Route::default()).unwrap(); + let _late = origin.announce(Path::new("late-cam").unwrap(), crate::origin::Route::default()).unwrap(); for _ in 0..100 { assert!(futures::poll!(run.as_mut()).is_pending()); if occurrences(&log, b"late-cam") >= 1 { @@ -14926,7 +14928,7 @@ mod tests { const VERSION: Version = Version::Draft17; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _local = origin.announce("local-cam", crate::origin::Route::default()).unwrap(); + let _local = origin.announce(Path::new("local-cam").unwrap(), crate::origin::Route::default()).unwrap(); settle().await; // The only stream is the PUBLISH_NAMESPACE request we open ourselves. @@ -14970,7 +14972,7 @@ mod tests { async fn publish_namespace_withdraws_by_reset_from_draft_17() { for version in [Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft22] { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let local = origin.announce("local-cam", crate::origin::Route::default()).unwrap(); + let local = origin.announce(Path::new("local-cam").unwrap(), crate::origin::Route::default()).unwrap(); settle().await; let session = @@ -15034,7 +15036,7 @@ mod tests { const VERSION: Version = Version::Draft17; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _local = origin.announce("local-cam", crate::origin::Route::default()).unwrap(); + let _local = origin.announce(Path::new("local-cam").unwrap(), crate::origin::Route::default()).unwrap(); settle().await; let ok = crate::lite::test_transport::Log::default(); @@ -15126,8 +15128,8 @@ mod tests { scoped, } = case; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _cam = origin.announce("cam", crate::origin::Route::default()).unwrap(); - let _stats = origin.announce(".stats/node", crate::origin::Route::default()).unwrap(); + let _cam = origin.announce(Path::new("cam").unwrap(), crate::origin::Route::default()).unwrap(); + let _stats = origin.announce(Path::new(".stats/node").unwrap(), crate::origin::Route::default()).unwrap(); settle().await; // Stream 1 is the peer's SUBSCRIBE_NAMESPACE; stream 2, if opened at all, is our @@ -15147,7 +15149,7 @@ mod tests { let consume = match scoped { true => origin .consume() - .scope("", &crate::Pattern::subtree(".stats").unwrap().into()) + .scope(Path::new("").unwrap(), &crate::Pattern::subtree(".stats").unwrap().into()) .unwrap(), false => origin.consume(), }; @@ -15166,7 +15168,7 @@ mod tests { .unwrap(); let msg = ietf::SubscribeNamespace { request_id: RequestId(1), - namespace: crate::Path::new(prefix), + namespace: crate::Path::new(prefix).unwrap(), hidden, }; let mut solicited = std::pin::pin!(publisher.clone().run_subscribe_namespace_stream(stream, msg)); @@ -15301,7 +15303,7 @@ mod tests { async fn a_non_solicit_subscribe_namespace_carries_namespace() { for version in [Version::Draft16, Version::Draft18] { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let early = origin.announce("early-cam", crate::origin::Route::default()).unwrap(); + let early = origin.announce(Path::new("early-cam").unwrap(), crate::origin::Route::default()).unwrap(); settle().await; let session = crate::lite::test_transport::ScriptedSession::per_stream(vec![Vec::new()]); @@ -15325,7 +15327,7 @@ mod tests { .unwrap(); let msg = ietf::SubscribeNamespace { request_id: RequestId(1), - namespace: crate::Path::new(""), + namespace: crate::Path::new("").unwrap(), hidden: false, }; let mut run = std::pin::pin!(publisher.run_subscribe_namespace_stream(stream, msg)); @@ -15344,7 +15346,7 @@ mod tests { "{version:?}: existing match", ); - let _late = origin.announce("late-cam", crate::origin::Route::default()).unwrap(); + let _late = origin.announce(Path::new("late-cam").unwrap(), crate::origin::Route::default()).unwrap(); for _ in 0..100 { assert!(futures::poll!(run.as_mut()).is_pending()); if occurrences(&log, b"late-cam") >= 1 { @@ -15393,7 +15395,7 @@ mod tests { const VERSION: Version = Version::Draft14; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let first = origin.announce("first-cam", crate::origin::Route::default()).unwrap(); + let first = origin.announce(Path::new("first-cam").unwrap(), crate::origin::Route::default()).unwrap(); settle().await; // The first advertisement has send capacity, and the peer answers it. @@ -15428,7 +15430,7 @@ mod tests { // Send capacity runs out before the second advertisement can send its header. set_gate(&gate, false); - let _second = origin.announce("second-cam", crate::origin::Route::default()).unwrap(); + let _second = origin.announce(Path::new("second-cam").unwrap(), crate::origin::Route::default()).unwrap(); settle().await; // Retiring the first needs no new stream, so the loop has to reach @@ -15492,7 +15494,7 @@ mod tests { // The state a refused or failed offer leaves behind: the peer holds nothing, and // the loop is coming back to it on a timer. - let suffix: crate::PathOwned = crate::Path::new("from/peer").to_owned(); + let suffix: crate::PathOwned = crate::Path::new("from/peer").unwrap().to_owned(); let mut watch = Watched::new(crate::origin::Route::default().with_hops(hops)); watch.deferred = true; @@ -15518,7 +15520,7 @@ mod tests { // One epoch, so the second route re-prices the instance rather than restart it. let epoch = crate::Epoch::mint(); let cam = origin - .announce("solo-cam", crate::origin::Route::default().with_epoch(epoch.clone())) + .announce(Path::new("solo-cam").unwrap(), crate::origin::Route::default().with_epoch(epoch.clone())) .unwrap(); settle().await; @@ -15552,7 +15554,7 @@ mod tests { // path back into the reconciliation that does not go through the retry timer. let _standby = origin .announce( - "solo-cam", + Path::new("solo-cam").unwrap(), crate::origin::Route::default().with_epoch(epoch).with_cost(0), ) .unwrap(); @@ -15601,7 +15603,7 @@ mod tests { writer.varint(ietf::PublishNamespaceDone::ID).await.unwrap(); writer .encode(&ietf::PublishNamespaceDone { - track_namespace: crate::Path::new("cam"), + track_namespace: crate::Path::new("cam").unwrap(), request_id: RequestId(1), }) .await @@ -15619,7 +15621,7 @@ mod tests { writer.varint(ietf::PublishNamespaceCancel::ID).await.unwrap(); writer .encode(&ietf::PublishNamespaceCancel { - track_namespace: crate::Path::new("cam"), + track_namespace: crate::Path::new("cam").unwrap(), request_id: RequestId(1), error_code: 0, reason_phrase: "gone".into(), @@ -15659,7 +15661,7 @@ mod tests { let epoch = crate::Epoch::mint(); let _cold = origin .announce( - "cam", + Path::new("cam").unwrap(), crate::origin::Route::default().with_epoch(epoch.clone()).with_cost(4), ) .unwrap(); @@ -15693,7 +15695,7 @@ mod tests { // We start carrying it: a free route outranks the cold one. let _warm = origin - .announce("cam", crate::origin::Route::default().with_epoch(epoch).with_cost(0)) + .announce(Path::new("cam").unwrap(), crate::origin::Route::default().with_epoch(epoch).with_cost(0)) .unwrap(); // The request consumed id 1, so the update takes the next of our parity. The @@ -15732,7 +15734,7 @@ mod tests { let epoch = crate::Epoch::mint(); let _cold = origin .announce( - "cam", + Path::new("cam").unwrap(), crate::origin::Route::default().with_epoch(epoch.clone()).with_cost(4), ) .unwrap(); @@ -15784,7 +15786,7 @@ mod tests { peer.push(&counted); // Repricing sends the REQUEST_UPDATE whose OK is counted. let _warm = origin - .announce("cam", crate::origin::Route::default().with_epoch(epoch).with_cost(0)) + .announce(Path::new("cam").unwrap(), crate::origin::Route::default().with_epoch(epoch).with_cost(0)) .unwrap(); let res = moq_clock::timeout(Duration::from_secs(5), run) @@ -15815,7 +15817,7 @@ mod tests { let epoch = crate::Epoch::mint(); let _from_a = origin .announce( - "cam", + Path::new("cam").unwrap(), crate::origin::Route::default() .with_epoch(epoch.clone()) .with_hops(publisher_a) @@ -15853,7 +15855,7 @@ mod tests { // A cheaper route from B wins the selection. let _from_b = origin .announce( - "cam", + Path::new("cam").unwrap(), crate::origin::Route::default() .with_epoch(epoch) .with_hops(publisher_b) @@ -15959,7 +15961,7 @@ mod tests { .present(bytes::Bytes::from_static(b"second-secret"), false) .unwrap(); let cam = origin - .announce("cam", crate::origin::Route::default().with_auth(first)) + .announce(Path::new("cam").unwrap(), crate::origin::Route::default().with_auth(first)) .unwrap(); settle().await; @@ -16030,7 +16032,7 @@ mod tests { .present(bytes::Bytes::from_static(b"second-secret"), false) .unwrap(); let cam = origin - .announce("cam", crate::origin::Route::default().with_auth(first)) + .announce(Path::new("cam").unwrap(), crate::origin::Route::default().with_auth(first)) .unwrap(); settle().await; @@ -16073,7 +16075,7 @@ mod tests { .present(bytes::Bytes::from_static(b"second-secret"), false) .unwrap(); let cam = origin - .announce("cam", crate::origin::Route::default().with_auth(first)) + .announce(Path::new("cam").unwrap(), crate::origin::Route::default().with_auth(first)) .unwrap(); settle().await; @@ -16119,7 +16121,7 @@ mod tests { .present(bytes::Bytes::from_static(b"foreign-secret"), false) .unwrap(); let _cam = origin - .announce("cam", crate::origin::Route::default().with_auth(foreign)) + .announce(Path::new("cam").unwrap(), crate::origin::Route::default().with_auth(foreign)) .unwrap(); settle().await; @@ -16145,7 +16147,7 @@ mod tests { let origin = unheld_origin(); let auth = crate::auth::Link::ietf(false); let token = auth.present(bytes::Bytes::from_static(b"late-secret"), false).unwrap(); - let cam = origin.announce("cam", crate::origin::Route::default()).unwrap(); + let cam = origin.announce(Path::new("cam").unwrap(), crate::origin::Route::default()).unwrap(); settle().await; let ok = publish_namespace_ok(VERSION).await; @@ -16175,7 +16177,7 @@ mod tests { .present(bytes::Bytes::from_static(b"second-secret"), false) .unwrap(); let cam = origin - .announce("cam", crate::origin::Route::default().with_auth(first)) + .announce(Path::new("cam").unwrap(), crate::origin::Route::default().with_auth(first)) .unwrap(); settle().await; @@ -16206,10 +16208,10 @@ mod tests { let auth = crate::auth::Link::ietf(false); let present = |token: &'static [u8]| auth.present(bytes::Bytes::from_static(token), false).unwrap(); let a = origin - .announce("cam-a", crate::origin::Route::default().with_auth(present(b"a-first"))) + .announce(Path::new("cam-a").unwrap(), crate::origin::Route::default().with_auth(present(b"a-first"))) .unwrap(); let b = origin - .announce("cam-b", crate::origin::Route::default().with_auth(present(b"b-first"))) + .announce(Path::new("cam-b").unwrap(), crate::origin::Route::default().with_auth(present(b"b-first"))) .unwrap(); settle().await; @@ -16233,7 +16235,7 @@ mod tests { "cam-b's renewal waited on cam-a's answer" ); - let _c = origin.announce("cam-c", crate::origin::Route::default()).unwrap(); + let _c = origin.announce(Path::new("cam-c").unwrap(), crate::origin::Route::default()).unwrap(); poll_until(&mut run, &log, b"cam-c", 1).await; assert_eq!( occurrences(&log, b"cam-c"), @@ -16252,7 +16254,7 @@ mod tests { for fin in [true, false] { let origin = unheld_origin(); - let _cam = origin.announce("cam", crate::origin::Route::default()).unwrap(); + let _cam = origin.announce(Path::new("cam").unwrap(), crate::origin::Route::default()).unwrap(); settle().await; let (session, peer) = memory::pair(memory::Config::default()); @@ -16320,7 +16322,7 @@ mod tests { let origin = unheld_origin(); let mut cams: HashMap<&str, _> = ["a-cam", "b-cam"] .into_iter() - .map(|name| (name, origin.announce(name, crate::origin::Route::default()).unwrap())) + .map(|name| (name, origin.announce(Path::new(name).unwrap(), crate::origin::Route::default()).unwrap())) .collect(); settle().await; @@ -16409,7 +16411,7 @@ mod tests { let auth = crate::auth::Link::ietf(false); let token = auth.present(bytes::Bytes::from(vec![0; 70_000]), false).unwrap(); let _cam = origin - .announce("cam", crate::origin::Route::default().with_auth(token)) + .announce(Path::new("cam").unwrap(), crate::origin::Route::default().with_auth(token)) .unwrap(); settle().await; @@ -16474,7 +16476,7 @@ mod tests { let auth = crate::auth::Link::ietf(false); let present = |token: &'static [u8]| auth.present(bytes::Bytes::from_static(token), false).unwrap(); let cam = origin - .announce("cam", crate::origin::Route::default().with_auth(present(b"first"))) + .announce(Path::new("cam").unwrap(), crate::origin::Route::default().with_auth(present(b"first"))) .unwrap(); settle().await; @@ -16529,7 +16531,7 @@ mod tests { let auth = crate::auth::Link::ietf(false); let present = |token: &'static [u8]| auth.present(bytes::Bytes::from_static(token), false).unwrap(); let cam = origin - .announce("cam", crate::origin::Route::default().with_auth(present(b"first"))) + .announce(Path::new("cam").unwrap(), crate::origin::Route::default().with_auth(present(b"first"))) .unwrap(); settle().await; @@ -16573,7 +16575,7 @@ mod tests { } .produce(); let _old = origin - .announce("cam", crate::origin::Route::default().with_cost(4)) + .announce(Path::new("cam").unwrap(), crate::origin::Route::default().with_cost(4)) .unwrap(); settle().await; @@ -16602,7 +16604,7 @@ mod tests { assert_eq!(occurrences(&log, b"cam"), 1, "the advertisement never went out"); let _new = origin - .announce("cam", crate::origin::Route::default().with_cost(0)) + .announce(Path::new("cam").unwrap(), crate::origin::Route::default().with_cost(0)) .unwrap(); for _ in 0..100 { assert!(futures::poll!(run.as_mut()).is_pending()); @@ -16628,7 +16630,7 @@ mod tests { let epoch = crate::Epoch::mint(); let _cold = origin .announce( - "cam", + Path::new("cam").unwrap(), crate::origin::Route::default().with_epoch(epoch.clone()).with_cost(4), ) .unwrap(); @@ -16665,7 +16667,7 @@ mod tests { peer.push(&refusal); let _warm = origin - .announce("cam", crate::origin::Route::default().with_epoch(epoch).with_cost(0)) + .announce(Path::new("cam").unwrap(), crate::origin::Route::default().with_epoch(epoch).with_cost(0)) .unwrap(); for _ in 0..100 { @@ -16696,7 +16698,7 @@ mod tests { async fn close_withdraws_legacy_namespaces_without_closing_the_origin() { const VERSION: Version = Version::Draft14; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _cam = origin.announce("closing-cam", crate::origin::Route::default()).unwrap(); + let _cam = origin.announce(Path::new("closing-cam").unwrap(), crate::origin::Route::default()).unwrap(); settle().await; let session = crate::lite::test_transport::ScriptedSession::per_stream(vec![publish_namespace_ok(VERSION).await]); @@ -16740,8 +16742,8 @@ mod tests { const VERSION: Version = Version::Draft14; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _first = origin.announce("first-cam", crate::origin::Route::default()).unwrap(); - let _second = origin.announce("second-cam", crate::origin::Route::default()).unwrap(); + let _first = origin.announce(Path::new("first-cam").unwrap(), crate::origin::Route::default()).unwrap(); + let _second = origin.announce(Path::new("second-cam").unwrap(), crate::origin::Route::default()).unwrap(); settle().await; // Every stream opens and then goes silent: an exhausted script parks rather than @@ -16787,7 +16789,7 @@ mod tests { async fn an_unanswered_advertisement_is_withdrawn() { for version in [Version::Draft14, Version::Draft15, Version::Draft16, Version::Draft17] { let origin = unheld_origin(); - let _cam = origin.announce("cam", crate::origin::Route::default()).unwrap(); + let _cam = origin.announce(Path::new("cam").unwrap(), crate::origin::Route::default()).unwrap(); settle().await; // The peer takes the request and answers nothing. @@ -16840,7 +16842,7 @@ mod tests { Version::Draft19, ] { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _cam = origin.announce("lonely-cam", crate::origin::Route::default()).unwrap(); + let _cam = origin.announce(Path::new("lonely-cam").unwrap(), crate::origin::Route::default()).unwrap(); settle().await; let session = crate::lite::test_transport::ScriptedSession::new(publish_namespace_ok(version).await).without_credit(); @@ -16891,7 +16893,7 @@ mod tests { const VERSION: Version = Version::Draft14; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _cam = origin.announce("lonely-cam", crate::origin::Route::default()).unwrap(); + let _cam = origin.announce(Path::new("lonely-cam").unwrap(), crate::origin::Route::default()).unwrap(); settle().await; // No send capacity from the start: an admitted header cannot finish. @@ -16997,7 +16999,7 @@ mod tests { max_age: None, new_group: None, request_id: RequestId(1), - track_namespace: crate::Path::new("nothing/here"), + track_namespace: crate::Path::new("nothing/here").unwrap(), track_name: "video".into(), subscriber_priority: 128, group_order: GroupOrder::Descending, @@ -17075,7 +17077,7 @@ mod tests { ( "standalone", FetchType::Standalone { - namespace: crate::Path::new("nothing/here"), + namespace: crate::Path::new("nothing/here").unwrap(), track: "video".into(), start: Location { group: 0, object: 0 }, end: Location { group: 1, object: 0 }, @@ -17084,7 +17086,7 @@ mod tests { ( "empty range", FetchType::Standalone { - namespace: crate::Path::new("nothing/here"), + namespace: crate::Path::new("nothing/here").unwrap(), track: "video".into(), start: Location { group: 2, object: 0 }, end: Location { group: 1, object: 0 }, @@ -17367,7 +17369,7 @@ mod range_tests { max_age: None, new_group: None, request_id: RequestId(1), - track_namespace: crate::Path::new("broadcast"), + track_namespace: crate::Path::new("broadcast").unwrap(), track_name: "video".into(), subscriber_priority: 128, group_order: GroupOrder::Descending, diff --git a/rs/moq-net/src/ietf/publisher/tracks.rs b/rs/moq-net/src/ietf/publisher/tracks.rs index 1ee432ccd7d..09ba76141ad 100644 --- a/rs/moq-net/src/ietf/publisher/tracks.rs +++ b/rs/moq-net/src/ietf/publisher/tracks.rs @@ -1315,6 +1315,7 @@ fn unlisted(listed: &kio::Consumer) -> Served { #[cfg(test)] mod tests { use super::*; + use crate::Path; use crate::model::ProduceTest as _; use crate::transport::memory; @@ -1346,7 +1347,7 @@ mod tests { fn harness_with(version: Version, config: memory::Config, declared: peer::Peer) -> Harness { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let broadcast = origin.publish("room/cam", crate::origin::Route::default()).unwrap(); + let broadcast = origin.publish(Path::new("room/cam").unwrap(), crate::origin::Route::default()).unwrap(); let tracks = ["video", "audio"] .into_iter() .map(|name| (name, broadcast.create_track(name, crate::track::Info::timed()).unwrap())) @@ -1377,7 +1378,7 @@ mod tests { fn listing(forward: bool) -> ietf::SubscribeTracks<'static> { ietf::SubscribeTracks { request_id: RequestId(0), - prefix: crate::Path::new("room"), + prefix: crate::Path::new("room").unwrap(), forward, subscriber_priority: None, group_order: None, @@ -1513,7 +1514,7 @@ mod tests { let (_stream, _, name, _) = h.publish().await; assert_eq!(name, "captions", "{version}"); - let mic = h._origin.publish("room/mic", crate::origin::Route::default()).unwrap(); + let mic = h._origin.publish(Path::new("room/mic").unwrap(), crate::origin::Route::default()).unwrap(); let _audio = mic.create_track("audio", crate::track::Info::timed()).unwrap(); let (_stream, namespace, name, _) = h.publish().await; assert_eq!((namespace.as_str(), name.as_str()), ("room/mic", "audio"), "{version}"); @@ -1727,7 +1728,7 @@ mod tests { let mut nested = listing(false); nested.request_id = RequestId(2); - nested.prefix = crate::Path::new("room/cam"); + nested.prefix = crate::Path::new("room/cam").unwrap(); let mut second = h.request(&nested).await; let (id, body) = next(&mut second).await; assert_eq!(id, ietf::RequestError::ID, "{version}"); @@ -1753,7 +1754,7 @@ mod tests { let subscribe = ietf::Subscribe { request_id: RequestId(2), - track_namespace: crate::Path::new("room/cam"), + track_namespace: crate::Path::new("room/cam").unwrap(), track_name: "video".into(), subscriber_priority: 128, group_order: GroupOrder::Descending, @@ -1842,7 +1843,7 @@ mod tests { let route = kio::Producer::new(()); let request = Request { origin: h._origin.consume(), - prefix: crate::Path::new("").to_owned(), + prefix: crate::Path::new("").unwrap().to_owned(), forward: true, params: Params { priority: crate::ietf::priority::DEFAULT_WIRE, @@ -1857,7 +1858,7 @@ mod tests { }; moq_clock::sim::spawn(h.publisher.clone().run_listed_broadcast( request, - crate::Path::new("room/cam").to_owned(), + crate::Path::new("room/cam").unwrap().to_owned(), None, route.consume(), )); @@ -2343,7 +2344,7 @@ mod tests { let mut h = harness(version); let subscribe = ietf::Subscribe { request_id: RequestId(0), - track_namespace: crate::Path::new("room/cam"), + track_namespace: crate::Path::new("room/cam").unwrap(), track_name: "video".into(), subscriber_priority: 128, group_order: GroupOrder::Descending, @@ -2505,7 +2506,7 @@ mod tests { moq_clock::sleep(Duration::from_millis(10)).await; // A new instance takes the path while the old one goes on: only its route ends. - let _restarted = h._origin.publish("room/cam", crate::origin::Route::default()).unwrap(); + let _restarted = h._origin.publish(Path::new("room/cam").unwrap(), crate::origin::Route::default()).unwrap(); let (id, body) = next(&mut stream).await; assert_eq!(id, ietf::PublishDone::ID, "{version}"); let done: ietf::PublishDone = body.message(version).unwrap(); diff --git a/rs/moq-net/src/ietf/request_stream.rs b/rs/moq-net/src/ietf/request_stream.rs index ae9ee8a0be1..43d7a3d2404 100644 --- a/rs/moq-net/src/ietf/request_stream.rs +++ b/rs/moq-net/src/ietf/request_stream.rs @@ -566,6 +566,7 @@ impl Decode for NamespaceUpdate { #[cfg(test)] mod tests { use super::*; + use crate::Path; #[moq_clock::test] async fn request_messages_keep_goaway_state_across_response_phases() { @@ -594,7 +595,7 @@ mod tests { use crate::lite::test_transport::ScriptedSession; use crate::stats::{Control, Registry, Tier}; let registry = Registry::new(Default::default()); - let stats = registry.tier(Tier::default()).session(""); + let stats = registry.tier(Tier::default()).session(Path::new("").unwrap()); let version = Version::Draft22; let session = ScriptedSession::new(vec![0x10, 0, 2, 0, 0, 0x07, 0, 0]); let mut stream = with_stats( diff --git a/rs/moq-net/src/ietf/session.rs b/rs/moq-net/src/ietf/session.rs index 6b46a30ecda..6e25aac32d6 100644 --- a/rs/moq-net/src/ietf/session.rs +++ b/rs/moq-net/src/ietf/session.rs @@ -1544,6 +1544,7 @@ async fn enforce_grant(auth: crate::auth::Link, publisher: Publisher, mut sessio #[cfg(test)] mod tests { use super::*; + use crate::Path; use crate::model::ProduceTest; /// The peer's IMPLEMENTATION option is read alongside what it declared, and one that @@ -1667,7 +1668,7 @@ mod tests { } else { ietf::TrackStatus { request_id: RequestId(id), - track_namespace: crate::Path::from("test"), + track_namespace: crate::Path::new("test").unwrap(), track_name: "video".into(), properties_wanted: true, epoch: None, @@ -1871,7 +1872,7 @@ mod tests { writer.varint(ietf::Namespace::ID).await.unwrap(); writer .encode(&ietf::Namespace { - suffix: crate::Path::new("cam"), + suffix: crate::Path::new("cam").unwrap(), params: None, }) .await @@ -1959,7 +1960,7 @@ mod tests { .map(|prefix| crate::Pattern::subtree(prefix).unwrap()) .collect(); let scoped = origin - .scope("rootns", &scope) + .scope(Path::new("rootns").unwrap(), &scope) .expect("scope the origin to two prefixes"); let _watch = scoped.consume().announced(); @@ -2016,7 +2017,7 @@ mod tests { ); let msg = ietf::SubscribeNamespaceLegacy { request_id, - namespace: crate::Path::new(namespace), + namespace: crate::Path::new(namespace).unwrap(), subscribe_options: ietf::SubscribeOptions::Namespace, hidden: false, }; @@ -2030,7 +2031,7 @@ mod tests { let log = crate::lite::test_transport::Log::default(); let mut writer = Writer::new(crate::lite::test_transport::SinkSend::new(log.clone()), version); let msg = ietf::UnsubscribeNamespace { - prefix: crate::Path::new(prefix), + prefix: crate::Path::new(prefix).unwrap(), request_id, }; writer.varint(ietf::UnsubscribeNamespace::ID).await.unwrap(); @@ -2042,7 +2043,7 @@ mod tests { fn watch(origin: &crate::origin::Producer, prefix: &str) -> crate::announce::Consumer { origin .consume() - .scope(prefix, &crate::Patterns::from(crate::Pattern::all())) + .scope(Path::new(prefix).unwrap(), &crate::Patterns::from(crate::Pattern::all())) .unwrap() .announced() } @@ -2343,7 +2344,7 @@ mod tests { /// enough: the question is only whether the bytes went out unasked. async fn announce_occurrences(peer_declared: Option) -> usize { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _cam = origin.announce("solo-cam", crate::origin::Route::default()).unwrap(); + let _cam = origin.announce(Path::new("solo-cam").unwrap(), crate::origin::Route::default()).unwrap(); // An open gate: an unsolicited PUBLISH_NAMESPACE can reach the wire. let gate = kio::Producer::new(true); @@ -2449,7 +2450,7 @@ mod tests { fn auth_session(auth: bool) -> AuthSession { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let cam = origin.announce("solo-cam", crate::origin::Route::default()).unwrap(); + let cam = origin.announce(Path::new("solo-cam").unwrap(), crate::origin::Route::default()).unwrap(); let gate = kio::Producer::new(true); let session = crate::lite::test_transport::SinkSession::gated_bi(gate.consume()); @@ -2991,7 +2992,7 @@ mod tests { max_age: None, new_group: None, request_id: RequestId(1), - track_namespace: crate::Path::new("room"), + track_namespace: crate::Path::new("room").unwrap(), track_name: "video".into(), subscriber_priority: 128, group_order: ietf::GroupOrder::Descending, @@ -3010,7 +3011,7 @@ mod tests { // Stall before the type, then after it while the body has not arrived. for stalled in [Vec::new(), vec![ietf::Subscribe::ID as u8]] { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let broadcast = origin.publish("room", crate::origin::Route::default()).unwrap(); + let broadcast = origin.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); let mut track = broadcast.create_track("video", None).unwrap(); let session = crate::lite::test_transport::ScriptedSession::new(Vec::new()) .with_incoming_bidis(vec![stalled, subscribe.clone()]); @@ -3322,7 +3323,7 @@ mod tests { writer .encode(&ietf::PublishNamespace { request_id: RequestId(1), - track_namespace: crate::Path::new("room/host"), + track_namespace: crate::Path::new("room/host").unwrap(), params: Default::default(), authorization_token: None, }) @@ -3333,7 +3334,7 @@ mod tests { writer.varint(ietf::PublishNamespaceDone::ID).await.unwrap(); writer .encode(&ietf::PublishNamespaceDone { - track_namespace: crate::Path::new("room/host"), + track_namespace: crate::Path::new("room/host").unwrap(), request_id: RequestId(0), }) .await @@ -3409,7 +3410,7 @@ mod tests { let accepted = publish_namespace_ok(RequestId(1)).await; for _ in 0..ANNOUNCE_TURNS { - if occurrences(&log, &accepted) > 0 && consumer.get_broadcast("room/host").is_none() { + if occurrences(&log, &accepted) > 0 && consumer.get_broadcast(Path::new("room/host").unwrap()).is_none() { break; } moq_clock::sleep(std::time::Duration::from_millis(1)).await; @@ -3417,7 +3418,7 @@ mod tests { assert_eq!(occurrences(&log, &accepted), 1, "the advertisement was not accepted"); assert!( - consumer.get_broadcast("room/host").is_none(), + consumer.get_broadcast(Path::new("room/host").unwrap()).is_none(), "the withdrawal did not reach the request that advertised it" ); assert!(!driver.is_finished(), "the repeated withdrawal ended the session"); @@ -3431,7 +3432,7 @@ mod tests { max_age: None, new_group: None, request_id: RequestId(0), - track_namespace: crate::Path::new("room"), + track_namespace: crate::Path::new("room").unwrap(), track_name: "video".into(), subscriber_priority: 128, group_order: ietf::GroupOrder::Descending, @@ -3981,7 +3982,7 @@ mod tests { let mut body = Vec::new(); ietf::SubscribeNamespace { request_id: RequestId(request_id), - namespace: crate::Path::new(""), + namespace: crate::Path::new("").unwrap(), hidden: false, } .encode_msg(&mut crate::coding::Encoder::new(&mut body, version.into()), version) diff --git a/rs/moq-net/src/ietf/subscribe.rs b/rs/moq-net/src/ietf/subscribe.rs index 1a6e1d60725..bb11d89b84f 100644 --- a/rs/moq-net/src/ietf/subscribe.rs +++ b/rs/moq-net/src/ietf/subscribe.rs @@ -628,7 +628,7 @@ mod tests { let msg = Subscribe { max_age, request_id: RequestId(0), - track_namespace: Path::new("live"), + track_namespace: Path::new("live").unwrap(), track_name: "catalog".into(), subscriber_priority: 128, group_order: GroupOrder::Descending, @@ -670,7 +670,7 @@ mod tests { new_group: None, max_age: None, request_id: RequestId(1), - track_namespace: Path::new("test"), + track_namespace: Path::new("test").unwrap(), track_name: "video".into(), subscriber_priority: 128, group_order: GroupOrder::Descending, @@ -699,7 +699,7 @@ mod tests { new_group: None, max_age: None, request_id: RequestId(1), - track_namespace: Path::new("test"), + track_namespace: Path::new("test").unwrap(), track_name: "video".into(), subscriber_priority: 128, group_order: GroupOrder::Descending, @@ -745,7 +745,7 @@ mod tests { new_group: Some(7), max_age: None, request_id: RequestId(1), - track_namespace: Path::new("test"), + track_namespace: Path::new("test").unwrap(), track_name: "video".into(), subscriber_priority: 128, group_order: GroupOrder::Descending, @@ -788,7 +788,7 @@ mod tests { if version == Version::Draft17 { w.varint(0)?; // required_request_id_delta } - encode_namespace(w, &Path::new("test"))?; + encode_namespace(w, &Path::new("test").unwrap())?; w.string("video")?; encode_params!(w, version, 0x04 => millis, @@ -855,7 +855,7 @@ mod tests { new_group: None, max_age: None, request_id: RequestId(1), - track_namespace: Path::new("test"), + track_namespace: Path::new("test").unwrap(), track_name: "video".into(), subscriber_priority: 128, group_order: GroupOrder::Descending, @@ -891,7 +891,7 @@ mod tests { new_group: None, max_age: None, request_id: RequestId(100), - track_namespace: Path::new("conference/room123"), + track_namespace: Path::new("conference/room123").unwrap(), track_name: "audio".into(), subscriber_priority: 255, group_order: GroupOrder::Descending, @@ -1054,7 +1054,7 @@ mod tests { let mut body = Vec::new(); let w = &mut Encoder::new(&mut body, version.into()); RequestId(1).encode(w, version)?; - encode_namespace(w, &crate::Path::new("broadcast"))?; + encode_namespace(w, &crate::Path::new("broadcast").unwrap())?; w.string("video")?; encode_params!(w, version, 0x02 => 5000u64, @@ -1082,7 +1082,7 @@ mod tests { new_group: None, max_age: None, request_id: RequestId(1), - track_namespace: crate::Path::new("broadcast"), + track_namespace: crate::Path::new("broadcast").unwrap(), track_name: "video".into(), subscriber_priority: 128, group_order: GroupOrder::Descending, @@ -1264,7 +1264,7 @@ mod tests { new_group: None, max_age: None, request_id: RequestId(1), - track_namespace: Path::new("test"), + track_namespace: Path::new("test").unwrap(), track_name: "video".into(), subscriber_priority: 128, group_order: GroupOrder::Descending, @@ -1334,7 +1334,7 @@ mod tests { new_group: None, max_age: None, request_id: RequestId(1), - track_namespace: Path::new("test"), + track_namespace: Path::new("test").unwrap(), track_name: "video".into(), subscriber_priority: 128, group_order: GroupOrder::Descending, @@ -1664,7 +1664,7 @@ mod tests { new_group: None, max_age: None, request_id: RequestId(1), - track_namespace: crate::Path::new("live"), + track_namespace: crate::Path::new("live").unwrap(), track_name: "video".into(), subscriber_priority: 128, group_order: GroupOrder::Descending, @@ -1729,7 +1729,7 @@ mod tests { new_group: None, max_age: None, request_id: RequestId(1), - track_namespace: crate::Path::new("live"), + track_namespace: crate::Path::new("live").unwrap(), track_name: "video".into(), subscriber_priority: 128, group_order: GroupOrder::Descending, diff --git a/rs/moq-net/src/ietf/subscribe_namespace.rs b/rs/moq-net/src/ietf/subscribe_namespace.rs index 79cb3233061..1b09b726949 100644 --- a/rs/moq-net/src/ietf/subscribe_namespace.rs +++ b/rs/moq-net/src/ietf/subscribe_namespace.rs @@ -392,7 +392,7 @@ mod tests { #[test] fn unsubscribe_namespace_names_the_prefix_then_the_request() { let msg = UnsubscribeNamespace { - prefix: Path::new("cam/front"), + prefix: Path::new("cam/front").unwrap(), request_id: RequestId(6), }; let mut v14 = bytes::Bytes::from(body(&msg, Version::Draft14)); @@ -426,7 +426,7 @@ mod tests { fn cluster_namespace_round_trips() { let version = Version::Draft19; let msg = Namespace { - suffix: Path::new("alice.hang"), + suffix: Path::new("alice.hang").unwrap(), params: clustered(&[7, 9], 5), }; @@ -439,7 +439,7 @@ mod tests { // The base form is strictly shorter, and reading the extended bytes as base // leaves the parameters behind rather than silently absorbing them. let base = Namespace { - suffix: Path::new("alice.hang"), + suffix: Path::new("alice.hang").unwrap(), params: None, }; let base_encoded = body(&base, version); @@ -455,11 +455,11 @@ mod tests { fn cluster_namespace_omits_zero_cost() { let version = Version::Draft19; let free = Namespace { - suffix: Path::new("a"), + suffix: Path::new("a").unwrap(), params: clustered(&[7], 0), }; let priced = Namespace { - suffix: Path::new("a"), + suffix: Path::new("a").unwrap(), params: clustered(&[7], 1), }; assert!(body(&free, version).len() < body(&priced, version).len()); @@ -476,7 +476,7 @@ mod tests { let epoch = crate::Epoch::mint(); for epoch in [None, Some(epoch)] { let msg = Namespace { - suffix: Path::new("a"), + suffix: Path::new("a").unwrap(), params: Some(AdvertParams { cluster: None, epoch: epoch.clone(), @@ -495,7 +495,7 @@ mod tests { let mut params = clustered(&[7], 3).unwrap(); params.epoch = Some(crate::Epoch::mint()); let msg = Namespace { - suffix: Path::new("a"), + suffix: Path::new("a").unwrap(), params: Some(params), }; let encoded = body(&msg, version); @@ -505,7 +505,7 @@ mod tests { // Read as the base form, a single block is all that is left over. let mut suffix = Vec::new(); - encode_namespace(&mut Encoder::new(&mut suffix, version.into()), &Path::new("a")).unwrap(); + encode_namespace(&mut Encoder::new(&mut suffix, version.into()), &Path::new("a").unwrap()).unwrap(); let mut block = Vec::new(); super::super::publish_namespace::encode_advert_params( &mut Encoder::new(&mut block, version.into()), @@ -522,7 +522,7 @@ mod tests { fn epoch_refused_unless_negotiated_and_well_formed() { let version = Version::Draft22; let msg = Namespace { - suffix: Path::new("a"), + suffix: Path::new("a").unwrap(), params: Some(AdvertParams { cluster: clustered(&[7], 0).unwrap().cluster, epoch: Some(crate::Epoch::mint()), @@ -534,7 +534,7 @@ mod tests { )); let mut buf = Vec::new(); - encode_namespace(&mut Encoder::new(&mut buf, version.into()), &Path::new("a")).unwrap(); + encode_namespace(&mut Encoder::new(&mut buf, version.into()), &Path::new("a").unwrap()).unwrap(); let w = &mut Encoder::new(&mut buf, version.into()); w.varint(1).unwrap(); w.varint(super::super::epoch::EPOCH_PARAM).unwrap(); @@ -547,7 +547,7 @@ mod tests { fn cluster_namespace_requires_hop_path() { let version = Version::Draft19; let mut buf = Vec::new(); - encode_namespace(&mut Encoder::new(&mut buf, version.into()), &Path::new("a")).unwrap(); + encode_namespace(&mut Encoder::new(&mut buf, version.into()), &Path::new("a").unwrap()).unwrap(); // Number of Parameters = 0. Encoder::new(&mut buf, version.into()).varint(0).unwrap(); @@ -565,7 +565,7 @@ mod tests { let version = Version::Draft19; let msg = super::super::PublishNamespace { request_id: RequestId(1), - track_namespace: Path::new("a"), + track_namespace: Path::new("a").unwrap(), params: AdvertParams { cluster: Some(cluster::Advert { hops: hop_path(&[7]), @@ -666,7 +666,7 @@ mod tests { fn modern_round_trips() { let msg = SubscribeNamespace { request_id: RequestId(4), - namespace: Path::new("example/meeting"), + namespace: Path::new("example/meeting").unwrap(), hidden: false, }; let mut buf = bytes::Bytes::from(body(&msg, Version::Draft18)); @@ -682,7 +682,7 @@ mod tests { for hidden in [false, true] { let msg = SubscribeNamespace { request_id: RequestId(4), - namespace: Path::new("example"), + namespace: Path::new("example").unwrap(), hidden, }; let mut buf = bytes::Bytes::from(body(&msg, Version::Draft18)); @@ -696,7 +696,7 @@ mod tests { for version in [Version::Draft14, Version::Draft16, Version::Draft17] { let msg = SubscribeNamespaceLegacy { request_id: RequestId(4), - namespace: Path::new("example"), + namespace: Path::new("example").unwrap(), subscribe_options: SubscribeOptions::Namespace, hidden, }; @@ -718,7 +718,7 @@ mod tests { ] { let msg = SubscribeNamespaceLegacy { request_id: RequestId(4), - namespace: Path::new("example/meeting"), + namespace: Path::new("example/meeting").unwrap(), subscribe_options: options, hidden: false, }; diff --git a/rs/moq-net/src/ietf/subscribe_tracks.rs b/rs/moq-net/src/ietf/subscribe_tracks.rs index 5dba72a7103..d3b8cf85d9a 100644 --- a/rs/moq-net/src/ietf/subscribe_tracks.rs +++ b/rs/moq-net/src/ietf/subscribe_tracks.rs @@ -200,7 +200,7 @@ mod tests { fn paused() -> SubscribeTracks<'static> { SubscribeTracks { request_id: RequestId(4), - prefix: Path::new("room"), + prefix: Path::new("room").unwrap(), forward: false, subscriber_priority: None, group_order: None, @@ -318,7 +318,7 @@ mod tests { fn publish_skipped_round_trips() { for version in [Version::Draft17, Version::Draft18, Version::Draft22] { let msg = PublishSkipped { - suffix: Path::new("cam"), + suffix: Path::new("cam").unwrap(), track_name: "video".into(), }; let decoded: PublishSkipped = decode(&encode(&msg, version), version).unwrap(); diff --git a/rs/moq-net/src/ietf/subscriber.rs b/rs/moq-net/src/ietf/subscriber.rs index e58bd3dc828..40095514b98 100644 --- a/rs/moq-net/src/ietf/subscriber.rs +++ b/rs/moq-net/src/ietf/subscriber.rs @@ -6208,7 +6208,7 @@ mod tests { pending: Some(request), ..TrackState::pending( "video".to_string(), - crate::Path::new("bcast").to_owned(), + crate::Path::new("bcast").unwrap().to_owned(), kio::Producer::new(Fill::Done), ) }, @@ -6334,7 +6334,7 @@ mod tests { async fn a_rooted_subscriber_asks_for_its_scope_not_its_root() { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let scope = crate::Patterns::from(crate::Pattern::subtree("cam").unwrap()); - let scoped = origin.scope("rootns", &scope).expect("scope the origin"); + let scoped = origin.scope(Path::new("rootns").unwrap(), &scope).expect("scope the origin"); let gate = kio::Producer::new(true); let session = crate::lite::test_transport::SinkSession::gated_bi(gate.consume()); @@ -6361,7 +6361,7 @@ mod tests { let mut namespaces = crate::model::interest_prefixes(&subscriber.origin.allowed()); assert_eq!( namespaces, - vec![crate::Path::new("cam").to_owned()], + vec![crate::Path::new("cam").unwrap().to_owned()], "one SUBSCRIBE_NAMESPACE per permitted prefix, relative to the root", ); let prefix = namespaces.pop().unwrap(); @@ -6401,7 +6401,7 @@ mod tests { writer.varint(ietf::Namespace::ID).await.unwrap(); writer .encode(&ietf::Namespace { - suffix: crate::Path::new(suffix), + suffix: crate::Path::new(suffix).unwrap(), params: None, }) .await @@ -6424,7 +6424,7 @@ mod tests { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let consumer = origin.consume(); let scope = crate::Patterns::from(crate::Pattern::subtree("cam").unwrap()); - let scoped = origin.scope("rootns", &scope).expect("scope the origin"); + let scoped = origin.scope(Path::new("rootns").unwrap(), &scope).expect("scope the origin"); let session = crate::lite::test_transport::ScriptedSession::new(namespace_response(VERSION, "x.hang").await); let (tasks, _task_set) = crate::util::TaskSet::new(); @@ -6510,7 +6510,7 @@ mod tests { writer.varint(ietf::Namespace::ID).await.unwrap(); writer .encode(&ietf::Namespace { - suffix: crate::Path::new("room"), + suffix: crate::Path::new("room").unwrap(), params: Some(ietf::AdvertParams { cluster: Some(cluster::Advert { hops, cost: 0 }), epoch, @@ -6593,7 +6593,7 @@ mod tests { .await .unwrap(); let namespace = |suffix| ietf::Namespace { - suffix: crate::Path::new(suffix), + suffix: crate::Path::new(suffix).unwrap(), params: Some(ietf::AdvertParams { cluster: Some(cluster::Advert { hops: hop_path(&[7, 5, 9]), @@ -6607,7 +6607,7 @@ mod tests { writer.varint(ietf::NamespaceDone::ID).await.unwrap(); writer .encode(&ietf::NamespaceDone { - suffix: crate::Path::new("a"), + suffix: crate::Path::new("a").unwrap(), }) .await .unwrap(); @@ -6719,7 +6719,7 @@ mod tests { let res = subscriber .run_subscribe_namespace( stream, - crate::Path::new("").to_owned(), + crate::Path::new("").unwrap().to_owned(), crate::model::Snapshot::landed(), live, ) @@ -6754,7 +6754,7 @@ mod tests { writer.varint(ietf::NamespaceDone::ID).await.unwrap(); writer .encode(&ietf::NamespaceDone { - suffix: crate::Path::new(suffix), + suffix: crate::Path::new(suffix).unwrap(), }) .await .unwrap(); @@ -6763,7 +6763,7 @@ mod tests { writer.varint(ietf::Namespace::ID).await.unwrap(); writer .encode(&ietf::Namespace { - suffix: crate::Path::new(entry), + suffix: crate::Path::new(entry).unwrap(), params: None, }) .await @@ -6784,7 +6784,7 @@ mod tests { ) -> (Subscriber, crate::origin::Consumer, crate::model::Snapshot) { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let consumer = origin.consume(); - let snapshot = origin.snapshot(""); + let snapshot = origin.snapshot(Path::new("").unwrap()); let (tasks, _task_set) = crate::util::TaskSet::new(); let peer_setup = peer::PeerSetup::default(); peer_setup.set(peer::Peer { @@ -6822,7 +6822,7 @@ mod tests { .unwrap(); let mut run = std::pin::pin!(subscriber.run_subscribe_namespace( stream, - crate::Path::new("").to_owned(), + crate::Path::new("").unwrap().to_owned(), snapshot, live )); @@ -6831,7 +6831,7 @@ mod tests { settle().await; } for entry in entries { - cursor.assert_next_active(*entry); + cursor.assert_next_active(Path::new(*entry).unwrap()); } assert_eq!(cursor.is_synced(), synced, "{entries:?}"); } @@ -6850,7 +6850,7 @@ mod tests { .await .unwrap(); let mut run = - std::pin::pin!(subscriber.run_subscribe_namespace(stream, crate::Path::new("").to_owned(), snapshot, live)); + std::pin::pin!(subscriber.run_subscribe_namespace(stream, crate::Path::new("").unwrap().to_owned(), snapshot, live)); for _ in 0..10 { assert!(futures::poll!(run.as_mut()).is_pending()); settle().await; @@ -6874,7 +6874,7 @@ mod tests { .await .unwrap(); let res = subscriber - .run_subscribe_namespace(stream, crate::Path::new("").to_owned(), snapshot, live) + .run_subscribe_namespace(stream, crate::Path::new("").unwrap().to_owned(), snapshot, live) .await; assert!(matches!(res, Err(Error::ProtocolViolation)), "{entries:?}: {res:?}"); } @@ -6996,7 +6996,7 @@ mod tests { *name, crate::track::Info::timed(), ), - Path::new(broadcast).to_owned(), + Path::new(broadcast).unwrap().to_owned(), kio::Producer::new(Fill::Done), ), ); @@ -7276,7 +7276,7 @@ mod tests { let serving = moq_clock::sim::spawn(async move { subscriber - .run_subscribe(Path::new("broadcast"), dynamic, None, request) + .run_subscribe(Path::new("broadcast").unwrap(), dynamic, None, request) .await; }); @@ -7342,7 +7342,7 @@ mod tests { let mut serving = moq_clock::sim::spawn(async move { subscriber - .run_subscribe(Path::new("broadcast"), dynamic, None, request) + .run_subscribe(Path::new("broadcast").unwrap(), dynamic, None, request) .await; }); assert!( @@ -7383,7 +7383,7 @@ mod tests { let live = route.consume(); let mut serving = moq_clock::sim::spawn(async move { subscriber - .run_subscribe(Path::new("broadcast"), dynamic, Some(live), request) + .run_subscribe(Path::new("broadcast").unwrap(), dynamic, Some(live), request) .await; }); assert!( @@ -7442,7 +7442,7 @@ mod tests { let serving = moq_clock::sim::spawn(async move { subscriber - .run_subscribe(Path::new("broadcast"), dynamic, None, request) + .run_subscribe(Path::new("broadcast").unwrap(), dynamic, None, request) .await; }); @@ -7513,7 +7513,7 @@ mod tests { let serving = moq_clock::sim::spawn(async move { subscriber - .run_subscribe(Path::new("broadcast"), dynamic, None, request) + .run_subscribe(Path::new("broadcast").unwrap(), dynamic, None, request) .await; }); settle().await; @@ -7579,7 +7579,7 @@ mod tests { let serving = moq_clock::sim::spawn(async move { subscriber - .run_subscribe(Path::new("broadcast"), dynamic, None, request) + .run_subscribe(Path::new("broadcast").unwrap(), dynamic, None, request) .await; }); // Let the SUBSCRIBE go out. No SUBSCRIBE_OK is coming. @@ -7646,7 +7646,7 @@ mod tests { let serving = moq_clock::sim::spawn(async move { subscriber - .run_subscribe(Path::new("broadcast"), dynamic, None, request) + .run_subscribe(Path::new("broadcast").unwrap(), dynamic, None, request) .await; }); @@ -7714,7 +7714,7 @@ mod tests { subscriber.validity = crate::model::broadcast::RequestValidity::token(Some(route.consume())); let mut gate = crate::auth::Gate::new( auth.clone(), - Path::new("broadcast").to_owned(), + Path::new("broadcast").unwrap().to_owned(), crate::auth::Direction::Subscribe, ); let waiter = kio::Waiter::noop(); @@ -7734,7 +7734,7 @@ mod tests { assert!( subscriber .subscribe_once( - &Path::new("broadcast"), + &Path::new("broadcast").unwrap(), "video", Target::Request(request), &mut TaskSet::owned(), @@ -7747,7 +7747,7 @@ mod tests { SetupWait::StatusOpen | SetupWait::StatusCredit | SetupWait::StatusResponse => Box::pin(async { assert!( subscriber - .track_status(&Path::new("broadcast"), "video", request, &mut gate) + .track_status(&Path::new("broadcast").unwrap(), "video", request, &mut gate) .await .is_none() ); @@ -7761,7 +7761,7 @@ mod tests { group = Some(pending); accepted = Some(track); Box::pin(subscriber.clone().run_group_fetch( - Path::new("broadcast").to_owned(), + Path::new("broadcast").unwrap().to_owned(), "video".into(), request, None, @@ -7925,18 +7925,18 @@ mod tests { let serving = match kind { Allocated::Subscribe => moq_clock::sim::spawn(async move { subscriber - .run_subscribe(Path::new("broadcast"), dynamic, None, request) + .run_subscribe(Path::new("broadcast").unwrap(), dynamic, None, request) .await; }), Allocated::TrackStatus => moq_clock::sim::spawn(async move { let mut gate = crate::auth::Gate::new( subscriber.auth.clone(), - Path::new("broadcast").to_owned(), + Path::new("broadcast").unwrap().to_owned(), crate::auth::Direction::Subscribe, ); assert!( subscriber - .track_status(&Path::new("broadcast"), "video", request, &mut gate) + .track_status(&Path::new("broadcast").unwrap(), "video", request, &mut gate) .await .is_none() ); @@ -7953,7 +7953,7 @@ mod tests { let group = requested.requested_fill_group().await.expect("group request"); fetch = Some((track, pending)); moq_clock::sim::spawn(subscriber.run_group_fetch( - Path::new("broadcast").to_owned(), + Path::new("broadcast").unwrap().to_owned(), "video".into(), group, None, @@ -8064,7 +8064,7 @@ mod tests { let serving = moq_clock::sim::spawn(async move { subscriber - .run_subscribe(Path::new("broadcast"), dynamic, None, request) + .run_subscribe(Path::new("broadcast").unwrap(), dynamic, None, request) .await; }); @@ -8136,7 +8136,7 @@ mod tests { let request = dynamic.requested_track().await.expect("no track requested"); let _serving = moq_clock::sim::spawn(async move { subscriber - .run_subscribe(Path::new("broadcast"), dynamic, None, request) + .run_subscribe(Path::new("broadcast").unwrap(), dynamic, None, request) .await; }); settle().await; @@ -8215,7 +8215,7 @@ mod tests { let request = dynamic.requested_track().await.expect("no track requested"); let _serving = moq_clock::sim::spawn(async move { subscriber - .run_subscribe(Path::new("broadcast"), dynamic, None, request) + .run_subscribe(Path::new("broadcast").unwrap(), dynamic, None, request) .await; }); settle().await; @@ -8336,7 +8336,7 @@ mod tests { "video", crate::track::Info::timed(), ), - Path::new("broadcast").to_owned(), + Path::new("broadcast").unwrap().to_owned(), kio::Producer::new(Fill::Done), ) }, @@ -8359,7 +8359,7 @@ mod tests { let serving = moq_clock::sim::spawn(async move { subscriber - .run_subscribe(Path::new("broadcast"), dynamic, None, request) + .run_subscribe(Path::new("broadcast").unwrap(), dynamic, None, request) .await; }); @@ -8442,7 +8442,7 @@ mod tests { let probe = subscriber.clone(); let serving = moq_clock::sim::spawn(async move { subscriber - .run_subscribe(Path::new("broadcast"), dynamic, None, request) + .run_subscribe(Path::new("broadcast").unwrap(), dynamic, None, request) .await; }); @@ -8564,7 +8564,7 @@ mod tests { Default::default(), ); subscriber - .run_subscribe(Path::new("broadcast"), dynamic, None, request) + .run_subscribe(Path::new("broadcast").unwrap(), dynamic, None, request) .await; }); // Run the request classification before the front can add demand after @@ -8577,8 +8577,8 @@ mod tests { for version in [Version::Draft18, Version::Draft19, Version::Draft22] { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let source = origin.publish("broadcast", Default::default()).unwrap(); - let resolved = origin.consume().request_broadcast("broadcast", None).await.unwrap(); + let source = origin.publish(Path::new("broadcast").unwrap(), Default::default()).unwrap(); + let resolved = origin.consume().request_broadcast(Path::new("broadcast").unwrap(), None).await.unwrap(); let peer = Arc::new(Peer { version, dynamic: Mutex::new(Some(source.dynamic())), @@ -8665,7 +8665,7 @@ mod tests { assert!(futures::poll!(pending.as_mut()).is_pending()); let request = dynamic.requested_track().await.expect("no track requested"); let mut serving = - Box::pin(subscriber.run_subscribe(Path::new("broadcast"), dynamic, None, request)); + Box::pin(subscriber.run_subscribe(Path::new("broadcast").unwrap(), dynamic, None, request)); assert!( futures::poll!(serving.as_mut()).is_ready(), "{version}: refusal was not terminal" @@ -8749,7 +8749,7 @@ mod tests { let probe = subscriber.clone(); let serving = moq_clock::sim::spawn(async move { subscriber - .run_subscribe(Path::new("broadcast"), dynamic, None, request) + .run_subscribe(Path::new("broadcast").unwrap(), dynamic, None, request) .await; }); settle().await; @@ -8857,8 +8857,8 @@ mod tests { subscriber.announces = crate::session::Slots::new(1); let advert = |subscriber: &Subscriber| subscriber.route(None, &cluster::Peer::default()).expect("route"); - let a = crate::Path::new("a").to_owned(); - let b = crate::Path::new("b").to_owned(); + let a = crate::Path::new("a").unwrap().to_owned(); + let b = crate::Path::new("b").unwrap().to_owned(); let (first, repeat, over, last) = ( advert(&subscriber), advert(&subscriber), @@ -8915,11 +8915,11 @@ mod tests { let advert = subscriber.route(None, &cluster::Peer::default()).expect("route"); subscriber - .start_announce(crate::Path::new("room/host").to_owned(), advert, Admit::Session(None)) + .start_announce(crate::Path::new("room/host").unwrap().to_owned(), advert, Admit::Session(None)) .unwrap(); let mut announced = consumer.announced(); - let route = announced.expect_next_active("room/host").await; + let route = announced.expect_next_active(Path::new("room/host").unwrap()).await; let hops: Vec<_> = route.hops.iter().copied().collect(); assert_eq!(hops, vec![crate::Hop::UNKNOWN]); assert!(route.is_anonymous()); @@ -8952,10 +8952,10 @@ mod tests { // What we are publishing to the peer: a real upstream route. let upstream = crate::Hops::try_from(vec![crate::Hop::new(7).unwrap()]).unwrap(); let _source = origin - .announce("room/host", crate::origin::Route::default().with_hops(upstream.clone())) + .announce(Path::new("room/host").unwrap(), crate::origin::Route::default().with_hops(upstream.clone())) .unwrap(); - announced.expect_next_active("room/host").await; - let _advertised = publishing.expect_next_active("room/host").await; + announced.expect_next_active(Path::new("room/host").unwrap()).await; + let _advertised = publishing.expect_next_active(Path::new("room/host").unwrap()).await; // The peer reflects it back over the subscribe direction, which carries no // hop chain of its own. @@ -8975,7 +8975,7 @@ mod tests { ); let advert = subscriber.route(None, &cluster::Peer::default()).expect("route"); subscriber - .start_announce(crate::Path::new("room/host").to_owned(), advert, Admit::Session(None)) + .start_announce(crate::Path::new("room/host").unwrap().to_owned(), advert, Admit::Session(None)) .unwrap(); // No announce churn: the upstream route stays the best one, on both cursors. @@ -9015,20 +9015,20 @@ mod tests { ); let advert = subscriber.route(None, &cluster::Peer::default()).expect("route"); subscriber - .start_announce(crate::Path::new("room/host").to_owned(), advert, Admit::Session(None)) + .start_announce(crate::Path::new("room/host").unwrap().to_owned(), advert, Admit::Session(None)) .unwrap(); subscriber }; let first = connect(); moq_clock::sim::yield_now().await; - announced.expect_next_active("room/host").await; + announced.expect_next_active(Path::new("room/host").unwrap()).await; // The peer reconnects before the old session is retired: an identical route // from the fresh session wins at once, as another source. let _second = connect(); moq_clock::sim::yield_now().await; - announced.expect_next_restarted("room/host").await; + announced.expect_next_restarted(Path::new("room/host").unwrap()).await; announced.assert_next_wait(); // Neither route is offered back to the peer they both came from. @@ -9068,7 +9068,7 @@ mod tests { /// The current best route covering `path`, if any (synchronous peek). fn routed_now(consumer: &crate::origin::Consumer, path: &str) -> Option { use futures::FutureExt; - consumer.routed(path).now_or_never().flatten() + consumer.routed(Path::new(path).unwrap()).now_or_never().flatten() } fn hop_path(ids: &[u64]) -> cluster::HopPath { @@ -9104,7 +9104,7 @@ mod tests { let mut subscriber = subscriber; subscriber .start_announce( - crate::Path::new("room/host").to_owned(), + crate::Path::new("room/host").unwrap().to_owned(), advertised, Admit::Session(None), ) @@ -9208,7 +9208,7 @@ mod tests { subscriber .run_subscribe_namespace( stream, - crate::Path::new("").to_owned(), + crate::Path::new("").unwrap().to_owned(), crate::model::Snapshot::landed(), live, ) @@ -9251,7 +9251,7 @@ mod tests { writer.varint(ietf::Namespace::ID).await.unwrap(); writer .encode(&ietf::Namespace { - suffix: crate::Path::new("x.hang"), + suffix: crate::Path::new("x.hang").unwrap(), params: Some(ietf::AdvertParams { cluster: Some(cluster::Advert { hops: hop_path(&[7, 9]), @@ -9298,7 +9298,7 @@ mod tests { .unwrap(); let mut run = std::pin::pin!(subscriber.run_subscribe_namespace( stream, - crate::Path::new("").to_owned(), + crate::Path::new("").unwrap().to_owned(), crate::model::Snapshot::landed(), live )); @@ -9324,7 +9324,7 @@ mod tests { let (mut subscriber, origin) = cluster_subscriber(crate::Hop::new(1).unwrap()); let consumer = origin.consume(); - let path = crate::Path::new("room/host").to_owned(); + let path = crate::Path::new("room/host").unwrap().to_owned(); let advert = subscriber.route(None, &cluster::Peer::default()).expect("route"); let id = subscriber .start_announce(path.clone(), advert, Admit::Session(None)) @@ -9368,7 +9368,7 @@ mod tests { .unwrap(); let msg = ietf::PublishNamespace { request_id: RequestId(0), - track_namespace: crate::Path::new("room/host"), + track_namespace: crate::Path::new("room/host").unwrap(), params: Default::default(), authorization_token: None, }; @@ -9397,7 +9397,7 @@ mod tests { async fn a_publish_namespace_done_retracts_without_faulting_the_session() { const VERSION: Version = Version::Draft14; - let path = crate::Path::new("room/host").to_owned(); + let path = crate::Path::new("room/host").unwrap().to_owned(); let log = crate::lite::test_transport::Log::default(); let mut writer = crate::coding::Writer::new( crate::transport::boxed::SendStream::new(crate::lite::test_transport::SinkSend::new(log.clone())), @@ -9458,7 +9458,7 @@ mod tests { #[moq_clock::test] async fn a_legacy_update_on_an_advertisement_is_answered() { for version in [Version::Draft14, Version::Draft15] { - let path = crate::Path::new("room/host").to_owned(); + let path = crate::Path::new("room/host").unwrap().to_owned(); // Own Request ID 10, aimed at the advertisement (0). Draft 14 carries its fixed // start, end group, priority and forward before the parameters. let body: &[u8] = match version { @@ -9571,7 +9571,7 @@ mod tests { Default::default(), ); - let path = crate::Path::new("room/host").to_owned(); + let path = crate::Path::new("room/host").unwrap().to_owned(); let stream = Stream::open(&mut crate::driver::Transport::new(session.clone()), VERSION) .await .unwrap(); @@ -9606,7 +9606,7 @@ mod tests { async fn the_last_owner_out_decides_the_detach() { let (mut subscriber, origin) = cluster_subscriber(crate::Hop::new(1).unwrap()); let consumer = origin.consume(); - let path = crate::Path::new("room/host").to_owned(); + let path = crate::Path::new("room/host").unwrap().to_owned(); let peer = cluster::Peer::default(); let mut ids = Vec::new(); @@ -9644,11 +9644,11 @@ mod tests { async fn a_minted_source_closes_unheld_or_retracted() { let (subscriber, origin) = cluster_subscriber(crate::Hop::new(1).unwrap()); let run = |route: &kio::Producer<()>| { - let source = crate::model::broadcast::SourceGuard::new(origin.create_source("pool/p")); + let source = crate::model::broadcast::SourceGuard::new(origin.create_source(Path::new("pool/p").unwrap())); let (holder, dynamic) = (source.consume(), source.dynamic()); let (this, route) = (subscriber.clone(), route.consume()); let task = moq_clock::sim::spawn(async move { - this.run_broadcast(crate::Path::new("pool/p"), source, dynamic, Some(route)) + this.run_broadcast(crate::Path::new("pool/p").unwrap(), source, dynamic, Some(route)) .await }); (holder, task) @@ -9703,7 +9703,7 @@ mod tests { async fn cluster_update_replaces_in_place() { let (mut subscriber, origin) = cluster_subscriber(crate::Hop::new(1).unwrap()); let consumer = origin.consume(); - let path = crate::Path::new("room/host").to_owned(); + let path = crate::Path::new("room/host").unwrap().to_owned(); let first = Advertised { route: crate::origin::Route::default() @@ -9744,7 +9744,7 @@ mod tests { async fn anonymous_publisher_survives_a_repricing_update() { let (mut subscriber, origin) = cluster_subscriber(crate::Hop::new(1).unwrap()); let consumer = origin.consume(); - let path = crate::Path::new("room/host").to_owned(); + let path = crate::Path::new("room/host").unwrap().to_owned(); // A free link, so the route cost is exactly what the peer advertised. let peer = cluster::Peer { hop: Some(crate::Hop::new(9).unwrap()), @@ -9794,7 +9794,7 @@ mod tests { async fn a_reordered_replacement_keeps_the_new_instance() { let (mut subscriber, origin) = cluster_subscriber(crate::Hop::new(1).unwrap()); let consumer = origin.consume(); - let path = crate::Path::new("room/host").to_owned(); + let path = crate::Path::new("room/host").unwrap().to_owned(); let peer = cluster::Peer::default(); let (old, new) = (crate::Epoch::mint(), crate::Epoch::mint()); let advert = |subscriber: &Subscriber, epoch: &crate::Epoch| { @@ -9842,7 +9842,7 @@ mod tests { async fn a_repeat_under_another_epoch_becomes_the_newest() { let (mut subscriber, origin) = cluster_subscriber(crate::Hop::new(1).unwrap()); let consumer = origin.consume(); - let path = crate::Path::new("room/host").to_owned(); + let path = crate::Path::new("room/host").unwrap().to_owned(); let peer = cluster::Peer::default(); let (old, new) = (crate::Epoch::mint(), crate::Epoch::mint()); let advert = |subscriber: &Subscriber, epoch: &crate::Epoch| { @@ -9884,7 +9884,7 @@ mod tests { async fn separate_adverts_refcount_the_route() { let (mut subscriber, origin) = cluster_subscriber(crate::Hop::new(1).unwrap()); let consumer = origin.consume(); - let path = crate::Path::new("room/host").to_owned(); + let path = crate::Path::new("room/host").unwrap().to_owned(); let peer = cluster::Peer { hop: Some(crate::Hop::new(9).unwrap()), cost: None, @@ -9922,7 +9922,7 @@ mod tests { async fn pathless_adverts_never_replace_the_source() { let (mut subscriber, origin) = cluster_subscriber(crate::Hop::new(1).unwrap()); let consumer = origin.consume(); - let path = crate::Path::new("room/host").to_owned(); + let path = crate::Path::new("room/host").unwrap().to_owned(); let peer = cluster::Peer::default(); // What a PUBLISH_NAMESPACE with no cluster parameters resolves to. @@ -9954,7 +9954,7 @@ mod tests { let self_origin = crate::Hop::new(5).unwrap(); let (mut subscriber, origin) = cluster_subscriber(self_origin); let consumer = origin.consume(); - let path = crate::Path::new("room/host").to_owned(); + let path = crate::Path::new("room/host").unwrap().to_owned(); let peer = cluster::Peer { hop: Some(crate::Hop::new(9).unwrap()), cost: None, @@ -10054,7 +10054,7 @@ mod tests { Default::default(), ); - let path = crate::Path::new("room/host").to_owned(); + let path = crate::Path::new("room/host").unwrap().to_owned(); let advert = subscriber.route(Some(attached), peer).expect("route"); let id = subscriber.start_announce(path, advert, Admit::Session(None)).unwrap(); assert_eq!(id, 0, "the harness advertisement is the first"); @@ -10141,7 +10141,7 @@ mod tests { let err = subscriber .run_publish_namespace_updates( &mut stream, - &crate::Path::new("room/host"), + &crate::Path::new("room/host").unwrap(), Held { cluster: Some(clean), epoch: None, @@ -10170,7 +10170,7 @@ mod tests { let (mut subscriber, consumer, mut stream, log) = reflected_harness(self_origin, &peer, &clean, &[looped]).await; - let path = crate::Path::new("room/host").to_owned(); + let path = crate::Path::new("room/host").unwrap().to_owned(); let mut attached = Some(0); { let mut run = std::pin::pin!(subscriber.run_publish_namespace_updates( @@ -10220,7 +10220,7 @@ mod tests { let (mut subscriber, consumer, mut stream, _log) = reflected_harness(self_origin, &peer, &clean, &[looped, clean.clone()]).await; - let path = crate::Path::new("room/host").to_owned(); + let path = crate::Path::new("room/host").unwrap().to_owned(); let mut attached = Some(0); { let mut run = std::pin::pin!(subscriber.run_publish_namespace_updates( @@ -10283,7 +10283,7 @@ mod tests { subscriber.announces = crate::session::Slots::new(1); // Admitted by its own token, which holds the one slot for the request's life. - let path = crate::Path::new("room/host").to_owned(); + let path = crate::Path::new("room/host").unwrap().to_owned(); let hold: crate::auth::Hold = std::sync::Arc::new(subscriber.announces.acquire().unwrap()); let auth = crate::auth::Link::new(true); let mut requests = auth.handle().requests(); @@ -10384,7 +10384,7 @@ mod tests { std::mem::forget(driver); assert_eq!(routed_now(&consumer, "room/host").expect("routed").cost.value(), 4); - let path = crate::Path::new("room/host").to_owned(); + let path = crate::Path::new("room/host").unwrap().to_owned(); let mut attached = Some(0); { let mut run = std::pin::pin!(subscriber.run_publish_namespace_updates( @@ -10435,7 +10435,7 @@ mod tests { // repriced, which is the one way an in-place update fails. drop(driver); - let path = crate::Path::new("room/host").to_owned(); + let path = crate::Path::new("room/host").unwrap().to_owned(); let mut attached = Some(0); let mut result = None; { @@ -10490,7 +10490,7 @@ mod tests { update_harness(self_origin, &peer, &clean, script).await; std::mem::forget(driver); - let path = crate::Path::new("room/host").to_owned(); + let path = crate::Path::new("room/host").unwrap().to_owned(); let mut attached = Some(0); { let mut run = std::pin::pin!(subscriber.run_publish_namespace_updates( @@ -10540,7 +10540,7 @@ mod tests { writer .encode(&ietf::PublishNamespace { request_id: RequestId(1), - track_namespace: crate::Path::new("room/host"), + track_namespace: crate::Path::new("room/host").unwrap(), params: ietf::AdvertParams { cluster: Some(cluster::Advert { cost: 0, @@ -10560,7 +10560,7 @@ mod tests { update_harness(self_origin, &peer, &clean, script).await; std::mem::forget(driver); - let path = crate::Path::new("room/host").to_owned(); + let path = crate::Path::new("room/host").unwrap().to_owned(); let mut attached = Some(0); let mut run = std::pin::pin!(subscriber.run_publish_namespace_updates( &mut stream, @@ -10598,7 +10598,7 @@ mod tests { let mut live = std::collections::HashMap::new(); for path in ["room/a", "room/b"] { - let path = crate::Path::new(path).to_owned(); + let path = crate::Path::new(path).unwrap().to_owned(); let advert = subscriber.route(None, &peer).expect("route"); let id = subscriber .start_announce(path.clone(), advert, Admit::Session(None)) @@ -10653,7 +10653,7 @@ mod tests { .unwrap(); let msg = ietf::Publish { request_id: RequestId(1), - track_namespace: crate::Path::new("room/host"), + track_namespace: crate::Path::new("room/host").unwrap(), track_name: "video".into(), track_alias: 7, largest_location: None, @@ -10822,7 +10822,7 @@ mod tests { fn token_publish_namespace() -> ietf::PublishNamespace<'static> { ietf::PublishNamespace { request_id: RequestId(1), - track_namespace: crate::Path::new("room/alice"), + track_namespace: crate::Path::new("room/alice").unwrap(), params: Default::default(), authorization_token: Some(announce_token()), } @@ -11011,7 +11011,7 @@ mod tests { VERSION, ) .encode_message(&ietf::PublishNamespaceDone { - track_namespace: crate::Path::new("room/alice"), + track_namespace: crate::Path::new("room/alice").unwrap(), request_id: RequestId(1), }) .await @@ -11303,7 +11303,7 @@ mod tests { } let issued = issued.expect("the announce never presented its token"); - let mut routing = std::pin::pin!(consumer.routed_broadcast("room/alice")); + let mut routing = std::pin::pin!(consumer.routed_broadcast(Path::new("room/alice").unwrap())); let mut broadcast = None; for _ in 0..500 { assert!(futures::poll!(run.as_mut()).is_pending(), "the announce ended early"); @@ -11608,7 +11608,7 @@ mod tests { ); writer .encode_message(&ietf::PublishNamespaceCancel { - track_namespace: crate::Path::new("room/alice"), + track_namespace: crate::Path::new("room/alice").unwrap(), request_id: RequestId(1), error_code: request::to_code( &Error::Unauthorized, @@ -11642,7 +11642,7 @@ mod tests { .unwrap(); let tokenless = ietf::PublishNamespace { request_id: RequestId(1), - track_namespace: crate::Path::new("other/alice"), + track_namespace: crate::Path::new("other/alice").unwrap(), params: Default::default(), authorization_token: None, }; @@ -13021,7 +13021,7 @@ mod stitch_tests { TrackState { alias: Some(ALIAS), timescale, - ..TrackState::new(track.clone(), Path::new("broadcast").to_owned(), fill.clone()) + ..TrackState::new(track.clone(), Path::new("broadcast").unwrap().to_owned(), fill.clone()) }, ); insert_track_alias(&state.aliases, ALIAS, REQUEST).unwrap(); @@ -13231,7 +13231,7 @@ mod stitch_tests { ) -> (Vec, crate::lite::test_transport::Log) { use crate::lite::test_transport::Sent; let origin = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); - let broadcast = origin.publish("room", crate::origin::Route::default()).unwrap(); + let broadcast = origin.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); let track = broadcast .create_track( "video", @@ -13274,7 +13274,7 @@ mod stitch_tests { let id = if let Some((start, end)) = fetch { let fetch_type = if Filter::is_draft20(egress) { ietf::FetchType::Filtered { - namespace: Path::new("room"), + namespace: Path::new("room").unwrap(), track: "video".into(), filter: Filter::Absolute { start: ietf::Location { @@ -13289,7 +13289,7 @@ mod stitch_tests { } } else { ietf::FetchType::Standalone { - namespace: Path::new("room"), + namespace: Path::new("room").unwrap(), track: "video".into(), start: ietf::Location { group: SEQUENCE, @@ -13319,7 +13319,7 @@ mod stitch_tests { max_age: None, new_group: None, request_id: RequestId(3), - track_namespace: Path::new("room"), + track_namespace: Path::new("room").unwrap(), track_name: "video".into(), subscriber_priority: 128, group_order: ietf::GroupOrder::Ascending, @@ -14000,7 +14000,7 @@ mod stitch_tests { { { let origin = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); - let broadcast = origin.publish("room", crate::origin::Route::default()).unwrap(); + let broadcast = origin.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); let track = broadcast .create_track("video", accepted_info(&Default::default(), version)) .unwrap(); @@ -14058,7 +14058,7 @@ mod stitch_tests { max_age: None, new_group: None, request_id: RequestId(3), - track_namespace: Path::new("room"), + track_namespace: Path::new("room").unwrap(), track_name: "video".into(), subscriber_priority: 128, group_order: ietf::GroupOrder::Ascending, @@ -14130,7 +14130,7 @@ mod stitch_tests { .flat_map(|egress| [END_OF_GROUP, END_OF_TRACK].map(|status| (egress, status))); for (egress, status) in pairs { let origin = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); - let broadcast = origin.publish("room", crate::origin::Route::default()).unwrap(); + let broadcast = origin.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); let track = broadcast .create_track("video", accepted_info(&Default::default(), ingress)) .unwrap(); @@ -14170,7 +14170,7 @@ mod stitch_tests { max_age: None, new_group: None, request_id: RequestId(3), - track_namespace: Path::new("room"), + track_namespace: Path::new("room").unwrap(), track_name: "video".into(), subscriber_priority: 128, group_order: ietf::GroupOrder::Ascending, @@ -15803,7 +15803,7 @@ mod joining_fetch_tests { let mut serving_subscriber = subscriber.clone(); let serving = moq_clock::sim::spawn(async move { serving_subscriber - .run_subscribe(Path::new("broadcast"), dynamic, None, request) + .run_subscribe(Path::new("broadcast").unwrap(), dynamic, None, request) .await; }); @@ -15891,7 +15891,7 @@ mod joining_fetch_tests { RequestId(99), TrackState::new( track.clone(), - Path::new("broadcast").to_owned(), + Path::new("broadcast").unwrap().to_owned(), kio::Producer::new(Fill::Requested), ), ); @@ -15928,7 +15928,7 @@ mod joining_fetch_tests { let track = consumer.track("video").unwrap(); let mut subscribing = Box::pin(track.subscribe(None)); let request = dynamic.requested_track().await.unwrap(); - let mut serving = Box::pin(subscriber.run_subscribe(Path::new("broadcast"), dynamic, None, request)); + let mut serving = Box::pin(subscriber.run_subscribe(Path::new("broadcast").unwrap(), dynamic, None, request)); assert!(futures::poll!(serving.as_mut()).is_pending()); let received = (&mut subscribing).now_or_never().expect("SUBSCRIBE_OK").unwrap(); let mut fetch = Box::pin(track.fetch_group(4, None)); @@ -16399,7 +16399,7 @@ mod joining_fetch_tests { let request = dynamic.requested_fill_group().await.expect("group request"); let outcome = request.joined(); let mut run = Box::pin(subscriber.clone().run_group_fetch( - Path::new("broadcast").to_owned(), + Path::new("broadcast").unwrap().to_owned(), "video".into(), request, None, @@ -16643,7 +16643,7 @@ mod joining_fetch_tests { subscriber .clone() - .run_group_fetch(Path::new("broadcast").to_owned(), "video".into(), request, None) + .run_group_fetch(Path::new("broadcast").unwrap().to_owned(), "video".into(), request, None) .await; assert!(fetch.await.is_err(), "the accepted group was aborted"); @@ -16715,7 +16715,7 @@ mod joining_fetch_tests { subscriber .clone() - .run_group_fetch(Path::new("broadcast").to_owned(), "video".into(), request, None) + .run_group_fetch(Path::new("broadcast").unwrap().to_owned(), "video".into(), request, None) .await; assert_eq!( @@ -16860,7 +16860,7 @@ mod joining_fetch_tests { let request = dynamic.requested_fill_group().await.expect("no group requested"); let serving = moq_clock::sim::spawn(subscriber.clone().run_group_fetch( - Path::new("broadcast").to_owned(), + Path::new("broadcast").unwrap().to_owned(), "video".into(), request, None, @@ -16975,7 +16975,7 @@ mod new_group_tests { let probe = subscriber.clone(); let serving = moq_clock::sim::spawn(async move { subscriber - .run_subscribe(Path::new("broadcast"), dynamic, None, request) + .run_subscribe(Path::new("broadcast").unwrap(), dynamic, None, request) .await; }); let relay = Relay { @@ -17278,7 +17278,7 @@ mod track_property_tests { let probe = subscriber.clone(); let serving = moq_clock::sim::spawn(async move { subscriber - .run_subscribe(Path::new("broadcast"), dynamic, None, request) + .run_subscribe(Path::new("broadcast").unwrap(), dynamic, None, request) .await; }); diff --git a/rs/moq-net/src/ietf/subscriber/tracks.rs b/rs/moq-net/src/ietf/subscriber/tracks.rs index 53881fc05a4..a141232b5d4 100644 --- a/rs/moq-net/src/ietf/subscriber/tracks.rs +++ b/rs/moq-net/src/ietf/subscriber/tracks.rs @@ -1281,7 +1281,7 @@ mod tests { let broadcast = crate::broadcast::Info::default().produce(); let lister = Arc::new(broadcast.dynamic().lister().unwrap()); let tracks = broadcast.consume().tracks().unwrap(); - let listening = subscriber.listen(PathOwned::from("bcast"), lister); + let listening = subscriber.listen(Path::new("bcast").unwrap(), lister); Harness { subscriber, peer, @@ -1372,7 +1372,7 @@ mod tests { let mut subscriber = self.subscriber.clone(); let serving = moq_clock::sim::spawn(async move { subscriber - .run_subscribe(Path::new("bcast"), dynamic, None, request) + .run_subscribe(Path::new("bcast").unwrap(), dynamic, None, request) .await; }); (track, reader, serving) @@ -1449,7 +1449,7 @@ mod tests { fn offered<'a>(namespace: &'a str, name: &'a str, request_id: u64) -> ietf::Publish<'a> { ietf::Publish { request_id: RequestId(request_id), - track_namespace: Path::new(namespace), + track_namespace: Path::new(namespace).unwrap(), track_name: name.into(), track_alias: request_id, largest_location: None, @@ -1564,7 +1564,7 @@ mod tests { let mut h = harness(version); let mut listing = h.establish().await; let skipped = ietf::PublishSkipped { - suffix: Path::new(""), + suffix: Path::new("").unwrap(), track_name: "audio".into(), }; write(&mut listing, ietf::PublishSkipped::ID, &skipped).await; @@ -1609,7 +1609,7 @@ mod tests { let mut h = harness(version); let mut listing = h.establish().await; let skipped = ietf::PublishSkipped { - suffix: Path::new(""), + suffix: Path::new("").unwrap(), track_name: "audio".into(), }; write(&mut listing, ietf::PublishSkipped::ID, &skipped).await; diff --git a/rs/moq-net/src/ietf/track.rs b/rs/moq-net/src/ietf/track.rs index abc97b75ce6..dd3738b6b59 100644 --- a/rs/moq-net/src/ietf/track.rs +++ b/rs/moq-net/src/ietf/track.rs @@ -265,7 +265,7 @@ mod tests { fn test_track_status_v14_round_trip() { let msg = TrackStatus { request_id: RequestId(1), - track_namespace: Path::new("test/ns"), + track_namespace: Path::new("test/ns").unwrap(), track_name: "video".into(), properties_wanted: true, epoch: None, @@ -283,7 +283,7 @@ mod tests { fn test_track_status_v15_round_trip() { let msg = TrackStatus { request_id: RequestId(1), - track_namespace: Path::new("test/ns"), + track_namespace: Path::new("test/ns").unwrap(), track_name: "video".into(), properties_wanted: true, epoch: None, @@ -301,7 +301,7 @@ mod tests { fn test_track_status_v17_round_trip() { let msg = TrackStatus { request_id: RequestId(1), - track_namespace: Path::new("test/ns"), + track_namespace: Path::new("test/ns").unwrap(), track_name: "video".into(), properties_wanted: true, epoch: None, @@ -319,7 +319,7 @@ mod tests { fn test_track_status_v16_round_trip() { let msg = TrackStatus { request_id: RequestId(1), - track_namespace: Path::new("test/ns"), + track_namespace: Path::new("test/ns").unwrap(), track_name: "video".into(), properties_wanted: true, epoch: None, @@ -337,7 +337,7 @@ mod tests { fn test_track_status_v18_round_trip() { let msg = TrackStatus { request_id: RequestId(1), - track_namespace: Path::new("test/ns"), + track_namespace: Path::new("test/ns").unwrap(), track_name: "video".into(), properties_wanted: true, epoch: None, @@ -371,7 +371,7 @@ mod tests { for wanted in [true, false] { let msg = TrackStatus { request_id: RequestId(1), - track_namespace: Path::new("ns"), + track_namespace: Path::new("ns").unwrap(), track_name: "video".into(), properties_wanted: wanted, epoch: None, diff --git a/rs/moq-net/src/ietf/version.rs b/rs/moq-net/src/ietf/version.rs index faf024169dd..ab14acb5a93 100644 --- a/rs/moq-net/src/ietf/version.rs +++ b/rs/moq-net/src/ietf/version.rs @@ -93,7 +93,7 @@ mod tests { max_age: None, new_group: None, request_id: RequestId(1), - track_namespace: Path::new("broadcast"), + track_namespace: Path::new("broadcast").unwrap(), track_name: "video".into(), subscriber_priority: 128, group_order: GroupOrder::Descending, @@ -120,7 +120,7 @@ mod tests { let publish = Publish { request_id: RequestId(2), - track_namespace: Path::new("broadcast"), + track_namespace: Path::new("broadcast").unwrap(), track_name: "audio".into(), track_alias: 7, largest_location: Some(Location { group: 9, object: 0 }), @@ -136,7 +136,7 @@ mod tests { subscriber_priority: 64, group_order: GroupOrder::Ascending, fetch_type: FetchType::Filtered { - namespace: Path::new("broadcast"), + namespace: Path::new("broadcast").unwrap(), track: "video".into(), filter: Filter::Absolute { start: Location { group: 1, object: 0 }, @@ -176,7 +176,7 @@ mod tests { max_age: None, new_group: None, request_id: RequestId(1), - track_namespace: Path::new("broadcast"), + track_namespace: Path::new("broadcast").unwrap(), track_name: "video".into(), subscriber_priority: 128, group_order: GroupOrder::Descending, diff --git a/rs/moq-net/src/lite/announce.rs b/rs/moq-net/src/lite/announce.rs index 834ed8423ac..7d687f69b3c 100644 --- a/rs/moq-net/src/lite/announce.rs +++ b/rs/moq-net/src/lite/announce.rs @@ -634,7 +634,7 @@ mod tests { let version = Version::Lite02; let mut wire = Vec::new(); AnnounceInit { - suffixes: vec![Path::new("a"), Path::new(""), Path::new("b")], + suffixes: vec![Path::new("a").unwrap(), Path::new("").unwrap(), Path::new("b").unwrap()], } .encode(&mut Encoder::new(&mut wire, version.into()), version) .unwrap(); @@ -691,7 +691,7 @@ mod tests { let mut buf = Vec::new(); AnnounceBroadcast::Active { epoch: None, - suffix: PathRef::literal(Path::new("foo/bar")), + suffix: PathRef::literal(Path::new("foo/bar").unwrap()), hops: HopsRef::default(), cost: Cost::default(), } @@ -782,14 +782,14 @@ mod tests { hops.push(Hop::new(7).unwrap()).unwrap(); let msg = AnnounceBroadcast::Active { epoch: None, - suffix: PathRef::literal(Path::new("room/cam")), + suffix: PathRef::literal(Path::new("room/cam").unwrap()), hops: HopsRef::literal(hops.clone()), cost: Cost::UNKNOWN, }; assert_eq!(broadcast_round_trip(&msg, Version::Lite05), msg); let ended = AnnounceBroadcast::Ended { - suffix: Path::new("room/cam"), + suffix: Path::new("room/cam").unwrap(), hops: Hops::new(), }; assert_eq!(broadcast_round_trip(&ended, Version::Lite05), ended); @@ -805,7 +805,7 @@ mod tests { let active = AnnounceBroadcast::Active { epoch: None, - suffix: PathRef::literal(Path::new("room/cam")), + suffix: PathRef::literal(Path::new("room/cam").unwrap()), hops: HopsRef::literal(hops.clone()), cost, }; @@ -834,7 +834,7 @@ mod tests { suffix: PathRef { base: 2, keep: 3, - rest: Path::new("cam"), + rest: Path::new("cam").unwrap(), }, hops: HopsRef { base: 1, @@ -926,7 +926,7 @@ mod tests { suffix: PathRef { base: 1, keep: 1, - rest: Path::new("cam"), + rest: Path::new("cam").unwrap(), }, hops: HopsRef::default(), cost: Cost::default(), @@ -960,7 +960,7 @@ mod tests { )); assert!(matches!( AnnounceBroadcast::Ended { - suffix: Path::new("room/cam"), + suffix: Path::new("room/cam").unwrap(), hops: Hops::new() } .encode(&mut Encoder::new(&mut buf, Version::Lite06.into()), Version::Lite06), @@ -976,7 +976,7 @@ mod tests { fn route_cost_is_dropped_before_lite06() { let msg = AnnounceBroadcast::Active { epoch: None, - suffix: PathRef::literal(Path::new("room/cam")), + suffix: PathRef::literal(Path::new("room/cam").unwrap()), hops: HopsRef::default(), cost: Cost::new(9), }; @@ -985,7 +985,7 @@ mod tests { got, AnnounceBroadcast::Active { epoch: None, - suffix: PathRef::literal(Path::new("room/cam")), + suffix: PathRef::literal(Path::new("room/cam").unwrap()), hops: HopsRef::default(), cost: Cost::UNKNOWN, } @@ -1008,7 +1008,7 @@ mod tests { #[test] fn unknown_announce_type_is_skipped() { let mut body = Vec::new(); - Path::new("room/cam") + Path::new("room/cam").unwrap() .encode(&mut Encoder::new(&mut body, Version::Lite06.into()), Version::Lite06) .unwrap(); Hops::new() @@ -1061,7 +1061,7 @@ mod tests { fn announce_request_carries_hidden_from_lite07() { for hidden in [false, true] { let msg = AnnounceRequest { - prefix: Path::new("room/"), + prefix: Path::new("room").unwrap(), exclude_hop: Hop::UNKNOWN, hidden, }; @@ -1075,7 +1075,7 @@ mod tests { fn announce_request_rejects_a_bad_hidden_flag() { let mut buf = Vec::new(); let mut body = Vec::new(); - Path::new("room") + Path::new("room").unwrap() .encode(&mut Encoder::new(&mut body, Version::Lite07.into()), Version::Lite07) .unwrap(); body.push(2); @@ -1091,7 +1091,7 @@ mod tests { #[test] fn announce_request_carries_exclude_hop_on_lite05() { let msg = AnnounceRequest { - prefix: Path::new("room/"), + prefix: Path::new("room").unwrap(), exclude_hop: Hop::new(42).unwrap(), hidden: false, }; @@ -1103,7 +1103,7 @@ mod tests { #[test] fn announce_request_drops_exclude_hop_on_lite06() { let msg = AnnounceRequest { - prefix: Path::new("room/"), + prefix: Path::new("room").unwrap(), exclude_hop: Hop::new(42).unwrap(), hidden: false, }; diff --git a/rs/moq-net/src/lite/compress.rs b/rs/moq-net/src/lite/compress.rs index 2b7f7432207..9ce26c158b1 100644 --- a/rs/moq-net/src/lite/compress.rs +++ b/rs/moq-net/src/lite/compress.rs @@ -367,7 +367,7 @@ mod tests { PathRef { base, keep, - rest: Path::new(rest).to_owned(), + rest: Path::new(rest).unwrap().to_owned(), } } @@ -511,7 +511,7 @@ mod tests { /// Encode a message with `encoder`, decode it with `decoder`, and check that the /// resolved values match the input. fn start(encoder: &mut AnnounceEncoder, decoder: &mut AnnounceDecoder, suffix: &str, ids: &[u64]) -> (u64, usize) { - let (id, wire_path, wire_hops) = encoder.start(Path::new(suffix).to_owned(), hops(ids)); + let (id, wire_path, wire_hops) = encoder.start(Path::new(suffix).unwrap().to_owned(), hops(ids)); let size = wire_path.encode_bytes(VERSION).unwrap().len() + wire_hops.encode_bytes(VERSION).unwrap().len(); let (got_path, got_hops) = decoder.start(wire_path, wire_hops).unwrap(); assert_eq!(got_path.as_str(), suffix); @@ -565,7 +565,7 @@ mod tests { // Shares a byte prefix with `a/b/d`, but no second segment. start(&mut encoder, &mut decoder, "a/b-z", &[3]); - let (_, wire_path, wire_hops) = encoder.start(Path::new("a/b/d").to_owned(), hops(&[5, 1u64 << 51])); + let (_, wire_path, wire_hops) = encoder.start(Path::new("a/b/d").unwrap().to_owned(), hops(&[5, 1u64 << 51])); assert_eq!(wire_path, path(2, 2, "d")); assert_eq!(wire_hops, chain(2, &[5], 1)); } @@ -594,7 +594,7 @@ mod tests { let suffix = format!("f{n}"); start(&mut encoder, &mut decoder, &suffix, &[1]); } - let (_, wire_path, wire_hops) = encoder.start(Path::new("again").to_owned(), hops(&[100])); + let (_, wire_path, wire_hops) = encoder.start(Path::new("again").unwrap().to_owned(), hops(&[100])); assert_eq!(wire_hops, HopsRef::literal(hops(&[100]))); let (got_path, got_hops) = decoder.start(wire_path, wire_hops).unwrap(); assert_eq!(got_path.as_str(), "again"); @@ -606,19 +606,19 @@ mod tests { let mut encoder = AnnounceEncoder::new(VERSION); let mut decoder = AnnounceDecoder::default(); start(&mut encoder, &mut decoder, "a", &[1]); - let (_, wire_path, wire_hops) = encoder.start(Path::new("b").to_owned(), hops(&[2])); - assert_eq!(wire_path, PathRef::literal(Path::new("b"))); + let (_, wire_path, wire_hops) = encoder.start(Path::new("b").unwrap().to_owned(), hops(&[2])); + assert_eq!(wire_path, PathRef::literal(Path::new("b").unwrap())); assert_eq!(wire_hops, HopsRef::literal(hops(&[2]))); } #[test] fn lite06_assigns_ids_without_bases() { let mut encoder = AnnounceEncoder::new(Version::Lite06); - let (id, _, _) = encoder.start(Path::new("a/b").to_owned(), hops(&[1])); + let (id, _, _) = encoder.start(Path::new("a/b").unwrap().to_owned(), hops(&[1])); assert_eq!(id, Some(0)); - let (id, wire_path, wire_hops) = encoder.start(Path::new("a/c").to_owned(), hops(&[1])); + let (id, wire_path, wire_hops) = encoder.start(Path::new("a/c").unwrap().to_owned(), hops(&[1])); assert_eq!(id, Some(1)); - assert_eq!(wire_path, PathRef::literal(Path::new("a/c"))); + assert_eq!(wire_path, PathRef::literal(Path::new("a/c").unwrap())); assert_eq!(wire_hops, HopsRef::literal(hops(&[1]))); encoder.end(0); assert_eq!(encoder.update(1, hops(&[1])), HopsRef::literal(hops(&[1]))); @@ -632,11 +632,11 @@ mod tests { fn golden() -> Vec { use crate::fuzz::Announced; vec![ - Announced::Start(Path::new("room/a/cam").to_owned(), hops(&[0x1111, 0x2222])), - Announced::Start(Path::new("room/a/mic").to_owned(), hops(&[0x3333, 0x2222])), + Announced::Start(Path::new("room/a/cam").unwrap().to_owned(), hops(&[0x1111, 0x2222])), + Announced::Start(Path::new("room/a/mic").unwrap().to_owned(), hops(&[0x3333, 0x2222])), Announced::Update(0, hops(&[0x4444, 0x2222])), Announced::End(1), - Announced::Start(Path::new("room/b").to_owned(), hops(&[0x5555, 0x2222])), + Announced::Start(Path::new("room/b").unwrap().to_owned(), hops(&[0x5555, 0x2222])), ] } diff --git a/rs/moq-net/src/lite/fetch.rs b/rs/moq-net/src/lite/fetch.rs index a793517dd8d..67285b70700 100644 --- a/rs/moq-net/src/lite/fetch.rs +++ b/rs/moq-net/src/lite/fetch.rs @@ -112,7 +112,7 @@ mod test { fn fetch_sample() -> Fetch<'static> { Fetch { epoch: None, - broadcast: Path::new("room").to_owned(), + broadcast: Path::new("room").unwrap().to_owned(), track: Cow::Borrowed("video"), priority: 3, max_delay: None, @@ -157,7 +157,7 @@ mod test { fn fetch_roundtrips() { for version in [Version::Lite03, Version::Lite04, Version::Lite05] { let got = fetch_roundtrip(version, &fetch_sample()); - assert_eq!(got.broadcast, Path::new("room")); + assert_eq!(got.broadcast, Path::new("room").unwrap()); assert_eq!(got.track, "video"); assert_eq!(got.priority, 3); assert_eq!(got.group, 7); diff --git a/rs/moq-net/src/lite/ietf.rs b/rs/moq-net/src/lite/ietf.rs index fae719f149a..a4fd7018cff 100644 --- a/rs/moq-net/src/lite/ietf.rs +++ b/rs/moq-net/src/lite/ietf.rs @@ -1057,7 +1057,7 @@ pub(crate) async fn test_hop( ); downstream .consume() - .routed(broadcast) + .routed(crate::Path::new(broadcast).unwrap()) .await .expect("the hop announced the broadcast"); (downstream, [client, server]) @@ -1066,6 +1066,7 @@ pub(crate) async fn test_hop( #[cfg(all(test, feature = "async"))] mod hop_tests { use super::*; + use crate::Path; use crate::{Timestamp, frame, model::ProduceTest, track}; use std::time::Duration; @@ -1135,7 +1136,7 @@ mod hop_tests { } async fn subscribe(origin: &crate::origin::Producer) -> (track::Consumer, track::Subscriber) { - let broadcast = moq_clock::timeout(TIMEOUT, origin.consume().request_broadcast("room", None)) + let broadcast = moq_clock::timeout(TIMEOUT, origin.consume().request_broadcast(Path::new("room").unwrap(), None)) .await .expect("no broadcast") .unwrap(); @@ -1164,7 +1165,7 @@ mod hop_tests { for offer in [[true, true], [true, false], [false, true]] { let negotiated = offer == [true, true]; let upstream = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); - let broadcast = upstream.publish("room", crate::origin::Route::default()).unwrap(); + let broadcast = upstream.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); let mut info = track::Info::timed().with_timescale(Timescale::MILLI); info.max_age = Some(Duration::from_secs(7)); info.priority = 9; @@ -1276,11 +1277,11 @@ mod hop_tests { /// Subscribe across a negotiated hop to a track with `info`. async fn subscribe_across_info(info: track::Info) -> Result<(), crate::Error> { let upstream = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); - let broadcast = upstream.publish("room", crate::origin::Route::default()).unwrap(); + let broadcast = upstream.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); let _track = broadcast.create_track("video", info).unwrap(); let (downstream, _sessions) = test_hop(&upstream, "room", [true, true]).await; - let broadcast = moq_clock::timeout(TIMEOUT, downstream.consume().request_broadcast("room", None)) + let broadcast = moq_clock::timeout(TIMEOUT, downstream.consume().request_broadcast(Path::new("room").unwrap(), None)) .await .expect("no broadcast") .unwrap(); @@ -1385,7 +1386,7 @@ mod hop_tests { #[moq_clock::test] async fn plain_media_crosses_unchanged() { let upstream = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); - let broadcast = upstream.publish("room", crate::origin::Route::default()).unwrap(); + let broadcast = upstream.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); let mut track = broadcast .create_track("video", track::Info::timed().with_timescale(Timescale::MILLI)) .unwrap(); @@ -1428,7 +1429,7 @@ mod hop_tests { for offer in [[true, true], [true, false], [false, true]] { let negotiated = offer == [true, true]; let upstream = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); - let broadcast = upstream.publish("room", crate::origin::Route::default()).unwrap(); + let broadcast = upstream.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); let info = track::Info { properties: draft22(Vec::new()), ..track::Info::timed() @@ -1438,7 +1439,7 @@ mod hop_tests { head.write_frame(ts(100), b"frame".to_vec()).unwrap(); head.finish().unwrap(); let (downstream, sessions) = test_hop(&upstream, "room", offer).await; - let broadcast = downstream.consume().request_broadcast("room", None).await.unwrap(); + let broadcast = downstream.consume().request_broadcast(Path::new("room").unwrap(), None).await.unwrap(); // A listing cannot carry the provenance, so it lists the track untimed even when // negotiated: a relay re-listing it would otherwise advertise it as native lite. let mut tracks = broadcast.tracks().unwrap(); @@ -1499,7 +1500,7 @@ mod hop_tests { #[moq_clock::test] async fn compressed_media_crosses_a_negotiated_hop() { let upstream = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); - let broadcast = upstream.publish("room", crate::origin::Route::default()).unwrap(); + let broadcast = upstream.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); let info = track::Info::timed() .with_timescale(Timescale::MILLI) .with_compress(true); diff --git a/rs/moq-net/src/lite/publisher.rs b/rs/moq-net/src/lite/publisher.rs index 01094d1971e..883d3d4fc33 100644 --- a/rs/moq-net/src/lite/publisher.rs +++ b/rs/moq-net/src/lite/publisher.rs @@ -2543,6 +2543,7 @@ mod test { #[cfg(test)] mod announce_test { use super::*; + use crate::Path; use crate::coding::{Decode, Reader}; use crate::lite::test_transport::*; use crate::model::ProduceTest; @@ -2555,7 +2556,7 @@ mod announce_test { #[test] fn initial_replay_keeps_the_last_event_and_its_order() { let update = |prefix: &'static str, cost| announce::Announce { - prefix: crate::PathOwned::from(prefix), + prefix: crate::Path::new(prefix).unwrap(), captures: None, route: origin::Route::default().with_cost(cost), }; @@ -2575,15 +2576,15 @@ mod announce_test { .collect(); assert_eq!( initial, - vec![("a".into(), origin::Cost::new(3)), ("b".into(), origin::Cost::new(6))] + vec![(Path::new("a").unwrap(), origin::Cost::new(3)), (Path::new("b").unwrap(), origin::Cost::new(6))] ); } #[test] fn synced_survives_a_removed_initial_route_and_live_churn() { let origin = Hop::new(1).unwrap().produce(); - let removed = origin.announce("z/removed", origin::Route::default()).unwrap(); - let _initial = origin.announce("z/retained", origin::Route::default()).unwrap(); + let removed = origin.announce(Path::new("z/removed").unwrap(), origin::Route::default()).unwrap(); + let _initial = origin.announce(Path::new("z/retained").unwrap(), origin::Route::default()).unwrap(); let consumer = origin.consume(); let mut announced = consumer.announced(); let budget = kio::Producer::new(0usize); @@ -2600,13 +2601,13 @@ mod announce_test { ), reader: Reader::new(crate::transport::boxed::RecvStream::new(PendingRecv), Version::Lite07), }; - let mut run = AnnounceRun::new(crate::Path::new("").to_owned(), consumer.hop(), Version::Lite07); + let mut run = AnnounceRun::new(crate::Path::new("").unwrap().to_owned(), consumer.hop(), Version::Lite07); let waiter = kio::Waiter::noop(); assert!(run.poll(&mut stream, &consumer, &mut announced, &waiter).is_pending()); drop(removed); let mut churn = Vec::new(); for limit in 1..=4 { - churn.push(origin.announce(format!("a/{limit}"), origin::Route::default()).unwrap()); + churn.push(origin.announce(Path::try_from(format!("a/{limit}")).unwrap(), origin::Route::default()).unwrap()); *budget.write().ok().unwrap() = limit; assert!(run.poll(&mut stream, &consumer, &mut announced, &waiter).is_pending()); } @@ -2624,8 +2625,8 @@ mod announce_test { #[test] fn a_partial_regrant_cannot_overtake_an_initial_route() { let origin = Hop::new(1).unwrap().produce(); - let _a = origin.announce("a", origin::Route::default()).unwrap(); - let _b = origin.announce("b", origin::Route::default()).unwrap(); + let _a = origin.announce(Path::new("a").unwrap(), origin::Route::default()).unwrap(); + let _b = origin.announce(Path::new("b").unwrap(), origin::Route::default()).unwrap(); let consumer = origin.consume(); let mut announced = consumer.announced(); let budget = kio::Producer::new(1usize); @@ -2642,7 +2643,7 @@ mod announce_test { ), reader: Reader::new(crate::transport::boxed::RecvStream::new(PendingRecv), Version::Lite07), }; - let mut run = AnnounceRun::new(crate::Path::new("").to_owned(), consumer.hop(), Version::Lite07); + let mut run = AnnounceRun::new(crate::Path::new("").unwrap().to_owned(), consumer.hop(), Version::Lite07); let waiter = kio::Waiter::noop(); assert!(run.poll(&mut stream, &consumer, &mut announced, &waiter).is_pending()); let auth = crate::auth::Link::new(false); @@ -2666,8 +2667,8 @@ mod announce_test { #[test] fn synced_cuts_a_regrant_burst_at_the_initial_bound() { let origin = Hop::new(1).unwrap().produce(); - let _a = origin.announce("a", origin::Route::default()).unwrap(); - let _b = origin.announce("b", origin::Route::default()).unwrap(); + let _a = origin.announce(Path::new("a").unwrap(), origin::Route::default()).unwrap(); + let _b = origin.announce(Path::new("b").unwrap(), origin::Route::default()).unwrap(); let consumer = origin.consume(); let mut announced = consumer.announced(); let budget = kio::Producer::new(0usize); @@ -2684,7 +2685,7 @@ mod announce_test { ), reader: Reader::new(crate::transport::boxed::RecvStream::new(PendingRecv), Version::Lite07), }; - let mut run = AnnounceRun::new(crate::Path::new("").to_owned(), consumer.hop(), Version::Lite07); + let mut run = AnnounceRun::new(crate::Path::new("").unwrap().to_owned(), consumer.hop(), Version::Lite07); let waiter = kio::Waiter::noop(); assert!(run.poll(&mut stream, &consumer, &mut announced, &waiter).is_pending()); let auth = crate::auth::Link::new(false); @@ -2693,7 +2694,7 @@ mod announce_test { panic!("the changed grant is ready"); }; run.regrant(&mut stream, &consumer, restricted).unwrap(); - let _live = origin.announce("c", origin::Route::default()).unwrap(); + let _live = origin.announce(Path::new("c").unwrap(), origin::Route::default()).unwrap(); run.regrant(&mut stream, &consumer, crate::auth::Permit::default()) .unwrap(); *budget.write().ok().unwrap() = 4; @@ -2722,8 +2723,8 @@ mod announce_test { #[test] fn a_seen_retraction_can_precede_synced() { let origin = Hop::new(1).unwrap().produce(); - let first = origin.announce("a", origin::Route::default()).unwrap(); - let unseen = origin.announce("b", origin::Route::default()).unwrap(); + let first = origin.announce(Path::new("a").unwrap(), origin::Route::default()).unwrap(); + let unseen = origin.announce(Path::new("b").unwrap(), origin::Route::default()).unwrap(); let consumer = origin.consume(); let mut announced = consumer.announced(); let budget = kio::Producer::new(1usize); @@ -2740,7 +2741,7 @@ mod announce_test { ), reader: Reader::new(crate::transport::boxed::RecvStream::new(PendingRecv), Version::Lite07), }; - let mut run = AnnounceRun::new(crate::Path::new("").to_owned(), consumer.hop(), Version::Lite07); + let mut run = AnnounceRun::new(crate::Path::new("").unwrap().to_owned(), consumer.hop(), Version::Lite07); let waiter = kio::Waiter::noop(); assert!(run.poll(&mut stream, &consumer, &mut announced, &waiter).is_pending()); drop(unseen); @@ -2763,7 +2764,7 @@ mod announce_test { #[test] fn an_empty_cold_relay_syncs_without_its_upstream() { let origin = Hop::new(1).unwrap().produce(); - let _upstream = origin.snapshot(""); + let _upstream = origin.snapshot(Path::new("").unwrap()); let consumer = origin.consume(); let mut announced = consumer.announced(); assert!(!announced.is_synced()); @@ -2780,7 +2781,7 @@ mod announce_test { ), reader: Reader::new(crate::transport::boxed::RecvStream::new(PendingRecv), Version::Lite07), }; - let mut run = AnnounceRun::new(crate::Path::new("").to_owned(), consumer.hop(), Version::Lite07); + let mut run = AnnounceRun::new(crate::Path::new("").unwrap().to_owned(), consumer.hop(), Version::Lite07); assert!( run.poll(&mut stream, &consumer, &mut announced, &kio::Waiter::noop()) .is_pending() @@ -2879,9 +2880,9 @@ mod announce_test { #[moq_clock::test] async fn a_silent_upstream_never_delays_the_answer() { let origin = Hop::new(1).unwrap().produce(); - let _route = origin.announce("cam", crate::origin::Route::default()).unwrap(); + let _route = origin.announce(Path::new("cam").unwrap(), crate::origin::Route::default()).unwrap(); // An upstream that never answers its announce request. - let _silent = origin.clone().with_link(crate::origin::Link::Upstream).snapshot(""); + let _silent = origin.clone().with_link(crate::origin::Link::Upstream).snapshot(Path::new("").unwrap()); let log = Log::default(); let writes = log.writes.clone(); @@ -2912,7 +2913,7 @@ mod announce_test { let origin = Hop::new(1).unwrap().produce(); let announcement = origin .announce( - "cam", + Path::new("cam").unwrap(), crate::origin::Route::default().with_hops(pub_hops()).with_cost(7), ) .unwrap(); @@ -2970,7 +2971,7 @@ mod announce_test { let late = h .origin - .announce("mic", crate::origin::Route::default().with_hops(pub_hops())) + .announce(Path::new("mic").unwrap(), crate::origin::Route::default().with_hops(pub_hops())) .unwrap(); settle().await; match h.wire.take_announces().as_slice() { @@ -3028,7 +3029,7 @@ mod announce_test { for version in [Version::Lite06, Version::Lite07] { let mut h = harness_on(version).await; let route = crate::origin::Route::default().with_hops(pub_hops()).with_cost(7); - let newer = h.origin.announce("cam", route.clone()).unwrap(); + let newer = h.origin.announce(Path::new("cam").unwrap(), route.clone()).unwrap(); // A restart waits out the update hold like an update. moq_clock::sleep(crate::origin::Config::default().update_hold).await; settle().await; @@ -3075,7 +3076,7 @@ mod announce_test { let _newer = h .origin .announce( - "cam", + Path::new("cam").unwrap(), crate::origin::Route::default() .with_epoch(epoch.clone()) .with_hops(pub_hops()) @@ -3123,7 +3124,7 @@ mod announce_test { Some(epoch) => route.with_epoch(epoch.clone()), None => route, }; - let _newer = h.origin.announce("cam", route).unwrap(); + let _newer = h.origin.announce(Path::new("cam").unwrap(), route).unwrap(); auth.handle().authorize(&grant(&["cam", "other"])); moq_clock::sleep(crate::origin::Config::default().update_hold).await; settle().await; @@ -3163,10 +3164,10 @@ mod announce_test { let tainted = Hops::try_from(vec![peer]).unwrap(); let _tainted = origin - .announce("echoed", crate::origin::Route::default().with_hops(tainted)) + .announce(Path::new("echoed").unwrap(), crate::origin::Route::default().with_hops(tainted)) .unwrap(); let _clean = origin - .announce("local", crate::origin::Route::default().with_hops(pub_hops())) + .announce(Path::new("local").unwrap(), crate::origin::Route::default().with_hops(pub_hops())) .unwrap(); let log = Log::default(); @@ -3202,7 +3203,7 @@ mod announce_test { let mut h = harness().await; let _late = h .origin - .announce("mic", crate::origin::Route::default().with_hops(pub_hops())) + .announce(Path::new("mic").unwrap(), crate::origin::Route::default().with_hops(pub_hops())) .unwrap(); settle().await; match h.wire.take_announces().as_slice() { @@ -4689,6 +4690,7 @@ impl GroupServe { #[cfg(all(test, not(loom)))] mod serve_group_test { use super::*; + use crate::Path; use crate::lite::test_transport::*; use crate::{Timestamp, broadcast}; use futures::FutureExt; @@ -6207,13 +6209,13 @@ mod serve_group_test { let mut starts = Vec::new(); for warm in [false, true] { let publisher = origin(1); - let broadcast = publisher.create_broadcast("room").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("room").unwrap()).unwrap(); let mut track = broadcast.create_track("test", crate::track::Info::timed()).unwrap(); track.start_at(0).unwrap(); broadcast.announce(Default::default()).unwrap(); let relay = origin(2); let _upstream = connect(version, &publisher, &relay).await; - let remote = relay.consume().routed_broadcast("room").await.unwrap(); + let remote = relay.consume().routed_broadcast(Path::new("room").unwrap()).await.unwrap(); let mut keeper = match warm { true => Some( remote @@ -6238,7 +6240,7 @@ mod serve_group_test { moq_clock::sim::advance(Duration::from_secs(1)).await; let subscriber = origin(3); let _downstream = connect(version, &relay, &subscriber).await; - let remote = subscriber.consume().routed_broadcast("room").await.unwrap(); + let remote = subscriber.consume().routed_broadcast(Path::new("room").unwrap()).await.unwrap(); let mut live = remote .track("test") .unwrap() @@ -6953,6 +6955,7 @@ mod serve_group_test { #[cfg(test)] mod tests { use super::*; + use crate::Path; use crate::lite::test_transport::{Close, ScriptedSession, SinkSend, SinkSession}; use crate::model::ProduceTest; use crate::{broadcast, coding::Encode}; @@ -6972,7 +6975,7 @@ mod tests { echoed_hops.push(crate::Hop::UNKNOWN).unwrap(); let _echoed = origin .dynamic_route( - "echoed", + Path::new("echoed").unwrap(), crate::origin::Route::default() .with_hops(echoed_hops) .with_via(assigned), @@ -6982,7 +6985,7 @@ mod tests { let mut local_hops = Hops::new(); local_hops.push(upstream).unwrap(); let _local = origin - .dynamic_route("local", crate::origin::Route::default().with_hops(local_hops)) + .dynamic_route(Path::new("local").unwrap(), crate::origin::Route::default().with_hops(local_hops)) .unwrap(); // A SETUP that declares no origin of its own, so only the assigned one applies. @@ -7009,14 +7012,14 @@ mod tests { use futures::FutureExt; assert!( serving - .request_broadcast("echoed/x", None) + .request_broadcast(Path::new("echoed/x").unwrap(), None) .now_or_never() .unwrap() .is_err(), "served the peer its own route" ); assert!( - serving.request_broadcast("local/x", None).now_or_never().is_none(), + serving.request_broadcast(Path::new("local/x").unwrap(), None).now_or_never().is_none(), "withheld an independent route" ); } @@ -7036,7 +7039,7 @@ mod tests { tainted_hops.push(crate::Hop::UNKNOWN).unwrap(); let _tainted = origin .announce( - "echoed", + Path::new("echoed").unwrap(), crate::origin::Route::default() .with_hops(tainted_hops) .with_via(assigned), @@ -7046,7 +7049,7 @@ mod tests { let mut clean_hops = Hops::new(); clean_hops.push(clean_publisher).unwrap(); let _clean = origin - .announce("local", crate::origin::Route::default().with_hops(clean_hops)) + .announce(Path::new("local").unwrap(), crate::origin::Route::default().with_hops(clean_hops)) .unwrap(); let gate = kio::Producer::new(true); @@ -7085,7 +7088,7 @@ mod tests { async fn announce_init_broadcast_ends() { let self_origin = crate::Hop::new(1).unwrap(); let origin = crate::origin::Config::new(self_origin).produce(); - let cam = origin.announce("cam", crate::origin::Route::default()).unwrap(); + let cam = origin.announce(Path::new("cam").unwrap(), crate::origin::Route::default()).unwrap(); let gate = kio::Producer::new(true); let session = SinkSession::gated_bi(gate.consume()); @@ -7121,7 +7124,7 @@ mod tests { async fn withdraw_before_init_sends_the_initial_burst() { let self_origin = crate::Hop::new(1).unwrap(); let origin = crate::origin::Config::new(self_origin).produce(); - let _cam = origin.announce("cam", crate::origin::Route::default()).unwrap(); + let _cam = origin.announce(Path::new("cam").unwrap(), crate::origin::Route::default()).unwrap(); let gate = kio::Producer::new(true); let session = SinkSession::gated_bi(gate.consume()); @@ -7454,9 +7457,9 @@ mod tests { let mut _route = None; let mut held = None; match wait { - Wait::Broadcast => _route = Some(origin.dynamic_route("room", crate::origin::Route::default()).unwrap()), + Wait::Broadcast => _route = Some(origin.dynamic_route(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap()), Wait::Track => { - let broadcast = origin.create_broadcast("room").unwrap(); + let broadcast = origin.create_broadcast(Path::new("room").unwrap()).unwrap(); let dynamic = broadcast.dynamic(); broadcast.announce(Default::default()).unwrap(); held = Some((broadcast, dynamic)); @@ -7538,7 +7541,7 @@ mod tests { /// nobody will read. #[moq_clock::test] async fn a_request_ends_when_the_requester_leaves() { - let broadcast = crate::Path::new("room"); + let broadcast = crate::Path::new("room").unwrap(); for version in [Version::Lite05, Version::Lite06, Version::Lite07] { for wait in [Wait::Broadcast, Wait::Track] { for close in [Close::Fin, Close::Reset] { @@ -7590,7 +7593,7 @@ mod tests { for blocked in [false, true] { let case = format!("{version:?}, {close:?}, blocked {blocked}"); let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let broadcast = origin.create_broadcast("room").unwrap(); + let broadcast = origin.create_broadcast(Path::new("room").unwrap()).unwrap(); let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); broadcast.announce(Default::default()).unwrap(); @@ -7615,7 +7618,7 @@ mod tests { let mut script = Vec::new(); lite::Track { epoch: None, - broadcast: crate::Path::new("room"), + broadcast: crate::Path::new("room").unwrap(), track: "video".into(), } .encode(&mut crate::coding::Encoder::new(&mut script, version.into()), version) @@ -7684,7 +7687,7 @@ mod tests { #[moq_clock::test] async fn a_subscribe_update_is_not_a_close() { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let broadcast = origin.create_broadcast("room").unwrap(); + let broadcast = origin.create_broadcast(Path::new("room").unwrap()).unwrap(); let mut dynamic = broadcast.dynamic(); broadcast.announce(Default::default()).unwrap(); @@ -7712,7 +7715,7 @@ mod tests { order: crate::track::Order::Descending, epoch: None, id: 0, - broadcast: crate::Path::new("room"), + broadcast: crate::Path::new("room").unwrap(), track: "video".into(), priority: 1, max_delay: Duration::ZERO, @@ -7801,7 +7804,7 @@ mod tests { type Task = Box Poll<()>>; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let broadcast = origin.create_broadcast("room").unwrap(); + let broadcast = origin.create_broadcast(Path::new("room").unwrap()).unwrap(); let mut dynamic = broadcast.dynamic(); broadcast.announce(Default::default()).unwrap(); @@ -7829,7 +7832,7 @@ mod tests { order: crate::track::Order::Descending, epoch: None, id: 0, - broadcast: crate::Path::new("room"), + broadcast: crate::Path::new("room").unwrap(), track: "video".into(), priority: 0, max_delay: Duration::from_secs(3600), @@ -7927,7 +7930,7 @@ mod tests { async fn an_expired_fetch_resets_rather_than_finishing() { const VERSION: Version = Version::Lite07; let origin = crate::origin::Config::new(Hop::new(1).unwrap()).produce(); - let broadcast = origin.create_broadcast("room").unwrap(); + let broadcast = origin.create_broadcast(Path::new("room").unwrap()).unwrap(); let track = broadcast.create_track("video", track::Info::timed()).unwrap(); broadcast.announce(Default::default()).unwrap(); let mut open = track.append_group().unwrap(); @@ -7953,7 +7956,7 @@ mod tests { let mut script = Vec::new(); lite::Fetch { epoch: None, - broadcast: crate::Path::new("room"), + broadcast: crate::Path::new("room").unwrap(), track: "video".into(), priority: 0, max_delay: Some(Duration::from_millis(500)), @@ -8070,14 +8073,14 @@ mod tests { use kio::Task; for version in [Version::Lite05, Version::Lite06, Version::Lite07] { let origin = crate::origin::Config::new(Hop::random()).produce(); - let broadcast = origin.create_broadcast("room").unwrap(); + let broadcast = origin.create_broadcast(Path::new("room").unwrap()).unwrap(); let _dynamic = broadcast.dynamic(); broadcast.announce(Default::default()).unwrap(); let request = lite::Subscribe { order: crate::track::Order::Descending, epoch: None, id: 0, - broadcast: crate::Path::new("room"), + broadcast: crate::Path::new("room").unwrap(), track: "video".into(), priority: 0, max_delay: Duration::ZERO, @@ -8131,10 +8134,10 @@ mod tests { use kio::Task; let version = Version::Lite07; let origin = crate::origin::Config::new(Hop::random()).produce(); - let broadcast = origin.create_broadcast("room").unwrap(); + let broadcast = origin.create_broadcast(Path::new("room").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); let request = lite::Tracks { - broadcast: crate::Path::new("room"), + broadcast: crate::Path::new("room").unwrap(), epoch: None, }; let request = request.encode_bytes(version).unwrap().to_vec(); @@ -8184,14 +8187,14 @@ mod tests { use kio::Task; for version in [Version::Lite05, Version::Lite06, Version::Lite07] { let origin = crate::origin::Config::new(Hop::random()).produce(); - let broadcast = origin.create_broadcast("room").unwrap(); + let broadcast = origin.create_broadcast(Path::new("room").unwrap()).unwrap(); let mut dynamic = broadcast.dynamic(); broadcast.announce(Default::default()).unwrap(); let request = lite::Subscribe { order: crate::track::Order::Descending, epoch: None, id: 0, - broadcast: crate::Path::new("room"), + broadcast: crate::Path::new("room").unwrap(), track: "video".into(), priority: 0, max_delay: Duration::ZERO, @@ -8331,7 +8334,7 @@ mod tests { order: crate::track::Order::Descending, epoch: None, id: 0, - broadcast: crate::Path::new(broadcast), + broadcast: crate::Path::new(broadcast).unwrap(), track: track.into(), priority, max_delay: Duration::ZERO, @@ -8374,7 +8377,7 @@ mod tests { #[moq_clock::test] async fn send_group_ranks_by_the_subscriber_then_the_publisher() { let origin = crate::origin::Config::new(Hop::new(1).unwrap()).produce(); - let broadcast = origin.create_broadcast("a").unwrap(); + let broadcast = origin.create_broadcast(Path::new("a").unwrap()).unwrap(); let mut dynamic = broadcast.dynamic(); broadcast.announce(Default::default()).unwrap(); let (publisher, log) = grouped_publisher(origin.consume()); diff --git a/rs/moq-net/src/lite/subscribe.rs b/rs/moq-net/src/lite/subscribe.rs index c8b3aca1982..e5ca861c784 100644 --- a/rs/moq-net/src/lite/subscribe.rs +++ b/rs/moq-net/src/lite/subscribe.rs @@ -776,7 +776,7 @@ mod test { order: crate::track::Order::Descending, epoch: None, id: 1, - broadcast: Path::new("room").to_owned(), + broadcast: Path::new("room").unwrap().to_owned(), track: Cow::Borrowed("video"), priority: 3, max_delay: std::time::Duration::from_millis(250), diff --git a/rs/moq-net/src/lite/subscriber.rs b/rs/moq-net/src/lite/subscriber.rs index ba0a93f6c9b..1df65294ce4 100644 --- a/rs/moq-net/src/lite/subscriber.rs +++ b/rs/moq-net/src/lite/subscriber.rs @@ -3416,7 +3416,7 @@ mod tests { validity: Default::default(), route: None, subscriber, - path: Path::new("room").to_owned(), + path: Path::new("room").unwrap().to_owned(), epoch: None, name: "video".to_string(), }; @@ -3488,7 +3488,7 @@ mod tests { validity: Default::default(), route: None, subscriber, - path: Path::new("room").to_owned(), + path: Path::new("room").unwrap().to_owned(), epoch: None, name: "video".to_string(), }; @@ -3558,7 +3558,7 @@ mod tests { validity: Default::default(), route: None, subscriber, - path: Path::new("room").to_owned(), + path: Path::new("room").unwrap().to_owned(), epoch: None, name: "video".to_string(), }; @@ -3617,7 +3617,7 @@ mod tests { validity: Default::default(), route: None, subscriber, - path: Path::new("room").to_owned(), + path: Path::new("room").unwrap().to_owned(), epoch: None, name: "video".to_string(), }; @@ -3801,7 +3801,7 @@ mod tests { validity: Default::default(), route: None, subscriber: subscriber.clone(), - path: Path::new("room").to_owned(), + path: Path::new("room").unwrap().to_owned(), epoch: None, name: "video".to_string(), }, @@ -3896,7 +3896,7 @@ mod tests { validity: Default::default(), route: None, subscriber, - path: Path::new("room").to_owned(), + path: Path::new("room").unwrap().to_owned(), epoch: None, name: "video".to_string(), }, @@ -3943,7 +3943,7 @@ mod tests { subscriber, MintedSource { validity, - path: Path::new("room").to_owned(), + path: Path::new("room").unwrap().to_owned(), epoch: None, source: crate::model::broadcast::SourceGuard::new(broadcast), dynamic, @@ -4071,7 +4071,7 @@ mod tests { validity: Default::default(), route: None, subscriber, - path: Path::new("room").to_owned(), + path: Path::new("room").unwrap().to_owned(), epoch: None, name: "video".to_string(), }, @@ -4122,7 +4122,7 @@ mod tests { validity: Default::default(), route: None, subscriber, - path: Path::new("room/host").to_owned(), + path: Path::new("room/host").unwrap().to_owned(), epoch: None, name: "catalog.json".to_string(), }; @@ -4189,7 +4189,7 @@ mod tests { validity: Default::default(), route: None, subscriber, - path: Path::new("room/host").to_owned(), + path: Path::new("room/host").unwrap().to_owned(), epoch: None, name: "audio".to_string(), }; @@ -4257,7 +4257,7 @@ mod tests { validity: Default::default(), route: None, subscriber, - path: Path::new("room/host").to_owned(), + path: Path::new("room/host").unwrap().to_owned(), epoch: None, name: "catalog.json".to_string(), }, @@ -4323,7 +4323,7 @@ mod tests { validity: Default::default(), route: None, subscriber, - path: Path::new("room").to_owned(), + path: Path::new("room").unwrap().to_owned(), epoch: None, name: "video".into(), }; @@ -4377,7 +4377,7 @@ mod tests { validity: Default::default(), route: None, subscriber, - path: Path::new("room").to_owned(), + path: Path::new("room").unwrap().to_owned(), epoch: None, name: "video".into(), }; @@ -4686,7 +4686,7 @@ mod tests { auth: crate::auth::Link::new(false), }); - let path = Path::new("room/host").to_owned(); + let path = Path::new("room/host").unwrap().to_owned(); let mut announced = Announced::default(); assert!( subscriber @@ -4746,7 +4746,7 @@ mod tests { assert!( subscriber .start_announce( - Path::new(&format!("room/{i}")).to_owned(), + Path::new(&format!("room/{i}")).unwrap().to_owned(), None, crate::Hops::new(), crate::origin::Cost::default(), @@ -4764,7 +4764,7 @@ mod tests { assert!(announced.ready.is_empty()); let consumer = origin.consume(); - let request = moq_clock::sim::spawn(async move { consumer.request_broadcast("room/7", None).await }); + let request = moq_clock::sim::spawn(async move { consumer.request_broadcast(Path::new("room/7").unwrap(), None).await }); let ready = kio::wait(|waiter| announced.ready.poll_pop(waiter)).await.unwrap(); assert_eq!(ready.as_str(), "room/7"); @@ -4794,7 +4794,7 @@ mod tests { going_away: Default::default(), auth: crate::auth::Link::new(false), }); - let path = Path::new("pool").to_owned(); + let path = Path::new("pool").unwrap().to_owned(); let mut announced = Announced::default(); subscriber .start_announce( @@ -4816,7 +4816,7 @@ mod tests { announced: &mut Announced, ) -> (crate::broadcast::Consumer, SourceServe) { let consumer = origin.consume(); - let request = moq_clock::sim::spawn(async move { consumer.request_broadcast("pool/p", None).await }); + let request = moq_clock::sim::spawn(async move { consumer.request_broadcast(Path::new("pool/p").unwrap(), None).await }); let ready = kio::wait(|waiter| announced.ready.poll_pop(waiter)).await.unwrap(); announced.ready.try_push(ready).unwrap(); announced.poll_serve(subscriber, &kio::Waiter::noop()); @@ -4866,7 +4866,7 @@ mod tests { let mut announced = Announced::default(); subscriber .start_announce( - Path::new("pool").to_owned(), + Path::new("pool").unwrap().to_owned(), None, crate::Hops::new(), crate::origin::Cost::default(), @@ -4878,7 +4878,7 @@ mod tests { announced.poll_serve(&subscriber, &kio::Waiter::noop()); let consumer = origin.consume(); - let request = moq_clock::sim::spawn(async move { consumer.request_broadcast("pool/p", None).await }); + let request = moq_clock::sim::spawn(async move { consumer.request_broadcast(Path::new("pool/p").unwrap(), None).await }); let ready = kio::wait(|waiter| announced.ready.poll_pop(waiter)).await.unwrap(); announced.ready.try_push(ready).unwrap(); announced.poll_serve(&subscriber, &kio::Waiter::noop()); @@ -4920,7 +4920,7 @@ mod tests { auth: crate::auth::Link::new(false), }); - let path = Path::new("room/host").to_owned(); + let path = Path::new("room/host").unwrap().to_owned(); let mut announced = Announced::default(); // A chain that already names us is a reflection, declined but still recorded. @@ -4979,7 +4979,7 @@ mod tests { auth: crate::auth::Link::new(false), }); - let path = Path::new("room/host").to_owned(); + let path = Path::new("room/host").unwrap().to_owned(); let mut announced = Announced::default(); let mut reflected = crate::Hops::new(); reflected.push(assigned).unwrap(); @@ -4997,7 +4997,7 @@ mod tests { .unwrap(), "a chain naming its own sender must be dropped", ); - assert!(consumer.get_broadcast("room/host").is_none()); + assert!(consumer.get_broadcast(Path::new("room/host").unwrap()).is_none()); let mut hops = crate::Hops::new(); hops.push(crate::Hop::new(7).unwrap()).unwrap(); @@ -5045,7 +5045,7 @@ mod tests { let mut announced = Announced::default(); let accepted = subscriber .start_announce( - Path::new("room/host").to_owned(), + Path::new("room/host").unwrap().to_owned(), None, hops, crate::origin::Cost::default(), @@ -5057,7 +5057,7 @@ mod tests { assert!(!accepted, "a chain naming its own sender must not become a route"); moq_clock::sleep(std::time::Duration::from_millis(1)).await; - assert!(consumer.get_broadcast("room/host").is_none()); + assert!(consumer.get_broadcast(Path::new("room/host").unwrap()).is_none()); } /// A peer that was advertised a local path and announces it back with this @@ -5070,7 +5070,7 @@ mod tests { let origin = origin::Config::new(relay).produce(); let assigned = crate::Hop::new(777).unwrap(); - let local = origin.publish("room/host", origin::Route::default()).unwrap(); + let local = origin.publish(Path::new("room/host").unwrap(), origin::Route::default()).unwrap(); let track = local.create_track("video", crate::track::Info::timed()).unwrap(); let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"local".as_ref()).unwrap(); @@ -5079,7 +5079,7 @@ mod tests { // The peer's own subscription, excluding the hop the server minted for // it, is served from the local front before anything is announced back. let peer = origin.consume().excluding(assigned); - let resolved = peer.request_broadcast("room/host", None).await.expect("resolves"); + let resolved = peer.request_broadcast(Path::new("room/host").unwrap(), None).await.expect("resolves"); let mut sub = resolved .track("video") .unwrap() @@ -5111,7 +5111,7 @@ mod tests { let mut announced = Announced::default(); let accepted = subscriber .start_announce( - Path::new("room/host").to_owned(), + Path::new("room/host").unwrap().to_owned(), None, hops, crate::origin::Cost::default(), @@ -5125,7 +5125,7 @@ mod tests { // The local front is still the one at the path, and still serving: the // peer's next request joins it rather than minting another. let still = peer - .request_broadcast("room/host", None) + .request_broadcast(Path::new("room/host").unwrap(), None) .await .expect("the local front keeps serving"); assert!( @@ -5170,7 +5170,7 @@ mod tests { let mut announced = Announced::default(); let accepted = subscriber .start_announce( - Path::new("room/host").to_owned(), + Path::new("room/host").unwrap().to_owned(), None, crate::Hops::new(), crate::origin::Cost::UNKNOWN, @@ -5183,7 +5183,7 @@ mod tests { // The route is announced synchronously: hop 0 on the wire, assigned id local. let mut cursor = consumer.announced(); - let route = cursor.expect_next_active("room/host").await; + let route = cursor.expect_next_active(Path::new("room/host").unwrap()).await; let hops: Vec<_> = route.hops.iter().copied().collect(); assert_eq!(hops, vec![crate::Hop::UNKNOWN]); assert!(route.is_anonymous()); @@ -5217,7 +5217,7 @@ mod tests { assert!( subscriber .start_announce( - Path::new("room/host").to_owned(), + Path::new("room/host").unwrap().to_owned(), None, hops, crate::origin::Cost::UNKNOWN, @@ -5229,7 +5229,7 @@ mod tests { ); let mut cursor = consumer.announced(); - let route = cursor.expect_next_active("room/host").await; + let route = cursor.expect_next_active(Path::new("room/host").unwrap()).await; let hops: Vec<_> = route.hops.iter().copied().collect(); assert_eq!(hops, vec![crate::Hop::UNKNOWN, crate::Hop::UNKNOWN]); assert!(route.is_anonymous()); @@ -5245,7 +5245,7 @@ mod tests { let mut announced = Announced::default(); subscriber .start_announce( - Path::new("room/host").to_owned(), + Path::new("room/host").unwrap().to_owned(), None, crate::Hops::new(), crate::origin::Cost::UNKNOWN, @@ -5257,14 +5257,14 @@ mod tests { let mut cursor = consumer.announced(); moq_clock::sim::yield_now().await; - let route = cursor.expect_next_active("room/host").await; + let route = cursor.expect_next_active(Path::new("room/host").unwrap()).await; let hops: Vec<_> = route.hops.iter().copied().collect(); assert_eq!(hops, vec![crate::Hop::UNKNOWN]); // A reprice from the same unnamed publisher stays anonymous and in place. subscriber .update_announce( - Path::new("room/host").to_owned(), + Path::new("room/host").unwrap().to_owned(), crate::Hops::new(), crate::origin::Cost::UNKNOWN, 4, @@ -5273,7 +5273,7 @@ mod tests { ) .unwrap(); moq_clock::sim::yield_now().await; - let route = cursor.expect_next_active("room/host").await; + let route = cursor.expect_next_active(Path::new("room/host").unwrap()).await; let hops: Vec<_> = route.hops.iter().copied().collect(); assert_eq!(hops, vec![crate::Hop::UNKNOWN]); } @@ -5303,7 +5303,7 @@ mod tests { let (mut subscriber, consumer) = restart_subscriber(SinkSession::new(Default::default())); let mut announced = Announced::default(); - let path = Path::new("room/host").to_owned(); + let path = Path::new("room/host").unwrap().to_owned(); subscriber .start_announce( path.clone(), @@ -5318,7 +5318,7 @@ mod tests { let mut cursor = consumer.announced(); moq_clock::sim::yield_now().await; - cursor.expect_next_active("room/host").await; + cursor.expect_next_active(Path::new("room/host").unwrap()).await; subscriber .update_announce( @@ -5332,7 +5332,7 @@ mod tests { .unwrap(); moq_clock::sim::yield_now().await; - let route = cursor.expect_next_active("room/host").await; + let route = cursor.expect_next_active(Path::new("room/host").unwrap()).await; assert_eq!(route.cost, crate::origin::Cost::new(5).charged(0)); } @@ -5344,7 +5344,7 @@ mod tests { let auth = subscriber.auth.clone(); let mut announced = Announced::default(); - let path = Path::new("room/host").to_owned(); + let path = Path::new("room/host").unwrap().to_owned(); subscriber .start_announce( path.clone(), @@ -5357,7 +5357,7 @@ mod tests { ) .unwrap(); let mut cursor = consumer.announced(); - cursor.expect_next_active("room/host").await; + cursor.expect_next_active(Path::new("room/host").unwrap()).await; auth.handle().authorize(&crate::auth::Grant { publish: Default::default(), @@ -5376,7 +5376,7 @@ mod tests { ) .unwrap(); assert!(!attached, "a restart outside the limit was attached"); - cursor.expect_next_ended("room/host").await; + cursor.expect_next_ended(Path::new("room/host").unwrap()).await; } /// An announce stream that dies without an explicit `ended` retracts the route @@ -5403,7 +5403,7 @@ mod tests { auth: crate::auth::Link::new(false), }); - let path = Path::new("room/host").to_owned(); + let path = Path::new("room/host").unwrap().to_owned(); let hops = crate::Hops::try_from(vec![crate::Hop::new(7).unwrap()]).unwrap(); let mut announced = Announced::default(); subscriber @@ -5418,12 +5418,12 @@ mod tests { ) .unwrap(); let mut cursor = consumer.announced(); - cursor.expect_next_active("room/host").await; + cursor.expect_next_active(Path::new("room/host").unwrap()).await; // The stream ends without retracting anything: the map dies with it and the // route retracts. drop(announced); - cursor.expect_next_ended("room/host").await; + cursor.expect_next_ended(Path::new("room/host").unwrap()).await; // An explicit retraction retracts it the same way. let hops = crate::Hops::try_from(vec![crate::Hop::new(7).unwrap()]).unwrap(); @@ -5439,10 +5439,10 @@ mod tests { &mut announced, ) .unwrap(); - cursor.expect_next_active("room/host").await; + cursor.expect_next_active(Path::new("room/host").unwrap()).await; assert!(announced.contains(&path.clone()), "the announce was not recorded"); announced.withdraw(&path); - cursor.expect_next_ended("room/host").await; + cursor.expect_next_ended(Path::new("room/host").unwrap()).await; } /// An unknown announce type between two starts is skipped without ending the @@ -5452,7 +5452,7 @@ mod tests { const VERSION: Version = Version::Lite06; let start = |suffix| lite::AnnounceBroadcast::Active { epoch: None, - suffix: lite::PathRef::literal(Path::new(suffix)), + suffix: lite::PathRef::literal(Path::new(suffix).unwrap()), hops: lite::HopsRef::literal(crate::Hops::new()), cost: crate::origin::Cost::default(), }; @@ -5488,16 +5488,16 @@ mod tests { }); let mut prefix = AnnouncePrefix::new( subscriber.clone(), - Path::new("").to_owned(), - subscriber.origin.snapshot(""), + Path::new("").unwrap().to_owned(), + subscriber.origin.snapshot(Path::new("").unwrap()), ); let mut cursor = consumer.announced(); let mut run = std::pin::pin!(kio::wait(|waiter| prefix.poll(waiter))); assert!(futures::poll!(run.as_mut()).is_pending()); - cursor.expect_next_active("a").await; - cursor.expect_next_active("b").await; + cursor.expect_next_active(Path::new("a").unwrap()).await; + cursor.expect_next_active(Path::new("b").unwrap()).await; } /// A peer's announce stream for the root, encoded for `version`. @@ -5526,7 +5526,7 @@ mod tests { move |w| { lite::AnnounceBroadcast::Active { epoch: None, - suffix: lite::PathRef::literal(Path::new(suffix)), + suffix: lite::PathRef::literal(Path::new(suffix).unwrap()), hops: lite::HopsRef::literal(crate::Hops::new()), cost: crate::origin::Cost::default(), } @@ -5557,8 +5557,8 @@ mod tests { ( AnnouncePrefix::new( subscriber.clone(), - Path::new("").to_owned(), - subscriber.origin.snapshot(""), + Path::new("").unwrap().to_owned(), + subscriber.origin.snapshot(Path::new("").unwrap()), ), consumer, ) @@ -5583,14 +5583,14 @@ mod tests { let mut run = std::pin::pin!(kio::wait(|waiter| prefix.poll(waiter))); assert!(futures::poll!(run.as_mut()).is_pending()); - cursor.assert_next_active("a"); + cursor.assert_next_active(Path::new("a").unwrap()); assert!(!cursor.is_synced(), "never before an earlier event is read"); - cursor.assert_next_active("b"); + cursor.assert_next_active(Path::new("b").unwrap()); assert!(cursor.is_synced()); // A consumer created after the boundary syncs on its replay. let mut late = consumer.announced(); - late.assert_next_active("a"); - late.assert_next_active("b"); + late.assert_next_active(Path::new("a").unwrap()); + late.assert_next_active(Path::new("b").unwrap()); assert!(late.is_synced()); } @@ -5604,7 +5604,7 @@ mod tests { let mut run = std::pin::pin!(kio::wait(|waiter| prefix.poll(waiter))); assert!(futures::poll!(run.as_mut()).is_pending()); - cursor.assert_next_active("a"); + cursor.assert_next_active(Path::new("a").unwrap()); assert!(!cursor.is_synced()); } @@ -5677,7 +5677,7 @@ mod tests { const VERSION: Version = Version::Lite02; let init = |w: &mut crate::coding::Encoder<'_>| { lite::AnnounceInit { - suffixes: vec![Path::new("a")], + suffixes: vec![Path::new("a").unwrap()], } .encode(w, VERSION) .unwrap() @@ -5690,7 +5690,7 @@ mod tests { let mut run = std::pin::pin!(kio::wait(|waiter| prefix.poll(waiter))); assert!(futures::poll!(run.as_mut()).is_pending()); assert!(!cursor.is_synced()); - cursor.assert_next_active("a"); + cursor.assert_next_active(Path::new("a").unwrap()); assert!(cursor.is_synced()); } @@ -5701,7 +5701,7 @@ mod tests { const VERSION: Version = Version::Lite06; let start = |suffix| lite::AnnounceBroadcast::Active { epoch: None, - suffix: lite::PathRef::literal(Path::new(suffix)), + suffix: lite::PathRef::literal(Path::new(suffix).unwrap()), hops: lite::HopsRef::literal(crate::Hops::new()), cost: crate::origin::Cost::default(), }; @@ -5736,8 +5736,8 @@ mod tests { subscriber.announces = slots.clone(); let mut prefix = AnnouncePrefix::new( subscriber.clone(), - Path::new("").to_owned(), - subscriber.origin.snapshot(""), + Path::new("").unwrap().to_owned(), + subscriber.origin.snapshot(Path::new("").unwrap()), ); let err = kio::wait(|waiter| prefix.poll(waiter)) diff --git a/rs/moq-net/src/lite/track.rs b/rs/moq-net/src/lite/track.rs index 0143105cdf5..0e8b054b444 100644 --- a/rs/moq-net/src/lite/track.rs +++ b/rs/moq-net/src/lite/track.rs @@ -483,7 +483,7 @@ mod test { fn track_request_roundtrips_on_lite05() { let msg = Track { epoch: None, - broadcast: Path::new("room").to_owned(), + broadcast: Path::new("room").unwrap().to_owned(), track: Cow::Borrowed("video"), }; let mut buf = Vec::new(); @@ -491,7 +491,7 @@ mod test { .unwrap(); let mut slice = buf.as_slice(); let got = crate::coding::decode_buf(&mut slice, Version::Lite05, Track::decode_msg).unwrap(); - assert_eq!(got.broadcast, Path::new("room")); + assert_eq!(got.broadcast, Path::new("room").unwrap()); assert_eq!(got.track, "video"); } @@ -499,7 +499,7 @@ mod test { fn track_request_errors_before_lite05() { let msg = Track { epoch: None, - broadcast: Path::new("room").to_owned(), + broadcast: Path::new("room").unwrap().to_owned(), track: Cow::Borrowed("video"), }; let mut buf = Vec::new(); diff --git a/rs/moq-net/src/lite/tracks.rs b/rs/moq-net/src/lite/tracks.rs index 4287476e211..ea50b0c2689 100644 --- a/rs/moq-net/src/lite/tracks.rs +++ b/rs/moq-net/src/lite/tracks.rs @@ -196,19 +196,19 @@ mod test { fn the_request_roundtrips() { let epoch: crate::Epoch = "01900000-0000-7000-8000-000000000001".parse().unwrap(); let msg = Tracks { - broadcast: Path::new("room/alice").to_owned(), + broadcast: Path::new("room/alice").unwrap().to_owned(), epoch: Some(epoch.clone()), }; let buf = msg.encode_bytes(Version::Lite07).unwrap(); let (got, _) = Tracks::decode_slice(&buf, Version::Lite07).unwrap(); - assert_eq!(got.broadcast, Path::new("room/alice")); + assert_eq!(got.broadcast, Path::new("room/alice").unwrap()); assert_eq!(got.epoch, Some(epoch)); } #[test] fn older_versions_have_no_tracks_stream() { let msg = Tracks { - broadcast: Path::new("room").to_owned(), + broadcast: Path::new("room").unwrap().to_owned(), epoch: None, }; assert!(msg.encode_bytes(Version::Lite06).is_err()); diff --git a/rs/moq-net/src/model/follow.rs b/rs/moq-net/src/model/follow.rs index e26d92af015..f17b666ab76 100644 --- a/rs/moq-net/src/model/follow.rs +++ b/rs/moq-net/src/model/follow.rs @@ -294,6 +294,7 @@ impl AnnouncedBroadcast { #[cfg(all(test, feature = "async"))] mod tests { + use crate::Path; use std::time::Duration; use super::super::ProduceTest; @@ -331,19 +332,19 @@ mod tests { #[moq_clock::test] async fn follow_reports_the_route_serving_the_path() { let origin = Hop::new(1).unwrap().produce(); - let mut follow = origin.consume().follow("pool/job").unwrap(); + let mut follow = origin.consume().follow(Path::new("pool/job").unwrap()).unwrap(); let epoch = Epoch::mint(); // A prefix above the path covers it. - let pool = origin.dynamic_route("pool", route(&epoch)).unwrap(); + let pool = origin.dynamic_route(Path::new("pool").unwrap(), route(&epoch)).unwrap(); assert_eq!(followed(&mut follow).await, ("start", "pool".into())); // A route beneath the path serves another broadcast. - let _beneath = origin.publish("pool/job/thumbnail", Route::default()).unwrap(); + let _beneath = origin.publish(Path::new("pool/job/thumbnail").unwrap(), Route::default()).unwrap(); quiet(&mut follow).await; // The path itself, from the same instance, takes over without a restart. - let exact = origin.publish("pool/job", route(&epoch)).unwrap(); + let exact = origin.publish(Path::new("pool/job").unwrap(), route(&epoch)).unwrap(); assert_eq!(followed(&mut follow).await, ("update", "pool/job".into())); // The covering prefix no longer serves the path, so its changes are not seen. @@ -370,10 +371,10 @@ mod tests { #[moq_clock::test] async fn follow_starts_on_the_serving_route_when_joining_late() { let origin = Hop::new(1).unwrap().produce(); - let _pool = origin.dynamic_route("pool", Route::default()).unwrap(); - let _exact = origin.publish("pool/job", Route::default()).unwrap(); + let _pool = origin.dynamic_route(Path::new("pool").unwrap(), Route::default()).unwrap(); + let _exact = origin.publish(Path::new("pool/job").unwrap(), Route::default()).unwrap(); - let mut follow = origin.consume().follow("pool/job").unwrap(); + let mut follow = origin.consume().follow(Path::new("pool/job").unwrap()).unwrap(); assert_eq!(followed(&mut follow).await, ("start", "pool/job".into())); quiet(&mut follow).await; } @@ -384,19 +385,19 @@ mod tests { async fn follow_keeps_a_gap_between_routes_of_one_epoch() { let origin = Hop::new(1).unwrap().produce(); let epoch = Epoch::mint(); - let exact = origin.publish("pool/job", route(&epoch)).unwrap(); - let mut follow = origin.consume().follow("pool/job").unwrap(); + let exact = origin.publish(Path::new("pool/job").unwrap(), route(&epoch)).unwrap(); + let mut follow = origin.consume().follow(Path::new("pool/job").unwrap()).unwrap(); assert_eq!(followed(&mut follow).await, ("start", "pool/job".into())); // Both land before the follower reads again, and the cursor delivers the prefix's start // ahead of the path's end, but the path went unserved in between. drop(exact); - let _pool = origin.dynamic_route("pool", route(&epoch)).unwrap(); + let _pool = origin.dynamic_route(Path::new("pool").unwrap(), route(&epoch)).unwrap(); assert_eq!(followed(&mut follow).await, ("end", "pool/job".into())); assert_eq!(followed(&mut follow).await, ("start", "pool".into())); // A prefix standing while the path's route goes takes over in place. - let exact = origin.publish("pool/job", route(&epoch)).unwrap(); + let exact = origin.publish(Path::new("pool/job").unwrap(), route(&epoch)).unwrap(); assert_eq!(followed(&mut follow).await, ("update", "pool/job".into())); drop(exact); assert_eq!(followed(&mut follow).await, ("update", "pool".into())); @@ -407,12 +408,12 @@ mod tests { #[moq_clock::test] async fn follow_hands_over_to_a_prefix_that_started_before_the_last_change() { let origin = Hop::new(1).unwrap().produce(); - let exact = origin.publish("pool/job", route(&Epoch::mint())).unwrap(); - let mut follow = origin.consume().follow("pool/job").unwrap(); + let exact = origin.publish(Path::new("pool/job").unwrap(), route(&Epoch::mint())).unwrap(); + let mut follow = origin.consume().follow(Path::new("pool/job").unwrap()).unwrap(); assert_eq!(followed(&mut follow).await, ("start", "pool/job".into())); let epoch = Epoch::mint(); - let _pool = origin.dynamic_route("pool", route(&epoch)).unwrap(); + let _pool = origin.dynamic_route(Path::new("pool").unwrap(), route(&epoch)).unwrap(); exact.announce(route(&epoch)).unwrap(); assert_eq!(followed(&mut follow).await, ("restart", "pool/job".into())); @@ -424,12 +425,12 @@ mod tests { #[moq_clock::test] async fn follow_restarts_onto_a_more_specific_route_without_an_epoch() { let origin = Hop::new(1).unwrap().produce(); - let mut follow = origin.consume().follow("pool/job").unwrap(); + let mut follow = origin.consume().follow(Path::new("pool/job").unwrap()).unwrap(); - let _pool = origin.dynamic_route("pool", Route::default()).unwrap(); + let _pool = origin.dynamic_route(Path::new("pool").unwrap(), Route::default()).unwrap(); assert_eq!(followed(&mut follow).await, ("start", "pool".into())); - let _exact = origin.publish("pool/job", Route::default()).unwrap(); + let _exact = origin.publish(Path::new("pool/job").unwrap(), Route::default()).unwrap(); assert_eq!(followed(&mut follow).await, ("restart", "pool/job".into())); } @@ -440,13 +441,13 @@ mod tests { let origin = Hop::new(1).unwrap().produce(); let chat = Patterns::from("room/*/chat".parse::().unwrap()); let _chat = origin - .scope("", &chat) + .scope(Path::new("").unwrap(), &chat) .unwrap() - .dynamic_route("room/alice", Route::default()) + .dynamic_route(Path::new("room/alice").unwrap(), Route::default()) .unwrap(); - let mut follow = origin.consume().follow("room/alice").unwrap(); + let mut follow = origin.consume().follow(Path::new("room/alice").unwrap()).unwrap(); - let first = origin.publish("room/alice", Route::default().with_cost(5)).unwrap(); + let first = origin.publish(Path::new("room/alice").unwrap(), Route::default().with_cost(5)).unwrap(); let event = moq_clock::timeout(Duration::from_secs(1), follow.next()) .await .unwrap() @@ -457,7 +458,7 @@ mod tests { ); // A republish is another instance of the route that serves the path. - let _second = origin.publish("room/alice", Route::default().with_cost(5)).unwrap(); + let _second = origin.publish(Path::new("room/alice").unwrap(), Route::default().with_cost(5)).unwrap(); drop(first); let event = moq_clock::timeout(Duration::from_secs(1), follow.next()) .await @@ -501,13 +502,13 @@ mod tests { #[moq_clock::test] async fn announced_hands_out_a_held_takeover_once() { let origin = Hop::new(1).unwrap().produce(); - let dynamic = origin.dynamic("live").unwrap(); - let mut announced = origin.consume().announced_broadcast("live", None).unwrap(); + let dynamic = origin.dynamic(Path::new("live").unwrap()).unwrap(); + let mut announced = origin.consume().announced_broadcast(Path::new("live").unwrap(), None).unwrap(); // The wait is on the dynamic route's answer when the exact path takes over without an epoch. let (_takeover, _publish) = futures::join!(available(&mut announced), async { let _unanswered = requested(&dynamic).await; - origin.publish("live", Route::default()).unwrap() + origin.publish(Path::new("live").unwrap(), Route::default()).unwrap() }); none(&mut announced).await; } @@ -517,12 +518,12 @@ mod tests { #[moq_clock::test] async fn announced_hands_out_a_dropped_takeover_again() { let origin = Hop::new(1).unwrap().produce(); - let dynamic = origin.dynamic("live").unwrap(); - let mut announced = origin.consume().announced_broadcast("live", None).unwrap(); + let dynamic = origin.dynamic(Path::new("live").unwrap()).unwrap(); + let mut announced = origin.consume().announced_broadcast(Path::new("live").unwrap(), None).unwrap(); let (dropped, _publish) = futures::join!(available(&mut announced), async { let _unanswered = requested(&dynamic).await; - origin.publish("live", Route::default()).unwrap() + origin.publish(Path::new("live").unwrap(), Route::default()).unwrap() }); let front = dropped.weak(); drop(dropped); @@ -537,14 +538,14 @@ mod tests { #[moq_clock::test] async fn announced_hands_out_a_gap_while_resolving_once() { let origin = Hop::new(1).unwrap().produce(); - let dynamic = origin.dynamic("").unwrap(); - let mut announced = origin.consume().announced_broadcast("live", None).unwrap(); + let dynamic = origin.dynamic(Path::new("").unwrap()).unwrap(); + let mut announced = origin.consume().announced_broadcast(Path::new("live").unwrap(), None).unwrap(); let (_arrival, _publish) = futures::join!(available(&mut announced), async { let _unanswered = requested(&dynamic).await; drop(dynamic); moq_clock::sleep(super::super::origin_impl::DEFAULT_UPDATE_HOLD * 2).await; - origin.publish("live", Route::default()).unwrap() + origin.publish(Path::new("live").unwrap(), Route::default()).unwrap() }); none(&mut announced).await; } @@ -556,11 +557,11 @@ mod tests { async fn announced_hands_out_the_instance_again_after_an_end() { let origin = Hop::new(1).unwrap().produce(); let epoch = Epoch::mint(); - let mut announced = origin.consume().announced_broadcast("live", None).unwrap(); - let exact = origin.publish("live", route(&epoch)).unwrap(); + let mut announced = origin.consume().announced_broadcast(Path::new("live").unwrap(), None).unwrap(); + let exact = origin.publish(Path::new("live").unwrap(), route(&epoch)).unwrap(); let first = available(&mut announced).await; - let dynamic = origin.dynamic_route("", route(&epoch)).unwrap(); + let dynamic = origin.dynamic_route(Path::new("").unwrap(), route(&epoch)).unwrap(); exact.unannounce(); let served = broadcast::Info::new().produce(); let (again, ()) = futures::join!(available(&mut announced), async { @@ -575,16 +576,16 @@ mod tests { async fn announced_pinned_refuses_another_instance() { let origin = Hop::new(1).unwrap().produce(); let epoch = Epoch::mint(); - let _first = origin.publish("live", route(&epoch)).unwrap(); - let mut announced = origin.consume().announced_broadcast("live", epoch.clone()).unwrap(); + let _first = origin.publish(Path::new("live").unwrap(), route(&epoch)).unwrap(); + let mut announced = origin.consume().announced_broadcast(Path::new("live").unwrap(), epoch.clone()).unwrap(); let pinned = available(&mut announced).await; assert_eq!(pinned.info().epoch.as_ref(), Some(&epoch)); - let _second = origin.publish("live", route(&Epoch::mint())).unwrap(); + let _second = origin.publish(Path::new("live").unwrap(), route(&Epoch::mint())).unwrap(); none(&mut announced).await; // Unpinned, the same takeover is followed. - let mut unpinned = origin.consume().announced_broadcast("live", None).unwrap(); + let mut unpinned = origin.consume().announced_broadcast(Path::new("live").unwrap(), None).unwrap(); let current = available(&mut unpinned).await; assert_ne!(current.info().epoch.as_ref(), Some(&epoch)); } @@ -595,7 +596,7 @@ mod tests { fn follow_refuses_a_path_no_pattern_can_spell() { let origin = Hop::new(1).unwrap().produce(); assert!(matches!( - origin.consume().follow("camera*main"), + origin.consume().follow(Path::new("camera*main").unwrap()), Err(Error::InvalidPath(_)) )); } @@ -605,7 +606,7 @@ mod tests { fn follow_refuses_a_path_outside_the_scope() { let origin = Hop::new(1).unwrap().produce(); let scope = Patterns::from(Pattern::subtree("pool/job/cam").unwrap()); - let scoped = origin.consume().scope("", &scope).unwrap(); - assert!(matches!(scoped.follow("pool/job"), Err(Error::Unauthorized))); + let scoped = origin.consume().scope(Path::new("").unwrap(), &scope).unwrap(); + assert!(matches!(scoped.follow(Path::new("pool/job").unwrap()), Err(Error::Unauthorized))); } } diff --git a/rs/moq-net/src/model/group.rs b/rs/moq-net/src/model/group.rs index 02cae7143af..49db415da76 100644 --- a/rs/moq-net/src/model/group.rs +++ b/rs/moq-net/src/model/group.rs @@ -3205,6 +3205,7 @@ impl Fetch { #[cfg(test)] mod test { use super::*; + use crate::Path; use crate::model::test_tracing::count_drop_warnings; use bytes::Bytes; #[cfg(feature = "async")] @@ -4799,7 +4800,7 @@ mod test { #[cfg(feature = "async")] fn inflation_is_shared_and_stops_at_release() { let registry = stats::Registry::new(stats::Config::new()); - let meter = registry.publisher_meter("demo", &stats::Tier::default()); + let meter = registry.publisher_meter(Path::new("demo").unwrap(), &stats::Tier::default()); let inflated = || { registry .snapshot() @@ -4863,7 +4864,7 @@ mod test { .map_or(0, |(_, _, traffic)| traffic.bytes) }; let pool = cache::Pool::unbounded(); - let meter = registry.publisher_meter("demo", &stats::Tier::default()); + let meter = registry.publisher_meter(Path::new("demo").unwrap(), &stats::Tier::default()); let mut group = compressed_group(&pool).with_meter(meter); group.write_frame(None, verbose(0)).unwrap(); diff --git a/rs/moq-net/src/model/origin.rs b/rs/moq-net/src/model/origin.rs index ccee267434a..60bced08515 100644 --- a/rs/moq-net/src/model/origin.rs +++ b/rs/moq-net/src/model/origin.rs @@ -7113,7 +7113,7 @@ mod tests { ..Default::default() }; let (producer, _driver) = Producer::new(config); - let scoped = producer.scope("room", &Patterns::from(Pattern::all())).unwrap(); + let scoped = producer.scope(Path::new("room").unwrap(), &Patterns::from(Pattern::all())).unwrap(); assert_eq!(scoped.config().max_hops.get(), 6); assert_eq!(scoped.consume().forwardable().horizon.max_hops, HopLimit::new(6)); } @@ -7258,14 +7258,14 @@ mod tests { let mut announced = consumer.announced(); announced.assert_next_wait(); - let announcement = producer.announce("room/alice", Route::default()).unwrap(); - let route = announced.expect_next_active("room/alice").await; + let announcement = producer.announce(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let route = announced.expect_next_active(Path::new("room/alice").unwrap()).await; assert!(route.hops.is_empty()); assert_eq!(route.cost, Cost::default()); announced.assert_next_wait(); drop(announcement); - announced.expect_next_ended("room/alice").await; + announced.expect_next_ended(Path::new("room/alice").unwrap()).await; announced.assert_next_wait(); } @@ -7273,19 +7273,19 @@ mod tests { #[test] fn synced_after_the_snapshot_and_its_events() { let producer = origin(1).produce(); - let snapshot = producer.snapshot("room"); + let snapshot = producer.snapshot(Path::new("room").unwrap()); let mut announced = producer.consume().announced(); assert!(!announced.is_synced(), "a snapshot in flight holds it"); - let _alice = producer.announce("room/alice", Route::default()).unwrap(); + let _alice = producer.announce(Path::new("room/alice").unwrap(), Route::default()).unwrap(); drop(snapshot); assert!(!announced.is_synced(), "never before an earlier event is read"); - announced.assert_next_active("room/alice"); + announced.assert_next_active(Path::new("room/alice").unwrap()); assert!(announced.is_synced()); // A later announcement is news, not part of what it synced with. - let _bob = producer.announce("room/bob", Route::default()).unwrap(); + let _bob = producer.announce(Path::new("room/bob").unwrap(), Route::default()).unwrap(); assert!(announced.is_synced()); } @@ -7297,35 +7297,35 @@ mod tests { assert!(empty.is_synced(), "nothing to wait on"); empty.assert_next_wait(); - let _alice = producer.announce("room/alice", Route::default()).unwrap(); + let _alice = producer.announce(Path::new("room/alice").unwrap(), Route::default()).unwrap(); let mut announced = producer.consume().announced(); assert!(!announced.is_synced(), "the replay is owed"); - announced.assert_next_active("room/alice"); + announced.assert_next_active(Path::new("room/alice").unwrap()); assert!(announced.is_synced()); } #[test] fn initial_routes_precede_live_prefixes() { let producer = origin(1).produce(); - let _initial = producer.announce("z/initial", Route::default()).unwrap(); + let _initial = producer.announce(Path::new("z/initial").unwrap(), Route::default()).unwrap(); let mut announced = producer.consume().announced(); - let _live = producer.announce("a/live", Route::default()).unwrap(); - announced.assert_next_active("z/initial"); + let _live = producer.announce(Path::new("a/live").unwrap(), Route::default()).unwrap(); + announced.assert_next_active(Path::new("z/initial").unwrap()); assert!(announced.is_synced()); } #[test] fn stalled_initial_replay_collapses_churn_without_a_backlog() { let producer = origin(1).produce(); - let initial = producer.announce("z/initial", Route::default()).unwrap(); + let initial = producer.announce(Path::new("z/initial").unwrap(), Route::default()).unwrap(); let mut announced = producer.consume().announced(); for i in 0..1_000 { - let transient = producer.announce(format!("a/{i}"), Route::default()).unwrap(); + let transient = producer.announce(Path::try_from(format!("a/{i}")).unwrap(), Route::default()).unwrap(); initial.update(Route::default().with_cost(i)).unwrap(); drop(transient); assert_eq!(announced.state.read().pending.len(), 1); } - announced.assert_next_active("z/initial"); + announced.assert_next_active(Path::new("z/initial").unwrap()); assert!(announced.is_synced()); announced.assert_next_wait(); } @@ -7334,10 +7334,10 @@ mod tests { #[test] fn a_cancelled_start_still_catches_up() { let producer = origin(1).produce(); - let snapshot = producer.snapshot(""); + let snapshot = producer.snapshot(Path::new("").unwrap()); let mut announced = producer.consume().announced(); - let alice = producer.announce("room/alice", Route::default()).unwrap(); + let alice = producer.announce(Path::new("room/alice").unwrap(), Route::default()).unwrap(); drop(snapshot); assert!(!announced.is_synced()); drop(alice); @@ -7350,10 +7350,10 @@ mod tests { fn an_update_is_not_owed() { let producer = origin(1).produce(); let mut announced = producer.consume().announced(); - let alice = producer.announce("room/alice", Route::default()).unwrap(); - announced.assert_next_active("room/alice"); + let alice = producer.announce(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + announced.assert_next_active(Path::new("room/alice").unwrap()); - let snapshot = producer.snapshot(""); + let snapshot = producer.snapshot(Path::new("").unwrap()); alice.update(Route::default().with_cost(5)).unwrap(); drop(snapshot); assert!(announced.is_synced()); @@ -7366,9 +7366,9 @@ mod tests { let announced = producer.consume().announced(); assert!(announced.is_synced()); - let snapshot = producer.snapshot("room/alice"); + let snapshot = producer.snapshot(Path::new("room/alice").unwrap()); assert!(!announced.is_synced(), "a snapshot beneath the scope holds it"); - let second = producer.snapshot(""); + let second = producer.snapshot(Path::new("").unwrap()); drop(snapshot); assert!(!announced.is_synced(), "every current snapshot must land"); drop(second); @@ -7381,13 +7381,13 @@ mod tests { let producer = origin(1).produce(); let room = producer .consume() - .scope("room", &Patterns::from(Pattern::all())) + .scope(Path::new("room").unwrap(), &Patterns::from(Pattern::all())) .unwrap(); - let other = producer.snapshot("other"); + let other = producer.snapshot(Path::new("other").unwrap()); assert!(room.announced().is_synced(), "a disjoint prefix"); - let above = producer.snapshot(""); + let above = producer.snapshot(Path::new("").unwrap()); let announced = room.announced(); assert!(!announced.is_synced(), "a snapshot above the root covers it"); drop(above); @@ -7396,7 +7396,7 @@ mod tests { drop(other); // A local view never waits on a peer's routes. - let _peer = producer.clone().with_link(Link::Peer).snapshot("room"); + let _peer = producer.clone().with_link(Link::Peer).snapshot(Path::new("room").unwrap()); assert!(producer.consume().local().announced().is_synced()); assert!(!producer.consume().announced().is_synced()); } @@ -7409,12 +7409,12 @@ mod tests { let announced = project.announced(); assert!(announced.is_synced()); - let shadowed = producer.snapshot("p1/.svc"); + let shadowed = producer.snapshot(Path::new("p1/.svc").unwrap()); assert!(announced.is_synced(), "a snapshot in flight under the hole"); assert!(project.announced().is_synced(), "a reader registering past one"); drop(shadowed); - let _target = producer.snapshot(".svc/p1"); + let _target = producer.snapshot(Path::new(".svc/p1").unwrap()); assert!(!announced.is_synced(), "the mount's target does hold it"); } @@ -7423,7 +7423,7 @@ mod tests { fn a_hidden_snapshot_holds_only_hidden_readers() { let producer = origin(1).produce(); let announced = producer.consume().announced(); - let _stats = producer.snapshot(".stats"); + let _stats = producer.snapshot(Path::new(".stats").unwrap()); assert!(announced.is_synced(), "a snapshot in flight under a hidden segment"); assert!( producer.consume().announced().is_synced(), @@ -7443,7 +7443,7 @@ mod tests { } let producer = origin(1).produce(); - let snapshot = producer.snapshot(""); + let snapshot = producer.snapshot(Path::new("").unwrap()); let announced = producer.consume().announced(); let woken = Arc::new(Woken(AtomicBool::new(false))); let waiter = kio::Waiter::new(std::task::Waker::from(woken.clone())); @@ -7471,8 +7471,8 @@ mod tests { assert!(announced.poll_next(&waiter).is_pending()); assert!(announced.poll_synced(&waiter).is_ready()); - let first = producer.snapshot(""); - let second = producer.snapshot("room"); + let first = producer.snapshot(Path::new("").unwrap()); + let second = producer.snapshot(Path::new("room").unwrap()); drop(first); assert!(!woken.0.load(Ordering::SeqCst), "woken while still held back"); drop(second); @@ -7485,47 +7485,47 @@ mod tests { async fn hidden_routes_need_an_opt_in() { let producer = origin(1).produce(); let consumer = producer.consume(); - let _visible = producer.announce("room/alice", Route::default()).unwrap(); - let _stats = producer.announce(".stats/node", Route::default()).unwrap(); - let _nested = producer.announce("room/.internal", Route::default()).unwrap(); + let _visible = producer.announce(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let _stats = producer.announce(Path::new(".stats/node").unwrap(), Route::default()).unwrap(); + let _nested = producer.announce(Path::new("room/.internal").unwrap(), Route::default()).unwrap(); // Only a leading dot hides: a suffix is part of the name. - let _suffix = producer.announce("room/catalog.pro", Route::default()).unwrap(); + let _suffix = producer.announce(Path::new("room/catalog.pro").unwrap(), Route::default()).unwrap(); let mut announced = consumer.announced(); - announced.expect_next_active("room/alice").await; - announced.expect_next_active("room/catalog.pro").await; + announced.expect_next_active(Path::new("room/alice").unwrap()).await; + announced.expect_next_active(Path::new("room/catalog.pro").unwrap()).await; announced.assert_next_wait(); let mut announced = consumer.clone().with_hidden(true).announced(); - announced.expect_next_active(".stats/node").await; - announced.expect_next_active("room/.internal").await; - announced.expect_next_active("room/alice").await; - announced.expect_next_active("room/catalog.pro").await; + announced.expect_next_active(Path::new(".stats/node").unwrap()).await; + announced.expect_next_active(Path::new("room/.internal").unwrap()).await; + announced.expect_next_active(Path::new("room/alice").unwrap()).await; + announced.expect_next_active(Path::new("room/catalog.pro").unwrap()).await; announced.assert_next_wait(); // Naming the dot segment lists what is under it, by root or by pattern. let mut announced = consumer - .scope(".stats", &Patterns::from(Pattern::all())) + .scope(Path::new(".stats").unwrap(), &Patterns::from(Pattern::all())) .unwrap() .announced(); - announced.expect_next_active("node").await; + announced.expect_next_active(Path::new("node").unwrap()).await; announced.assert_next_wait(); - let mut announced = consumer.scope("", &scopes(&["room/.internal"])).unwrap().announced(); - announced.expect_next_active("room/.internal").await; + let mut announced = consumer.scope(Path::new("").unwrap(), &scopes(&["room/.internal"])).unwrap().announced(); + announced.expect_next_active(Path::new("room/.internal").unwrap()).await; announced.assert_next_wait(); // A top-up feed reports only what a feed from the root hid, filtered by its own // prefix and opt-in. let mut announced = consumer.clone().with_hidden(true).beyond(&consumer).announced(); - announced.expect_next_active(".stats/node").await; - announced.expect_next_active("room/.internal").await; + announced.expect_next_active(Path::new(".stats/node").unwrap()).await; + announced.expect_next_active(Path::new("room/.internal").unwrap()).await; announced.assert_next_wait(); - let room = consumer.scope("", &scopes(&["room"])).unwrap().beyond(&consumer); + let room = consumer.scope(Path::new("").unwrap(), &scopes(&["room"])).unwrap().beyond(&consumer); let mut announced = room.announced(); announced.assert_next_wait(); - let stats = consumer.scope("", &scopes(&[".stats"])).unwrap().beyond(&consumer); + let stats = consumer.scope(Path::new("").unwrap(), &scopes(&[".stats"])).unwrap().beyond(&consumer); let mut announced = stats.announced(); - announced.expect_next_active(".stats/node").await; + announced.expect_next_active(Path::new(".stats/node").unwrap()).await; announced.assert_next_wait(); } @@ -7535,11 +7535,11 @@ mod tests { async fn hidden_broadcast_resolves_by_path() { let producer = origin(1).produce(); let consumer = producer.consume(); - let broadcast = producer.create_broadcast(".stats/node").unwrap(); + let broadcast = producer.create_broadcast(Path::new(".stats/node").unwrap()).unwrap(); broadcast.announce(Route::default()).unwrap(); consumer.announced().assert_next_wait(); - let resolved = consumer.request_broadcast(".stats/node", None).await.expect("resolves"); + let resolved = consumer.request_broadcast(Path::new(".stats/node").unwrap(), None).await.expect("resolves"); assert_eq!(resolved.info().path.as_str(), ".stats/node"); } @@ -7547,9 +7547,9 @@ mod tests { fn mounted(producer: &Producer, pid: &str, patterns: &[&str]) -> Consumer { let patterns: Patterns = patterns.iter().map(|pattern| pattern.parse().unwrap()).collect(); producer - .mount(format!("{pid}/.svc"), format!(".svc/{pid}")) + .mount(Path::try_from(format!("{pid}/.svc")).unwrap(), Path::try_from(format!(".svc/{pid}")).unwrap()) .unwrap() - .scope(pid, &patterns) + .scope(Path::new(pid).unwrap(), &patterns) .unwrap() .consume() } @@ -7560,11 +7560,11 @@ mod tests { #[cfg(feature = "async")] async fn mount_resolves_on_the_target_front() { let producer = origin(1).produce(); - let server = producer.dynamic_route(".svc", Route::default()).unwrap(); + let server = producer.dynamic_route(Path::new(".svc").unwrap(), Route::default()).unwrap(); let project = mounted(&producer, "p1", &["**"]); - let through = project.request_broadcast(".svc/foo", None); - let direct = producer.consume().request_broadcast(".svc/p1/foo", None); + let through = project.request_broadcast(Path::new(".svc/foo").unwrap(), None); + let direct = producer.consume().request_broadcast(Path::new(".svc/p1/foo").unwrap(), None); let request = queued(&server).await; assert_eq!(request.path().as_str(), ".svc/p1/foo"); @@ -7585,40 +7585,40 @@ mod tests { #[cfg(feature = "async")] async fn mount_presents_target_routes_under_the_mount() { let producer = origin(1).produce(); - let _claim = producer.announce(".svc", Route::default()).unwrap(); - let foo = producer.publish(".svc/p1/foo", Route::default()).unwrap(); - let _other = producer.publish(".svc/p2/bar", Route::default()).unwrap(); - let _cam = producer.publish("p1/cam", Route::default()).unwrap(); - let _shadowed = producer.publish("p1/.svc/forged", Route::default()).unwrap(); + let _claim = producer.announce(Path::new(".svc").unwrap(), Route::default()).unwrap(); + let foo = producer.publish(Path::new(".svc/p1/foo").unwrap(), Route::default()).unwrap(); + let _other = producer.publish(Path::new(".svc/p2/bar").unwrap(), Route::default()).unwrap(); + let _cam = producer.publish(Path::new("p1/cam").unwrap(), Route::default()).unwrap(); + let _shadowed = producer.publish(Path::new("p1/.svc/forged").unwrap(), Route::default()).unwrap(); let project = mounted(&producer, "p1", &["**"]); // A dot segment hides the mount like any other. let mut announced = project.announced(); - announced.expect_next_active("cam").await; + announced.expect_next_active(Path::new("cam").unwrap()).await; announced.assert_next_wait(); let mut announced = project.clone().with_hidden(true).announced(); - announced.expect_next_active("cam").await; - announced.expect_next_active(".svc").await; - announced.expect_next_active(".svc/foo").await; + announced.expect_next_active(Path::new("cam").unwrap()).await; + announced.expect_next_active(Path::new(".svc").unwrap()).await; + announced.expect_next_active(Path::new(".svc/foo").unwrap()).await; announced.assert_next_wait(); // Rooted inside the mount, the claim covers the root itself. let mut inside = project - .scope(".svc", &Patterns::from(Pattern::all())) + .scope(Path::new(".svc").unwrap(), &Patterns::from(Pattern::all())) .unwrap() .announced(); - inside.expect_next_active("").await; - inside.expect_next_active("foo").await; + inside.expect_next_active(Path::new("").unwrap()).await; + inside.expect_next_active(Path::new("foo").unwrap()).await; inside.assert_next_wait(); drop(foo); - announced.expect_next_ended(".svc/foo").await; - inside.expect_next_ended("foo").await; + announced.expect_next_ended(Path::new(".svc/foo").unwrap()).await; + inside.expect_next_ended(Path::new("foo").unwrap()).await; announced.assert_next_wait(); // The shadowed path never resolves: the mount answers for it. - let err = project.request_broadcast(".svc/forged", None).await.err().unwrap(); + let err = project.request_broadcast(Path::new(".svc/forged").unwrap(), None).await.err().unwrap(); assert!(matches!(err, Error::NotFound | Error::Unroutable), "{err:?}"); } @@ -7628,23 +7628,23 @@ mod tests { #[cfg(feature = "async")] async fn mount_authorizes_the_named_path() { let producer = origin(1).produce(); - let _foo = producer.publish(".svc/p1/foo", Route::default()).unwrap(); - let _bar = producer.publish(".svc/p1/bar", Route::default()).unwrap(); + let _foo = producer.publish(Path::new(".svc/p1/foo").unwrap(), Route::default()).unwrap(); + let _bar = producer.publish(Path::new(".svc/p1/bar").unwrap(), Route::default()).unwrap(); let granted = mounted(&producer, "p1", &["foo", ".svc/foo"]); - granted.request_broadcast(".svc/foo", None).await.expect("granted"); + granted.request_broadcast(Path::new(".svc/foo").unwrap(), None).await.expect("granted"); let refused = granted - .request_broadcast(".svc/bar", None) + .request_broadcast(Path::new(".svc/bar").unwrap(), None) .now_or_never() .expect("refused at once"); assert!(matches!(refused, Err(Error::Unauthorized))); let mut announced = granted.clone().with_hidden(true).announced(); - announced.expect_next_active(".svc/foo").await; + announced.expect_next_active(Path::new(".svc/foo").unwrap()).await; announced.assert_next_wait(); let narrower = mounted(&producer, "p1", &["foo"]); let refused = narrower - .request_broadcast(".svc/foo", None) + .request_broadcast(Path::new(".svc/foo").unwrap(), None) .now_or_never() .expect("refused at once"); assert!(matches!(refused, Err(Error::Unauthorized))); @@ -7653,7 +7653,7 @@ mod tests { // Another project's mount reaches its own target, never this one's. let other = mounted(&producer, "p2", &["**"]); other.clone().with_hidden(true).announced().assert_next_wait(); - let err = other.request_broadcast(".svc/foo", None).await.err().unwrap(); + let err = other.request_broadcast(Path::new(".svc/foo").unwrap(), None).await.err().unwrap(); assert!(matches!(err, Error::Unroutable)); } @@ -7662,7 +7662,7 @@ mod tests { #[moq_clock::test] async fn mount_captures_the_named_path() { let producer = origin(1).produce(); - let _foo = producer.publish(".svc/p1/foo", Route::default()).unwrap(); + let _foo = producer.publish(Path::new(".svc/p1/foo").unwrap(), Route::default()).unwrap(); let project = mounted(&producer, "p1", &["**"]).with_hidden(true); let Some(AnnounceEvent::Start(update)) = project.announced().try_next() else { @@ -7671,7 +7671,7 @@ mod tests { assert_eq!(update.prefix.as_str(), ".svc/foo"); assert_eq!(update.captures, Some(vec![".svc/foo".parse::().unwrap()])); - let inside = project.scope(".svc", &Patterns::from(Pattern::all())).unwrap(); + let inside = project.scope(Path::new(".svc").unwrap(), &Patterns::from(Pattern::all())).unwrap(); let Some(AnnounceEvent::Start(update)) = inside.announced().try_next() else { panic!("expected foo to start"); }; @@ -7686,23 +7686,23 @@ mod tests { async fn mount_keeps_a_max_depth_target() { let producer = origin(1).produce(); let deep = vec!["d"; Path::MAX_PARTS].join("/"); - let _leaf = producer.publish(deep.as_str(), Route::default()).unwrap(); + let _leaf = producer.publish(Path::new(deep.as_str()).unwrap(), Route::default()).unwrap(); let project = producer - .mount("p1/.svc", deep.as_str()) + .mount(Path::new("p1/.svc").unwrap(), Path::new(deep.as_str()).unwrap()) .unwrap() - .scope("p1", &Patterns::from(Pattern::all())) + .scope(Path::new("p1").unwrap(), &Patterns::from(Pattern::all())) .unwrap() .consume() .with_hidden(true); let mut announced = project.announced(); - announced.expect_next_active(".svc").await; + announced.expect_next_active(Path::new(".svc").unwrap()).await; announced.assert_next_wait(); // Beneath the mount the target has no room: refused, never handed to a route. - let err = project.request_broadcast(".svc/x", None).await.err().unwrap(); + let err = project.request_broadcast(Path::new(".svc/x").unwrap(), None).await.err().unwrap(); assert!(matches!(err, Error::BoundsExceeded(_)), "{err:?}"); - let inside = project.scope(".svc/x", &Patterns::from(Pattern::all())).unwrap(); + let inside = project.scope(Path::new(".svc/x").unwrap(), &Patterns::from(Pattern::all())).unwrap(); inside.announced().assert_next_wait(); } @@ -7711,23 +7711,23 @@ mod tests { #[moq_clock::test] async fn mount_bounds_the_named_path() { let producer = origin(1).produce(); - let _near = producer.publish("t/x", Route::default()).unwrap(); + let _near = producer.publish(Path::new("t/x").unwrap(), Route::default()).unwrap(); let deep = format!("t/{}", vec!["d"; Path::MAX_PARTS - 1].join("/")); - let _deep = producer.publish(deep.as_str(), Route::default()).unwrap(); + let _deep = producer.publish(Path::new(deep.as_str()).unwrap(), Route::default()).unwrap(); let project = producer - .mount("p1/a/b", "t") + .mount(Path::new("p1/a/b").unwrap(), Path::new("t").unwrap()) .unwrap() - .scope("p1", &Patterns::from(Pattern::all())) + .scope(Path::new("p1").unwrap(), &Patterns::from(Pattern::all())) .unwrap() .consume(); let mut announced = project.announced(); - announced.expect_next_active("a/b/x").await; + announced.expect_next_active(Path::new("a/b/x").unwrap()).await; announced.assert_next_wait(); let over = vec!["d"; Path::MAX_PARTS + 1].join("/"); assert!(matches!( - producer.mount(over.as_str(), "t"), + producer.mount(Path::new(over.as_str()).unwrap(), Path::new("t").unwrap()), Err(Error::BoundsExceeded(_)) )); } @@ -7737,45 +7737,45 @@ mod tests { async fn mount_is_read_only() { let producer = origin(1).produce(); let project = producer - .mount("p1/.svc", ".svc/p1") + .mount(Path::new("p1/.svc").unwrap(), Path::new(".svc/p1").unwrap()) .unwrap() - .scope("p1", &Patterns::from(Pattern::all())) + .scope(Path::new("p1").unwrap(), &Patterns::from(Pattern::all())) .unwrap(); - assert!(matches!(project.create_broadcast(".svc/foo"), Err(Error::Unauthorized))); + assert!(matches!(project.create_broadcast(Path::new(".svc/foo").unwrap()), Err(Error::Unauthorized))); assert!(matches!( - project.dynamic_route(".svc", Route::default()), + project.dynamic_route(Path::new(".svc").unwrap(), Route::default()), Err(Error::Unauthorized) )); assert!(matches!( - project.dynamic_route(".svc/foo", Route::default()), + project.dynamic_route(Path::new(".svc/foo").unwrap(), Route::default()), Err(Error::Unauthorized) )); - project.publish("cam", Route::default()).unwrap(); + project.publish(Path::new("cam").unwrap(), Route::default()).unwrap(); } /// A mount reaches only what the handle already reaches, and mounts never nest. #[moq_clock::test] async fn mount_never_widens_a_scope() { let (producer, _driver) = Producer::new(Config::new(origin(1))); - let project = producer.scope("", &scopes(&["p1"])).unwrap(); - assert!(matches!(project.mount("p1/.svc", ".svc/p1"), Err(Error::Unauthorized))); + let project = producer.scope(Path::new("").unwrap(), &scopes(&["p1"])).unwrap(); + assert!(matches!(project.mount(Path::new("p1/.svc").unwrap(), Path::new(".svc/p1").unwrap()), Err(Error::Unauthorized))); - let mounted = producer.mount("p1/.svc", ".svc/p1").unwrap(); - assert!(matches!(mounted.mount("p1/.svc/x", ".other"), Err(Error::Duplicate))); - assert!(matches!(mounted.mount("p1", ".other"), Err(Error::Duplicate))); + let mounted = producer.mount(Path::new("p1/.svc").unwrap(), Path::new(".svc/p1").unwrap()).unwrap(); + assert!(matches!(mounted.mount(Path::new("p1/.svc/x").unwrap(), Path::new(".other").unwrap()), Err(Error::Duplicate))); + assert!(matches!(mounted.mount(Path::new("p1").unwrap(), Path::new(".other").unwrap()), Err(Error::Duplicate))); // A target through a mount would read the subtree the mount shadows. - assert!(matches!(mounted.mount("p2", "p1/.svc/x"), Err(Error::Duplicate))); - assert!(matches!(mounted.mount("p2", "p1"), Err(Error::Duplicate))); + assert!(matches!(mounted.mount(Path::new("p2").unwrap(), Path::new("p1/.svc/x").unwrap()), Err(Error::Duplicate))); + assert!(matches!(mounted.mount(Path::new("p2").unwrap(), Path::new("p1").unwrap()), Err(Error::Duplicate))); // A mount point on a target would chain through it, in either order. - assert!(matches!(mounted.mount(".svc/p1/x", ".other"), Err(Error::Duplicate))); - assert!(matches!(mounted.mount(".svc", ".other"), Err(Error::Duplicate))); - mounted.mount("p1/.other", ".other/p1").unwrap(); + assert!(matches!(mounted.mount(Path::new(".svc/p1/x").unwrap(), Path::new(".other").unwrap()), Err(Error::Duplicate))); + assert!(matches!(mounted.mount(Path::new(".svc").unwrap(), Path::new(".other").unwrap()), Err(Error::Duplicate))); + mounted.mount(Path::new("p1/.other").unwrap(), Path::new(".other/p1").unwrap()).unwrap(); // Mount points may share a target. - mounted.mount("p2/.svc", ".svc/p1").unwrap(); + mounted.mount(Path::new("p2/.svc").unwrap(), Path::new(".svc/p1").unwrap()).unwrap(); // A mount point overlapping its own target is refused like any other overlap. for (at, target) in [("a", "a/b"), ("a/b", "a"), ("a", "a")] { assert!( - matches!(producer.mount(at, target), Err(Error::Duplicate)), + matches!(producer.mount(Path::new(at).unwrap(), Path::new(target).unwrap()), Err(Error::Duplicate)), "{at} -> {target}" ); } @@ -7787,7 +7787,7 @@ mod tests { let (producer, _driver) = Producer::new(Config::new(origin(1))); for at in ["*", "p1/*", "p1/**", "p1/a*"] { assert!( - matches!(producer.mount(at, ".svc/p1"), Err(Error::InvalidPath(_))), + matches!(producer.mount(Path::new(at).unwrap(), Path::new(".svc/p1").unwrap()), Err(Error::InvalidPath(_))), "{at}" ); } @@ -7800,14 +7800,14 @@ mod tests { async fn mount_egress_counts_under_the_named_path() { let registry = stats::Registry::new(stats::Config::new()); let producer = origin(1).produce(); - let _foo = producer.publish(".svc/p1/foo", Route::default()).unwrap(); + let _foo = producer.publish(Path::new(".svc/p1/foo").unwrap(), Route::default()).unwrap(); let project = mounted(&producer, "p1", &["**"]) - .with_stats(registry.tier(stats::Tier::default()).session("p1")) + .with_stats(registry.tier(stats::Tier::default()).session(Path::new("p1").unwrap())) .with_hidden(true); let mut announced = project.announced(); - announced.expect_next_active(".svc/foo").await; - project.request_broadcast(".svc/foo", None).await.expect("resolves"); + announced.expect_next_active(Path::new(".svc/foo").unwrap()).await; + project.request_broadcast(Path::new(".svc/foo").unwrap(), None).await.expect("resolves"); let mut report = stats::Report::default(); registry.report(&mut report); @@ -7827,19 +7827,19 @@ mod tests { let mut announced = consumer.announced(); let mut opted = consumer.clone().with_hidden(true).announced(); - let hidden = producer.announce(".stats/node", Route::default()).unwrap(); + let hidden = producer.announce(Path::new(".stats/node").unwrap(), Route::default()).unwrap(); announced.assert_next_wait(); - opted.expect_next_active(".stats/node").await; + opted.expect_next_active(Path::new(".stats/node").unwrap()).await; drop(hidden); announced.assert_next_wait(); - opted.expect_next_ended(".stats/node").await; + opted.expect_next_ended(Path::new(".stats/node").unwrap()).await; } #[moq_clock::test] async fn a_replayed_route_retracted_before_delivery_cancels() { let producer = origin(1).produce(); - let alice = producer.announce("alice", Route::default()).unwrap(); + let alice = producer.announce(Path::new("alice").unwrap(), Route::default()).unwrap(); let mut announced = producer.consume().announced(); drop(alice); announced.assert_next_wait(); @@ -7854,35 +7854,35 @@ mod tests { let mut peer = consumer.clone().excluding(Hop::UNKNOWN).announced(); // Created but not announced: invisible to local and peer cursors alike. - let broadcast = producer.create_broadcast("room/alice").unwrap(); + let broadcast = producer.create_broadcast(Path::new("room/alice").unwrap()).unwrap(); announced.assert_next_wait(); peer.assert_next_wait(); broadcast.announce(Route::default().with_cost(3)).unwrap(); - assert_eq!(announced.expect_next_active("room/alice").await.cost, Cost::new(3)); - assert_eq!(peer.expect_next_active("room/alice").await.cost, Cost::new(3)); + assert_eq!(announced.expect_next_active(Path::new("room/alice").unwrap()).await.cost, Cost::new(3)); + assert_eq!(peer.expect_next_active(Path::new("room/alice").unwrap()).await.cost, Cost::new(3)); // Announcing again re-prices in place. broadcast.announce(Route::default().with_cost(1)).unwrap(); - assert_eq!(announced.expect_next_active("room/alice").await.cost, Cost::new(1)); - assert_eq!(peer.expect_next_active("room/alice").await.cost, Cost::new(1)); + assert_eq!(announced.expect_next_active(Path::new("room/alice").unwrap()).await.cost, Cost::new(1)); + assert_eq!(peer.expect_next_active(Path::new("room/alice").unwrap()).await.cost, Cost::new(1)); // Off the air: the route retracts for everyone and the path is unroutable. broadcast.unannounce(); - announced.expect_next_ended("room/alice").await; - peer.expect_next_ended("room/alice").await; + announced.expect_next_ended(Path::new("room/alice").unwrap()).await; + peer.expect_next_ended(Path::new("room/alice").unwrap()).await; broadcast.unannounce(); announced.assert_next_wait(); - let err = consumer.request_broadcast("room/alice", None).await.err().unwrap(); + let err = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.err().unwrap(); assert!(matches!(err, Error::Unroutable)); // Back on the air, then the end of the broadcast retracts for good. broadcast.announce(Route::default()).unwrap(); - announced.expect_next_active("room/alice").await; - peer.expect_next_active("room/alice").await; + announced.expect_next_active(Path::new("room/alice").unwrap()).await; + peer.expect_next_active(Path::new("room/alice").unwrap()).await; broadcast.close(); - announced.expect_next_ended("room/alice").await; - peer.expect_next_ended("room/alice").await; + announced.expect_next_ended(Path::new("room/alice").unwrap()).await; + peer.expect_next_ended(Path::new("room/alice").unwrap()).await; assert!(matches!(broadcast.announce(Route::default()), Err(Error::Closed))); announced.assert_next_wait(); } @@ -7893,24 +7893,24 @@ mod tests { let consumer = producer.consume(); let mut announced = consumer.announced(); - let broadcast = producer.create_broadcast("room/alice").unwrap(); + let broadcast = producer.create_broadcast(Path::new("room/alice").unwrap()).unwrap(); let clone = broadcast.clone(); broadcast.announce(Route::default()).unwrap(); - announced.expect_next_active("room/alice").await; + announced.expect_next_active(Path::new("room/alice").unwrap()).await; // A clone keeps the broadcast, and its advertisement, alive. drop(broadcast); announced.assert_next_wait(); drop(clone); - announced.expect_next_ended("room/alice").await; + announced.expect_next_ended(Path::new("room/alice").unwrap()).await; } #[moq_clock::test] async fn publish_creates_and_announces_together() { let producer = origin(1).produce(); let mut announced = producer.consume().announced(); - let _broadcast = producer.publish("room/alice", Route::default()).unwrap(); - announced.expect_next_active("room/alice").await; + let _broadcast = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + announced.expect_next_active(Path::new("room/alice").unwrap()).await; } #[moq_clock::test] @@ -7924,29 +7924,29 @@ mod tests { #[moq_clock::test] async fn announce_replays_to_late_cursor() { let producer = origin(1).produce(); - let _a = producer.announce("room/alice", Route::default()).unwrap(); - let _b = producer.announce("room/bob", Route::default()).unwrap(); + let _a = producer.announce(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let _b = producer.announce(Path::new("room/bob").unwrap(), Route::default()).unwrap(); let mut announced = producer.consume().announced(); // Replay follows the table traversal order. - announced.expect_next_active("room/alice").await; - announced.expect_next_active("room/bob").await; + announced.expect_next_active(Path::new("room/alice").unwrap()).await; + announced.expect_next_active(Path::new("room/bob").unwrap()).await; announced.assert_next_wait(); } #[moq_clock::test] async fn announce_keeps_its_prefix_under_a_producer_scope() { let producer = origin(1).produce(); - let scoped = producer.scope("", &scopes(&["room"])).unwrap(); + let scoped = producer.scope(Path::new("").unwrap(), &scopes(&["room"])).unwrap(); // Prefix advertisements stay prefixes. The scope filters requests locally. - let _a = scoped.announce("", Route::default()).unwrap(); + let _a = scoped.announce(Path::new("").unwrap(), Route::default()).unwrap(); let mut announced = producer.consume().announced(); - announced.expect_next_active("").await; + announced.expect_next_active(Path::new("").unwrap()).await; // Disjoint prefixes cannot be claimed at all. assert!(matches!( - scoped.announce("other", Route::default()), + scoped.announce(Path::new("other").unwrap(), Route::default()), Err(Error::Unauthorized) )); } @@ -7954,24 +7954,24 @@ mod tests { #[moq_clock::test] async fn cursor_keeps_an_overlapping_prefix_above_its_scope() { let producer = origin(1).produce(); - let _a = producer.announce("", Route::default()).unwrap(); + let _a = producer.announce(Path::new("").unwrap(), Route::default()).unwrap(); - let consumer = producer.consume().scope("", &scopes(&["room"])).unwrap(); + let consumer = producer.consume().scope(Path::new("").unwrap(), &scopes(&["room"])).unwrap(); let mut announced = consumer.announced(); - announced.expect_next_active("").await; + announced.expect_next_active(Path::new("").unwrap()).await; } #[moq_clock::test] async fn cursor_root_strips_prefix() { let producer = origin(1).produce(); - let _a = producer.announce("room/alice", Route::default()).unwrap(); + let _a = producer.announce(Path::new("room/alice").unwrap(), Route::default()).unwrap(); let consumer = producer .consume() - .scope("room", &Patterns::from(Pattern::all())) + .scope(Path::new("room").unwrap(), &Patterns::from(Pattern::all())) .unwrap(); let mut announced = consumer.announced(); - announced.expect_next_active("alice").await; + announced.expect_next_active(Path::new("alice").unwrap()).await; } #[moq_clock::test] @@ -7980,26 +7980,26 @@ mod tests { let mut announced = producer.consume().announced(); let expensive = producer - .announce("room", Route::default().with_hops(hops(&[10])).with_cost(5)) + .announce(Path::new("room").unwrap(), Route::default().with_hops(hops(&[10])).with_cost(5)) .unwrap(); - let route = announced.expect_next_active("room").await; + let route = announced.expect_next_active(Path::new("room").unwrap()).await; assert_eq!(route.cost, Cost::new(5)); // A cheaper route for the same prefix takes over in place. let cheap = producer - .announce("room", Route::default().with_hops(hops(&[20])).with_cost(1)) + .announce(Path::new("room").unwrap(), Route::default().with_hops(hops(&[20])).with_cost(1)) .unwrap(); - let route = announced.expect_next_active("room").await; + let route = announced.expect_next_active(Path::new("room").unwrap()).await; assert_eq!(route.cost, Cost::new(1)); // Losing the winner falls back to the survivor, still in place. drop(cheap); - let route = announced.expect_next_active("room").await; + let route = announced.expect_next_active(Path::new("room").unwrap()).await; assert_eq!(route.cost, Cost::new(5)); // Losing the last retracts. drop(expensive); - announced.expect_next_ended("room").await; + announced.expect_next_ended(Path::new("room").unwrap()).await; } /// Pinned so `spreadHash` in `js/net` picks the same pool member for a path. @@ -8025,14 +8025,14 @@ mod tests { let _pool: Vec = order .map(|id| { producer - .dynamic_route("pool", Route::default().with_hops(hops(&[id])).with_cost(3)) + .dynamic_route(Path::new("pool").unwrap(), Route::default().with_hops(hops(&[id])).with_cost(3)) .unwrap() }) .collect(); let table = producer.shared.read(); (0..PATHS) .map(|i| { - let path = Path::new(&format!("pool/job-{i}")).to_owned(); + let path = Path::new(&format!("pool/job-{i}")).unwrap().to_owned(); let entry = table .best_route(&path.as_path(), Horizon::default(), &HashSet::new(), |_| true) .expect("the pool serves every path"); @@ -8074,13 +8074,13 @@ mod tests { let mut route = Route::default().with_hops(hops(&[10])); route.epoch = epoch.clone(); - let old = producer.announce("room", route.clone()).unwrap(); - let first = announced.expect_next_active("room").await; + let old = producer.announce(Path::new("room").unwrap(), route.clone()).unwrap(); + let first = announced.expect_next_active(Path::new("room").unwrap()).await; assert_eq!(first.hops.as_slice(), hops(&[10]).as_slice()); - let _new = producer.announce("room", route).unwrap(); + let _new = producer.announce(Path::new("room").unwrap(), route).unwrap(); match epoch { - None => assert_eq!(announced.expect_next_restarted("room").await.hops, hops(&[10])), + None => assert_eq!(announced.expect_next_restarted(Path::new("room").unwrap()).await.hops, hops(&[10])), Some(_) => announced.assert_next_wait(), } @@ -8095,8 +8095,8 @@ mod tests { async fn a_reprice_is_an_update() { let producer = origin(1).produce(); let mut announced = producer.consume().announced(); - let route = producer.dynamic_route("room", Route::default().with_cost(3)).unwrap(); - announced.expect_next_active("room").await; + let route = producer.dynamic_route(Path::new("room").unwrap(), Route::default().with_cost(3)).unwrap(); + announced.expect_next_active(Path::new("room").unwrap()).await; route.update_route(Route::default().with_cost(5)).unwrap(); match announced.next().await.expect("no next") { @@ -8116,9 +8116,9 @@ mod tests { let producer = origin(1).produce(); let mut announced = producer.consume().announced(); let route = producer - .dynamic_route("room", Route::default().with_auth(first.clone())) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_auth(first.clone())) .unwrap(); - assert_eq!(announced.expect_next_active("room").await.auth, Some(first)); + assert_eq!(announced.expect_next_active(Path::new("room").unwrap()).await.auth, Some(first)); route.update_route(Route::default().with_auth(second.clone())).unwrap(); match announced.next().await.expect("no next") { @@ -8145,16 +8145,16 @@ mod tests { let mut announced = consumer.announced(); let peer = producer.clone().with_link(Link::Peer); let old = peer - .dynamic_route("pool/job-0", Route::default().with_hops(hops(&[11]))) + .dynamic_route(Path::new("pool/job-0").unwrap(), Route::default().with_hops(hops(&[11]))) .unwrap(); - announced.expect_next_active("pool/job-0").await; + announced.expect_next_active(Path::new("pool/job-0").unwrap()).await; let new = peer - .dynamic_route("pool/job-0", Route::default().with_hops(hops(&[10]))) + .dynamic_route(Path::new("pool/job-0").unwrap(), Route::default().with_hops(hops(&[10]))) .unwrap(); announced.assert_next_wait(); - let pending = consumer.request_broadcast("pool/job-0", None); + let pending = consumer.request_broadcast(Path::new("pool/job-0").unwrap(), None); let request = queued(&old).await; let first = broadcast::Info::new().produce(); request.accept(&first); @@ -8162,9 +8162,9 @@ mod tests { assert!(new.poll_requested_broadcast(&kio::Waiter::noop()).is_pending()); drop(old); - assert_eq!(announced.expect_next_restarted("pool/job-0").await.hops, hops(&[10])); + assert_eq!(announced.expect_next_restarted(Path::new("pool/job-0").unwrap()).await.hops, hops(&[10])); - let pending = consumer.request_broadcast("pool/job-0", None); + let pending = consumer.request_broadcast(Path::new("pool/job-0").unwrap(), None); let request = queued(&new).await; let second = broadcast::Info::new().produce(); request.accept(&second); @@ -8187,19 +8187,19 @@ mod tests { let consumer = producer.consume(); let mut announced = consumer.announced(); let _old = producer - .dynamic_route("pool/job-0", Route::default().with_hops(hops(&[old_hop]))) + .dynamic_route(Path::new("pool/job-0").unwrap(), Route::default().with_hops(hops(&[old_hop]))) .unwrap(); - announced.expect_next_active("pool/job-0").await; + announced.expect_next_active(Path::new("pool/job-0").unwrap()).await; let new = producer - .dynamic_route("pool/job-0", Route::default().with_hops(hops(&[new_hop]))) + .dynamic_route(Path::new("pool/job-0").unwrap(), Route::default().with_hops(hops(&[new_hop]))) .unwrap(); assert_eq!( - announced.expect_next_restarted("pool/job-0").await.hops, + announced.expect_next_restarted(Path::new("pool/job-0").unwrap()).await.hops, hops(&[new_hop]) ); - let pending = consumer.request_broadcast("pool/job-0", None); + let pending = consumer.request_broadcast(Path::new("pool/job-0").unwrap(), None); queued(&new).await.accept(broadcast::Info::new().produce()); pending.await.expect("the replacement resolves"); } @@ -8217,9 +8217,9 @@ mod tests { let claims = producer.clone(); let claim = move |prefix: &str, scope: &str, hop: u64, cost: u64| { claims - .scope("", &scopes(&[scope])) + .scope(Path::new("").unwrap(), &scopes(&[scope])) .unwrap() - .dynamic_route(prefix, Route::default().with_hops(hops(&[hop])).with_cost(cost)) + .dynamic_route(Path::new(prefix).unwrap(), Route::default().with_hops(hops(&[hop])).with_cost(cost)) .unwrap() }; (producer, claim) @@ -8229,7 +8229,7 @@ mod tests { /// the requester's broadcast. #[cfg(feature = "async")] async fn hold(consumer: &Consumer, path: &str, server: &Dynamic) -> (broadcast::Producer, broadcast::Consumer) { - let pending = consumer.request_broadcast(path, None); + let pending = consumer.request_broadcast(Path::new(path).unwrap(), None); let answer = broadcast::Info::new().produce(); queued(server).await.accept(&answer); (answer, pending.await.expect("the request resolves")) @@ -8250,7 +8250,7 @@ mod tests { for _ in 0..20 { moq_clock::sim::yield_now().await; } - announced.expect_next_restarted(prefix).await + announced.expect_next_restarted(Path::new(prefix).unwrap()).await } /// A held path moving restarts a scoped cursor whose own winner stayed, even @@ -8266,10 +8266,10 @@ mod tests { let chat = claim("room", "room/chat", 12, 1); let mut video = consumer .clone() - .scope("", &scopes(&["room/video"])) + .scope(Path::new("").unwrap(), &scopes(&["room/video"])) .unwrap() .announced(); - assert_eq!(video.expect_next_active("room").await.cost, Cost::new(5)); + assert_eq!(video.expect_next_active(Path::new("room").unwrap()).await.cost, Cost::new(5)); let _sticky = hold(&consumer, "room/video/b", &b).await; drop(chat); @@ -8288,14 +8288,14 @@ mod tests { let _w = claim("pool", "pool/other", 10, 2); let r = claim("pool", "pool/job", 11, 5); let mut announced = consumer.announced(); - assert_eq!(announced.expect_next_active("pool").await.cost, Cost::new(2)); + assert_eq!(announced.expect_next_active(Path::new("pool").unwrap()).await.cost, Cost::new(2)); let (_answer, sticky) = hold(&consumer, "pool/job", &r).await; let _y = claim("pool", "pool/other", 12, 1); - assert_eq!(announced.expect_next_restarted("pool").await.cost, Cost::new(1)); + assert_eq!(announced.expect_next_restarted(Path::new("pool").unwrap()).await.cost, Cost::new(1)); quiet(&mut announced).await; // The path still resolves through the front's route, so the re-request joins it. - let joined = consumer.request_broadcast("pool/job", None).await.unwrap(); + let joined = consumer.request_broadcast(Path::new("pool/job").unwrap(), None).await.unwrap(); assert!(joined.is_clone(&sticky)); let _z = claim("pool", "pool/job", 13, 3); @@ -8313,18 +8313,18 @@ mod tests { let a = claim("room", "room/job", 10, 5); let _b = claim("room", "room/other", 11, 2); let mut announced = consumer.announced(); - assert_eq!(announced.expect_next_active("room").await.cost, Cost::new(2)); + assert_eq!(announced.expect_next_active(Path::new("room").unwrap()).await.cost, Cost::new(2)); let _sticky = hold(&consumer, "room/job", &a).await; let c = producer - .dynamic_route("room", Route::default().with_hops(hops(&[12])).with_cost(1)) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_hops(hops(&[12])).with_cost(1)) .unwrap(); - assert_eq!(announced.expect_next_restarted("room").await.cost, Cost::new(1)); + assert_eq!(announced.expect_next_restarted(Path::new("room").unwrap()).await.cost, Cost::new(1)); quiet(&mut announced).await; c.update_route(Route::default().with_hops(hops(&[12])).with_cost(3)) .unwrap(); - assert_eq!(announced.expect_next_restarted("room").await.cost, Cost::new(2)); + assert_eq!(announced.expect_next_restarted(Path::new("room").unwrap()).await.cost, Cost::new(2)); quiet(&mut announced).await; } @@ -8338,12 +8338,12 @@ mod tests { let a = claim("room", "room", 10, 5); let b = claim("room", "room", 11, 9); let mut announced = consumer.announced(); - assert_eq!(announced.expect_next_active("room").await.cost, Cost::new(5)); + assert_eq!(announced.expect_next_active(Path::new("room").unwrap()).await.cost, Cost::new(5)); let _sticky = hold(&consumer, "room/job", &a).await; b.update_route(Route::default().with_hops(hops(&[11])).with_cost(3)) .unwrap(); - assert_eq!(announced.expect_next_restarted("room").await.cost, Cost::new(3)); + assert_eq!(announced.expect_next_restarted(Path::new("room").unwrap()).await.cost, Cost::new(3)); quiet(&mut announced).await; } @@ -8351,14 +8351,14 @@ mod tests { async fn exclude_hides_routes_through_the_peer() { let producer = origin(1).produce(); let _a = producer - .announce("room", Route::default().with_hops(hops(&[7]))) + .announce(Path::new("room").unwrap(), Route::default().with_hops(hops(&[7]))) .unwrap(); let mut hidden = producer.consume().excluding(origin(7)).announced(); hidden.assert_next_wait(); let mut visible = producer.consume().excluding(origin(8)).announced(); - visible.expect_next_active("room").await; + visible.expect_next_active(Path::new("room").unwrap()).await; } #[moq_clock::test] @@ -8366,14 +8366,14 @@ mod tests { let producer = origin(1).produce(); let assigned = origin(777); let _echoed = producer - .announce("echoed", Route::default().with_hops(hops(&[0])).with_via(assigned)) + .announce(Path::new("echoed").unwrap(), Route::default().with_hops(hops(&[0])).with_via(assigned)) .unwrap(); let _local = producer - .announce("local", Route::default().with_hops(hops(&[10]))) + .announce(Path::new("local").unwrap(), Route::default().with_hops(hops(&[10]))) .unwrap(); let mut hidden = producer.consume().excluding(assigned).announced(); - hidden.expect_next_active("local").await; + hidden.expect_next_active(Path::new("local").unwrap()).await; hidden.assert_next_wait(); } @@ -8383,16 +8383,16 @@ mod tests { let mut announced = producer.consume().announced(); let _anonymous = producer - .announce("room", Route::default().with_hops(hops(&[0])).with_cost(1)) + .announce(Path::new("room").unwrap(), Route::default().with_hops(hops(&[0])).with_cost(1)) .unwrap(); - let route = announced.expect_next_active("room").await; + let route = announced.expect_next_active(Path::new("room").unwrap()).await; assert!(route.is_anonymous()); assert_eq!(route.cost, Cost::new(1)); let _identified = producer - .announce("room", Route::default().with_hops(hops(&[10])).with_cost(5)) + .announce(Path::new("room").unwrap(), Route::default().with_hops(hops(&[10])).with_cost(5)) .unwrap(); - let route = announced.expect_next_active("room").await; + let route = announced.expect_next_active(Path::new("room").unwrap()).await; assert!(!route.is_anonymous()); assert_eq!(route.cost, Cost::new(5)); } @@ -8403,15 +8403,15 @@ mod tests { let mut announced = producer.consume().announced(); let expensive = producer - .announce("room", Route::default().with_hops(hops(&[0])).with_cost(5)) + .announce(Path::new("room").unwrap(), Route::default().with_hops(hops(&[0])).with_cost(5)) .unwrap(); - let route = announced.expect_next_active("room").await; + let route = announced.expect_next_active(Path::new("room").unwrap()).await; assert_eq!(route.cost, Cost::new(5)); let _cheap = producer - .announce("room", Route::default().with_hops(hops(&[0, 7])).with_cost(1)) + .announce(Path::new("room").unwrap(), Route::default().with_hops(hops(&[0, 7])).with_cost(1)) .unwrap(); - let route = announced.expect_next_active("room").await; + let route = announced.expect_next_active(Path::new("room").unwrap()).await; assert!(route.is_anonymous()); assert_eq!(route.cost, Cost::new(1)); @@ -8426,19 +8426,19 @@ mod tests { let _anonymous = producer .announce( - "room", + Path::new("room").unwrap(), Route::default() .with_hops(hops(&[0, 7])) .with_cost(1) .with_via(origin(7)), ) .unwrap(); - announced.expect_next_active("room").await; + announced.expect_next_active(Path::new("room").unwrap()).await; let _identified = producer - .announce("room", Route::default().with_hops(hops(&[10, 20])).with_cost(5)) + .announce(Path::new("room").unwrap(), Route::default().with_hops(hops(&[10, 20])).with_cost(5)) .unwrap(); - let route = announced.expect_next_active("room").await; + let route = announced.expect_next_active(Path::new("room").unwrap()).await; assert!(!route.is_anonymous()); assert_eq!(route.cost, Cost::new(5)); } @@ -8450,13 +8450,13 @@ mod tests { let consumer = producer.consume(); let anonymous = producer - .dynamic_route("room", Route::default().with_hops(hops(&[0])).with_cost(1)) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_hops(hops(&[0])).with_cost(1)) .unwrap(); let identified = producer - .dynamic_route("room", Route::default().with_hops(hops(&[10])).with_cost(5)) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_hops(hops(&[10])).with_cost(5)) .unwrap(); - let _pending = consumer.request_broadcast("room/alice", None); + let _pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); let request = queued(&identified).await; assert_eq!(request.path().as_str(), "room/alice"); assert!( @@ -8474,13 +8474,13 @@ mod tests { let demoted = producer .clone() .with_preference(Preference::new(-1)) - .dynamic_route("room", Route::default().with_hops(hops(&[10])).with_cost(1)) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_hops(hops(&[10])).with_cost(1)) .unwrap(); let unranked = producer - .dynamic_route("room", Route::default().with_hops(hops(&[11])).with_cost(5)) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_hops(hops(&[11])).with_cost(5)) .unwrap(); - let _pending = consumer.request_broadcast("room/alice", None); + let _pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); let request = queued(&unranked).await; assert_eq!(request.path().as_str(), "room/alice"); assert!( @@ -8494,11 +8494,11 @@ mod tests { let producer = origin(1).produce(); let mut announced = producer.consume().announced(); - let announcement = producer.announce("room", Route::default()).unwrap(); - announced.expect_next_active("room").await; + let announcement = producer.announce(Path::new("room").unwrap(), Route::default()).unwrap(); + announced.expect_next_active(Path::new("room").unwrap()).await; announcement.update(Route::default().with_cost(9)).unwrap(); - let route = announced.expect_next_active("room").await; + let route = announced.expect_next_active(Path::new("room").unwrap()).await; assert_eq!(route.cost, Cost::new(9)); } @@ -8509,22 +8509,22 @@ mod tests { let mut announced = producer.consume().announced(); let dynamic = producer - .dynamic_route("room", Route::default().with_epoch(epoch()).with_cost(5)) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_epoch(epoch()).with_cost(5)) .unwrap(); - announced.expect_next_active("room").await; + announced.expect_next_active(Path::new("room").unwrap()).await; dynamic.update_route(dynamic.route().with_cost(1)).unwrap(); - let route = announced.expect_next_active("room").await; + let route = announced.expect_next_active(Path::new("room").unwrap()).await; assert_eq!((route.epoch, route.cost), (Some(epoch()), Cost::new(1))); assert_eq!(dynamic.route().cost, Cost::new(1)); - let broadcast = producer.create_broadcast("lobby").unwrap(); + let broadcast = producer.create_broadcast(Path::new("lobby").unwrap()).unwrap(); assert!(broadcast.route().is_none(), "not announced yet"); broadcast .announce(Route::default().with_epoch(epoch()).with_cost(5)) .unwrap(); - announced.expect_next_active("lobby").await; + announced.expect_next_active(Path::new("lobby").unwrap()).await; broadcast.announce(broadcast.route().unwrap().with_cost(1)).unwrap(); - let route = announced.expect_next_active("lobby").await; + let route = announced.expect_next_active(Path::new("lobby").unwrap()).await; assert_eq!((route.epoch, route.cost), (Some(epoch()), Cost::new(1))); broadcast.unannounce(); assert!(broadcast.route().is_none(), "withdrawn"); @@ -8535,15 +8535,15 @@ mod tests { let producer = origin(1).produce(); let mut announced = producer.consume().announced(); - let announcement = producer.announce("room", Route::default()).unwrap(); - announced.expect_next_active("room").await; + let announcement = producer.announce(Path::new("room").unwrap(), Route::default()).unwrap(); + announced.expect_next_active(Path::new("room").unwrap()).await; // Reprice, then retract before the consumer observes the reprice: the // pending metadata update must not cancel the retraction the delivered // announce still owes. announcement.update(Route::default().with_cost(9)).unwrap(); drop(announcement); - announced.expect_next_ended("room").await; + announced.expect_next_ended(Path::new("room").unwrap()).await; announced.assert_next_wait(); } @@ -8552,15 +8552,15 @@ mod tests { let producer = origin(1).produce(); // Broad and cheap; narrow and expensive. Both present relative to a cursor // rooted below them, and the narrow one is what a request there resolves. - let _broad = producer.announce("room", Route::default().with_cost(1)).unwrap(); - let _narrow = producer.announce("room/alice", Route::default().with_cost(9)).unwrap(); + let _broad = producer.announce(Path::new("room").unwrap(), Route::default().with_cost(1)).unwrap(); + let _narrow = producer.announce(Path::new("room/alice").unwrap(), Route::default().with_cost(9)).unwrap(); let consumer = producer .consume() - .scope("room/alice", &Patterns::from(Pattern::all())) + .scope(Path::new("room/alice").unwrap(), &Patterns::from(Pattern::all())) .unwrap(); let mut announced = consumer.announced(); - let route = announced.expect_next_active("").await; + let route = announced.expect_next_active(Path::new("").unwrap()).await; assert_eq!(route.cost, Cost::new(9)); announced.assert_next_wait(); } @@ -8569,13 +8569,13 @@ mod tests { #[cfg(feature = "async")] async fn capture_change_retracts_before_reannouncing_a_presented_prefix() { let producer = origin(1).produce(); - let _broad = producer.announce("room", Route::default()).unwrap(); - let exact = producer.announce("room/alice", Route::default()).unwrap(); + let _broad = producer.announce(Path::new("room").unwrap(), Route::default()).unwrap(); + let exact = producer.announce(Path::new("room/alice").unwrap(), Route::default()).unwrap(); let consumer = producer .consume() - .scope("", &Patterns::from("room/*".parse::().unwrap())) + .scope(Path::new("").unwrap(), &Patterns::from("room/*".parse::().unwrap())) .unwrap() - .scope("room/alice", &Patterns::from(Pattern::all())) + .scope(Path::new("room/alice").unwrap(), &Patterns::from(Pattern::all())) .unwrap(); let mut announced = consumer.announced(); @@ -8605,11 +8605,11 @@ mod tests { let consumer = producer.consume(); // Asking before anything is announced parks instead of failing Unroutable. - let mut resolving = Box::pin(consumer.routed_broadcast("room/alice")); + let mut resolving = Box::pin(consumer.routed_broadcast(Path::new("room/alice").unwrap())); assert!((&mut resolving).now_or_never().is_none()); // Creating is not announcing: still parked. - let broadcast = producer.create_broadcast("room/alice").unwrap(); + let broadcast = producer.create_broadcast(Path::new("room/alice").unwrap()).unwrap(); for _ in 0..20 { moq_clock::sim::yield_now().await; } @@ -8631,22 +8631,22 @@ mod tests { let mut announced = consumer.announced(); let _local = producer - .publish("room/alice", Route::default().with_epoch(epoch()).with_cost(5)) + .publish(Path::new("room/alice").unwrap(), Route::default().with_epoch(epoch()).with_cost(5)) .unwrap(); - assert_eq!(announced.expect_next_active("room/alice").await.cost, Cost::new(5)); + assert_eq!(announced.expect_next_active(Path::new("room/alice").unwrap()).await.cost, Cost::new(5)); let server = producer .dynamic_route( - "room/alice", + Path::new("room/alice").unwrap(), Route::default().with_epoch(epoch()).with_hops(hops(&[10])).with_cost(1), ) .unwrap(); - let route = announced.expect_next_active("room/alice").await; + let route = announced.expect_next_active(Path::new("room/alice").unwrap()).await; assert_eq!(route.cost, Cost::new(1)); assert_eq!(route.hops, hops(&[10])); // The request goes upstream rather than to the local broadcast. - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); let request = queued(&server).await; let upstream = broadcast::Info::new().produce(); request.accept(&upstream); @@ -8662,13 +8662,13 @@ mod tests { let consumer = producer.consume(); let _epoched = producer - .publish("room/alice", Route::default().with_epoch(epoch())) + .publish(Path::new("room/alice").unwrap(), Route::default().with_epoch(epoch())) .unwrap(); - let _plain = producer.publish("room/bob", Route::default()).unwrap(); + let _plain = producer.publish(Path::new("room/bob").unwrap(), Route::default()).unwrap(); - let alice = consumer.request_broadcast("room/alice", None).await.unwrap(); + let alice = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.unwrap(); assert_eq!(alice.info().epoch, Some(epoch())); - let bob = consumer.request_broadcast("room/bob", None).await.unwrap(); + let bob = consumer.request_broadcast(Path::new("room/bob").unwrap(), None).await.unwrap(); assert_eq!(bob.info().epoch, None); } @@ -8681,16 +8681,16 @@ mod tests { let consumer = producer.consume(); let _local = producer - .publish("room/alice", Route::default().with_epoch(epoch()).with_cost(5)) + .publish(Path::new("room/alice").unwrap(), Route::default().with_epoch(epoch()).with_cost(5)) .unwrap(); let first = consumer - .request_broadcast("room/alice", None) + .request_broadcast(Path::new("room/alice").unwrap(), None) .await .expect("resolves locally"); let server = producer .dynamic_route( - "room/alice", + Path::new("room/alice").unwrap(), Route::default().with_epoch(epoch()).with_hops(hops(&[10])).with_cost(1), ) .unwrap(); @@ -8698,7 +8698,7 @@ mod tests { let upstream = broadcast::Info::new().produce(); request.accept(&upstream); - let second = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let second = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); assert!(first.is_clone(&second), "the newcomer joins the front"); } @@ -8720,10 +8720,10 @@ mod tests { async fn a_front_lists_its_source() { let producer = origin(1).produce(); let consumer = producer.consume(); - let source = producer.publish("room/alice", Route::default()).unwrap(); + let source = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); let video = source.create_track("video", None).unwrap(); - let front = consumer.request_broadcast("room/alice", None).await.unwrap(); + let front = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.unwrap(); let mut tracks = front.tracks().unwrap(); assert_eq!(listed(&mut tracks).await, "+video"); assert_eq!(listed(&mut tracks).await, "synced"); @@ -8744,12 +8744,12 @@ mod tests { async fn a_front_ends_its_listing_with_its_sources() { let producer = origin(1).produce(); let consumer = producer.consume(); - let source = producer.publish("room/alice", Route::default()).unwrap(); + let source = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); let lister = source.dynamic().lister().unwrap(); lister.add("video", crate::track::Info::default()).unwrap(); lister.synced(); - let front = consumer.request_broadcast("room/alice", None).await.unwrap(); + let front = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.unwrap(); let mut tracks = front.tracks().unwrap(); assert_eq!(listed(&mut tracks).await, "+video"); assert_eq!(listed(&mut tracks).await, "synced"); @@ -8767,12 +8767,12 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let local = producer - .publish("room/alice", Route::default().with_epoch(epoch()).with_cost(5)) + .publish(Path::new("room/alice").unwrap(), Route::default().with_epoch(epoch()).with_cost(5)) .unwrap(); let _a = local.create_track("a", None).unwrap(); let _b = local.create_track("b", None).unwrap(); - let front = consumer.request_broadcast("room/alice", None).await.unwrap(); + let front = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.unwrap(); let mut tracks = front.tracks().unwrap(); assert_eq!(listed(&mut tracks).await, "+a"); assert_eq!(listed(&mut tracks).await, "+b"); @@ -8780,7 +8780,7 @@ mod tests { let server = producer .dynamic_route( - "room/alice", + Path::new("room/alice").unwrap(), Route::default().with_epoch(epoch()).with_hops(hops(&[10])).with_cost(1), ) .unwrap(); @@ -8800,8 +8800,8 @@ mod tests { async fn a_front_through_a_covering_prefix_lists_nothing() { let producer = origin(1).produce(); let consumer = producer.consume(); - let server = producer.dynamic_route("room", Route::default()).unwrap(); - let pending = consumer.request_broadcast("room/alice", None); + let server = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); + let pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); let upstream = broadcast::Info::new().produce(); let _video = upstream.create_track("video", None).unwrap(); queued(&server).await.accept(&upstream); @@ -8820,11 +8820,11 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); - let _local = producer.publish("room/alice", Route::default()).unwrap(); - let server = producer.dynamic_route("room/alice", Route::default()).unwrap(); + let _local = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let server = producer.dynamic_route(Path::new("room/alice").unwrap(), Route::default()).unwrap(); // Were the claim to win, the request would park on its handler forever. - let resolved = moq_clock::timeout(Duration::from_secs(1), consumer.request_broadcast("room/alice", None)) + let resolved = moq_clock::timeout(Duration::from_secs(1), consumer.request_broadcast(Path::new("room/alice").unwrap(), None)) .await .expect("the newer hopless route won the tie") .expect("resolves"); @@ -8839,7 +8839,7 @@ mod tests { let registry = stats::Registry::new(stats::Config::new()); let producer = origin(1) .produce() - .with_stats(registry.tier(stats::Tier::default()).session("root")); + .with_stats(registry.tier(stats::Tier::default()).session(Path::new("root").unwrap())); let announces = || { registry .snapshot() @@ -8850,7 +8850,7 @@ mod tests { .unwrap_or_default() }; - let broadcast = producer.create_broadcast("room/alice").unwrap(); + let broadcast = producer.create_broadcast(Path::new("room/alice").unwrap()).unwrap(); assert_eq!(announces(), (0, 0), "a hidden broadcast is not announced"); broadcast.announce(Route::default()).unwrap(); broadcast @@ -8877,17 +8877,17 @@ mod tests { let server = producer .dynamic_route( - "room/alice", + Path::new("room/alice").unwrap(), Route::default().with_epoch(epoch()).with_hops(hops(&[10])).with_cost(2), ) .unwrap(); - announced.expect_next_active("room/alice").await; + announced.expect_next_active(Path::new("room/alice").unwrap()).await; let _local = producer - .publish("room/alice", Route::default().with_epoch(epoch()).with_cost(2)) + .publish(Path::new("room/alice").unwrap(), Route::default().with_epoch(epoch()).with_cost(2)) .unwrap(); - assert!(announced.expect_next_active("room/alice").await.hops.is_empty()); + assert!(announced.expect_next_active(Path::new("room/alice").unwrap()).await.hops.is_empty()); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); assert_eq!(resolved.info().path.as_str(), "room/alice"); for _ in 0..20 { moq_clock::sim::yield_now().await; @@ -8903,11 +8903,11 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); - let broadcast = producer.publish("room/alice", Route::default()).unwrap(); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let broadcast = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); broadcast.unannounce(); - let err = consumer.request_broadcast("room/alice", None).await.err().unwrap(); + let err = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.err().unwrap(); assert!(matches!(err, Error::Unroutable), "joined a retracted front: {err}"); settle(|| resolved.is_closed()).await; assert!(!broadcast.consume().is_closed(), "the broadcast itself lives on"); @@ -8915,7 +8915,7 @@ mod tests { // Announcing again serves a fresh front. broadcast.announce(Route::default()).unwrap(); let again = consumer - .request_broadcast("room/alice", None) + .request_broadcast(Path::new("room/alice").unwrap(), None) .await .expect("resolves again"); assert!(!again.is_clone(&resolved)); @@ -8930,9 +8930,9 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); - let broadcast = producer.publish("room/alice", Route::default()).unwrap(); + let broadcast = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); let mut dynamic = broadcast.dynamic(); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); let track = resolved.track("video").unwrap(); let subscribing = moq_clock::sim::spawn(async move { track.subscribe(None).await }); let request = moq_clock::timeout(Duration::from_secs(1), dynamic.requested_track()) @@ -8962,9 +8962,9 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let server = producer - .dynamic_route("room/alice", Route::default().with_hops(hops(&[10]))) + .dynamic_route(Path::new("room/alice").unwrap(), Route::default().with_hops(hops(&[10]))) .unwrap(); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); let upstream = broadcast::Info::new().produce(); let dynamic = upstream.dynamic(); queued(&server).await.accept(&upstream); @@ -9043,7 +9043,7 @@ mod tests { let producer = origin(1).produce(); // A prefix route, which resolves any path beneath it optimistically. let server = producer - .dynamic_route("room", Route::default().with_hops(hops(&[10]))) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_hops(hops(&[10]))) .unwrap(); let upstream = broadcast::Info::new().produce(); let source = upstream.create_track("video", crate::track::Info::timed()).unwrap(); @@ -9055,7 +9055,7 @@ mod tests { let watches = table .routes .root - .find(Path::new("room/alice").parts()) + .find(Path::new("room/alice").unwrap().parts()) .map_or(0, |node| node.watches.len()); (table.fronts.len(), watches) }; @@ -9066,7 +9066,7 @@ mod tests { for viewer in 0..1000 { kio::wait(|waiter| budget.poll_yield(waiter)).await; let session = producer.consume().excluding(Hop::random()); - let pending = session.request_broadcast("room/alice", None); + let pending = session.request_broadcast(Path::new("room/alice").unwrap(), None); if viewer == 0 { queued(&server).await.accept(&upstream); } @@ -9095,25 +9095,25 @@ mod tests { async fn a_hop_in_a_chain_gets_its_own_front() { let producer = origin(1).produce(); let _incumbent = producer - .dynamic_route("room", Route::default().with_hops(hops(&[10]))) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_hops(hops(&[10]))) .unwrap(); let fronts = || producer.shared.lock().fronts.len(); let peer = producer.consume().excluding(origin(7)); - let _local = producer.consume().request_broadcast("room/alice", None); - let _peer = peer.request_broadcast("room/alice", None); + let _local = producer.consume().request_broadcast(Path::new("room/alice").unwrap(), None); + let _peer = peer.request_broadcast(Path::new("room/alice").unwrap(), None); assert_eq!(fronts(), 1, "a hop no chain names excludes nothing"); // The same publisher, now also reached through the peer. let _echo = producer - .dynamic_route("room", Route::default().with_hops(hops(&[10, 7]))) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_hops(hops(&[10, 7]))) .unwrap(); - let _filtered = peer.request_broadcast("room/alice", None); + let _filtered = peer.request_broadcast(Path::new("room/alice").unwrap(), None); assert_eq!(fronts(), 2, "the peer still shares the plain front"); let _viewer = producer .consume() .excluding(origin(8)) - .request_broadcast("room/alice", None); + .request_broadcast(Path::new("room/alice").unwrap(), None); assert_eq!(fronts(), 2, "a viewer left the plain front"); } @@ -9125,7 +9125,7 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let server = producer - .dynamic_route("room", Route::default().with_hops(hops(&[10]))) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_hops(hops(&[10]))) .unwrap(); let upstream = broadcast::Info::new().produce(); let source = upstream.create_track("video", crate::track::Info::timed()).unwrap(); @@ -9133,7 +9133,7 @@ mod tests { group.write_frame(crate::Timestamp::ZERO, b"live".as_ref()).unwrap(); let fronts = || producer.shared.lock().fronts.len(); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); queued(&server).await.accept(&upstream); let resolved = pending.await.expect("resolves"); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); @@ -9160,14 +9160,14 @@ mod tests { async fn a_request_racing_a_front_retiring_never_joins_it_ending() { let producer = origin(1).produce(); let consumer = producer.consume(); - let _broadcast = producer.publish("room/alice", Route::default()).unwrap(); + let _broadcast = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); let fronts = || producer.shared.lock().fronts.len(); - let first = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let first = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); let front = first.weak(); drop(first); let again = consumer - .request_broadcast("room/alice", None) + .request_broadcast(Path::new("room/alice").unwrap(), None) .await .expect("joins in time"); assert!(again.is_clone(&front.consume()), "a request in time keeps the front"); @@ -9176,7 +9176,7 @@ mod tests { settle(|| front.is_closed()).await; assert_eq!(fronts(), 0, "a retired front left the table"); let fresh = consumer - .request_broadcast("room/alice", None) + .request_broadcast(Path::new("room/alice").unwrap(), None) .await .expect("a fresh front"); assert!(!fresh.is_closed()); @@ -9192,13 +9192,13 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let server = producer - .dynamic_route("room", Route::default().with_hops(hops(&[10]))) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_hops(hops(&[10]))) .unwrap(); let upstream = broadcast::Info::new().produce(); let source = upstream.create_track("video", None).unwrap(); let fronts = || producer.shared.lock().fronts.len(); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); queued(&server).await.accept(&upstream); let resolved = pending.await.expect("resolves"); let reader = resolved.track("video").unwrap().subscribe(None); @@ -9221,8 +9221,8 @@ mod tests { async fn a_front_whose_broadcast_closes_ends() { let producer = origin(1).produce(); let consumer = producer.consume(); - let _published = producer.publish("room/alice", Route::default()).unwrap(); - let path = consumer.absolute("room/alice").to_owned(); + let _published = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let path = consumer.absolute(Path::new("room/alice").unwrap()).to_owned(); let broadcast = broadcast::Info::new().produce(); // Held, so the front waits on its holder rather than retiring on its own. let holder = broadcast.consume(); @@ -9255,11 +9255,11 @@ mod tests { async fn a_peers_filtered_front_ends_once_unread() { let producer = origin(1).produce(); let server = producer - .dynamic_route("room", Route::default().with_hops(hops(&[10]))) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_hops(hops(&[10]))) .unwrap(); // The same publisher, also reached through the peer, at a price the plain front skips. let _echo = producer - .dynamic_route("room", Route::default().with_hops(hops(&[10, 7])).with_cost(100)) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_hops(hops(&[10, 7])).with_cost(100)) .unwrap(); let upstream = broadcast::Info::new().produce(); let source = upstream.create_track("video", crate::track::Info::timed()).unwrap(); @@ -9267,12 +9267,12 @@ mod tests { group.write_frame(crate::Timestamp::ZERO, b"live".as_ref()).unwrap(); let fronts = || producer.shared.lock().fronts.len(); - let pending = producer.consume().request_broadcast("room/alice", None); + let pending = producer.consume().request_broadcast(Path::new("room/alice").unwrap(), None); queued(&server).await.accept(&upstream); let _viewer = pending.await.expect("the plain front resolves"); let peer = producer.consume().excluding(origin(7)); - let peered = peer.request_broadcast("room/alice", None).await.expect("resolves"); + let peered = peer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); assert_eq!(fronts(), 2, "the peer has a front of its own"); let mut subscription = peered.track("video").unwrap().subscribe(None).await.unwrap(); next_group(&mut subscription).await.unwrap().expect("the live group"); @@ -9295,18 +9295,18 @@ mod tests { let peer = producer.consume().excluding(origin(7)); let mut view = peer.announced(); let incumbent = producer - .dynamic_route("room", Route::default().with_epoch(epoch()).with_hops(hops(&[10]))) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_epoch(epoch()).with_hops(hops(&[10]))) .unwrap(); - view.expect_next_active("room").await; + view.expect_next_active(Path::new("room").unwrap()).await; - let pending = peer.request_broadcast("room/alice", None); + let pending = peer.request_broadcast(Path::new("room/alice").unwrap(), None); let source = broadcast::Info::new().produce(); queued(&incumbent).await.accept(&source); let resolved = pending.await.expect("resolves through the incumbent"); // The same publisher, now also reached through the peer, outlives the incumbent. let echo = producer - .dynamic_route("room", Route::default().with_epoch(epoch()).with_hops(hops(&[10, 7]))) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_epoch(epoch()).with_hops(hops(&[10, 7]))) .unwrap(); drop(incumbent); drop(source); @@ -9314,7 +9314,7 @@ mod tests { let replacement = broadcast::Info::new().produce(); queued(&echo).await.accept(&replacement); resolved.assert_not_closed(); - view.expect_next_ended("room").await; + view.expect_next_ended(Path::new("room").unwrap()).await; } /// A route that ends abruptly releases its open groups, and the next route may @@ -9336,11 +9336,11 @@ mod tests { let producer = origin(1).produce(); let first_server = producer .dynamic_route( - "room/alice", + Path::new("room/alice").unwrap(), Route::default().with_epoch(epoch()).with_hops(hops(&[10])).with_cost(5), ) .unwrap(); - let pending = producer.consume().request_broadcast("room/alice", None); + let pending = producer.consume().request_broadcast(Path::new("room/alice").unwrap(), None); let upstream = broadcast::Info::new().produce(); let mut dynamic = upstream.dynamic(); queued(&first_server).await.accept(&upstream); @@ -9391,7 +9391,7 @@ mod tests { let cost = if dies_first { 5 } else { 0 }; let replacement_server = producer .dynamic_route( - "room/alice", + Path::new("room/alice").unwrap(), Route::default() .with_epoch(epoch()) .with_hops(hops(&[10])) @@ -9503,9 +9503,9 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); - let broadcast = producer.publish("room/alice", Route::default()).unwrap(); + let broadcast = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); let mut dynamic = broadcast.dynamic(); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); let track = resolved.track("video").unwrap(); let subscribing = moq_clock::sim::spawn(async move { track.subscribe(None).await }); let request = moq_clock::timeout(Duration::from_secs(1), dynamic.requested_track()) @@ -9560,8 +9560,8 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); - let broadcast = producer.publish("room/alice", Route::default()).unwrap(); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let broadcast = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); broadcast.unannounce(); broadcast.announce(Route::default()).unwrap(); @@ -9569,7 +9569,7 @@ mod tests { moq_clock::sim::yield_now().await; } assert!(!resolved.is_closed(), "the front ended across a reannouncement"); - let again = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let again = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); assert!(again.is_clone(&resolved)); } @@ -9580,9 +9580,9 @@ mod tests { let consumer = producer.consume(); // Created but not announced: nobody can reach it, locally included. - let broadcast = producer.create_broadcast("room/alice").unwrap(); + let broadcast = producer.create_broadcast(Path::new("room/alice").unwrap()).unwrap(); let err = consumer - .request_broadcast("room/alice", None) + .request_broadcast(Path::new("room/alice").unwrap(), None) .now_or_never() .expect("unroutable is synchronous") .err() @@ -9590,13 +9590,13 @@ mod tests { assert!(matches!(err, Error::Unroutable)); broadcast.announce(Route::default()).unwrap(); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); assert_eq!(resolved.info().path.as_str(), "room/alice"); drop(broadcast); // Nothing covers an unknown path and no handler exists. let err = consumer - .request_broadcast("room/bob", None) + .request_broadcast(Path::new("room/bob").unwrap(), None) .now_or_never() .expect("unroutable is synchronous") .err() @@ -9608,10 +9608,10 @@ mod tests { async fn create_broadcast_accepts_a_max_depth_path() { let producer = origin(1).produce(); let path = vec!["a"; Path::MAX_PARTS].join("/"); - let _broadcast = producer.create_broadcast(path.as_str()).expect("max depth is allowed"); + let _broadcast = producer.create_broadcast(Path::new(path.as_str()).unwrap()).expect("max depth is allowed"); let deeper = vec!["a"; Path::MAX_PARTS + 1].join("/"); assert!(matches!( - producer.create_broadcast(deeper.as_str()), + producer.create_broadcast(Path::new(deeper.as_str()).unwrap()), Err(Error::BoundsExceeded(_)) )); } @@ -9620,8 +9620,8 @@ mod tests { #[cfg(feature = "async")] async fn duplicate_routes_aggregate_until_the_last_leaves() { let producer = origin(1).produce(); - let first = producer.dynamic_route("live", Route::default().with_cost(3)).unwrap(); - let second = producer.dynamic_route("live", Route::default().with_cost(1)).unwrap(); + let first = producer.dynamic_route(Path::new("live").unwrap(), Route::default().with_cost(3)).unwrap(); + let second = producer.dynamic_route(Path::new("live").unwrap(), Route::default().with_cost(1)).unwrap(); let mut announced = producer.consume().announced(); let Some(Some(AnnounceEvent::Start(update))) = announced.next().now_or_never() else { @@ -9633,26 +9633,26 @@ mod tests { // Without an epoch the survivor is another source. drop(second); - assert_eq!(announced.expect_next_restarted("live").await.cost, Cost::new(3)); + assert_eq!(announced.expect_next_restarted(Path::new("live").unwrap()).await.cost, Cost::new(3)); drop(first); - announced.expect_next_ended("live").await; + announced.expect_next_ended(Path::new("live").unwrap()).await; announced.assert_next_wait(); } #[moq_clock::test] async fn dynamic_may_cover_a_scope_but_disjoint_prefixes_are_refused() { let producer = origin(1).produce(); - let scoped = producer.scope("", &scopes(&["room"])).unwrap(); + let scoped = producer.scope(Path::new("").unwrap(), &scopes(&["room"])).unwrap(); let _broad = scoped - .dynamic_route("", Route::default()) + .dynamic_route(Path::new("").unwrap(), Route::default()) .expect("an overlapping prefix is accepted"); let _ok = scoped - .dynamic_route("room/alice", Route::default()) + .dynamic_route(Path::new("room/alice").unwrap(), Route::default()) .expect("a contained prefix is accepted"); assert!(matches!( - scoped.dynamic_route("other", Route::default()), + scoped.dynamic_route(Path::new("other").unwrap(), Route::default()), Err(Error::Unauthorized) )); } @@ -9662,31 +9662,31 @@ mod tests { async fn dynamic_route_keeps_its_producer_scope() { let producer = origin(1).produce(); let scope = Patterns::from("*/chat".parse::().unwrap()); - let scoped = producer.scope("", &scope).unwrap(); - let dynamic = scoped.dynamic_route("", Route::default()).unwrap(); + let scoped = producer.scope(Path::new("").unwrap(), &scope).unwrap(); + let dynamic = scoped.dynamic_route(Path::new("").unwrap(), Route::default()).unwrap(); let mut matching = producer .consume() - .scope("", &scopes(&["room/chat"])) + .scope(Path::new("").unwrap(), &scopes(&["room/chat"])) .unwrap() .announced(); - matching.expect_next_active("").await; + matching.expect_next_active(Path::new("").unwrap()).await; let mut outside = producer .consume() - .scope("", &scopes(&["room/video"])) + .scope(Path::new("").unwrap(), &scopes(&["room/video"])) .unwrap() .announced(); outside.assert_next_wait(); let refused = producer .consume() - .request_broadcast("room/video", None) + .request_broadcast(Path::new("room/video").unwrap(), None) .now_or_never() .expect("an out-of-scope request must be refused synchronously"); assert!(matches!(refused, Err(Error::Unroutable))); assert!(dynamic.requested_broadcast().now_or_never().is_none()); - let _pending = producer.consume().request_broadcast("room/chat", None); + let _pending = producer.consume().request_broadcast(Path::new("room/chat").unwrap(), None); let request = queued(&dynamic).await; assert_eq!(request.path().as_str(), "room/chat"); } @@ -9696,22 +9696,22 @@ mod tests { let producer = origin(1).produce(); let scoped = |pattern: &str| { producer - .scope("", &Patterns::from(pattern.parse::().unwrap())) + .scope(Path::new("").unwrap(), &Patterns::from(pattern.parse::().unwrap())) .unwrap() }; let _chat = scoped("*/chat") - .dynamic_route("", Route::default().with_cost(1)) + .dynamic_route(Path::new("").unwrap(), Route::default().with_cost(1)) .unwrap(); let _video = scoped("*/video") - .dynamic_route("", Route::default().with_cost(5)) + .dynamic_route(Path::new("").unwrap(), Route::default().with_cost(5)) .unwrap(); let mut video = producer .consume() - .scope("", &scopes(&["room/video"])) + .scope(Path::new("").unwrap(), &scopes(&["room/video"])) .unwrap() .announced(); - assert_eq!(video.expect_next_active("").await.cost, Cost::new(5)); + assert_eq!(video.expect_next_active(Path::new("").unwrap()).await.cost, Cost::new(5)); } #[moq_clock::test] @@ -9723,69 +9723,69 @@ mod tests { let mut excluded = consumer.clone().excluding(origin(7)).announced(); let mut video = consumer .clone() - .scope("", &scopes(&["room/live/video"])) + .scope(Path::new("").unwrap(), &scopes(&["room/live/video"])) .unwrap() .announced(); let mut rooted = consumer - .scope("room/live", &Patterns::from(Pattern::all())) + .scope(Path::new("room/live").unwrap(), &Patterns::from(Pattern::all())) .unwrap() .announced(); let chat = producer - .scope("", &scopes(&["room/live/chat"])) + .scope(Path::new("").unwrap(), &scopes(&["room/live/chat"])) .unwrap() - .dynamic_route("room/live", Route::default().with_hops(hops(&[7])).with_cost(1)) + .dynamic_route(Path::new("room/live").unwrap(), Route::default().with_hops(hops(&[7])).with_cost(1)) .unwrap(); - assert_eq!(all.expect_next_active("room/live").await.cost, Cost::new(1)); - assert_eq!(rooted.expect_next_active("").await.cost, Cost::new(1)); + assert_eq!(all.expect_next_active(Path::new("room/live").unwrap()).await.cost, Cost::new(1)); + assert_eq!(rooted.expect_next_active(Path::new("").unwrap()).await.cost, Cost::new(1)); excluded.assert_next_wait(); video.assert_next_wait(); let video_route = producer - .scope("", &scopes(&["room/live/video"])) + .scope(Path::new("").unwrap(), &scopes(&["room/live/video"])) .unwrap() - .dynamic_route("room/live", Route::default().with_hops(hops(&[8])).with_cost(5)) + .dynamic_route(Path::new("room/live").unwrap(), Route::default().with_hops(hops(&[8])).with_cost(5)) .unwrap(); all.assert_next_wait(); rooted.assert_next_wait(); - assert_eq!(excluded.expect_next_active("room/live").await.cost, Cost::new(5)); - assert_eq!(video.expect_next_active("room/live").await.cost, Cost::new(5)); + assert_eq!(excluded.expect_next_active(Path::new("room/live").unwrap()).await.cost, Cost::new(5)); + assert_eq!(video.expect_next_active(Path::new("room/live").unwrap()).await.cost, Cost::new(5)); chat.update_route(Route::default().with_hops(hops(&[7])).with_cost(9)) .unwrap(); - assert_eq!(all.expect_next_active("room/live").await.cost, Cost::new(5)); - assert_eq!(rooted.expect_next_active("").await.cost, Cost::new(5)); + assert_eq!(all.expect_next_active(Path::new("room/live").unwrap()).await.cost, Cost::new(5)); + assert_eq!(rooted.expect_next_active(Path::new("").unwrap()).await.cost, Cost::new(5)); excluded.assert_next_wait(); video.assert_next_wait(); drop(video_route); - assert_eq!(all.expect_next_active("room/live").await.cost, Cost::new(9)); - assert_eq!(rooted.expect_next_active("").await.cost, Cost::new(9)); - excluded.expect_next_ended("room/live").await; - video.expect_next_ended("room/live").await; + assert_eq!(all.expect_next_active(Path::new("room/live").unwrap()).await.cost, Cost::new(9)); + assert_eq!(rooted.expect_next_active(Path::new("").unwrap()).await.cost, Cost::new(9)); + excluded.expect_next_ended(Path::new("room/live").unwrap()).await; + video.expect_next_ended(Path::new("room/live").unwrap()).await; } #[moq_clock::test] #[cfg(feature = "async")] async fn root_cursor_keeps_the_more_specific_covering_route() { let producer = origin(1).produce(); - let broad = producer.dynamic_route("room", Route::default().with_cost(1)).unwrap(); + let broad = producer.dynamic_route(Path::new("room").unwrap(), Route::default().with_cost(1)).unwrap(); let narrow = producer - .dynamic_route("room/live", Route::default().with_cost(9)) + .dynamic_route(Path::new("room/live").unwrap(), Route::default().with_cost(9)) .unwrap(); let mut announced = producer .consume() - .scope("room/live/video", &Patterns::from(Pattern::all())) + .scope(Path::new("room/live/video").unwrap(), &Patterns::from(Pattern::all())) .unwrap() .announced(); - assert_eq!(announced.expect_next_active("").await.cost, Cost::new(9)); + assert_eq!(announced.expect_next_active(Path::new("").unwrap()).await.cost, Cost::new(9)); broad.update_route(Route::default().with_cost(0)).unwrap(); announced.assert_next_wait(); narrow.update_route(Route::default().with_cost(8)).unwrap(); - assert_eq!(announced.expect_next_active("").await.cost, Cost::new(8)); + assert_eq!(announced.expect_next_active(Path::new("").unwrap()).await.cost, Cost::new(8)); drop(narrow); - assert_eq!(announced.expect_next_active("").await.cost, Cost::new(0)); + assert_eq!(announced.expect_next_active(Path::new("").unwrap()).await.cost, Cost::new(0)); } #[moq_clock::test] @@ -9799,11 +9799,11 @@ mod tests { let mut announced = producer.consume().announced(); let dynamic = producer - .dynamic_route(&path, Route::default()) + .dynamic_route(Path::new(&path).unwrap(), Route::default()) .expect("max depth is allowed"); - announced.expect_next_active(&path).await; + announced.expect_next_active(Path::new(&path).unwrap()).await; - let _pending = producer.consume().request_broadcast(&path, None); + let _pending = producer.consume().request_broadcast(Path::new(&path).unwrap(), None); let request = queued(&dynamic).await; assert_eq!(request.path().as_str(), path); } @@ -9812,14 +9812,14 @@ mod tests { async fn dynamic_exclusion_skips_routes_through_the_subscriber() { let producer = origin(1).produce(); let _server = producer - .dynamic_route("live", Route::default().with_hops(hops(&[7]))) + .dynamic_route(Path::new("live").unwrap(), Route::default().with_hops(hops(&[7]))) .unwrap(); let mut excluded = producer.consume().excluding(origin(7)).announced(); excluded.assert_next_wait(); let mut clean = producer.consume().excluding(origin(8)).announced(); - clean.expect_next_active("live").await; + clean.expect_next_active(Path::new("live").unwrap()).await; } /// The consumer is a `Stream` of the same updates as `next`. @@ -9828,7 +9828,7 @@ mod tests { async fn announce_consumer_is_a_stream() { use futures::StreamExt; let producer = origin(1).produce(); - let server = producer.dynamic_route("live", Route::default()).unwrap(); + let server = producer.dynamic_route(Path::new("live").unwrap(), Route::default()).unwrap(); let mut announced = producer.consume().announced(); let mut next = || StreamExt::next(&mut announced).now_or_never(); let Some(Some(AnnounceEvent::Start(update))) = next() else { @@ -9843,12 +9843,12 @@ mod tests { #[moq_clock::test] async fn dynamic_retracts() { let producer = origin(1).produce(); - let server = producer.dynamic_route("live", Route::default()).unwrap(); + let server = producer.dynamic_route(Path::new("live").unwrap(), Route::default()).unwrap(); let mut announced = producer.consume().announced(); - announced.expect_next_active("live").await; + announced.expect_next_active(Path::new("live").unwrap()).await; drop(server); - announced.expect_next_ended("live").await; + announced.expect_next_ended(Path::new("live").unwrap()).await; } #[moq_clock::test] @@ -9856,17 +9856,17 @@ mod tests { let producer = origin(1).produce(); let mut local = producer.consume().announced(); let mut peer = producer.consume().excluding(Hop::UNKNOWN).announced(); - let broadcast = producer.create_broadcast("room/alice").unwrap(); + let broadcast = producer.create_broadcast(Path::new("room/alice").unwrap()).unwrap(); local.assert_next_wait(); peer.assert_next_wait(); broadcast.announce(Route::default()).unwrap(); - local.expect_next_active("room/alice").await; - peer.expect_next_active("room/alice").await; + local.expect_next_active(Path::new("room/alice").unwrap()).await; + peer.expect_next_active(Path::new("room/alice").unwrap()).await; drop(broadcast); - local.expect_next_ended("room/alice").await; - peer.expect_next_ended("room/alice").await; + local.expect_next_ended(Path::new("room/alice").unwrap()).await; + peer.expect_next_ended(Path::new("room/alice").unwrap()).await; } #[moq_clock::test] @@ -9875,9 +9875,9 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); - let server = producer.dynamic_route("room", Route::default()).unwrap(); + let server = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); let request = queued(&server).await; assert_eq!(request.path().as_str(), "room/alice"); @@ -9889,7 +9889,7 @@ mod tests { assert_eq!(resolved.info().path.as_str(), "room/alice"); // A repeat request shares the served broadcast instead of re-asking. - let again = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let again = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); assert!(again.is_clone(&resolved)); } @@ -9898,10 +9898,10 @@ mod tests { async fn served_requests_coalesce() { let producer = origin(1).produce(); let consumer = producer.consume(); - let server = producer.dynamic_route("room", Route::default()).unwrap(); + let server = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); - let first = consumer.request_broadcast("room/alice", None); - let second = consumer.request_broadcast("room/alice", None); + let first = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); + let second = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); let request = queued(&server).await; // Only one request reaches the server. @@ -9920,9 +9920,9 @@ mod tests { async fn retract_rejects_pending_requests() { let producer = origin(1).produce(); let consumer = producer.consume(); - let server = producer.dynamic_route("room", Route::default()).unwrap(); + let server = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); drop(server); let err = pending.await.err().unwrap(); @@ -9930,7 +9930,7 @@ mod tests { // With the route gone, later requests are unroutable immediately. let err = consumer - .request_broadcast("room/alice", None) + .request_broadcast(Path::new("room/alice").unwrap(), None) .now_or_never() .expect("unroutable") .err() @@ -9946,11 +9946,11 @@ mod tests { // Three identical routes, oldest first: the newest identical route wins // requests, and swapping between them emits no announce update. - let standby_server = producer.dynamic_route("room", Route::default()).unwrap(); - let second_server = producer.dynamic_route("room", Route::default()).unwrap(); - let incumbent_server = producer.dynamic_route("room", Route::default()).unwrap(); + let standby_server = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); + let second_server = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); + let incumbent_server = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); - let mut resolving = Box::pin(consumer.routed_broadcast("room/alice")); + let mut resolving = Box::pin(consumer.routed_broadcast(Path::new("room/alice").unwrap())); assert!((&mut resolving).now_or_never().is_none()); // Each incumbent dies with the front's request in flight on it: the @@ -9975,13 +9975,13 @@ mod tests { async fn split_horizon_skips_routes_through_the_requester() { let producer = origin(1).produce(); let _server = producer - .dynamic_route("room", Route::default().with_hops(hops(&[7]))) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_hops(hops(&[7]))) .unwrap(); // The requester's own bytes must not be served back to it. let excluded = producer.consume().excluding(origin(7)); let err = excluded - .request_broadcast("room/alice", None) + .request_broadcast(Path::new("room/alice").unwrap(), None) .now_or_never() .expect("unroutable") .err() @@ -9990,7 +9990,7 @@ mod tests { // A clean requester resolves through the route (the request queues). let clean = producer.consume().excluding(origin(8)); - let pending = clean.request_broadcast("room/alice", None); + let pending = clean.request_broadcast(Path::new("room/alice").unwrap(), None); assert!(pending.now_or_never().is_none()); } @@ -10001,28 +10001,28 @@ mod tests { let mut announced = producer.consume().announced(); let _ingest = producer - .dynamic_route("client", Route::default().with_hops(hops(&[5])).with_via(origin(5))) + .dynamic_route(Path::new("client").unwrap(), Route::default().with_hops(hops(&[5])).with_via(origin(5))) .unwrap(); - let _gateway = producer.publish("gateway", Route::default()).unwrap(); + let _gateway = producer.publish(Path::new("gateway").unwrap(), Route::default()).unwrap(); let _forwarded = peer .dynamic_route( - "forwarded", + Path::new("forwarded").unwrap(), Route::default().with_hops(hops(&[5, 7])).with_via(origin(7)), ) .unwrap(); - assert_eq!(announced.expect_next_active("client").await.source(), Source::Local); - assert_eq!(announced.expect_next_active("gateway").await.source(), Source::Local); + assert_eq!(announced.expect_next_active(Path::new("client").unwrap()).await.source(), Source::Local); + assert_eq!(announced.expect_next_active(Path::new("gateway").unwrap()).await.source(), Source::Local); assert_eq!( - announced.expect_next_active("forwarded").await.source(), + announced.expect_next_active(Path::new("forwarded").unwrap()).await.source(), Source::Peer(origin(7)) ); // The mark survives narrowing the handle. - let scoped = peer.scope("room", &Patterns::from(Pattern::all())).unwrap(); - let _nested = scoped.dynamic_route("x", Route::default().with_via(origin(8))).unwrap(); + let scoped = peer.scope(Path::new("room").unwrap(), &Patterns::from(Pattern::all())).unwrap(); + let _nested = scoped.dynamic_route(Path::new("x").unwrap(), Route::default().with_via(origin(8))).unwrap(); assert_eq!( - announced.expect_next_active("room/x").await.source(), + announced.expect_next_active(Path::new("room/x").unwrap()).await.source(), Source::Peer(origin(8)) ); } @@ -10054,10 +10054,10 @@ mod tests { .with_hops(hops(chain)) .with_via(origin(via)) }; - let near = peer.dynamic_route("room", route(&[9, 2], 2)).unwrap(); - announced.assert_try_next_active("room"); + let near = peer.dynamic_route(Path::new("room").unwrap(), route(&[9, 2], 2)).unwrap(); + announced.assert_try_next_active(Path::new("room").unwrap()); - let _far = peer.dynamic_route("room", route(&[9, 3, 4], 4)).unwrap(); + let _far = peer.dynamic_route(Path::new("room").unwrap(), route(&[9, 3, 4], 4)).unwrap(); drop(near); assert!(announced.try_next().is_none(), "the update is held"); step(Duration::from_millis(1)).await; @@ -10092,8 +10092,8 @@ mod tests { let mut near = Vec::new(); let mut far = Vec::new(); for i in 0..k { - near.push(peer.dynamic_route(format!("room/{i}"), route(&[9, 2], 2)).unwrap()); - far.push(peer.dynamic_route(format!("room/{i}"), route(&[9, 3, 4], 4)).unwrap()); + near.push(peer.dynamic_route(Path::try_from(format!("room/{i}")).unwrap(), route(&[9, 2], 2)).unwrap()); + far.push(peer.dynamic_route(Path::try_from(format!("room/{i}")).unwrap(), route(&[9, 3, 4], 4)).unwrap()); } let mut announced = producer.consume().announced(); for _ in 0..k { @@ -10108,7 +10108,7 @@ mod tests { for (i, route) in far.into_iter().enumerate().rev() { drop(route); match announced.try_next() { - Some(AnnounceEvent::End(end)) => assert_eq!(end.prefix, Path::new(&format!("room/{i}"))), + Some(AnnounceEvent::End(end)) => assert_eq!(end.prefix, Path::new(&format!("room/{i}")).unwrap()), other => panic!("should be a retraction: got {other:?}"), } } @@ -10138,12 +10138,12 @@ mod tests { .with_hops(hops(chain)) .with_via(origin(via)) }; - let near = peer.dynamic_route("room", route(&[9, 2], 2)).unwrap(); - announced.expect_next_active("room").await; + let near = peer.dynamic_route(Path::new("room").unwrap(), route(&[9, 2], 2)).unwrap(); + announced.expect_next_active(Path::new("room").unwrap()).await; // The best route changes twice; the consumer sees only the last, once. - let far = peer.dynamic_route("room", route(&[9, 3, 4], 4)).unwrap(); - let farther = peer.dynamic_route("room", route(&[9, 5, 6, 7], 7)).unwrap(); + let far = peer.dynamic_route(Path::new("room").unwrap(), route(&[9, 3, 4], 4)).unwrap(); + let farther = peer.dynamic_route(Path::new("room").unwrap(), route(&[9, 5, 6, 7], 7)).unwrap(); let start = moq_clock::now(); drop(near); drop(far); @@ -10156,7 +10156,7 @@ mod tests { // The last route goes: retracted at once. drop(farther); - announced.expect_next_ended("room").await; + announced.expect_next_ended(Path::new("room").unwrap()).await; } /// After a retraction, a worse path to the same publisher waits out the @@ -10171,42 +10171,42 @@ mod tests { let route = |chain: &[u64], via| Route::default().with_hops(hops(chain)).with_via(origin(via)); - let near = peer.dynamic_route("named", route(&[9, 2], 2)).unwrap(); - announced.expect_next_active("named").await; + let near = peer.dynamic_route(Path::new("named").unwrap(), route(&[9, 2], 2)).unwrap(); + announced.expect_next_active(Path::new("named").unwrap()).await; drop(near); - announced.expect_next_ended("named").await; + announced.expect_next_ended(Path::new("named").unwrap()).await; let start = moq_clock::now(); - let _stale = peer.dynamic_route("named", route(&[9, 3, 4], 4)).unwrap(); + let _stale = peer.dynamic_route(Path::new("named").unwrap(), route(&[9, 3, 4], 4)).unwrap(); match announced.next().await.unwrap() { AnnounceEvent::Start(announce) => assert_eq!(announce.route.hops, hops(&[9, 3, 4])), other => panic!("should be a start: got {other:?}"), } assert!(moq_clock::now() - start >= RETRACT_QUARANTINE); - let near = peer.dynamic_route("anonymous", route(&[0, 2], 2)).unwrap(); - announced.expect_next_active("anonymous").await; + let near = peer.dynamic_route(Path::new("anonymous").unwrap(), route(&[0, 2], 2)).unwrap(); + announced.expect_next_active(Path::new("anonymous").unwrap()).await; drop(near); - announced.expect_next_ended("anonymous").await; - let _other = peer.dynamic_route("anonymous", route(&[0, 3, 4], 4)).unwrap(); - announced.expect_next_active("anonymous").await; + announced.expect_next_ended(Path::new("anonymous").unwrap()).await; + let _other = peer.dynamic_route(Path::new("anonymous").unwrap(), route(&[0, 3, 4], 4)).unwrap(); + announced.expect_next_active(Path::new("anonymous").unwrap()).await; // Retract and announce cycles at one clock reading queue the prefix once, // whether or not the route names its publisher. let queued = announced.anchoring.len(); for chain in [[9, 2], [0, 2], [9, 2], [0, 2]] { - let churn = peer.dynamic_route("churn", route(&chain, 2)).unwrap(); - announced.expect_next_active("churn").await; + let churn = peer.dynamic_route(Path::new("churn").unwrap(), route(&chain, 2)).unwrap(); + announced.expect_next_active(Path::new("churn").unwrap()).await; drop(churn); - announced.expect_next_ended("churn").await; + announced.expect_next_ended(Path::new("churn").unwrap()).await; } assert_eq!(announced.anchoring.len(), queued + 1); // A quarantine is forgotten once it ends: the cursor wakes to anchor it, // then again to drop it. - let gone = peer.dynamic_route("gone", route(&[9, 2], 2)).unwrap(); - announced.expect_next_active("gone").await; + let gone = peer.dynamic_route(Path::new("gone").unwrap(), route(&[9, 2], 2)).unwrap(); + announced.expect_next_active(Path::new("gone").unwrap()).await; drop(gone); - announced.expect_next_ended("gone").await; + announced.expect_next_ended(Path::new("gone").unwrap()).await; assert!(!announced.retracted.is_empty()); for _ in 0..2 { announced.assert_next_wait(); @@ -10227,27 +10227,27 @@ mod tests { // Publisher 9 ingests at relay 2; relay 3 relays 2's route. let direct = || Route::default().with_hops(hops(&[9, 2])).with_via(origin(2)); - let first = peer.dynamic_route("room", direct()).unwrap(); + let first = peer.dynamic_route(Path::new("room").unwrap(), direct()).unwrap(); let relayed = peer - .dynamic_route("room", Route::default().with_hops(hops(&[9, 2, 3])).with_via(origin(3))) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_hops(hops(&[9, 2, 3])).with_via(origin(3))) .unwrap(); - announced.expect_next_active("room").await; + announced.expect_next_active(Path::new("room").unwrap()).await; announced.assert_next_wait(); // Relay 2 withdraws: the relayed copy goes with it rather than taking over. first.withdrawn(); - announced.expect_next_ended("room").await; + announced.expect_next_ended(Path::new("room").unwrap()).await; announced.assert_next_wait(); // Relay 2 announces again, and the relayed copy is live with it. - let second = peer.dynamic_route("room", direct()).unwrap(); - announced.expect_next_active("room").await; + let second = peer.dynamic_route(Path::new("room").unwrap(), direct()).unwrap(); + announced.expect_next_active(Path::new("room").unwrap()).await; assert!(producer.shared.lock().withdrawn.is_empty()); // Nothing passes through relay 2 once both routes are gone. second.withdrawn(); drop(relayed); - announced.expect_next_ended("room").await; + announced.expect_next_ended(Path::new("room").unwrap()).await; assert!(producer.shared.lock().withdrawn.is_empty()); } @@ -10260,15 +10260,15 @@ mod tests { let peer = producer.clone().with_link(Link::Peer); let mut announced = producer.consume().announced(); let route = Route::default().with_hops(hops(&[9, 2])); - let first = peer.dynamic_route("room", route.clone()).unwrap(); - let second = peer.dynamic_route("room", route.clone()).unwrap(); - announced.expect_next_active("room").await; + let first = peer.dynamic_route(Path::new("room").unwrap(), route.clone()).unwrap(); + let second = peer.dynamic_route(Path::new("room").unwrap(), route.clone()).unwrap(); + announced.expect_next_active(Path::new("room").unwrap()).await; announced.assert_next_wait(); let remaining = if restart { // The older table entry has the newest advertisement after a restart. first.update_route(route).unwrap(); second.withdrawn(); - announced.expect_next_restarted("room").await; + announced.expect_next_restarted(Path::new("room").unwrap()).await; first } else { first.withdrawn(); @@ -10277,7 +10277,7 @@ mod tests { announced.assert_next_wait(); assert!(producer.shared.lock().withdrawn.is_empty()); remaining.withdrawn(); - announced.expect_next_ended("room").await; + announced.expect_next_ended(Path::new("room").unwrap()).await; assert!(producer.shared.lock().withdrawn.is_empty()); } } @@ -10287,12 +10287,12 @@ mod tests { let producer = origin(1).produce(); let peer = producer.clone().with_link(Link::Peer); let direct = peer - .dynamic_route("room", Route::default().with_hops(hops(&[9, 2]))) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_hops(hops(&[9, 2]))) .unwrap(); let _relayed = peer - .dynamic_route("room", Route::default().with_hops(hops(&[9, 2, 3]))) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_hops(hops(&[9, 2, 3]))) .unwrap(); - let path = Path::new("room/video"); + let path = Path::new("room/video").unwrap(); let id = producer .shared .read() @@ -10320,14 +10320,14 @@ mod tests { .with_epoch(epoch()) .with_hops(hops(&[7])) .with_via(origin(7)); - let _forwarded = peer.dynamic_route("room", route.clone()).unwrap(); + let _forwarded = peer.dynamic_route(Path::new("room").unwrap(), route.clone()).unwrap(); assert_eq!( - announced.expect_next_active("room").await.source(), + announced.expect_next_active(Path::new("room").unwrap()).await.source(), Source::Peer(origin(7)) ); // The newest identical route wins, so the local twin takes over. - let local = producer.dynamic_route("room", route).unwrap(); + let local = producer.dynamic_route(Path::new("room").unwrap(), route).unwrap(); match announced.next().await.expect("no next") { AnnounceEvent::Update(announce) => assert_eq!(announce.route.source(), Source::Local), other => panic!("should be an update: got {other:?}"), @@ -10335,7 +10335,7 @@ mod tests { drop(local); assert_eq!( - announced.expect_next_active("room").await.source(), + announced.expect_next_active(Path::new("room").unwrap()).await.source(), Source::Peer(origin(7)) ); } @@ -10347,7 +10347,7 @@ mod tests { let mut local = producer.consume().local().announced(); let _forwarded = peer - .dynamic_route("remote", Route::default().with_hops(hops(&[7])).with_via(origin(7))) + .dynamic_route(Path::new("remote").unwrap(), Route::default().with_hops(hops(&[7])).with_via(origin(7))) .unwrap(); local.assert_next_wait(); @@ -10355,24 +10355,24 @@ mod tests { // and retracts from the local view when the local route goes, even though // the peer's still covers it. let _shadow = peer - .dynamic_route("both", Route::default().with_hops(hops(&[7])).with_via(origin(7))) + .dynamic_route(Path::new("both").unwrap(), Route::default().with_hops(hops(&[7])).with_via(origin(7))) .unwrap(); let ingest = producer .dynamic_route( - "both", + Path::new("both").unwrap(), Route::default().with_hops(hops(&[5])).with_via(origin(5)).with_cost(9), ) .unwrap(); - assert_eq!(local.expect_next_active("both").await.source(), Source::Local); + assert_eq!(local.expect_next_active(Path::new("both").unwrap()).await.source(), Source::Local); drop(ingest); - local.expect_next_ended("both").await; + local.expect_next_ended(Path::new("both").unwrap()).await; // Resolution agrees with the cursor: a peer-only path is unroutable here, // while the full view queues the request on the peer's route. let err = producer .consume() .local() - .request_broadcast("remote/alice", None) + .request_broadcast(Path::new("remote/alice").unwrap(), None) .now_or_never() .expect("unroutable") .err() @@ -10381,7 +10381,7 @@ mod tests { assert!( producer .consume() - .request_broadcast("remote/alice", None) + .request_broadcast(Path::new("remote/alice").unwrap(), None) .now_or_never() .is_none() ); @@ -10399,45 +10399,45 @@ mod tests { let mut everyone = producer.consume().announced(); let _core = core - .dynamic_route("core", Route::default().with_hops(hops(&[7])).with_via(origin(7))) + .dynamic_route(Path::new("core").unwrap(), Route::default().with_hops(hops(&[7])).with_via(origin(7))) .unwrap(); assert_eq!( - everyone.expect_next_active("core").await.source(), + everyone.expect_next_active(Path::new("core").unwrap()).await.source(), Source::Peer(origin(7)) ); toward_core.assert_next_wait(); let _mesh = peer - .dynamic_route("mesh", Route::default().with_hops(hops(&[8])).with_via(origin(8))) + .dynamic_route(Path::new("mesh").unwrap(), Route::default().with_hops(hops(&[8])).with_via(origin(8))) .unwrap(); assert_eq!( - toward_core.expect_next_active("mesh").await.source(), + toward_core.expect_next_active(Path::new("mesh").unwrap()).await.source(), Source::Peer(origin(8)) ); // A path both an upstream and a mesh peer reach: the upstream route is // cheaper, yet the upstream view selects the mesh peer's. let _cheap = core - .dynamic_route("both", Route::default().with_hops(hops(&[7])).with_via(origin(7))) + .dynamic_route(Path::new("both").unwrap(), Route::default().with_hops(hops(&[7])).with_via(origin(7))) .unwrap(); let mesh = peer .dynamic_route( - "both", + Path::new("both").unwrap(), Route::default().with_hops(hops(&[8])).with_via(origin(8)).with_cost(9), ) .unwrap(); assert_eq!( - toward_core.expect_next_active("both").await.source(), + toward_core.expect_next_active(Path::new("both").unwrap()).await.source(), Source::Peer(origin(8)) ); drop(mesh); - toward_core.expect_next_ended("both").await; + toward_core.expect_next_ended(Path::new("both").unwrap()).await; // Resolution agrees with the cursor: an upstream-only path is unroutable // toward an upstream, while the full view queues it on the core's route. let err = core .consume() - .request_broadcast("core/alice", None) + .request_broadcast(Path::new("core/alice").unwrap(), None) .now_or_never() .expect("unroutable") .err() @@ -10446,7 +10446,7 @@ mod tests { assert!( producer .consume() - .request_broadcast("core/alice", None) + .request_broadcast(Path::new("core/alice").unwrap(), None) .now_or_never() .is_none() ); @@ -10460,9 +10460,9 @@ mod tests { async fn handler_rejection_is_final() { let producer = origin(1).produce(); let consumer = producer.consume(); - let server = producer.dynamic_route("room", Route::default()).unwrap(); + let server = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); let request = queued(&server).await; request.reject(Error::Unroutable); let err = moq_clock::timeout(Duration::from_secs(5), pending) @@ -10473,7 +10473,7 @@ mod tests { assert!(matches!(err, Error::Unroutable)); // The route still stands and serves the next path. - let pending = consumer.request_broadcast("room/bob", None); + let pending = consumer.request_broadcast(Path::new("room/bob").unwrap(), None); let request = queued(&server).await; assert_eq!(request.path().as_str(), "room/bob"); let served = broadcast::Info::new().produce(); @@ -10486,9 +10486,9 @@ mod tests { async fn claim_answer_is_hidden_until_published_with_its_epoch() { let producer = origin(1).produce(); let consumer = producer.consume(); - let claim = producer.dynamic("room").unwrap(); + let claim = producer.dynamic(Path::new("room").unwrap()).unwrap(); let epoch = crate::Epoch::mint(); - let mut pending = Box::pin(consumer.request_broadcast("room/alice", None)); + let mut pending = Box::pin(consumer.request_broadcast(Path::new("room/alice").unwrap(), None)); assert!((&mut pending).now_or_never().is_none()); let prepared = queued(&claim).await.prepare(epoch.clone()).unwrap(); @@ -10510,9 +10510,9 @@ mod tests { async fn a_prepared_answer_cannot_announce_itself() { let producer = origin(1).produce(); let mut announced = producer.consume().announced(); - let claim = producer.dynamic("room").unwrap(); - announced.assert_next_active("room"); - let pending = producer.consume().request_broadcast("room/alice", None); + let claim = producer.dynamic(Path::new("room").unwrap()).unwrap(); + announced.assert_next_active(Path::new("room").unwrap()); + let pending = producer.consume().request_broadcast(Path::new("room/alice").unwrap(), None); let epoch = crate::Epoch::mint(); let prepared = queued(&claim).await.prepare(epoch.clone()).unwrap(); let answer = prepared.broadcast().clone(); @@ -10532,8 +10532,8 @@ mod tests { #[cfg(feature = "async")] async fn a_refused_prepared_answer_cannot_announce_later() { let producer = origin(1).produce(); - let claim = producer.dynamic("room").unwrap(); - let _pending = producer.consume().request_broadcast("room/alice", None); + let claim = producer.dynamic(Path::new("room").unwrap()).unwrap(); + let _pending = producer.consume().request_broadcast(Path::new("room/alice").unwrap(), None); let prepared = queued(&claim).await.prepare(crate::Epoch::mint()).unwrap(); let answer = prepared.broadcast().clone(); @@ -10547,8 +10547,8 @@ mod tests { async fn dropping_a_prepared_claim_answer_refuses_the_request() { let producer = origin(1).produce(); let consumer = producer.consume(); - let claim = producer.dynamic("room").unwrap(); - let pending = consumer.request_broadcast("room/alice", None); + let claim = producer.dynamic(Path::new("room").unwrap()).unwrap(); + let pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); let prepared = queued(&claim).await.prepare(crate::Epoch::mint()).unwrap(); drop(prepared); assert!(matches!(pending.await, Err(Error::Unroutable))); @@ -10560,13 +10560,13 @@ mod tests { async fn a_prepared_answer_for_an_abandoned_claim_is_never_announced() { let producer = origin(1).produce(); let mut announced = producer.consume().announced(); - let claim = producer.dynamic("room").unwrap(); - announced.assert_next_active("room"); - let _pending = producer.consume().request_broadcast("room/alice", None); + let claim = producer.dynamic(Path::new("room").unwrap()).unwrap(); + announced.assert_next_active(Path::new("room").unwrap()); + let _pending = producer.consume().request_broadcast(Path::new("room/alice").unwrap(), None); let prepared = queued(&claim).await.prepare(crate::Epoch::mint()).unwrap(); drop(claim); - announced.assert_next_ended("room"); + announced.assert_next_ended(Path::new("room").unwrap()); assert!(matches!(prepared.publish(), Err(Error::Unroutable))); announced.assert_next_wait(); } @@ -10577,15 +10577,15 @@ mod tests { async fn a_prepared_answer_for_a_released_request_is_never_announced() { let producer = origin(1).produce(); let mut announced = producer.consume().announced(); - let claim = producer.dynamic("room").unwrap(); - announced.assert_next_active("room"); - let _pending = producer.consume().request_broadcast("room/alice", None); + let claim = producer.dynamic(Path::new("room").unwrap()).unwrap(); + announced.assert_next_active(Path::new("room").unwrap()); + let _pending = producer.consume().request_broadcast(Path::new("room/alice").unwrap(), None); let prepared = queued(&claim).await.prepare(crate::Epoch::mint()).unwrap(); claim .update_route(Route::default().with_epoch(crate::Epoch::mint())) .unwrap(); - announced.assert_next_restarted("room"); + announced.assert_next_restarted(Path::new("room").unwrap()); assert!(matches!(prepared.publish(), Err(Error::Unroutable))); announced.assert_next_wait(); } @@ -10597,18 +10597,18 @@ mod tests { async fn a_pinned_request_resolves_only_through_the_published_epoch() { let producer = origin(1).produce(); let consumer = producer.consume(); - let claim = producer.dynamic("room").unwrap(); + let claim = producer.dynamic(Path::new("room").unwrap()).unwrap(); let epoch = crate::Epoch::mint(); - let unknown = consumer.request_broadcast("room/alice", crate::Epoch::mint()); + let unknown = consumer.request_broadcast(Path::new("room/alice").unwrap(), crate::Epoch::mint()); assert!(matches!(unknown.await, Err(Error::Unroutable))); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); let _published = queued(&claim).await.prepare(epoch.clone()).unwrap().publish().unwrap(); pending.await.expect("resolves"); - let pinned = consumer.request_broadcast("room/alice", epoch.clone()).await; + let pinned = consumer.request_broadcast(Path::new("room/alice").unwrap(), epoch.clone()).await; assert_eq!(pinned.expect("resolves").info().epoch.as_ref(), Some(&epoch)); - let stale = consumer.request_broadcast("room/alice", crate::Epoch::mint()); + let stale = consumer.request_broadcast(Path::new("room/alice").unwrap(), crate::Epoch::mint()); assert!(matches!(stale.await, Err(Error::Unroutable))); } @@ -10617,8 +10617,8 @@ mod tests { #[should_panic(expected = "prepare and publish")] async fn an_application_claim_cannot_accept_an_arbitrary_broadcast() { let producer = origin(1).produce(); - let claim = producer.dynamic("room").unwrap(); - let _pending = producer.consume().request_broadcast("room/alice", None); + let claim = producer.dynamic(Path::new("room").unwrap()).unwrap(); + let _pending = producer.consume().request_broadcast(Path::new("room/alice").unwrap(), None); queued(&claim).await.accept(broadcast::Info::new().produce()); } @@ -10629,11 +10629,11 @@ mod tests { async fn refusal_never_falls_through() { let producer = origin(1).produce(); let consumer = producer.consume(); - let catch_all = producer.dynamic_route("", Route::default()).unwrap(); - let winner = producer.dynamic_route("room", Route::default()).unwrap(); - let sibling = producer.dynamic_route("room", Route::default().with_cost(2)).unwrap(); + let catch_all = producer.dynamic_route(Path::new("").unwrap(), Route::default()).unwrap(); + let winner = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); + let sibling = producer.dynamic_route(Path::new("room").unwrap(), Route::default().with_cost(2)).unwrap(); - let mut pending = Box::pin(consumer.request_broadcast("room/alice", None)); + let mut pending = Box::pin(consumer.request_broadcast(Path::new("room/alice").unwrap(), None)); assert!((&mut pending).now_or_never().is_none()); queued(&winner).await.reject(Error::NotFound); let mut result = None; @@ -10657,14 +10657,14 @@ mod tests { async fn superseded_refusal_does_not_end_the_request() { let producer = origin(1).produce(); let consumer = producer.consume(); - let stale = producer.dynamic_route("room", Route::default()).unwrap(); + let stale = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); - let mut pending = Box::pin(consumer.request_broadcast("room/alice", None)); + let mut pending = Box::pin(consumer.request_broadcast(Path::new("room/alice").unwrap(), None)); assert!((&mut pending).now_or_never().is_none()); let request = queued(&stale).await; // The local broadcast wins before the front sees the rejection. - let local = producer.create_broadcast("room/alice").unwrap(); + let local = producer.create_broadcast(Path::new("room/alice").unwrap()).unwrap(); local.announce(Route::default()).unwrap(); request.reject(Error::NotFound); @@ -10684,13 +10684,13 @@ mod tests { async fn refusal_from_a_beaten_route_asks_the_new_winner() { let producer = origin(1).produce(); let consumer = producer.consume(); - let stale = producer.dynamic_route("room", Route::default()).unwrap(); + let stale = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); - let mut pending = Box::pin(consumer.request_broadcast("room/alice", None)); + let mut pending = Box::pin(consumer.request_broadcast(Path::new("room/alice").unwrap(), None)); assert!((&mut pending).now_or_never().is_none()); let request = queued(&stale).await; - let winner = producer.dynamic_route("room/alice", Route::default()).unwrap(); + let winner = producer.dynamic_route(Path::new("room/alice").unwrap(), Route::default()).unwrap(); request.reject(Error::NotFound); let source = broadcast::Info::new().produce(); queued(&winner).await.accept(&source); @@ -10711,9 +10711,9 @@ mod tests { async fn routed_broadcast_waits_out_a_rejection() { let producer = origin(1).produce(); let consumer = producer.consume(); - let server = producer.dynamic_route("room", Route::default()).unwrap(); + let server = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); - let mut resolving = Box::pin(consumer.routed_broadcast("room/alice")); + let mut resolving = Box::pin(consumer.routed_broadcast(Path::new("room/alice").unwrap())); assert!((&mut resolving).now_or_never().is_none()); let request = queued(&server).await; request.reject(Error::Unroutable); @@ -10740,10 +10740,10 @@ mod tests { async fn routed_broadcast_reports_teardown_as_closed() { let (producer, driver) = Producer::new(Config::new(origin(1))); let consumer = producer.consume(); - let _server = producer.dynamic_route("room", Route::default()).unwrap(); + let _server = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); // Park on the covering route, past the loop's closed check. - let mut resolving = Box::pin(consumer.routed_broadcast("room/alice")); + let mut resolving = Box::pin(consumer.routed_broadcast(Path::new("room/alice").unwrap())); assert!((&mut resolving).now_or_never().is_none()); drop(driver); @@ -10763,9 +10763,9 @@ mod tests { async fn routed_broadcast_wakes_for_a_local_broadcast() { let producer = origin(1).produce(); let consumer = producer.consume(); - let server = producer.dynamic_route("room", Route::default()).unwrap(); + let server = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); - let mut resolving = Box::pin(consumer.routed_broadcast("room/alice")); + let mut resolving = Box::pin(consumer.routed_broadcast(Path::new("room/alice").unwrap())); assert!((&mut resolving).now_or_never().is_none()); queued(&server).await.reject(Error::Unroutable); for _ in 0..20 { @@ -10774,7 +10774,7 @@ mod tests { assert!((&mut resolving).now_or_never().is_none()); // The more specific route wins outright over the handler's prefix. - let _local = producer.publish("room/alice", Route::default()).unwrap(); + let _local = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); let resolved = resolving.await.expect("resolves locally"); assert_eq!(resolved.info().path.as_str(), "room/alice"); assert!(server.poll_requested_broadcast(&kio::Waiter::noop()).is_pending()); @@ -10787,7 +10787,7 @@ mod tests { async fn late_track_on_a_served_front_replays() { let producer = origin(1).produce(); let consumer = producer.consume(); - let server = producer.dynamic_route("room", Route::default()).unwrap(); + let server = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); let source = broadcast::Info::new().produce(); for name in ["a", "b"] { @@ -10799,7 +10799,7 @@ mod tests { std::mem::forget(track); } - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); queued(&server).await.accept(&source); let resolved = pending.await.expect("resolves"); @@ -10827,13 +10827,13 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); - let broad_server = producer.dynamic_route("", Route::default()).unwrap(); + let broad_server = producer.dynamic_route(Path::new("").unwrap(), Route::default()).unwrap(); // A narrow advertise-only claim: requests under it must NOT route to the // broad server; they fall through to the (absent) fallback handler. - let _narrow = producer.announce(".dash", Route::default()).unwrap(); + let _narrow = producer.announce(Path::new(".dash").unwrap(), Route::default()).unwrap(); let err = consumer - .request_broadcast(".dash/pid", None) + .request_broadcast(Path::new(".dash/pid").unwrap(), None) .now_or_never() .expect("unroutable") .err() @@ -10841,7 +10841,7 @@ mod tests { assert!(matches!(err, Error::Unroutable)); // Everything else still routes to the broad server. - let _pending = consumer.request_broadcast("room/alice", None); + let _pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); let request = queued(&broad_server).await; assert_eq!(request.path().as_str(), "room/alice"); } @@ -10852,11 +10852,11 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let mut announced = consumer.announced(); - let dynamic = producer.dynamic_route("", Route::default()).unwrap(); + let dynamic = producer.dynamic_route(Path::new("").unwrap(), Route::default()).unwrap(); // The root claim is advertised like any other prefix. - announced.expect_next_active("").await; + announced.expect_next_active(Path::new("").unwrap()).await; - let pending = consumer.request_broadcast("anything/at/all", None); + let pending = consumer.request_broadcast(Path::new("anything/at/all").unwrap(), None); let request = queued(&dynamic).await; assert_eq!(request.path().as_str(), "anything/at/all"); @@ -10867,9 +10867,9 @@ mod tests { // Nothing serves an uncovered path once the handler is gone. drop(dynamic); - announced.expect_next_ended("").await; + announced.expect_next_ended(Path::new("").unwrap()).await; let err = consumer - .request_broadcast("something/else", None) + .request_broadcast(Path::new("something/else").unwrap(), None) .now_or_never() .expect("unroutable") .err() @@ -10886,14 +10886,14 @@ mod tests { #[cfg(feature = "async")] async fn out_of_scope_request_never_reaches_the_dynamic_handler() { let producer = origin(1).produce(); - let dynamic = producer.dynamic_route("", Route::default()).unwrap(); - let scoped = producer.consume().scope("", &scopes(&["tenant-a"])).unwrap(); + let dynamic = producer.dynamic_route(Path::new("").unwrap(), Route::default()).unwrap(); + let scoped = producer.consume().scope(Path::new("").unwrap(), &scopes(&["tenant-a"])).unwrap(); // `tenant-a-other` shares a character prefix but not a segment, so this // also pins that the check is segment-aware rather than textual. for path in ["tenant-b/live", "tenant-a-other/live"] { let refused = scoped - .request_broadcast(path, None) + .request_broadcast(Path::new(path).unwrap(), None) .now_or_never() .expect("an out-of-scope request must be refused synchronously, not queued"); assert!(matches!(refused, Err(Error::Unauthorized))); @@ -10910,17 +10910,17 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); - let mut fut = consumer.routed("room/alice").boxed(); + let mut fut = consumer.routed(Path::new("room/alice").unwrap()).boxed(); assert!((&mut fut).now_or_never().is_none()); // A covering prefix resolves the wait. - let _a = producer.announce("room", Route::default().with_cost(3)).unwrap(); + let _a = producer.announce(Path::new("room").unwrap(), Route::default().with_cost(3)).unwrap(); let route = fut.now_or_never().expect("covered").expect("routed"); assert_eq!(route.cost, Cost::new(3)); // Already covered: resolves immediately. consumer - .routed("room/alice/cam") + .routed(Path::new("room/alice/cam").unwrap()) .now_or_never() .expect("covered") .expect("routed"); @@ -10933,11 +10933,11 @@ mod tests { let consumer = producer.consume(); // A deeper route does not cover the shorter path. - let _deep = producer.announce("room/alice/cam", Route::default()).unwrap(); - let mut fut = consumer.routed("room/alice").boxed(); + let _deep = producer.announce(Path::new("room/alice/cam").unwrap(), Route::default()).unwrap(); + let mut fut = consumer.routed(Path::new("room/alice").unwrap()).boxed(); assert!((&mut fut).now_or_never().is_none()); - let _exact = producer.announce("room/alice", Route::default()).unwrap(); + let _exact = producer.announce(Path::new("room/alice").unwrap(), Route::default()).unwrap(); fut.now_or_never().expect("covered").expect("routed"); } @@ -10950,15 +10950,15 @@ mod tests { .map(|i| format!("s{i}")) .collect::>() .join("/"); - assert_eq!(Path::new(&path).parts().count(), Path::MAX_PARTS); + assert_eq!(Path::new(&path).unwrap().parts().count(), Path::MAX_PARTS); assert!(consumer.allowed().matches(&path)); - let mut fut = consumer.routed(&path).boxed(); + let mut fut = consumer.routed(Path::new(&path).unwrap()).boxed(); assert!((&mut fut).now_or_never().is_none()); // A covering root still resolves: the lookup must not require `path/**`. - let _a = producer.announce("", Route::default()).unwrap(); + let _a = producer.announce(Path::new("").unwrap(), Route::default()).unwrap(); fut.now_or_never().expect("covered").expect("routed"); } @@ -10967,25 +10967,25 @@ mod tests { async fn teardown_ends_everything() { let (producer, driver) = Producer::new(Config::new(origin(1))); let consumer = producer.consume(); - let _announcement = producer.announce("room", Route::default()).unwrap(); + let _announcement = producer.announce(Path::new("room").unwrap(), Route::default()).unwrap(); let mut announced = consumer.announced(); - announced.expect_next_active("room").await; + announced.expect_next_active(Path::new("room").unwrap()).await; - let _server = producer.dynamic_route("served", Route::default()).unwrap(); - let pending = consumer.request_broadcast("served/path", None); + let _server = producer.dynamic_route(Path::new("served").unwrap(), Route::default()).unwrap(); + let pending = consumer.request_broadcast(Path::new("served/path").unwrap(), None); drop(driver); // The cursor observes the end (after draining pending updates). - announced.expect_next_active("served").await; + announced.expect_next_active(Path::new("served").unwrap()).await; assert!(announced.next().now_or_never().expect("ended").is_none()); // Pending requests reject; new work refuses. assert!(matches!(pending.now_or_never().expect("rejected"), Err(Error::Closed))); - assert!(matches!(producer.announce("x", Route::default()), Err(Error::Closed))); - assert!(matches!(producer.create_broadcast("x"), Err(Error::Closed))); + assert!(matches!(producer.announce(Path::new("x").unwrap(), Route::default()), Err(Error::Closed))); + assert!(matches!(producer.create_broadcast(Path::new("x").unwrap()), Err(Error::Closed))); let err = consumer - .request_broadcast("y", None) + .request_broadcast(Path::new("y").unwrap(), None) .now_or_never() .expect("closed") .err() @@ -11002,13 +11002,13 @@ mod tests { #[cfg(feature = "async")] fn teardown_owes_what_a_snapshot_held() { let (producer, driver) = Producer::new(Config::new(origin(1))); - let snapshot = producer.snapshot("room"); + let snapshot = producer.snapshot(Path::new("room").unwrap()); let mut announced = producer.consume().announced(); - let _alice = producer.announce("room/alice", Route::default()).unwrap(); + let _alice = producer.announce(Path::new("room/alice").unwrap(), Route::default()).unwrap(); drop(driver); assert!(!announced.is_synced(), "the queue is still owed"); - announced.assert_next_active("room/alice"); + announced.assert_next_active(Path::new("room/alice").unwrap()); assert!(announced.is_synced()); drop(snapshot); } @@ -11016,8 +11016,8 @@ mod tests { #[test] fn internal_route_requests_are_closed_on_teardown() { let (producer, mut driver) = Producer::new(Config::new(origin(1))); - let server = producer.dynamic_route("room", Route::default()).unwrap(); - let _pending = producer.consume().request_broadcast("room/alice", None); + let server = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); + let _pending = producer.consume().request_broadcast(Path::new("room/alice").unwrap(), None); driver.poll(Instant::now(), &kio::Waiter::noop()).unwrap(); let Poll::Ready(Ok(request)) = server.poll_requested_broadcast(&kio::Waiter::noop()) else { panic!("front requested its route"); @@ -11048,10 +11048,10 @@ mod tests { let consumer = producer.consume(); let server = producer - .dynamic_route("room", Route::default().with_epoch(epoch()).with_hops(hops(first))) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_epoch(epoch()).with_hops(hops(first))) .unwrap(); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); let request = queued(&server).await; let source = broadcast::Info::new().produce(); let track = source.create_track("video", crate::track::Info::timed()).unwrap(); @@ -11091,7 +11091,7 @@ mod tests { /// back its handle, ready to answer the front's re-request. fn standby(&self, first: &[u64]) -> Dynamic { self.producer - .dynamic_route("room", Route::default().with_epoch(epoch()).with_hops(hops(first))) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_epoch(epoch()).with_hops(hops(first))) .unwrap() } } @@ -11145,9 +11145,9 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let first = producer - .dynamic_route("room", Route::default().with_hops(hops(&[10])).with_cost(5)) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_hops(hops(&[10])).with_cost(5)) .unwrap(); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); let source = broadcast::Info::new().produce(); let track = source.create_track("video", crate::track::Info::timed()).unwrap(); queued(&first).await.accept(&source); @@ -11156,7 +11156,7 @@ mod tests { deliver(&track, &mut subscription, b"first").await; let second = producer - .dynamic_route("room", Route::default().with_hops(hops(&[11])).with_cost(1)) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_hops(hops(&[11])).with_cost(1)) .unwrap(); deliver(&track, &mut subscription, b"pinned").await; @@ -11183,25 +11183,25 @@ mod tests { let consumer = producer.consume(); let old = producer .publish( - "room/alice", + Path::new("room/alice").unwrap(), Route::default().with_epoch(crate::Epoch::mint()).with_cost(1), ) .unwrap(); let old_track = old.create_track("video", crate::track::Info::timed()).unwrap(); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); deliver(&old_track, &mut subscription, b"old").await; let new = producer .publish( - "room/alice", + Path::new("room/alice").unwrap(), Route::default().with_epoch(crate::Epoch::mint()).with_cost(9), ) .unwrap(); let new_track = new.create_track("video", crate::track::Info::timed()).unwrap(); deliver(&old_track, &mut subscription, b"sticky").await; - let replaced = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let replaced = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); assert!(!replaced.is_clone(&resolved)); let mut fresh = replaced.track("video").unwrap().subscribe(None).await.unwrap(); deliver(&new_track, &mut fresh, b"new").await; @@ -11227,10 +11227,10 @@ mod tests { let consumer = producer.consume(); let first = crate::Epoch::mint(); let old = producer - .publish("room/alice", Route::default().with_epoch(first.clone())) + .publish(Path::new("room/alice").unwrap(), Route::default().with_epoch(first.clone())) .unwrap(); let _old_track = old.create_track("video", crate::track::Info::timed()).unwrap(); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); assert_eq!( resolved.info().epoch.as_ref(), Some(&first), @@ -11239,11 +11239,11 @@ mod tests { let epoch = crate::Epoch::mint(); let new = producer - .publish("room/alice", Route::default().with_epoch(epoch.clone())) + .publish(Path::new("room/alice").unwrap(), Route::default().with_epoch(epoch.clone())) .unwrap(); let new_track = new.create_track("video", crate::track::Info::timed()).unwrap(); - let named = consumer.request_broadcast("room/alice", epoch.clone()); - let bare = consumer.request_broadcast("room/alice", None); + let named = consumer.request_broadcast(Path::new("room/alice").unwrap(), epoch.clone()); + let bare = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); let named = named.await.expect("the new epoch resolves"); let bare = bare.await.expect("the new epoch resolves"); @@ -11270,14 +11270,14 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let old = producer - .dynamic_route("room", Route::default().with_epoch(crate::Epoch::mint())) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_epoch(crate::Epoch::mint())) .unwrap(); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); let request = queued(&old).await; // The answer and the newer epoch land in the same tick. let new = producer - .publish("room/alice", Route::default().with_epoch(crate::Epoch::mint())) + .publish(Path::new("room/alice").unwrap(), Route::default().with_epoch(crate::Epoch::mint())) .unwrap(); let new_track = new.create_track("video", crate::track::Info::timed()).unwrap(); let stale = broadcast::Info::new().produce(); @@ -11300,10 +11300,10 @@ mod tests { let consumer = producer.consume(); let old = crate::Epoch::mint(); let dynamic = producer - .dynamic_route("room", Route::default().with_epoch(old.clone())) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_epoch(old.clone())) .unwrap(); - let pending = consumer.request_broadcast("room/alice", None); - let pinned = consumer.request_broadcast("room/alice", old); + let pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); + let pinned = consumer.request_broadcast(Path::new("room/alice").unwrap(), old); let request = queued(&dynamic).await; let stale = broadcast::Info::new().produce(); @@ -11327,7 +11327,7 @@ mod tests { matches!(pinned.await, Err(Error::Unroutable)), "a request pinned to the old epoch resolved" ); - let cached = dynamic.state.lock().served.get(&Path::new("room/alice").to_owned()); + let cached = dynamic.state.lock().served.get(&Path::new("room/alice").unwrap().to_owned()); assert!( cached.is_some_and(|cached| cached.consume().is_clone(&fresh.consume())), "the old answer was cached" @@ -11356,9 +11356,9 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let dynamic = producer - .dynamic_route("room", Route::default().with_epoch(crate::Epoch::mint())) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_epoch(crate::Epoch::mint())) .unwrap(); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); queued(&dynamic).await.reject(Error::NotFound); let epoch = crate::Epoch::mint(); dynamic.update_route(dynamic.route().with_epoch(epoch.clone())).unwrap(); @@ -11381,9 +11381,9 @@ mod tests { let consumer = producer.consume(); let old = crate::Epoch::mint(); let dynamic = producer - .dynamic_route("room", Route::default().with_epoch(old.clone())) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_epoch(old.clone())) .unwrap(); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); let request = queued(&dynamic).await; dynamic @@ -11411,8 +11411,8 @@ mod tests { async fn losing_an_epoch_is_another_instance() { let producer = origin(1).produce(); let consumer = producer.consume(); - let dynamic = producer.dynamic_route("room", Route::default()).unwrap(); - let pending = consumer.request_broadcast("room/alice", None); + let dynamic = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); + let pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); let old = broadcast::Info::new().produce(); let _old_track = old.create_track("video", crate::track::Info::timed()).unwrap(); queued(&dynamic).await.accept(&old); @@ -11425,7 +11425,7 @@ mod tests { route.epoch = None; dynamic.update_route(route).unwrap(); - let retry = consumer.request_broadcast("room/alice", None); + let retry = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); let fresh = broadcast::Info::new().produce(); let _fresh_track = fresh.create_track("video", crate::track::Info::timed()).unwrap(); queued(&dynamic).await.accept(&fresh); @@ -11442,24 +11442,24 @@ mod tests { let mut announced = producer.consume().announced(); let _old = producer .publish( - "room/alice", + Path::new("room/alice").unwrap(), Route::default().with_epoch(crate::Epoch::mint()).with_cost(1), ) .unwrap(); let old = announced - .expect_next_active("room/alice") + .expect_next_active(Path::new("room/alice").unwrap()) .await .epoch .expect("announced"); let new = producer .publish( - "room/alice", + Path::new("room/alice").unwrap(), Route::default().with_epoch(crate::Epoch::mint()).with_cost(9), ) .unwrap(); let newest = announced - .expect_next_restarted("room/alice") + .expect_next_restarted(Path::new("room/alice").unwrap()) .await .epoch .expect("announced"); @@ -11467,7 +11467,7 @@ mod tests { // The older one still stands, so it comes back once the newer one goes. drop(new); - assert_eq!(announced.expect_next_restarted("room/alice").await.epoch, Some(old)); + assert_eq!(announced.expect_next_restarted(Path::new("room/alice").unwrap()).await.epoch, Some(old)); } /// A peer naming one publisher instance is never handed another. @@ -11477,14 +11477,14 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let _broadcast = producer - .publish("room/alice", Route::default().with_epoch(epoch())) + .publish(Path::new("room/alice").unwrap(), Route::default().with_epoch(epoch())) .unwrap(); let other: crate::Epoch = "01900000-0000-7000-8000-000000000002".parse().unwrap(); - let refused = consumer.request_broadcast("room/alice", other).await; + let refused = consumer.request_broadcast(Path::new("room/alice").unwrap(), other).await; assert!(matches!(refused, Err(Error::Unroutable))); let named = consumer - .request_broadcast("room/alice", epoch()) + .request_broadcast(Path::new("room/alice").unwrap(), epoch()) .await .expect("the named epoch resolves"); assert_eq!(named.info().epoch.as_ref(), Some(&epoch())); @@ -11495,10 +11495,10 @@ mod tests { #[cfg(feature = "async")] async fn a_route_without_an_epoch_resolves_without_one() { let producer = origin(1).produce(); - let _broadcast = producer.publish("room/alice", Route::default()).unwrap(); + let _broadcast = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); let resolved = producer .consume() - .request_broadcast("room/alice", None) + .request_broadcast(Path::new("room/alice").unwrap(), None) .await .expect("resolves"); assert_eq!(resolved.info().epoch, None); @@ -11634,7 +11634,7 @@ mod tests { let resolved = rig .producer .consume() - .request_broadcast("room/alice", None) + .request_broadcast(Path::new("room/alice").unwrap(), None) .await .unwrap(); assert!(resolved.is_clone(&rig.resolved), "first hop {first:?} left the front"); @@ -11658,14 +11658,14 @@ mod tests { None => producer.consume(), }; let incumbent = producer - .dynamic_route("room", Route::default().with_epoch(epoch()).with_hops(hops(&[10]))) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_epoch(epoch()).with_hops(hops(&[10]))) .unwrap(); // The same publisher, reached through the requesting peer. let echo = producer - .dynamic_route("room", Route::default().with_epoch(epoch()).with_hops(hops(&[10, 7]))) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_epoch(epoch()).with_hops(hops(&[10, 7]))) .unwrap(); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); let request = queued(&incumbent).await; let source = broadcast::Info::new().produce(); let track = source.create_track("video", crate::track::Info::timed()).unwrap(); @@ -11725,13 +11725,13 @@ mod tests { // Session A: an assigned anonymous hop serving the path. let server_a = producer - .dynamic_route("room", Route::default().with_hops(hops(&[10]))) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_hops(hops(&[10]))) .unwrap(); // Session C: a third anonymous session, excluding the hop the server // minted for it, the same split-horizon a live session applies. let consumer = producer.consume().excluding(origin(30)); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); let request = queued(&server_a).await; let source_a = broadcast::Info::new().produce(); let track_a = source_a.create_track("video", crate::track::Info::timed()).unwrap(); @@ -11770,10 +11770,10 @@ mod tests { // No stale front at the leaf, and a repeat request does not join the // corpse: nothing covers the path, so it is Unroutable rather than // parked on a linger or 404 `dropped` from the dead front. - settle(|| consumer.get_broadcast("room/alice").is_none()).await; + settle(|| consumer.get_broadcast(Path::new("room/alice").unwrap()).is_none()).await; settle(|| { matches!( - consumer.request_broadcast("room/alice", None).now_or_never(), + consumer.request_broadcast(Path::new("room/alice").unwrap(), None).now_or_never(), Some(Err(Error::Unroutable)) ) }) @@ -11781,9 +11781,9 @@ mod tests { // Session B attaches at the same path. Its front is served immediately. let server_b = producer - .dynamic_route("room", Route::default().with_hops(hops(&[20]))) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_hops(hops(&[20]))) .unwrap(); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); let request = queued(&server_b).await; let source_b = broadcast::Info::new().produce(); let track_b = source_b.create_track("video", crate::track::Info::timed()).unwrap(); @@ -11880,22 +11880,22 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); - let first = producer.publish("room/alice", Route::default()).unwrap(); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let first = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); - let second = producer.publish("room/alice", Route::default()).unwrap(); - let again = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let second = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let again = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); assert!(!again.is_clone(&resolved)); // Losing one source leaves the path served; losing both frees it. second.close(); - settle(|| consumer.get_broadcast("room/alice").is_some()).await; + settle(|| consumer.get_broadcast(Path::new("room/alice").unwrap()).is_some()).await; first.close(); - settle(|| consumer.get_broadcast("room/alice").is_none()).await; + settle(|| consumer.get_broadcast(Path::new("room/alice").unwrap()).is_none()).await; // The path is free again for a fresh broadcast. - let _third = producer.publish("room/alice", Route::default()).unwrap(); - assert!(consumer.get_broadcast("room/alice").is_some()); + let _third = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + assert!(consumer.get_broadcast(Path::new("room/alice").unwrap()).is_some()); } /// The publisher finishes a track, then its broadcast. A subscription already in @@ -11911,10 +11911,10 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); - let broadcast = producer.publish("room/alice", Route::default()).unwrap(); + let broadcast = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); let mut subscription = resolved .track("video") .unwrap() @@ -11954,10 +11954,10 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let server = producer - .dynamic_route("room", Route::default().with_hops(hops(&[10]))) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_hops(hops(&[10]))) .unwrap(); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); let request = queued(&server).await; let source = broadcast::Info::new().produce(); let track = source.create_track("video", crate::track::Info::timed()).unwrap(); @@ -12002,9 +12002,9 @@ mod tests { async fn a_closed_source_is_not_requested_again_from_its_standing_route() { let producer = origin(1).produce(); let server = producer - .dynamic_route("room", Route::default().with_hops(hops(&[10]))) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_hops(hops(&[10]))) .unwrap(); - let pending = producer.consume().request_broadcast("room/alice", None); + let pending = producer.consume().request_broadcast(Path::new("room/alice").unwrap(), None); let source = broadcast::Info::new().produce(); queued(&server).await.accept(&source); let resolved = pending.await.unwrap(); @@ -12027,13 +12027,13 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); - let broadcast = producer.publish("room/alice", Route::default()).unwrap(); + let broadcast = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"cached".as_ref()).unwrap(); group.finish().unwrap(); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); let mut subscription = resolved .track("video") .unwrap() @@ -12089,9 +12089,9 @@ mod tests { async fn a_held_group_continues_after_its_track_goes_unread() { let producer = origin(1).produce(); let server = producer - .dynamic_route("live", Route::default().with_hops(hops(&[10]))) + .dynamic_route(Path::new("live").unwrap(), Route::default().with_hops(hops(&[10]))) .unwrap(); - let pending = producer.consume().request_broadcast("live", None); + let pending = producer.consume().request_broadcast(Path::new("live").unwrap(), None); let source = broadcast::Info::new().produce(); let track = source.create_track("video", crate::track::Info::timed()).unwrap(); queued(&server).await.accept(&source); @@ -12129,9 +12129,9 @@ mod tests { #[cfg(feature = "async")] async fn a_group_the_source_aborts_ends_while_the_track_lives() { let producer = origin(1).produce(); - let broadcast = producer.publish("live", Route::default()).unwrap(); + let broadcast = producer.publish(Path::new("live").unwrap(), Route::default()).unwrap(); let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); - let resolved = producer.consume().request_broadcast("live", None).await.unwrap(); + let resolved = producer.consume().request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); let mut aborted = track.append_group().unwrap(); @@ -12164,7 +12164,7 @@ mod tests { let leaf = origin(1).produce(); let leaf_consumer = leaf.consume(); - let broadcast = leaf.publish("room/alice", Route::default()).unwrap(); + let broadcast = leaf.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"cached".as_ref()).unwrap(); @@ -12172,23 +12172,23 @@ mod tests { // The leaf's front view, which the next front serves from. let leaf_front = leaf_consumer - .request_broadcast("room/alice", None) + .request_broadcast(Path::new("room/alice").unwrap(), None) .await .expect("resolves"); let mid = origin(2).produce(); let mid_server = mid - .dynamic_route("room", Route::default().with_hops(hops(&[10]))) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_hops(hops(&[10]))) .unwrap(); - let mid_pending = mid.consume().request_broadcast("room/alice", None); + let mid_pending = mid.consume().request_broadcast(Path::new("room/alice").unwrap(), None); queued(&mid_server).await.accept(&leaf_front); let mid_resolved = mid_pending.await.expect("mid resolves"); let edge = origin(3).produce(); let edge_server = edge - .dynamic_route("room", Route::default().with_hops(hops(&[20]))) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_hops(hops(&[20]))) .unwrap(); - let edge_pending = edge.consume().request_broadcast("room/alice", None); + let edge_pending = edge.consume().request_broadcast(Path::new("room/alice").unwrap(), None); queued(&edge_server).await.accept(&mid_resolved); let edge_resolved = edge_pending.await.expect("edge resolves"); @@ -12264,10 +12264,10 @@ mod tests { let consumer = producer.consume(); let first = producer - .publish("room/alice", Route::default().with_epoch(epoch())) + .publish(Path::new("room/alice").unwrap(), Route::default().with_epoch(epoch())) .unwrap(); let track = first.create_track("video", crate::track::Info::timed()).unwrap(); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); let mut subscription = resolved .track("video") .unwrap() @@ -12282,7 +12282,7 @@ mod tests { // The newest source is dispatched the track, and refused for its metadata. let second = producer - .publish("room/alice", Route::default().with_epoch(epoch())) + .publish(Path::new("room/alice").unwrap(), Route::default().with_epoch(epoch())) .unwrap(); let _incompatible = second .create_track("video", track::Info::default().with_timescale(crate::Timescale::MICRO)) @@ -12316,9 +12316,9 @@ mod tests { ) { let producer = origin(1).produce(); let server = producer - .dynamic_route("room", Route::default().with_epoch(epoch()).with_hops(hops(&[10]))) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_epoch(epoch()).with_hops(hops(&[10]))) .unwrap(); - let pending = producer.consume().request_broadcast("room/alice", None); + let pending = producer.consume().request_broadcast(Path::new("room/alice").unwrap(), None); let upstream = broadcast::Info::new().produce(); let old = upstream.create_track("video", crate::track::Info::timed()).unwrap(); queued(&server).await.accept(&upstream); @@ -12340,7 +12340,7 @@ mod tests { async fn an_unread_draining_track_releases_the_old_source() { let (producer, _server, _upstream, old, subscription) = remote_front().await; - let newcomer = producer.create_broadcast("room/alice").unwrap(); + let newcomer = producer.create_broadcast(Path::new("room/alice").unwrap()).unwrap(); let mut handler = newcomer.dynamic(); newcomer.announce(Route::default().with_epoch(epoch())).unwrap(); let _unanswered = moq_clock::timeout(Duration::from_secs(1), handler.requested_track()) @@ -12363,11 +12363,11 @@ mod tests { #[cfg(feature = "async")] async fn a_returning_reader_is_not_stranded_on_a_dropped_copy() { let (producer, _server, upstream, old, mut subscription) = remote_front().await; - let resolved = producer.consume().request_broadcast("room/alice", None).await.unwrap(); + let resolved = producer.consume().request_broadcast(Path::new("room/alice").unwrap(), None).await.unwrap(); // No handler and no track: refuses "video" with NotFound. let _second = producer - .publish("room/alice", Route::default().with_epoch(epoch())) + .publish(Path::new("room/alice").unwrap(), Route::default().with_epoch(epoch())) .unwrap(); for _ in 0..10 { moq_clock::sim::yield_now().await; @@ -12386,7 +12386,7 @@ mod tests { .expect("open"); let _third = producer - .publish("room/alice", Route::default().with_epoch(epoch())) + .publish(Path::new("room/alice").unwrap(), Route::default().with_epoch(epoch())) .unwrap(); for _ in 0..10 { moq_clock::sim::yield_now().await; @@ -12421,7 +12421,7 @@ mod tests { #[cfg(feature = "async")] async fn a_parked_track_serves_whole_groups_from_its_copy() { let (producer, _server, _upstream, old, subscription) = remote_front().await; - let resolved = producer.consume().request_broadcast("room/alice", None).await.unwrap(); + let resolved = producer.consume().request_broadcast(Path::new("room/alice").unwrap(), None).await.unwrap(); let mut open = old.append_group().unwrap(); open.write_frame(crate::Timestamp::ZERO, b"open".as_ref()).unwrap(); drop(subscription); @@ -12454,7 +12454,7 @@ mod tests { #[cfg(feature = "async")] async fn a_new_source_unparks_the_old_copy() { let (producer, _server, _upstream, old, subscription) = remote_front().await; - let resolved = producer.consume().request_broadcast("room/alice", None).await.unwrap(); + let resolved = producer.consume().request_broadcast(Path::new("room/alice").unwrap(), None).await.unwrap(); drop(subscription); moq_clock::timeout(Duration::from_secs(1), old.demand().until(|wanted| wanted.is_none())) .await @@ -12462,7 +12462,7 @@ mod tests { .expect("open"); let newcomer = producer - .publish("room/alice", Route::default().with_epoch(epoch())) + .publish(Path::new("room/alice").unwrap(), Route::default().with_epoch(epoch())) .unwrap(); let _video = newcomer.create_track("video", crate::track::Info::timed()).unwrap(); for _ in 0..10 { @@ -12485,10 +12485,10 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let first = producer - .publish("room/alice", Route::default().with_epoch(epoch())) + .publish(Path::new("room/alice").unwrap(), Route::default().with_epoch(epoch())) .unwrap(); let track = first.create_track("video", crate::track::Info::timed()).unwrap(); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"before".as_ref()).unwrap(); @@ -12497,7 +12497,7 @@ mod tests { assert_eq!(&group.read_frame().await.unwrap().unwrap().payload[..], b"before"); let second = producer - .publish("room/alice", Route::default().with_epoch(epoch())) + .publish(Path::new("room/alice").unwrap(), Route::default().with_epoch(epoch())) .unwrap(); let incompatible = second .create_track("video", track::Info::default().with_timescale(crate::Timescale::MICRO)) @@ -12522,10 +12522,10 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let first = producer - .publish("room/alice", Route::default().with_epoch(epoch())) + .publish(Path::new("room/alice").unwrap(), Route::default().with_epoch(epoch())) .unwrap(); let track = first.create_track("video", crate::track::Info::timed()).unwrap(); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"before".as_ref()).unwrap(); @@ -12535,7 +12535,7 @@ mod tests { drop(group); let second = producer - .publish("room/alice", Route::default().with_epoch(epoch())) + .publish(Path::new("room/alice").unwrap(), Route::default().with_epoch(epoch())) .unwrap(); let incompatible = second .create_track("video", track::Info::default().with_timescale(crate::Timescale::MICRO)) @@ -12578,10 +12578,10 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let first = producer - .publish("room/alice", Route::default().with_epoch(epoch())) + .publish(Path::new("room/alice").unwrap(), Route::default().with_epoch(epoch())) .unwrap(); let track = first.create_track("video", crate::track::Info::timed()).unwrap(); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"before".as_ref()).unwrap(); @@ -12590,7 +12590,7 @@ mod tests { assert_eq!(&group.read_frame().await.unwrap().unwrap().payload[..], b"before"); drop(group); - let second = producer.create_broadcast("room/alice").unwrap(); + let second = producer.create_broadcast(Path::new("room/alice").unwrap()).unwrap(); let mut handler = second.dynamic(); second.announce(Route::default().with_epoch(epoch())).unwrap(); let request = moq_clock::timeout(Duration::from_secs(1), handler.requested_track()) @@ -12617,11 +12617,11 @@ mod tests { #[moq_clock::test] async fn multiple_scopes_present_one_broad_prefix() { let producer = origin(1).produce(); - let _a = producer.announce("", Route::default()).unwrap(); + let _a = producer.announce(Path::new("").unwrap(), Route::default()).unwrap(); - let consumer = producer.consume().scope("", &scopes(&["alpha", "beta"])).unwrap(); + let consumer = producer.consume().scope(Path::new("").unwrap(), &scopes(&["alpha", "beta"])).unwrap(); let mut announced = consumer.announced(); - announced.expect_next_active("").await; + announced.expect_next_active(Path::new("").unwrap()).await; announced.assert_next_wait(); } @@ -12630,26 +12630,26 @@ mod tests { let producer = origin(1).produce(); // The root grant is `**`, the old empty prefix. - let root = producer.scope("", &Patterns::from(Pattern::all())).unwrap(); + let root = producer.scope(Path::new("").unwrap(), &Patterns::from(Pattern::all())).unwrap(); assert_eq!(root.allowed(), Patterns::from(Pattern::all())); // `foo/**` keeps the old `foo` prefix meaning. - let scoped = producer.scope("", &scopes(&["room"])).unwrap(); + let scoped = producer.scope(Path::new("").unwrap(), &scopes(&["room"])).unwrap(); assert_eq!(scoped.allowed(), scopes(&["room"])); // Multiple prefixes round-trip, with overlap collapsed. - let multi = producer.scope("", &scopes(&["room", "room/chat", "anon"])).unwrap(); + let multi = producer.scope(Path::new("").unwrap(), &scopes(&["room", "room/chat", "anon"])).unwrap(); assert_eq!(multi.allowed(), scopes(&["room", "anon"])); // The consumer side reports the same way. - let consumer = producer.consume().scope("", &scopes(&["room"])).unwrap(); + let consumer = producer.consume().scope(Path::new("").unwrap(), &scopes(&["room"])).unwrap(); assert_eq!(consumer.allowed(), scopes(&["room"])); for text in ["room", "", "*room", "room/*", "*", "**/room", "room/**/chat", "*.hang"] { let union = Patterns::from(text.parse::().unwrap()); - assert_eq!(producer.scope("", &union).expect(text).allowed(), union, "{text}"); + assert_eq!(producer.scope(Path::new("").unwrap(), &union).expect(text).allowed(), union, "{text}"); assert_eq!( - producer.consume().scope("", &union).expect(text).allowed(), + producer.consume().scope(Path::new("").unwrap(), &union).expect(text).allowed(), union, "{text}" ); @@ -12658,7 +12658,7 @@ mod tests { let mixed: Patterns = ["room/**".parse().unwrap(), "other".parse().unwrap()] .into_iter() .collect(); - assert_eq!(producer.scope("", &mixed).unwrap().allowed(), mixed); + assert_eq!(producer.scope(Path::new("").unwrap(), &mixed).unwrap().allowed(), mixed); } #[moq_clock::test] @@ -12669,14 +12669,14 @@ mod tests { // Routes and cursors hang at their prefixes; the nodes on the way exist // only while something is there. let cursor = consumer - .scope("", &scopes(&["room/a", "other/deep/head"])) + .scope(Path::new("").unwrap(), &scopes(&["room/a", "other/deep/head"])) .unwrap() .announced(); - let route = producer.announce("room/a/b/c", Route::default()).unwrap(); + let route = producer.announce(Path::new("room/a/b/c").unwrap(), Route::default()).unwrap(); { let table = producer.shared.lock(); - assert!(table.routes.root.find(Path::new("room/a/b/c").parts()).is_some()); - assert!(table.routes.root.find(Path::new("other/deep/head").parts()).is_some()); + assert!(table.routes.root.find(Path::new("room/a/b/c").unwrap().parts()).is_some()); + assert!(table.routes.root.find(Path::new("other/deep/head").unwrap().parts()).is_some()); assert_eq!(table.routes.root.cursors_below, 2); } @@ -12694,7 +12694,7 @@ mod tests { async fn a_published_broadcast_keeps_the_driver_running() { let (producer, mut driver) = Producer::new(Config::new(origin(1))); let waiter = kio::Waiter::noop(); - let broadcast = producer.create_broadcast("room/a").unwrap(); + let broadcast = producer.create_broadcast(Path::new("room/a").unwrap()).unwrap(); drop(producer); assert!( driver.poll(Instant::now(), &waiter).is_ok(), @@ -12712,10 +12712,10 @@ mod tests { let (producer, driver) = Producer::new(Config::new(origin(1))); let run = moq_clock::sim::spawn(crate::time::run(driver)); let consumer = producer.consume(); - let server = producer.dynamic_route("room", Route::default()).unwrap(); + let server = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); drop(producer); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); let request = queued(&server).await; let source = broadcast::Info::new().produce(); request.accept(&source); @@ -12739,9 +12739,9 @@ mod tests { let (producer, driver) = Producer::new(Config::new(origin(1))); let run = moq_clock::sim::spawn(crate::time::run(driver)); let consumer = producer.consume(); - let broadcast = producer.publish("room/alice", Route::default()).unwrap(); + let broadcast = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); let sub = resolved.track("video").unwrap().subscribe(None).await.unwrap(); broadcast.unannounce(); @@ -12764,9 +12764,9 @@ mod tests { let (producer, driver) = Producer::new(Config::new(origin(1))); let run = moq_clock::sim::spawn(crate::time::run(driver)); let consumer = producer.consume(); - let broadcast = producer.publish("room/alice", Route::default()).unwrap(); + let broadcast = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); let mut track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); let sub = resolved.track("video").unwrap().subscribe(None).await.unwrap(); let pending = resolved.track("video").unwrap().subscribe(None); @@ -12792,9 +12792,9 @@ mod tests { async fn a_track_unread_as_its_broadcast_ends_releases_its_source() { let producer = origin(1).produce(); let consumer = producer.consume(); - let broadcast = producer.publish("room/alice", Route::default()).unwrap(); + let broadcast = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); let sub = resolved.track("video").unwrap().subscribe(None).await.unwrap(); moq_clock::timeout(Duration::from_secs(1), track.demand().until(|wanted| wanted.is_some())) .await @@ -12817,20 +12817,20 @@ mod tests { async fn source_selection_leases_survive_reprices_but_never_revive_pending_work() { let producer = origin(1).produce(); let broad = producer - .dynamic_route("room", Route::default().with_via(origin(2))) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_via(origin(2))) .unwrap(); - let selected = broad.request_validity(&Path::new("room/a")).unwrap(); + let selected = broad.request_validity(&Path::new("room/a").unwrap()).unwrap(); let pending = selected.current(); assert!(!pending.is_closed()); broad.update_route(broad.route().with_cost(Cost::from(7))).unwrap(); assert!(!pending.is_closed()); // Another peer's winning route cannot change what a request on peer 2 names. let other = producer - .dynamic_route("room/a", Route::default().with_via(origin(3))) + .dynamic_route(Path::new("room/a").unwrap(), Route::default().with_via(origin(3))) .unwrap(); assert!(!pending.is_closed()); let replacement = producer - .dynamic_route("room/a", Route::default().with_via(origin(2))) + .dynamic_route(Path::new("room/a").unwrap(), Route::default().with_via(origin(2))) .unwrap(); assert!(pending.is_closed()); assert!(selected.current().is_closed()); @@ -12849,9 +12849,9 @@ mod tests { async fn source_selection_unregisters_without_retaining_the_source() { let producer = origin(1).produce(); let route = producer - .dynamic_route("room", Route::default().with_via(origin(2))) + .dynamic_route(Path::new("room").unwrap(), Route::default().with_via(origin(2))) .unwrap(); - let path = Path::new("room/a"); + let path = Path::new("room/a").unwrap(); let selected = route.request_validity(&path).unwrap(); let lease = selected.current(); drop(selected); @@ -12864,16 +12864,16 @@ mod tests { async fn watch_wakes_only_for_covering_changes() { let producer = origin(1).produce(); let waiter = kio::Waiter::noop(); - let watch = producer.shared.lock().watch(&producer.shared, &Path::new("room/a")); + let watch = producer.shared.lock().watch(&producer.shared, &Path::new("room/a").unwrap()); let seen = watch.seen(); // A route beside the path or beneath it covers nothing at the path. - let _other = producer.announce("other", Route::default()).unwrap(); - let _below = producer.announce("room/a/b", Route::default()).unwrap(); + let _other = producer.announce(Path::new("other").unwrap(), Route::default()).unwrap(); + let _below = producer.announce(Path::new("room/a/b").unwrap(), Route::default()).unwrap(); assert!(watch.poll_changed(&waiter, seen).is_pending()); // A route above it does, and so does its retraction. - let above = producer.announce("room", Route::default()).unwrap(); + let above = producer.announce(Path::new("room").unwrap(), Route::default()).unwrap(); assert!(watch.poll_changed(&waiter, seen).is_ready()); let seen = watch.seen(); drop(above); @@ -12881,9 +12881,9 @@ mod tests { let seen = watch.seen(); // A local broadcast attaching at the exact path does; one beside it does not. - let _beside = producer.create_broadcast("room/b").unwrap(); + let _beside = producer.create_broadcast(Path::new("room/b").unwrap()).unwrap(); assert!(watch.poll_changed(&waiter, seen).is_pending()); - let _here = producer.create_broadcast("room/a").unwrap(); + let _here = producer.create_broadcast(Path::new("room/a").unwrap()).unwrap(); assert!(watch.poll_changed(&waiter, seen).is_ready()); // Dropping the watch takes it out of the table. @@ -12892,7 +12892,7 @@ mod tests { let node = table .routes .root - .find(Path::new("room/a").parts()) + .find(Path::new("room/a").unwrap().parts()) .expect("route below keeps the node"); assert!(node.watches.is_empty()); assert_eq!(table.routes.root.watches_below, 0); @@ -12905,28 +12905,28 @@ mod tests { ..Default::default() }); let consumer = producer.consume(); - let _served = producer.dynamic_route("room", Route::default()).unwrap(); + let _served = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); // A consumer outlives its producer by design, so the task set can refuse // submissions while the origin is still open. The front's task is then // dropped on the spot, taking its `Watch` with it: the request must not // still be holding the table lock the watch unregisters under. drop(producer); - let _pending = consumer.request_broadcast("room/a", None); + let _pending = consumer.request_broadcast(Path::new("room/a").unwrap(), None); } #[moq_clock::test] async fn published_names_refuse_navigation_segments() { let producer = origin(1).produce(); for path in ["room/./cam", "room/../cam", ".", ".."] { - assert!(producer.create_broadcast(path).is_err(), "created {path}"); - assert!(producer.announce(path, Route::default()).is_err(), "announced {path}"); + assert!(producer.create_broadcast(Path::new(path).unwrap()).is_err(), "created {path}"); + assert!(producer.announce(Path::new(path).unwrap(), Route::default()).is_err(), "announced {path}"); } let scoped = producer - .scope("room/..", &Patterns::from_iter([Pattern::all()])) + .scope(Path::new("room/..").unwrap(), &Patterns::from_iter([Pattern::all()])) .unwrap(); - assert!(scoped.create_broadcast("cam").is_err()); + assert!(scoped.create_broadcast(Path::new("cam").unwrap()).is_err()); for path in ["room/.pro/cam", "room/a..b", "room/cam"] { - producer.create_broadcast(path).unwrap(); + producer.create_broadcast(Path::new(path).unwrap()).unwrap(); } } @@ -12938,11 +12938,11 @@ mod tests { // never be built: refuse the broadcast instead of publishing one that // announces nowhere. assert!(matches!( - producer.create_broadcast("room/*"), + producer.create_broadcast(Path::new("room/*").unwrap()), Err(Error::InvalidPath(_)) )); assert!(matches!( - producer.announce("room/**", Route::default()), + producer.announce(Path::new("room/**").unwrap(), Route::default()), Err(Error::InvalidPath(_)) )); } @@ -12952,9 +12952,9 @@ mod tests { let producer = origin(1).produce(); // An empty union grants nothing: scoping is refused, like a disjoint prefix. - assert!(matches!(producer.scope("", &Patterns::new()), Err(Error::Unauthorized))); + assert!(matches!(producer.scope(Path::new("").unwrap(), &Patterns::new()), Err(Error::Unauthorized))); assert!(matches!( - producer.consume().scope("", &Patterns::new()), + producer.consume().scope(Path::new("").unwrap(), &Patterns::new()), Err(Error::Unauthorized) )); } @@ -12964,23 +12964,23 @@ mod tests { let producer = origin(1).produce(); // Narrowing twice intersects; the grant stays in the new vocabulary. - let scoped = producer.scope("", &scopes(&["room"])).unwrap(); - let nested = scoped.scope("", &scopes(&["room/chat"])).unwrap(); + let scoped = producer.scope(Path::new("").unwrap(), &scopes(&["room"])).unwrap(); + let nested = scoped.scope(Path::new("").unwrap(), &scopes(&["room/chat"])).unwrap(); assert_eq!(nested.allowed(), scopes(&["room/chat"])); // A disjoint nesting is refused, not widened. assert!(matches!( - scoped.scope("", &scopes(&["other"])), + scoped.scope(Path::new("").unwrap(), &scopes(&["other"])), Err(Error::Unauthorized) )); // A literal root rebases the grant without changing its meaning. - let rooted = nested.scope("room/chat", &Patterns::from(Pattern::all())).unwrap(); + let rooted = nested.scope(Path::new("room/chat").unwrap(), &Patterns::from(Pattern::all())).unwrap(); assert_eq!(rooted.allowed(), scopes(&[""])); // Publishing through the nested view lands where the root says. - let broadcast = nested.create_broadcast("room/chat/live").unwrap(); - assert!(producer.consume().get_broadcast("room/chat/live").is_some()); + let broadcast = nested.create_broadcast(Path::new("room/chat/live").unwrap()).unwrap(); + assert!(producer.consume().get_broadcast(Path::new("room/chat/live").unwrap()).is_some()); broadcast.close(); } @@ -12988,29 +12988,29 @@ mod tests { async fn scope_intersects_and_rebases_arbitrary_grants() { let producer = origin(1).produce(); let rooms = producer - .scope("", &Patterns::from("room/*".parse::().unwrap())) + .scope(Path::new("").unwrap(), &Patterns::from("room/*".parse::().unwrap())) .unwrap(); let chats = rooms - .scope("", &Patterns::from("*/chat".parse::().unwrap())) + .scope(Path::new("").unwrap(), &Patterns::from("*/chat".parse::().unwrap())) .unwrap(); assert_eq!(chats.allowed(), Patterns::from("room/chat".parse::().unwrap())); let exact = producer - .scope("", &Patterns::from("room/alice".parse::().unwrap())) + .scope(Path::new("").unwrap(), &Patterns::from("room/alice".parse::().unwrap())) .unwrap(); - let rooted = exact.scope("room", &Patterns::from(Pattern::all())).unwrap(); + let rooted = exact.scope(Path::new("room").unwrap(), &Patterns::from(Pattern::all())).unwrap(); assert_eq!(rooted.allowed(), Patterns::from("alice".parse::().unwrap())); assert!(matches!( - exact.scope("room/bob", &Patterns::from(Pattern::all())), + exact.scope(Path::new("room/bob").unwrap(), &Patterns::from(Pattern::all())), Err(Error::Unauthorized) )); - let broadcast = exact.create_broadcast("room/alice").unwrap(); + let broadcast = exact.create_broadcast(Path::new("room/alice").unwrap()).unwrap(); assert!(matches!( - exact.create_broadcast("room/alice/cam"), + exact.create_broadcast(Path::new("room/alice/cam").unwrap()), Err(Error::Unauthorized) )); - assert!(producer.consume().get_broadcast("room/alice").is_some()); + assert!(producer.consume().get_broadcast(Path::new("room/alice").unwrap()).is_some()); drop(broadcast); } @@ -13019,11 +13019,11 @@ mod tests { let producer = origin(1).produce(); let consumer = producer .consume() - .scope("", &Patterns::from("room/*/chat".parse::().unwrap())) + .scope(Path::new("").unwrap(), &Patterns::from("room/*/chat".parse::().unwrap())) .unwrap(); let mut announced = consumer.announced(); - let alice = producer.create_broadcast("room/alice/chat").unwrap(); + let alice = producer.create_broadcast(Path::new("room/alice/chat").unwrap()).unwrap(); alice.announce(Route::default()).unwrap(); let Some(AnnounceEvent::Start(update)) = announced.try_next() else { panic!("expected alice's chat"); @@ -13031,11 +13031,11 @@ mod tests { assert_eq!(update.prefix.as_str(), "room/alice/chat"); assert_eq!(update.captures, Some(vec!["alice".parse::().unwrap()])); - let audio = producer.create_broadcast("room/alice/audio").unwrap(); + let audio = producer.create_broadcast(Path::new("room/alice/audio").unwrap()).unwrap(); audio.announce(Route::default()).unwrap(); announced.assert_next_wait(); - let broad = producer.announce("room", Route::default()).unwrap(); + let broad = producer.announce(Path::new("room").unwrap(), Route::default()).unwrap(); let Some(AnnounceEvent::Start(update)) = announced.try_next() else { panic!("expected the overlapping broad route"); }; @@ -13050,8 +13050,8 @@ mod tests { #[moq_clock::test] async fn local_broadcast_wins_announcement_ties() { let producer = origin(1).produce(); - let remote = producer.announce("room/alice", Route::default().with_cost(9)).unwrap(); - let local = producer.create_broadcast("room/alice").unwrap(); + let remote = producer.announce(Path::new("room/alice").unwrap(), Route::default().with_cost(9)).unwrap(); + let local = producer.create_broadcast(Path::new("room/alice").unwrap()).unwrap(); local.announce(Route::default()).unwrap(); let mut announced = producer.consume().announced(); @@ -13097,7 +13097,7 @@ mod tests { async fn stalled_publisher_open_group_is_reclaimed() { let expiry = Duration::from_secs(1); let origin = expiring_origin(expiry); - let broadcast = origin.create_broadcast("test").unwrap(); + let broadcast = origin.create_broadcast(Path::new("test").unwrap()).unwrap(); let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); let mut stalled = track.append_group().unwrap(); @@ -13130,7 +13130,7 @@ mod tests { ..Config::default() } .produce(); - let broadcast = origin.create_broadcast("test").unwrap(); + let broadcast = origin.create_broadcast(Path::new("test").unwrap()).unwrap(); let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); let mut stalled = track.append_group().unwrap(); diff --git a/rs/moq-net/src/server.rs b/rs/moq-net/src/server.rs index 458c8eaf516..8504f96eeaf 100644 --- a/rs/moq-net/src/server.rs +++ b/rs/moq-net/src/server.rs @@ -1030,6 +1030,7 @@ impl Drop for Handshake { #[cfg(test)] mod tests { use super::*; + use crate::Path; use crate::Hop; use crate::model::ProduceTest; use std::{ @@ -1388,7 +1389,7 @@ mod tests { .accept_request(start, session.clone()) .await .unwrap() - .with_stats(registry.tier(Default::default()).session("room")) + .with_stats(registry.tier(Default::default()).session(Path::new("room").unwrap())) .with_deadline(deadline); let Err(err) = request.ok().await else { panic!("a reply the peer never took completed"); @@ -1416,7 +1417,7 @@ mod tests { .accept_request(moq_clock::now(), session.clone()) .await .unwrap() - .with_stats(registry.tier(Default::default()).session("room")); + .with_stats(registry.tier(Default::default()).session(Path::new("room").unwrap())); let abandoned = moq_clock::timeout(std::time::Duration::from_secs(1), request.ok()).await; assert!(abandoned.is_err(), "a reply the peer never took completed"); assert_eq!( @@ -1442,7 +1443,7 @@ mod tests { .accept_request(moq_clock::now(), session) .await .unwrap() - .with_stats(registry.tier(Default::default()).session("room")) + .with_stats(registry.tier(Default::default()).session(Path::new("room").unwrap())) .close(err.clone()); let failures = registry.snapshot().sessions()[0].1.sessions_failed; for kind in stats::Failure::ALL { @@ -1691,7 +1692,7 @@ mod tests { echoed_hops.push(crate::Hop::UNKNOWN).unwrap(); let _echoed = origin .announce( - "echoed-route", + Path::new("echoed-route").unwrap(), crate::origin::Route::default() .with_hops(echoed_hops) .with_via(assigned), @@ -1701,7 +1702,7 @@ mod tests { let mut local_hops = crate::Hops::new(); local_hops.push(other).unwrap(); let _local = origin - .announce("local-route", crate::origin::Route::default().with_hops(local_hops)) + .announce(Path::new("local-route").unwrap(), crate::origin::Route::default().with_hops(local_hops)) .unwrap(); let (session, driver) = request.ok().await.unwrap(); diff --git a/rs/moq-net/src/stats.rs b/rs/moq-net/src/stats.rs index d6c783670e8..8462b9dab86 100644 --- a/rs/moq-net/src/stats.rs +++ b/rs/moq-net/src/stats.rs @@ -2142,6 +2142,7 @@ impl Drop for Announce { #[cfg(test)] mod tests { + use crate::Path; use std::sync::{Arc, atomic::Ordering::Relaxed}; use super::*; @@ -2156,9 +2157,9 @@ mod tests { #[test] fn wire_deltas_follow_label_and_tier_changes() { let registry = test_stats(); - let old = Tier::new("old"); - let new = Tier::new("new"); - let session = registry.tier(old.clone()).session("room"); + let old = Tier::new(Path::new("old").unwrap()); + let new = Tier::new(Path::new("new").unwrap()); + let session = registry.tier(old.clone()).session(Path::new("room").unwrap()); let bytes = counters(10, 20); let _wire = session.wire(bytes.clone()); let report = drain(®istry); @@ -2171,7 +2172,7 @@ mod tests { ); bytes.set_sent_bytes(15); bytes.set_received_bytes(27); - session.retag(new.clone(), "hall"); + session.retag(new.clone(), Path::new("hall").unwrap()); bytes.set_sent_bytes(25); bytes.set_received_bytes(50); let report = drain(®istry); @@ -2188,7 +2189,7 @@ mod tests { #[test] fn a_wire_counter_reset_never_lowers_presence() { let registry = test_stats(); - let session = registry.tier(Tier::default()).session("room"); + let session = registry.tier(Tier::default()).session(Path::new("room").unwrap()); let bytes = crate::transport::Wire::new(); let _wire = session.wire(bytes.clone()); for (reading, expected) in [((20, 30), (20, 30)), ((3, 4), (20, 30)), ((8, 10), (25, 36))] { @@ -2205,7 +2206,7 @@ mod tests { #[test] fn disabled_wire_collection_reports_nothing() { let registry = Registry::disabled(); - let session = registry.tier(Tier::default()).session("root"); + let session = registry.tier(Tier::default()).session(Path::new("root").unwrap()); let wire = session.wire(counters(5, 7)); assert!(drain(®istry).sessions.is_empty()); drop(wire); @@ -2215,7 +2216,7 @@ mod tests { #[test] fn wire_guards_hold_the_session_until_the_final_reading() { let registry = test_stats(); - let session = registry.tier(Tier::default()).session("room"); + let session = registry.tier(Tier::default()).session(Path::new("room").unwrap()); let wire = session.wire(counters(19, 23)); drop(session); assert_eq!(drain(®istry).sessions[0].presence.active(), 1); @@ -2240,11 +2241,11 @@ mod tests { #[test] fn outcomes_survive_clones_tier_changes_and_pruning() { let stats = test_stats(); - let handle = stats.tier(Tier::new("gateway")); - handle.refuse("root", RefusalKind::Forbidden); - let session = handle.session("root"); + let handle = stats.tier(Tier::new(Path::new("gateway").unwrap())); + handle.refuse(Path::new("root").unwrap(), RefusalKind::Forbidden); + let session = handle.session(Path::new("root").unwrap()); let clone = session.clone(); - session.retag(Tier::new("next"), "root"); + session.retag(Tier::new(Path::new("next").unwrap()), Path::new("root").unwrap()); // A reconnect's later end replaces an earlier one. clone.end(&crate::Error::Transport("lost".into())); session.end(&crate::Error::IdleTimeout); @@ -2272,10 +2273,10 @@ mod tests { let after = stats.snapshot(); assert_eq!(before.sessions(), after.sessions(), "retirement keeps outcomes once"); let disabled = Registry::disabled(); - disabled.tier(Tier::default()).refuse("root", RefusalKind::Refused); + disabled.tier(Tier::default()).refuse(Path::new("root").unwrap(), RefusalKind::Refused); disabled .tier(Tier::default()) - .session("root") + .session(Path::new("root").unwrap()) .end(&crate::Error::Expired); assert!(disabled.snapshot().sessions().is_empty()); } @@ -2313,7 +2314,7 @@ mod tests { .shared() .entries .lock() - .get(&PathOwned::from(path.to_string())) + .get(&Path::new(path).unwrap().to_owned()) .expect("entry") .tier(tier) } @@ -2325,7 +2326,7 @@ mod tests { .sessions .lock() .get(tier) - .and_then(|labels| labels.get(&PathOwned::from(label.to_string())).map(|c| c.snapshot().0)) + .and_then(|labels| labels.get(&Path::new(label).unwrap().to_owned()).map(|c| c.snapshot().0)) } fn test_stats() -> Registry { @@ -2335,14 +2336,14 @@ mod tests { #[test] fn default_and_named_tiers_are_independent() { let stats = test_stats(); - let default = stats.tier(Tier::default()).session("root"); - let regional = stats.tier(Tier::new("region/sjc")).session("root"); + let default = stats.tier(Tier::default()).session(Path::new("root").unwrap()); + let regional = stats.tier(Tier::new(Path::new("region/sjc").unwrap())).session(Path::new("root").unwrap()); - default.egress("demo/bbb").meter().bytes(100); - regional.ingress("demo/bbb").meter().bytes(7); + default.egress(Path::new("demo/bbb").unwrap()).meter().bytes(100); + regional.ingress(Path::new("demo/bbb").unwrap()).meter().bytes(7); let default_counters = tier_counters(&stats, "demo/bbb", &Tier::default()); - let regional_counters = tier_counters(&stats, "demo/bbb", &Tier::new("region/sjc")); + let regional_counters = tier_counters(&stats, "demo/bbb", &Tier::new(Path::new("region/sjc").unwrap())); assert_eq!(default_counters.publisher.bytes.load(Relaxed), 100); assert_eq!(default_counters.subscriber.bytes.load(Relaxed), 0); assert_eq!(regional_counters.publisher.bytes.load(Relaxed), 0); @@ -2358,7 +2359,7 @@ mod tests { let stats = test_stats(); let tier = stats.tier(Tier::default()); - let (s1, s2) = (tier.session("acme"), tier.session("acme")); + let (s1, s2) = (tier.session(Path::new("acme").unwrap()), tier.session(Path::new("acme").unwrap())); let announces = Slots::new(10).with_stats(&s1, Cap::Announces); let subscriptions = Slots::new(10).with_stats(&s2, Cap::Subscriptions); let other = Slots::new(10).with_stats(&s2, Cap::Announces); @@ -2390,13 +2391,13 @@ mod tests { use crate::session::Slots; let stats = test_stats(); - let session = stats.tier(Tier::default()).session("acme"); + let session = stats.tier(Tier::default()).session(Path::new("acme").unwrap()); let subscriptions = Slots::new(10).with_stats(&session, Cap::Subscriptions); let mut held: Vec<_> = (0..5).map(|_| subscriptions.acquire().unwrap()).collect(); held.truncate(3); - let gold = Tier::new("gold"); - session.retag(gold.clone(), "acme"); + let gold = Tier::new(Path::new("gold").unwrap()); + session.retag(gold.clone(), Path::new("acme").unwrap()); let peak = |tier: &Tier| { let (_, presence) = stats @@ -2415,23 +2416,23 @@ mod tests { fn snapshot_rolls_up_by_tier_role_and_sessions() { let stats = test_stats(); let default = stats.tier(Tier::default()); - let regional = stats.tier(Tier::new("region/sjc")); + let regional = stats.tier(Tier::new(Path::new("region/sjc").unwrap())); // Two default-tier sessions under one label, one regional; presence sums them. - let s1 = default.session("acme"); - let _s2 = default.session("acme"); - let s3 = regional.session("peer"); + let s1 = default.session(Path::new("acme").unwrap()); + let _s2 = default.session(Path::new("acme").unwrap()); + let s3 = regional.session(Path::new("peer").unwrap()); // Default-tier egress across two broadcasts; the snapshot sums them. { - let m = s1.egress("demo/aaa").meter(); + let m = s1.egress(Path::new("demo/aaa").unwrap()).meter(); m.bytes(100); m.frames(1); m.group(); } - s1.egress("demo/bbb").meter().bytes(50); + s1.egress(Path::new("demo/bbb").unwrap()).meter().bytes(50); // Regional ingress on a different tier/role stays isolated. - s3.ingress("demo/aaa").meter().bytes(7); + s3.ingress(Path::new("demo/aaa").unwrap()).meter().bytes(7); let snap = stats.snapshot(); @@ -2451,10 +2452,10 @@ mod tests { assert_eq!(default_publisher.frames, 1); assert_eq!(default_publisher.groups, 1); - let regional_subscriber = slot(Tier::new("region/sjc"), Role::Subscriber); + let regional_subscriber = slot(Tier::new(Path::new("region/sjc").unwrap()), Role::Subscriber); assert_eq!(regional_subscriber.bytes, 7, "regional ingress isolated by tier/role"); assert_eq!(slot(Tier::default(), Role::Subscriber).bytes, 0); - assert_eq!(slot(Tier::new("region/sjc"), Role::Publisher).bytes, 0); + assert_eq!(slot(Tier::new(Path::new("region/sjc").unwrap()), Role::Publisher).bytes, 0); let sessions = |tier| { snap.sessions() @@ -2469,7 +2470,7 @@ mod tests { "two default-tier sessions under one label" ); assert_eq!(default_sessions.sessions_ended, 0, "guards still held"); - assert_eq!(sessions(Tier::new("region/sjc")).sessions_started, 1); + assert_eq!(sessions(Tier::new(Path::new("region/sjc").unwrap())).sessions_started, 1); } fn drain(stats: &Registry) -> Report { @@ -2482,8 +2483,8 @@ mod tests { fn report_reuses_capacity() { // A reused report is cleared, not appended to, and keeps its buffers. let stats = test_stats(); - let ctx = stats.tier(Tier::default()).session("root"); - let _scopes: Vec<_> = (0..8).map(|i| ctx.egress(format!("b/{i}").as_str())).collect(); + let ctx = stats.tier(Tier::default()).session(Path::new("root").unwrap()); + let _scopes: Vec<_> = (0..8).map(|i| ctx.egress(Path::new(format!("b/{i}").as_str()).unwrap())).collect(); let mut report = Report::default(); stats.report(&mut report); @@ -2504,9 +2505,9 @@ mod tests { // entry across drains while live, and prunes it on the first drain // after the last guard drops (returning the final values that once). let stats = test_stats(); - let key = PathOwned::from("foo/bar"); - let ctx = stats.tier(Tier::default()).session("root"); - let scope = ctx.egress("foo/bar"); + let key = Path::new("foo/bar").unwrap(); + let ctx = stats.tier(Tier::default()).session(Path::new("root").unwrap()); + let scope = ctx.egress(Path::new("foo/bar").unwrap()); let sub = scope.subscribe(); scope.meter().bytes(42); @@ -2552,9 +2553,9 @@ mod tests { // the registry indefinitely: announces_started != announces_ended means a // subscription could still begin at any moment. let stats = test_stats(); - let key = PathOwned::from("foo/bar"); - let ctx = stats.tier(Tier::default()).session("root"); - let scope = ctx.egress("foo/bar"); + let key = Path::new("foo/bar").unwrap(); + let ctx = stats.tier(Tier::default()).session(Path::new("root").unwrap()); + let scope = ctx.egress(Path::new("foo/bar").unwrap()); let guard = scope.announce(); for _ in 0..3 { @@ -2578,7 +2579,7 @@ mod tests { // Once the last session under a label disconnects, the label leaves the // registry on the drain that reports its final gauge. let stats = test_stats(); - let session = stats.tier(Tier::default()).session("acme"); + let session = stats.tier(Tier::default()).session(Path::new("acme").unwrap()); let report = drain(&stats); let row = report @@ -2605,11 +2606,11 @@ mod tests { #[test] fn control_body_totals_follow_retags_and_survive_retirement() { let registry = Registry::new(Default::default()); - let first = Tier::new("internal"); - let second = Tier::new("edge"); - let context = registry.tier(first.clone()).session(""); + let first = Tier::new(Path::new("internal").unwrap()); + let second = Tier::new(Path::new("edge").unwrap()); + let context = registry.tier(first.clone()).session(Path::new("").unwrap()); context.control(Control::Announce, 17, false); - context.retag(second.clone(), ""); + context.retag(second.clone(), Path::new("").unwrap()); context.control(Control::TrackInfo, 23, true); let expected = vec![ (second, Control::TrackInfo, Bytes { tx: 0, rx: 23 }), @@ -2626,12 +2627,12 @@ mod tests { fn snapshot_preserves_retired_counters() { let stats = test_stats(); let tier = Tier::default(); - let live = stats.tier(tier.clone()).session("live"); - let scope = live.egress("live/video"); + let live = stats.tier(tier.clone()).session(Path::new("live").unwrap()); + let scope = live.egress(Path::new("live/video").unwrap()); let _live_sub = scope.subscribe(); for _ in 0..2 { - let session = stats.tier(tier.clone()).session("retired"); - let scope = session.egress("retired/video"); + let session = stats.tier(tier.clone()).session(Path::new("retired").unwrap()); + let scope = session.egress(Path::new("retired/video").unwrap()); let sub = scope.subscribe(); scope.meter().bytes(100); drop(sub); @@ -2673,8 +2674,8 @@ mod tests { let worker = std::thread::spawn(move || { for i in 0..256 { let path = format!("root/{i}"); - let session = worker_stats.tier(Tier::default()).session(path.as_str()); - session.ingress(path.as_str()).meter().bytes(1); + let session = worker_stats.tier(Tier::default()).session(Path::new(path.as_str()).unwrap()); + session.ingress(Path::new(path.as_str()).unwrap()).meter().bytes(1); drop(session); drain(&worker_stats); } @@ -2719,8 +2720,8 @@ mod tests { // Our own stats broadcasts (and any sibling category under the same // prefix) must not feed back into the registry. let stats = test_stats(); - let ctx = stats.tier(Tier::default()).session("root"); - let scope = ctx.egress(".stats/node/sjc"); + let ctx = stats.tier(Tier::default()).session(Path::new("root").unwrap()); + let scope = ctx.egress(Path::new(".stats/node/sjc").unwrap()); scope.meter().bytes(100); let _guard = scope.announce(); let _sub = scope.subscribe(); @@ -2733,8 +2734,8 @@ mod tests { // and bumps are dropped. let stats = Registry::default(); assert!(stats.shared.is_none()); - let ctx = stats.tier(Tier::default()).session("root"); - let scope = ctx.egress("demo/bbb"); + let ctx = stats.tier(Tier::default()).session(Path::new("root").unwrap()); + let scope = ctx.egress(Path::new("demo/bbb").unwrap()); scope.meter().bytes(100); let _guard = scope.announce(); let _sub = scope.subscribe(); @@ -2753,9 +2754,9 @@ mod tests { session_snapshot(&stats, &Tier::default(), label).map(|p| (p.sessions_started, p.sessions_ended)) }; - let a1 = ext.session("acme"); - let a2 = ext.session("acme"); - let b1 = ext.session("globex"); + let a1 = ext.session(Path::new("acme").unwrap()); + let a2 = ext.session(Path::new("acme").unwrap()); + let b1 = ext.session(Path::new("globex").unwrap()); assert_eq!(snap("acme"), Some((2, 0)), "two sessions under one label"); assert_eq!(snap("globex"), Some((1, 0)), "a distinct label is counted separately"); @@ -2830,7 +2831,7 @@ mod tests { session_snapshot(&stats, &Tier::default(), label).map(|p| (p.sessions_started, p.sessions_ended)) }; - let ctx = stats.tier(Tier::default()).session("acme"); + let ctx = stats.tier(Tier::default()).session(Path::new("acme").unwrap()); assert_eq!(snap("acme"), Some((1, 0))); let clone = ctx.clone(); @@ -2845,14 +2846,14 @@ mod tests { #[test] fn retag_moves_presence() { let stats = test_stats(); - let gold = Tier::new("gold"); + let gold = Tier::new(Path::new("gold").unwrap()); let snap = |tier: &Tier| session_snapshot(&stats, tier, "acme").map(|p| (p.sessions_started, p.sessions_ended)); - let ctx = stats.tier(Tier::default()).session("acme"); - ctx.retag(Tier::default(), "acme"); + let ctx = stats.tier(Tier::default()).session(Path::new("acme").unwrap()); + ctx.retag(Tier::default(), Path::new("acme").unwrap()); assert_eq!(snap(&Tier::default()), Some((1, 0)), "the same tier is a no-op"); - ctx.retag(gold.clone(), "acme"); + ctx.retag(gold.clone(), Path::new("acme").unwrap()); assert_eq!(snap(&Tier::default()), Some((1, 1))); assert_eq!(snap(&gold), Some((1, 0))); @@ -2863,9 +2864,9 @@ mod tests { #[test] fn retag_moves_subsequent_traffic() { let stats = test_stats(); - let gold = Tier::new("gold"); - let ctx = stats.tier(Tier::default()).session("acme"); - let scope = ctx.egress("demo/bbb"); + let gold = Tier::new(Path::new("gold").unwrap()); + let ctx = stats.tier(Tier::default()).session(Path::new("acme").unwrap()); + let scope = ctx.egress(Path::new("demo/bbb").unwrap()); let clone = scope.clone(); let before = scope.meter(); @@ -2873,7 +2874,7 @@ mod tests { let announce = scope.announce(); before.bytes(10); - ctx.retag(gold.clone(), "acme"); + ctx.retag(gold.clone(), Path::new("acme").unwrap()); // A meter handed out earlier keeps its tier; everything after moves. before.bytes(1); scope.meter().bytes(5); @@ -2910,11 +2911,11 @@ mod tests { fn retag_moves_presence_between_labels_on_one_tier() { let stats = test_stats(); let tier = Tier::default(); - let session = stats.tier(tier.clone()).session("project/root"); - session.egress("project/live").meter().bytes(5); + let session = stats.tier(tier.clone()).session(Path::new("project/root").unwrap()); + session.egress(Path::new("project/live").unwrap()).meter().bytes(5); - session.retag(tier.clone(), "project/key/123"); - session.egress("project/live").meter().bytes(7); + session.retag(tier.clone(), Path::new("project/key/123").unwrap()); + session.egress(Path::new("project/live").unwrap()).meter().bytes(7); let root = session_snapshot(&stats, &tier, "project/root").unwrap(); let key = session_snapshot(&stats, &tier, "project/key/123").unwrap(); @@ -2926,12 +2927,12 @@ mod tests { fn retag_back_counts_bytes_once() { let stats = test_stats(); let tier = Tier::default(); - let session = stats.tier(tier.clone()).session("a"); - let meter = session.ingress("a/live").meter(); + let session = stats.tier(tier.clone()).session(Path::new("a").unwrap()); + let meter = session.ingress(Path::new("a/live").unwrap()).meter(); meter.bytes(1); - session.retag(tier.clone(), "b"); + session.retag(tier.clone(), Path::new("b").unwrap()); meter.bytes(2); - session.retag(tier.clone(), "a"); + session.retag(tier.clone(), Path::new("a").unwrap()); meter.bytes(4); let received = |label| session_snapshot(&stats, &tier, label).unwrap().received_bytes; @@ -2942,8 +2943,8 @@ mod tests { fn session_bytes_outlive_the_session() { let stats = test_stats(); let tier = Tier::default(); - let session = stats.tier(tier.clone()).session("acme"); - let meter = session.egress("acme/live").meter(); + let session = stats.tier(tier.clone()).session(Path::new("acme").unwrap()); + let meter = session.egress(Path::new("acme/live").unwrap()).meter(); meter.bytes(3); drop(session); @@ -2967,8 +2968,8 @@ mod tests { fn excluded_paths_skip_session_bytes() { let stats = test_stats(); let tier = Tier::default(); - let session = stats.tier(tier.clone()).session("acme"); - session.egress(".stats/node").meter().bytes(9); + let session = stats.tier(tier.clone()).session(Path::new("acme").unwrap()); + session.egress(Path::new(".stats/node").unwrap()).meter().bytes(9); assert_eq!(session_snapshot(&stats, &tier, "acme").unwrap().sent_bytes, 0); } @@ -2976,14 +2977,14 @@ mod tests { fn meter_bumps_the_right_side() { // A payload meter records on its own side only. let stats = test_stats(); - let ctx = stats.tier(Tier::default()).session("root"); + let ctx = stats.tier(Tier::default()).session(Path::new("root").unwrap()); - let egress = ctx.egress("demo/bbb").meter(); + let egress = ctx.egress(Path::new("demo/bbb").unwrap()).meter(); egress.group(); egress.frames(3); egress.bytes(100); - let ingress = ctx.ingress("demo/bbb").meter(); + let ingress = ctx.ingress(Path::new("demo/bbb").unwrap()).meter(); ingress.group(); ingress.frames(1); ingress.bytes(7); @@ -3000,10 +3001,10 @@ mod tests { // An egress subscription bumps `subscriptions_started` and, being the context's first // for the broadcast, `broadcasts_started`. Dropping closes both. let stats = test_stats(); - let ctx = stats.tier(Tier::default()).session("root"); + let ctx = stats.tier(Tier::default()).session(Path::new("root").unwrap()); let raw = || tier_counters(&stats, "demo/bbb", &Tier::default()).publisher.snapshot(); - let scope = ctx.egress("demo/bbb"); + let scope = ctx.egress(Path::new("demo/bbb").unwrap()); let s1 = scope.subscribe(); let s2 = scope.subscribe(); let r = raw(); @@ -3025,9 +3026,9 @@ mod tests { let stats = test_stats(); let raw = || tier_counters(&stats, "demo/bbb", &Tier::default()).publisher.snapshot(); - let v1 = stats.tier(Tier::default()).session("a").egress("demo/bbb").subscribe(); + let v1 = stats.tier(Tier::default()).session(Path::new("a").unwrap()).egress(Path::new("demo/bbb").unwrap()).subscribe(); assert_eq!(raw().broadcasts_started, 1); - let v2 = stats.tier(Tier::default()).session("b").egress("demo/bbb").subscribe(); + let v2 = stats.tier(Tier::default()).session(Path::new("b").unwrap()).egress(Path::new("demo/bbb").unwrap()).subscribe(); assert_eq!(raw().broadcasts_started, 2, "two distinct contexts => two viewers"); drop(v1); @@ -3041,8 +3042,8 @@ mod tests { // An ingress (producer-lifetime) subscription bumps subscriptions but never // the viewer refcount, which is egress-only. let stats = test_stats(); - let ctx = stats.tier(Tier::default()).session("root"); - let guard = ctx.ingress("demo/bbb").subscribe(); + let ctx = stats.tier(Tier::default()).session(Path::new("root").unwrap()); + let guard = ctx.ingress(Path::new("demo/bbb").unwrap()).subscribe(); let sub = tier_counters(&stats, "demo/bbb", &Tier::default()) .subscriber .snapshot(); @@ -3061,17 +3062,17 @@ mod tests { #[test] fn request_admission_survives_clones_retiering_and_retirement_without_presence() { let stats = test_stats(); - let request = stats.tier(Tier::new("old")).request("root"); + let request = stats.tier(Tier::new(Path::new("old").unwrap())).request(Path::new("root").unwrap()); let clone = request.clone(); - request.egress("root/video").meter().bytes(7); - request.retag(Tier::new("new"), "root"); - clone.egress("root/video").meter().bytes(11); + request.egress(Path::new("root/video").unwrap()).meter().bytes(7); + request.retag(Tier::new(Path::new("new").unwrap()), Path::new("root").unwrap()); + clone.egress(Path::new("root/video").unwrap()).meter().bytes(11); drop(request); drop(clone); let mut report = Report::default(); stats.report(&mut report); for (label, requests, bytes) in [("old", 1, 7), ("new", 0, 11)] { - let tier = Tier::new(label); + let tier = Tier::new(Path::new(label).unwrap()); let presence = report.sessions.iter().find(|entry| entry.tier == tier).unwrap(); assert_eq!(presence.presence.requests, requests); assert_eq!(presence.presence.active(), 0); @@ -3121,8 +3122,8 @@ mod tests { fn fetch_counts_separately_from_subscriptions() { // A fetch bumps `fetches`, not `subscriptions_started` or the viewer refcount. let stats = test_stats(); - let ctx = stats.tier(Tier::default()).session("root"); - let scope = ctx.egress("demo/bbb"); + let ctx = stats.tier(Tier::default()).session(Path::new("root").unwrap()); + let scope = ctx.egress(Path::new("demo/bbb").unwrap()); scope.fetch(); scope.fetch(); let r = tier_counters(&stats, "demo/bbb", &Tier::default()).publisher.snapshot(); @@ -3136,10 +3137,10 @@ mod tests { // The announce guard bumps `announces_started` + the path length on open, and // `announces_ended` + the path length again on drop. let stats = test_stats(); - let ctx = stats.tier(Tier::default()).session("root"); + let ctx = stats.tier(Tier::default()).session(Path::new("root").unwrap()); let path_len = "demo/bbb".len() as u64; - let guard = ctx.egress("demo/bbb").announce(); + let guard = ctx.egress(Path::new("demo/bbb").unwrap()).announce(); let r = tier_counters(&stats, "demo/bbb", &Tier::default()).publisher.snapshot(); assert_eq!(r.announces_started, 1); assert_eq!(r.announces_ended, 0); @@ -3159,7 +3160,7 @@ mod tests { fn disabled_context_is_noop() { // A default (disabled) context resolves empty scopes: every bump is dropped. let ctx = Session::default(); - let scope = ctx.egress("demo/bbb"); + let scope = ctx.egress(Path::new("demo/bbb").unwrap()); scope.meter().bytes(100); let _guard = scope.announce(); let _sub = scope.subscribe(); diff --git a/rs/moq-net/src/test_interop.rs b/rs/moq-net/src/test_interop.rs index f99c3404ed1..cd8bc9ab003 100644 --- a/rs/moq-net/src/test_interop.rs +++ b/rs/moq-net/src/test_interop.rs @@ -383,7 +383,7 @@ fn lite_tracks_interop() { let version = lite::Version::Lite07; let request = lite::Tracks { - broadcast: crate::Path::new("room"), + broadcast: crate::Path::new("room").unwrap(), epoch: None, } .encode_bytes(version) @@ -466,7 +466,7 @@ fn ietf_track_status_interop() { w.varint(::ID).unwrap(); ietf::TrackStatus { request_id: ietf::RequestId(id), - track_namespace: crate::Path::new(namespace), + track_namespace: crate::Path::new(namespace).unwrap(), track_name: "video".into(), properties_wanted: wanted, epoch: None, diff --git a/rs/moq-net/tests/announce_allocs.rs b/rs/moq-net/tests/announce_allocs.rs index b41579ff697..2c6c4783e55 100644 --- a/rs/moq-net/tests/announce_allocs.rs +++ b/rs/moq-net/tests/announce_allocs.rs @@ -8,6 +8,7 @@ //! route churn multiplies by the cursors watching. A counting allocator needs //! the whole binary to itself, hence a test of its own. +use moq_net::Path; use std::alloc::{GlobalAlloc, Layout, System}; use std::cell::Cell; @@ -57,16 +58,16 @@ fn peer_route(peer: u64, cost: u64) -> origin::Route { /// again, with `cursors` cursors rooted at `root` watching it. fn churn_allocs(root: &str, cursors: usize) -> usize { let (producer, _driver) = origin::Producer::new(origin::Config::default()); - let _winner = producer.dynamic_route("room/a", peer_route(1, 1)).unwrap(); + let _winner = producer.dynamic_route(Path::new("room/a").unwrap(), peer_route(1, 1)).unwrap(); let all = Patterns::from(Pattern::all()); let mut cursors: Vec<_> = (0..cursors) - .map(|_| producer.consume().scope(root, &all).unwrap().announced()) + .map(|_| producer.consume().scope(Path::new(root).unwrap(), &all).unwrap().announced()) .collect(); for cursor in &mut cursors { while cursor.try_next().is_some() {} } - let cycle = || drop(producer.dynamic_route("room/a", peer_route(2, 5)).unwrap()); + let cycle = || drop(producer.dynamic_route(Path::new("room/a").unwrap(), peer_route(2, 5)).unwrap()); // Reach the steady state first, with every table grown to what it settles at. for _ in 0..4 { cycle(); diff --git a/rs/moq-net/tests/integration/announce_covering_route.rs b/rs/moq-net/tests/integration/announce_covering_route.rs index 20e152994c2..7ad4c5108a9 100644 --- a/rs/moq-net/tests/integration/announce_covering_route.rs +++ b/rs/moq-net/tests/integration/announce_covering_route.rs @@ -7,6 +7,7 @@ //! `.dash/nobody` sees it at its own root. Across a session the publisher must //! translate it into the requested scope rather than end the session. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -54,22 +55,22 @@ async fn covering(version: Option<&str>) -> Vec { Some(version) => { let subscriber = produce_origin(2); let interest = Patterns::from(Pattern::subtree(REQUESTED).unwrap()); - let scoped = subscriber.scope("", &interest).unwrap(); + let scoped = subscriber.scope(Path::new("").unwrap(), &interest).unwrap(); let mut options = MockConnectOptions::new(version.parse::().unwrap()); options.server_publish = Some(publisher.consume()); options.client_subscribe = Some(scoped); (subscriber.consume(), Some(connect_mock(options).await)) } }; - let mut announced = observer.scope(REQUESTED, &everything).unwrap().announced(); + let mut announced = observer.scope(Path::new(REQUESTED).unwrap(), &everything).unwrap().announced(); let mut log = Vec::new(); - let served = publisher.create_broadcast(SERVED).unwrap(); + let served = publisher.create_broadcast(Path::new(SERVED).unwrap()).unwrap(); served.announce(Default::default()).unwrap(); moq_clock::sleep(SETTLE).await; log.push(format!("served: {:?}", drain(&mut announced))); - let below = publisher.create_broadcast(format!("{REQUESTED}/cam")).unwrap(); + let below = publisher.create_broadcast(Path::try_from(format!("{REQUESTED}/cam")).unwrap()).unwrap(); below.announce(Default::default()).unwrap(); moq_clock::sleep(SETTLE).await; log.push(format!("below: {:?}", drain(&mut announced))); diff --git a/rs/moq-net/tests/integration/announce_to_serve.rs b/rs/moq-net/tests/integration/announce_to_serve.rs index eb71f54291c..ff4760755a3 100644 --- a/rs/moq-net/tests/integration/announce_to_serve.rs +++ b/rs/moq-net/tests/integration/announce_to_serve.rs @@ -10,6 +10,7 @@ //! Deterministic: time is paused and the runtime is single-threaded, so settling //! is a virtual sleep. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -61,7 +62,7 @@ fn drain(announced: &mut moq_net::announce::Consumer) -> Vec { /// How a request for the path answers. async fn request(consumer: &origin::Consumer) -> Result { - consumer.request_broadcast(PATH, None).await.map_err(|err| match err { + consumer.request_broadcast(Path::new(PATH).unwrap(), None).await.map_err(|err| match err { Error::Unroutable => "unroutable".to_string(), err => err.to_string(), }) @@ -144,7 +145,7 @@ async fn lifecycle(observer: Observer) -> Vec { let mut log = Vec::new(); // Created, not yet announced: nobody can see or reach it. - let broadcast = publisher.create_broadcast(PATH).unwrap(); + let broadcast = publisher.create_broadcast(Path::new(PATH).unwrap()).unwrap(); let track = broadcast.create_track("video", timed()).unwrap(); moq_clock::sleep(SETTLE).await; log.push(format!( diff --git a/rs/moq-net/tests/integration/auth.rs b/rs/moq-net/tests/integration/auth.rs index 91a4de62dc2..54832f4cd88 100644 --- a/rs/moq-net/tests/integration/auth.rs +++ b/rs/moq-net/tests/integration/auth.rs @@ -4,6 +4,7 @@ //! tokens union, and a publication outside the grant fails loud. Every case runs on //! moq-lite-07-wip and on moq-transport with the MoQ Auth extension. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -168,7 +169,7 @@ async fn moqt_22_renewing_a_cancelled_announce_keeps_the_session() { let mut tokens = serve(pair.requests.take().unwrap(), |_| Some(Grant::all())); let (first, answer) = pair.client.auth().add("first").await.expect("kept for requests"); assert_eq!(answer, auth::Answer::Requests); - let broadcast = client_origin.create_broadcast("room/x").unwrap(); + let broadcast = client_origin.create_broadcast(Path::new("room/x").unwrap()).unwrap(); broadcast.announce(origin::Route::default().with_auth(first)).unwrap(); let (_, first) = tokens.next().await.expect("the announce's token"); @@ -199,7 +200,7 @@ async fn moqt_22_a_cancelled_renewal_keeps_the_session() { (token == b"first").then(Grant::all) }); let (first, _) = pair.client.auth().add("first").await.expect("kept for requests"); - let broadcast = client_origin.create_broadcast("room/x").unwrap(); + let broadcast = client_origin.create_broadcast(Path::new("room/x").unwrap()).unwrap(); broadcast.announce(origin::Route::default().with_auth(first)).unwrap(); let (_, first) = tokens.next().await.expect("the announce's token"); @@ -223,7 +224,7 @@ async fn moqt_22_dropping_the_old_grant_with_its_renewal_keeps_the_announce() { let (mut pair, client_origin, server_origin) = connect_route_auth(MOQT_22).await; let mut requests = pair.requests.take().unwrap(); let (first, _) = pair.client.auth().add("first").await.expect("kept for requests"); - let broadcast = client_origin.create_broadcast("room/x").unwrap(); + let broadcast = client_origin.create_broadcast(Path::new("room/x").unwrap()).unwrap(); broadcast.announce(origin::Route::default().with_auth(first)).unwrap(); let first = requests .next() @@ -278,7 +279,7 @@ async fn moqt_22_a_revoked_route_auth_remakes_its_announce() { let (first, _) = pair.client.auth().add("first").await.expect("granted"); let (token, presented) = tokens.next().await.expect("the AUTH stream's token"); assert_eq!(token, b"first"); - let broadcast = client_origin.create_broadcast("room/x").unwrap(); + let broadcast = client_origin.create_broadcast(Path::new("room/x").unwrap()).unwrap(); broadcast.announce(origin::Route::default().with_auth(first)).unwrap(); let (token, carried) = tokens.next().await.expect("the announce's token"); assert_eq!(token, b"first"); @@ -338,7 +339,7 @@ async fn a_route_auth_survives_a_reconnect(version: &'static str) { let mut first = connect_route_auth_on(version, &client_origin, &server_origin, Some(handle.clone())).await; let mut tokens = serve(first.requests.take().unwrap(), |_| Some(Grant::all())); let (token, _) = handle.add("first").await.expect("kept for requests"); - let broadcast = client_origin.create_broadcast("room/x").unwrap(); + let broadcast = client_origin.create_broadcast(Path::new("room/x").unwrap()).unwrap(); broadcast.announce(origin::Route::default().with_auth(token)).unwrap(); let (token, _first) = tokens.next().await.expect("the announce's token"); assert_eq!(token, b"first"); @@ -364,7 +365,7 @@ async fn a_route_auth_renews_its_announce(version: &'static str) { let mut tokens = serve(pair.requests.take().unwrap(), |_| Some(Grant::all())); let (first, _) = pair.client.auth().add("first").await.expect("kept for requests"); - let broadcast = client_origin.create_broadcast("room/x").unwrap(); + let broadcast = client_origin.create_broadcast(Path::new("room/x").unwrap()).unwrap(); broadcast.announce(origin::Route::default().with_auth(first)).unwrap(); let (token, _first) = tokens.next().await.expect("the announce's token"); assert_eq!(token, b"first"); @@ -571,8 +572,8 @@ async fn both_sides_learn_their_grant_from_scoped_origins(version: &'static str) version: Some(version), client_publish: Some(produce_origin(2)), client_subscribe: Some(produce_origin(3)), - server_publish: Some(relay.scope("", &patterns(&["room"])).unwrap()), - server_subscribe: Some(relay.scope("", &patterns(&["room/alice"])).unwrap()), + server_publish: Some(relay.scope(Path::new("").unwrap(), &patterns(&["room"])).unwrap()), + server_subscribe: Some(relay.scope(Path::new("").unwrap(), &patterns(&["room/alice"])).unwrap()), ..Default::default() }) .await; @@ -614,18 +615,18 @@ async fn an_out_of_scope_announce_aborts_with_the_path(version: &'static str) { let pair = connect(Options { version: Some(version), client_publish: Some(publisher.clone()), - server_subscribe: Some(relay.scope("", &patterns(&["baz"])).unwrap()), + server_subscribe: Some(relay.scope(Path::new("").unwrap(), &patterns(&["baz"])).unwrap()), ..Default::default() }) .await; // In scope: served, and nothing aborts. - let ok = publisher.create_broadcast("baz/ok").unwrap(); + let ok = publisher.create_broadcast(Path::new("baz/ok").unwrap()).unwrap(); ok.announce(Default::default()).unwrap(); wait_announced(&relay.consume(), "baz/ok", true).await; assert_eq!(pair.client_transport.close_reason(), None); - let bad = publisher.create_broadcast("foo/bar").unwrap(); + let bad = publisher.create_broadcast(Path::new("foo/bar").unwrap()).unwrap(); bad.announce(Default::default()).unwrap(); let err = pair.server.closed().await; assert!( @@ -644,13 +645,13 @@ async fn an_out_of_scope_announce_aborts_with_the_path(version: &'static str) { async fn a_broadcast_published_before_the_grant_is_checked(version: &'static str) { within(async { let publisher = produce_origin(2); - let early = publisher.create_broadcast("foo/bar").unwrap(); + let early = publisher.create_broadcast(Path::new("foo/bar").unwrap()).unwrap(); early.announce(Default::default()).unwrap(); let pair = connect(Options { version: Some(version), client_publish: Some(publisher.clone()), - server_subscribe: Some(produce_origin(1).scope("", &patterns(&["baz"])).unwrap()), + server_subscribe: Some(produce_origin(1).scope(Path::new("").unwrap(), &patterns(&["baz"])).unwrap()), ..Default::default() }) .await; @@ -686,7 +687,7 @@ async fn an_unanswered_token_holds_the_check(version: &'static str) { let auth = pair.client.auth(); let pending = moq_clock::sim::spawn(async move { auth.add("new").await }); let unanswered = requests.next().await.unwrap(); - let broadcast = publisher.create_broadcast("foo/bar").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("foo/bar").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); moq_clock::sleep(Duration::from_secs(1)).await; use futures::FutureExt; @@ -697,7 +698,7 @@ async fn an_unanswered_token_holds_the_check(version: &'static str) { let _issued = unanswered.accept(grant(&["foo"], &[])); let _token = pending.await.unwrap().unwrap(); assert_eq!(granted(&pair.client).await, grant(&["baz", "foo"], &[])); - let bad = publisher.create_broadcast("still-bad").unwrap(); + let bad = publisher.create_broadcast(Path::new("still-bad").unwrap()).unwrap(); bad.announce(Default::default()).unwrap(); assert!(matches!( pair.server.closed().await, @@ -728,7 +729,7 @@ async fn a_broadcast_withdrawn_while_its_token_waits_is_not_refused(version: &'s let auth = pair.client.auth(); let pending = moq_clock::sim::spawn(async move { auth.add("new").await }); let unanswered = requests.next().await.unwrap(); - let withdrawn = publisher.create_broadcast("foo/bar").unwrap(); + let withdrawn = publisher.create_broadcast(Path::new("foo/bar").unwrap()).unwrap(); withdrawn.announce(Default::default()).unwrap(); moq_clock::sleep(Duration::from_secs(1)).await; withdrawn.unannounce(); @@ -737,7 +738,7 @@ async fn a_broadcast_withdrawn_while_its_token_waits_is_not_refused(version: &'s let _token = pending.await.unwrap().unwrap(); assert_eq!(granted(&pair.client).await, grant(&["baz", "other"], &[])); // Still enforcing: the next uncovered broadcast is the one named. - let bad = publisher.create_broadcast("still-bad").unwrap(); + let bad = publisher.create_broadcast(Path::new("still-bad").unwrap()).unwrap(); bad.announce(Default::default()).unwrap(); assert!(matches!( pair.server.closed().await, @@ -776,9 +777,9 @@ async fn tokens_union_and_withdrawing_one_shrinks_it(version: &'static str) { assert_eq!(t1.grant().peek(), Some(grant(&["b"], &[]))); assert_eq!(granted(&pair.client).await, grant(&["a", "b"], &[])); - let a = publisher.create_broadcast("a/x").unwrap(); + let a = publisher.create_broadcast(Path::new("a/x").unwrap()).unwrap(); a.announce(Default::default()).unwrap(); - let b = publisher.create_broadcast("b/y").unwrap(); + let b = publisher.create_broadcast(Path::new("b/y").unwrap()).unwrap(); b.announce(Default::default()).unwrap(); let served = relay.consume(); wait_announced(&served, "a/x", true).await; @@ -844,7 +845,7 @@ async fn a_revoked_grant_withdraws_and_can_be_restored(version: &'static str) { }); let (_, setup) = issued.next().await.unwrap(); - let a = publisher.create_broadcast("a/x").unwrap(); + let a = publisher.create_broadcast(Path::new("a/x").unwrap()).unwrap(); a.announce(Default::default()).unwrap(); let served = relay.consume(); wait_announced(&served, "a/x", true).await; @@ -853,7 +854,7 @@ async fn a_revoked_grant_withdraws_and_can_be_restored(version: &'static str) { wait_for(pair.client.auth().grant(), |g| g == &Some(Grant::default())).await; wait_announced(&served, "a/x", false).await; // Still published locally, and the session survives the empty union. - assert!(publisher.consume().routed("a/x").await.is_some()); + assert!(publisher.consume().routed(Path::new("a/x").unwrap()).await.is_some()); assert_eq!(pair.client_transport.close_reason(), None); let (_again, _) = pair.client.auth().add("again").await.expect("re-authorized"); @@ -1049,7 +1050,7 @@ async fn exact_and_subtree_grants_admit_their_broadcast(version: &'static str) { for scope in ["ch1", "ch1/**"] { within(async { let relay = produce_origin(1); - let broadcast = relay.create_broadcast("ch1").unwrap(); + let broadcast = relay.create_broadcast(Path::new("ch1").unwrap()).unwrap(); let track = broadcast.create_track("video", timed()).unwrap(); broadcast.announce(Default::default()).unwrap(); @@ -1058,7 +1059,7 @@ async fn exact_and_subtree_grants_admit_their_broadcast(version: &'static str) { let pair = connect(Options { version: Some(version), client_subscribe: Some(received.clone()), - server_publish: Some(relay.scope("", &scope).unwrap()), + server_publish: Some(relay.scope(Path::new("").unwrap(), &scope).unwrap()), ..Default::default() }) .await; @@ -1067,7 +1068,7 @@ async fn exact_and_subtree_grants_admit_their_broadcast(version: &'static str) { group .write_frame(moq_net::Timestamp::from_millis(0).unwrap(), b"frame".as_ref()) .unwrap(); - let remote = received.consume().routed_broadcast("ch1").await.unwrap(); + let remote = received.consume().routed_broadcast(Path::new("ch1").unwrap()).await.unwrap(); let prefs = moq_net::track::Subscription::default().with_max_delay(Duration::from_secs(10)); let mut sub = remote.track("video").unwrap().subscribe(prefs).await.unwrap(); sub.recv_group().await.unwrap().expect("a group"); @@ -1088,7 +1089,7 @@ async fn exact_and_subtree_grants_admit_their_broadcast(version: &'static str) { /// version with AUTH has opened its Auth Stream on both sides. async fn connect_announced(version: &'static str) -> (Pair, moq_net::broadcast::Producer) { let client_origin = produce_origin(2); - let broadcast = client_origin.create_broadcast("room/x").unwrap(); + let broadcast = client_origin.create_broadcast(Path::new("room/x").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); let server_origin = produce_origin(1); let pair = connect(Options { @@ -1105,7 +1106,7 @@ async fn connect_announced(version: &'static str) -> (Pair, moq_net::broadcast:: async fn a_live_subscription_survives_union_renewal(version: &'static str) { within(async { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("room/x").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("room/x").unwrap()).unwrap(); let published = broadcast.create_track("video", timed()).unwrap(); broadcast.announce(Default::default()).unwrap(); let received = produce_origin(2); @@ -1125,7 +1126,7 @@ async fn a_live_subscription_survives_union_renewal(version: &'static str) { requests.next().await.unwrap().accept(grant(&[], &["room"])) }); let first = first.unwrap(); - let remote = received.consume().routed_broadcast("room/x").await.unwrap(); + let remote = received.consume().routed_broadcast(Path::new("room/x").unwrap()).await.unwrap(); let mut group = published.append_group().unwrap(); group .write_frame(moq_net::Timestamp::from_millis(0).unwrap(), b"first".as_ref()) @@ -1166,12 +1167,12 @@ async fn a_revoked_grant_cancels_its_subscriptions(version: &'static str) { // The server publishes room/x to the client; the client publishes up/y to the server. let server_origin = produce_origin(1); - let down = server_origin.create_broadcast("room/x").unwrap(); + let down = server_origin.create_broadcast(Path::new("room/x").unwrap()).unwrap(); let down_track = down.create_track("video", timed()).unwrap(); down.announce(Default::default()).unwrap(); let client_origin = produce_origin(2); - let up = client_origin.create_broadcast("up/y").unwrap(); + let up = client_origin.create_broadcast(Path::new("up/y").unwrap()).unwrap(); let up_track = up.create_track("video", timed()).unwrap(); up.announce(Default::default()).unwrap(); @@ -1196,11 +1197,11 @@ async fn a_revoked_grant_cancels_its_subscriptions(version: &'static str) { let mut group = up_track.append_group().unwrap(); group.write_frame(ts(0), b"up".as_ref()).unwrap(); - let remote = received.consume().routed_broadcast("room/x").await.unwrap(); + let remote = received.consume().routed_broadcast(Path::new("room/x").unwrap()).await.unwrap(); let mut down_sub = remote.track("video").unwrap().subscribe(prefs()).await.unwrap(); down_sub.recv_group().await.unwrap().unwrap(); - let remote = server_origin.consume().routed_broadcast("up/y").await.unwrap(); + let remote = server_origin.consume().routed_broadcast(Path::new("up/y").unwrap()).await.unwrap(); let mut up_sub = remote.track("video").unwrap().subscribe(prefs()).await.unwrap(); up_sub.recv_group().await.unwrap().unwrap(); @@ -1374,7 +1375,7 @@ async fn a_wildcard_grant_is_enforced(version: &'static str) { let pair = connect(Options { version: Some(version), client_publish: Some(publisher.clone()), - server_subscribe: Some(relay.scope("", &scope).unwrap()), + server_subscribe: Some(relay.scope(Path::new("").unwrap(), &scope).unwrap()), ..Default::default() }) .await; @@ -1382,14 +1383,14 @@ async fn a_wildcard_grant_is_enforced(version: &'static str) { let mut held = Vec::new(); for path in ["room/alice/cam", "b.hang", "deep/x/b.hang"] { - let broadcast = publisher.create_broadcast(path).unwrap(); + let broadcast = publisher.create_broadcast(Path::new(path).unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); wait_announced(&relay.consume(), path, true).await; held.push(broadcast); } assert_eq!(pair.client_transport.close_reason(), None); - let bad = publisher.create_broadcast("room/alice/mic").unwrap(); + let bad = publisher.create_broadcast(Path::new("room/alice/mic").unwrap()).unwrap(); bad.announce(Default::default()).unwrap(); assert!(matches!( pair.server.closed().await, @@ -1410,7 +1411,7 @@ async fn a_wildcard_grant_is_enforced(version: &'static str) { async fn nothing_outside_the_grant_reaches_the_peer(version: &'static str) { within(async { let publisher = produce_origin(2); - let early = publisher.create_broadcast("foo/bar").unwrap(); + let early = publisher.create_broadcast(Path::new("foo/bar").unwrap()).unwrap(); early.announce(Default::default()).unwrap(); // The relay accepts anything; only the grant it tells the client is narrow. @@ -1450,7 +1451,7 @@ async fn a_broadcast_received_from_the_peer_is_not_ours_to_check(version: &'stat within(async { let local = produce_origin(2); let relay = produce_origin(1); - let remote = relay.create_broadcast("remote/x").unwrap(); + let remote = relay.create_broadcast(Path::new("remote/x").unwrap()).unwrap(); remote.announce(Default::default()).unwrap(); let pair = connect(Options { @@ -1458,7 +1459,7 @@ async fn a_broadcast_received_from_the_peer_is_not_ours_to_check(version: &'stat client_publish: Some(local.clone()), client_subscribe: Some(local.clone()), server_publish: Some(relay.clone()), - server_subscribe: Some(relay.scope("", &patterns(&["local"])).unwrap()), + server_subscribe: Some(relay.scope(Path::new("").unwrap(), &patterns(&["local"])).unwrap()), ..Default::default() }) .await; @@ -1467,7 +1468,7 @@ async fn a_broadcast_received_from_the_peer_is_not_ours_to_check(version: &'stat wait_announced(&local.consume(), "remote/x", true).await; // The first broadcast refused is the one we published, not the one we received. - let bad = local.create_broadcast("bad/x").unwrap(); + let bad = local.create_broadcast(Path::new("bad/x").unwrap()).unwrap(); bad.announce(Default::default()).unwrap(); assert!(matches!( pair.server.closed().await, @@ -1555,10 +1556,10 @@ async fn a_narrowing_deafens_one_path(version: &'static str) { let prefs = || moq_net::track::Subscription::default().with_max_delay(Duration::from_secs(10)); let relay = produce_origin(1); - let audio = relay.create_broadcast("room/alice/audio").unwrap(); + let audio = relay.create_broadcast(Path::new("room/alice/audio").unwrap()).unwrap(); let audio_track = audio.create_track("opus", timed()).unwrap(); audio.announce(Default::default()).unwrap(); - let video = relay.create_broadcast("room/alice/video").unwrap(); + let video = relay.create_broadcast(Path::new("room/alice/video").unwrap()).unwrap(); let video_track = video.create_track("h264", timed()).unwrap(); video.announce(Default::default()).unwrap(); @@ -1566,7 +1567,7 @@ async fn a_narrowing_deafens_one_path(version: &'static str) { let pair = connect(Options { version: Some(version), client_subscribe: Some(received.clone()), - server_publish: Some(relay.scope("", &patterns(&["room"])).unwrap()), + server_publish: Some(relay.scope(Path::new("").unwrap(), &patterns(&["room"])).unwrap()), ..Default::default() }) .await; @@ -1576,10 +1577,10 @@ async fn a_narrowing_deafens_one_path(version: &'static str) { let mut group = video_track.append_group().unwrap(); group.write_frame(ts(0), b"v".as_ref()).unwrap(); - let remote = received.consume().routed_broadcast("room/alice/audio").await.unwrap(); + let remote = received.consume().routed_broadcast(Path::new("room/alice/audio").unwrap()).await.unwrap(); let mut audio_sub = remote.track("opus").unwrap().subscribe(prefs()).await.unwrap(); audio_sub.recv_group().await.unwrap().unwrap(); - let remote = received.consume().routed_broadcast("room/alice/video").await.unwrap(); + let remote = received.consume().routed_broadcast(Path::new("room/alice/video").unwrap()).await.unwrap(); let mut video_sub = remote.track("h264").unwrap().subscribe(prefs()).await.unwrap(); video_sub.recv_group().await.unwrap().unwrap(); @@ -1628,10 +1629,10 @@ async fn a_narrowing_aborts_what_the_peer_published(version: &'static str) { let prefs = || moq_net::track::Subscription::default().with_max_delay(Duration::from_secs(10)); let client_origin = produce_origin(2); - let mic = client_origin.create_broadcast("room/bob/mic").unwrap(); + let mic = client_origin.create_broadcast(Path::new("room/bob/mic").unwrap()).unwrap(); let mic_track = mic.create_track("opus", timed()).unwrap(); mic.announce(Default::default()).unwrap(); - let cam = client_origin.create_broadcast("room/bob/cam").unwrap(); + let cam = client_origin.create_broadcast(Path::new("room/bob/cam").unwrap()).unwrap(); let cam_track = cam.create_track("h264", timed()).unwrap(); cam.announce(Default::default()).unwrap(); @@ -1649,10 +1650,10 @@ async fn a_narrowing_aborts_what_the_peer_published(version: &'static str) { let mut group = cam_track.append_group().unwrap(); group.write_frame(ts(0), b"c".as_ref()).unwrap(); - let remote = relay.consume().routed_broadcast("room/bob/mic").await.unwrap(); + let remote = relay.consume().routed_broadcast(Path::new("room/bob/mic").unwrap()).await.unwrap(); let mut mic_sub = remote.track("opus").unwrap().subscribe(prefs()).await.unwrap(); mic_sub.recv_group().await.unwrap().unwrap(); - let remote = relay.consume().routed_broadcast("room/bob/cam").await.unwrap(); + let remote = relay.consume().routed_broadcast(Path::new("room/bob/cam").unwrap()).await.unwrap(); let mut cam_sub = remote.track("h264").unwrap().subscribe(prefs()).await.unwrap(); cam_sub.recv_group().await.unwrap().unwrap(); @@ -1681,7 +1682,7 @@ async fn a_narrowing_resets_a_fetch_in_flight(version: &'static str) { let ts = |ms| moq_net::Timestamp::from_millis(ms).unwrap(); let relay = produce_origin(1); - let broadcast = relay.create_broadcast("room/x").unwrap(); + let broadcast = relay.create_broadcast(Path::new("room/x").unwrap()).unwrap(); let track = broadcast.create_track("video", timed()).unwrap(); broadcast.announce(Default::default()).unwrap(); // The group stays open, so the fetch is still in flight when the grant narrows. @@ -1697,7 +1698,7 @@ async fn a_narrowing_resets_a_fetch_in_flight(version: &'static str) { }) .await; - let remote = received.consume().routed_broadcast("room/x").await.unwrap(); + let remote = received.consume().routed_broadcast(Path::new("room/x").unwrap()).await.unwrap(); let mut fetched = remote.track("video").unwrap().fetch_group(0, None).await.unwrap(); let frame = fetched.read_frame().await.unwrap().expect("first frame"); assert_eq!(frame.payload.as_ref(), b"first"); @@ -1744,7 +1745,7 @@ async fn a_widening_brings_back_a_deafened_path(version: &'static str) { let prefs = || moq_net::track::Subscription::default().with_max_delay(Duration::from_secs(10)); let relay = produce_origin(1); - let audio = relay.create_broadcast("room/alice/audio").unwrap(); + let audio = relay.create_broadcast(Path::new("room/alice/audio").unwrap()).unwrap(); let audio_track = audio.create_track("opus", timed()).unwrap(); audio.announce(Default::default()).unwrap(); @@ -1752,14 +1753,14 @@ async fn a_widening_brings_back_a_deafened_path(version: &'static str) { let pair = connect(Options { version: Some(version), client_subscribe: Some(received.clone()), - server_publish: Some(relay.scope("", &patterns(&["room"])).unwrap()), + server_publish: Some(relay.scope(Path::new("").unwrap(), &patterns(&["room"])).unwrap()), ..Default::default() }) .await; let mut group = audio_track.append_group().unwrap(); group.write_frame(ts(0), b"a".as_ref()).unwrap(); - let remote = received.consume().routed_broadcast("room/alice/audio").await.unwrap(); + let remote = received.consume().routed_broadcast(Path::new("room/alice/audio").unwrap()).await.unwrap(); let mut sub = remote.track("opus").unwrap().subscribe(prefs()).await.unwrap(); sub.recv_group().await.unwrap().unwrap(); @@ -1771,7 +1772,7 @@ async fn a_widening_brings_back_a_deafened_path(version: &'static str) { pair.server.auth().authorize(&grant(&[], &["room"])); wait_announced(&received.consume(), "room/alice/audio", true).await; - let remote = received.consume().routed_broadcast("room/alice/audio").await.unwrap(); + let remote = received.consume().routed_broadcast(Path::new("room/alice/audio").unwrap()).await.unwrap(); let mut sub = remote.track("opus").unwrap().subscribe(prefs()).await.unwrap(); let mut group = audio_track.append_group().unwrap(); group.write_frame(ts(1), b"a".as_ref()).unwrap(); @@ -1801,7 +1802,7 @@ async fn a_widening_brings_back_what_the_peer_published(version: &'static str) { let prefs = || moq_net::track::Subscription::default().with_max_delay(Duration::from_secs(10)); let client_origin = produce_origin(2); - let mic = client_origin.create_broadcast("room/bob/mic").unwrap(); + let mic = client_origin.create_broadcast(Path::new("room/bob/mic").unwrap()).unwrap(); let mic_track = mic.create_track("opus", timed()).unwrap(); mic.announce(Default::default()).unwrap(); @@ -1820,7 +1821,7 @@ async fn a_widening_brings_back_what_the_peer_published(version: &'static str) { pair.server.auth().authorize(&grant(&["room"], &[])); wait_announced(&relay.consume(), "room/bob/mic", true).await; - let remote = relay.consume().routed_broadcast("room/bob/mic").await.unwrap(); + let remote = relay.consume().routed_broadcast(Path::new("room/bob/mic").unwrap()).await.unwrap(); let mut sub = remote.track("opus").unwrap().subscribe(prefs()).await.unwrap(); let mut group = mic_track.append_group().unwrap(); group.write_frame(ts(0), b"m".as_ref()).unwrap(); diff --git a/rs/moq-net/tests/integration/broadcast_close.rs b/rs/moq-net/tests/integration/broadcast_close.rs index b2126764dc0..07cd44e0291 100644 --- a/rs/moq-net/tests/integration/broadcast_close.rs +++ b/rs/moq-net/tests/integration/broadcast_close.rs @@ -5,6 +5,7 @@ //! [`Error::Unroutable`](moq_net::Error::Unroutable), a fresh request for the path //! answers the same, and the broadcast can never be announced again. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -22,16 +23,16 @@ fn produce_origin(hop: u64) -> moq_net::origin::Producer { /// Close a published broadcast and check what `reader`'s origin answers afterwards. async fn close_then_lookup(publisher: moq_net::origin::Producer, reader: moq_net::origin::Producer) { - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let _track = broadcast.create_track("video", None).unwrap(); broadcast.announce(Default::default()).unwrap(); let consumer = reader.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) + moq_clock::timeout(TIMEOUT, consumer.routed(Path::new("bcast").unwrap())) .await .expect("announce timeout") .expect("routed"); - let handle = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("bcast", None)) + let handle = moq_clock::timeout(TIMEOUT, consumer.request_broadcast(Path::new("bcast").unwrap(), None)) .await .expect("resolve timeout") .expect("broadcast resolves"); @@ -45,7 +46,7 @@ async fn close_then_lookup(publisher: moq_net::origin::Producer, reader: moq_net assert!(matches!(handle.track("video"), Err(Error::Unroutable))); assert!(matches!(handle.track("audio"), Err(Error::Unroutable))); assert!(matches!( - consumer.request_broadcast("bcast", None).await, + consumer.request_broadcast(Path::new("bcast").unwrap(), None).await, Err(Error::Unroutable) )); assert!(matches!(broadcast.announce(Default::default()), Err(Error::Closed))); diff --git a/rs/moq-net/tests/integration/catalog_acquisition.rs b/rs/moq-net/tests/integration/catalog_acquisition.rs index ca4bc66cf77..17412e25ce6 100644 --- a/rs/moq-net/tests/integration/catalog_acquisition.rs +++ b/rs/moq-net/tests/integration/catalog_acquisition.rs @@ -2,6 +2,7 @@ //! Initial catalog acquisition while the same publisher gains a second session. +use moq_net::Path; use crate::support; use moq_net::{Error, Hop, Version, origin}; @@ -27,14 +28,14 @@ async fn acquisition(version: &str, carries_epoch: bool) { let version: Version = version.parse().unwrap(); let publisher = origin(1); let subscriber = origin(2); - let broadcast = publisher.create_broadcast("live").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("live").unwrap()).unwrap(); let mut dynamic = broadcast.dynamic(); broadcast .announce(origin::Route::default().with_epoch(moq_net::Epoch::mint())) .unwrap(); let _old = link(version, &publisher, &subscriber, 100).await; - let remote = subscriber.consume().routed_broadcast("live").await.unwrap(); - let mut announced = subscriber.consume().follow("live").unwrap(); + let remote = subscriber.consume().routed_broadcast(Path::new("live").unwrap()).await.unwrap(); + let mut announced = subscriber.consume().follow(Path::new("live").unwrap()).unwrap(); let old_cost = match announced.next().await { Some(moq_net::announce::Event::Start(announce)) => announce.route.cost, other => panic!("expected the first route, got {other:?}"), diff --git a/rs/moq-net/tests/integration/catalog_churn.rs b/rs/moq-net/tests/integration/catalog_churn.rs index 31c944f87c2..0192e2e140f 100644 --- a/rs/moq-net/tests/integration/catalog_churn.rs +++ b/rs/moq-net/tests/integration/catalog_churn.rs @@ -9,6 +9,7 @@ //! on, and every fetch gets the whole group written so far. A failing seed is //! shrunk to the ops it needs, which the report names. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -265,7 +266,7 @@ impl Topology { /// A fresh request for the broadcast; `None` when refused, as with no route right now. async fn request(&self, step: usize) -> Result, Failure> { - let request = self.subscriber.consume().request_broadcast("live", None); + let request = self.subscriber.consume().request_broadcast(Path::new("live").unwrap(), None); match moq_clock::timeout(READ_TIMEOUT, request).await { Ok(result) => Ok(result.ok()), Err(_) => Err(stuck(format!("{step}: request hung"))), @@ -279,7 +280,7 @@ async fn execute(version: Version, ops: &[Op]) -> Result<(), Failure> { let relay_b = produce_origin(3); let subscriber = produce_origin(4); - let broadcast = publisher.create_broadcast("live").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("live").unwrap()).unwrap(); let info = track::Info::default().with_timescale(moq_net::Timescale::MILLI); let track = broadcast.create_track("catalog.json", info).unwrap(); broadcast @@ -291,7 +292,7 @@ async fn execute(version: Version, ops: &[Op]) -> Result<(), Failure> { link(version, &publisher, &relay_b).await, ]; let a_to_r = link(version, &relay_a, &subscriber).await; - subscriber.consume().routed("live").await.unwrap(); + subscriber.consume().routed(Path::new("live").unwrap()).await.unwrap(); let mut topology = Topology { version, publisher, diff --git a/rs/moq-net/tests/integration/catalog_handover.rs b/rs/moq-net/tests/integration/catalog_handover.rs index 8039b5eb11f..14bc31fc2a0 100644 --- a/rs/moq-net/tests/integration/catalog_handover.rs +++ b/rs/moq-net/tests/integration/catalog_handover.rs @@ -11,6 +11,7 @@ //! so a reader that starts at frame 0 must not be refused as lagged and left with //! no catalog. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -104,7 +105,7 @@ impl Topology { let relay_b = produce_origin(3); let subscriber = produce_origin(4); - let broadcast = publisher.create_broadcast("live").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("live").unwrap()).unwrap(); let track = broadcast.create_track("catalog.json", timed()).unwrap(); broadcast .announce(origin::Route::default().with_epoch(moq_net::Epoch::mint())) @@ -114,7 +115,7 @@ impl Topology { let p_to_a = link(version, &publisher, &relay_a, None).await; let p_to_b = link(version, &publisher, &relay_b, None).await; let a_to_r = link(version, &relay_a, &subscriber, None).await; - subscriber.consume().routed("live").await.unwrap(); + subscriber.consume().routed(Path::new("live").unwrap()).await.unwrap(); let mut topology = Self { version, @@ -167,7 +168,7 @@ impl Topology { /// A new reader on `R`: a fresh broadcast request and a floorless subscription. async fn reader(&self) -> Reader { - let remote = moq_clock::timeout(READ_TIMEOUT, self.subscriber.consume().request_broadcast("live", None)) + let remote = moq_clock::timeout(READ_TIMEOUT, self.subscriber.consume().request_broadcast(Path::new("live").unwrap(), None)) .await .expect("request hung") .expect("request refused"); @@ -394,7 +395,7 @@ async fn fetch_after_leave(version: &str, pause: Duration) { let remote = topology .subscriber .consume() - .request_broadcast("live", None) + .request_broadcast(Path::new("live").unwrap(), None) .await .unwrap(); let fetch = remote.track("catalog.json").unwrap().fetch_group(0, None); diff --git a/rs/moq-net/tests/integration/compress.rs b/rs/moq-net/tests/integration/compress.rs index 8f6b53cca01..f8135919acc 100644 --- a/rs/moq-net/tests/integration/compress.rs +++ b/rs/moq-net/tests/integration/compress.rs @@ -5,6 +5,7 @@ //! Negotiated IETF and lite-07 hops keep DEFLATE slices as received. Peers that cannot //! signal compression receive the plain frames the relay inflates once for all of them. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -62,7 +63,7 @@ struct Published { /// Announce one track described by `info`. fn publish(info: moq_net::track::Info) -> Published { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let track = broadcast.create_track("data", info).unwrap(); broadcast.announce(Default::default()).unwrap(); Published { @@ -105,8 +106,8 @@ async fn relay(published: Published, hops: [&str; 2], subscription: moq_net::tra let downstream = connect_mock(options).await; let consumer = origin.consume(); - consumer.routed("bcast").await.unwrap(); - let remote = consumer.request_broadcast("bcast", None).await.unwrap(); + consumer.routed(Path::new("bcast").unwrap()).await.unwrap(); + let remote = consumer.request_broadcast(Path::new("bcast").unwrap(), None).await.unwrap(); let subscriber = remote.track("data").unwrap().subscribe(subscription).await.unwrap(); support::harness::subscribed(&track).await; @@ -286,7 +287,7 @@ async fn datagrams_meter_the_bytes_on_the_wire() { for &version in &["moq-lite-07-wip", "moq-lite-06"] { moq_clock::timeout(TIMEOUT, async { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let mut track = broadcast.create_track("data", compressed()).unwrap(); broadcast.announce(Default::default()).unwrap(); @@ -296,7 +297,7 @@ async fn datagrams_meter_the_bytes_on_the_wire() { let mut options = MockConnectOptions::new("moq-lite-07-wip".parse::().unwrap()); options.client_publish = Some(publisher.consume()); options.server_subscribe = Some(relay.clone()); - options.server_stats = ingress.tier(Default::default()).session("ingress"); + options.server_stats = ingress.tier(Default::default()).session(Path::new("ingress").unwrap()); let upstream = connect_mock(options).await; let origin = produce_origin(3); @@ -304,12 +305,12 @@ async fn datagrams_meter_the_bytes_on_the_wire() { let mut options = MockConnectOptions::new(version.parse::().unwrap()); options.server_publish = Some(relay.consume()); options.client_subscribe = Some(origin.clone()); - options.server_stats = egress.tier(Default::default()).session("egress"); + options.server_stats = egress.tier(Default::default()).session(Path::new("egress").unwrap()); let downstream = connect_mock(options).await; let consumer = origin.consume(); - consumer.routed("bcast").await.unwrap(); - let remote = consumer.request_broadcast("bcast", None).await.unwrap(); + consumer.routed(Path::new("bcast").unwrap()).await.unwrap(); + let remote = consumer.request_broadcast(Path::new("bcast").unwrap(), None).await.unwrap(); let mut subscriber = remote.track("data").unwrap().subscribe(None).await.unwrap(); support::harness::subscribed(&track).await; @@ -400,7 +401,7 @@ async fn ietf_fetch_keeps_the_stored_form() { for version in ["moq-transport-16", "moq-transport-18", "moq-transport-22"] { moq_clock::timeout(TIMEOUT, async { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let track = broadcast.create_track("data", compressed()).unwrap(); let mut group = track.append_group().unwrap(); for index in 0..3 { @@ -416,8 +417,8 @@ async fn ietf_fetch_keeps_the_stored_form() { options.server_publish = Some(publisher.consume()); options.client_subscribe = Some(origin.clone()); let _pair = connect_mock(options).await; - origin.consume().routed("bcast").await.unwrap(); - let remote = origin.consume().request_broadcast("bcast", None).await.unwrap(); + origin.consume().routed(Path::new("bcast").unwrap()).await.unwrap(); + let remote = origin.consume().request_broadcast(Path::new("bcast").unwrap(), None).await.unwrap(); let consumer = remote.track("data").unwrap(); assert_eq!(consumer.query().await.unwrap().compress, version != "moq-transport-16"); let mut fetched = consumer.fetch_group(0, moq_net::group::Fetch::default()).await.unwrap(); diff --git a/rs/moq-net/tests/integration/control_stats.rs b/rs/moq-net/tests/integration/control_stats.rs index 554859399b6..4df59a7734f 100644 --- a/rs/moq-net/tests/integration/control_stats.rs +++ b/rs/moq-net/tests/integration/control_stats.rs @@ -2,6 +2,7 @@ //! Control counters cross real protocol drivers, including legacy multiplexing. +use moq_net::Path; use crate::support::{ harness::{MockConnectOptions, connect_mock, now, spawn, subscribed}, mock::create_mock_session_pair, @@ -31,13 +32,13 @@ async fn control_classes_cross_lite_and_ietf_sessions_without_counting_payload() let publisher = origin(); let subscriber = origin(); let registry = Registry::new(Default::default()); - let tier = Tier::new("internal"); + let tier = Tier::new(Path::new("internal").unwrap()); let mut options = MockConnectOptions::new(version.parse().unwrap()); - options.server_stats = registry.tier(tier.clone()).session(""); + options.server_stats = registry.tier(tier.clone()).session(Path::new("").unwrap()); options.client_publish = Some(publisher.consume()); options.server_subscribe = Some(subscriber.clone()); let _pair = connect_mock(options).await; - let broadcast = publisher.create_broadcast("room").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("room").unwrap()).unwrap(); let track = broadcast .create_track( "video", @@ -45,8 +46,8 @@ async fn control_classes_cross_lite_and_ietf_sessions_without_counting_payload() ) .unwrap(); broadcast.announce(Default::default()).unwrap(); - subscriber.consume().routed("room").await.unwrap(); - let remote = subscriber.consume().request_broadcast("room", None).await.unwrap(); + subscriber.consume().routed(Path::new("room").unwrap()).await.unwrap(); + let remote = subscriber.consume().request_broadcast(Path::new("room").unwrap(), None).await.unwrap(); let mut sub = remote.track("video").unwrap().subscribe(None).await.unwrap(); subscribed(&track).await; let mut group = track.append_group().unwrap(); @@ -79,13 +80,13 @@ async fn setup_counts_under_the_admitted_stats() { for version in ["moq-lite-07-wip", "moq-transport-14", "moq-transport-22"] { let version: moq_net::Version = version.parse().unwrap(); let registry = Registry::new(Default::default()); - let tier = Tier::new("internal"); + let tier = Tier::new(Path::new("internal").unwrap()); let mut transport = moq_net::transport::memory::Config::default(); transport.protocol = Some(version.alpn().to_string()); let (client_transport, server_transport) = create_mock_session_pair(transport); let client = moq_net::Client::new().with_versions(version.into()); let server = moq_net::Server::new().with_versions(version.into()); - let stats = registry.tier(tier.clone()).session(""); + let stats = registry.tier(tier.clone()).session(Path::new("").unwrap()); let client = async { let (session, driver) = client.connect(now(), client_transport).await.unwrap(); spawn(driver); diff --git a/rs/moq-net/tests/integration/datagram.rs b/rs/moq-net/tests/integration/datagram.rs index 2b373c9c6f6..9ea5efa87d9 100644 --- a/rs/moq-net/tests/integration/datagram.rs +++ b/rs/moq-net/tests/integration/datagram.rs @@ -7,6 +7,7 @@ //! delivery through the model. The mock delivers queued datagrams //! deterministically, so every wait here is on an observable event. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -44,7 +45,7 @@ async fn connect_datagram_track() -> Fixture { let publisher = produce_origin(1); let consumer_origin = produce_origin(2); - let broadcast = publisher.create_broadcast("bench").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bench").unwrap()).unwrap(); let producer = broadcast.create_track("datagrams", timed()).unwrap(); broadcast.announce(Default::default()).unwrap(); @@ -55,8 +56,8 @@ async fn connect_datagram_track() -> Fixture { let pair = connect_mock(options).await; let consumer = consumer_origin.consume(); - consumer.routed("bench").await.unwrap(); - let remote = consumer.request_broadcast("bench", None).await.unwrap(); + consumer.routed(Path::new("bench").unwrap()).await.unwrap(); + let remote = consumer.request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); let subscriber = remote.track("datagrams").unwrap().subscribe(None).await.unwrap(); // The subscriber is handed over once TRACK_INFO answers, before its SUBSCRIBE reaches // the publisher, and a datagram only goes to a subscription already there. @@ -140,7 +141,7 @@ async fn ietf_delivers_datagrams_on(version: &str) { let publisher = produce_origin(1); let consumer_origin = produce_origin(2); - let broadcast = publisher.create_broadcast("bench").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bench").unwrap()).unwrap(); let mut producer = broadcast.create_track("datagrams", timed()).unwrap(); broadcast.announce(Default::default()).unwrap(); @@ -150,8 +151,8 @@ async fn ietf_delivers_datagrams_on(version: &str) { let _pair = connect_mock(options).await; let consumer = consumer_origin.consume(); - consumer.routed("bench").await.unwrap(); - let remote = consumer.request_broadcast("bench", None).await.unwrap(); + consumer.routed(Path::new("bench").unwrap()).await.unwrap(); + let remote = consumer.request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); let mut subscriber = remote.track("datagrams").unwrap().subscribe(None).await.unwrap(); // A group first, so the subscription's alias is bound before any datagram lands. @@ -255,14 +256,14 @@ async fn a_fetched_datagram_is_refused_per_version() { _pairs.push(peer(version.parse().unwrap(), &pair[0], &pair[1]).await); } - let broadcast = nodes[0].create_broadcast("room").unwrap(); + let broadcast = nodes[0].create_broadcast(Path::new("room").unwrap()).unwrap(); let mut producer = broadcast.create_track("datagrams", timed()).unwrap(); broadcast.announce(Default::default()).unwrap(); let sequence = producer.append_datagram(Timestamp::ZERO, &b"x"[..]).unwrap(); let consumer = nodes.last().unwrap().consume(); - consumer.routed("room").await.unwrap(); - let remote = consumer.request_broadcast("room", None).await.unwrap(); + consumer.routed(Path::new("room").unwrap()).await.unwrap(); + let remote = consumer.request_broadcast(Path::new("room").unwrap(), None).await.unwrap(); let err = match remote.track("datagrams").unwrap().fetch_group(sequence, None).await { Ok(_) => panic!("{versions:?}: a datagram was fetched"), Err(err) => err, diff --git a/rs/moq-net/tests/integration/dial_split_horizon.rs b/rs/moq-net/tests/integration/dial_split_horizon.rs index ca4df3e39e7..8c49e9fde74 100644 --- a/rs/moq-net/tests/integration/dial_split_horizon.rs +++ b/rs/moq-net/tests/integration/dial_split_horizon.rs @@ -8,6 +8,7 @@ //! anonymous dial: the accepting side already stamps one, and the dialing side //! has to as well. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -43,7 +44,7 @@ struct Link { async fn dial(dialer: &origin::Producer, edge: &origin::Producer) -> Link { let version = version(); let registry = stats::Registry::new(stats::Config::new()); - let session_stats = registry.tier(stats::Tier::default()).session(""); + let session_stats = registry.tier(stats::Tier::default()).session(Path::new("").unwrap()); let mut mock = moq_net::transport::memory::Config::default(); mock.protocol = Some(version.alpn().to_string()); let (client_transport, server_transport) = create_mock_session_pair(mock); @@ -134,7 +135,7 @@ async fn dialed_anonymous_session_does_not_echo_or_route_subscribe_back() { let to_publisher = dial(&dialer, &publisher).await; let to_subscriber = dial(&dialer, &subscriber).await; - let broadcast = publisher.create_broadcast("room").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("room").unwrap()).unwrap(); let track = broadcast.create_track("video", None).unwrap(); broadcast.announce(origin::Route::default()).unwrap(); @@ -181,7 +182,7 @@ async fn dialed_anonymous_session_does_not_echo_or_route_subscribe_back() { // session it arrived on. let viewed = subscriber .consume() - .request_broadcast("room", None) + .request_broadcast(Path::new("room").unwrap(), None) .await .expect("subscriber resolves the namespace"); let subscription = moq_net::track::Subscription::default(); diff --git a/rs/moq-net/tests/integration/drained_claim.rs b/rs/moq-net/tests/integration/drained_claim.rs index 84ac5f0ad17..4e7c6a626a9 100644 --- a/rs/moq-net/tests/integration/drained_claim.rs +++ b/rs/moq-net/tests/integration/drained_claim.rs @@ -9,6 +9,7 @@ //! once unread lets the next viewer reach worker `B`, which wins the path now, rather //! than the drained worker. +use moq_net::Path; use crate::support; use std::{cell::RefCell, rc::Rc, time::Duration}; @@ -56,7 +57,7 @@ impl Worker { let origin = produce_origin(hop); let claim = Rc::new( origin - .dynamic_route("pool", origin::Route::default().with_cost(cost)) + .dynamic_route(Path::new("pool").unwrap(), origin::Route::default().with_cost(cost)) .unwrap(), ); let outputs = Rc::new(RefCell::new(Vec::new())); @@ -83,7 +84,7 @@ impl Worker { /// Read the first frame of `video` at `pool/p` through `relay`. async fn watch(relay: &origin::Producer) -> String { - let broadcast = relay.consume().request_broadcast("pool/p", None).await.unwrap(); + let broadcast = relay.consume().request_broadcast(Path::new("pool/p").unwrap(), None).await.unwrap(); let mut subscription = broadcast.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = subscription.recv_group().await.unwrap().expect("a group"); let frame = group.read_frame().await.unwrap().expect("a frame"); diff --git a/rs/moq-net/tests/integration/empty_group.rs b/rs/moq-net/tests/integration/empty_group.rs index ad7e1dd7c65..0003ea1cc93 100644 --- a/rs/moq-net/tests/integration/empty_group.rs +++ b/rs/moq-net/tests/integration/empty_group.rs @@ -4,6 +4,7 @@ //! to 17 its stream is a bare header with no FIRST_OBJECT bit, which must not read as a //! group missing its head. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -39,13 +40,13 @@ async fn an_empty_group_arrives_empty() { let subscriber = produce_origin(2); let _pair = peer(version.parse::().unwrap(), &publisher, &subscriber).await; - let broadcast = publisher.create_broadcast("room").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("room").unwrap()).unwrap(); let track = broadcast.create_track("data", timed()).unwrap(); broadcast.announce(Default::default()).unwrap(); let consumer = subscriber.consume(); - consumer.routed("room").await.unwrap(); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("room", None)) + consumer.routed(Path::new("room").unwrap()).await.unwrap(); + let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast(Path::new("room").unwrap(), None)) .await .expect("resolve timeout") .expect("broadcast resolves"); diff --git a/rs/moq-net/tests/integration/empty_replacement.rs b/rs/moq-net/tests/integration/empty_replacement.rs index 8c34a501ea8..59712f4c3b5 100644 --- a/rs/moq-net/tests/integration/empty_replacement.rs +++ b/rs/moq-net/tests/integration/empty_replacement.rs @@ -6,6 +6,7 @@ //! contradicts a received group, which the relay treats as a protocol violation and closes //! the whole session. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -43,7 +44,7 @@ async fn serve( async fn empty_replacement_ends_after_the_cached_group(version: &str) { let version: Version = version.parse().unwrap(); let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("room").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("room").unwrap()).unwrap(); let mut dynamic = broadcast.dynamic(); broadcast.announce(Default::default()).unwrap(); @@ -54,11 +55,11 @@ async fn empty_replacement_ends_after_the_cached_group(version: &str) { let pair = connect_mock(options).await; let consumer = relay.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("room")) + moq_clock::timeout(TIMEOUT, consumer.routed(Path::new("room").unwrap())) .await .unwrap() .unwrap(); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("room", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast(Path::new("room").unwrap(), None)) .await .unwrap() .unwrap(); diff --git a/rs/moq-net/tests/integration/extensions.rs b/rs/moq-net/tests/integration/extensions.rs index 7e8364c60db..ad77cfdbab4 100644 --- a/rs/moq-net/tests/integration/extensions.rs +++ b/rs/moq-net/tests/integration/extensions.rs @@ -5,6 +5,7 @@ //! //! Deterministic: paused time over the mock transport. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -95,7 +96,7 @@ async fn a_side_that_declines_solicit_takes_unsolicited_announces() { } let pair = connect_mock(options).await; - let broadcast = publisher.create_broadcast("room/cam").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("room/cam").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); moq_clock::sleep(SETTLE).await; @@ -210,7 +211,7 @@ async fn an_epoch_crosses_only_when_both_offer_it() { let pair = connect_mock(options).await; let epoch = moq_net::Epoch::mint(); - let broadcast = publisher.create_broadcast("room/cam").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("room/cam").unwrap()).unwrap(); broadcast .announce(origin::Route::default().with_epoch(epoch.clone())) .unwrap(); diff --git a/rs/moq-net/tests/integration/fetch_cancel.rs b/rs/moq-net/tests/integration/fetch_cancel.rs index 1609c164f85..c619edabb4d 100644 --- a/rs/moq-net/tests/integration/fetch_cancel.rs +++ b/rs/moq-net/tests/integration/fetch_cancel.rs @@ -7,6 +7,7 @@ //! (lite has no FETCH_OK, so one that never answers would pin them for good) or is //! partway through the group. A group cut short is aborted, never cached as whole. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -47,14 +48,14 @@ async fn abandoned_fetch_reaches_the_publisher(version: &str, relays: u64, stage _pairs.push(peer(version, &pair[0], &pair[1]).await); } - let broadcast = nodes[0].create_broadcast("room").unwrap(); + let broadcast = nodes[0].create_broadcast(Path::new("room").unwrap()).unwrap(); let mut dynamic = broadcast.dynamic(); broadcast.announce(Default::default()).unwrap(); moq_clock::sleep(Duration::from_secs(1)).await; let consumer = nodes[relays as usize] .consume() - .request_broadcast("room", None) + .request_broadcast(Path::new("room").unwrap(), None) .await .unwrap(); let track = consumer.track("video").unwrap(); @@ -169,12 +170,12 @@ async fn a_refetch_within_the_linger_stays_on_the_relay(version: &str) { let relay = produce_origin(2); let _pair = peer(version, &publisher, &relay).await; - let broadcast = publisher.create_broadcast("room").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("room").unwrap()).unwrap(); let mut dynamic = broadcast.dynamic(); broadcast.announce(Default::default()).unwrap(); moq_clock::sleep(Duration::from_secs(1)).await; - let consumer = relay.consume().request_broadcast("room", None).await.unwrap(); + let consumer = relay.consume().request_broadcast(Path::new("room").unwrap(), None).await.unwrap(); let mut waiting = Box::pin(consumer.track("video").unwrap().fetch_group(0, None)); let request = match futures::future::select(std::pin::pin!(dynamic.requested_track()), &mut waiting).await { futures::future::Either::Left((request, _)) => request.expect("the track request reaches the publisher"), diff --git a/rs/moq-net/tests/integration/fetch_fanout.rs b/rs/moq-net/tests/integration/fetch_fanout.rs index 3b09be36bf8..f6ff36f2f08 100644 --- a/rs/moq-net/tests/integration/fetch_fanout.rs +++ b/rs/moq-net/tests/integration/fetch_fanout.rs @@ -3,6 +3,7 @@ //! A relay fetches each group's payload upstream once, independently of how many //! viewers ask for it, and keeps serving the cached copy after a reader leaves. +use moq_net::Path; use crate::support; use moq_net::{Hop, Version, origin, track}; use std::time::Duration; @@ -19,7 +20,7 @@ async fn sequential_viewers_share_the_relays_fetched_groups() { for version in ["moq-lite-05", "moq-lite-06", "moq-lite-07-wip"] { let version: Version = version.parse().unwrap(); let publisher = origin(1); - let broadcast = publisher.publish("room", Default::default()).unwrap(); + let broadcast = publisher.publish(Path::new("room").unwrap(), Default::default()).unwrap(); let track = broadcast .create_track( "video", @@ -38,7 +39,7 @@ async fn sequential_viewers_share_the_relays_fetched_groups() { options.server_publish = Some(relay.consume()); options.client_subscribe = Some(viewer.clone()); let pair = connect_mock(options).await; - let remote = viewer.consume().routed_broadcast("room").await.unwrap(); + let remote = viewer.consume().routed_broadcast(Path::new("room").unwrap()).await.unwrap(); viewers.push((viewer, pair, remote)); } for round in 0..3 { diff --git a/rs/moq-net/tests/integration/fetch_from_feed.rs b/rs/moq-net/tests/integration/fetch_from_feed.rs index 66f33efce1c..f55dfe12bf5 100644 --- a/rs/moq-net/tests/integration/fetch_from_feed.rs +++ b/rs/moq-net/tests/integration/fetch_from_feed.rs @@ -4,6 +4,7 @@ //! subscription: a group the feed delivers is served, and one it never will is a miss, //! never a version error that a caller would retry forever. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -32,7 +33,7 @@ struct Relay { /// A publisher on `version` with group 0 of an untimed track written, and the relay's view of it. async fn relay(version: &str) -> Relay { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let mut track = broadcast .create_track("video", moq_net::track::Info::default().with_timescale(None)) .unwrap(); @@ -46,11 +47,11 @@ async fn relay(version: &str) -> Relay { let pair = connect_mock(options).await; let consumer = client.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) + moq_clock::timeout(TIMEOUT, consumer.routed(Path::new("bcast").unwrap())) .await .expect("announce timeout") .expect("routed"); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("bcast", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast(Path::new("bcast").unwrap(), None)) .await .expect("resolve timeout") .expect("broadcast resolves"); diff --git a/rs/moq-net/tests/integration/fetch_only.rs b/rs/moq-net/tests/integration/fetch_only.rs index 70d7bd7fffb..54ec47eb7bf 100644 --- a/rs/moq-net/tests/integration/fetch_only.rs +++ b/rs/moq-net/tests/integration/fetch_only.rs @@ -6,6 +6,7 @@ //! fetchable, and a relay's fetch-only demand puts no live subscription upstream to race //! the fetches that report where the track ends. +use moq_net::Path; use crate::support; use std::sync::Arc; @@ -30,11 +31,11 @@ fn produce_origin(hop: u64) -> moq_net::origin::Producer { async fn resolve(origin: &moq_net::origin::Producer) -> moq_net::broadcast::Consumer { let consumer = origin.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) + moq_clock::timeout(TIMEOUT, consumer.routed(Path::new("bcast").unwrap())) .await .expect("announce timeout") .expect("routed"); - moq_clock::timeout(TIMEOUT, consumer.request_broadcast("bcast", None)) + moq_clock::timeout(TIMEOUT, consumer.request_broadcast(Path::new("bcast").unwrap(), None)) .await .expect("resolve timeout") .expect("broadcast resolves") @@ -42,7 +43,7 @@ async fn resolve(origin: &moq_net::origin::Producer) -> moq_net::broadcast::Cons /// Publish a finished track of three groups, and flag any subscription it ever gets. fn publish_finished(origin: &moq_net::origin::Producer) -> (moq_net::broadcast::Producer, Arc) { - let broadcast = origin.create_broadcast("bcast").unwrap(); + let broadcast = origin.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let mut track = broadcast.create_track("video", timed()).unwrap(); broadcast.announce(Default::default()).unwrap(); for sequence in 0..3u64 { @@ -169,7 +170,7 @@ async fn a_subscribe_after_track_status_keeps_timestamps() { for version in ["moq-transport-18", "moq-transport-19", "moq-transport-22"] { moq_clock::timeout(TIMEOUT, async { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let track = broadcast.create_track("video", timed()).unwrap(); broadcast.announce(Default::default()).unwrap(); diff --git a/rs/moq-net/tests/integration/finished_broadcast_mock.rs b/rs/moq-net/tests/integration/finished_broadcast_mock.rs index 7c8701f3e6d..83646367790 100644 --- a/rs/moq-net/tests/integration/finished_broadcast_mock.rs +++ b/rs/moq-net/tests/integration/finished_broadcast_mock.rs @@ -14,6 +14,7 @@ //! writes the track and ends it with no await in between, so the session has sent //! nothing when the broadcast ends. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -39,7 +40,7 @@ fn produce_origin(hop: u64) -> moq_net::origin::Producer { /// the subscriber read: the frame payloads and the error it ended with, if any. async fn round(finish_broadcast: bool) -> (Vec>, Option) { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let track = broadcast.create_track("video", timed()).unwrap(); broadcast.announce(Default::default()).unwrap(); @@ -50,11 +51,11 @@ async fn round(finish_broadcast: bool) -> (Vec>, Option) let pair: MockPair = connect_mock(options).await; let consumer = subscriber.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) + moq_clock::timeout(TIMEOUT, consumer.routed(Path::new("bcast").unwrap())) .await .expect("announce timeout") .expect("routed"); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("bcast", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast(Path::new("bcast").unwrap(), None)) .await .expect("resolve timeout") .expect("broadcast resolves"); diff --git a/rs/moq-net/tests/integration/finite_relay.rs b/rs/moq-net/tests/integration/finite_relay.rs index ff700f21e43..f2362e612de 100644 --- a/rs/moq-net/tests/integration/finite_relay.rs +++ b/rs/moq-net/tests/integration/finite_relay.rs @@ -8,6 +8,7 @@ //! last until those groups drain: a relay cancels its upstream subscription once nobody //! subscribes, and the publisher then resets every group still on the wire. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -60,7 +61,7 @@ enum Arrival { async fn round(name: &str, arrival: Arrival) -> (Vec, Result<(), moq_net::Error>) { let version: Version = name.parse().unwrap(); let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let mut track = broadcast.create_track("tail", timed()).unwrap(); broadcast.announce(Default::default()).unwrap(); @@ -77,11 +78,11 @@ async fn round(name: &str, arrival: Arrival) -> (Vec, Result<(), moq_net::E let downstream = connect_mock(options).await; let consumer = subscriber.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) + moq_clock::timeout(TIMEOUT, consumer.routed(Path::new("bcast").unwrap())) .await .expect("announce timeout") .expect("routed"); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("bcast", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast(Path::new("bcast").unwrap(), None)) .await .expect("resolve timeout") .expect("broadcast resolves"); diff --git a/rs/moq-net/tests/integration/goaway.rs b/rs/moq-net/tests/integration/goaway.rs index 72f1395032f..e11ab64484e 100644 --- a/rs/moq-net/tests/integration/goaway.rs +++ b/rs/moq-net/tests/integration/goaway.rs @@ -6,6 +6,7 @@ //! network I/O), so these tests are reliable without sleeps: every wait is on //! an observable event. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -374,7 +375,7 @@ async fn goaway_keeps_new_subscribes(version: Version) { moq_clock::timeout(TEST_TIMEOUT, async { // Server publishes a broadcast with one live track. let pub_origin = produce_origin(Hop::random()); - let broadcast = pub_origin.create_broadcast("test").expect("create broadcast"); + let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); broadcast.announce(moq_net::origin::Route::default()).expect("announce"); let track = broadcast.create_track("video", timed()).expect("create track"); // A second track with content ready for the subscribe opened after the GOAWAY. @@ -395,8 +396,8 @@ async fn goaway_keeps_new_subscribes(version: Version) { // Subscribe BEFORE the GOAWAY and receive a first group. let sub = sub_origin.consume(); - sub.routed("test").await.expect("route announced"); - let bc = sub.request_broadcast("test", None).await.expect("broadcast resolves"); + sub.routed(Path::new("test").unwrap()).await.expect("route announced"); + let bc = sub.request_broadcast(Path::new("test").unwrap(), None).await.expect("broadcast resolves"); let mut existing = bc.track("video").unwrap().subscribe(None).await.expect("subscribe"); let mut group = track.append_group().expect("append group"); @@ -484,7 +485,7 @@ async fn goaway_keeps_new_subscribes_moq_transport_19() { async fn goaway_drains_routes(version: Version) { moq_clock::timeout(TEST_TIMEOUT, async { let pub_origin = produce_origin(Hop::random()); - let broadcast = pub_origin.create_broadcast("test").expect("create broadcast"); + let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); broadcast.announce(moq_net::origin::Route::default()).expect("announce"); let sub_origin = produce_origin(Hop::random()); @@ -495,7 +496,7 @@ async fn goaway_drains_routes(version: Version) { let MockPair { client, server, .. } = connect_mock(opts).await; let sub = sub_origin.consume(); - let route = sub.routed("test").await.expect("route announced"); + let route = sub.routed(Path::new("test").unwrap()).await.expect("route announced"); assert_ne!( route.cost, moq_net::origin::Cost::DRAIN, diff --git a/rs/moq-net/tests/integration/group_order.rs b/rs/moq-net/tests/integration/group_order.rs index 581fe3c63bc..1ee1748e7e1 100644 --- a/rs/moq-net/tests/integration/group_order.rs +++ b/rs/moq-net/tests/integration/group_order.rs @@ -7,6 +7,7 @@ //! the hop into the subscriber and releases them by send order, the way a congested //! sender would transmit them. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -47,12 +48,12 @@ async fn connect( fn read_arrivals(origin: moq_net::origin::Producer, order: Order) -> moq_clock::sim::JoinHandle> { moq_clock::sim::spawn(async move { let consumer = origin.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) + moq_clock::timeout(TIMEOUT, consumer.routed(Path::new("bcast").unwrap())) .await .expect("announce timeout") .expect("routed"); let remote = consumer - .request_broadcast("bcast", None) + .request_broadcast(Path::new("bcast").unwrap(), None) .await .expect("broadcast resolves"); let subscription = Subscription::default() @@ -114,7 +115,7 @@ fn carries_order(version: &str) -> bool { async fn round(version: &str, relay: bool, order: Order) -> Vec { let version: Version = version.parse().unwrap(); let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let track = broadcast .create_track( "ordered", @@ -189,7 +190,7 @@ async fn merged_subscribers_keep_their_own_order() { for version in ["moq-lite-07-wip", "moq-transport-17"] { let version: Version = version.parse().unwrap(); let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let track = broadcast .create_track( "ordered", diff --git a/rs/moq-net/tests/integration/history_groups.rs b/rs/moq-net/tests/integration/history_groups.rs index e7ada798343..52a9ac9a21b 100644 --- a/rs/moq-net/tests/integration/history_groups.rs +++ b/rs/moq-net/tests/integration/history_groups.rs @@ -8,6 +8,7 @@ //! would drop the older group for good. The mock holds the publisher's group streams and //! releases them newest first to make that race deterministic. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -42,7 +43,7 @@ fn produce_origin(hop: u64) -> moq_net::origin::Producer { async fn round(version: &str, relay: bool, newest_first: bool) -> Vec<(u64, usize)> { let version: Version = version.parse().unwrap(); let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let track = broadcast .create_track( "history", @@ -72,11 +73,11 @@ async fn round(version: &str, relay: bool, newest_first: bool) -> Vec<(u64, usiz let pair = connect_mock(options).await; let consumer = subscriber.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) + moq_clock::timeout(TIMEOUT, consumer.routed(Path::new("bcast").unwrap())) .await .expect("announce timeout") .expect("routed"); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("bcast", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast(Path::new("bcast").unwrap(), None)) .await .expect("resolve timeout") .expect("broadcast resolves"); @@ -202,7 +203,7 @@ async fn a_late_subscriber_receives_the_relays_cached_history() { // Older drafts canonicalize group 0 to the live edge instead of replay. let version: Version = "moq-lite-07-wip".parse().unwrap(); let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let track = broadcast .create_track( "history", @@ -221,8 +222,8 @@ async fn a_late_subscriber_receives_the_relays_cached_history() { options.client_subscribe = Some(first.clone()); let first_pair = connect_mock(options).await; let consumer = first.consume(); - consumer.routed("bcast").await.unwrap(); - let remote = consumer.request_broadcast("bcast", None).await.unwrap(); + consumer.routed(Path::new("bcast").unwrap()).await.unwrap(); + let remote = consumer.request_broadcast(Path::new("bcast").unwrap(), None).await.unwrap(); let subscription = Subscription::default().with_max_delay(FOREVER).with_range(0..); let first_subscription = subscription.clone(); let first_reader = moq_clock::sim::spawn(async move { @@ -259,8 +260,8 @@ async fn a_late_subscriber_receives_the_relays_cached_history() { options.client_subscribe = Some(late.clone()); let late_pair = connect_mock(options).await; let consumer = late.consume(); - consumer.routed("bcast").await.unwrap(); - let remote = consumer.request_broadcast("bcast", None).await.unwrap(); + consumer.routed(Path::new("bcast").unwrap()).await.unwrap(); + let remote = consumer.request_broadcast(Path::new("bcast").unwrap(), None).await.unwrap(); let mut late_sub = remote.track("history").unwrap().subscribe(subscription).await.unwrap(); moq_clock::timeout(TIMEOUT, read_history(&mut late_sub)) .await diff --git a/rs/moq-net/tests/integration/idle_cancel_refetch.rs b/rs/moq-net/tests/integration/idle_cancel_refetch.rs index 0705c09f658..ca7f44c96d1 100644 --- a/rs/moq-net/tests/integration/idle_cancel_refetch.rs +++ b/rs/moq-net/tests/integration/idle_cancel_refetch.rs @@ -3,6 +3,7 @@ //! A relay whose last reader leaves mid-group cancels the idle upstream subscription. A later //! fetch of that group still gets every frame (#5348, a release-line regression). +use moq_net::Path; use crate::support; use std::time::Duration; @@ -21,7 +22,7 @@ fn produce_origin(hop: u64) -> moq_net::origin::Producer { #[moq_clock::test] async fn a_group_cut_by_an_idle_cancel_is_refetched_whole() { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let track = broadcast .create_track("audio", moq_net::track::Info::default().with_timescale(None)) .unwrap(); @@ -40,11 +41,11 @@ async fn a_group_cut_by_an_idle_cancel_is_refetched_whole() { let _pair = connect_mock(options).await; let consumer = client.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) + moq_clock::timeout(TIMEOUT, consumer.routed(Path::new("bcast").unwrap())) .await .unwrap() .unwrap(); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("bcast", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast(Path::new("bcast").unwrap(), None)) .await .unwrap() .unwrap(); diff --git a/rs/moq-net/tests/integration/idle_session.rs b/rs/moq-net/tests/integration/idle_session.rs index 593ee2ead4f..673dd259f64 100644 --- a/rs/moq-net/tests/integration/idle_session.rs +++ b/rs/moq-net/tests/integration/idle_session.rs @@ -4,6 +4,7 @@ //! no transport stats reads while nothing moves. A server holds thousands of these, //! so a fixed-interval timer per session adds up to whole cores. +use moq_net::Path; use crate::support; use std::{ @@ -95,7 +96,7 @@ async fn busy_viewer_sees_the_estimate_move() { ..STATS }); // Server work for this session: announcing a broadcast to the viewer. - let broadcast = origin.create_broadcast("live").unwrap(); + let broadcast = origin.create_broadcast(Path::new("live").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); let moved = moq_clock::timeout(Duration::from_millis(1), probe.changed()).await; @@ -179,7 +180,7 @@ async fn wire_collection_never_arms_the_idle_sampler() { let registry = moq_net::stats::Registry::new(Default::default()); let polls = Arc::new(AtomicUsize::new(0)); let mut options = MockConnectOptions::new(version.parse().unwrap()); - options.server_stats = registry.tier(Default::default()).session("room"); + options.server_stats = registry.tier(Default::default()).session(Path::new("room").unwrap()); options.server_polls = Some(polls.clone()); let pair = connect_mock(options).await; moq_clock::sleep(Duration::from_secs(1)).await; diff --git a/rs/moq-net/tests/integration/ietf_conformance.rs b/rs/moq-net/tests/integration/ietf_conformance.rs index 163ae649fe2..01c708b97cb 100644 --- a/rs/moq-net/tests/integration/ietf_conformance.rs +++ b/rs/moq-net/tests/integration/ietf_conformance.rs @@ -2,6 +2,7 @@ //! Moxygen announces one prefix, then serves its sixteen-field test namespaces. +use moq_net::Path; use crate::support::harness::{MockConnectOptions, connect_mock, spawn}; use moq_net::{Hop, Version, broadcast, origin}; use std::sync::Arc; @@ -21,7 +22,7 @@ async fn routing(version: &str, cluster: bool) { let publisher = origin(1); let relay = origin(2); let reader = origin(4); - let prefix = Arc::new(publisher.dynamic_route(PREFIX, Default::default()).unwrap()); + let prefix = Arc::new(publisher.dynamic_route(Path::new(PREFIX).unwrap(), Default::default()).unwrap()); let broadcast = broadcast::Info::new().produce(); let track = broadcast.create_track("test", moq_net::track::Info::default()).unwrap(); let serving = prefix.clone(); @@ -53,8 +54,8 @@ async fn routing(version: &str, cluster: bool) { options.client_subscribe = Some(reader.clone()); links.push(connect_mock(options).await); - reader.consume().routed(NAMESPACE).await.unwrap(); - let remote = reader.consume().request_broadcast(NAMESPACE, None).await.unwrap(); + reader.consume().routed(Path::new(NAMESPACE).unwrap()).await.unwrap(); + let remote = reader.consume().request_broadcast(Path::new(NAMESPACE).unwrap(), None).await.unwrap(); let mut subscription = remote.track("test").unwrap().subscribe(None).await.unwrap(); crate::support::harness::subscribed(&track).await; let mut group = track.append_group().unwrap(); diff --git a/rs/moq-net/tests/integration/late_lower_group.rs b/rs/moq-net/tests/integration/late_lower_group.rs index a7aa035cdbd..f83193b9b61 100644 --- a/rs/moq-net/tests/integration/late_lower_group.rs +++ b/rs/moq-net/tests/integration/late_lower_group.rs @@ -7,6 +7,7 @@ //! is dropped. Lite-06 and later encode a floor of group 0 as 0, which is the only //! spelling of both an omitted floor and group 0; the draft says that 0 is group 0. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -82,7 +83,7 @@ async fn read_all(sub: &mut moq_net::track::Subscriber) -> Vec<(u64, usize)> { async fn session(version: &str, relay: bool, start: Option) -> Vec<(u64, usize)> { let version: Version = version.parse().unwrap(); let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let track = broadcast .create_track( "late", @@ -114,11 +115,11 @@ async fn session(version: &str, relay: bool, start: Option) -> Vec<(u64, us let pair = connect_mock(options).await; let consumer = subscriber.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) + moq_clock::timeout(TIMEOUT, consumer.routed(Path::new("bcast").unwrap())) .await .expect("announce timeout") .expect("routed"); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("bcast", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast(Path::new("bcast").unwrap(), None)) .await .expect("resolve timeout") .expect("broadcast resolves"); @@ -158,7 +159,7 @@ async fn session(version: &str, relay: bool, start: Option) -> Vec<(u64, us async fn in_process(start: Option) -> Vec<(u64, usize)> { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let track = broadcast .create_track( "late", diff --git a/rs/moq-net/tests/integration/lazy_discovery.rs b/rs/moq-net/tests/integration/lazy_discovery.rs index 42075bce0fb..9325ebe89aa 100644 --- a/rs/moq-net/tests/integration/lazy_discovery.rs +++ b/rs/moq-net/tests/integration/lazy_discovery.rs @@ -4,6 +4,7 @@ //! watch, keeps a request open while anything at or beneath it is watched, and lets //! it go once nothing has been for a linger. A relay's link still asks for everything. +use moq_net::Path; use std::time::Duration; use moq_net::{Error, Hop, Pattern, Patterns, Version, announce, origin}; @@ -47,7 +48,7 @@ impl Lazy { let broadcasts = ["a/x", "b/y"] .into_iter() .map(|path| { - let broadcast = publisher.create_broadcast(path).unwrap(); + let broadcast = publisher.create_broadcast(Path::new(path).unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); broadcast }) @@ -80,14 +81,14 @@ impl Lazy { fn watch(&self, prefix: &str) -> announce::Consumer { self.subscriber .consume() - .scope(prefix, &Patterns::from(Pattern::all())) + .scope(Path::new(prefix).unwrap(), &Patterns::from(Pattern::all())) .unwrap() .announced() } /// Whether the client's origin routes `path` right now. async fn routes(&self, path: &str) -> bool { - match self.subscriber.consume().request_broadcast(path, None).await { + match self.subscriber.consume().request_broadcast(Path::new(path).unwrap(), None).await { Ok(_) => true, Err(Error::Unroutable) => false, Err(err) => panic!("{path}: {err}"), @@ -144,7 +145,7 @@ async fn a_new_session_asks_about_existing_watches() { let subscriber = produce_origin(2); let mut watch = subscriber .consume() - .scope("b", &Patterns::from(Pattern::all())) + .scope(Path::new("b").unwrap(), &Patterns::from(Pattern::all())) .unwrap() .announced(); let lazy = Lazy::with("moq-lite-07-wip", subscriber).await; @@ -258,7 +259,7 @@ async fn a_resolved_broadcast_keeps_its_route() { let lazy = Lazy::new(version).await; let mut watch = lazy.watch("a"); synced(&mut watch).await; - let broadcast = lazy.subscriber.consume().request_broadcast("a/x", None).await.unwrap(); + let broadcast = lazy.subscriber.consume().request_broadcast(Path::new("a/x").unwrap(), None).await.unwrap(); drop(watch); moq_clock::sleep(LINGERED).await; @@ -275,11 +276,11 @@ async fn waiting_on_a_path_asks_about_it() { for version in VERSIONS { let lazy = Lazy::new(version).await; let consumer = lazy.subscriber.consume(); - moq_clock::timeout(SETTLE, consumer.routed_broadcast("a/x")) + moq_clock::timeout(SETTLE, consumer.routed_broadcast(Path::new("a/x").unwrap())) .await .expect("routed in time") .unwrap(); - let mut followed = consumer.announced_broadcast("b/y", None).unwrap(); + let mut followed = consumer.announced_broadcast(Path::new("b/y").unwrap(), None).unwrap(); moq_clock::timeout(SETTLE, followed.available()) .await .expect("announced in time") @@ -303,7 +304,7 @@ async fn a_relay_link_asks_for_everything() { assert_eq!(lazy.requests(), 1, "{version}"); // Read through a plain handle: one taken from an upstream link hides its routes. for path in ["a/x", "b/y"] { - relay.consume().request_broadcast(path, None).await.unwrap(); + relay.consume().request_broadcast(Path::new(path).unwrap(), None).await.unwrap(); } } } @@ -314,7 +315,7 @@ async fn a_relay_link_asks_for_everything() { async fn a_server_asks_for_everything() { for version in VERSIONS { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("a/x").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("a/x").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); let relay = produce_origin(2); let mut options = MockConnectOptions::new(version.parse::().unwrap()); @@ -322,7 +323,7 @@ async fn a_server_asks_for_everything() { options.server_subscribe = Some(relay.clone()); let _pair = connect_mock(options).await; moq_clock::sleep(SETTLE).await; - relay.consume().request_broadcast("a/x", None).await.unwrap(); + relay.consume().request_broadcast(Path::new("a/x").unwrap(), None).await.unwrap(); } } @@ -333,7 +334,7 @@ async fn serving_the_peer_asks_nothing() { for version in VERSIONS { let local = produce_origin(2); let remote = produce_origin(1); - let broadcast = remote.create_broadcast("a/x").unwrap(); + let broadcast = remote.create_broadcast(Path::new("a/x").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); let mut options = MockConnectOptions::new(version.parse::().unwrap()); @@ -353,7 +354,7 @@ async fn serving_the_peer_asks_nothing() { .count(); assert_eq!(requests, 0, "{version}"); assert!(matches!( - local.consume().request_broadcast("a/x", None).await, + local.consume().request_broadcast(Path::new("a/x").unwrap(), None).await, Err(Error::Unroutable) )); } @@ -483,7 +484,7 @@ async fn ietf_waiting_on_a_path_asks_about_it() { for version in IETF { let lazy = Lazy::new(version).await; let consumer = lazy.subscriber.consume(); - moq_clock::timeout(SETTLE, consumer.routed_broadcast("a/x")) + moq_clock::timeout(SETTLE, consumer.routed_broadcast(Path::new("a/x").unwrap())) .await .expect("routed in time") .unwrap(); @@ -498,7 +499,7 @@ async fn ietf_a_relay_link_asks_for_everything() { let relay = produce_origin(2); let _lazy = Lazy::with(version, relay.clone().with_link(moq_net::origin::Link::Peer)).await; for path in ["a/x", "b/y"] { - relay.consume().request_broadcast(path, None).await.unwrap(); + relay.consume().request_broadcast(Path::new(path).unwrap(), None).await.unwrap(); } } } diff --git a/rs/moq-net/tests/integration/mesh_withdraw.rs b/rs/moq-net/tests/integration/mesh_withdraw.rs index 0c2e6605c21..34637ca50b6 100644 --- a/rs/moq-net/tests/integration/mesh_withdraw.rs +++ b/rs/moq-net/tests/integration/mesh_withdraw.rs @@ -7,6 +7,7 @@ //! withdrawn; a relay that selects them in turn re-advertises each stale path, and //! the cluster walks all of them before it converges (path hunting). +use moq_net::Path; use crate::support; use std::{collections::HashMap, time::Duration}; @@ -102,7 +103,7 @@ impl Mesh { let broadcasts = (0..count) .map(|i| { let broadcast = self.nodes[(i + offset) % relays] - .create_broadcast(format!("room/{i}")) + .create_broadcast(Path::try_from(format!("room/{i}")).unwrap()) .unwrap(); broadcast.announce(Default::default()).unwrap(); broadcast @@ -224,7 +225,7 @@ async fn partial_mesh_withdraw_retracts_once() { let mut watched: Vec<_> = nodes.iter().map(|node| watch(node.consume().announced())).collect(); for publisher in [5, 13, 22, 26, 32] { - let broadcast = nodes[publisher].create_broadcast(format!("room/{publisher}")).unwrap(); + let broadcast = nodes[publisher].create_broadcast(Path::try_from(format!("room/{publisher}")).unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); moq_clock::sim::idle().await; for (relay, watched) in watched.iter_mut().enumerate() { @@ -278,7 +279,7 @@ async fn retracted_relay_ignores_a_stale_path() { } let mut watched: Vec<_> = nodes.iter().map(|node| watch(node.consume().announced())).collect(); - let broadcast = nodes[7].create_broadcast("room/7").unwrap(); + let broadcast = nodes[7].create_broadcast(Path::new("room/7").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); moq_clock::sim::idle().await; for watched in watched.iter_mut() { @@ -360,7 +361,7 @@ impl Cluster { /// Publish `path` from the client and require everyone to see it. Returns /// what the watching client saw. async fn publish(&mut self, path: &str) -> (broadcast::Producer, Vec) { - let broadcast = self.publisher.create_broadcast(path).unwrap(); + let broadcast = self.publisher.create_broadcast(Path::new(path).unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); moq_clock::sim::idle().await; let client = drain(&mut self.client).remove(path).unwrap(); @@ -657,9 +658,9 @@ async fn hop_limit_bounds_receive_and_send() { .unwrap(), ) }; - let _long = source.dynamic_route("long", route(2)).unwrap(); - let _boundary = source.dynamic_route("boundary", route(1)).unwrap(); - let short = source.dynamic_route("short", route(0)).unwrap(); + let _long = source.dynamic_route(Path::new("long").unwrap(), route(2)).unwrap(); + let _boundary = source.dynamic_route(Path::new("boundary").unwrap(), route(1)).unwrap(); + let short = source.dynamic_route(Path::new("short").unwrap(), route(0)).unwrap(); moq_clock::sim::idle().await; let received = drain(&mut received); assert!(!received.contains_key("long"), "{name}: accepted over-limit path"); @@ -678,7 +679,7 @@ async fn hop_limit_bounds_receive_and_send() { Some(&Kind::End), "{name}" ); - let _replacement = source.dynamic_route("short", route(1)).unwrap(); + let _replacement = source.dynamic_route(Path::new("short").unwrap(), route(1)).unwrap(); moq_clock::sim::idle().await; assert!(drain(&mut sent).is_empty(), "{name}: forwarded over-limit replacement"); continue; @@ -738,9 +739,9 @@ async fn hop_limit_falls_back_to_a_forwardable_route() { .with_cost(origin::Cost::new(cost)) }; // Three hops at the relay once the sender is appended: in the cap, but full. - let _cheap = far.dynamic_route("room", route(100, 2, 1)).unwrap(); + let _cheap = far.dynamic_route(Path::new("room").unwrap(), route(100, 2, 1)).unwrap(); // Two hops at the relay, so it has room for the relay's own. - let pricey = near.dynamic_route("room", route(200, 1, 50)).unwrap(); + let pricey = near.dynamic_route(Path::new("room").unwrap(), route(200, 1, 50)).unwrap(); moq_clock::sim::idle().await; let started = drain(&mut sent); assert_eq!( diff --git a/rs/moq-net/tests/integration/model.rs b/rs/moq-net/tests/integration/model.rs index 5dbcf90053c..1ad0f9adf7b 100644 --- a/rs/moq-net/tests/integration/model.rs +++ b/rs/moq-net/tests/integration/model.rs @@ -1,5 +1,6 @@ //! The explicit-time model works without async helpers or a runtime. +use moq_net::Path; use moq_net::{Error, Hop, Timestamp, broadcast, frame, group, kio, origin, track}; use std::task::Poll; @@ -16,7 +17,7 @@ fn origin_front_serves_media_with_only_explicit_polls() { let waiter = kio::Waiter::noop(); let (origin, mut driver) = origin::Producer::new(origin::Config::new(Hop::new(1).unwrap())); driver.poll(now, &waiter).unwrap(); - let broadcast = origin.create_broadcast("room/live").unwrap(); + let broadcast = origin.create_broadcast(Path::new("room/live").unwrap()).unwrap(); let track = broadcast .create_track( "video", @@ -29,7 +30,7 @@ fn origin_front_serves_media_with_only_explicit_polls() { broadcast.announce(origin::Route::default()).unwrap(); // Resolving and subscribing pass through the origin's core front tasks. - let requesting = origin.consume().request_broadcast("room/live", None); + let requesting = origin.consume().request_broadcast(Path::new("room/live").unwrap(), None); assert!(requesting.poll_ok(&waiter).is_pending()); driver.poll(now, &waiter).unwrap(); let receiving: broadcast::Consumer = ready(requesting.poll_ok(&waiter)).unwrap(); @@ -44,7 +45,7 @@ fn origin_front_serves_media_with_only_explicit_polls() { // Driver teardown also works without any executor-owned tasks. drop(driver); - assert!(matches!(origin.create_broadcast("after-close"), Err(Error::Closed))); + assert!(matches!(origin.create_broadcast(Path::new("after-close").unwrap()), Err(Error::Closed))); } #[test] @@ -57,9 +58,9 @@ fn routed_broadcast_resolves_with_only_explicit_polls() { driver.poll(now, &waiter).unwrap(); // Nothing covers the path yet: the first ask fails `Unroutable` and parks on the routes. - let mut routing = origin.consume().routed_broadcast("room/live"); + let mut routing = origin.consume().routed_broadcast(Path::new("room/live").unwrap()); assert!(routing.poll(&waiter).is_pending()); - let broadcast = origin.create_broadcast("room/live").unwrap(); + let broadcast = origin.create_broadcast(Path::new("room/live").unwrap()).unwrap(); assert!(routing.poll(&waiter).is_pending()); // Announcing moves the routes, so the next poll asks again and the driver serves it. @@ -70,7 +71,7 @@ fn routed_broadcast_resolves_with_only_explicit_polls() { assert_eq!(resolved.info().path.as_str(), "room/live"); // A closed origin ends a parked resolution. - let mut routing = origin.consume().routed_broadcast("room/other"); + let mut routing = origin.consume().routed_broadcast(Path::new("room/other").unwrap()); assert!(routing.poll(&waiter).is_pending()); drop(driver); assert!(matches!(ready(routing.poll(&waiter)), Err(Error::Closed))); diff --git a/rs/moq-net/tests/integration/multi_cdn.rs b/rs/moq-net/tests/integration/multi_cdn.rs index 6fb67494522..810750e5f3d 100644 --- a/rs/moq-net/tests/integration/multi_cdn.rs +++ b/rs/moq-net/tests/integration/multi_cdn.rs @@ -11,6 +11,7 @@ //! that cannot carry the epoch (before draft-17) makes each move a restart and a //! re-request. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -159,7 +160,7 @@ impl Topology { let cdn_b = produce_origin(3); let subscriber = produce_origin(4); - let broadcast = publisher.create_broadcast("live").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("live").unwrap()).unwrap(); let track = broadcast.create_track("video", timed()).unwrap(); broadcast .announce(origin::Route::default().with_epoch(moq_net::Epoch::mint())) @@ -188,7 +189,7 @@ impl Topology { } async fn subscribe(&self) -> mpsc::UnboundedReceiver { - let remote = self.subscriber.consume().request_broadcast("live", None).await.unwrap(); + let remote = self.subscriber.consume().request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); let prefs = track::Subscription::default().with_max_delay(Duration::from_secs(60)); read(remote.track("video").unwrap().subscribe(prefs).await.unwrap()) } diff --git a/rs/moq-net/tests/integration/partial_group.rs b/rs/moq-net/tests/integration/partial_group.rs index 609ee7e5462..d6c93d94a34 100644 --- a/rs/moq-net/tests/integration/partial_group.rs +++ b/rs/moq-net/tests/integration/partial_group.rs @@ -4,6 +4,7 @@ //! reaches the next hop as finished. The served stream resets with `Old`, so a relay does //! not cache the frames it already has as the whole group. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -45,18 +46,18 @@ async fn round(version: &str) -> Option, moq_net::Error>> { let downstream = produce_origin(2); let _pair = peer(version.parse::().unwrap(), &publisher, &downstream).await; - let broadcast = publisher.create_broadcast("room").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("room").unwrap()).unwrap(); let track = broadcast .create_track("data", Info::default().with_timescale(Timescale::MILLI)) .unwrap(); broadcast.announce(Default::default()).unwrap(); let consumer = downstream.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("room")) + moq_clock::timeout(TIMEOUT, consumer.routed(Path::new("room").unwrap())) .await .expect("announce timeout") .expect("routed"); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("room", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast(Path::new("room").unwrap(), None)) .await .expect("resolve timeout") .expect("broadcast resolves"); diff --git a/rs/moq-net/tests/integration/quiet_catalog.rs b/rs/moq-net/tests/integration/quiet_catalog.rs index dab2e9e4a32..ffc5e5b7c16 100644 --- a/rs/moq-net/tests/integration/quiet_catalog.rs +++ b/rs/moq-net/tests/integration/quiet_catalog.rs @@ -5,6 +5,7 @@ //! catalog does not produce one, so a reader that never received the snapshot //! must still get it. +use moq_net::Path; use crate::support; use std::{future::Future, time::Duration}; @@ -48,7 +49,7 @@ async fn settle() { /// Announce `live/catalog.json` holding one finished snapshot group. fn publish(origin: &origin::Producer) -> (broadcast::Producer, track::Producer) { - let broadcast = origin.create_broadcast("live").unwrap(); + let broadcast = origin.create_broadcast(Path::new("live").unwrap()).unwrap(); let track = broadcast.create_track("catalog.json", timed()).unwrap(); broadcast.announce(Default::default()).unwrap(); let mut group = track.append_group().unwrap(); @@ -59,8 +60,8 @@ fn publish(origin: &origin::Producer) -> (broadcast::Producer, track::Producer) async fn request(origin: &origin::Producer) -> broadcast::Consumer { let consumer = origin.consume(); - consumer.routed("live").await.unwrap(); - consumer.request_broadcast("live", None).await.unwrap() + consumer.routed(Path::new("live").unwrap()).await.unwrap(); + consumer.request_broadcast(Path::new("live").unwrap(), None).await.unwrap() } /// Subscribe without a floor and expect the snapshot as group 0. diff --git a/rs/moq-net/tests/integration/range_anchors.rs b/rs/moq-net/tests/integration/range_anchors.rs index d1d1c3e2c7d..c80a5d46534 100644 --- a/rs/moq-net/tests/integration/range_anchors.rs +++ b/rs/moq-net/tests/integration/range_anchors.rs @@ -5,6 +5,7 @@ //! the anchor the same way. A copy received over any other wire refuses the anchor instead //! of resolving it against the part of the track it happens to hold. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -46,7 +47,7 @@ fn millis(ms: u64) -> Timestamp { /// over one session on it. async fn read(version: Option<&str>, range: Range) -> Result, Error> { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("room").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("room").unwrap()).unwrap(); let track = broadcast .create_track( "data", @@ -64,18 +65,18 @@ async fn read(version: Option<&str>, range: Range) -> Result, Error> { let _pair; let remote = match version { // Through the origin, as a reader of a local route. - None => moq_clock::timeout(TIMEOUT, publisher.consume().request_broadcast("room", None)) + None => moq_clock::timeout(TIMEOUT, publisher.consume().request_broadcast(Path::new("room").unwrap(), None)) .await .expect("resolve timeout") .expect("broadcast resolves"), Some(version) => { _pair = peer(version.parse::().unwrap(), &publisher, &subscriber).await; let consumer = subscriber.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("room")) + moq_clock::timeout(TIMEOUT, consumer.routed(Path::new("room").unwrap())) .await .expect("announce timeout") .expect("routed"); - moq_clock::timeout(TIMEOUT, consumer.request_broadcast("room", None)) + moq_clock::timeout(TIMEOUT, consumer.request_broadcast(Path::new("room").unwrap(), None)) .await .expect("resolve timeout") .expect("broadcast resolves") diff --git a/rs/moq-net/tests/integration/received_rewind.rs b/rs/moq-net/tests/integration/received_rewind.rs index 6b8bd7cda19..fb822afd70e 100644 --- a/rs/moq-net/tests/integration/received_rewind.rs +++ b/rs/moq-net/tests/integration/received_rewind.rs @@ -7,6 +7,7 @@ //! cannot tell that from media time, so its copy is untimed and every hop past it sees an //! untimed track that nothing can refuse. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -46,7 +47,7 @@ async fn relay( timescale: Option, ) -> (Option, Vec) { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let track = broadcast .create_track("data", Info::default().with_timescale(timescale)) .unwrap(); @@ -65,11 +66,11 @@ async fn relay( let pair = connect_mock(options).await; let consumer = subscriber.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) + moq_clock::timeout(TIMEOUT, consumer.routed(Path::new("bcast").unwrap())) .await .expect("announce timeout") .expect("routed"); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("bcast", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast(Path::new("bcast").unwrap(), None)) .await .expect("resolve timeout") .expect("broadcast resolves"); @@ -157,7 +158,7 @@ async fn moq_transport_timestamps_stay_on_moq_transport() { /// copy the fetches fill drops them, so neither is refused. async fn fetch_only(version: &str) -> Vec> { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let track = broadcast.create_track("data", Info::default()).unwrap(); broadcast.announce(Default::default()).unwrap(); write_group(&track, 0); @@ -171,11 +172,11 @@ async fn fetch_only(version: &str) -> Vec> { let pair = connect_mock(options).await; let consumer = subscriber.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) + moq_clock::timeout(TIMEOUT, consumer.routed(Path::new("bcast").unwrap())) .await .expect("announce timeout") .expect("routed"); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("bcast", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast(Path::new("bcast").unwrap(), None)) .await .expect("resolve timeout") .expect("broadcast resolves"); diff --git a/rs/moq-net/tests/integration/refresh.rs b/rs/moq-net/tests/integration/refresh.rs index 886e1d53746..418c74ff653 100644 --- a/rs/moq-net/tests/integration/refresh.rs +++ b/rs/moq-net/tests/integration/refresh.rs @@ -1,6 +1,7 @@ #![cfg(feature = "async")] //! Refresh joins traverse real protocol hops, judged independently from each cache. +use moq_net::Path; use crate::support::harness::{MockConnectOptions, connect_mock, peer, spawn, subscribed}; use moq_net::{Hop, Version, origin, track}; use std::time::Duration; @@ -26,7 +27,7 @@ async fn json_snapshot_refresh_crosses_a_two_relay_cluster() { let a = origin(2); let b = origin(3); let reader = origin(4); - let broadcast = source.create_broadcast("room").unwrap(); + let broadcast = source.create_broadcast(Path::new("room").unwrap()).unwrap(); let track = broadcast .create_track( "state", @@ -44,8 +45,8 @@ async fn json_snapshot_refresh_crosses_a_two_relay_cluster() { options.client_subscribe = Some(downstream.clone()); links.push(connect_mock(options).await); } - reader.consume().routed("room").await.unwrap(); - let remote = reader.consume().request_broadcast("room", None).await.unwrap(); + reader.consume().routed(Path::new("room").unwrap()).await.unwrap(); + let remote = reader.consume().request_broadcast(Path::new("room").unwrap(), None).await.unwrap(); let remote = remote.track("state").unwrap(); let mut baseline = remote.subscribe(None).await.unwrap(); assert_eq!(baseline.info().refresh, Some(ratio)); @@ -151,7 +152,7 @@ async fn ratio_joins_cross_two_relays() { let source = origin(1); let a = origin(2); let b = origin(3); - let broadcast = source.create_broadcast("room").unwrap(); + let broadcast = source.create_broadcast(Path::new("room").unwrap()).unwrap(); let producer = broadcast .create_track("data", track::Info::default().with_refresh(1)) .unwrap(); @@ -163,8 +164,8 @@ async fn ratio_joins_cross_two_relays() { options.client_subscribe = Some(downstream.clone()); links.push(connect_mock(options).await); } - b.consume().routed("room").await.unwrap(); - let remote = b.consume().request_broadcast("room", None).await.unwrap(); + b.consume().routed(Path::new("room").unwrap()).await.unwrap(); + let remote = b.consume().request_broadcast(Path::new("room").unwrap(), None).await.unwrap(); let remote = remote.track("data").unwrap(); let mut baseline = remote.subscribe(None).await.unwrap(); assert_eq!(baseline.info().refresh, (name == "moq-lite-07-wip").then_some(1)); diff --git a/rs/moq-net/tests/integration/rejoin.rs b/rs/moq-net/tests/integration/rejoin.rs index e209bc30674..4d87cc5501e 100644 --- a/rs/moq-net/tests/integration/rejoin.rs +++ b/rs/moq-net/tests/integration/rejoin.rs @@ -2,6 +2,7 @@ //! A reader leaving and rejoining a track relayed over the in-memory mock transport. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -45,7 +46,7 @@ async fn rejoin_recovers_the_group_reset_on_leave() { let publisher = produce_origin(1); let relay = produce_origin(2); - let broadcast = publisher.create_broadcast("bench").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bench").unwrap()).unwrap(); let track = broadcast.create_track("video", timed()).unwrap(); broadcast.announce(Default::default()).unwrap(); @@ -55,8 +56,8 @@ async fn rejoin_recovers_the_group_reset_on_leave() { let _pair = connect_mock(options).await; let consumer = relay.consume(); - consumer.routed("bench").await.unwrap(); - let remote = consumer.request_broadcast("bench", None).await.unwrap(); + consumer.routed(Path::new("bench").unwrap()).await.unwrap(); + let remote = consumer.request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); let ts = |ms| Timestamp::from_millis(ms).unwrap(); let prefs = || track::Subscription::default().with_max_delay(Duration::from_secs(10)); @@ -138,7 +139,7 @@ async fn rejoin_skips_a_cache_kept_by_another_handle() { let publisher = produce_origin(1); let relay = produce_origin(2); - let broadcast = publisher.create_broadcast("bench").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bench").unwrap()).unwrap(); let track = broadcast.create_track("video", timed()).unwrap(); broadcast.announce(Default::default()).unwrap(); @@ -148,8 +149,8 @@ async fn rejoin_skips_a_cache_kept_by_another_handle() { let _pair = connect_mock(options).await; let consumer = relay.consume(); - consumer.routed("bench").await.unwrap(); - let remote = consumer.request_broadcast("bench", None).await.unwrap(); + consumer.routed(Path::new("bench").unwrap()).await.unwrap(); + let remote = consumer.request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); let ts = |ms| Timestamp::from_millis(ms).unwrap(); // Held for fetches only: it keeps the relay's copy without subscribing. @@ -202,7 +203,7 @@ async fn rejoin_mid_group_keeps_the_head_for_later_readers() { let relay = produce_origin(2); let client = produce_origin(3); - let broadcast = publisher.create_broadcast("bench").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bench").unwrap()).unwrap(); let track = broadcast.create_track("video", timed()).unwrap(); broadcast.announce(Default::default()).unwrap(); // Left open, as a JSON snapshot group stays open for its deltas. @@ -220,8 +221,8 @@ async fn rejoin_mid_group_keeps_the_head_for_later_readers() { let _downstream = connect_mock(options).await; let consumer = client.consume(); - consumer.routed("bench").await.unwrap(); - let remote = consumer.request_broadcast("bench", None).await.unwrap(); + consumer.routed(Path::new("bench").unwrap()).await.unwrap(); + let remote = consumer.request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); let mut sub = remote.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = sub.recv_group().await.unwrap().unwrap(); assert_eq!(group.read_frame().await.unwrap().unwrap().payload, b"a0".as_ref()); @@ -233,7 +234,7 @@ async fn rejoin_mid_group_keeps_the_head_for_later_readers() { assert_eq!(rejoined.read_frame().await.unwrap().unwrap().payload, b"a0".as_ref()); crate::support::wanted(track.demand()).await.unwrap(); - let later = relay.consume().request_broadcast("bench", None).await.unwrap(); + let later = relay.consume().request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); let mut sub = later.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = sub.recv_group().await.unwrap().unwrap(); assert_eq!(group.sequence, 0, "{version}"); @@ -275,7 +276,7 @@ async fn rejoin_goes_live_without_the_join_head() { let relay = produce_origin(2); let client = produce_origin(3); - let broadcast = publisher.create_broadcast("bench").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bench").unwrap()).unwrap(); let track = broadcast.create_track("video", timed()).unwrap(); broadcast.announce(Default::default()).unwrap(); let mut open = track.append_group().unwrap(); @@ -292,8 +293,8 @@ async fn rejoin_goes_live_without_the_join_head() { let _downstream = connect_mock(options).await; let consumer = client.consume(); - consumer.routed("bench").await.unwrap(); - let remote = consumer.request_broadcast("bench", None).await.unwrap(); + consumer.routed(Path::new("bench").unwrap()).await.unwrap(); + let remote = consumer.request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); let mut sub = remote.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = sub.recv_group().await.unwrap().unwrap(); assert_eq!(group.read_frame().await.unwrap().unwrap().payload, b"a0".as_ref()); @@ -320,7 +321,7 @@ async fn rejoin_goes_live_without_the_join_head() { .unwrap(); next.finish().unwrap(); - let local = relay.consume().request_broadcast("bench", None).await.unwrap(); + let local = relay.consume().request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); let mut sub = local.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = sub.recv_group().await.unwrap().unwrap(); assert_eq!(group.sequence, 1, "{version}"); @@ -345,7 +346,7 @@ async fn rejoin_during_the_cancel_skips_the_cache() { let publisher = produce_origin(1); let relay = produce_origin(2); - let broadcast = publisher.create_broadcast("bench").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bench").unwrap()).unwrap(); let track = broadcast.create_track("video", timed()).unwrap(); broadcast.announce(Default::default()).unwrap(); @@ -356,8 +357,8 @@ async fn rejoin_during_the_cancel_skips_the_cache() { let _pair = connect_mock(options).await; let consumer = relay.consume(); - consumer.routed("bench").await.unwrap(); - let remote = consumer.request_broadcast("bench", None).await.unwrap(); + consumer.routed(Path::new("bench").unwrap()).await.unwrap(); + let remote = consumer.request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); let ts = |ms| Timestamp::from_millis(ms).unwrap(); let mut group = track.append_group().unwrap(); @@ -406,7 +407,7 @@ async fn rejoin_waits_for_the_answers_first_frame() { let publisher = produce_origin(1); let relay = produce_origin(2); - let broadcast = publisher.create_broadcast("bench").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bench").unwrap()).unwrap(); let track = broadcast.create_track("video", timed()).unwrap(); broadcast.announce(Default::default()).unwrap(); @@ -416,8 +417,8 @@ async fn rejoin_waits_for_the_answers_first_frame() { let pair = connect_mock(options).await; let consumer = relay.consume(); - consumer.routed("bench").await.unwrap(); - let remote = consumer.request_broadcast("bench", None).await.unwrap(); + consumer.routed(Path::new("bench").unwrap()).await.unwrap(); + let remote = consumer.request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); let ts = |ms| Timestamp::from_millis(ms).unwrap(); // Held for fetches only: it keeps the relay's copy without subscribing. @@ -479,7 +480,7 @@ async fn leaving_after_the_cache_window_keeps_the_latest_group() { let publisher = produce_origin(1); let relay = produce_origin(2); - let broadcast = publisher.create_broadcast("bench").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bench").unwrap()).unwrap(); let track = broadcast.create_track("catalog", timed()).unwrap(); broadcast.announce(Default::default()).unwrap(); let mut group = track.append_group().unwrap(); @@ -501,8 +502,8 @@ async fn leaving_after_the_cache_window_keeps_the_latest_group() { options.client_subscribe = Some(client.clone()); let pair = connect_mock(options).await; let consumer = client.consume(); - consumer.routed("bench").await.unwrap(); - let remote = consumer.request_broadcast("bench", None).await.unwrap(); + consumer.routed(Path::new("bench").unwrap()).await.unwrap(); + let remote = consumer.request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); (remote, pair) } }; @@ -554,7 +555,7 @@ async fn rejoin_keeps_source_timestamps() { let publisher = produce_origin(1); let client = produce_origin(2); - let broadcast = publisher.create_broadcast("bench").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bench").unwrap()).unwrap(); let track = broadcast.create_track("video", timed()).unwrap(); broadcast.announce(Default::default()).unwrap(); @@ -564,8 +565,8 @@ async fn rejoin_keeps_source_timestamps() { let _pair = connect_mock(options).await; let consumer = client.consume(); - consumer.routed("bench").await.unwrap(); - let remote = consumer.request_broadcast("bench", None).await.unwrap(); + consumer.routed(Path::new("bench").unwrap()).await.unwrap(); + let remote = consumer.request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); // Far from any arrival time, so a frame stamped on arrival cannot pass. let ts = |ms| Timestamp::from_millis(ms).unwrap(); @@ -639,7 +640,7 @@ async fn quiet_catalog_survives_cache_expiry(version: Version, takeover: bool) { moq_clock::timeout(TEST_TIMEOUT + moq_net::cache::DEFAULT_EXPIRY * 5, async { let publisher = produce_origin(1); let relay = produce_origin(2); - let broadcast = publisher.create_broadcast("bench").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bench").unwrap()).unwrap(); let track = broadcast.create_track("catalog", timed()).unwrap(); broadcast .announce(moq_net::origin::Route::default().with_epoch(moq_net::Epoch::mint())) @@ -667,8 +668,8 @@ async fn quiet_catalog_survives_cache_expiry(version: Version, takeover: bool) { options.client_subscribe = Some(client.clone()); let pair = connect_mock(options).await; let consumer = client.consume(); - consumer.routed("bench").await.unwrap(); - let remote = consumer.request_broadcast("bench", None).await.unwrap(); + consumer.routed(Path::new("bench").unwrap()).await.unwrap(); + let remote = consumer.request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); let sub = remote.track("catalog").unwrap().subscribe(None).await.unwrap(); (sub, remote, pair) } @@ -680,7 +681,7 @@ async fn quiet_catalog_survives_cache_expiry(version: Version, takeover: bool) { let (mut holder, remote, pair) = session(3).await; assert_eq!(holder.recv_group().await.unwrap().unwrap().sequence, 0, "{version}"); // The new connection is cheaper, so the relay reports its route taking over. - let mut follow = relay.consume().follow("bench").unwrap(); + let mut follow = relay.consume().follow(Path::new("bench").unwrap()).unwrap(); assert!( matches!(follow.next().await, Some(announce::Event::Start(_))), "{version}" diff --git a/rs/moq-net/tests/integration/relay_upstream_close.rs b/rs/moq-net/tests/integration/relay_upstream_close.rs index ee3096ca8dd..996bcbfb9c9 100644 --- a/rs/moq-net/tests/integration/relay_upstream_close.rs +++ b/rs/moq-net/tests/integration/relay_upstream_close.rs @@ -11,6 +11,7 @@ //! the subscriber are held, with a one-message stream buffer, so the relay still holds //! most of the track when the upstream session ends. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -61,7 +62,7 @@ enum End { async fn round(name: &str, end: End) -> (Vec<(u64, u64)>, Result<(), Error>) { let version: Version = name.parse().unwrap(); let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let track = broadcast.create_track("video", timed()).unwrap(); broadcast.announce(Default::default()).unwrap(); @@ -79,11 +80,11 @@ async fn round(name: &str, end: End) -> (Vec<(u64, u64)>, Result<(), Error>) { let downstream = connect_mock(options).await; let consumer = subscriber.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) + moq_clock::timeout(TIMEOUT, consumer.routed(Path::new("bcast").unwrap())) .await .expect("announce timeout") .expect("routed"); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("bcast", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast(Path::new("bcast").unwrap(), None)) .await .expect("resolve timeout") .expect("broadcast resolves"); diff --git a/rs/moq-net/tests/integration/replacement.rs b/rs/moq-net/tests/integration/replacement.rs index 98c33b1bc87..92b3ff43bbf 100644 --- a/rs/moq-net/tests/integration/replacement.rs +++ b/rs/moq-net/tests/integration/replacement.rs @@ -10,6 +10,7 @@ //! of failing `Unroutable`. With an epoch the replacement continues the instance: no //! `Restart`, and the old handle keeps working. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -83,7 +84,7 @@ async fn replace(version: &str, epoch: Option) { let mut route = origin::Route::default(); route.epoch = epoch.clone(); - let cam = publisher.publish("cam", route).unwrap(); + let cam = publisher.publish(Path::new("cam").unwrap(), route).unwrap(); let video = cam.create_track("video", timed()).unwrap(); let audio = cam.create_track("audio", timed()).unwrap(); let meta = cam.create_track("meta", timed()).unwrap(); @@ -95,7 +96,7 @@ async fn replace(version: &str, epoch: Option) { other => panic!("{version}: expected the broadcast, got {other:?}"), } - let old = viewer.consume().request_broadcast("cam", None).await.unwrap(); + let old = viewer.consume().request_broadcast(Path::new("cam").unwrap(), None).await.unwrap(); let mut sticky = subscribe(&old, "video").await.unwrap(); write(&video, "video:0"); assert_eq!(read(&mut sticky).await, "video:0", "{version}"); @@ -137,7 +138,7 @@ async fn replace(version: &str, epoch: Option) { } // Following the restart resolves the path afresh, and the new handle serves. - let fresh = viewer.consume().request_broadcast("cam", None).await.unwrap(); + let fresh = viewer.consume().request_broadcast(Path::new("cam").unwrap(), None).await.unwrap(); assert!(!fresh.is_clone(&old), "{version}: joined the retired broadcast"); let mut followed = subscribe(&fresh, "meta").await.unwrap(); write(&meta, "meta:0"); @@ -203,7 +204,7 @@ async fn route_death(version: &str, relayed: bool, wait: Duration) { let relay = produce_origin(2); let viewer = produce_origin(3); - let cam = publisher.publish("cam", origin::Route::default()).unwrap(); + let cam = publisher.publish(Path::new("cam").unwrap(), origin::Route::default()).unwrap(); let video = cam.create_track("video", timed()).unwrap(); let upstream = if relayed { &relay } else { &viewer }; @@ -215,7 +216,7 @@ async fn route_death(version: &str, relayed: bool, wait: Duration) { let mut announced = viewer.consume().announced(); next_event(&mut announced).await; - let old = viewer.consume().request_broadcast("cam", None).await.unwrap(); + let old = viewer.consume().request_broadcast(Path::new("cam").unwrap(), None).await.unwrap(); let mut sticky = subscribe(&old, "video").await.unwrap(); write(&video, "video:0"); assert_eq!(read(&mut sticky).await, "video:0", "{version}"); @@ -277,7 +278,7 @@ async fn restart_while_the_old_session_lingers(version: &str, old_hop: u64, new_ let viewer = produce_origin(3); let old = produce_origin(old_hop); - let old_cam = old.publish("cam", origin::Route::default()).unwrap(); + let old_cam = old.publish(Path::new("cam").unwrap(), origin::Route::default()).unwrap(); let _old_video = old_cam.create_track("video", timed()).unwrap(); let old_session = link(version, &old, &viewer).await; let mut announced = viewer.consume().announced(); @@ -288,12 +289,12 @@ async fn restart_while_the_old_session_lingers(version: &str, old_hop: u64, new_ old_session.server_transport.set_latency(Duration::from_secs(3600)); let new = produce_origin(new_hop); - let new_cam = new.publish("cam", origin::Route::default()).unwrap(); + let new_cam = new.publish(Path::new("cam").unwrap(), origin::Route::default()).unwrap(); let new_video = new_cam.create_track("video", timed()).unwrap(); let _new_session = link(version, &new, &viewer).await; moq_clock::sleep(PAST_HOLD).await; - let cam = viewer.consume().request_broadcast("cam", None).await.unwrap(); + let cam = viewer.consume().request_broadcast(Path::new("cam").unwrap(), None).await.unwrap(); let mut video = subscribe(&cam, "video") .await .unwrap_or_else(|err| panic!("{version} ({old_hop} -> {new_hop}): {err}")); diff --git a/rs/moq-net/tests/integration/request_caps.rs b/rs/moq-net/tests/integration/request_caps.rs index ca70c7b092b..93b93ece132 100644 --- a/rs/moq-net/tests/integration/request_caps.rs +++ b/rs/moq-net/tests/integration/request_caps.rs @@ -6,6 +6,7 @@ //! limits size is granted back as requests close, so a client that keeps opening and closing //! requests within them never stalls. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -44,7 +45,7 @@ async fn setup(version: &str, limits: Limits, tracks: usize) -> Setup { let server = produce_origin(1); let client = produce_origin(2); - let broadcast = server.create_broadcast("bcast").unwrap(); + let broadcast = server.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let tracks = (0..tracks) .map(|i| broadcast.create_track(format!("t{i}"), None).unwrap()) .collect(); @@ -82,7 +83,7 @@ async fn closed_requests_are_granted_back() { // A window of 8 requests, far fewer than the rounds below. Doubling the limit leaves // room for an UNSUBSCRIBE still in flight when the next SUBSCRIBE lands. let setup = setup(version, limits(0, 4), ROUNDS).await; - let broadcast = moq_clock::timeout(TIMEOUT, setup.client.consume().routed_broadcast("bcast")) + let broadcast = moq_clock::timeout(TIMEOUT, setup.client.consume().routed_broadcast(Path::new("bcast").unwrap())) .await .expect("announce timeout") .unwrap(); @@ -119,7 +120,7 @@ async fn flow_control_bounds_the_subscriptions_a_peer_holds() { let version: Version = version.parse().unwrap(); let server = produce_origin(1); let client = produce_origin(2); - let broadcast = server.create_broadcast("bcast").unwrap(); + let broadcast = server.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let tracks: Vec<_> = (0..TRACKS) .map(|i| broadcast.create_track(format!("t{i}"), None).unwrap()) .collect(); @@ -132,7 +133,7 @@ async fn flow_control_bounds_the_subscriptions_a_peer_holds() { options.server_limits = Some(limits(0, BOUND / 2)); let pair = connect_mock(options).await; - let remote = moq_clock::timeout(TIMEOUT, client.consume().routed_broadcast("bcast")) + let remote = moq_clock::timeout(TIMEOUT, client.consume().routed_broadcast(Path::new("bcast").unwrap())) .await .expect("announce timeout") .unwrap(); @@ -169,8 +170,8 @@ async fn an_announce_past_the_cap_closes_the_session() { let version: Version = version.parse().unwrap(); let client = produce_origin(1); let server = produce_origin(2); - let a = client.create_broadcast("a").unwrap(); - let b = client.create_broadcast("b").unwrap(); + let a = client.create_broadcast(Path::new("a").unwrap()).unwrap(); + let b = client.create_broadcast(Path::new("b").unwrap()).unwrap(); a.announce(Default::default()).unwrap(); b.announce(Default::default()).unwrap(); diff --git a/rs/moq-net/tests/integration/restart.rs b/rs/moq-net/tests/integration/restart.rs index c5b24d1d1a2..a2f6364bc21 100644 --- a/rs/moq-net/tests/integration/restart.rs +++ b/rs/moq-net/tests/integration/restart.rs @@ -9,6 +9,7 @@ //! retires its copy of the old source, so a new subscriber never sees the old //! instance's cached groups. +use moq_net::Path; use crate::support; use std::{cell::RefCell, rc::Rc, time::Duration}; @@ -105,7 +106,7 @@ async fn read(subscription: &mut track::Subscriber) -> String { } async fn subscribe(origin: &origin::Producer, path: &str) -> (broadcast::Consumer, track::Subscriber) { - let broadcast = origin.consume().request_broadcast(path, None).await.unwrap(); + let broadcast = origin.consume().request_broadcast(Path::new(path).unwrap(), None).await.unwrap(); let subscription = broadcast.track("video").unwrap().subscribe(None).await.unwrap(); (broadcast, subscription) } @@ -121,7 +122,7 @@ async fn relay_chain(version: &str) { let _upstream = link(version, &publisher, &relay).await; let _downstream = link(version, &relay, &viewer).await; - let old = publisher.publish("live", origin::Route::default()).unwrap(); + let old = publisher.publish(Path::new("live").unwrap(), origin::Route::default()).unwrap(); let old_track = old.create_track("video", timed()).unwrap(); let mut announced = viewer.consume().announced(); match next_event(&mut announced).await { @@ -136,7 +137,7 @@ async fn relay_chain(version: &str) { } // The publisher restarts without an epoch, its old session still open. - let new = publisher.publish("live", origin::Route::default()).unwrap(); + let new = publisher.publish(Path::new("live").unwrap(), origin::Route::default()).unwrap(); let new_track = new.create_track("video", timed()).unwrap(); expect_restart(version, &mut announced, "live").await; @@ -182,7 +183,7 @@ struct Worker { impl Worker { fn new(hop: u64) -> Self { let origin = produce_origin(hop); - let claim = Rc::new(origin.dynamic_route("pool", origin::Route::default()).unwrap()); + let claim = Rc::new(origin.dynamic_route(Path::new("pool").unwrap(), origin::Route::default()).unwrap()); let outputs = Rc::new(RefCell::new(Vec::new())); let (handler, served) = (claim.clone(), outputs.clone()); drop(moq_clock::sim::spawn(async move { @@ -265,7 +266,7 @@ impl Claim { fn new(origin: &origin::Producer, epoch: Option) -> Self { let mut route = origin::Route::default(); route.epoch = epoch; - let dynamic = Rc::new(origin.dynamic_route("live", route).unwrap()); + let dynamic = Rc::new(origin.dynamic_route(Path::new("live").unwrap(), route).unwrap()); let outputs = Rc::new(RefCell::new(Vec::new())); let (handler, served) = (dynamic.clone(), outputs.clone()); drop(moq_clock::sim::spawn(async move { @@ -427,7 +428,7 @@ async fn dynamic_epoch_second_route_keeps_winning() { "dropping a shared epoch delivered {event:?}" ); } - let fresh = origin.consume().request_broadcast("live/cam", None).await.unwrap(); + let fresh = origin.consume().request_broadcast(Path::new("live/cam").unwrap(), None).await.unwrap(); assert!(fresh.is_clone(&resolved), "the epoch's broadcast was replaced"); assert_eq!((first.answered(), second.answered()), (1, 1)); // The same epoch serves the same bytes: group 0 was delivered, so it resumes at 1. @@ -453,7 +454,7 @@ async fn retired_fetch(version: &str, explicit: bool) { } else { origin::Route::default() }; - let old = publisher.publish("live", old_route).unwrap(); + let old = publisher.publish(Path::new("live").unwrap(), old_route).unwrap(); let old_track = old.create_track("video", timed()).unwrap(); let mut announced = viewer.consume().announced(); assert!(matches!(next_event(&mut announced).await, announce::Event::Start(_))); @@ -462,7 +463,7 @@ async fn retired_fetch(version: &str, explicit: bool) { write(&old_track, "old:0"); assert_eq!(read(&mut subscription).await, "old:0"); - let replacement = publisher.publish("live", new_route).unwrap(); + let replacement = publisher.publish(Path::new("live").unwrap(), new_route).unwrap(); let replacement_track = replacement.create_track("video", timed()).unwrap(); let _late = replacement .create_track("late", Some(track::Info::default().with_priority(17))) @@ -547,7 +548,7 @@ async fn withdrawal_refuses_new_fetches_but_keeps_open_reads() { let publisher = produce_origin(1); let viewer = produce_origin(2); let _session = link(version, &publisher, &viewer).await; - let source = publisher.publish("live", origin::Route::default()).unwrap(); + let source = publisher.publish(Path::new("live").unwrap(), origin::Route::default()).unwrap(); let produced = source.create_track("video", timed()).unwrap(); let mut announced = viewer.consume().announced(); assert!(matches!(next_event(&mut announced).await, announce::Event::Start(_))); @@ -583,7 +584,7 @@ async fn a_more_specific_source_cannot_fill_a_held_covering_track() { let track = held.track("video").unwrap(); old.write(0, "old:0"); assert_eq!(read(&mut subscription).await, "old:0"); - let replacement = publisher.publish("live/job", origin::Route::default()).unwrap(); + let replacement = publisher.publish(Path::new("live/job").unwrap(), origin::Route::default()).unwrap(); let replacement_track = replacement.create_track("video", timed()).unwrap(); write(&replacement_track, "new:0"); write(&replacement_track, "new:1"); @@ -607,7 +608,7 @@ struct Pool { impl Pool { fn new(origin: &origin::Producer) -> Self { - let claim = Rc::new(origin.dynamic("pool").unwrap()); + let claim = Rc::new(origin.dynamic(Path::new("pool").unwrap()).unwrap()); let outputs = Rc::new(RefCell::new(std::collections::HashMap::new())); let answered = Rc::new(RefCell::new(0)); let (handler, served, count) = (claim.clone(), outputs.clone(), answered.clone()); @@ -643,7 +644,7 @@ impl Pool { /// subscription through it is reset once the exact route arrives: the cold-start reset /// accepted until announce takeover lands. async fn claimed(origin: &origin::Producer, path: &str) -> (broadcast::Consumer, track::Subscriber) { - let cold = origin.consume().request_broadcast(path, None).await.unwrap(); + let cold = origin.consume().request_broadcast(Path::new(path).unwrap(), None).await.unwrap(); drop(cold.track("video").unwrap().subscribe(None).await); settle().await; subscribe(origin, path).await diff --git a/rs/moq-net/tests/integration/route_change.rs b/rs/moq-net/tests/integration/route_change.rs index e0c3605c4d5..dba1857d04f 100644 --- a/rs/moq-net/tests/integration/route_change.rs +++ b/rs/moq-net/tests/integration/route_change.rs @@ -16,6 +16,7 @@ //! Two publishers sharing one explicit epoch, a redundant pair, are one source the //! same way. +use moq_net::Path; use crate::support; use std::collections::BTreeMap; @@ -113,7 +114,7 @@ impl Topology { let relay_b = produce_origin(3); let subscriber = produce_origin(4); - let broadcast = publisher.create_broadcast("live").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("live").unwrap()).unwrap(); let track = broadcast.create_track("video", timed()).unwrap(); broadcast .announce(origin::Route::default().with_epoch(moq_net::Epoch::mint())) @@ -124,8 +125,8 @@ impl Topology { let a_to_r = link(version, &relay_a, &subscriber).await; let consumer = subscriber.consume(); - consumer.routed("live").await.unwrap(); - let remote = consumer.request_broadcast("live", None).await.unwrap(); + consumer.routed(Path::new("live").unwrap()).await.unwrap(); + let remote = consumer.request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); let prefs = track::Subscription::default().with_max_delay(Duration::from_secs(60)); let sub = remote.track("video").unwrap().subscribe(prefs).await.unwrap(); @@ -359,7 +360,7 @@ async fn route_dies_without_an_epoch(version: &str, trigger: Trigger) { let remote = topology .subscriber .consume() - .request_broadcast("live", None) + .request_broadcast(Path::new("live").unwrap(), None) .await .expect("B serves a re-request"); let sub = remote.track("video").unwrap().subscribe(None).await.unwrap(); @@ -388,7 +389,7 @@ async fn better_route_restarts(version: &str) { let mut group = topology.track.append_group().unwrap(); group.write_frame(Timestamp::ZERO, payload(0, 0)).unwrap(); assert_eq!(next(&mut rx).await, (0, payload(0, 0)), "{version}"); - let incumbent = consumer.request_broadcast("live", None).await.unwrap(); + let incumbent = consumer.request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); topology.trigger(Trigger::BetterRoute).await; match announced.next().await.expect("announced") { @@ -404,7 +405,7 @@ async fn better_route_restarts(version: &str) { assert_eq!(next(&mut rx).await, (0, payload(0, 1)), "{version}"); // A re-request resolves the better route on a fresh broadcast. - let replaced = consumer.request_broadcast("live", None).await.unwrap(); + let replaced = consumer.request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); assert!(!replaced.is_clone(&incumbent), "{version}: joined the replaced front"); let sub = replaced.track("video").unwrap().subscribe(None).await.unwrap(); let mut fresh = read(sub); @@ -530,8 +531,8 @@ async fn lagging_route_dies(version: Version) { } async fn subscribe(origin: &origin::Producer) -> track::Subscriber { let consumer = origin.consume(); - consumer.routed("live").await.unwrap(); - let remote = consumer.request_broadcast("live", None).await.unwrap(); + consumer.routed(Path::new("live").unwrap()).await.unwrap(); + let remote = consumer.request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); let preferences = track::Subscription::default().with_max_delay(Duration::from_secs(60)); remote.track("video").unwrap().subscribe(preferences).await.unwrap() } @@ -547,7 +548,7 @@ async fn lagging_route_dies(version: Version) { produce_origin(4), produce_origin(5), ); - let broadcast = p.create_broadcast("live").unwrap(); + let broadcast = p.create_broadcast(Path::new("live").unwrap()).unwrap(); let track = broadcast.create_track("video", timed()).unwrap(); broadcast .announce(origin::Route::default().with_epoch(moq_net::Epoch::mint())) @@ -646,7 +647,7 @@ async fn undetected_outage(budget: Duration) -> BTreeMap> { produce_origin(4), produce_origin(5), ); - let broadcast = p.create_broadcast("live").unwrap(); + let broadcast = p.create_broadcast(Path::new("live").unwrap()).unwrap(); let track = broadcast.create_track("video", timed()).unwrap(); broadcast .announce(origin::Route::default().with_epoch(moq_net::Epoch::mint())) @@ -657,8 +658,8 @@ async fn undetected_outage(budget: Duration) -> BTreeMap> { let m1_e = link(version, &m1, &e).await; let consumer = e.consume(); - consumer.routed("live").await.unwrap(); - let remote = consumer.request_broadcast("live", None).await.unwrap(); + consumer.routed(Path::new("live").unwrap()).await.unwrap(); + let remote = consumer.request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); let prefs = track::Subscription::default().with_max_delay(budget); let mut rx = read(remote.track("video").unwrap().subscribe(prefs).await.unwrap()); let m2_e = priced_link(version, &m2, &e, Some(1_000)).await; @@ -786,7 +787,7 @@ async fn redundant_pair_fails_over(version: &str, loss: Loss) { let mut replicas = Vec::new(); for (name, hop, cost) in [("P1", 1, 1), ("P2", 2, 5)] { let publisher = produce_origin(hop); - let broadcast = publisher.create_broadcast("live").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("live").unwrap()).unwrap(); let track = broadcast.create_track("video", timed()).unwrap(); broadcast .announce(origin::Route::default().with_epoch(epoch.clone()).with_cost(cost)) @@ -804,7 +805,7 @@ async fn redundant_pair_fails_over(version: &str, loss: Loss) { settle().await; let consumer = subscriber.consume(); - let remote = consumer.request_broadcast("live", None).await.unwrap(); + let remote = consumer.request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); let prefs = track::Subscription::default().with_max_delay(Duration::from_secs(60)); let mut rx = read(remote.track("video").unwrap().subscribe(prefs).await.unwrap()); @@ -893,7 +894,7 @@ async fn replaced_behind_a_relay(version: &str, epoch: Option, r let mut replicas = Vec::new(); for (name, hop, cost) in [("P1", 1, None), ("P2", 2, Some(1_000))] { let publisher = produce_origin(hop); - let broadcast = publisher.create_broadcast("live").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("live").unwrap()).unwrap(); let track = broadcast.create_track("video", timed()).unwrap(); let route = match &epoch { Some(epoch) => origin::Route::default().with_epoch(epoch.clone()), @@ -913,8 +914,8 @@ async fn replaced_behind_a_relay(version: &str, epoch: Option, r let _r_to_d = link(version, &relay, &downstream).await; let consumer = downstream.consume(); - consumer.routed("live").await.unwrap(); - let remote = consumer.request_broadcast("live", None).await.unwrap(); + consumer.routed(Path::new("live").unwrap()).await.unwrap(); + let remote = consumer.request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); let prefs = track::Subscription::default().with_max_delay(Duration::from_secs(60)); let mut rx = read(remote.track("video").unwrap().subscribe(prefs).await.unwrap()); @@ -1011,7 +1012,7 @@ async fn producer_replaced(version: &str) { let relay = produce_origin(2); let subscriber = produce_origin(3); - let broadcast = publisher.create_broadcast("live").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("live").unwrap()).unwrap(); let mut dynamic = broadcast.dynamic(); broadcast .announce(origin::Route::default().with_epoch(moq_net::Epoch::mint())) @@ -1029,8 +1030,8 @@ async fn producer_replaced(version: &str) { let _a_to_r = link(version, &relay, &subscriber).await; let consumer = subscriber.consume(); - consumer.routed("live").await.unwrap(); - let remote = consumer.request_broadcast("live", None).await.unwrap(); + consumer.routed(Path::new("live").unwrap()).await.unwrap(); + let remote = consumer.request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); let prefs = track::Subscription::default().with_max_delay(Duration::from_secs(60)); let sub = remote.track("video").unwrap().subscribe(prefs).await.unwrap(); let mut rx = read(sub); diff --git a/rs/moq-net/tests/integration/session_close.rs b/rs/moq-net/tests/integration/session_close.rs index 6b6cbe01cee..6ee3cb0ec6b 100644 --- a/rs/moq-net/tests/integration/session_close.rs +++ b/rs/moq-net/tests/integration/session_close.rs @@ -5,6 +5,7 @@ //! //! Deterministic: simulated time over the mock transport. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -42,7 +43,7 @@ async fn setup(version: &str) -> Setup { async fn setup_with_gate(version: &str, gate: Option>) -> Setup { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let track = broadcast.create_track("video", timed()).unwrap(); broadcast.announce(Default::default()).unwrap(); @@ -54,11 +55,11 @@ async fn setup_with_gate(version: &str, gate: Option>) -> Se let pair = connect_mock(options).await; let consumer = subscriber.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) + moq_clock::timeout(TIMEOUT, consumer.routed(Path::new("bcast").unwrap())) .await .expect("announce timeout") .expect("routed"); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("bcast", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast(Path::new("bcast").unwrap(), None)) .await .expect("resolve timeout") .expect("broadcast resolves"); @@ -108,7 +109,7 @@ async fn setup_with_gate(version: &str, gate: Option>) -> Se async fn track_info_interest_precedes_a_subscription() { for version in ["moq-lite-05", "moq-lite-06", "moq-lite-07-wip"] { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let track = broadcast.create_track("video", timed()).unwrap(); broadcast.announce(Default::default()).unwrap(); let subscriber = produce_origin(2); @@ -117,8 +118,8 @@ async fn track_info_interest_precedes_a_subscription() { options.client_subscribe = Some(subscriber.clone()); let _pair = connect_mock(options).await; let consumer = subscriber.consume(); - consumer.routed("bcast").await.unwrap(); - let remote = consumer.request_broadcast("bcast", None).await.unwrap(); + consumer.routed(Path::new("bcast").unwrap()).await.unwrap(); + let remote = consumer.request_broadcast(Path::new("bcast").unwrap(), None).await.unwrap(); let copy = remote.track("video").unwrap(); copy.query().await.expect("TRACK_INFO"); crate::support::wanted(track.demand()) @@ -231,14 +232,14 @@ async fn abort_cuts_a_drain_short_for(version: &str) { async fn close_withdraws_announcements_before_closing_the_transport() { for version in ["moq-lite-01", "moq-lite-07-wip", "moq-transport-17", "moq-transport-22"] { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); let subscriber = produce_origin(2); let mut options = MockConnectOptions::new(version.parse().unwrap()); options.client_publish = Some(publisher.consume()); options.server_subscribe = Some(subscriber.clone()); let pair = connect_mock(options).await; - subscriber.consume().routed("bcast").await.unwrap(); + subscriber.consume().routed(Path::new("bcast").unwrap()).await.unwrap(); let before = pair.client_transport.finished_streams(); pair.client.close().await.unwrap(); assert!( @@ -252,14 +253,14 @@ async fn close_withdraws_announcements_before_closing_the_transport() { async fn close_times_out_waiting_for_announcement_acknowledgements() { for version in ["moq-lite-01", "moq-lite-07-wip", "moq-transport-17", "moq-transport-22"] { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); let subscriber = produce_origin(2); let mut options = MockConnectOptions::new(version.parse().unwrap()); options.client_publish = Some(publisher.consume()); options.server_subscribe = Some(subscriber.clone()); let pair = connect_mock(options).await; - subscriber.consume().routed("bcast").await.unwrap(); + subscriber.consume().routed(Path::new("bcast").unwrap()).await.unwrap(); pair.client_transport.hold_fin_acknowledgements(); let started = moq_clock::now(); assert!(matches!(pair.client.close().await, Err(Error::Timeout)), "{version}"); @@ -433,7 +434,7 @@ async fn an_unknown_lite_range_abort_is_unspecified_on_every_wire() { async fn ended(version: &str, close: impl FnOnce(&MockPair)) -> (Error, moq_net::stats::Failures) { let registry = moq_net::stats::Registry::new(Default::default()); let mut options = MockConnectOptions::new(version.parse().unwrap()); - options.server_stats = registry.tier(Default::default()).session("room"); + options.server_stats = registry.tier(Default::default()).session(Path::new("room").unwrap()); let pair = connect_mock(options).await; close(&pair); let err = moq_clock::timeout(TIMEOUT, pair.server.closed()) diff --git a/rs/moq-net/tests/integration/session_panic.rs b/rs/moq-net/tests/integration/session_panic.rs index 14c36d3156e..50636699858 100644 --- a/rs/moq-net/tests/integration/session_panic.rs +++ b/rs/moq-net/tests/integration/session_panic.rs @@ -9,6 +9,7 @@ //! //! Deterministic: simulated time over the mock transport. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -39,7 +40,7 @@ struct Publisher { async fn publish(version: Version, relay: &origin::Producer, hop: u64, name: &str) -> Publisher { let origin = produce_origin(hop); - let broadcast = origin.create_broadcast(name).unwrap(); + let broadcast = origin.create_broadcast(Path::new(name).unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); let mut mock = moq_net::transport::memory::Config::default(); @@ -124,10 +125,10 @@ async fn a_panicking_session_leaves_the_others_serving() { .unwrap_or_else(|_| panic!("{version}: the panicked session never closed")); // The other session still serves: a fresh announcement reaches the relay. - let later = healthy.origin.create_broadcast("later").unwrap(); + let later = healthy.origin.create_broadcast(Path::new("later").unwrap()).unwrap(); later.announce(Default::default()).unwrap(); until(&mut announced, "later", true).await; - assert!(relay.consume().routed("healthy").await.is_some()); + assert!(relay.consume().routed(Path::new("healthy").unwrap()).await.is_some()); drop((healthy, broken.client, later)); } } diff --git a/rs/moq-net/tests/integration/settled_end_survives_abort.rs b/rs/moq-net/tests/integration/settled_end_survives_abort.rs index 090336763ea..60743126d4d 100644 --- a/rs/moq-net/tests/integration/settled_end_survives_abort.rs +++ b/rs/moq-net/tests/integration/settled_end_survives_abort.rs @@ -5,6 +5,7 @@ //! the session dying, ends the track cleanly but must not throw those groups away: a //! consumer that has not read them yet still gets them, then the clean end. +use moq_net::Path; use crate::support; use moq_net::{Error, Hop, Timestamp}; @@ -27,7 +28,7 @@ const GROUPS: u64 = 2; /// or in sequence order, and how the read ended. async fn round(abort: bool, ordered: bool) -> (Vec, Option) { let origin = produce_origin(1); - let broadcast = origin.create_broadcast("bcast").unwrap(); + let broadcast = origin.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let mut track = broadcast.create_track("video", timed()).unwrap(); // From the first group with a replay window: a late reader is owed the whole track, // not the live edge. diff --git a/rs/moq-net/tests/integration/source_errors.rs b/rs/moq-net/tests/integration/source_errors.rs index 92b81051d75..751c1704480 100644 --- a/rs/moq-net/tests/integration/source_errors.rs +++ b/rs/moq-net/tests/integration/source_errors.rs @@ -6,6 +6,7 @@ //! Each case runs publisher -> relay -> far over two mock sessions. moq-lite only: //! moq-transport's PUBLISH_DONE registry has no code for either error. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -40,11 +41,11 @@ struct Relayed { async fn resolve(origin: &moq_net::origin::Producer) -> moq_net::broadcast::Consumer { let consumer = origin.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) + moq_clock::timeout(TIMEOUT, consumer.routed(Path::new("bcast").unwrap())) .await .expect("announce timeout") .expect("routed"); - moq_clock::timeout(TIMEOUT, consumer.request_broadcast("bcast", None)) + moq_clock::timeout(TIMEOUT, consumer.request_broadcast(Path::new("bcast").unwrap(), None)) .await .expect("resolve timeout") .expect("broadcast resolves") @@ -55,7 +56,7 @@ async fn relayed(version: &str) -> Relayed { let publisher = produce_origin(1); let relay = produce_origin(2); let far = produce_origin(3); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); let mut options = MockConnectOptions::new(version); diff --git a/rs/moq-net/tests/integration/stream_credit.rs b/rs/moq-net/tests/integration/stream_credit.rs index 2fac6daaf9a..98755333403 100644 --- a/rs/moq-net/tests/integration/stream_credit.rs +++ b/rs/moq-net/tests/integration/stream_credit.rs @@ -2,6 +2,7 @@ //! A peer granting one uni stream at a time still receives every group, on each protocol. +use moq_net::Path; use std::time::Duration; use moq_net::{Hop, Timestamp, Version, origin, track}; @@ -20,7 +21,7 @@ async fn one_stream_credit_serves_every_backlogged_group() { let version: Version = version.parse().unwrap(); let publisher = origin(1); let viewer = origin(2); - let broadcast = publisher.create_broadcast("live").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("live").unwrap()).unwrap(); let info = track::Info::default().with_timescale(moq_net::Timescale::MILLI); let tracks: Vec<_> = (0..2) .map(|i| broadcast.create_track(format!("{i}"), info.clone()).unwrap()) @@ -34,7 +35,7 @@ async fn one_stream_credit_serves_every_backlogged_group() { options.client_subscribe = Some(viewer.clone()); let _pair = connect_mock(options).await; - let remote = viewer.consume().routed_broadcast("live").await.unwrap(); + let remote = viewer.consume().routed_broadcast(Path::new("live").unwrap()).await.unwrap(); let prefs = track::Subscription::default().with_max_delay(Duration::from_secs(30)); let mut subscribers = Vec::new(); for i in 0..tracks.len() { diff --git a/rs/moq-net/tests/integration/subscribe_priority.rs b/rs/moq-net/tests/integration/subscribe_priority.rs index 1ec161c36b1..c0c49bbff59 100644 --- a/rs/moq-net/tests/integration/subscribe_priority.rs +++ b/rs/moq-net/tests/integration/subscribe_priority.rs @@ -3,6 +3,7 @@ //! One upstream subscription carries the aggregate priority of the subscribers it serves, //! and follows it as they come and go, directly and through a relay. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -60,7 +61,7 @@ async fn priority(track: &moq_net::track::Producer, want: i8) -> Result<(), Stri /// publisher sees the priority rise and fall back. async fn follows(version: Version, relay: bool) -> Result<(), String> { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let track = broadcast .create_track("video", Info::default().with_timescale(Timescale::MILLI)) .unwrap(); @@ -77,11 +78,11 @@ async fn follows(version: Version, relay: bool) -> Result<(), String> { } let consumer = subscriber.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) + moq_clock::timeout(TIMEOUT, consumer.routed(Path::new("bcast").unwrap())) .await .expect("announce timeout") .expect("routed"); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("bcast", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast(Path::new("bcast").unwrap(), None)) .await .expect("resolve timeout") .expect("broadcast resolves"); diff --git a/rs/moq-net/tests/integration/subscribe_ranges.rs b/rs/moq-net/tests/integration/subscribe_ranges.rs index 7375b7f8eb7..d99ddcc12ec 100644 --- a/rs/moq-net/tests/integration/subscribe_ranges.rs +++ b/rs/moq-net/tests/integration/subscribe_ranges.rs @@ -3,6 +3,7 @@ //! Subscribers asking for different ranges of one track share a single upstream //! subscription, and each still gets the groups its own range asks for. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -63,7 +64,7 @@ async fn subscribe(remote: &moq_net::broadcast::Consumer, subscription: Subscrip /// one joins. async fn ahead_then_live(version: Option<&str>, relay: bool) -> (Vec, Vec) { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let track = broadcast .create_track("quiet", Info::default().with_timescale(moq_net::Timescale::MILLI)) .unwrap(); @@ -94,11 +95,11 @@ async fn ahead_then_live(version: Option<&str>, relay: bool) -> (Vec, Vec Setup { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("room").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("room").unwrap()).unwrap(); let track = broadcast.create_track("video", timed()).unwrap(); broadcast.announce(Default::default()).unwrap(); @@ -61,11 +62,11 @@ async fn setup(version: Version) -> Setup { let pair = connect_mock(options).await; let consumer = subscriber.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("room")) + moq_clock::timeout(TIMEOUT, consumer.routed(Path::new("room").unwrap())) .await .expect("announce timeout") .expect("routed"); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("room", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast(Path::new("room").unwrap(), None)) .await .expect("resolve timeout") .expect("broadcast resolves"); diff --git a/rs/moq-net/tests/integration/subscriber_max_age.rs b/rs/moq-net/tests/integration/subscriber_max_age.rs index 1b53354830f..bc3422bf0ad 100644 --- a/rs/moq-net/tests/integration/subscriber_max_age.rs +++ b/rs/moq-net/tests/integration/subscriber_max_age.rs @@ -2,6 +2,7 @@ //! IETF relays forward their most tolerant subscriber's negotiated age budget. +use moq_net::Path; use std::time::Duration; use moq_net::{Hop, Timestamp, Version, origin, track}; @@ -39,7 +40,7 @@ async fn relay_forwards_the_most_tolerant_subscriber_max_age() { let viewer = origin(3); let _upstream = peer(version, &publisher, &relay).await; let _downstream = peer(version, &relay, &viewer).await; - let broadcast = publisher.create_broadcast("live").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("live").unwrap()).unwrap(); let mut source = broadcast .create_track( "catalog", @@ -51,8 +52,8 @@ async fn relay_forwards_the_most_tolerant_subscriber_max_age() { group.finish().unwrap(); broadcast.announce(Default::default()).unwrap(); let consumer = viewer.consume(); - consumer.routed("live").await.unwrap(); - let remote = consumer.request_broadcast("live", None).await.unwrap(); + consumer.routed(Path::new("live").unwrap()).await.unwrap(); + let remote = consumer.request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); let cache = remote.track("catalog").unwrap(); let prefs = |millis| track::Subscription::default().with_max_delay(Duration::from_millis(millis)); let mut short = cache.subscribe(prefs(250)).await.unwrap(); diff --git a/rs/moq-net/tests/integration/subscription_end_integrity.rs b/rs/moq-net/tests/integration/subscription_end_integrity.rs index 3814ece5db2..43b781b7966 100644 --- a/rs/moq-net/tests/integration/subscription_end_integrity.rs +++ b/rs/moq-net/tests/integration/subscription_end_integrity.rs @@ -19,6 +19,7 @@ //! Deterministic: paused time, single-threaded runtime, and every "let the session //! send" step is an idle-advance rather than a race. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -56,7 +57,7 @@ fn expected() -> Vec> { /// payloads and the error it ended with, if any. async fn round(drop_session: bool) -> (Vec>, Option) { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let track = broadcast.create_track("video", timed()).unwrap(); broadcast.announce(Default::default()).unwrap(); @@ -67,11 +68,11 @@ async fn round(drop_session: bool) -> (Vec>, Option) { let MockPair { client, server, .. } = connect_mock(options).await; let consumer = subscriber.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) + moq_clock::timeout(TIMEOUT, consumer.routed(Path::new("bcast").unwrap())) .await .expect("announce timeout") .expect("routed"); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("bcast", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast(Path::new("bcast").unwrap(), None)) .await .expect("resolve timeout") .expect("broadcast resolves"); @@ -206,7 +207,7 @@ const DEATH: moq_net::SessionError = moq_net::SessionError::App(7); /// subscriber's `recv_group` ends with once it drains what arrived. async fn killed(version: &str, local: bool) -> (Option, Option) { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let track = broadcast.create_track("video", timed()).unwrap(); broadcast.announce(Default::default()).unwrap(); @@ -217,9 +218,9 @@ async fn killed(version: &str, local: bool) -> (Option, Option BTreeSet BTreeSet { let publisher = produce_origin(1); - let a = publisher.create_broadcast("a").unwrap(); + let a = publisher.create_broadcast(Path::new("a").unwrap()).unwrap(); a.announce(Default::default()).unwrap(); - let b = publisher.create_broadcast("b").unwrap(); + let b = publisher.create_broadcast(Path::new("b").unwrap()).unwrap(); b.announce(Default::default()).unwrap(); let subscriber = produce_origin(2); @@ -97,7 +98,7 @@ async fn a_best_effort_boundary_still_catches_up() { #[moq_clock::test] async fn a_second_session_catches_up() { let publisher = produce_origin(1); - let a = publisher.create_broadcast("a").unwrap(); + let a = publisher.create_broadcast(Path::new("a").unwrap()).unwrap(); a.announce(Default::default()).unwrap(); let subscriber = produce_origin(2); @@ -136,7 +137,7 @@ async fn a_cold_relay_syncs_then_forwards_upstream_routes_as_live() { assert!(announced.try_next().is_none()); let upstream = produce_origin(1); - let broadcast = upstream.create_broadcast("room/cam").unwrap(); + let broadcast = upstream.create_broadcast(Path::new("room/cam").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); let mut options = MockConnectOptions::new(version); options.server_publish = Some(upstream.consume()); diff --git a/rs/moq-net/tests/integration/track_abort_over_session.rs b/rs/moq-net/tests/integration/track_abort_over_session.rs index 388c8a995d4..7e7f6f2891f 100644 --- a/rs/moq-net/tests/integration/track_abort_over_session.rs +++ b/rs/moq-net/tests/integration/track_abort_over_session.rs @@ -3,6 +3,7 @@ //! A track aborted by its publisher while the broadcast stays announced, read by a //! subscriber on the far side of one session. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -26,7 +27,7 @@ async fn after_abort(version: &str, hops: u32) { let publisher = produce_origin(1); let relay = produce_origin(2); let far = produce_origin(3); - let broadcast = publisher.create_broadcast("bench").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bench").unwrap()).unwrap(); let track = broadcast.create_track("video", timed()).unwrap(); broadcast.announce(Default::default()).unwrap(); let mut options = MockConnectOptions::new(version.parse::().unwrap()); @@ -38,8 +39,8 @@ async fn after_abort(version: &str, hops: u32) { options.client_subscribe = Some(far.clone()); let _pair2 = connect_mock(options).await; let consumer = if hops == 2 { far.consume() } else { relay.consume() }; - consumer.routed("bench").await.unwrap(); - let remote = consumer.request_broadcast("bench", None).await.unwrap(); + consumer.routed(Path::new("bench").unwrap()).await.unwrap(); + let remote = consumer.request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); let mut sub = remote.track("video").unwrap().subscribe(None).await.unwrap(); let mut open = track.append_group().unwrap(); open.write_frame(Timestamp::ZERO, b"head".as_ref()).unwrap(); @@ -77,12 +78,12 @@ abort_test!(abort_06_two, "moq-lite-06", 2); /// group. async fn recreate(finish: bool) { let origin = produce_origin(1); - let broadcast = origin.create_broadcast("bench").unwrap(); + let broadcast = origin.create_broadcast(Path::new("bench").unwrap()).unwrap(); broadcast .announce(moq_net::origin::Route::default().with_epoch(moq_net::Epoch::mint())) .unwrap(); let track = broadcast.create_track("video", timed()).unwrap(); - let remote = origin.consume().request_broadcast("bench", None).await.unwrap(); + let remote = origin.consume().request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); let mut sub = remote.track("video").unwrap().subscribe(None).await.unwrap(); let mut open = track.create_group(moq_net::group::Info { sequence: 2 }).unwrap(); open.write_frame(Timestamp::ZERO, b"head".as_ref()).unwrap(); diff --git a/rs/moq-net/tests/integration/track_info_cancel.rs b/rs/moq-net/tests/integration/track_info_cancel.rs index 6fcb5e55306..50ea41e2eef 100644 --- a/rs/moq-net/tests/integration/track_info_cancel.rs +++ b/rs/moq-net/tests/integration/track_info_cancel.rs @@ -8,6 +8,7 @@ //! with its stream credit spent) pins them for good, and a relay retrying across //! routes accumulates them until it runs out of memory. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -30,14 +31,14 @@ async fn abandoned_request_reaches_the_publisher(version: &str, relays: u64) { _pairs.push(peer(version, &pair[0], &pair[1]).await); } - let broadcast = nodes[0].create_broadcast("room").unwrap(); + let broadcast = nodes[0].create_broadcast(Path::new("room").unwrap()).unwrap(); let mut dynamic = broadcast.dynamic(); broadcast.announce(Default::default()).unwrap(); moq_clock::sleep(Duration::from_secs(1)).await; let consumer = nodes[relays as usize] .consume() - .request_broadcast("room", None) + .request_broadcast(Path::new("room").unwrap(), None) .await .unwrap(); let mut waiting = Box::pin(consumer.track("video").unwrap().subscribe(None)); @@ -74,7 +75,7 @@ async fn withdrawn_broadcast_releases_track_info(version: &str, answered: bool, let version: Version = version.parse().unwrap(); let publisher = produce_origin(1); let reader = produce_origin(2); - let broadcast = publisher.create_broadcast("room").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("room").unwrap()).unwrap(); let mut dynamic = broadcast.dynamic(); let mut route = origin::Route::default(); if explicit { @@ -85,7 +86,7 @@ async fn withdrawn_broadcast_releases_track_info(version: &str, answered: bool, options.server_publish = Some(publisher.consume()); options.client_subscribe = Some(reader.clone()); let pair = connect_mock(options).await; - let remote = reader.consume().routed_broadcast("room").await.unwrap(); + let remote = reader.consume().routed_broadcast(Path::new("room").unwrap()).await.unwrap(); let mut query = remote.track("video").unwrap().query(); let request = match futures::future::select(std::pin::pin!(dynamic.requested_track()), &mut query).await { futures::future::Either::Left((request, _)) => request.expect("TRACK reaches the publisher"), diff --git a/rs/moq-net/tests/integration/track_stream_demand.rs b/rs/moq-net/tests/integration/track_stream_demand.rs index 21d941b643d..f1e6d9f898f 100644 --- a/rs/moq-net/tests/integration/track_stream_demand.rs +++ b/rs/moq-net/tests/integration/track_stream_demand.rs @@ -8,6 +8,7 @@ //! publisher watching its demand sees one `used` edge for a viewer, not `used`, `unused`, //! `used` with a round trip per hop in between. +use moq_net::Path; use crate::support; use std::{cell::RefCell, rc::Rc, time::Duration}; @@ -100,7 +101,7 @@ async fn one_used_edge(version: &str, relays: usize, reorder: bool) { } let reader: &MockSession = &links.last().unwrap().client_transport; - let broadcast = nodes[0].create_broadcast("room").unwrap(); + let broadcast = nodes[0].create_broadcast(Path::new("room").unwrap()).unwrap(); let mut dynamic = broadcast.dynamic(); broadcast.announce(Default::default()).unwrap(); let broadcast_edges = record!(broadcast.demand()); @@ -124,11 +125,11 @@ async fn one_used_edge(version: &str, relays: usize, reorder: bool) { }); let consumer = nodes.last().unwrap().consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("room")) + moq_clock::timeout(TIMEOUT, consumer.routed(Path::new("room").unwrap())) .await .unwrap_or_else(|_| panic!("{label}: never announced")) .unwrap(); - let remote = consumer.request_broadcast("room", None).await.unwrap(); + let remote = consumer.request_broadcast(Path::new("room").unwrap(), None).await.unwrap(); let subscribing = remote.track("video").unwrap().subscribe(None); if reorder { @@ -203,7 +204,7 @@ async fn bare_handle_is_lazy(version: &str, relays: usize) { links.push(link(version, &pair[0], &pair[1]).await); } - let broadcast = nodes[0].create_broadcast("room").unwrap(); + let broadcast = nodes[0].create_broadcast(Path::new("room").unwrap()).unwrap(); let mut dynamic = broadcast.dynamic(); broadcast.announce(Default::default()).unwrap(); let broadcast_edges = record!(broadcast.demand()); @@ -220,11 +221,11 @@ async fn bare_handle_is_lazy(version: &str, relays: usize) { }); let consumer = nodes.last().unwrap().consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("room")) + moq_clock::timeout(TIMEOUT, consumer.routed(Path::new("room").unwrap())) .await .unwrap_or_else(|_| panic!("{label}: never announced")) .unwrap(); - let remote = consumer.request_broadcast("room", None).await.unwrap(); + let remote = consumer.request_broadcast(Path::new("room").unwrap(), None).await.unwrap(); let handle = remote.track("video").unwrap(); moq_clock::sleep(Duration::from_secs(1)).await; diff --git a/rs/moq-net/tests/integration/track_tail.rs b/rs/moq-net/tests/integration/track_tail.rs index 10fbf478745..7a07d954b04 100644 --- a/rs/moq-net/tests/integration/track_tail.rs +++ b/rs/moq-net/tests/integration/track_tail.rs @@ -11,6 +11,7 @@ //! //! Time is paused, so the one-second grace for a group that never arrives is free. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -77,7 +78,7 @@ struct Pair { async fn connect(version: &str) -> Pair { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let track = broadcast.create_track("video", timed()).unwrap(); broadcast.announce(Default::default()).unwrap(); @@ -88,11 +89,11 @@ async fn connect(version: &str) -> Pair { let pair = connect_mock(options).await; let consumer = subscriber.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) + moq_clock::timeout(TIMEOUT, consumer.routed(Path::new("bcast").unwrap())) .await .expect("announce timeout") .expect("routed"); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("bcast", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast(Path::new("bcast").unwrap(), None)) .await .expect("resolve timeout") .expect("broadcast resolves"); diff --git a/rs/moq-net/tests/integration/tracks.rs b/rs/moq-net/tests/integration/tracks.rs index 1dcbf5fa696..365fc4e6c12 100644 --- a/rs/moq-net/tests/integration/tracks.rs +++ b/rs/moq-net/tests/integration/tracks.rs @@ -3,6 +3,7 @@ //! A moq-lite-07 TRACKS listing over a session and through a relay: each hop syncs with //! what it holds at once, and the upstream's tracks follow as live adds. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -53,7 +54,7 @@ async fn connect( } async fn resolve(origin: &moq_net::origin::Producer) -> moq_net::broadcast::Consumer { - moq_clock::timeout(TIMEOUT, origin.consume().routed_broadcast("bcast")) + moq_clock::timeout(TIMEOUT, origin.consume().routed_broadcast(Path::new("bcast").unwrap())) .await .expect("announce timeout") .expect("routed") @@ -64,7 +65,7 @@ async fn resolve(origin: &moq_net::origin::Producer) -> moq_net::broadcast::Cons #[moq_clock::test] async fn a_session_lists_its_peers_tracks() { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let a = broadcast.create_track("a", None).unwrap(); broadcast.announce(Default::default()).unwrap(); @@ -94,7 +95,7 @@ async fn a_session_lists_its_peers_tracks() { #[moq_clock::test] async fn a_listing_carries_track_info() { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let info = moq_net::track::Info::default() .with_timescale(moq_net::Timescale::MILLI) .with_max_age(Duration::from_secs(3)) @@ -127,7 +128,7 @@ async fn a_listing_carries_track_info() { #[moq_clock::test] async fn a_listed_track_serves_its_cached_group() { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); let (subscriber, _pair) = connect(&publisher, 2, lite07()).await; @@ -160,7 +161,7 @@ async fn a_listed_track_serves_its_cached_group() { #[moq_clock::test] async fn a_relay_shares_its_upstream_listing() { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let a = broadcast.create_track("a", None).unwrap(); broadcast.announce(Default::default()).unwrap(); @@ -194,7 +195,7 @@ async fn a_relay_shares_its_upstream_listing() { #[moq_clock::test] async fn lite06_cannot_list() { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let _a = broadcast.create_track("a", None).unwrap(); broadcast.announce(Default::default()).unwrap(); @@ -211,7 +212,7 @@ async fn lite06_cannot_list() { #[moq_clock::test] async fn a_listing_past_the_announces_cap_is_reset() { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); const CAP: usize = 10; let _tracks: Vec<_> = (0..CAP) .map(|i| broadcast.create_track(format!("t{i}"), None).unwrap()) diff --git a/rs/moq-net/tests/integration/tracks_ietf.rs b/rs/moq-net/tests/integration/tracks_ietf.rs index f1fe79db18b..cead26e34ac 100644 --- a/rs/moq-net/tests/integration/tracks_ietf.rs +++ b/rs/moq-net/tests/integration/tracks_ietf.rs @@ -6,6 +6,7 @@ //! //! Deterministic: paused time and a single-threaded runtime over the mock transport. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -70,7 +71,7 @@ async fn connect(publisher: &moq_net::origin::Producer, version: &str) -> (moq_n } async fn resolve(origin: &moq_net::origin::Producer, path: &str) -> moq_net::broadcast::Consumer { - moq_clock::timeout(TIMEOUT, origin.consume().routed_broadcast(path)) + moq_clock::timeout(TIMEOUT, origin.consume().routed_broadcast(Path::new(path).unwrap())) .await .expect("announce timeout") .expect("routed") @@ -108,7 +109,7 @@ async fn read(sub: &mut moq_net::track::Subscriber) -> Option<(u64, Vec)> { async fn an_ietf_session_lists_its_peers_tracks() { for version in DRAFTS { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let _a = broadcast.create_track("a", None).unwrap(); broadcast.announce(Default::default()).unwrap(); @@ -130,7 +131,7 @@ async fn an_ietf_session_lists_its_peers_tracks() { async fn only_a_listing_sends_subscribe_tracks() { for version in DRAFTS { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let video = broadcast.create_track("video", None).unwrap(); broadcast.announce(Default::default()).unwrap(); @@ -162,7 +163,7 @@ async fn only_a_listing_sends_subscribe_tracks() { #[moq_clock::test] async fn a_listing_carries_track_info() { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let info = moq_net::track::Info::default() .with_timescale(moq_net::Timescale::MILLI) .with_priority(9); @@ -189,7 +190,7 @@ async fn a_listing_carries_track_info() { #[moq_clock::test] async fn before_draft_18_the_listing_is_refused() { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let a = broadcast.create_track("a", None).unwrap(); broadcast.announce(Default::default()).unwrap(); @@ -223,7 +224,7 @@ async fn before_draft_18_the_listing_is_refused() { async fn a_reader_resumes_the_held_publish() { for version in DRAFTS { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let video = broadcast.create_track("video", None).unwrap(); broadcast.announce(Default::default()).unwrap(); @@ -284,7 +285,7 @@ async fn a_reader_resumes_the_held_publish() { async fn a_join_gets_the_current_groups_head() { for version in DRAFTS { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let video = broadcast.create_track("video", None).unwrap(); broadcast.announce(Default::default()).unwrap(); @@ -334,10 +335,10 @@ async fn a_join_gets_the_current_groups_head() { async fn a_nested_listing_reuses_the_broader_one() { for version in DRAFTS { let publisher = produce_origin(1); - let outer = publisher.create_broadcast("a").unwrap(); + let outer = publisher.create_broadcast(Path::new("a").unwrap()).unwrap(); let _x = outer.create_track("x", None).unwrap(); outer.announce(Default::default()).unwrap(); - let inner = publisher.create_broadcast("a/b").unwrap(); + let inner = publisher.create_broadcast(Path::new("a/b").unwrap()).unwrap(); let _y = inner.create_track("y", None).unwrap(); inner.announce(Default::default()).unwrap(); @@ -368,7 +369,7 @@ async fn a_broader_listing_replaces_the_nested_ones() { let mut held = Vec::new(); let mut broadcasts = Vec::new(); for path in ["a/b", "a/c", "a"] { - let broadcast = publisher.create_broadcast(path).unwrap(); + let broadcast = publisher.create_broadcast(Path::new(path).unwrap()).unwrap(); held.push(broadcast.create_track("t", None).unwrap()); broadcast.announce(Default::default()).unwrap(); broadcasts.push(broadcast); @@ -402,7 +403,7 @@ async fn a_broader_listing_replaces_the_nested_ones() { async fn a_subscribed_track_is_listed_through_its_subscribe() { for version in DRAFTS { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let video = broadcast.create_track("video", None).unwrap(); broadcast.announce(Default::default()).unwrap(); @@ -438,7 +439,7 @@ async fn a_subscribed_track_is_listed_through_its_subscribe() { async fn a_listing_past_the_announces_cap_is_reset() { for version in DRAFTS { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); const CAP: usize = 10; let _tracks: Vec<_> = (0..CAP) .map(|i| broadcast.create_track(format!("t{i}"), None).unwrap()) @@ -486,7 +487,7 @@ async fn a_track_leaves_the_listing_as_it_ended() { for finish in [true, false] { for version in DRAFTS { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let a = broadcast.create_track("a", None).unwrap(); let _b = broadcast.create_track("b", None).unwrap(); broadcast.announce(Default::default()).unwrap(); diff --git a/rs/moq-net/tests/integration/unannounce_release.rs b/rs/moq-net/tests/integration/unannounce_release.rs index 69cb03f9e2e..db6043634dd 100644 --- a/rs/moq-net/tests/integration/unannounce_release.rs +++ b/rs/moq-net/tests/integration/unannounce_release.rs @@ -3,6 +3,7 @@ //! A relay reading a broadcast that its publisher unannounced still cancels its upstream //! subscription once its last reader leaves, so the publisher's demand goes unused. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -24,12 +25,12 @@ async fn release(version: Version) { options.client_subscribe = Some(relay.clone()); let _pair = connect_mock(options).await; - let broadcast = publisher.publish("a/b", moq_net::origin::Route::default()).unwrap(); + let broadcast = publisher.publish(Path::new("a/b").unwrap(), moq_net::origin::Route::default()).unwrap(); let track = broadcast.create_track("t", None).unwrap(); let consumer = relay.consume(); - consumer.routed("a/b").await.expect("routed"); - let remote = consumer.request_broadcast("a/b", None).await.expect("resolves"); + consumer.routed(Path::new("a/b").unwrap()).await.expect("routed"); + let remote = consumer.request_broadcast(Path::new("a/b").unwrap(), None).await.expect("resolves"); let sub = remote.track("t").unwrap().subscribe(None).await.expect("subscribes"); crate::support::wanted(track.demand()).await.unwrap(); diff --git a/rs/moq-net/tests/integration/untimed.rs b/rs/moq-net/tests/integration/untimed.rs index f80e65755cd..37539168abf 100644 --- a/rs/moq-net/tests/integration/untimed.rs +++ b/rs/moq-net/tests/integration/untimed.rs @@ -7,6 +7,7 @@ //! encoder writes its send time instead, and their receivers drop every timestamp, which //! leaves a timed track untimed too. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -85,7 +86,7 @@ impl Chain { async fn subscribe(&self, track: &str) -> track::Subscriber { let consumer = self.nodes.last().unwrap().consume(); - let broadcast = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("room", None)) + let broadcast = moq_clock::timeout(TIMEOUT, consumer.request_broadcast(Path::new("room").unwrap(), None)) .await .expect("resolve timeout") .expect("broadcast resolves"); @@ -111,7 +112,7 @@ async fn next_frame(subscriber: &mut track::Subscriber) -> Option { async fn frame_through(hops: &[&str], info: track::Info) -> (Option, track::Info) { let timestamp = info.timescale.map(|_| millis(7)); let chain = Chain::new(hops).await; - let broadcast = chain.nodes[0].create_broadcast("room").unwrap(); + let broadcast = chain.nodes[0].create_broadcast(Path::new("room").unwrap()).unwrap(); let mut producer = broadcast.create_track("data", info).unwrap(); broadcast.announce(Default::default()).unwrap(); moq_clock::sleep(Duration::from_secs(1)).await; @@ -177,7 +178,7 @@ async fn a_relay_forwards_an_untimed_track_untimed() { async fn an_explicit_start_holds_on_an_untimed_track() { for version in ["moq-lite-03", "moq-lite-06", "moq-lite-07-wip", "moq-transport-20"] { let chain = Chain::new(&[version]).await; - let broadcast = chain.nodes[0].create_broadcast("room").unwrap(); + let broadcast = chain.nodes[0].create_broadcast(Path::new("room").unwrap()).unwrap(); let mut producer = broadcast.create_track("data", untimed()).unwrap(); broadcast.announce(Default::default()).unwrap(); for _ in 0..5 { @@ -185,7 +186,7 @@ async fn an_explicit_start_holds_on_an_untimed_track() { } moq_clock::sleep(Duration::from_secs(1)).await; - let consumer = chain.nodes[1].consume().request_broadcast("room", None).await.unwrap(); + let consumer = chain.nodes[1].consume().request_broadcast(Path::new("room").unwrap(), None).await.unwrap(); let subscription = track::Subscription::default() .with_range(2..) .with_max_delay(Duration::from_secs(30)); @@ -212,7 +213,7 @@ async fn an_explicit_start_holds_on_an_untimed_track() { async fn datagrams_arrive_as_published() { for version in ["moq-lite-05", "moq-lite-07-wip", "moq-transport-16", "moq-transport-20"] { let chain = Chain::new(&[version]).await; - let broadcast = chain.nodes[0].create_broadcast("room").unwrap(); + let broadcast = chain.nodes[0].create_broadcast(Path::new("room").unwrap()).unwrap(); let mut producer = broadcast.create_track("data", untimed()).unwrap(); broadcast.announce(Default::default()).unwrap(); moq_clock::sleep(Duration::from_secs(1)).await; @@ -237,12 +238,12 @@ async fn datagrams_arrive_as_published() { async fn a_fetched_untimed_frame_arrives_untimed() { for version in ["moq-lite-06", "moq-lite-07-wip", "moq-transport-19"] { let chain = Chain::new(&[version]).await; - let broadcast = chain.nodes[0].create_broadcast("room").unwrap(); + let broadcast = chain.nodes[0].create_broadcast(Path::new("room").unwrap()).unwrap(); let mut dynamic = broadcast.dynamic(); broadcast.announce(Default::default()).unwrap(); moq_clock::sleep(Duration::from_secs(1)).await; - let consumer = chain.nodes[1].consume().request_broadcast("room", None).await.unwrap(); + let consumer = chain.nodes[1].consume().request_broadcast(Path::new("room").unwrap(), None).await.unwrap(); let mut waiting = Box::pin(consumer.track("video").unwrap().fetch_group(0, None)); let request = match futures::future::select(std::pin::pin!(dynamic.requested_track()), &mut waiting).await { futures::future::Either::Left((request, _)) => request.expect("the track request reaches the publisher"), diff --git a/rs/moq-net/tests/integration/wide_hop.rs b/rs/moq-net/tests/integration/wide_hop.rs index c1d2872dea2..d8b9b55a147 100644 --- a/rs/moq-net/tests/integration/wide_hop.rs +++ b/rs/moq-net/tests/integration/wide_hop.rs @@ -3,6 +3,7 @@ //! Hop IDs span 64 bits. A link whose varint stops at 2^62 - 1 carries a larger //! one as 0, the reserved unknown hop. +use moq_net::Path; use crate::support; use moq_net::{Hop, Version, cache, origin}; @@ -28,13 +29,13 @@ async fn widest_hop_crosses_each_varint_form() { let upstream: Version = "moq-transport-18".parse().unwrap(); let _upstream = peer(upstream, &source, &relay).await; let _downstream = peer(downstream.parse().unwrap(), &relay, &sink).await; - let _route = source.dynamic_route("room", origin::Route::default()).unwrap(); + let _route = source.dynamic_route(Path::new("room").unwrap(), origin::Route::default()).unwrap(); moq_clock::sim::idle().await; let ids = |route: origin::Route| route.hops.iter().map(|hop| hop.id()).collect::>(); - let at_relay = relay.consume().routed("room").await.expect("relay learned the route"); + let at_relay = relay.consume().routed(Path::new("room").unwrap()).await.expect("relay learned the route"); assert_eq!(ids(at_relay), [u64::MAX], "{downstream}"); - let at_sink = sink.consume().routed("room").await.expect("sink learned the route"); + let at_sink = sink.consume().routed(Path::new("room").unwrap()).await.expect("sink learned the route"); assert_eq!(ids(at_sink), [forwarded, 2], "{downstream}"); } } diff --git a/rs/moq-net/tests/integration/wide_sequence.rs b/rs/moq-net/tests/integration/wide_sequence.rs index 6eecf2c6171..3ed48c6dd31 100644 --- a/rs/moq-net/tests/integration/wide_sequence.rs +++ b/rs/moq-net/tests/integration/wide_sequence.rs @@ -2,6 +2,7 @@ //! Group sequence boundaries, directly and through a forwarding origin. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -19,7 +20,7 @@ async fn largest_quic_sequence_reaches_the_subscriber() { let publisher = produce_origin(1); let relay = produce_origin(2); let client = produce_origin(3); - let broadcast = publisher.create_broadcast("ladder").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("ladder").unwrap()).unwrap(); let info = moq_net::track::Info::default().with_timescale(moq_net::Timescale::MICRO); let track = broadcast.create_track("data", info).unwrap(); broadcast.announce(Default::default()).unwrap(); @@ -35,8 +36,8 @@ async fn largest_quic_sequence_reaches_the_subscriber() { } else { None }; - client.consume().routed("ladder").await.unwrap(); - let remote = client.consume().request_broadcast("ladder", None).await.unwrap(); + client.consume().routed(Path::new("ladder").unwrap()).await.unwrap(); + let remote = client.consume().request_broadcast(Path::new("ladder").unwrap(), None).await.unwrap(); let mut sub = remote.track("data").unwrap().subscribe(None).await.unwrap(); for sequence in [5, 1 << 32, (1 << 53) - 1, (1 << 53) + 1, (1 << 62) - 1] { // Timestamps stop at 2^61 - 1, the most lite-05/06 can zigzag as a first frame. @@ -81,7 +82,7 @@ async fn wide_sequence_fails_only_its_subscription() { let relay = produce_origin(2); let client = produce_origin(3); - let broadcast = publisher.create_broadcast("bench").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bench").unwrap()).unwrap(); let wide = broadcast.create_track("wide", timed()).unwrap(); let narrow = broadcast.create_track("narrow", timed()).unwrap(); broadcast.announce(Default::default()).unwrap(); @@ -100,14 +101,14 @@ async fn wide_sequence_fails_only_its_subscription() { let _downstream = connect_mock(options).await; // lite-07 carries the full 64 bits, so the relay holds the group. - relay.consume().routed("bench").await.unwrap(); - let cached = relay.consume().request_broadcast("bench", None).await.unwrap(); + relay.consume().routed(Path::new("bench").unwrap()).await.unwrap(); + let cached = relay.consume().request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); let mut sub = cached.track("wide").unwrap().subscribe(None).await.unwrap(); assert_eq!(sub.recv_group().await.unwrap().unwrap().sequence, WIDE); let consumer = client.consume(); - consumer.routed("bench").await.unwrap(); - let remote = consumer.request_broadcast("bench", None).await.unwrap(); + consumer.routed(Path::new("bench").unwrap()).await.unwrap(); + let remote = consumer.request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); let result = moq_clock::timeout(Duration::from_secs(5), async { let mut sub = remote.track("wide").unwrap().subscribe(None).await?; @@ -137,7 +138,7 @@ async fn a_later_wide_group_fails_only_that_subscription() { let relay = produce_origin(2); let client = produce_origin(3); - let broadcast = publisher.create_broadcast("bench").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bench").unwrap()).unwrap(); let wide = broadcast.create_track("wide", timed()).unwrap(); let narrow = broadcast.create_track("narrow", timed()).unwrap(); broadcast.announce(Default::default()).unwrap(); @@ -156,8 +157,8 @@ async fn a_later_wide_group_fails_only_that_subscription() { let _downstream = connect_mock(options).await; let consumer = client.consume(); - consumer.routed("bench").await.unwrap(); - let remote = consumer.request_broadcast("bench", None).await.unwrap(); + consumer.routed(Path::new("bench").unwrap()).await.unwrap(); + let remote = consumer.request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); let mut sub = remote.track("wide").unwrap().subscribe(None).await.unwrap(); let mut group = sub.recv_group().await.unwrap().unwrap(); diff --git a/rs/moq-net/tests/integration/zero_copy.rs b/rs/moq-net/tests/integration/zero_copy.rs index 5e4c3212579..ed5bcc18679 100644 --- a/rs/moq-net/tests/integration/zero_copy.rs +++ b/rs/moq-net/tests/integration/zero_copy.rs @@ -4,6 +4,7 @@ //! publisher hands the payload to the transport, and the subscriber reads it back, //! without a copy on either side. +use moq_net::Path; use crate::support; use std::time::Duration; @@ -53,17 +54,17 @@ async fn frames_cross_without_a_copy() { } ); - let broadcast = publisher.create_broadcast("room").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("room").unwrap()).unwrap(); let info = moq_net::track::Info::default().with_timescale(moq_net::Timescale::MILLI); let track = broadcast.create_track("video", info).unwrap(); broadcast.announce(Default::default()).unwrap(); let consumer = subscriber.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("room")) + moq_clock::timeout(TIMEOUT, consumer.routed(Path::new("room").unwrap())) .await .expect("announce timeout") .unwrap(); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("room", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast(Path::new("room").unwrap(), None)) .await .expect("resolve timeout") .expect("broadcast resolves"); From f927421a4b12de31ce2a889e2bed31090a20eb03 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sat, 24 Oct 2026 22:42:13 -0700 Subject: [PATCH 05/67] wip: migrate the rest of the Rust workspace to strict Path Co-Authored-By: Claude Opus 5.5 --- rs/hang/examples/video.rs | 2 +- rs/hang/src/catalog/consumer.rs | 5 +- rs/hang/src/snapshot.rs | 6 +- rs/moq-audio/src/decode/consumer.rs | 7 +- rs/moq-bench/src/connection.rs | 27 +-- rs/moq-boy/src/input.rs | 2 +- rs/moq-boy/src/main.rs | 6 +- rs/moq-c/src/api.rs | 8 +- rs/moq-c/src/origin.rs | 21 ++- rs/moq-c/src/publish.rs | 5 +- rs/moq-c/src/test.rs | 7 +- rs/moq-cli/src/announced.rs | 6 +- rs/moq-cli/src/archive.rs | 22 +-- rs/moq-cli/src/complete.rs | 2 +- rs/moq-cli/src/fetch.rs | 8 +- rs/moq-cli/src/hls.rs | 8 +- rs/moq-cli/src/main.rs | 18 +- rs/moq-cli/src/play/media.rs | 20 +- rs/moq-cli/src/publish.rs | 18 +- rs/moq-cli/src/report.rs | 15 +- rs/moq-cli/src/rtc.rs | 7 +- rs/moq-cli/src/rtmp.rs | 7 +- rs/moq-cli/src/rtsp.rs | 2 +- rs/moq-cli/src/srt.rs | 7 +- rs/moq-cli/src/subscribe.rs | 2 +- rs/moq-cli/src/transcode.rs | 33 ++-- rs/moq-cli/tests/integration/epochs.rs | 15 +- rs/moq-cli/tests/integration/export.rs | 9 +- rs/moq-cli/tests/integration/import.rs | 5 +- rs/moq-cli/tests/integration/listen.rs | 3 +- rs/moq-cli/tests/integration/report.rs | 3 +- rs/moq-cli/tests/integration/rtsp.rs | 3 +- rs/moq-e2ee/src/credential.rs | 2 +- rs/moq-ffi/src/bench.rs | 2 +- rs/moq-ffi/src/origin.rs | 10 +- rs/moq-ffi/src/test.rs | 7 +- rs/moq-gst/src/sink/session.rs | 2 +- rs/moq-gst/src/source/imp.rs | 35 ++-- rs/moq-hls/src/export/mod.rs | 111 +++++------ rs/moq-hls/src/export/rendition.rs | 9 +- rs/moq-hls/src/lib.rs | 2 +- rs/moq-hls/src/server/mod.rs | 19 +- rs/moq-hls/src/server/routes.rs | 51 ++--- rs/moq-mux/benches/catalog.rs | 5 +- rs/moq-mux/benches/containers.rs | 5 +- rs/moq-mux/benches/export.rs | 9 +- rs/moq-mux/benches/ts_programs.rs | 3 +- rs/moq-mux/src/catalog/hang/consumer.rs | 7 +- rs/moq-mux/src/catalog/msf/consumer.rs | 10 +- rs/moq-mux/src/catalog/producer.rs | 21 ++- rs/moq-mux/src/container/consumer.rs | 7 +- rs/moq-mux/src/container/source.rs | 27 +-- rs/moq-mux/src/container/test_util.rs | 5 +- rs/moq-mux/src/container/ts/export_test.rs | 65 +++---- rs/moq-mux/src/container/ts/health.rs | 3 +- rs/moq-mux/src/container/ts/programs.rs | 67 +++---- rs/moq-mux/src/follow.rs | 21 ++- rs/moq-mux/src/linger.rs | 7 +- rs/moq-mux/src/source.rs | 85 ++++----- rs/moq-relay/src/auth.rs | 100 ++++++---- rs/moq-relay/src/auth/admission_tests.rs | 3 +- rs/moq-relay/src/auth/refresh.rs | 15 +- rs/moq-relay/src/cluster.rs | 68 ++++--- rs/moq-relay/src/connection.rs | 2 +- rs/moq-relay/src/internal.rs | 19 +- rs/moq-relay/src/lib.rs | 7 +- rs/moq-relay/src/refusals.rs | 10 +- rs/moq-relay/src/stats.rs | 11 +- rs/moq-relay/src/web.rs | 8 +- rs/moq-relay/tests/drills.rs | 18 +- .../tests/integration/auth_lifetime.rs | 33 ++-- .../tests/integration/cluster_drain.rs | 17 +- .../tests/integration/cluster_idle.rs | 3 +- .../tests/integration/cluster_unknown.rs | 7 +- rs/moq-relay/tests/integration/connection.rs | 11 +- rs/moq-relay/tests/integration/embed.rs | 5 +- .../tests/integration/goaway_cluster.rs | 19 +- .../tests/integration/hidden_cluster.rs | 3 +- .../tests/integration/public_rules.rs | 5 +- rs/moq-relay/tests/integration/refusals.rs | 17 +- .../tests/integration/runtime_uring.rs | 16 +- .../tests/integration/runtime_workers.rs | 5 +- .../tests/integration/shutdown_signal.rs | 5 +- rs/moq-relay/tests/integration/smoke.rs | 27 +-- .../tests/integration/upstream_links.rs | 5 +- rs/moq-room/src/chat.rs | 7 +- rs/moq-room/src/claims.rs | 11 +- rs/moq-room/src/path.rs | 29 ++- rs/moq-room/src/room.rs | 4 +- rs/moq-rtc/src/client/mod.rs | 3 +- rs/moq-rtc/src/egress.rs | 17 +- rs/moq-rtc/src/lib.rs | 29 +-- rs/moq-rtc/src/server/whep.rs | 15 +- rs/moq-rtc/src/server/whip.rs | 16 +- rs/moq-rtmp/src/dial.rs | 39 ++-- rs/moq-rtmp/src/server.rs | 50 ++--- rs/moq-rtsp/src/client.rs | 3 +- rs/moq-srt/src/dial.rs | 5 +- rs/moq-srt/src/server.rs | 9 +- rs/moq-srt/src/ts.rs | 33 ++-- rs/moq-stats/benches/aggregate.rs | 3 +- rs/moq-stats/benches/producer_tick.rs | 12 +- rs/moq-stats/src/aggregate.rs | 39 ++-- rs/moq-stats/src/consume.rs | 17 +- rs/moq-stats/src/lib.rs | 40 ++-- rs/moq-stats/src/produce.rs | 178 +++++++++--------- rs/moq-stats/src/produce_bench.rs | 6 +- rs/moq-tokio/examples/chat.rs | 2 +- rs/moq-tokio/examples/clock.rs | 6 +- rs/moq-tokio/src/client.rs | 5 +- rs/moq-tokio/src/connection.rs | 9 +- rs/moq-tokio/src/origin.rs | 3 +- rs/moq-tokio/src/server.rs | 7 +- rs/moq-tokio/src/webrtc/tests.rs | 4 +- rs/moq-tokio/tests/integration/backend.rs | 21 ++- rs/moq-tokio/tests/integration/broadcast.rs | 117 ++++++------ rs/moq-tokio/tests/integration/max_age.rs | 5 +- .../tests/integration/receive_credit.rs | 9 +- .../integration/subscription_end_integrity.rs | 7 +- rs/moq-tokio/tests/integration/unannounce.rs | 5 +- rs/moq-transcode/examples/transcode.rs | 7 +- rs/moq-transcode/src/lib.rs | 3 +- rs/moq-uring/benches/session_lite.rs | 8 +- .../tests/integration/receive_credit.rs | 11 +- rs/moq-uring/tests/integration/session.rs | 13 +- rs/moq-uring/tests/integration/web.rs | 7 +- rs/moq-video/src/decode/decoder.rs | 6 +- test/interop/clients/rust/audio.rs | 2 +- test/interop/clients/rust/control.rs | 4 +- test/interop/clients/rust/finish.rs | 8 +- test/interop/clients/rust/goaway-client.rs | 6 +- test/interop/clients/rust/goaway.rs | 2 +- test/interop/clients/rust/tail.rs | 4 +- 133 files changed, 1160 insertions(+), 1031 deletions(-) diff --git a/rs/hang/examples/video.rs b/rs/hang/examples/video.rs index 40fc8f57511..de9094ee922 100644 --- a/rs/hang/examples/video.rs +++ b/rs/hang/examples/video.rs @@ -82,7 +82,7 @@ fn create_track(broadcast: &mut moq_net::broadcast::Producer) -> anyhow::Result< async fn run_broadcast(origin: moq_net::origin::Producer) -> anyhow::Result<()> { // Create a broadcast on the origin and announce its path. // NOTE: The path is empty because we're using the URL to scope the broadcast. - let mut broadcast = origin.create_broadcast("").context("failed to create broadcast")?; + let mut broadcast = origin.create_broadcast(moq_net::Path::empty()).context("failed to create broadcast")?; broadcast .announce(Default::default()) .context("failed to announce broadcast")?; diff --git a/rs/hang/src/catalog/consumer.rs b/rs/hang/src/catalog/consumer.rs index 114c75b1080..b643e623b6b 100644 --- a/rs/hang/src/catalog/consumer.rs +++ b/rs/hang/src/catalog/consumer.rs @@ -106,11 +106,12 @@ fn check_resolvable(base: &PathOwned, catalog: &Catalog) -> Result<()> { #[cfg(test)] mod test { use super::*; + use moq_net::Path; use std::str::FromStr; #[test] fn echo_prefix_cannot_escape_the_catalog_root() { - let base = moq_net::PathOwned::from("room/live"); + let base = Path::new("room/live").unwrap(); let mut catalog = Catalog::<()>::from_str(include_str!("../../fixtures/catalog-stats-echo.json")).unwrap(); assert!(check_resolvable(&base, &catalog).is_ok()); let echo = catalog.echo.as_mut().unwrap(); @@ -127,7 +128,7 @@ mod test { async fn subscribe_validates_echo_prefix_before_yielding() { for (reference, accepted) in [("viewers", true), ("../../viewers", false)] { let mut info = moq_net::broadcast::Info::new(); - info.path = "room/live".into(); + info.path = moq_net::Path::new("room/live").unwrap().to_owned(); let broadcast = info.produce(); let track = broadcast .create_track(Catalog::DEFAULT_NAME, Catalog::default_track_info()) diff --git a/rs/hang/src/snapshot.rs b/rs/hang/src/snapshot.rs index a2806d88c18..cccfe61e547 100644 --- a/rs/hang/src/snapshot.rs +++ b/rs/hang/src/snapshot.rs @@ -200,9 +200,9 @@ mod tests { #[test] fn echo_suffix_filters_only_the_broadcast_name() { - assert!(echo::is_echo(&moq_net::Path::new("room/alice.echo"))); - assert!(!echo::is_echo(&moq_net::Path::new("room.echo/alice"))); - assert!(!echo::is_echo(&moq_net::Path::new("room/alice.echoes"))); + assert!(echo::is_echo(&moq_net::Path::new("room/alice.echo").unwrap())); + assert!(!echo::is_echo(&moq_net::Path::new("room.echo/alice").unwrap())); + assert!(!echo::is_echo(&moq_net::Path::new("room/alice.echoes").unwrap())); } #[test] diff --git a/rs/moq-audio/src/decode/consumer.rs b/rs/moq-audio/src/decode/consumer.rs index 15472fad230..d4d0c76caae 100644 --- a/rs/moq-audio/src/decode/consumer.rs +++ b/rs/moq-audio/src/decode/consumer.rs @@ -687,6 +687,7 @@ fn rewind(timestamp: moq_net::Timestamp, frames: usize, sample_rate: u32) -> Res #[cfg(test)] mod tests { + use moq_net::Path; async fn next_frame(consumer: &mut Consumer) -> Result, Error> { loop { match consumer.read().await? { @@ -803,7 +804,7 @@ mod tests { #[tokio::test(start_paused = true)] async fn latest_skips_a_warm_copys_backlog() { let publisher = origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("bcast").unwrap()).unwrap(); let track = broadcast .create_track("audio", hang::container::track_info(hang::catalog::PRIORITY.audio)) .unwrap(); @@ -831,8 +832,8 @@ mod tests { let relay = origin(2); let _link = link(&publisher, &relay).await; let consumer = relay.consume(); - consumer.routed("bcast").await.unwrap(); - let remote = consumer.request_broadcast("bcast", None).await.unwrap(); + consumer.routed(Path::new("bcast").unwrap()).await.unwrap(); + let remote = consumer.request_broadcast(Path::new("bcast").unwrap(), None).await.unwrap(); // A first reader warms the relay's copy with every group. { diff --git a/rs/moq-bench/src/connection.rs b/rs/moq-bench/src/connection.rs index 0f5bcde0373..f673ad2029a 100644 --- a/rs/moq-bench/src/connection.rs +++ b/rs/moq-bench/src/connection.rs @@ -126,7 +126,7 @@ pub async fn run(ctx: Connection) { }; for (relative, path) in paths { - let broadcast = match publish.create_broadcast(&path) { + let broadcast = match moq_net::Path::new(&path).and_then(|path| publish.create_broadcast(path)) { Ok(broadcast) => broadcast, Err(err) => { tracing::error!(connection, %err, "failed to create broadcast"); @@ -304,7 +304,10 @@ async fn produce( fn discover(consume: &moq_net::origin::Producer, name: &str) -> moq_net::origin::Consumer { consume .consume() - .scope(name, &moq_net::Patterns::from(moq_net::Pattern::all())) + .scope( + moq_net::Path::new(name).expect("a valid bench namespace"), + &moq_net::Patterns::from(moq_net::Pattern::all()), + ) .expect("origin must permit the bench namespace") } @@ -315,11 +318,12 @@ async fn subscribe_named( max_delay: Duration, stats: Arc, ) -> anyhow::Result<()> { + let path = moq_net::PathOwned::try_from(path)?; consume - .routed(path.as_str()) + .routed(&path) .await .ok_or_else(|| anyhow::anyhow!("target broadcast was never announced: {path}"))?; - let broadcast = consume.request_broadcast(path.as_str(), None).await?; + let broadcast = consume.request_broadcast(&path, None).await?; drain(broadcast, max_delay, &stats).await } @@ -380,7 +384,7 @@ async fn subscribe( let mut selected = pool.len() as u64; for path in pool { - let Ok(broadcast) = consume.request_broadcast(path.as_str(), None).await else { + let Ok(broadcast) = consume.request_broadcast(moq_net::Path::new(&path)?, None).await else { continue; }; spawn_drain(&mut tasks, path, broadcast, max_delay, stats.clone()); @@ -402,7 +406,7 @@ async fn subscribe( if own.contains(&path) || !seen.insert(path.clone()) { continue; } - let Ok(broadcast) = consume.request_broadcast(path.as_str(), None).await else { + let Ok(broadcast) = consume.request_broadcast(moq_net::Path::new(&path)?, None).await else { continue; }; selected += 1; @@ -664,6 +668,7 @@ impl Drop for Gauge<'_> { )] mod tests { use super::*; + use moq_net::Path; #[test] fn a_broadcast_is_established_once_and_its_gauge_drops_with_the_producer() { @@ -975,20 +980,20 @@ mod tests { let origin = moq_tokio::origin::spawn(); // The relay-internal broadcast: announced, but with no bench data track. - let _internal = origin.create_broadcast(".stats/node/host").unwrap(); + let _internal = origin.create_broadcast(Path::new(".stats/node/host").unwrap()).unwrap(); _internal.announce(Default::default()).unwrap(); // Our own broadcast: in the namespace, but excluded via the `own` set // (paths relative to the namespace, matching the scoped announce consumer). - let _previous = origin.create_broadcast("bench/previous/0/0").unwrap(); + let _previous = origin.create_broadcast(Path::new("bench/previous/0/0").unwrap()).unwrap(); _previous.announce(Default::default()).unwrap(); - let _own = origin.create_broadcast("bench/current/9/9").unwrap(); + let _own = origin.create_broadcast(Path::new("bench/current/9/9").unwrap()).unwrap(); _own.announce(Default::default()).unwrap(); let own = HashSet::from(["9/9".to_string()]); // One legitimate peer under the bench namespace with a single finished group. - let peer = origin.create_broadcast("bench/current/0/0").unwrap(); + let peer = origin.create_broadcast(Path::new("bench/current/0/0").unwrap()).unwrap(); peer.announce(Default::default()).unwrap(); let track = peer.create_track(TRACK, timed()).unwrap(); let mut group = track.append_group().unwrap(); @@ -1020,7 +1025,7 @@ mod tests { stats.clone(), )); - let broadcast = origin.create_broadcast("bench/run/chat").unwrap(); + let broadcast = origin.create_broadcast(Path::new("bench/run/chat").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); let track = broadcast.create_track(TRACK, timed()).unwrap(); tokio::task::yield_now().await; diff --git a/rs/moq-boy/src/input.rs b/rs/moq-boy/src/input.rs index 8bcea7282e9..fdbd795e4e8 100644 --- a/rs/moq-boy/src/input.rs +++ b/rs/moq-boy/src/input.rs @@ -185,7 +185,7 @@ mod tests { /// Publish a viewer with a live command track. fn viewer(origin: &moq_net::origin::Producer) -> (moq_net::broadcast::Producer, moq_net::track::Producer) { - let broadcast = origin.create_broadcast("alice").unwrap(); + let broadcast = origin.create_broadcast(moq_net::Path::new("alice").unwrap()).unwrap(); let track = broadcast .create_track( "command", diff --git a/rs/moq-boy/src/main.rs b/rs/moq-boy/src/main.rs index 08184dfd4a6..4644905a07f 100644 --- a/rs/moq-boy/src/main.rs +++ b/rs/moq-boy/src/main.rs @@ -243,7 +243,8 @@ async fn run(config: &Config) -> Result<()> { let viewer_prefix = config.prefix_viewer.as_deref().unwrap_or(&default_viewer_prefix); // Create the broadcast on the publish origin and announce its path. - let broadcast_path = format!("{game_prefix}/{name}"); + let broadcast_path = + moq_net::PathOwned::try_from(format!("{game_prefix}/{name}")).context("invalid game broadcast path")?; let mut broadcast = publish_origin .create_broadcast(&broadcast_path) .context("failed to create broadcast")?; @@ -255,7 +256,8 @@ async fn run(config: &Config) -> Result<()> { // Consume origin: viewer broadcasts under the viewer prefix. // JS publishes viewer feedback at "{viewer_prefix}/{name}/{viewerId}" - let viewer_path = format!("{viewer_prefix}/{name}"); + let viewer_path = + moq_net::PathOwned::try_from(format!("{viewer_prefix}/{name}")).context("invalid viewer prefix")?; let consume_origin = moq_tokio::origin::spawn(); let viewer_consumer = consume_origin .scope(&viewer_path, &moq_net::Patterns::from(moq_net::Pattern::all())) diff --git a/rs/moq-c/src/api.rs b/rs/moq-c/src/api.rs index cd9fdd6f263..51b68a8d904 100644 --- a/rs/moq-c/src/api.rs +++ b/rs/moq-c/src/api.rs @@ -1759,7 +1759,7 @@ pub extern "C" fn moq_origin_create() -> i32 { pub unsafe extern "C" fn moq_origin_create_broadcast(origin: u32, path: *const c_char, path_len: usize) -> i32 { ffi::enter(move || { let origin = ffi::parse_id(origin)?; - let path = unsafe { ffi::parse_str(path, path_len)? }; + let path = moq_net::Path::new(unsafe { ffi::parse_str(path, path_len)? })?; let mut state = State::lock(); let broadcast = state.origin.create_broadcast(origin, path)?; @@ -1794,7 +1794,7 @@ pub unsafe extern "C" fn moq_origin_dynamic( ) -> i32 { ffi::enter(move || { let origin = ffi::parse_id(origin)?; - let prefix = unsafe { ffi::parse_str(prefix, prefix_len)? }; + let prefix = moq_net::Path::new(unsafe { ffi::parse_str(prefix, prefix_len)? })?; let on_request = unsafe { ffi::OnStatus::new(user_data, on_request)? }; State::lock().origin.dynamic(origin, prefix, on_request) }) @@ -2050,7 +2050,7 @@ pub unsafe extern "C" fn moq_origin_announced_broadcast( ) -> i32 { ffi::enter(move || { let origin = ffi::parse_id(origin)?; - let path = unsafe { ffi::parse_str(path, path_len)? }.to_string(); + let path = moq_net::Path::new(unsafe { ffi::parse_str(path, path_len)? })?.to_owned(); let on_broadcast = unsafe { ffi::OnStatus::new(user_data, on_broadcast)? }; State::lock().origin.consume_announced(origin, path, on_broadcast) }) @@ -2101,7 +2101,7 @@ pub unsafe extern "C" fn moq_origin_request( ) -> i32 { ffi::enter(move || { let origin = ffi::parse_id(origin)?; - let path = unsafe { ffi::parse_str(path, path_len)? }.to_string(); + let path = moq_net::Path::new(unsafe { ffi::parse_str(path, path_len)? })?.to_owned(); let on_broadcast = unsafe { ffi::OnStatus::new(user_data, on_broadcast)? }; State::lock().origin.request(origin, path, on_broadcast) }) diff --git a/rs/moq-c/src/origin.rs b/rs/moq-c/src/origin.rs index 7e7eaf7296f..83bfcf42d1e 100644 --- a/rs/moq-c/src/origin.rs +++ b/rs/moq-c/src/origin.rs @@ -151,7 +151,7 @@ impl Origin { let consumer = origin .producer .consume() - .scope("", &moq_net::Patterns::from(scope))? + .scope(moq_net::Path::empty(), &moq_net::Patterns::from(scope))? .with_hidden(hidden) .announced(); self.announced_task.spawn( @@ -217,7 +217,7 @@ impl Origin { /// The callback fires a broadcast handle (> 0) for each instance serving the path, until a /// single terminal code (`0` on close, negative on error). Returns a task handle for /// cancellation via [`Self::consume_announced_close`]. - pub fn consume_announced(&mut self, origin: Id, path: String, on_broadcast: OnStatus) -> Result { + pub fn consume_announced(&mut self, origin: Id, path: moq_net::PathOwned, on_broadcast: OnStatus) -> Result { let origin = self.active.get(origin).ok_or(Error::OriginNotFound)?; origin.driver.check()?; let driver = origin.driver.clone(); @@ -236,11 +236,11 @@ impl Origin { async fn run_consume_announced( callback: OnStatus, consumer: Consumer, - path: String, + path: moq_net::PathOwned, mut close: oneshot::Receiver<()>, ) -> Result<(), Error> { // An unreachable path and a closed origin both mean no broadcast can ever arrive here. - let mut announced = match consumer.announced_broadcast(path.as_str(), None) { + let mut announced = match consumer.announced_broadcast(&path, None) { Ok(announced) => announced, Err(moq_net::Error::Unauthorized) => return Err(Error::BroadcastNotFound), Err(err) => return Err(err.into()), @@ -276,7 +276,7 @@ impl Origin { /// announced now: the callback fires the broadcast /// handle (> 0) once served, then a terminal `0`; or a single terminal code (`0` on close, /// negative on error) if it can't be served. Returns a task handle for cancellation. - pub fn request(&mut self, origin: Id, path: String, on_broadcast: OnStatus) -> Result { + pub fn request(&mut self, origin: Id, path: moq_net::PathOwned, on_broadcast: OnStatus) -> Result { let origin = self.active.get(origin).ok_or(Error::OriginNotFound)?; origin.driver.check()?; let driver = origin.driver.clone(); @@ -295,11 +295,11 @@ impl Origin { async fn run_request( callback: OnStatus, consumer: Consumer, - path: String, + path: moq_net::PathOwned, mut close: oneshot::Receiver<()>, ) -> Result<(), Error> { // Resolves to an error when no announced route can serve the path. - let pending = consumer.request_broadcast(path.as_str(), None); + let pending = consumer.request_broadcast(&path, None); // `biased` so a pending close always wins over a ready broadcast. let broadcast = tokio::select! { @@ -334,7 +334,7 @@ impl Origin { /// Advertise `prefix` and serve requests beneath it, delivering each as a /// broadcast-request handle via `on_request`. - pub fn dynamic(&mut self, origin: Id, prefix: &str, on_request: OnStatus) -> Result { + pub fn dynamic(&mut self, origin: Id, prefix: moq_net::Path<'_>, on_request: OnStatus) -> Result { let origin = self.active.get(origin).ok_or(Error::OriginNotFound)?; origin.driver.check()?; let driver = origin.driver.clone(); @@ -442,6 +442,7 @@ impl Origin { #[cfg(test)] mod supervision_tests { use super::*; + use moq_net::Path; #[tokio::test] async fn a_broadcast_keeps_the_origin_failure_after_its_origin_handle_is_released() { @@ -456,7 +457,7 @@ mod supervision_tests { .unwrap(); let mut publish = crate::publish::Publish::default(); let broadcast = publish - .create(origins.create_broadcast(origin, "retained").unwrap()) + .create(origins.create_broadcast(origin, Path::new("retained").unwrap()).unwrap()) .unwrap(); origins.close(origin).unwrap(); *trigger @@ -470,7 +471,7 @@ mod supervision_tests { )); let healthy = origins.create().unwrap(); let broadcast = publish - .create(origins.create_broadcast(healthy, "healthy").unwrap()) + .create(origins.create_broadcast(healthy, Path::new("healthy").unwrap()).unwrap()) .unwrap(); publish.announce(broadcast, Default::default()).unwrap(); } diff --git a/rs/moq-c/src/publish.rs b/rs/moq-c/src/publish.rs index aac4d2e2c0e..651de9cd3f8 100644 --- a/rs/moq-c/src/publish.rs +++ b/rs/moq-c/src/publish.rs @@ -1143,13 +1143,14 @@ impl Publish { #[cfg(test)] mod supervision_tests { use super::*; + use moq_net::Path; #[tokio::test] async fn a_container_importer_keeps_the_origin_failure_after_other_owners_are_released() { let (origin, completion, trigger) = crate::ffi::panicking_origin(); let mut publish = Publish::default(); let broadcast = publish - .create((origin.create_broadcast("retained").unwrap(), completion.clone())) + .create((origin.create_broadcast(Path::new("retained").unwrap()).unwrap(), completion.clone())) .unwrap(); let container = publish .container( @@ -1173,7 +1174,7 @@ mod supervision_tests { let (origin, completion, trigger) = crate::ffi::panicking_origin(); let mut publish = Publish::default(); let broadcast = publish - .create((origin.create_broadcast("retained").unwrap(), completion.clone())) + .create((origin.create_broadcast(Path::new("retained").unwrap()).unwrap(), completion.clone())) .unwrap(); let producer = &publish.broadcast(broadcast).unwrap().producer; // A dynamic handle outlives the consumed broadcast, so only an explicit close ends it. diff --git a/rs/moq-c/src/test.rs b/rs/moq-c/src/test.rs index 0b74ccfa43e..e2db238f44f 100644 --- a/rs/moq-c/src/test.rs +++ b/rs/moq-c/src/test.rs @@ -1,4 +1,5 @@ use super::*; +use moq_net::Path; use crate::ffi::ReturnCode; use std::ffi::{c_char, c_void}; @@ -3707,7 +3708,7 @@ fn consume_announced_close_cancels() { fn publish(origin: u32, path: &str, route: moq_net::origin::Route) -> moq_net::broadcast::Producer { let _runtime = crate::ffi::RUNTIME.enter(); let origin = crate::Id::try_from(origin).unwrap(); - State::lock().origin.get(origin).unwrap().publish(path, route).unwrap() + State::lock().origin.get(origin).unwrap().publish(Path::new(path).unwrap(), route).unwrap() } /// Publish `path` on `origin` under a fresh epoch, as each run of a publisher does. @@ -3763,7 +3764,7 @@ fn consume_announced_delivers_a_takeover_once(dynamic_at: &str) { .origin .get(origin) .unwrap() - .dynamic_route(dynamic_at, route) + .dynamic_route(Path::new(dynamic_at).unwrap(), route) .unwrap() }; let cb = Callback::new(); @@ -3814,7 +3815,7 @@ fn serve_dynamic(origin: u32, prefix: &str, route: moq_net::origin::Route) -> mo .origin .get(origin) .unwrap() - .dynamic_route(prefix, route) + .dynamic_route(Path::new(prefix).unwrap(), route) .unwrap() } diff --git a/rs/moq-cli/src/announced.rs b/rs/moq-cli/src/announced.rs index 22f3ae353d5..f91a7b4481e 100644 --- a/rs/moq-cli/src/announced.rs +++ b/rs/moq-cli/src/announced.rs @@ -67,7 +67,7 @@ async fn follow( // Scoped to the prefix, so the session only asks the relay for what is followed. let pattern = moq_net::Pattern::subtree(prefix).with_context(|| format!("invalid prefix `{prefix}`"))?; let origin = moq_tokio::origin::spawn() - .scope("", &moq_net::Patterns::from(pattern)) + .scope(moq_net::Path::empty(), &moq_net::Patterns::from(pattern)) .with_context(|| format!("failed to scope to `{prefix}`"))?; // Subscribe-only: this session reads and never publishes. @@ -210,7 +210,7 @@ mod tests { let broadcasts = ["demo/a", "demo/b", "other/c"] .into_iter() .map(|path| { - let broadcast = origin.create_broadcast(path).expect("broadcast"); + let broadcast = origin.create_broadcast(moq_net::Path::new(path).unwrap()).expect("broadcast"); broadcast.announce(Default::default()).expect("announce"); (path, broadcast) }) @@ -229,7 +229,7 @@ mod tests { // Every broadcast is on the relay before anything follows it. for (path, _) in &broadcasts { - tokio::time::timeout(TIMEOUT, relay.routed_broadcast(*path)) + tokio::time::timeout(TIMEOUT, relay.routed_broadcast(moq_net::Path::new(path).unwrap())) .await .expect("relay routes the broadcast") .expect("broadcast"); diff --git a/rs/moq-cli/src/archive.rs b/rs/moq-cli/src/archive.rs index 8254b97fe5f..fbb309d226a 100644 --- a/rs/moq-cli/src/archive.rs +++ b/rs/moq-cli/src/archive.rs @@ -69,7 +69,7 @@ pub async fn export(origin: moq_net::origin::Consumer, prefix: String, args: Exp // Announcements leave hidden routes out unless asked, and a prefix naming one asks. let hidden = prefix.split('/').any(|segment| segment.starts_with('.')); - let prefix = moq_net::Path::new(&prefix).to_owned(); + let prefix = moq_net::Path::new(&prefix)?.to_owned(); let mut announced = origin.clone().with_hidden(hidden).announced(); let mut recordings = tokio::task::JoinSet::new(); let mut running = Running::default(); @@ -250,7 +250,7 @@ pub async fn import( let store = open(&args.store)?; // A second handle lists the recording's timelines while the reader owns the first. let listing = open(&args.store)?; - let broadcast = origin.create_broadcast(&name).context("failed to create broadcast")?; + let broadcast = origin.create_broadcast(moq_net::Path::new(&name)?).context("failed to create broadcast")?; let mut timelines = store .timelines() .await @@ -355,7 +355,7 @@ mod tests { let mut epochs = Vec::new(); let mut broadcasts = Vec::new(); for path in ["live/a", "live/b", "other"] { - let broadcast = origin.create_broadcast(path).unwrap(); + let broadcast = origin.create_broadcast(moq_net::Path::new(path).unwrap()).unwrap(); let track = broadcast.create_track("video", info.clone()).unwrap(); let mut group = track.create_group(group::Info { sequence: 0 }).unwrap(); group.write_frame(Timestamp::from_millis(0).unwrap(), path).unwrap(); @@ -410,12 +410,12 @@ mod tests { #[test] fn a_re_announced_instance_is_recorded() { let mut running = Running::default(); - let epochless = (moq_net::Path::new("live/a").to_owned(), None); + let epochless = (moq_net::Path::new("live/a").unwrap().to_owned(), None); assert!(running.start(&epochless)); assert!(running.start(&epochless)); assert!(!running.done(&epochless)); - let pinned = (moq_net::Path::new("live/b").to_owned(), Some(moq_net::Epoch::mint())); + let pinned = (moq_net::Path::new("live/b").unwrap().to_owned(), Some(moq_net::Epoch::mint())); assert!(running.start(&pinned)); assert!(!running.start(&pinned)); assert!(running.done(&pinned)); @@ -428,7 +428,7 @@ mod tests { #[tokio::test] async fn a_resolved_broadcast_is_recorded_once() { let origin = moq_tokio::origin::spawn(); - let path = moq_net::Path::new("live/a").to_owned(); + let path = moq_net::Path::new("live/a").unwrap().to_owned(); let newest = origin.create_broadcast(&path).unwrap(); let older = origin.create_broadcast(&path).unwrap(); @@ -447,14 +447,14 @@ mod tests { /// share a key prefix. #[test] fn an_epochless_instance_gets_a_fresh_key() { - let instance = (moq_net::Path::new("live/a").to_owned(), None); + let instance = (moq_net::Path::new("live/a").unwrap().to_owned(), None); let first = key(&Path::from("rec"), &instance).unwrap(); let second = key(&Path::from("rec"), &instance).unwrap(); assert_ne!(first, second); assert!(first.as_ref().starts_with("rec/live/a/"), "{first}"); let epoch = moq_net::Epoch::mint(); - let pinned = (moq_net::Path::new("live/a").to_owned(), Some(epoch.clone())); + let pinned = (moq_net::Path::new("live/a").unwrap().to_owned(), Some(epoch.clone())); assert_eq!( key(&Path::from("rec"), &pinned).unwrap().as_ref(), format!("rec/live/a/@{epoch}") @@ -468,13 +468,13 @@ mod tests { let epoch = moq_net::Epoch::mint(); let victim = key( &Path::from("rec"), - &(moq_net::Path::new("live/a").to_owned(), Some(epoch.clone())), + &(moq_net::Path::new("live/a").unwrap().to_owned(), Some(epoch.clone())), ) .unwrap(); let hostile = format!("live/a/@{epoch}"); let nested = key( &Path::from("rec"), - &(moq_net::Path::new(&hostile).to_owned(), Some(moq_net::Epoch::mint())), + &(moq_net::Path::new(&hostile).unwrap().to_owned(), Some(moq_net::Epoch::mint())), ) .unwrap(); assert!(nested.prefix_match(&victim).is_none(), "{nested} is under {victim}"); @@ -487,7 +487,7 @@ mod tests { let literal = key( &Path::from("rec"), &( - moq_net::Path::new(&format!("live/a/%40{epoch}")).to_owned(), + moq_net::Path::new(&format!("live/a/%40{epoch}")).unwrap().to_owned(), Some(epoch), ), ) diff --git a/rs/moq-cli/src/complete.rs b/rs/moq-cli/src/complete.rs index d0ca4c98da8..39f1619f45c 100644 --- a/rs/moq-cli/src/complete.rs +++ b/rs/moq-cli/src/complete.rs @@ -428,7 +428,7 @@ mod tests { let _ = moq_tokio::crypto::install_default(); let origin = moq_tokio::origin::spawn(); - let _alpha = origin.create_broadcast("alpha").expect("alpha"); + let _alpha = origin.create_broadcast(moq_tokio::moq_net::Path::new("alpha").unwrap()).expect("alpha"); _alpha.announce(Default::default()).expect("alpha"); let mut config = moq_tokio::listen::Config::default(); diff --git a/rs/moq-cli/src/fetch.rs b/rs/moq-cli/src/fetch.rs index 3f3c6c8fa57..4ce6d18e983 100644 --- a/rs/moq-cli/src/fetch.rs +++ b/rs/moq-cli/src/fetch.rs @@ -66,7 +66,7 @@ async fn fetch( // segment such as `.stats` would keep it out of an unscoped listing. let pattern = moq_net::Pattern::subtree(&broadcast).with_context(|| format!("invalid broadcast `{broadcast}`"))?; let origin = moq_tokio::origin::spawn() - .scope("", &moq_net::Patterns::from(pattern)) + .scope(moq_net::Path::empty(), &moq_net::Patterns::from(pattern)) .with_context(|| format!("failed to scope to `{broadcast}`"))?; // Subscribe-only: this session reads and never publishes. @@ -119,7 +119,7 @@ async fn fetch_from( // is still in flight right after connecting. let broadcast = origin .consume() - .routed_broadcast(path) + .routed_broadcast(moq_net::Path::new(path)?) .await .with_context(|| format!("broadcast `{}` not found", crate::display_name(path)))?; let track = broadcast.track(&args.track)?; @@ -191,7 +191,7 @@ mod tests { impl Fixture { async fn new() -> Self { let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast("demo").expect("broadcast"); + let broadcast = origin.create_broadcast(moq_net::Path::new("demo").unwrap()).expect("broadcast"); broadcast.announce(Default::default()).expect("announce"); let data = broadcast.create_track("data", timed()).expect("data track"); @@ -254,7 +254,7 @@ mod tests { .relay .cluster() .origin - .create_broadcast(".hidden") + .create_broadcast(moq_net::Path::new(".hidden").unwrap()) .expect("hidden broadcast"); hidden.announce(Default::default()).expect("announce hidden"); let secret = hidden.create_track("data", timed()).expect("hidden track"); diff --git a/rs/moq-cli/src/hls.rs b/rs/moq-cli/src/hls.rs index bec2b7f792f..49a92dbbd14 100644 --- a/rs/moq-cli/src/hls.rs +++ b/rs/moq-cli/src/hls.rs @@ -159,7 +159,7 @@ pub async fn import(target: ImportTarget, args: ImportArgs, epoch: moq_net::Epoc linger, bandwidth, } = target; - let mut producer = origin.create_broadcast(&name).context("failed to create broadcast")?; + let mut producer = origin.create_broadcast(moq_net::Path::new(&name)?).context("failed to create broadcast")?; let config = moq_mux::catalog::Config::default() .with_max_age(max_age) @@ -251,7 +251,7 @@ pub async fn export(origin: moq_net::origin::Consumer, args: ExportArgs, name: S moq_net::Pattern::subtree(&name).with_context(|| format!("invalid broadcast name `{name}`"))?, ); let scoped = origin - .scope("", &scope) + .scope(moq_net::Path::empty(), &scope) .with_context(|| format!("failed to scope origin to broadcast `{name}`"))?; let mut config = moq_hls::export::Config::default(); @@ -333,7 +333,7 @@ mod test { let (origin, driver) = moq_net::origin::Producer::new(moq_net::origin::Config::default()); tokio::spawn(moq_net::time::run(driver)); - let mut producer = origin.create_broadcast("hls")?; + let mut producer = origin.create_broadcast(moq_net::Path::new("hls").unwrap())?; let catalog = moq_mux::catalog::Producer::new(&mut producer, moq_mux::catalog::Config::default())?; let listed = catalog.consume()?; let mut importer = @@ -434,7 +434,7 @@ mod test { let importing = tokio::spawn(import(target, args, moq_net::Epoch::mint())); announced.next().await.expect("announced"); - let broadcast = consumer.request_broadcast("hls", None).await.unwrap(); + let broadcast = consumer.request_broadcast(moq_net::Path::new("hls").unwrap(), None).await.unwrap(); let mut catalogs = hang::catalog::Catalog::<()>::subscribe(&broadcast).await.unwrap(); let catalog = catalogs.next().await.unwrap().expect("a catalog"); let name = catalog.audio.renditions.keys().next().expect("an audio rendition"); diff --git a/rs/moq-cli/src/main.rs b/rs/moq-cli/src/main.rs index 2d500cd3991..f177b9bfbd0 100644 --- a/rs/moq-cli/src/main.rs +++ b/rs/moq-cli/src/main.rs @@ -745,9 +745,9 @@ fn spawn_import( }) = &import.source { let name = require_broadcast(name, "import ts --program all")?; - Publish::ts_programs(origin.clone(), name, config) + Publish::ts_programs(origin.clone(), moq_net::PathOwned::try_from(name)?, config) } else { - let broadcast = origin.create_broadcast(&name).context("failed to create broadcast")?; + let broadcast = origin.create_broadcast(moq_net::Path::new(&name)?).context("failed to create broadcast")?; Publish::new(broadcast, &format, config)? } .with_linger(linger); @@ -804,7 +804,7 @@ fn spawn_import( #[cfg(feature = "capture")] ImportSource::Capture(capture) => { warn_if_missing_format(&name); - let broadcast = origin.create_broadcast(&name).context("failed to create broadcast")?; + let broadcast = origin.create_broadcast(moq_net::Path::new(&name)?).context("failed to create broadcast")?; let mut publish = Publish::capture(broadcast, &capture, bandwidth.clone(), max_age)?; publish.announce(epoch)?; local = Some(publish); @@ -920,7 +920,7 @@ async fn run_stdout( // resolves it, and any sibling broadcast a rendition's `broadcast` field references // (e.g. "./source") through the same origin. consumer - .routed(&name) + .routed(moq_net::Path::new(&name)?) .await .ok_or_else(|| anyhow::anyhow!("origin closed before broadcast `{name}` was announced"))?; @@ -1164,7 +1164,7 @@ mod tests { let listener = cli.moq.server_config().init_streams().unwrap().listen().await.unwrap(); let addr = listener.tcp_local_addr().unwrap(); let cluster = moq_relay::cluster::Cluster::new(Default::default()).unwrap(); - let broadcast = cluster.origin.create_broadcast("probe").unwrap(); + let broadcast = cluster.origin.create_broadcast(moq_net::Path::new("probe").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); let info = moq_net::track::Info::default().with_timescale(moq_net::Timescale::MILLI); let track = broadcast.create_track("status", info).unwrap(); @@ -1261,7 +1261,7 @@ mod tests { .unwrap(); // Media proves the CLI admitted the session, even on a transport that establishes early. let payload = tokio::time::timeout(TIMEOUT, async { - let broadcast = listening.consumer.routed_broadcast("probe").await.unwrap(); + let broadcast = listening.consumer.routed_broadcast(moq_net::Path::new("probe").unwrap()).await.unwrap(); let mut track = broadcast .track("status") .unwrap() @@ -1347,7 +1347,7 @@ mod tests { tokio::spawn(moq_net::time::run(driver)); let _relayed = accepting.await.unwrap(); - let broadcast = publisher.create_broadcast("demo").unwrap(); + let broadcast = publisher.create_broadcast(moq_net::Path::new("demo").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); let info = moq_net::track::Info::default().with_timescale(moq_net::Timescale::MILLI); let track = broadcast.create_track("live", info).unwrap(); @@ -1356,9 +1356,9 @@ mod tests { group.finish().unwrap(); let reader = relay.consume(); - reader.routed("demo").await.unwrap(); + reader.routed(moq_net::Path::new("demo").unwrap()).await.unwrap(); let mut live = reader - .request_broadcast("demo", None) + .request_broadcast(moq_net::Path::new("demo").unwrap(), None) .await .unwrap() .track("live") diff --git a/rs/moq-cli/src/play/media.rs b/rs/moq-cli/src/play/media.rs index 4d25df38539..3f2c040332b 100644 --- a/rs/moq-cli/src/play/media.rs +++ b/rs/moq-cli/src/play/media.rs @@ -76,7 +76,7 @@ impl Media { /// and an end lets what is playing finish while waiting for the next start. An /// update is the same instance, which its subscriptions already ride out. async fn play(self) -> anyhow::Result<()> { - let mut follow = Instances::new(&self.origin, &self.broadcast, None)?; + let mut follow = Instances::new(&self.origin, moq_net::Path::new(&self.broadcast)?, None)?; let mut playing = None; loop { @@ -1378,7 +1378,7 @@ mod tests { async fn disabling_a_live_high_rendition_plays_the_lower_one() { tokio::time::pause(); let origin = moq_tokio::origin::spawn(); - let mut broadcast = origin.create_broadcast("room").unwrap(); + let mut broadcast = origin.create_broadcast(moq_net::Path::new("room").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); let mut catalog = catalog::Producer::new(&mut broadcast, Default::default()).unwrap(); let mut high = rendition(&broadcast, &catalog, "high"); @@ -1424,7 +1424,7 @@ mod tests { let delay = Duration::from_millis(500); let origin = moq_tokio::origin::spawn(); - let mut broadcast = origin.create_broadcast("room").unwrap(); + let mut broadcast = origin.create_broadcast(moq_net::Path::new("room").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); let mut catalog = catalog::Producer::new(&mut broadcast, Default::default()).unwrap(); @@ -1489,7 +1489,7 @@ mod tests { let delay = Duration::from_millis(500); let origin = moq_tokio::origin::spawn(); - let mut broadcast = origin.create_broadcast("room").unwrap(); + let mut broadcast = origin.create_broadcast(moq_net::Path::new("room").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); let mut catalog = catalog::Producer::new(&mut broadcast, Default::default()).unwrap(); let track = |name: &str| { @@ -1581,7 +1581,7 @@ mod tests { catalog::Producer, moq_mux::container::Producer, ) { - let mut broadcast = origin.create_broadcast("room").unwrap(); + let mut broadcast = origin.create_broadcast(moq_net::Path::new("room").unwrap()).unwrap(); let catalog = catalog::Producer::new(&mut broadcast, Default::default()).unwrap(); let audio = rendition(&broadcast, &catalog, "audio"); broadcast.announce(route).unwrap(); @@ -1657,7 +1657,7 @@ mod tests { #[tokio::test(start_paused = true)] async fn a_refused_broadcast_ends_the_player() { let origin = moq_tokio::origin::spawn(); - let handler = origin.dynamic_route("", Default::default()).unwrap(); + let handler = origin.dynamic_route(moq_net::Path::empty(), Default::default()).unwrap(); let recorder = Recorder::default(); let player = tokio::spawn(media(&origin, Duration::from_millis(50), recorder.clone()).run()); let request = handler.requested_broadcast().await.unwrap(); @@ -1822,7 +1822,7 @@ mod tests { let mut served = moq_net::broadcast::Info::new().produce(); let served_catalog = catalog::Producer::new(&mut served, Default::default()).unwrap(); let mut new = rendition(&served, &served_catalog, "audio"); - let pool = origin.dynamic_route("", route).unwrap(); + let pool = origin.dynamic_route(moq_net::Path::empty(), route).unwrap(); drop(exact); let consumer = served.consume(); tokio::spawn(async move { @@ -1868,7 +1868,7 @@ mod tests { } exact.unannounce(); - let pool = origin.dynamic_route("", route).unwrap(); + let pool = origin.dynamic_route(moq_net::Path::empty(), route).unwrap(); let consumer = mirror.consume(); tokio::spawn(async move { while let Ok(request) = pool.requested_broadcast().await { @@ -1921,7 +1921,7 @@ mod tests { async fn a_finite_audio_track_plays_its_final_samples() { tokio::time::pause(); let origin = moq_tokio::origin::spawn(); - let mut broadcast = origin.create_broadcast("room").unwrap(); + let mut broadcast = origin.create_broadcast(moq_net::Path::new("room").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); let mut catalog = catalog::Producer::new(&mut broadcast, Default::default()).unwrap(); let recorder = Recorder::default(); @@ -1944,7 +1944,7 @@ mod tests { tokio::time::pause(); let delay = Duration::from_secs(2); let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast("room").unwrap(); + let broadcast = origin.create_broadcast(moq_net::Path::new("room").unwrap()).unwrap(); let track = broadcast .create_track("video", hang::container::track_info(hang::catalog::PRIORITY.video)) .unwrap(); diff --git a/rs/moq-cli/src/publish.rs b/rs/moq-cli/src/publish.rs index fbea25d2a50..0b5ed8ef101 100644 --- a/rs/moq-cli/src/publish.rs +++ b/rs/moq-cli/src/publish.rs @@ -432,7 +432,7 @@ impl Publish { /// The programs aren't known until the PAT arrives, so each broadcast is created then and /// announced once its catalog has named a servable track, and [`announce`](Self::announce) has /// nothing to do. - pub fn ts_programs(origin: moq_net::origin::Producer, name: String, config: moq_mux::catalog::Config) -> Self { + pub fn ts_programs(origin: moq_net::origin::Producer, name: moq_net::PathOwned, config: moq_mux::catalog::Config) -> Self { Self { source: Source::Stream { decoder: PublishDecoder::TsPrograms(Box::new(ts::Programs::new(origin, name, config))), @@ -960,7 +960,7 @@ pub(crate) mod tests { async fn manufacture_input() -> Vec { // Create the broadcast on a throwaway origin so the exporter can resolve it by path. let origin = moq_tokio::origin::spawn(); - let mut broadcast = origin.create_broadcast("cli").unwrap(); + let mut broadcast = origin.create_broadcast(moq_net::Path::new("cli").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); settle().await; let config = moq_mux::catalog::Config::default().with_catalog(Catalog::::default()); @@ -1041,7 +1041,7 @@ pub(crate) mod tests { /// A source for the broadcast at `path`, resolved through `origin`. async fn resolved(origin: &moq_net::origin::Producer, path: &str) -> moq_mux::Source { let consumer = origin.consume(); - let broadcast = consumer.request_broadcast(path, None).await.unwrap(); + let broadcast = consumer.request_broadcast(moq_net::Path::new(path).unwrap(), None).await.unwrap(); moq_mux::Source::new(consumer, broadcast) } @@ -1073,7 +1073,7 @@ pub(crate) mod tests { // streams land in the broadcast instead of being dropped by the media-only path. // The broadcast is created on a throwaway origin so the exporter can resolve it by path. let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast("cli").unwrap(); + let broadcast = origin.create_broadcast(moq_net::Path::new("cli").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); settle().await; let mut publish = Publish::new(broadcast, &PublishFormat::Ts { program: None }, Default::default()).unwrap(); @@ -1268,7 +1268,7 @@ pub(crate) mod tests { }; let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast("pt.hang").unwrap(); + let broadcast = origin.create_broadcast(moq_net::Path::new("pt.hang").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); let mut publish = Publish::new( broadcast, @@ -1304,7 +1304,7 @@ pub(crate) mod tests { // the lead holds; the jump is in the copy after it. const WAIT: Duration = Duration::from_secs(10); decoder.decode_chunk(&lead).unwrap(); - let consumer = tokio::time::timeout(WAIT, remote.consume().routed_broadcast("pt.hang")) + let consumer = tokio::time::timeout(WAIT, remote.consume().routed_broadcast(moq_net::Path::new("pt.hang").unwrap())) .await .unwrap() .unwrap(); @@ -1670,7 +1670,7 @@ pub(crate) mod tests { let origin = moq_tokio::origin::spawn(); let consumer = origin.consume(); let mut announced = consumer.announced(); - let broadcast = origin.create_broadcast("demo").unwrap(); + let broadcast = origin.create_broadcast(moq_net::Path::new("demo").unwrap()).unwrap(); let publish = Publish::new(broadcast.clone(), &format, Default::default()).unwrap(); #[cfg_attr( not(feature = "capture"), @@ -1705,7 +1705,7 @@ pub(crate) mod tests { resolved = async { let event = announced.next().await.expect("origin closed"); assert!(matches!(event, moq_net::announce::Event::Start(_)), "{event:?}"); - let broadcast = consumer.request_broadcast("demo", None).await.unwrap(); + let broadcast = consumer.request_broadcast(moq_net::Path::new("demo").unwrap(), None).await.unwrap(); let mut catalogs = hang::catalog::Catalog::<()>::subscribe(&broadcast).await.unwrap(); let catalog = catalogs.next().await.unwrap().expect("a catalog"); // A passthrough carries the multiplex on one track, named by its m2ts section. @@ -1784,7 +1784,7 @@ pub(crate) mod tests { ] { let origin = moq_tokio::origin::spawn(); let mut announced = origin.consume().announced(); - let broadcast = origin.create_broadcast("demo").unwrap(); + let broadcast = origin.create_broadcast(moq_net::Path::new("demo").unwrap()).unwrap(); let publish = Publish::new(broadcast.clone(), &format, Default::default()).unwrap(); #[cfg_attr( not(feature = "capture"), diff --git a/rs/moq-cli/src/report.rs b/rs/moq-cli/src/report.rs index e819594afc6..3d136838463 100644 --- a/rs/moq-cli/src/report.rs +++ b/rs/moq-cli/src/report.rs @@ -334,7 +334,9 @@ impl Echo { if prefix.is_none() { tracing::warn!(path = %echo.path.as_str(), "the catalog solicits feedback above the connection root"); } - Some(prefix?.join(format!("{}{}", self.target.name.0, hang::echo::SUFFIX).as_str())) + let name = moq_net::PathOwned::try_from(format!("{}{}", self.target.name.0, hang::echo::SUFFIX)) + .expect("an echo name is one segment"); + Some(prefix?.join(name)) }); if self.feedback.as_ref().map(|feedback| &feedback.path) == target.as_ref() { return; @@ -418,13 +420,14 @@ async fn snapshot( /// `export report`: write the broadcast's media reports to stdout as JSON lines, following the /// track its catalog's `stats` section names, until the catalog and that track have both ended. pub async fn print_report(origin: moq_net::origin::Consumer, path: String) -> anyhow::Result<()> { + let path = moq_net::PathOwned::try_from(path)?; let mut stdout = tokio::io::stdout(); origin .routed(&path) .await .ok_or_else(|| anyhow::anyhow!("origin closed before broadcast `{path}` was announced"))?; let broadcast = origin - .request_broadcast(path.as_str(), None) + .request_broadcast(&path, None) .await .with_context(|| format!("failed to resolve broadcast `{path}`"))?; let source = moq_mux::Source::new(origin, broadcast.clone()); @@ -488,7 +491,7 @@ async fn write_echo( ) -> anyhow::Result<()> { // Announcements leave hidden routes out unless asked, and a prefix naming one asks. let hidden = prefix.split('/').any(|segment| segment.starts_with('.')); - let prefix = moq_net::Path::new(&prefix).to_owned(); + let prefix = moq_net::Path::new(&prefix)?.to_owned(); let mut announced = origin.clone().with_hidden(hidden).announced(); let (lines, mut written) = tokio::sync::mpsc::channel::(LINES); let mut readers = Readers::default(); @@ -645,7 +648,7 @@ mod tests { #[tokio::test(start_paused = true)] async fn an_ended_feedback_reader_stops_after_draining() { let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast("viewer.echo").unwrap(); + let broadcast = origin.create_broadcast(moq_net::Path::new("viewer.echo").unwrap()).unwrap(); let track = broadcast.create_track(hang::echo::TRACK, None).unwrap(); let mut feedback = moq_json::snapshot::Producer::::new(track, Default::default()); broadcast.announce(Default::default()).unwrap(); @@ -669,7 +672,7 @@ mod tests { #[tokio::test(start_paused = true)] async fn a_drained_reader_is_forgotten() { let mut readers = Readers::default(); - let path = moq_net::Path::new("viewer.echo").to_owned(); + let path = moq_net::Path::new("viewer.echo").unwrap().to_owned(); readers.start(path.clone(), tokio::spawn(std::future::pending())); readers.end(path.clone()); @@ -689,7 +692,7 @@ mod tests { #[tokio::test(start_paused = true)] async fn a_hidden_prefix_finds_its_feedback() { let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast(".viewers/alice.echo").unwrap(); + let broadcast = origin.create_broadcast(moq_net::Path::new(".viewers/alice.echo").unwrap()).unwrap(); let track = broadcast.create_track(hang::echo::TRACK, None).unwrap(); let mut feedback = moq_json::snapshot::Producer::::new(track, Default::default()); broadcast.announce(Default::default()).unwrap(); diff --git a/rs/moq-cli/src/rtc.rs b/rs/moq-cli/src/rtc.rs index f3a92f65867..9d572e0da3e 100644 --- a/rs/moq-cli/src/rtc.rs +++ b/rs/moq-cli/src/rtc.rs @@ -72,7 +72,7 @@ pub async fn listen_export(origin: moq_net::origin::Consumer, name: String, list moq_net::Pattern::subtree(&name).with_context(|| format!("invalid broadcast name `{name}`"))?, ); let subscriber = origin - .scope("", &scope) + .scope(moq_net::Path::empty(), &scope) .with_context(|| format!("failed to scope origin to broadcast `{name}`"))?; let server = moq_rtc::Server::new(server_config(&listen)); serve(server.subscribe_router(subscriber), "WHEP", listen).await @@ -84,7 +84,7 @@ fn scope_producer(origin: &moq_net::origin::Producer, name: &str) -> anyhow::Res moq_net::Pattern::subtree(name).with_context(|| format!("invalid broadcast name `{name}`"))?, ); origin - .scope("", &scope) + .scope(moq_net::Path::empty(), &scope) .with_context(|| format!("failed to scope origin to broadcast `{name}`")) } @@ -94,7 +94,7 @@ pub async fn connect_import(target: ImportTarget, url: Url, epoch: moq_net::Epoc let name = &target.name; let producer = target .origin - .create_broadcast(name) + .create_broadcast(moq_net::Path::new(name)?) .context("failed to create broadcast")?; // The WHEP pull fills the tracks as they arrive; announce up front so viewers // can discover the broadcast while it connects. @@ -115,6 +115,7 @@ pub async fn connect_import(target: ImportTarget, url: Url, epoch: moq_net::Epoc /// WHIP client: push a broadcast from the Origin to a remote (export). pub async fn connect_export(origin: moq_net::origin::Consumer, url: Url, name: String) -> anyhow::Result<()> { + let name = moq_net::PathOwned::try_from(name)?; // Confirm the broadcast is reachable (and wait for it to be announced) before dialing; // the egress re-resolves it (and any referenced sibling broadcast) through the origin. origin diff --git a/rs/moq-cli/src/rtmp.rs b/rs/moq-cli/src/rtmp.rs index 2a3dd43368f..39d482bb509 100644 --- a/rs/moq-cli/src/rtmp.rs +++ b/rs/moq-cli/src/rtmp.rs @@ -73,6 +73,7 @@ pub async fn listen_import(target: ImportTarget, addr: SocketAddr) -> anyhow::Re linger, bandwidth, } = target; + let name = moq_net::PathOwned::try_from(name)?; let mut server = Server::bind(addr).await?; tracing::info!(%addr, %name, "RTMP listening (import)"); notify_ready(); @@ -114,6 +115,7 @@ pub async fn listen_export( name: String, max_delay: Duration, ) -> anyhow::Result<()> { + let name = moq_net::PathOwned::try_from(name)?; let mut server = Server::bind(addr).await?; tracing::info!(%addr, %name, "RTMP listening (export)"); notify_ready(); @@ -146,7 +148,7 @@ pub async fn listen_export( /// Dial a remote RTMP server and pull its play into the Origin under `target.name` (import). pub async fn connect_import(target: ImportTarget, url: Url) -> anyhow::Result<()> { let (addr, app, key) = parse_url(&url).await?; - let name = &target.name; + let name = moq_net::Path::new(&target.name)?; // The stream key is the ingest credential, so log the dial target and app instead. tracing::info!(%addr, %app, %name, "RTMP client pulling"); notify_ready(); @@ -156,7 +158,7 @@ pub async fn connect_import(target: ImportTarget, url: Url) -> anyhow::Result<() .with_max_age(target.max_age) .with_bandwidth(target.bandwidth) .with_linger(target.linger); - Ok(client.pull(&key, &target.origin, name).await?) + Ok(client.pull(&key, &target.origin, &name).await?) } /// Push a broadcast from the Origin to a remote RTMP server (export). @@ -166,6 +168,7 @@ pub async fn connect_export( name: String, max_delay: Duration, ) -> anyhow::Result<()> { + let name = moq_net::PathOwned::try_from(name)?; let (addr, app, key) = parse_url(&url).await?; // Confirm the broadcast is reachable (and wait for it to be announced) before dialing; // the FLV export re-resolves it (and any referenced sibling broadcast) through the origin. diff --git a/rs/moq-cli/src/rtsp.rs b/rs/moq-cli/src/rtsp.rs index 532ce8e5ef6..461f07bf2d6 100644 --- a/rs/moq-cli/src/rtsp.rs +++ b/rs/moq-cli/src/rtsp.rs @@ -71,7 +71,7 @@ fn is_fatal(err: &anyhow::Error) -> bool { async fn run(target: &ImportTarget, client: &moq_rtsp::Client, published: &mut bool) -> anyhow::Result { let mut broadcast = target .origin - .create_broadcast(&target.name) + .create_broadcast(moq_net::Path::new(&target.name)?) .context("failed to create broadcast")?; let config = moq_mux::catalog::Config::default() .with_max_age(target.max_age) diff --git a/rs/moq-cli/src/srt.rs b/rs/moq-cli/src/srt.rs index a08f65e35d4..468912e1349 100644 --- a/rs/moq-cli/src/srt.rs +++ b/rs/moq-cli/src/srt.rs @@ -102,6 +102,7 @@ pub async fn listen_import( linger, bandwidth, } = target; +let name = moq_net::PathOwned::try_from(name)?; let mut server = Server::bind(addr, latency).await?; tracing::info!(%addr, %name, "SRT listening (import)"); notify_ready(); @@ -145,6 +146,7 @@ pub async fn listen_export( name: String, args: ExportArgs, ) -> anyhow::Result<()> { + let name = moq_net::PathOwned::try_from(name)?; let mut server = Server::bind(addr, Duration::from(args.endpoint.latency)).await?; let (follow, stitch) = (args.follow.into(), args.stitch); tracing::info!(%addr, %name, "SRT listening (export)"); @@ -182,7 +184,7 @@ pub async fn connect_import( program: Option, ) -> anyhow::Result<()> { let (addr, resource) = parse_url(&url).await?; - let name = &target.name; + let name = moq_net::Path::new(&target.name)?; tracing::info!(url = %RedactedUrl::new(&url), %name, "SRT client pulling"); notify_ready(); @@ -192,7 +194,7 @@ pub async fn connect_import( .with_bandwidth(target.bandwidth) .with_program(program) .with_linger(target.linger); - client.pull(&target.origin, name).await.map_err(suggest_program) + client.pull(&target.origin, &name).await.map_err(suggest_program) } /// Push a broadcast from the Origin to a remote SRT server (export). @@ -202,6 +204,7 @@ pub async fn connect_export( name: String, args: ExportArgs, ) -> anyhow::Result<()> { + let name = moq_net::PathOwned::try_from(name)?; let (addr, resource) = parse_url(&url).await?; tracing::info!(url = %RedactedUrl::new(&url), %name, "SRT client pushing"); notify_ready(); diff --git a/rs/moq-cli/src/subscribe.rs b/rs/moq-cli/src/subscribe.rs index ffa3f2f7e24..c5a5c171889 100644 --- a/rs/moq-cli/src/subscribe.rs +++ b/rs/moq-cli/src/subscribe.rs @@ -281,7 +281,7 @@ impl Subscribe { catalog: CatalogFormat, args: SubscribeArgs, ) -> anyhow::Result { - let path = moq_net::Path::new(path).to_owned(); + let path = moq_net::Path::new(path)?.to_owned(); let broadcast = origin .request_broadcast(&path, None) .await diff --git a/rs/moq-cli/src/transcode.rs b/rs/moq-cli/src/transcode.rs index a118cf40038..ff66b2d4f05 100644 --- a/rs/moq-cli/src/transcode.rs +++ b/rs/moq-cli/src/transcode.rs @@ -106,19 +106,18 @@ pub async fn run(moq: MoqSide, args: Args, net: Net) -> anyhow::Result<()> { }; config.resize.output = args.frames.0; - let source_path = moq_net::PathOwned::from( + let source_path = moq_net::PathOwned::try_from( moq.broadcast .clone() .context("`transcode` requires the source broadcast: pass --broadcast ")?, - ); + )?; if source_path.is_empty() { anyhow::bail!("`transcode` requires the source broadcast: pass --broadcast "); } - let output_path = moq_net::PathOwned::from( - args.output - .clone() - .unwrap_or_else(|| format!("{source_path}/transcode.hang")), - ); + let output_path = match args.output.clone() { + Some(output) => moq_net::PathOwned::try_from(output)?, + None => source_path.join(moq_net::Path::new("transcode.hang").expect("a literal path")), + }; // Publish the derivative through one origin and consume the source through // another, over a single auto-reconnecting session. @@ -226,14 +225,14 @@ mod tests { route } }; - let old = origin.publish("source", route()).unwrap(); + let old = origin.publish(moq_net::Path::new("source").unwrap(), route()).unwrap(); let _old_dynamic = old.dynamic(); - let mut derivatives = moq_mux::follow::Instances::new(&publish.consume(), "derived", None).unwrap(); + let mut derivatives = moq_mux::follow::Instances::new(&publish.consume(), moq_net::Path::new("derived").unwrap(), None).unwrap(); let following = Following { origin: origin.consume(), publish: publish.clone(), - source_path: "source".into(), - output_path: "derived".into(), + source_path: moq_net::Path::new("source").unwrap().to_owned(), + output_path: moq_net::Path::new("derived").unwrap().to_owned(), config: Default::default(), }; let task = tokio::spawn(following.run()); @@ -244,7 +243,7 @@ mod tests { .subscribe(None) .await .unwrap(); - let new = origin.publish("source", route()).unwrap(); + let new = origin.publish(moq_net::Path::new("source").unwrap(), route()).unwrap(); let _new_dynamic = new.dynamic(); let second = next(&mut derivatives).await; assert!(!first.is_clone(&second)); @@ -273,14 +272,14 @@ mod tests { let origin = moq_tokio::origin::spawn(); let publish = moq_tokio::origin::spawn(); let route = || moq_net::origin::Route::default().with_epoch(moq_net::Epoch::mint()); - let mut old = origin.publish("source", route()).unwrap(); + let mut old = origin.publish(moq_net::Path::new("source").unwrap(), route()).unwrap(); let mut catalog = moq_mux::catalog::Producer::new(&mut old, Default::default()).unwrap(); - let mut derivatives = moq_mux::follow::Instances::new(&publish.consume(), "derived", None).unwrap(); + let mut derivatives = moq_mux::follow::Instances::new(&publish.consume(), moq_net::Path::new("derived").unwrap(), None).unwrap(); let following = Following { origin: origin.consume(), publish: publish.clone(), - source_path: "source".into(), - output_path: "derived".into(), + source_path: moq_net::Path::new("source").unwrap().to_owned(), + output_path: moq_net::Path::new("derived").unwrap().to_owned(), config: Default::default(), }; let task = tokio::spawn(following.run()); @@ -292,7 +291,7 @@ mod tests { .expect("the ladder outlived its source's end"); assert!(!task.is_finished(), "a clean end stopped following"); - let new = origin.publish("source", route()).unwrap(); + let new = origin.publish(moq_net::Path::new("source").unwrap(), route()).unwrap(); let _new_dynamic = new.dynamic(); let second = next(&mut derivatives).await; assert!(!first.is_clone(&second)); diff --git a/rs/moq-cli/tests/integration/epochs.rs b/rs/moq-cli/tests/integration/epochs.rs index e55907363ba..d8a0f4da8c5 100644 --- a/rs/moq-cli/tests/integration/epochs.rs +++ b/rs/moq-cli/tests/integration/epochs.rs @@ -1,5 +1,6 @@ //! Real relay routing keeps held catalog/media identities while fresh readers follow replacements. +use hang::moq_net::Path; use std::time::{Duration, Instant}; use hang::moq_net::{self, Epoch, Timestamp, announce, broadcast, origin, track}; @@ -82,8 +83,8 @@ struct Published { fn publish(origin: &origin::Producer, epoch: &Epoch, tag: &str) -> Published { let route = origin::Route::default().with_epoch(epoch.clone()); - let mut broadcast = origin.publish("live/catalog.hang", route.clone()).unwrap(); - let sibling = origin.publish("live/media", route).unwrap(); + let mut broadcast = origin.publish(Path::new("live/catalog.hang").unwrap(), route.clone()).unwrap(); + let sibling = origin.publish(Path::new("live/media").unwrap(), route).unwrap(); let media = sibling .create_track( "audio", @@ -146,8 +147,8 @@ async fn replacement(version: &str) { .unwrap(); let viewer_origin = moq_tokio::origin::spawn(); let viewer = viewer_origin.consume(); - let mut catalog_follow = viewer.follow("live/catalog.hang").unwrap(); - let mut media_follow = viewer.follow("live/media").unwrap(); + let mut catalog_follow = viewer.follow(Path::new("live/catalog.hang").unwrap()).unwrap(); + let mut media_follow = viewer.follow(Path::new("live/media").unwrap()).unwrap(); let viewer_client = client(version).with_subscriber(viewer_origin); let _viewer_connection = viewer_client .clone() @@ -158,7 +159,7 @@ async fn replacement(version: &str) { assert!(matches!(catalog_follow.next().await, Some(announce::Event::Start(_)))); assert!(matches!(media_follow.next().await, Some(announce::Event::Start(_)))); - let held = viewer.request_broadcast("live/catalog.hang", None).await.unwrap(); + let held = viewer.request_broadcast(Path::new("live/catalog.hang").unwrap(), None).await.unwrap(); let old = moq_mux::Source::new(viewer.clone(), held); let mut catalog = old.catalog::<()>(moq_mux::catalog::CatalogFormat::Hang).await.unwrap(); let snapshot = catalog.next().await.unwrap().unwrap(); @@ -254,7 +255,7 @@ async fn replacement(version: &str) { // Fresh catalog handles start fresh pins instead of sharing the old Source's cache. let fresh = moq_mux::Source::new( viewer.clone(), - viewer.request_broadcast("live/catalog.hang", None).await.unwrap(), + viewer.request_broadcast(Path::new("live/catalog.hang").unwrap(), None).await.unwrap(), ); let mut fresh_catalog = fresh .catalog::<()>(moq_mux::catalog::CatalogFormat::Hang) @@ -282,7 +283,7 @@ async fn replacement(version: &str) { changed(&mut media_follow).await; }) .await; - let returned = viewer.request_broadcast("live/media", None).await.unwrap(); + let returned = viewer.request_broadcast(Path::new("live/media").unwrap(), None).await.unwrap(); let mut returned = returned.track("audio").unwrap().subscribe(None).await.unwrap(); write(&first.media, "A:3"); let returned_frame = read(&mut returned).await; diff --git a/rs/moq-cli/tests/integration/export.rs b/rs/moq-cli/tests/integration/export.rs index 2e1400e4cb2..52e109f2a8c 100644 --- a/rs/moq-cli/tests/integration/export.rs +++ b/rs/moq-cli/tests/integration/export.rs @@ -7,6 +7,7 @@ //! seconds between them, so they are ignored here and run nightly as `just rs cli-export`. #![cfg(unix)] +use hang::moq_net::Path; use std::io::Cursor; use std::os::fd::AsRawFd; use std::process::Stdio; @@ -516,7 +517,7 @@ async fn the_same_instance_within_the_follow_continues() { let epoch = moq_net::Epoch::mint(); let lite07 = ["--connect-version", LITE_07]; let origin = moq_tokio::origin::spawn(); - let mut broadcast = origin.create_broadcast("demo").unwrap(); + let mut broadcast = origin.create_broadcast(Path::new("demo").unwrap()).unwrap(); let config = moq_mux::catalog::Config::default() .with_max_age(Some(Duration::from_secs(1))) .with_catalog(moq_mux::catalog::hang::Catalog::::default()); @@ -557,7 +558,7 @@ async fn the_same_instance_within_the_follow_continues() { } export.output_past(0).await; assert!(split < LONG.len(), "the capture has a tail after the export joined"); - let old = relay.origin.request_broadcast("demo", None).await.unwrap(); + let old = relay.origin.request_broadcast(Path::new("demo").unwrap(), None).await.unwrap(); assert_eq!(old.info().epoch.as_ref(), Some(&epoch)); let clock = catalog.snapshot().clock; connection.abort(moq_net::Error::Cancel); @@ -567,7 +568,7 @@ async fn the_same_instance_within_the_follow_continues() { .expect("the relay observes the lost publication"); let mark = output.lock().unwrap().len().next_multiple_of(188); let connection = client.connect(url).established().await.unwrap(); - let back = tokio::time::timeout(TIMEOUT, relay.origin.routed_broadcast("demo")) + let back = tokio::time::timeout(TIMEOUT, relay.origin.routed_broadcast(Path::new("demo").unwrap())) .await .expect("the relay observes the returning publication") .unwrap(); @@ -1037,7 +1038,7 @@ async fn next_epoch(announced: &mut moq_net::announce::Follow) -> moq_net::Epoch #[ignore = "real-time process test: just rs cli-export"] async fn a_passthrough_export_ends_with_its_redundant_importer() { let relay = relay().await; - let mut announced = relay.origin.follow("demo").unwrap(); + let mut announced = relay.origin.follow(Path::new("demo").unwrap()).unwrap(); let (feed, feeding) = redundant_feed(); let mut first = redundant_import(&relay, &feed, &["--passthrough"]); let incumbent = next_epoch(&mut announced).await; diff --git a/rs/moq-cli/tests/integration/import.rs b/rs/moq-cli/tests/integration/import.rs index 6f584b9f9c4..b86ae1ba5e4 100644 --- a/rs/moq-cli/tests/integration/import.rs +++ b/rs/moq-cli/tests/integration/import.rs @@ -1,6 +1,7 @@ //! `moq import` over a real relay: at stdin EOF the process finishes its tracks and //! exits, and a subscriber sees the catalog finish rather than the publisher vanish. +use hang::moq_net::Path; use std::process::Stdio; use std::time::Duration; @@ -92,7 +93,7 @@ async fn import_delivers_the_catalog_finish_at_eof() { panic!("the first announce event is {event:?}, not a start"); }; assert_eq!(announce.prefix.as_str(), "demo"); - let broadcast = running(&mut child, "the broadcast", consumer.request_broadcast("demo", None)) + let broadcast = running(&mut child, "the broadcast", consumer.request_broadcast(Path::new("demo").unwrap(), None)) .await .expect("announced broadcast resolves"); let mut catalogs = hang::catalog::Catalog::<()>::subscribe(&broadcast) @@ -167,7 +168,7 @@ async fn a_short_import_drains_its_media_to_a_waiting_subscriber() { running(&mut child, "the announce", announced.next()) .await .expect("origin closed"); - let broadcast = running(&mut child, "the broadcast", consumer.request_broadcast("demo", None)) + let broadcast = running(&mut child, "the broadcast", consumer.request_broadcast(Path::new("demo").unwrap(), None)) .await .expect("announced broadcast resolves"); let mut catalogs = running( diff --git a/rs/moq-cli/tests/integration/listen.rs b/rs/moq-cli/tests/integration/listen.rs index 9bf6e859734..b6b1b57f243 100644 --- a/rs/moq-cli/tests/integration/listen.rs +++ b/rs/moq-cli/tests/integration/listen.rs @@ -1,6 +1,7 @@ //! Listening imports and exports drain accepted sessions on SIGTERM. #![cfg(unix)] +use hang::moq_net::Path; use std::{process::Stdio, time::Duration}; use hang::moq_net; @@ -147,7 +148,7 @@ async fn an_export_stage_ending_during_drain_waits_for_every_session() { let listening = listen("export", &["--drain-timeout", "3s"]).await; let _ = moq_tokio::crypto::install_default(); let origin = moq_tokio::origin::spawn(); - let source = origin.create_broadcast("demo.hang").unwrap(); + let source = origin.create_broadcast(Path::new("demo.hang").unwrap()).unwrap(); let catalog = source.create_track("catalog.json", None).unwrap(); source.announce(Default::default()).unwrap(); let publisher = moq_tokio::connect::Config::default() diff --git a/rs/moq-cli/tests/integration/report.rs b/rs/moq-cli/tests/integration/report.rs index 3188e735e82..cbb1e8876b7 100644 --- a/rs/moq-cli/tests/integration/report.rs +++ b/rs/moq-cli/tests/integration/report.rs @@ -2,6 +2,7 @@ //! `export report` and `export echo` sinks: each report counts what its side carried. #![cfg(unix)] +use hang::moq_net::Path; use std::collections::BTreeMap; use std::process::Stdio; use std::time::Duration; @@ -388,7 +389,7 @@ async fn export_echo_reports_what_the_export_reads() { let (expected, _) = written(CLIP); // A publisher soliciting feedback under `viewers`, a sibling of its broadcast. - let mut broadcast = relay.origin.create_broadcast("demo").expect("create the broadcast"); + let mut broadcast = relay.origin.create_broadcast(Path::new("demo").unwrap()).expect("create the broadcast"); let config = moq_mux::catalog::Config::default() .with_max_age(Some(Duration::from_secs(1))) .with_catalog(moq_mux::catalog::hang::Catalog::::default()); diff --git a/rs/moq-cli/tests/integration/rtsp.rs b/rs/moq-cli/tests/integration/rtsp.rs index 6b1d23b8be8..5d9981266a4 100644 --- a/rs/moq-cli/tests/integration/rtsp.rs +++ b/rs/moq-cli/tests/integration/rtsp.rs @@ -1,6 +1,7 @@ //! `moq import rtsp` over a real relay: every RTSP session is its own broadcast under a fresh //! epoch, so a camera whose RTP time restarts never splices onto the broadcast before it. +use hang::moq_net::Path; use std::process::Stdio; use std::time::Duration; @@ -67,7 +68,7 @@ async fn next_broadcast( moq_net::announce::Event::End(_) | moq_net::announce::Event::Update(_) => {} } } - let broadcast = running(child, "the broadcast", consumer.request_broadcast("camera", None)) + let broadcast = running(child, "the broadcast", consumer.request_broadcast(Path::new("camera").unwrap(), None)) .await .expect("announced broadcast resolves"); let mut catalogs = running( diff --git a/rs/moq-e2ee/src/credential.rs b/rs/moq-e2ee/src/credential.rs index 26f6940cb4a..9160bc8c7d5 100644 --- a/rs/moq-e2ee/src/credential.rs +++ b/rs/moq-e2ee/src/credential.rs @@ -85,7 +85,7 @@ impl Credential { /// [`Error::Identity`](crate::Error::Identity) if `semantic` exceeds 65535 bytes. pub fn path(&self, semantic: &str) -> Result { let material: [u8; PATH_LEN] = self.expand(&self.path_info(semantic)?); - Ok(moq_net::Path::new(&URL_SAFE_NO_PAD.encode(material)).into_owned()) + Ok(moq_net::PathOwned::try_from(URL_SAFE_NO_PAD.encode(material))?) } /// Mint a fresh epoch and a producing generation whose clones share track claims. diff --git a/rs/moq-ffi/src/bench.rs b/rs/moq-ffi/src/bench.rs index 0d96b97e224..ba2e53af713 100644 --- a/rs/moq-ffi/src/bench.rs +++ b/rs/moq-ffi/src/bench.rs @@ -282,7 +282,7 @@ async fn rust_net() { config.pool = moq_net::cache::Pool::new(cache); let (origin, driver) = moq_net::origin::Producer::new(config); let driver = tokio::spawn(moq_net::time::run(driver)); - let broadcast = origin.create_broadcast("bench").unwrap(); + let broadcast = origin.create_broadcast(moq_net::Path::new("bench").unwrap()).unwrap(); let info = moq_net::track::Info::default().with_timescale(moq_net::Timescale::MICRO); let tracks: Vec<_> = (0..case.publishers) .map(|p| broadcast.create_track(p.to_string(), Some(info.clone())).unwrap()) diff --git a/rs/moq-ffi/src/origin.rs b/rs/moq-ffi/src/origin.rs index f25a243a251..9a2a889bba5 100644 --- a/rs/moq-ffi/src/origin.rs +++ b/rs/moq-ffi/src/origin.rs @@ -401,6 +401,7 @@ impl MoqOriginProducer { pub fn dynamic(&self, prefix: String) -> Result, MoqError> { let _guard = crate::ffi::enter(); self.inner.driver.check()?; + let prefix = moq_net::PathOwned::try_from(prefix)?; let result = self.inner.dynamic(prefix); self.inner.driver.check()?; let dynamic = result?; @@ -428,7 +429,8 @@ impl MoqOriginProducer { let _guard = crate::ffi::enter(); self.inner.driver.check()?; // Surfaces Error::Unauthorized (out of scope) via the MoqError::Protocol conversion. - let result = self.inner.create_broadcast(path.as_str()); + let path = moq_net::Path::new(&path)?; + let result = self.inner.create_broadcast(path); self.inner.driver.check()?; let broadcast = result?; Ok(Arc::new(MoqBroadcastProducer::from_inner( @@ -451,7 +453,7 @@ impl MoqOriginConsumer { let filter = filter.rooted(&config.prefix)?; let origin = self .inner - .scope("", &moq_net::Patterns::from(filter))? + .scope(moq_net::Path::empty(), &moq_net::Patterns::from(filter))? .with_hidden(config.hidden); Ok(Arc::new(MoqAnnounceConsumer { task: Task::new(Announced { @@ -472,7 +474,7 @@ impl MoqOriginConsumer { self.driver.check()?; // Following checks the permission eagerly, so an unreachable path fails here rather // than surfacing later as a `Closed` the caller can't tell from the origin ending. - let inner = self.inner.announced_broadcast(path.as_str(), None)?; + let inner = self.inner.announced_broadcast(moq_net::Path::new(&path)?, None)?; Ok(Arc::new(MoqAnnouncedBroadcast { task: Task::new(AnnouncedBroadcast { @@ -499,7 +501,7 @@ impl MoqOriginConsumer { pub async fn request_broadcast(&self, path: String) -> Result, MoqError> { let broadcast = self .driver - .watch(async { Ok(self.inner.request_broadcast(path.as_str(), None).await?) }) + .watch(async { Ok(self.inner.request_broadcast(moq_net::Path::new(&path)?, None).await?) }) .await?; Ok(Arc::new(MoqBroadcastConsumer::routed( broadcast, diff --git a/rs/moq-ffi/src/test.rs b/rs/moq-ffi/src/test.rs index 36d9f34201a..40ec4e97c65 100644 --- a/rs/moq-ffi/src/test.rs +++ b/rs/moq-ffi/src/test.rs @@ -1,3 +1,4 @@ +use moq_net::Path; use super::origin::*; use super::producer::*; use super::server::{MoqServer, MoqServerConfig, MoqServerTls}; @@ -4296,7 +4297,7 @@ async fn cancel_retracts_the_route_synchronously() { let dynamic = serve(&origin, ""); let inner = origin.inner().consume(); - let queued = inner.request_broadcast("x", None).into_inner(); + let queued = inner.request_broadcast(Path::new("x").unwrap(), None).into_inner(); assert!( queued.poll_ok(&kio::Waiter::noop()).is_pending(), "the route must serve while the handler lives" @@ -4304,7 +4305,7 @@ async fn cancel_retracts_the_route_synchronously() { drop(queued); dynamic.cancel(); - let verdict = inner.request_broadcast("y", None).into_inner(); + let verdict = inner.request_broadcast(Path::new("y").unwrap(), None).into_inner(); match verdict.poll_ok(&kio::Waiter::noop()) { std::task::Poll::Ready(Err(moq_net::Error::Unroutable)) => {} std::task::Poll::Ready(Err(err)) => panic!("unexpected error: {err}"), @@ -5418,7 +5419,7 @@ async fn announced_broadcast_hands_out_the_instance_again_after_an_end() { let dynamic = origin .inner() .inner - .dynamic_route("", route.clone().try_into().unwrap()) + .dynamic_route(moq_net::Path::empty(), route.clone().try_into().unwrap()) .unwrap(); broadcast.unannounce().unwrap(); let again = tokio::spawn(async move { followed.available().await }); diff --git a/rs/moq-gst/src/sink/session.rs b/rs/moq-gst/src/sink/session.rs index a69fbae8435..4a21278f4e2 100644 --- a/rs/moq-gst/src/sink/session.rs +++ b/rs/moq-gst/src/sink/session.rs @@ -278,7 +278,7 @@ impl Session { // lingers, rather than resuming viewers into the old run's group sequence. Reconnects keep it. let epoch = moq_net::Epoch::mint(); gst::info!(CAT, "publishing {} under epoch {epoch}", settings.broadcast); - let mut broadcast = origin.publish(&settings.broadcast, moq_net::origin::Route::default().with_epoch(epoch))?; + let mut broadcast = origin.publish(&moq_net::Path::new(&settings.broadcast)?, moq_net::origin::Route::default().with_epoch(epoch))?; let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default())?; let status = Arc::new(Status::default()); diff --git a/rs/moq-gst/src/source/imp.rs b/rs/moq-gst/src/source/imp.rs index 629b8629749..89104882729 100644 --- a/rs/moq-gst/src/source/imp.rs +++ b/rs/moq-gst/src/source/imp.rs @@ -585,7 +585,7 @@ async fn follow_path( ) -> Result<()> { use moq_mux::follow::{Event, Instances}; - let mut follow = Instances::new(origin, path, None)?; + let mut follow = Instances::new(origin, moq_net::Path::new(path)?, None)?; let pads = Pads::default(); let mut runs = tokio::task::JoinSet::new(); // Cancels the latest run. @@ -2010,6 +2010,7 @@ mod tests { reason = "tests read the host clock directly" )] mod session_tests { + use moq_net::Path; use std::collections::{BTreeMap, HashSet}; use std::sync::atomic::Ordering; use std::sync::{Arc, Mutex}; @@ -2255,11 +2256,11 @@ mod session_tests { let _pad_ids = pad_ids(); let element = element(); let origin = origin(); - let mut catalog_broadcast = origin.create_broadcast("room/catalog").unwrap(); + let mut catalog_broadcast = origin.create_broadcast(Path::new("room/catalog").unwrap()).unwrap(); let mut local = catalog_broadcast.dynamic(); - let left = origin.create_broadcast("room/left").unwrap(); + let left = origin.create_broadcast(Path::new("room/left").unwrap()).unwrap(); let mut remote = left.dynamic(); - let right = origin.create_broadcast("room/right").unwrap(); + let right = origin.create_broadcast(Path::new("room/right").unwrap()).unwrap(); let mut replacement = right.dynamic(); let mut catalog = moq_mux::catalog::Producer::new(&mut catalog_broadcast, Default::default()).unwrap(); let mut config = video_rendition(); @@ -3065,14 +3066,14 @@ mod session_tests { impl Publisher { /// Publish at `room` on `origin` under `route`. fn new(origin: &moq_net::origin::Producer, route: moq_net::origin::Route, config: VideoConfig) -> Self { - let publisher = Self::build(origin.create_broadcast("room").unwrap(), config); + let publisher = Self::build(origin.create_broadcast(Path::new("room").unwrap()).unwrap(), config); publisher.broadcast.announce(route).unwrap(); publisher } /// The `cam` broadcast a rendition of `room` references as `./cam`, under `route`. fn sibling(origin: &moq_net::origin::Producer, route: moq_net::origin::Route) -> Self { - let publisher = Self::build(origin.create_broadcast("cam").unwrap(), video_rendition()); + let publisher = Self::build(origin.create_broadcast(Path::new("cam").unwrap()).unwrap(), video_rendition()); publisher.broadcast.announce(route).unwrap(); publisher } @@ -3427,7 +3428,7 @@ mod session_tests { /// Follow `room` on `origin` past its start. A follower folds everything on hand while nothing /// serves the path, so one first polled after the next change would never report it. fn announced(origin: &moq_net::origin::Producer) -> moq_net::announce::Follow { - let mut follow = origin.consume().follow("room").unwrap(); + let mut follow = origin.consume().follow(Path::new("room").unwrap()).unwrap(); await_event(&mut follow, |event| matches!(event, moq_net::announce::Event::Start(_))); follow } @@ -3490,7 +3491,7 @@ mod session_tests { let mut old = Publisher::standalone(video_rendition()); let serving = std::sync::Arc::new(Mutex::new(old.broadcast.consume())); - let pool = std::sync::Arc::new(origin.dynamic_route("", epoch()).unwrap()); + let pool = std::sync::Arc::new(origin.dynamic_route(moq_net::Path::empty(), epoch()).unwrap()); let (handler, answer) = (pool.clone(), serving.clone()); let handler = super::RUNTIME.spawn(async move { while let Ok(request) = handler.requested_broadcast().await { @@ -3519,7 +3520,7 @@ mod session_tests { let element = element(); let recorder = Recorder::attach(&element); let origin = origin(); - let pool = origin.dynamic_route("", epoch()).unwrap(); + let pool = origin.dynamic_route(moq_net::Path::empty(), epoch()).unwrap(); let session = follow(&element, &origin); let pending = super::RUNTIME.block_on(async { tokio::time::timeout(Duration::from_secs(10), pool.requested_broadcast()) @@ -3559,7 +3560,7 @@ mod session_tests { let mut first = Publisher::sibling(&origin, Default::default()); let pad = recorder.written(&mut first, 1); - let mut follow = origin.consume().follow("cam").unwrap(); + let mut follow = origin.consume().follow(Path::new("cam").unwrap()).unwrap(); await_event(&mut follow, |event| matches!(event, moq_net::announce::Event::Start(_))); drop(first); await_event(&mut follow, |event| matches!(event, moq_net::announce::Event::End(_))); @@ -3645,7 +3646,7 @@ mod session_tests { let origin = origin(); let _room = referencing(&origin, None); let session = follow(&element, &origin); - let mut follow = origin.consume().follow("cam").unwrap(); + let mut follow = origin.consume().follow(Path::new("cam").unwrap()).unwrap(); let route = epoch(); let mut first = Publisher::sibling(&origin, route.clone()); @@ -3727,7 +3728,7 @@ mod session_tests { let mut first = Publisher::sibling(&origin, Default::default()); let pad = recorder.written(&mut first, 1); room.catalog.finish().unwrap(); - let mut follow = origin.consume().follow("cam").unwrap(); + let mut follow = origin.consume().follow(Path::new("cam").unwrap()).unwrap(); await_event(&mut follow, |event| matches!(event, moq_net::announce::Event::Start(_))); drop(first); await_event(&mut follow, |event| matches!(event, moq_net::announce::Event::End(_))); @@ -4009,7 +4010,7 @@ mod session_tests { let mut second = Publisher::sibling(&origin, moq_net::origin::Route::default().with_epoch(other)); let unpinned = recorder.written(&mut second, 2); let pad = reached(1).into_iter().find(|pad| *pad != unpinned).unwrap(); - let mut follow = origin.consume().follow("cam").unwrap(); + let mut follow = origin.consume().follow(Path::new("cam").unwrap()).unwrap(); await_event(&mut follow, |event| matches!(event, moq_net::announce::Event::Start(_))); drop(second); await_event(&mut follow, |event| { @@ -4063,7 +4064,7 @@ mod session_tests { let mut first = Publisher::sibling(&origin, Default::default()); let pad = recorder.written(&mut first, 1); - let mut follow = origin.consume().follow("cam").unwrap(); + let mut follow = origin.consume().follow(Path::new("cam").unwrap()).unwrap(); await_event(&mut follow, |event| matches!(event, moq_net::announce::Event::Start(_))); drop(first); await_event(&mut follow, |event| matches!(event, moq_net::announce::Event::End(_))); @@ -4105,7 +4106,7 @@ mod session_tests { let mut first = Publisher::sibling(&origin, Default::default()); let pad = recorder.written(&mut first, 1); - let mut follow = origin.consume().follow("cam").unwrap(); + let mut follow = origin.consume().follow(Path::new("cam").unwrap()).unwrap(); await_event(&mut follow, |event| matches!(event, moq_net::announce::Event::Start(_))); drop(first); await_event(&mut follow, |event| matches!(event, moq_net::announce::Event::End(_))); @@ -4183,7 +4184,7 @@ mod session_tests { let session = follow(&element, &origin); let pad = recorder.written(&mut old, 1); - let mut follow = origin.consume().follow("cam").unwrap(); + let mut follow = origin.consume().follow(Path::new("cam").unwrap()).unwrap(); await_event(&mut follow, |event| matches!(event, moq_net::announce::Event::Start(_))); let mut new = Publisher::sibling(&origin, epoch()); await_event(&mut follow, |event| { @@ -4452,7 +4453,7 @@ mod session_tests { fn a_refused_catalog_fails_the_session() { let element = element(); let origin = origin(); - let broadcast = origin.create_broadcast("room").unwrap(); + let broadcast = origin.create_broadcast(Path::new("room").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); let (_shutdown, session) = follow(&element, &origin); diff --git a/rs/moq-hls/src/export/mod.rs b/rs/moq-hls/src/export/mod.rs index 7c73d43fe84..73e19277e23 100644 --- a/rs/moq-hls/src/export/mod.rs +++ b/rs/moq-hls/src/export/mod.rs @@ -565,6 +565,7 @@ async fn watch( reason = "tests read the host clock directly" )] mod tests { + use moq_net::Path; /// A millisecond track: the frames written here carry timestamps. fn timed() -> moq_net::track::Info { moq_net::track::Info::default().with_timescale(moq_net::Timescale::MILLI) @@ -769,7 +770,7 @@ mod tests { #[tokio::test] async fn escaping_broadcast_reference_is_not_advertised() { let origin = produce_origin(); - let _broadcast = origin.create_broadcast("a/pub").expect("publish allowed"); + let _broadcast = origin.create_broadcast(Path::new("a/pub").unwrap()).expect("publish allowed"); _broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let upstream = crate::resolved(&origin, "a/pub").await; @@ -875,7 +876,7 @@ mod tests { #[tokio::test] async fn estimate_only_catalog_update_keeps_the_rendition() { let origin = produce_origin(); - let _broadcast = origin.create_broadcast("live").expect("publish allowed"); + let _broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); _broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let upstream = empty_upstream(&origin, "live").await; @@ -944,7 +945,7 @@ mod tests { #[tokio::test] async fn estimated_framerate_keeps_the_rendition() { let origin = produce_origin(); - let _broadcast = origin.create_broadcast("live").expect("publish allowed"); + let _broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); _broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let upstream = empty_upstream(&origin, "live").await; @@ -997,7 +998,7 @@ mod tests { #[tokio::test] async fn estimate_before_first_init_reaches_aac_descriptor() { let origin = produce_origin(); - let _broadcast = origin.create_broadcast("live").expect("publish allowed"); + let _broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); _broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let upstream = empty_upstream(&origin, "live").await; @@ -1029,7 +1030,7 @@ mod tests { #[tokio::test] async fn decoder_config_change_rebuilds_the_rendition() { let origin = produce_origin(); - let _broadcast = origin.create_broadcast("live").expect("publish allowed"); + let _broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); _broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let upstream = empty_upstream(&origin, "live").await; @@ -1081,7 +1082,7 @@ mod tests { #[tokio::test] async fn master_lists_only_playable_renditions() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast("live").expect("publish allowed"); + let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); @@ -1143,7 +1144,7 @@ mod tests { #[tokio::test(start_paused = true)] async fn a_disabled_rendition_leaves_the_master_and_keeps_its_playlist() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast("live").expect("publish allowed"); + let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); @@ -1215,7 +1216,7 @@ mod tests { #[tokio::test(start_paused = true)] async fn disabled_reference_handoff_continues_the_source_media_sequence() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast("live").unwrap(); + let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); settle().await; let catalog = moq_mux::catalog::Producer::new(&mut broadcast, Default::default()).unwrap(); @@ -1322,7 +1323,7 @@ mod tests { #[tokio::test(start_paused = true)] async fn unaligned_reference_handoff_marks_the_gap_without_reusing_urls() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast("live").unwrap(); + let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); settle().await; let mut catalog = moq_mux::catalog::Producer::new(&mut broadcast, Default::default()).unwrap(); @@ -1453,7 +1454,7 @@ mod tests { /// The old reference cuts 2s records through 6s; the replacement cuts `span_ms` records. async fn edges_around_a_handoff(span_ms: u64) { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast("live").unwrap(); + let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); settle().await; let mut catalog = moq_mux::catalog::Producer::new(&mut broadcast, Default::default()).unwrap(); @@ -1560,7 +1561,7 @@ mod tests { moq_mux::catalog::Producer, ) { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast("live").unwrap(); + let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); settle().await; let mut catalog = moq_mux::catalog::Producer::new(&mut broadcast, Default::default()).unwrap(); @@ -1733,7 +1734,7 @@ mod tests { #[tokio::test(start_paused = true)] async fn a_transmuxed_segment_keeps_its_init_with_an_unfinished_tail() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast("live").expect("publish allowed"); + let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); let (mut catalog, mut registration, _media) = publish_vp8(&mut broadcast); registration .set(hang::catalog::VideoConfig::new(hang::catalog::VideoCodec::VP8)) @@ -1764,7 +1765,7 @@ mod tests { #[tokio::test(start_paused = true)] async fn a_blocked_init_bootstrap_does_not_hide_a_cached_init() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast("live").expect("publish allowed"); + let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); let (mut catalog, mut registration, _media) = publish_vp8(&mut broadcast); registration .set(hang::catalog::VideoConfig::new(hang::catalog::VideoCodec::VP8)) @@ -1801,7 +1802,7 @@ mod tests { #[tokio::test] async fn a_reconfigure_versions_the_init_url() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast("live").expect("publish allowed"); + let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let (_catalog, mut registration, _media) = publish_vp8(&mut broadcast); @@ -1846,7 +1847,7 @@ mod tests { #[tokio::test] async fn a_generation_versions_segment_urls_and_a_new_one_resets_the_window() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast("live").expect("publish allowed"); + let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let (_catalog, _registration, mut media) = publish_vp8(&mut broadcast); @@ -1903,7 +1904,7 @@ mod tests { #[tokio::test] async fn a_new_generation_rebuilds_an_inline_init() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast("live").expect("publish allowed"); + let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); @@ -1954,7 +1955,7 @@ mod tests { #[tokio::test] async fn serves_playlist_and_segments_from_the_timeline() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast("live").expect("publish allowed"); + let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); @@ -2042,7 +2043,7 @@ mod tests { #[tokio::test] async fn a_duration_marker_times_the_hls_trailing_sample() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast("live").expect("publish allowed"); + let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); @@ -2086,7 +2087,7 @@ mod tests { #[tokio::test] async fn serves_dash_manifest_and_time_addressed_segments() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast("live").expect("publish allowed"); + let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); @@ -2192,7 +2193,7 @@ mod tests { #[tokio::test] async fn root_clock_times_playlists_and_manifest() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast("live").expect("publish allowed"); + let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; @@ -2252,7 +2253,7 @@ mod tests { #[tokio::test] async fn manifest_falls_back_to_arrival_anchor_without_a_clock() { let origin = produce_origin(); - let broadcast = origin.create_broadcast("live").expect("publish allowed"); + let broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; @@ -2329,7 +2330,7 @@ mod tests { } let origin = produce_origin(); - let mut broadcast = origin.create_broadcast("live").expect("publish allowed"); + let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); @@ -2444,7 +2445,7 @@ mod tests { } else { None }; - let mut broadcast = origin.create_broadcast("live").unwrap(); + let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); settle().await; let catalog = moq_mux::catalog::Producer::new(&mut broadcast, Default::default()).unwrap(); @@ -2456,7 +2457,7 @@ mod tests { let audio_muxer = moq_mux::container::fmp4::Muxer::audio(snapshot.audio.renditions.values().next().unwrap()).unwrap(); let consuming = remote.as_ref().unwrap_or(&origin); - consuming.consume().routed("live").await.unwrap(); + consuming.consume().routed(Path::new("live").unwrap()).await.unwrap(); let source = crate::resolved(consuming, "live").await; let broadcaster = (!late).then(|| Broadcaster::new(source.clone(), Config::default())); for i in 0..20u64 { @@ -2519,7 +2520,7 @@ mod tests { #[tokio::test] async fn dash_manifest_turns_static_when_finished() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast("live").expect("publish allowed"); + let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let mut catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); @@ -2581,7 +2582,7 @@ mod tests { #[tokio::test] async fn renditions_snap_to_their_own_keyframes() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast("live").expect("publish allowed"); + let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); @@ -2670,7 +2671,7 @@ mod tests { #[tokio::test] async fn an_audio_only_broadcast_segments_on_its_audio() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast("live").expect("publish allowed"); + let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); @@ -2722,7 +2723,7 @@ mod tests { #[tokio::test] async fn target_duration_follows_the_observed_segments() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast("live").expect("publish allowed"); + let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); @@ -2762,7 +2763,7 @@ mod tests { #[tokio::test] async fn audio_and_video_segments_are_aligned() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast("live").expect("publish allowed"); + let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); @@ -2855,7 +2856,7 @@ mod tests { #[tokio::test] async fn dropping_the_broadcaster_keeps_a_cursor_drainable() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast("live").expect("publish allowed"); + let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let mut catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); @@ -2950,11 +2951,11 @@ mod tests { async fn ended_rendition(sibling: bool) -> Ended { const KEYFRAME: &[u8] = &[0x10, 0x00, 0x00, 0x9d, 0x01, 0x2a, 0x40, 0x01, 0xf0, 0x00]; let origin = produce_origin(); - let mut broadcast = origin.create_broadcast("live").unwrap(); + let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); let mut catalog = moq_mux::catalog::Producer::new(&mut broadcast, Default::default()).unwrap(); let mut target = if sibling { - let target = origin.create_broadcast("media").unwrap(); + let target = origin.create_broadcast(Path::new("media").unwrap()).unwrap(); target.announce(Default::default()).unwrap(); target } else { @@ -3038,7 +3039,7 @@ mod tests { for sibling in [false, true] { let ended = ended_rendition(sibling).await; let path = if sibling { "media" } else { "live" }; - let next = ended.origin.create_broadcast(path).unwrap(); + let next = ended.origin.create_broadcast(Path::new(path).unwrap()).unwrap(); next.announce(Default::default()).unwrap(); let mut media = moq_mux::container::Producer::new( next.create_track("video0", timed()).unwrap(), @@ -3095,7 +3096,7 @@ mod tests { origin: &moq_net::origin::Producer, payload: &'static [u8], ) -> (Box, hang::catalog::VideoConfig) { - let mut broadcast = origin.create_broadcast("live").expect("publish allowed"); + let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); @@ -3192,7 +3193,7 @@ mod tests { payload: &'static [u8], recorder: Option, ) -> Box { - let broadcast = origin.create_broadcast("media").expect("publish allowed"); + let broadcast = origin.create_broadcast(Path::new("media").unwrap()).expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); let track = broadcast.create_track("video0", timed()).unwrap(); @@ -3213,7 +3214,7 @@ mod tests { let origin = produce_origin(); // The catalog broadcast carries the catalog and the timeline; the media lives next door. - let mut live = origin.create_broadcast("live").expect("publish allowed"); + let mut live = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); live.announce(Default::default()).expect("publish allowed"); let catalog = moq_mux::catalog::Producer::new(&mut live, moq_mux::catalog::Config::default()).unwrap(); let recorder = catalog.enroll_test("video0").unwrap(); @@ -3343,14 +3344,14 @@ mod tests { const NEW: &[u8] = b"NEWNEWNEWNEWNEWN"; let origin = produce_origin(); - let mut live = origin.create_broadcast("live").expect("publish allowed"); + let mut live = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); live.announce(Default::default()).expect("publish allowed"); let catalog = moq_mux::catalog::Producer::new(&mut live, moq_mux::catalog::Config::default()).unwrap(); let recorder = catalog.enroll_test("video0").unwrap(); let mut old_media = moq_net::broadcast::Info::new().produce(); let _old_track = write_routed_media(&mut old_media, OLD, recorder, 0); - let old_server = origin.dynamic_route("media", sibling_route(10)).unwrap(); + let old_server = origin.dynamic_route(Path::new("media").unwrap(), sibling_route(10)).unwrap(); settle().await; let upstream = crate::resolved(&origin, "live").await; @@ -3395,7 +3396,7 @@ mod tests { } // A publisher serving the path afterwards, with rows recorded for it, is never bound. - let new_server = origin.dynamic_route("media", sibling_route(11)).unwrap(); + let new_server = origin.dynamic_route(Path::new("media").unwrap(), sibling_route(11)).unwrap(); let _ = rendition.snapshot(); assert!( tokio::time::timeout(Duration::from_secs(1), new_server.requested_broadcast()) @@ -3424,14 +3425,14 @@ mod tests { const KEYFRAME: &[u8] = &[0x10, 0x00, 0x00, 0x9d, 0x01, 0x2a, 0x40, 0x01, 0xf0, 0x00]; let origin = produce_origin(); - let mut live = origin.create_broadcast("live").expect("publish allowed"); + let mut live = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); live.announce(Default::default()).expect("publish allowed"); let catalog = moq_mux::catalog::Producer::new(&mut live, moq_mux::catalog::Config::default()).unwrap(); let recorder = catalog.enroll_test("video0").unwrap(); let mut media = moq_net::broadcast::Info::new().produce(); let _track = write_routed_media(&mut media, KEYFRAME, recorder, 0); - let server = origin.dynamic_route("media", sibling_route(10)).unwrap(); + let server = origin.dynamic_route(Path::new("media").unwrap(), sibling_route(10)).unwrap(); settle().await; let upstream = crate::resolved(&origin, "live").await; @@ -3481,14 +3482,14 @@ mod tests { const NEW: &[u8] = b"NEWNEWNEWNEWNEWN"; let origin = produce_origin(); - let mut live = origin.create_broadcast("live").expect("publish allowed"); + let mut live = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); live.announce(Default::default()).expect("publish allowed"); let catalog = moq_mux::catalog::Producer::new(&mut live, moq_mux::catalog::Config::default()).unwrap(); let recorder = catalog.enroll_test("video0").unwrap(); let mut media = moq_net::broadcast::Info::new().produce(); let _track = write_routed_media(&mut media, NEW, recorder, 0); - let server = origin.dynamic_route("media", sibling_route(11)).unwrap(); + let server = origin.dynamic_route(Path::new("media").unwrap(), sibling_route(11)).unwrap(); settle().await; let upstream = crate::resolved(&origin, "live").await; @@ -3520,14 +3521,14 @@ mod tests { const NEW: &[u8] = b"NEWNEWNEWNEWNEWN"; let origin = produce_origin(); - let mut live = origin.create_broadcast("live").expect("publish allowed"); + let mut live = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); live.announce(Default::default()).expect("publish allowed"); let catalog = moq_mux::catalog::Producer::new(&mut live, moq_mux::catalog::Config::default()).unwrap(); let recorder = catalog.enroll_test("video0").unwrap(); let mut old_media = moq_net::broadcast::Info::new().produce(); let _old_track = write_routed_media(&mut old_media, OLD, recorder, 0); - let old_server = origin.dynamic_route("media", sibling_route(10)).unwrap(); + let old_server = origin.dynamic_route(Path::new("media").unwrap(), sibling_route(10)).unwrap(); settle().await; let upstream = crate::resolved(&origin, "live").await; @@ -3552,7 +3553,7 @@ mod tests { .expect("the old retained segment drains"); assert!(contains(&served, OLD)); - let new_server = origin.dynamic_route("media", sibling_route(11)).unwrap(); + let new_server = origin.dynamic_route(Path::new("media").unwrap(), sibling_route(11)).unwrap(); let mut new_media = moq_net::broadcast::Info::new().produce(); let recorder = catalog.enroll_test("video0").unwrap(); let _new_track = write_routed_media(&mut new_media, NEW, recorder, 6_000_000); @@ -3585,13 +3586,13 @@ mod tests { const OLD: &[u8] = b"OLDOLDOLDOLDOLDO"; let origin = produce_origin(); - let mut live = origin.create_broadcast("live").expect("publish allowed"); + let mut live = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); live.announce(Default::default()).expect("publish allowed"); let catalog = moq_mux::catalog::Producer::new(&mut live, moq_mux::catalog::Config::default()).unwrap(); let recorder = catalog.enroll_test("video0").unwrap(); let mut media = moq_net::broadcast::Info::new().produce(); let track = write_routed_media(&mut media, OLD, recorder, 0); - let server = origin.dynamic_route("media", sibling_route(10)).unwrap(); + let server = origin.dynamic_route(Path::new("media").unwrap(), sibling_route(10)).unwrap(); settle().await; let upstream = crate::resolved(&origin, "live").await; @@ -3634,7 +3635,7 @@ mod tests { const OLD: &[u8] = b"OLDOLDOLDOLDOLDO"; let origin = produce_origin(); - let mut live = origin.create_broadcast("live").expect("publish allowed"); + let mut live = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); live.announce(Default::default()).expect("publish allowed"); let catalog = moq_mux::catalog::Producer::new(&mut live, moq_mux::catalog::Config::default()).unwrap(); let recorder = catalog.enroll_test("video0").unwrap(); @@ -3651,7 +3652,7 @@ mod tests { .await .expect("the catalog's rows are listed before the sibling resolves"); - let server = origin.dynamic_route("media", sibling_route(10)).unwrap(); + let server = origin.dynamic_route(Path::new("media").unwrap(), sibling_route(10)).unwrap(); let _ = rendition.snapshot(); accept_sibling(&server, &media).await; let served = rendition @@ -3670,7 +3671,7 @@ mod tests { #[tokio::test] async fn removing_a_rendition_ends_its_segment_cursor() { let origin = produce_origin(); - let broadcast = origin.create_broadcast("live").expect("publish allowed"); + let broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let upstream = crate::resolved(&origin, "live").await; @@ -3703,7 +3704,7 @@ mod tests { #[tokio::test] async fn a_rendition_appears_once_its_timeline_is_advertised() { let origin = produce_origin(); - let broadcast = origin.create_broadcast("live").expect("publish allowed"); + let broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let upstream = crate::resolved(&origin, "live").await; @@ -3748,7 +3749,7 @@ mod tests { #[tokio::test] async fn dropping_the_broadcaster_releases_its_renditions() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast("live").expect("publish allowed"); + let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); @@ -3806,7 +3807,7 @@ mod tests { #[tokio::test] async fn record_cursors_yield_renditions_and_segments() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast("live").expect("publish allowed"); + let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); @@ -4416,7 +4417,7 @@ mod tests { const NEW: &[u8] = b"NEWNEWNEWNEWNEWN"; let origin = produce_origin(); - let mut broadcast = origin.create_broadcast("live").expect("publish allowed"); + let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); diff --git a/rs/moq-hls/src/export/rendition.rs b/rs/moq-hls/src/export/rendition.rs index d4fddf57491..4f76580ad8f 100644 --- a/rs/moq-hls/src/export/rendition.rs +++ b/rs/moq-hls/src/export/rendition.rs @@ -1336,6 +1336,7 @@ fn net_errors(err: &moq_mux::Error) -> impl Iterator { #[cfg(test)] mod tests { use super::*; + use moq_net::Path; /// Decode the code `local` would send on a moq-lite stream reset. fn over_lite(local: &moq_net::Error) -> moq_net::Error { @@ -1358,14 +1359,14 @@ mod tests { #[tokio::test] async fn pending_reads_preserve_a_later_authorization_refusal() { let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast("room/live").unwrap(); - let dynamic = origin.dynamic_route("room/secret", Default::default()).unwrap(); + let broadcast = origin.create_broadcast(Path::new("room/live").unwrap()).unwrap(); + let dynamic = origin.dynamic_route(Path::new("room/secret").unwrap(), Default::default()).unwrap(); let source = moq_mux::Source::new(origin.consume(), broadcast.consume()); let mut config = VideoConfig::new(hang::catalog::VideoCodec::VP8); config.broadcast = Some(moq_net::path::Relative::new("./secret").to_owned()); let rendition = Arc::new(Rendition::video("video".into(), &config, &source, Archive::default(), None).unwrap()); let request = dynamic.requested_broadcast().await.unwrap(); - let other = origin.dynamic_route("room/hidden", Default::default()).unwrap(); + let other = origin.dynamic_route(Path::new("room/hidden").unwrap(), Default::default()).unwrap(); config.broadcast = Some(moq_net::path::Relative::new("./hidden").to_owned()); let resolving = Arc::new(Rendition::video("video".into(), &config, &source, Archive::default(), None).unwrap()); let other_request = other.requested_broadcast().await.unwrap(); @@ -1523,7 +1524,7 @@ mod tests { #[test] fn a_gone_publisher_is_unservable_and_an_ietf_miss_is_not() { let origin = produce_origin(); - let producer = origin.create_broadcast("live").expect("publish allowed"); + let producer = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); let live = producer.consume(); let ietf_miss = over_ietf_miss(); assert!( diff --git a/rs/moq-hls/src/lib.rs b/rs/moq-hls/src/lib.rs index 324fd6123ba..db28c2aa1cc 100644 --- a/rs/moq-hls/src/lib.rs +++ b/rs/moq-hls/src/lib.rs @@ -43,7 +43,7 @@ pub use axum; pub(crate) async fn resolved(origin: &moq_net::origin::Producer, path: &str) -> moq_mux::Source { let consumer = origin.consume(); let broadcast = consumer - .request_broadcast(path, None) + .request_broadcast(moq_net::Path::new(path).unwrap(), None) .await .expect("the broadcast resolves"); moq_mux::Source::new(consumer, broadcast) diff --git a/rs/moq-hls/src/server/mod.rs b/rs/moq-hls/src/server/mod.rs index f64ab977c76..ccc595982ab 100644 --- a/rs/moq-hls/src/server/mod.rs +++ b/rs/moq-hls/src/server/mod.rs @@ -209,7 +209,9 @@ impl Server { // source resolves a rendition's sibling `broadcast` reference through the same origin. // Once the origin has synced, a path with no route is not announced, so answer now // rather than wait out a publisher that has gone. - let mut routes = self.inner.origin.follow(name).ok()?; + // A name with an empty segment names no broadcast. + let path = moq_net::Path::new(name).ok()?; + let mut routes = self.inner.origin.follow(&path).ok()?; let routed = kio::wait(|waiter| match routes.poll_next(waiter) { Poll::Ready(Some(moq_net::announce::Event::End(_)) | None) => Poll::Ready(false), Poll::Ready(Some(_)) => Poll::Ready(true), @@ -219,7 +221,7 @@ impl Server { return None; } - let mut instances = follow::Instances::new(&self.inner.origin, name, None) + let mut instances = follow::Instances::new(&self.inner.origin, &path, None) .map_err(|err| tracing::warn!(%err, %name, "failed to follow broadcast")) .ok()?; // A covering dynamic route may never answer, so the resolution is bounded too. @@ -308,6 +310,7 @@ async fn run_follow(inner: Weak, name: String, followed: Weak, #[cfg(test)] mod tests { + use moq_net::Path; /// Build an origin producer, spawning its driver on the ambient runtime. fn produce_origin() -> moq_net::origin::Producer { let (producer, driver) = moq_net::origin::Producer::new(moq_net::origin::Config::default()); @@ -419,7 +422,7 @@ mod tests { async fn closed_broadcaster() -> Arc { let origin = produce_origin(); - let producer = origin.create_broadcast("gone").expect("publish allowed"); + let producer = origin.create_broadcast(Path::new("gone").unwrap()).expect("publish allowed"); producer.announce(Default::default()).expect("publish allowed"); settle().await; let broadcaster = Broadcaster::new(crate::resolved(&origin, "gone").await, Config::default()); @@ -441,7 +444,7 @@ mod tests { .lock() .unwrap() .insert("live".to_string(), Arc::new(Followed::new(stale.clone()))); - let _producer = origin.create_broadcast("live").expect("publish allowed"); + let _producer = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); _producer.announce(Default::default()).expect("publish allowed"); settle().await; @@ -457,7 +460,7 @@ mod tests { #[tokio::test] async fn dropping_the_server_releases_its_broadcasters() { let origin = produce_origin(); - let producer = origin.create_broadcast("live").expect("publish allowed"); + let producer = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); producer.announce(Default::default()).expect("publish allowed"); settle().await; @@ -501,12 +504,12 @@ mod tests { let (old_epoch, new_epoch) = (moq_net::Epoch::mint(), moq_net::Epoch::mint()); let route = |epoch: &moq_net::Epoch| moq_net::origin::Route::default().with_epoch(epoch.clone()); - let old = origin.publish("live", route(&old_epoch)).expect("publish allowed"); + let old = origin.publish(Path::new("live").unwrap(), route(&old_epoch)).expect("publish allowed"); settle().await; let first = server.broadcaster("live").await.expect("broadcast announced"); assert_eq!(first.instance().as_ref(), old_epoch.as_str()); - let new = origin.publish("live", route(&new_epoch)).expect("publish allowed"); + let new = origin.publish(Path::new("live").unwrap(), route(&new_epoch)).expect("publish allowed"); eventually(async || { let current = server.broadcaster("live").await.expect("broadcast announced"); current.instance().as_ref() == new_epoch.as_str() @@ -534,7 +537,7 @@ mod tests { let origin = produce_origin(); let server = Server::new(origin.consume(), Config::default()); let _old = origin - .publish("live", moq_net::origin::Route::default()) + .publish(Path::new("live").unwrap(), moq_net::origin::Route::default()) .expect("publish allowed"); settle().await; let open = Broadcaster::new(crate::resolved(&origin, "live").await, Config::default()); diff --git a/rs/moq-hls/src/server/routes.rs b/rs/moq-hls/src/server/routes.rs index 88190a2ec42..56f98f6217d 100644 --- a/rs/moq-hls/src/server/routes.rs +++ b/rs/moq-hls/src/server/routes.rs @@ -220,6 +220,7 @@ fn server_error(err: crate::Error) -> Response { )] mod tests { use super::*; + use moq_net::Path; /// A millisecond track: the frames written here carry timestamps. fn timed() -> moq_net::track::Info { @@ -401,7 +402,7 @@ mod tests { #[tokio::test] async fn respond_serves_a_route_rewritten_into_scope() { let pair = lite_pair().await; - let mut broadcast = pair.pub_origin.create_broadcast("live").expect("publish"); + let mut broadcast = pair.pub_origin.create_broadcast(Path::new("live").unwrap()).expect("publish"); broadcast.announce(Default::default()).expect("announce"); let (_catalog, _registration, _track, mut media) = publish_video(&mut broadcast, video_config(), timed()); write_three_gops(&mut media); @@ -445,7 +446,7 @@ mod tests { "moq-lite-05", ] { let pair = lite_pair_on(version, moq_net::Hop::random()).await; - let mut broadcast = pair.pub_origin.create_broadcast("live").expect("publish"); + let mut broadcast = pair.pub_origin.create_broadcast(Path::new("live").unwrap()).expect("publish"); broadcast.announce(Default::default()).expect("announce"); // A hinted timeline is declared before any media, so the rendition is listed early. let hinted = moq_mux::timeline::Config::default().with_duration_hint(Duration::from_secs(2)); @@ -466,11 +467,11 @@ mod tests { drop(reserved); let origin = pair.sub_origin.consume(); - tokio::time::timeout(TIMEOUT, origin.routed("live")) + tokio::time::timeout(TIMEOUT, origin.routed(Path::new("live").unwrap())) .await .expect("announce timed out") .expect("routed"); - let remote = tokio::time::timeout(TIMEOUT, origin.request_broadcast("live", None)) + let remote = tokio::time::timeout(TIMEOUT, origin.request_broadcast(Path::new("live").unwrap(), None)) .await .expect("request timed out") .expect("remote broadcast"); @@ -521,7 +522,7 @@ mod tests { #[tokio::test(start_paused = true)] async fn master_answers_404_until_a_rendition_can_start() { let origin = moq_tokio::origin::spawn(); - let mut broadcast = origin.create_broadcast("live").expect("publish"); + let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish"); broadcast.announce(run()).expect("announce"); let (_catalog, _registration, _track, mut media) = publish_video(&mut broadcast, video_config(), timed()); @@ -538,7 +539,7 @@ mod tests { #[tokio::test(start_paused = true)] async fn a_restart_lists_the_replacement_under_its_own_urls() { let origin = moq_tokio::origin::spawn(); - let mut old = origin.create_broadcast("live").expect("publish"); + let mut old = origin.create_broadcast(Path::new("live").unwrap()).expect("publish"); old.announce(run()).expect("announce"); let (old_catalog, _, old_track, mut old_media) = publish_video(&mut old, video_config(), timed()); write_three_gops(&mut old_media); @@ -550,7 +551,7 @@ mod tests { wait_listed(&app, &old_playlist, "seg/656e3d1b.0.m4s").await; let next = moq_net::Epoch::mint(); - let mut new = origin.create_broadcast("live").expect("publish"); + let mut new = origin.create_broadcast(Path::new("live").unwrap()).expect("publish"); new.announce(moq_net::origin::Route::default().with_epoch(next.clone())) .expect("announce"); let (_new_catalog, _, _new_track, mut new_media) = publish_video(&mut new, video_config(), timed()); @@ -584,7 +585,7 @@ mod tests { #[tokio::test(start_paused = true)] async fn a_failed_timeline_answers_an_uncacheable_error() { let origin = moq_tokio::origin::spawn(); - let mut broadcast = origin.create_broadcast("live").expect("publish"); + let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish"); broadcast.announce(run()).expect("announce"); let mut catalog = moq_mux::catalog::Producer::new(&mut broadcast, Default::default()).unwrap(); let name = hang::timeline::default_name("video0"); @@ -637,7 +638,7 @@ mod tests { #[tokio::test(start_paused = true)] async fn serves_only_versioned_media_urls() { let origin = moq_tokio::origin::spawn(); - let mut broadcast = origin.create_broadcast("live").expect("publish"); + let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish"); broadcast.announce(run()).expect("announce"); let (_catalog, _registration, _track, mut media) = publish_video(&mut broadcast, video_config(), timed()); write_three_gops(&mut media); @@ -712,7 +713,7 @@ mod tests { config }) .await; - let mut broadcast = pair.pub_origin.create_broadcast("live").expect("publish"); + let mut broadcast = pair.pub_origin.create_broadcast(Path::new("live").unwrap()).expect("publish"); broadcast.announce(Default::default()).expect("announce"); let (_catalog, _registration, _track, mut media) = publish_video(&mut broadcast, video_config(), timed()); write_three_gops(&mut media); @@ -737,7 +738,7 @@ mod tests { #[tokio::test] async fn a_disconnected_publisher_on_the_catalog_broadcast_answers_404() { let pair = lite_pair().await; - let mut broadcast = pair.pub_origin.create_broadcast("live").expect("publish"); + let mut broadcast = pair.pub_origin.create_broadcast(Path::new("live").unwrap()).expect("publish"); broadcast.announce(Default::default()).expect("announce"); let (catalog, registration, track, mut media) = publish_video(&mut broadcast, video_config(), timed()); write_three_gops(&mut media); @@ -752,7 +753,7 @@ mod tests { ) .await; - let remote = tokio::time::timeout(TIMEOUT, pair.sub_origin.consume().request_broadcast("live", None)) + let remote = tokio::time::timeout(TIMEOUT, pair.sub_origin.consume().request_broadcast(Path::new("live").unwrap(), None)) .await .expect("remote resolve timed out") .expect("remote broadcast"); @@ -773,7 +774,7 @@ mod tests { #[tokio::test] async fn lookups_ride_the_servers_scope_watch() { let pair = lite_pair().await; - let other = pair.pub_origin.create_broadcast("room/other").expect("other"); + let other = pair.pub_origin.create_broadcast(Path::new("room/other").unwrap()).expect("other"); other.announce(Default::default()).expect("announce other"); let server = Server::new(pair.sub_origin.consume(), crate::export::Config::default()); @@ -785,7 +786,7 @@ mod tests { // Nothing watches `room/other` on its own, yet the synced lookup already discovered it. pair.sub_origin .consume() - .request_broadcast("room/other", None) + .request_broadcast(Path::new("room/other").unwrap(), None) .await .expect("discovered through the scope watch"); @@ -808,13 +809,13 @@ mod tests { "moq-lite-07-wip", ] { let pair = lite_pair_on(version, moq_net::origin::Config::default()).await; - let catalog = pair.pub_origin.create_broadcast("room/live").expect("catalog"); + let catalog = pair.pub_origin.create_broadcast(Path::new("room/live").unwrap()).expect("catalog"); catalog.announce(Default::default()).expect("announce catalog"); - let media = pair.pub_origin.create_broadcast("room/source").expect("media"); + let media = pair.pub_origin.create_broadcast(Path::new("room/source").unwrap()).expect("media"); media.announce(Default::default()).expect("announce media"); let origin = pair.sub_origin.consume(); - let broadcast = tokio::time::timeout(TIMEOUT, origin.routed_broadcast("room/live")) + let broadcast = tokio::time::timeout(TIMEOUT, origin.routed_broadcast(Path::new("room/live").unwrap())) .await .expect("catalog resolve timed out") .expect("catalog broadcast"); @@ -836,11 +837,11 @@ mod tests { #[tokio::test(start_paused = true)] async fn denied_sibling_media_answers_403_without_poisoning_allowed_siblings() { let origin = moq_tokio::origin::spawn(); - let mut broadcast = origin.create_broadcast("room/live").unwrap(); + let mut broadcast = origin.create_broadcast(Path::new("room/live").unwrap()).unwrap(); broadcast.announce(run()).unwrap(); - let source = origin.create_broadcast("room/source").unwrap(); + let source = origin.create_broadcast(Path::new("room/source").unwrap()).unwrap(); source.announce(Default::default()).unwrap(); - let secret = origin.create_broadcast("room/secret").unwrap(); + let secret = origin.create_broadcast(Path::new("room/secret").unwrap()).unwrap(); secret.announce(Default::default()).unwrap(); let catalog = moq_mux::catalog::Producer::new(&mut broadcast, Default::default()).unwrap(); let reserved = catalog.reserve(); @@ -870,7 +871,7 @@ mod tests { .into_iter() .map(|path| path.parse::().unwrap()) .collect(); - let restricted = origin.consume().scope("", &patterns).unwrap(); + let restricted = origin.consume().scope(moq_net::Path::empty(), &patterns).unwrap(); let server = Server::new(restricted, Default::default()); let broadcaster = server.broadcaster("room/live").await.unwrap(); broadcaster.ready().await; @@ -931,7 +932,7 @@ mod tests { let only_catalog = origin .consume() .scope( - "", + moq_net::Path::empty(), &moq_net::Patterns::from("room/live".parse::().unwrap()), ) .unwrap(); @@ -954,11 +955,11 @@ mod tests { #[tokio::test] async fn a_disconnected_sibling_publisher_answers_404() { let pair = lite_pair().await; - let mut catalog_broadcast = pair.pub_origin.create_broadcast("room/live").expect("catalog"); + let mut catalog_broadcast = pair.pub_origin.create_broadcast(Path::new("room/live").unwrap()).expect("catalog"); catalog_broadcast .announce(Default::default()) .expect("announce catalog"); - let media_broadcast = pair.pub_origin.create_broadcast("room/source").expect("media"); + let media_broadcast = pair.pub_origin.create_broadcast(Path::new("room/source").unwrap()).expect("media"); media_broadcast.announce(Default::default()).expect("announce media"); let catalog = @@ -988,7 +989,7 @@ mod tests { .await; // Waited on rather than requested once: a client only asks about what it watches. - let remote_media = tokio::time::timeout(TIMEOUT, pair.sub_origin.consume().routed_broadcast("room/source")) + let remote_media = tokio::time::timeout(TIMEOUT, pair.sub_origin.consume().routed_broadcast(Path::new("room/source").unwrap())) .await .expect("sibling resolve timed out") .expect("sibling broadcast"); diff --git a/rs/moq-mux/benches/catalog.rs b/rs/moq-mux/benches/catalog.rs index 299a650ac13..596414aea38 100644 --- a/rs/moq-mux/benches/catalog.rs +++ b/rs/moq-mux/benches/catalog.rs @@ -19,6 +19,7 @@ //! //! Run with `cargo bench -p moq-mux --bench catalog`. +use moq_net::Path; use std::hint::black_box; use std::task::Poll; use std::time::Duration; @@ -49,7 +50,7 @@ struct Fanout { impl Fanout { async fn new(tracks: usize, subscribers: usize, references: bool) -> Self { let mut info = moq_net::broadcast::Info::new(); - info.path = "room/catalog".into(); + info.path = Path::new("room/catalog").unwrap(); let mut broadcast = info.produce(); let catalog = moq_mux::catalog::Producer::new(&mut broadcast, Default::default()).unwrap(); let tracks = (0..tracks) @@ -111,7 +112,7 @@ impl Fanout { black_box(rendition.jitter); if let Some(reference) = &rendition.broadcast { assert!( - moq_net::Path::new("room/catalog") + moq_net::Path::new("room/catalog").unwrap() .try_resolve(reference) .unwrap() .as_str() diff --git a/rs/moq-mux/benches/containers.rs b/rs/moq-mux/benches/containers.rs index b81c6a2ce0b..377069fce91 100644 --- a/rs/moq-mux/benches/containers.rs +++ b/rs/moq-mux/benches/containers.rs @@ -1,4 +1,5 @@ //! Complete fMP4/CMAF and Annex-B imports and exports, with setup outside timing. +use moq_net::Path; use std::time::Duration; use bytes::{Bytes, BytesMut}; @@ -87,13 +88,13 @@ async fn prepare(video: Video, payload: &Bytes) -> (moq_mux::Source, impl Stream catalog.finish().unwrap(); let (origin, driver) = moq_net::origin::Producer::new(Default::default()); let driver = tokio::spawn(moq_net::time::run(driver)); - let dynamic = origin.dynamic_route("", Default::default()).unwrap(); + let dynamic = origin.dynamic_route(moq_net::Path::empty(), Default::default()).unwrap(); let requests = tokio::spawn(async move { while let Ok(request) = dynamic.requested_broadcast().await { request.accept(consumer.clone()); } }); - let resolved = origin.consume().request_broadcast("bench", None).await.unwrap(); + let resolved = origin.consume().request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); let source = moq_mux::Source::new(origin.consume(), resolved); let stream = source.catalog::<()>(CatalogFormat::Hang).await.unwrap(); let fixture = Fixture { diff --git a/rs/moq-mux/benches/export.rs b/rs/moq-mux/benches/export.rs index 58383df9172..1e72d1faac7 100644 --- a/rs/moq-mux/benches/export.rs +++ b/rs/moq-mux/benches/export.rs @@ -1,4 +1,5 @@ //! Container export cost swept over independently varied tracks and queued frames. +use moq_net::Path; use std::time::Duration; use bytes::Bytes; @@ -58,13 +59,13 @@ async fn prepare(tracks: usize, frames: usize) -> (moq_mux::Source, moq_mux::cat catalog.finish().unwrap(); let (origin, driver) = moq_net::origin::Producer::new(Default::default()); let driver = tokio::spawn(moq_net::time::run(driver)); - let dynamic = origin.dynamic_route("", Default::default()).unwrap(); + let dynamic = origin.dynamic_route(moq_net::Path::empty(), Default::default()).unwrap(); let requests = tokio::spawn(async move { while let Ok(request) = dynamic.requested_broadcast().await { request.accept(consumer.clone()); } }); - let resolved = origin.consume().request_broadcast("bench", None).await.unwrap(); + let resolved = origin.consume().request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); let source = moq_mux::Source::new(origin.consume(), resolved); let fixture = Fixture { _published: Box::new((broadcast, catalog, publishers)), @@ -222,13 +223,13 @@ async fn prepare_video( catalog.finish().unwrap(); let (origin, driver) = moq_net::origin::Producer::new(Default::default()); let driver = tokio::spawn(moq_net::time::run(driver)); - let dynamic = origin.dynamic_route("", Default::default()).unwrap(); + let dynamic = origin.dynamic_route(moq_net::Path::empty(), Default::default()).unwrap(); let requests = tokio::spawn(async move { while let Ok(request) = dynamic.requested_broadcast().await { request.accept(consumer.clone()); } }); - let resolved = origin.consume().request_broadcast("bench", None).await.unwrap(); + let resolved = origin.consume().request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); let source = moq_mux::Source::new(origin.consume(), resolved); ( source, diff --git a/rs/moq-mux/benches/ts_programs.rs b/rs/moq-mux/benches/ts_programs.rs index 138d738ce9a..e425fb51f18 100644 --- a/rs/moq-mux/benches/ts_programs.rs +++ b/rs/moq-mux/benches/ts_programs.rs @@ -3,6 +3,7 @@ //! shows as a falling rate with program count. A PAT that also names programs no PMT //! describes shows what a program costs before it starts. +use moq_net::Path; use std::time::Duration; use criterion::{BatchSize, BenchmarkId, Criterion, Throughput, criterion_group, criterion_main}; @@ -183,7 +184,7 @@ fn multiplex(programs: u16, undescribed: u16, bitrate: u64) -> Vec { /// A fresh importer, with the origin driver it needs kept alive but unpolled. fn setup() -> (moq_mux::container::ts::Programs, impl Sized) { let (origin, driver) = moq_net::origin::Producer::new(Default::default()); - let programs = moq_mux::container::ts::Programs::new(origin, "bench.hang", moq_mux::catalog::Config::default()); + let programs = moq_mux::container::ts::Programs::new(origin, Path::new("bench.hang").unwrap(), moq_mux::catalog::Config::default()); (programs, driver) } diff --git a/rs/moq-mux/src/catalog/hang/consumer.rs b/rs/moq-mux/src/catalog/hang/consumer.rs index f7c9ec2f178..bf2c595c5a5 100644 --- a/rs/moq-mux/src/catalog/hang/consumer.rs +++ b/rs/moq-mux/src/catalog/hang/consumer.rs @@ -79,6 +79,7 @@ impl From for Consumer { #[cfg(test)] mod test { + use moq_net::Path; use std::task::Poll; use super::*; @@ -130,7 +131,7 @@ mod test { /// resolves against. fn publish_catalog(published: Catalog<()>) -> Result> { let origin = crate::source::produce_origin(); - let broadcast = origin.create_broadcast("a/pub").expect("broadcast should create"); + let broadcast = origin.create_broadcast(Path::new("a/pub").unwrap()).expect("broadcast should create"); let track = broadcast .create_track(hang::Catalog::DEFAULT_NAME, hang::Catalog::default_track_info()) .expect("catalog track should create"); @@ -169,8 +170,8 @@ mod test { .expect("catalog track should create"); let origin = crate::source::produce_origin(); - let dynamic = origin.dynamic_route("", Default::default()).unwrap(); - let requesting = origin.consume().request_broadcast("a/pub", None); + let dynamic = origin.dynamic_route(Path::new("").unwrap(), Default::default()).unwrap(); + let requesting = origin.consume().request_broadcast(Path::new("a/pub").unwrap(), None); let served = broadcast.consume(); // The handler hands its route back: dropping it would retract the route and end // the broadcast it just served. diff --git a/rs/moq-mux/src/catalog/msf/consumer.rs b/rs/moq-mux/src/catalog/msf/consumer.rs index 2b45d756c5c..9b9ecb194cb 100644 --- a/rs/moq-mux/src/catalog/msf/consumer.rs +++ b/rs/moq-mux/src/catalog/msf/consumer.rs @@ -124,15 +124,11 @@ pub(crate) fn from_msf(msf: &moq_msf::Catalog, base: &moq_net: .namespace .as_ref() .map(|namespace| { - let target = moq_net::Path::new(namespace); let unresolvable = || Error::UnresolvableNamespace { name: track.name.clone(), namespace: namespace.clone(), }; - // An MSF namespace names content; normalizing it must not select another namespace. - if target.as_str() != namespace { - return Err(unresolvable()); - } + let target = moq_net::Path::new(namespace).map_err(|_| unresolvable())?; if super::names_catalog(&target, base) { return Ok(None); } @@ -490,7 +486,7 @@ fn derive_from_cmaf_moov(track: &moq_msf::Track, init: bytes::Bytes) -> Result(catalog: &hang::Catalog, base: &moq_net::Path) -> #[cfg(test)] mod test { + use moq_net::Path; use std::collections::BTreeMap; use std::str::FromStr; @@ -1456,7 +1457,7 @@ mod test { let (origin, driver) = moq_net::origin::Producer::new(Default::default()); let driver = tokio::spawn(moq_net::time::run(driver)); let mut broadcast = match path { - Some(path) => origin.create_broadcast(path).unwrap(), + Some(path) => origin.create_broadcast(Path::new(path).unwrap()).unwrap(), None => moq_net::broadcast::Info::new().produce(), }; let mut producer = Producer::new(&mut broadcast, Config::default()).unwrap(); @@ -1623,7 +1624,7 @@ mod test { #[test] fn cross_broadcast_renditions_round_trip_through_msf() { - let base = moq_net::Path::new("room/catalog"); + let base = moq_net::Path::new("room/catalog").unwrap(); let catalog = hang::Catalog::<()>::from_str(r#"{ "video": {"renditions": {"view": {"broadcast": "./left", "track": "video", "codec": "vp8", "container": {"kind": "loc"}}}}, "audio": {"renditions": {"sound": {"broadcast": "./right", "track": "audio", "codec": "opus", "sampleRate": 48000, "numberOfChannels": 2, "container": {"kind": "loc"}}}}, @@ -1635,21 +1636,21 @@ mod test { let restored = crate::catalog::msf::from_msf(&msf, &base).unwrap(); assert_eq!( base.try_resolve(restored.video.renditions["video"].broadcast.as_ref().unwrap()), - Some("room/left".into()) + Some(Path::new("room/left").unwrap()) ); assert_eq!( base.try_resolve(restored.audio.renditions["audio"].broadcast.as_ref().unwrap()), - Some("room/right".into()) + Some(Path::new("room/right").unwrap()) ); assert_eq!( base.try_resolve(restored.text.renditions["text"].broadcast.as_ref().unwrap()), - Some("captions".into()) + Some(Path::new("captions").unwrap()) ); } #[test] fn msf_refuses_unresolvable_broadcast_references() { - let base = moq_net::Path::new("room/catalog"); + let base = moq_net::Path::new("room/catalog").unwrap(); for reference in ["../../left", "../../../left"] { let mut catalog = hang::Catalog::<()>::default(); let mut config = VideoConfig::new(hang::catalog::VideoCodec::VP8); @@ -1664,7 +1665,7 @@ mod test { /// reference to such a broadcast is refused rather than read from the catalog's broadcast. #[test] fn msf_refuses_references_readers_would_take_as_the_catalog() { - let base = moq_net::Path::new("room/catalog"); + let base = moq_net::Path::new("room/catalog").unwrap(); for reference in ["../catalog", "./catalog/room/catalog"] { let mut catalog = hang::Catalog::<()>::default(); let mut config = VideoConfig::new(hang::catalog::VideoCodec::VP8); @@ -1677,7 +1678,7 @@ mod test { #[test] fn msf_names_are_unique_per_namespace_but_ambiguous_hang_ids_are_refused() { - let base = moq_net::Path::new("room/catalog"); + let base = moq_net::Path::new("room/catalog").unwrap(); let mut catalog = hang::Catalog::<()>::default(); for (id, broadcast) in [("left", "./left"), ("right", "./right")] { let mut config = VideoConfig::new(hang::catalog::VideoCodec::VP8); @@ -2065,8 +2066,8 @@ mod test { let wall = moq_clock::Wall::UNIX_EPOCH + Duration::from_millis(hang::catalog::MOQ_EPOCH_UNIX_MILLIS + 60_000); let clock = crate::Clock::at(captured, wall).unwrap(); let (origin, _driver) = moq_net::origin::Producer::new(Default::default()); - let mut front = origin.create_broadcast("robot/front.hang").unwrap(); - let mut rear = origin.create_broadcast("robot/rear.hang").unwrap(); + let mut front = origin.create_broadcast(Path::new("robot/front.hang").unwrap()).unwrap(); + let mut rear = origin.create_broadcast(Path::new("robot/rear.hang").unwrap()).unwrap(); let catalogs = [ Producer::new(&mut front, Config::default().with_clock(clock)).unwrap(), Producer::new(&mut rear, Config::default().with_clock(clock)).unwrap(), diff --git a/rs/moq-mux/src/container/consumer.rs b/rs/moq-mux/src/container/consumer.rs index 5b2827f27a4..bd950303fbe 100644 --- a/rs/moq-mux/src/container/consumer.rs +++ b/rs/moq-mux/src/container/consumer.rs @@ -969,6 +969,7 @@ impl std::ops::Deref for GroupBuffer { #[cfg(test)] mod tests { + use moq_net::Path; use super::Container as ContainerTrait; use super::*; use crate::catalog::hang::Container; @@ -2384,14 +2385,14 @@ mod tests { let hops = moq_net::Hops::try_from(vec![moq_net::Hop::new(10).unwrap()]).unwrap(); let first_route = origin .dynamic_route( - "live", + Path::new("live").unwrap(), moq_net::origin::Route::default() .with_epoch(epoch.clone()) .with_hops(hops.clone()) .with_cost(5), ) .unwrap(); - let pending = origin.consume().request_broadcast("live", None); + let pending = origin.consume().request_broadcast(Path::new("live").unwrap(), None); let first = moq_net::broadcast::Info::new().produce(); let info = hang::container::track_info(hang::catalog::PRIORITY.video); let first_track = first.create_track("video", info.clone()).unwrap(); @@ -2428,7 +2429,7 @@ mod tests { for sequence in 1..=4 { let route = origin .dynamic_route( - "live", + Path::new("live").unwrap(), moq_net::origin::Route::default() .with_epoch(epoch.clone()) .with_hops(hops.clone()) diff --git a/rs/moq-mux/src/container/source.rs b/rs/moq-mux/src/container/source.rs index 2fb0653bad3..b8898750009 100644 --- a/rs/moq-mux/src/container/source.rs +++ b/rs/moq-mux/src/container/source.rs @@ -776,6 +776,7 @@ pub(crate) fn build_video_transform(config: &VideoConfig) -> Option (Link::held(&publisher, &subscriber, 2).await, None), }; - let broadcast = publisher.create_broadcast("room").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("room").unwrap()).unwrap(); let track = broadcast .create_track("audio", hang::container::track_info(hang::catalog::PRIORITY.audio)) .unwrap(); broadcast.announce(Default::default()).unwrap(); let consumer = subscriber.consume(); - consumer.routed("room").await.unwrap(); - let remote = consumer.request_broadcast("room", None).await.unwrap(); + consumer.routed(Path::new("room").unwrap()).await.unwrap(); + let remote = consumer.request_broadcast(Path::new("room").unwrap(), None).await.unwrap(); let source = crate::Source::new(consumer, remote); // MPEG-1 audio from TS: one 24 ms frame per group, a PES of five written at once. diff --git a/rs/moq-mux/src/container/test_util.rs b/rs/moq-mux/src/container/test_util.rs index 48f0be9fd64..3fe213df5e3 100644 --- a/rs/moq-mux/src/container/test_util.rs +++ b/rs/moq-mux/src/container/test_util.rs @@ -1,5 +1,6 @@ //! Shared scaffolding for exporter tests. +use moq_net::Path; use bytes::{Bytes, BytesMut}; use hang::catalog::{AudioConfig, Container, H264, VideoConfig}; use moq_net::Timestamp; @@ -119,8 +120,8 @@ impl Moving { pub(crate) fn new() -> Self { let origin = crate::source::produce_origin(); - let mut live = origin.publish("live", Default::default()).unwrap(); - let mut other = origin.publish("other", Default::default()).unwrap(); + let mut live = origin.publish(Path::new("live").unwrap(), Default::default()).unwrap(); + let mut other = origin.publish(Path::new("other").unwrap(), Default::default()).unwrap(); let catalog = crate::catalog::Producer::new(&mut live, crate::catalog::Config::default()).unwrap(); let track = |broadcast: &mut moq_net::broadcast::Producer, name: &str| { let info = hang::container::track_info(hang::catalog::PRIORITY.video); diff --git a/rs/moq-mux/src/container/ts/export_test.rs b/rs/moq-mux/src/container/ts/export_test.rs index c58e9f65c05..988c2285374 100644 --- a/rs/moq-mux/src/container/ts/export_test.rs +++ b/rs/moq-mux/src/container/ts/export_test.rs @@ -6,6 +6,7 @@ //! parameter sets on keyframes). These build a synthetic broadcast, export to //! TS, and re-parse with the `mpeg2ts` reader. +use moq_net::Path; use std::io::{Cursor, Write}; use std::time::Duration; @@ -164,7 +165,7 @@ async fn custom_selected_catalog_drives_export_and_follow() { let origin = crate::source::produce_origin(); let mut export: Option>> = None; for payload in [b"first".as_slice(), b"next".as_slice()] { - let broadcast = origin.create_broadcast("live").unwrap(); + let broadcast = origin.create_broadcast(Path::new("live").unwrap()).unwrap(); broadcast .announce(moq_net::origin::Route::default().with_epoch(moq_net::Epoch::mint())) .unwrap(); @@ -231,7 +232,7 @@ async fn a_follower_keeps_hangz_after_catalog_eof() { let origin = crate::source::produce_origin(); let epoch = moq_net::Epoch::mint(); let publish = || { - let broadcast = origin.create_broadcast("live").unwrap(); + let broadcast = origin.create_broadcast(Path::new("live").unwrap()).unwrap(); let track = broadcast .create_track(hang::Catalog::COMPRESSED_NAME, hang::Catalog::default_track_info()) .unwrap(); @@ -8294,7 +8295,7 @@ fn publish_live( origin: &moq_net::origin::Producer, route: moq_net::origin::Route, ) -> (moq_net::broadcast::Producer, crate::catalog::Producer) { - let mut broadcast = origin.publish("live", route).unwrap(); + let mut broadcast = origin.publish(Path::new("live").unwrap(), route).unwrap(); let config = crate::catalog::Config::default().with_catalog(crate::catalog::hang::Catalog::::default()); let catalog = crate::catalog::Producer::new(&mut broadcast, config).unwrap(); (broadcast, catalog) @@ -8416,7 +8417,7 @@ async fn same_instance_returns(finish: bool) { tokio::time::sleep(Duration::from_secs(1)).await; let (mut broadcast, mut catalog) = publish_live::<()>(&origin, route()); std::ops::DerefMut::deref_mut(&mut catalog.modify().unwrap()); - let back = origin.consume().routed_broadcast("live").await.unwrap(); + let back = origin.consume().routed_broadcast(Path::new("live").unwrap()).await.unwrap(); let stream = crate::catalog::Consumer::new(&back, Default::default()).await.unwrap(); let mut export = export.follow(back, stream).unwrap(); frames.extend(drain_frames(&mut export).await); @@ -8488,7 +8489,7 @@ async fn a_return_keeps_catalog_and_group_history() { crate::clock::fake_host_wall(wall + start.elapsed()); broadcast.announce(route).unwrap(); assert_eq!(catalog.snapshot().clock, clock, "a return must keep the catalog clock"); - let back = origin.consume().routed_broadcast("live").await.unwrap(); + let back = origin.consume().routed_broadcast(Path::new("live").unwrap()).await.unwrap(); assert_eq!(back.info().epoch.as_ref(), Some(&epoch)); assert!(!back.is_clone(&old), "the withdrawn front is replaced"); let stream = crate::catalog::Consumer::new(&back, Default::default()).await.unwrap(); @@ -8536,7 +8537,7 @@ async fn a_switch_carries_through_an_instance_that_never_built_its_tables() { // Switched to an instance whose catalog lists nothing, so it never builds its tables... let (_bare, _bare_catalog) = publish_live::<()>(&origin, route()); - let bare = origin.consume().request_broadcast("live", None).await.unwrap(); + let bare = origin.consume().request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); let stream = crate::catalog::Consumer::new(&bare, Default::default()).await.unwrap(); let mut export = export.follow(bare, stream).unwrap(); assert!( @@ -8547,7 +8548,7 @@ async fn a_switch_carries_through_an_instance_that_never_built_its_tables() { // ...and then to another. let (mut new, mut new_catalog) = publish_live::<()>(&origin, route()); let mut new_audio = aac_rendition(&mut new, &mut new_catalog, "b.aac"); - let replacement = origin.consume().request_broadcast("live", None).await.unwrap(); + let replacement = origin.consume().request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); let stream = crate::catalog::Consumer::new(&replacement, Default::default()) .await .unwrap(); @@ -8598,7 +8599,7 @@ async fn another_instance_is_a_full_program_switch() { let (mut new, mut new_catalog) = publish_live::<()>(&origin, route()); let mut video = h264_rendition(&mut new, &mut new_catalog, "video.avc1"); let mut new_audio = aac_rendition(&mut new, &mut new_catalog, "b.aac"); - let replacement = origin.consume().request_broadcast("live", None).await.unwrap(); + let replacement = origin.consume().request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); let stream = crate::catalog::Consumer::new(&replacement, Default::default()) .await .unwrap(); @@ -8684,7 +8685,7 @@ async fn a_switch_moving_the_pmt_advances_the_pat() { let before = drain_frames(&mut export).await; let (_new, mut new_catalog, mut new_track) = publish(0x200); - let replacement = origin.consume().request_broadcast("live", None).await.unwrap(); + let replacement = origin.consume().request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); let stream = crate::catalog::Consumer::new(&replacement, Default::default()) .await .unwrap(); @@ -8742,7 +8743,7 @@ async fn export_stats_count_only_returned_output() { drop((broadcast, catalog, track)); let (mut broadcast, mut catalog) = publish_live::<()>(&origin, route()); let mut track = aac_rendition(&mut broadcast, &mut catalog, "a.aac"); - let back = origin.consume().routed_broadcast("live").await.unwrap(); + let back = origin.consume().routed_broadcast(Path::new("live").unwrap()).await.unwrap(); let stream = crate::catalog::Consumer::new(&back, Default::default()).await.unwrap(); let mut export = export.follow(back, stream).unwrap(); for ms in (1_000..1_200).step_by(20) { @@ -9171,7 +9172,7 @@ async fn a_follower_awaits_a_replacement_catalog_past_the_follow() { // Replaced, but the replacement's catalog request is never answered. let second = origin .publish( - "live", + Path::new("live").unwrap(), moq_net::origin::Route::default().with_epoch(moq_net::Epoch::mint()), ) .unwrap(); @@ -9207,7 +9208,7 @@ async fn a_follower_awaits_a_return_catalog_until_it_fails() { ); let second = origin - .publish("live", moq_net::origin::Route::default().with_epoch(epoch)) + .publish(Path::new("live").unwrap(), moq_net::origin::Route::default().with_epoch(epoch)) .unwrap(); let silent = second.create_track(hang::Catalog::DEFAULT_NAME, None).unwrap(); assert!( @@ -9243,7 +9244,7 @@ async fn a_follower_keeps_following_when_a_return_goes_before_it_resolves() { // Back, but its catalog request is never answered before it goes again. let second = origin - .publish("live", moq_net::origin::Route::default().with_epoch(epoch)) + .publish(Path::new("live").unwrap(), moq_net::origin::Route::default().with_epoch(epoch)) .unwrap(); let unanswered = second.dynamic(); assert!( @@ -9265,7 +9266,7 @@ async fn a_follower_keeps_following_when_a_return_goes_before_it_resolves() { /// returned task is aborted, which ends the broadcast. fn publish_refusing(origin: &moq_net::origin::Producer, epoch: &moq_net::Epoch) -> tokio::task::JoinHandle<()> { let broadcast = origin - .publish("live", moq_net::origin::Route::default().with_epoch(epoch.clone())) + .publish(Path::new("live").unwrap(), moq_net::origin::Route::default().with_epoch(epoch.clone())) .unwrap(); let mut dynamic = broadcast.dynamic(); tokio::spawn(async move { @@ -9360,7 +9361,7 @@ async fn a_follower_stitches_onto_the_next_replacement_when_one_goes_before_it_r .with_follow(Duration::from_secs(10)); // Replaced, but the replacement's catalog request is never answered before it goes. - let second = origin.publish("live", route()).unwrap(); + let second = origin.publish(Path::new("live").unwrap(), route()).unwrap(); let unanswered = second.dynamic(); assert!( tokio::time::timeout(Duration::from_secs(1), follower.next()) @@ -9419,7 +9420,7 @@ async fn a_follower_keeps_a_return_awaiting_its_catalog_when_a_stitch_goes() { // Replaced, but the replacement's catalog request is never answered before it goes. let third = origin .publish( - "live", + Path::new("live").unwrap(), moq_net::origin::Route::default().with_epoch(moq_net::Epoch::mint()), ) .unwrap(); @@ -9483,7 +9484,7 @@ async fn a_follower_fails_a_stitch_onto_a_replacement_that_refuses_its_catalog() let _second = origin .publish( - "live", + Path::new("live").unwrap(), moq_net::origin::Route::default().with_epoch(moq_net::Epoch::mint()), ) .unwrap(); @@ -9545,7 +9546,7 @@ async fn a_follower_takes_its_own_instance_winning_back_for_no_replacement() { info.epoch = Some(epoch.clone()); let mut served = info.produce(); let mut catalog = crate::catalog::Producer::<()>::new(&mut served, Default::default()).unwrap(); - let pool = origin.dynamic_route("pool", route(epoch)).unwrap(); + let pool = origin.dynamic_route(Path::new("pool").unwrap(), route(epoch)).unwrap(); let consumer = served.consume(); tokio::spawn(async move { while let Ok(request) = pool.requested_broadcast().await { @@ -9556,7 +9557,7 @@ async fn a_follower_takes_its_own_instance_winning_back_for_no_replacement() { let mut follower = super::Follower::new(open_export(source).await.unwrap()).unwrap(); // A more specific route takes the path for a while, then goes. - let exact = origin.publish("pool/job", route(moq_net::Epoch::mint())).unwrap(); + let exact = origin.publish(Path::new("pool/job").unwrap(), route(moq_net::Epoch::mint())).unwrap(); assert!( tokio::time::timeout(Duration::from_secs(1), follower.next()) .await @@ -9665,7 +9666,7 @@ async fn a_follower_continues_through_a_same_epoch_handoff_after_a_gap() { let origin = crate::source::produce_origin(); let epoch = moq_net::Epoch::mint(); let route = moq_net::origin::Route::default().with_epoch(epoch.clone()); - let mut exact = origin.publish("pool/job", route.clone()).unwrap(); + let mut exact = origin.publish(Path::new("pool/job").unwrap(), route.clone()).unwrap(); let mut catalog = crate::catalog::Producer::<()>::new(&mut exact, Default::default()).unwrap(); let mut track = aac_rendition(&mut exact, &mut catalog, "a.aac"); let source = crate::source::resolved(&origin, "pool/job").await; @@ -9695,7 +9696,7 @@ async fn a_follower_continues_through_a_same_epoch_handoff_after_a_gap() { let mut served = info.produce(); let mut catalog = crate::catalog::Producer::<()>::new(&mut served, Default::default()).unwrap(); let mut track = aac_rendition(&mut served, &mut catalog, "a.aac"); - let pool = origin.dynamic_route("pool", route).unwrap(); + let pool = origin.dynamic_route(Path::new("pool").unwrap(), route).unwrap(); let consumer = served.consume(); tokio::spawn(async move { while let Ok(request) = pool.requested_broadcast().await { @@ -9735,16 +9736,16 @@ async fn a_follower_continues_through_a_same_epoch_handoff_after_a_gap() { async fn a_follower_ignores_a_covering_prefix_while_the_exact_route_serves() { let origin = crate::source::produce_origin(); let route = |epoch| moq_net::origin::Route::default().with_epoch(epoch); - let mut exact = origin.publish("pool/job", route(moq_net::Epoch::mint())).unwrap(); + let mut exact = origin.publish(Path::new("pool/job").unwrap(), route(moq_net::Epoch::mint())).unwrap(); let catalog = crate::catalog::Producer::<()>::new(&mut exact, Default::default()).unwrap(); let source = crate::source::resolved(&origin, "pool/job").await; let mut follower = super::Follower::new(open_export(source).await.unwrap()).unwrap(); let quiet = Duration::from_secs(1); - let pool = origin.dynamic_route("pool", route(moq_net::Epoch::mint())).unwrap(); + let pool = origin.dynamic_route(Path::new("pool").unwrap(), route(moq_net::Epoch::mint())).unwrap(); assert!(tokio::time::timeout(quiet, follower.next()).await.is_err(), "a start"); drop(pool); - let pool = origin.dynamic_route("pool", route(moq_net::Epoch::mint())).unwrap(); + let pool = origin.dynamic_route(Path::new("pool").unwrap(), route(moq_net::Epoch::mint())).unwrap(); assert!(tokio::time::timeout(quiet, follower.next()).await.is_err(), "a restart"); drop(pool); assert!(tokio::time::timeout(quiet, follower.next()).await.is_err(), "an end"); @@ -9803,7 +9804,7 @@ async fn a_midstream_stitch_keeps_the_old_instance_playing_until_it_switches() { let second = origin .publish( - "live", + Path::new("live").unwrap(), moq_net::origin::Route::default().with_epoch(moq_net::Epoch::mint()), ) .unwrap(); @@ -9840,7 +9841,7 @@ async fn a_nested_stitch_keeps_awaiting_the_pending_replacement() { // Replaced again, but that one's catalog request is never answered before it goes. let third = origin .publish( - "live", + Path::new("live").unwrap(), moq_net::origin::Route::default().with_epoch(moq_net::Epoch::mint()), ) .unwrap(); @@ -9989,7 +9990,7 @@ async fn a_repointed_si_entry_never_reads_a_replacement() { .collect(); // Another instance takes the path with its own `b.si`, and only then is the entry repointed. - let mut new = origin.publish("live", Default::default()).unwrap(); + let mut new = origin.publish(Path::new("live").unwrap(), Default::default()).unwrap(); let _new_b = si_track(&mut new, "b.si", &sdt_new); catalog .modify() @@ -10032,7 +10033,7 @@ async fn a_switch_reads_the_instance_it_followed() { for ms in (0..200).step_by(20) { write_aac(&mut followed_audio, ms); } - let broadcast = origin.consume().request_broadcast("live", None).await.unwrap(); + let broadcast = origin.consume().request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); // Replaced again, ten seconds ahead, before the switched export requests its track. let (mut newer, mut newer_catalog) = publish_live::<()>(&origin, Default::default()); @@ -10733,7 +10734,7 @@ async fn a_track_renamed_on_its_pid_across_returns_retires_the_one_before() { for round in 1..=4 { tokio::time::sleep(Duration::from_secs(1)).await; let (mut broadcast, mut catalog) = publish_live::(&origin, route()); - let back = origin.consume().routed_broadcast("live").await.unwrap(); + let back = origin.consume().routed_broadcast(Path::new("live").unwrap()).await.unwrap(); let stream = crate::catalog::Consumer::new(&back, Default::default()).await.unwrap(); export = export.follow(back, stream).unwrap(); drain_frames(&mut export).await; @@ -10789,7 +10790,7 @@ async fn a_track_renamed_on_its_pid_across_a_return_is_quiet_from_its_listing() tokio::time::sleep(Duration::from_secs(10)).await; let (mut broadcast, mut catalog) = publish_live::(&origin, route()); - let back = origin.consume().routed_broadcast("live").await.unwrap(); + let back = origin.consume().routed_broadcast(Path::new("live").unwrap()).await.unwrap(); let stream = crate::catalog::Consumer::new(&back, Default::default()).await.unwrap(); let mut export = export.follow(back, stream).unwrap(); drain_frames(&mut export).await; @@ -10842,7 +10843,7 @@ async fn a_switch_follows_the_last_pmt_out() { let (mut new, mut new_catalog) = publish_live::(&origin, route()); let mut audio = aac_rendition(&mut new, &mut new_catalog, "b.aac"); - let replacement = origin.consume().request_broadcast("live", None).await.unwrap(); + let replacement = origin.consume().request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); let stream = crate::catalog::Consumer::new(&replacement, Default::default()) .await .unwrap(); @@ -10870,7 +10871,7 @@ async fn a_switch_past_an_instance_that_laid_no_tables_follows_the_last_pmt_out( let origin = crate::source::produce_origin(); let route = || moq_net::origin::Route::default().with_epoch(moq_net::Epoch::mint()); let follow = async |export: Export<_>| { - let replacement = origin.consume().request_broadcast("live", None).await.unwrap(); + let replacement = origin.consume().request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); let stream = crate::catalog::Consumer::new(&replacement, Default::default()) .await .unwrap(); diff --git a/rs/moq-mux/src/container/ts/health.rs b/rs/moq-mux/src/container/ts/health.rs index e0ca98f5537..78e6dfa7614 100644 --- a/rs/moq-mux/src/container/ts/health.rs +++ b/rs/moq-mux/src/container/ts/health.rs @@ -545,6 +545,7 @@ impl Snapshot { #[cfg(test)] mod test { + use moq_net::Path; use std::collections::HashMap; use super::super::{Import, Programs, psi, stats::Snapshot}; @@ -1000,7 +1001,7 @@ mod test { #[test] fn a_multiplex_counts_each_fault_once() { let origin = crate::source::produce_origin(); - let mut programs = Programs::new(origin, "event.hang", crate::catalog::Config::default()); + let mut programs = Programs::new(origin, Path::new("event.hang").unwrap(), crate::catalog::Config::default()); let mut data = super::super::import::test::two_programs(); let mut corrupt = vec![0x47, 0x9f, 0xff, 0x10]; corrupt.resize(188, 0xff); diff --git a/rs/moq-mux/src/container/ts/programs.rs b/rs/moq-mux/src/container/ts/programs.rs index 4ff1e9291b7..ac0ba34cd2f 100644 --- a/rs/moq-mux/src/container/ts/programs.rs +++ b/rs/moq-mux/src/container/ts/programs.rs @@ -280,7 +280,7 @@ impl Programs { /// on the PMT `sections` began on `pmt_pid`. fn start(&mut self, number: u16, pmt_pid: u16, sections: SectionReassembler) -> anyhow::Result<()> { let pat = self.pat.as_ref().expect("a program waits on its PAT"); - let name = program_broadcast(self.name.as_str(), number); + let name = moq_net::PathOwned::try_from(program_broadcast(self.name.as_str(), number))?; let mut broadcast = self .origin .create_broadcast(&name) @@ -382,17 +382,19 @@ impl Programs { /// The broadcast one program of `name` publishes on: `event.hang` becomes `event/2.hang`. fn program_broadcast(name: &str, program: u16) -> String { - match catalog::CatalogFormat::detect(name) { - Some(format) => { - let stem = &name[..name.len() - format.extension().len()]; - format!("{stem}/{program}{}", format.extension()) - } - None => format!("{name}/{program}"), + let (stem, extension) = match catalog::CatalogFormat::detect(name) { + Some(format) => (&name[..name.len() - format.extension().len()], format.extension()), + None => (name, ""), + }; + match stem { + "" => format!("{program}{extension}"), + stem => format!("{stem}/{program}{extension}"), } } #[cfg(test)] mod test { + use moq_net::Path; use std::time::Duration; use super::*; @@ -405,7 +407,7 @@ mod test { #[tokio::test(start_paused = true)] async fn internal_program_abort_preserves_the_catalog_error() { let origin = crate::source::produce_origin(); - let mut programs = Programs::new(origin, "event.hang", catalog::Config::default()); + let mut programs = Programs::new(origin, Path::new("event.hang").unwrap(), catalog::Config::default()); programs.decode(&two_programs()).unwrap(); let mut consumers: Vec<_> = programs.programs.iter().map(|p| p.catalog.consume().unwrap()).collect(); programs.abort(moq_net::Error::Transport("decode failed".into())); @@ -427,6 +429,7 @@ mod test { assert_eq!(program_broadcast("event.hang", 2), "event/2.hang"); assert_eq!(program_broadcast("demo/event.msf", 7), "demo/event/7.msf"); assert_eq!(program_broadcast("event", 1), "event/1"); + assert_eq!(program_broadcast("", 1), "1"); } /// The first whole PAT in a buffer, as the parser reads it. @@ -457,7 +460,7 @@ mod test { #[tokio::test] async fn a_pat_spanning_two_packets_is_read_whole() { let origin = crate::source::produce_origin(); - let mut programs = Programs::new(origin.clone(), "event.hang", catalog::Config::default()); + let mut programs = Programs::new(origin.clone(), Path::new("event.hang").unwrap(), catalog::Config::default()); let input = fifty_programs(); for chunk in input.chunks(100) { programs.decode(chunk).unwrap(); @@ -465,7 +468,7 @@ mod test { programs.finish().unwrap(); assert_eq!(programs.programs.len(), 1, "only program 50 has a PMT"); - let consumer = origin.consume().request_broadcast("event/50.hang", None).await.unwrap(); + let consumer = origin.consume().request_broadcast(Path::new("event/50.hang").unwrap(), None).await.unwrap(); let catalog = hang::catalog::Catalog::<()>::subscribe(&consumer) .await .unwrap() @@ -481,7 +484,7 @@ mod test { #[test] fn a_corrupt_pat_starts_no_program() { let origin = crate::source::produce_origin(); - let mut programs = Programs::new(origin, "event.hang", catalog::Config::default()); + let mut programs = Programs::new(origin, Path::new("event.hang").unwrap(), catalog::Config::default()); // A null packet after each PAT confirms its sync byte. let mut null = vec![0x47, 0x1f, 0xff, 0x10]; null.resize(188, 0xff); @@ -501,7 +504,7 @@ mod test { /// How many audio renditions the catalog `path` publishes lists. async fn renditions(origin: &moq_net::origin::Producer, path: &str) -> usize { - let consumer = origin.consume().request_broadcast(path, None).await.unwrap(); + let consumer = origin.consume().request_broadcast(Path::new(path).unwrap(), None).await.unwrap(); let catalog = hang::catalog::Catalog::<()>::subscribe(&consumer) .await .unwrap() @@ -517,7 +520,7 @@ mod test { #[tokio::test] async fn a_pat_in_two_sections_starts_every_program() { let origin = crate::source::produce_origin(); - let mut programs = Programs::new(origin.clone(), "event.hang", catalog::Config::default()); + let mut programs = Programs::new(origin.clone(), Path::new("event.hang").unwrap(), catalog::Config::default()); programs.decode(&two_section_pat()).unwrap(); programs.finish().unwrap(); assert_eq!(programs.programs.len(), 2); @@ -530,7 +533,7 @@ mod test { #[tokio::test] async fn only_programs_a_pmt_describes_publish() { let origin = crate::source::produce_origin(); - let mut programs = Programs::new(origin.clone(), "event.hang", catalog::Config::default()); + let mut programs = Programs::new(origin.clone(), Path::new("event.hang").unwrap(), catalog::Config::default()); // Pairs of programs share a PMT PID, so 6 waits on the PID that starts 7. let pmt_pid = |program: u16| 0x0100 + program / 2; let mut cc = 0; @@ -569,7 +572,7 @@ mod test { #[tokio::test] async fn a_later_pat_revises_the_waiting_programs() { let origin = crate::source::produce_origin(); - let mut programs = Programs::new(origin.clone(), "event.hang", catalog::Config::default()); + let mut programs = Programs::new(origin.clone(), Path::new("event.hang").unwrap(), catalog::Config::default()); let mut cc = 0; let mut data = psi_packets(0, &mut cc, &[], &pat_section(&[(1, 0x0100), (2, 0x0101)])); let revised = psi::section(0x00, 1, 1, 0, 0, &[0x00, 0x01, 0xe2, 0x00]); @@ -595,7 +598,7 @@ mod test { #[tokio::test] async fn a_program_starts_on_the_last_pmt_in_its_packet() { let origin = crate::source::produce_origin(); - let mut programs = Programs::new(origin.clone(), "event.hang", catalog::Config::default()); + let mut programs = Programs::new(origin.clone(), Path::new("event.hang").unwrap(), catalog::Config::default()); let mut data = psi_packets(0, &mut 0, &[], &pat_section(&[(1, 0x0100)])); let mut sections = pmt_section(1, 0, &[(MP2, 0x0062, &[])]); sections.extend(pmt_section(1, 1, &[(MP2, 0x0061, &[])])); @@ -611,7 +614,7 @@ mod test { #[tokio::test] async fn a_pmt_spanning_two_packets_starts_its_program() { let origin = crate::source::produce_origin(); - let mut programs = Programs::new(origin.clone(), "event.hang", catalog::Config::default()); + let mut programs = Programs::new(origin.clone(), Path::new("event.hang").unwrap(), catalog::Config::default()); let mut data = psi_packets(0, &mut 0, &[], &pat_section(&[(1, 0x0100)])); let mut private = vec![0x80, 200]; private.resize(202, 0); @@ -630,7 +633,7 @@ mod test { #[test] fn a_corrupt_pmt_counts_once_whoever_reads_it() { let origin = crate::source::produce_origin(); - let mut programs = Programs::new(origin, "event.hang", catalog::Config::default()); + let mut programs = Programs::new(origin, Path::new("event.hang").unwrap(), catalog::Config::default()); let mut null = vec![0x47, 0x1f, 0xff, 0x10]; null.resize(188, 0xff); let pmt = |program| pmt_section(program, 0, &[(MP2, 0x0060 + program, &[])]); @@ -647,7 +650,7 @@ mod test { assert_eq!(programs.stats().crc_error, 4); let origin = crate::source::produce_origin(); - let mut programs = Programs::new(origin, "event.hang", catalog::Config::default()); + let mut programs = Programs::new(origin, Path::new("event.hang").unwrap(), catalog::Config::default()); let mut cc = 0; let mut data = psi_packets(0, &mut cc, &[], &pat_section(&[(1, 0x0100), (2, 0x0200)])); data.extend(psi_packets(0x0100, &mut 0, &[], &pmt(1))); @@ -661,7 +664,7 @@ mod test { // The same move landing while the corrupt section is partway in: the program it moved // never saw that section begin, so the scan counts it. let origin = crate::source::produce_origin(); - let mut programs = Programs::new(origin, "event.hang", catalog::Config::default()); + let mut programs = Programs::new(origin, Path::new("event.hang").unwrap(), catalog::Config::default()); let mut cc = 0; let mut data = psi_packets(0, &mut cc, &[], &pat_section(&[(1, 0x0100), (2, 0x0200)])); data.extend(psi_packets(0x0100, &mut 0, &[], &pmt(1))); @@ -683,7 +686,7 @@ mod test { // After that move, a section start abandons the partial for another split corrupt // section, which the moved program reads from its start, so it alone counts it. let origin = crate::source::produce_origin(); - let mut programs = Programs::new(origin, "event.hang", catalog::Config::default()); + let mut programs = Programs::new(origin, Path::new("event.hang").unwrap(), catalog::Config::default()); let mut cc = 0; let mut data = psi_packets(0, &mut cc, &[], &pat_section(&[(1, 0x0100), (2, 0x0200)])); data.extend(psi_packets(0x0100, &mut 0, &[], &pmt(1))); @@ -701,7 +704,7 @@ mod test { // A corrupt section begun in the packet that starts a program sharing the PID: the new // program reads that packet, so it alone counts the section. let origin = crate::source::produce_origin(); - let mut programs = Programs::new(origin, "event.hang", catalog::Config::default()); + let mut programs = Programs::new(origin, Path::new("event.hang").unwrap(), catalog::Config::default()); let mut data = psi_packets(0, &mut 0, &[], &pat_section(&[(1, 0x0100), (2, 0x0100)])); let mut sections = pmt(1); sections.extend(corrupt(pmt_section(2, 0, &[(MP2, 0x0071, &private)]))); @@ -713,7 +716,7 @@ mod test { // A waiting program's PMT PID that a started program reads only as media: no program // reassembles PMTs there, so the scan counts the corrupt section. let origin = crate::source::produce_origin(); - let mut programs = Programs::new(origin, "event.hang", catalog::Config::default()); + let mut programs = Programs::new(origin, Path::new("event.hang").unwrap(), catalog::Config::default()); let mut data = psi_packets(0, &mut 0, &[], &pat_section(&[(1, 0x0100), (2, 0x0061)])); data.extend(psi_packets(0x0100, &mut 0, &[], &pmt(1))); data.extend(psi_packets(0x0061, &mut 0, &[], &corrupt(pmt(2)))); @@ -727,7 +730,7 @@ mod test { #[test] fn every_program_mints_its_own_epoch() { let origin = crate::source::produce_origin(); - let mut programs = Programs::new(origin, "event.hang", catalog::Config::default()); + let mut programs = Programs::new(origin, Path::new("event.hang").unwrap(), catalog::Config::default()); programs.decode(&two_section_pat()).unwrap(); programs.finish().unwrap(); let epochs: Vec<_> = programs @@ -745,7 +748,7 @@ mod test { #[test] fn a_program_announces_once_it_declares_its_tracks() { let origin = crate::source::produce_origin(); - let mut programs = Programs::new(origin, "event.hang", catalog::Config::default()); + let mut programs = Programs::new(origin, Path::new("event.hang").unwrap(), catalog::Config::default()); let input = two_programs(); let mut packets = input.chunks(188); while programs.programs.is_empty() { @@ -777,7 +780,7 @@ mod test { #[test] fn input_ending_before_a_pat_fails() { let origin = crate::source::produce_origin(); - let mut programs = Programs::new(origin, "event.hang", catalog::Config::default()); + let mut programs = Programs::new(origin, Path::new("event.hang").unwrap(), catalog::Config::default()); let mut null = vec![0x47, 0x1f, 0xff, 0x10]; null.resize(188, 0xff); programs.decode(&null).unwrap(); @@ -790,7 +793,7 @@ mod test { #[test] fn input_ending_after_pmts_but_before_media_fails_unannounced() { let origin = crate::source::produce_origin(); - let mut programs = Programs::new(origin, "event.hang", catalog::Config::default()); + let mut programs = Programs::new(origin, Path::new("event.hang").unwrap(), catalog::Config::default()); let input = two_programs(); programs.decode(&input[..3 * 188]).unwrap(); @@ -811,7 +814,7 @@ mod test { #[test] fn a_partial_pat_does_not_hold_the_multiplex() { let origin = crate::source::produce_origin(); - let mut programs = Programs::new(origin, "event.hang", catalog::Config::default()); + let mut programs = Programs::new(origin, Path::new("event.hang").unwrap(), catalog::Config::default()); programs.decode(&fifty_programs()[..188]).unwrap(); let mut null = vec![0x47, 0x1f, 0xff, 0x10]; null.resize(188, 0xff); @@ -827,7 +830,7 @@ mod test { #[test] fn a_corrupt_pat_beside_a_good_one_counts_once() { let origin = crate::source::produce_origin(); - let mut programs = Programs::new(origin, "event.hang", catalog::Config::default()); + let mut programs = Programs::new(origin, Path::new("event.hang").unwrap(), catalog::Config::default()); let mut sections = corrupt(pat_section(&[(1, 0x0100)])); sections.extend(pat_section(&[(1, 0x0100)])); let mut data = psi_packets(0, &mut 0, &[], §ions); @@ -850,7 +853,7 @@ mod test { pkt }; let origin = crate::source::produce_origin(); - let mut programs = Programs::new(origin, "event.hang", catalog::Config::default()); + let mut programs = Programs::new(origin, Path::new("event.hang").unwrap(), catalog::Config::default()); let pmt = |program: u16| { psi_packets( program << 8, @@ -874,7 +877,7 @@ mod test { #[tokio::test] async fn every_program_publishes_its_own_broadcast() { let origin = crate::source::produce_origin(); - let mut programs = Programs::new(origin.clone(), "event.hang", catalog::Config::default()); + let mut programs = Programs::new(origin.clone(), Path::new("event.hang").unwrap(), catalog::Config::default()); let input = two_programs(); let before = moq_clock::wall(); @@ -888,7 +891,7 @@ mod test { let after = moq_clock::wall(); for (path, fills) in [("event/1.hang", [0xAA, 0xBB]), ("event/2.hang", [0xCC, 0xDD])] { - let consumer = origin.consume().request_broadcast(path, None).await.unwrap(); + let consumer = origin.consume().request_broadcast(Path::new(path).unwrap(), None).await.unwrap(); let catalog = hang::catalog::Catalog::<()>::subscribe(&consumer) .await .unwrap() diff --git a/rs/moq-mux/src/follow.rs b/rs/moq-mux/src/follow.rs index 9823777dd5d..75bd44ac8fc 100644 --- a/rs/moq-mux/src/follow.rs +++ b/rs/moq-mux/src/follow.rs @@ -112,6 +112,7 @@ impl Instances { #[cfg(test)] mod tests { use super::*; + use moq_net::Path; use crate::source::{produce_origin, resolved}; use moq_net::path::Relative; @@ -153,13 +154,13 @@ mod tests { #[tokio::test(start_paused = true)] async fn a_follow_starts_late_and_survives_an_end() { let origin = produce_origin(); - let _catalog = origin.publish("a/pub", Default::default()).unwrap(); + let _catalog = origin.publish(Path::new("a/pub").unwrap(), Default::default()).unwrap(); settle().await; let source = resolved(&origin, "a/pub").await; let mut follow = source.follow(Some(&Relative::new("./source")), None).unwrap(); quiet(&mut follow).await; - let first = origin.publish("a/source", Default::default()).unwrap(); + let first = origin.publish(Path::new("a/source").unwrap(), Default::default()).unwrap(); let started = followed(&mut follow).await.expect("a start"); assert_eq!(started.info().path.as_str(), "a/source"); @@ -167,7 +168,7 @@ mod tests { assert!(followed(&mut follow).await.is_none(), "an end"); quiet(&mut follow).await; - let _second = origin.publish("a/source", Default::default()).unwrap(); + let _second = origin.publish(Path::new("a/source").unwrap(), Default::default()).unwrap(); let restarted = followed(&mut follow).await.expect("a start"); assert!(!restarted.is_clone(&started)); } @@ -178,8 +179,8 @@ mod tests { async fn a_follow_restarts_only_without_an_epoch() { let origin = produce_origin(); let (old_epoch, new_epoch) = (moq_net::Epoch::mint(), moq_net::Epoch::mint()); - let _catalog = origin.publish("a/pub", Default::default()).unwrap(); - let _old = origin.publish("a/source", route(&old_epoch)).unwrap(); + let _catalog = origin.publish(Path::new("a/pub").unwrap(), Default::default()).unwrap(); + let _old = origin.publish(Path::new("a/source").unwrap(), route(&old_epoch)).unwrap(); settle().await; let source = resolved(&origin, "a/pub").await; let rel = Relative::new("./source"); @@ -188,7 +189,7 @@ mod tests { let old = followed(&mut any).await.unwrap(); assert!(followed(&mut named).await.unwrap().is_clone(&old)); - let new = origin.publish("a/source", route(&new_epoch)).unwrap(); + let new = origin.publish(Path::new("a/source").unwrap(), route(&new_epoch)).unwrap(); let replaced = followed(&mut any).await.unwrap(); assert_eq!(replaced.info().epoch.as_ref(), Some(&new_epoch)); assert!(followed(&mut named).await.is_none(), "another epoch ends it"); @@ -208,13 +209,13 @@ mod tests { #[tokio::test(start_paused = true)] async fn a_follow_reads_an_epochless_route_with_an_epoch() { let origin = produce_origin(); - let _catalog = origin.publish("a/pub", Default::default()).unwrap(); + let _catalog = origin.publish(Path::new("a/pub").unwrap(), Default::default()).unwrap(); settle().await; let source = resolved(&origin, "a/pub").await; let mut named = source .follow(Some(&Relative::new("./source")), Some(&moq_net::Epoch::mint())) .unwrap(); - let _sibling = origin.publish("a/source", Default::default()).unwrap(); + let _sibling = origin.publish(Path::new("a/source").unwrap(), Default::default()).unwrap(); assert!(followed(&mut named).await.is_some()); } @@ -222,13 +223,13 @@ mod tests { #[tokio::test(start_paused = true)] async fn a_follow_of_the_catalog_keeps_its_instance() { let origin = produce_origin(); - let old = origin.publish("a/pub", Default::default()).unwrap(); + let old = origin.publish(Path::new("a/pub").unwrap(), Default::default()).unwrap(); settle().await; let source = resolved(&origin, "a/pub").await; let mut follow = source.follow(Some(&Relative::new("./pub")), None).unwrap(); assert!(followed(&mut follow).await.unwrap().is_clone(&source.broadcast())); - let _new = origin.publish("a/pub", Default::default()).unwrap(); + let _new = origin.publish(Path::new("a/pub").unwrap(), Default::default()).unwrap(); quiet(&mut follow).await; // Its end is the catalog's, which the catalog's reader sees. drop(old); diff --git a/rs/moq-mux/src/linger.rs b/rs/moq-mux/src/linger.rs index c387650b7e0..ab7d8ec0213 100644 --- a/rs/moq-mux/src/linger.rs +++ b/rs/moq-mux/src/linger.rs @@ -78,12 +78,13 @@ impl Drop for Linger { #[cfg(test)] mod tests { use super::*; + use moq_net::Path; const PATH: &str = "live"; /// A broadcast at [`PATH`] whose one track, `video`, has three finished groups. fn finished(origin: &moq_net::origin::Producer) -> (moq_net::broadcast::Producer, moq_net::track::Producer) { - let broadcast = origin.publish(PATH, moq_net::origin::Route::default()).unwrap(); + let broadcast = origin.publish(Path::new(PATH).unwrap(), moq_net::origin::Route::default()).unwrap(); let track = broadcast.create_track("video", None).unwrap(); for _ in 0..3 { let mut group = track.append_group().unwrap(); @@ -97,7 +98,7 @@ mod tests { /// Whether the origin has stopped routing [`PATH`]. async fn unroutable(origin: &moq_net::origin::Producer) -> bool { matches!( - origin.consume().request_broadcast(PATH, None).await, + origin.consume().request_broadcast(Path::new(PATH).unwrap(), None).await, Err(moq_net::Error::Unroutable) ) } @@ -112,7 +113,7 @@ mod tests { let linger = tokio::spawn(Linger::new([broadcast], track, Duration::from_secs(30)).wait()); moq_clock::sleep(Duration::from_secs(29)).await; - let late = origin.consume().request_broadcast(PATH, None).await.unwrap(); + let late = origin.consume().request_broadcast(Path::new(PATH).unwrap(), None).await.unwrap(); let video = late.track("video").unwrap(); for sequence in 0..3 { let mut group = video.fetch_group(sequence, None).await.unwrap(); diff --git a/rs/moq-mux/src/source.rs b/rs/moq-mux/src/source.rs index 665c70a441e..91e86066bd6 100644 --- a/rs/moq-mux/src/source.rs +++ b/rs/moq-mux/src/source.rs @@ -438,7 +438,7 @@ pub(crate) fn produce_origin() -> moq_net::origin::Producer { pub(crate) async fn resolved(origin: &moq_net::origin::Producer, path: &str) -> Source { let consumer = origin.consume(); let broadcast = consumer - .request_broadcast(path, None) + .request_broadcast(moq_net::Path::new(path).unwrap(), None) .await .expect("the broadcast resolves"); Source::new(consumer, broadcast) @@ -451,7 +451,7 @@ pub(crate) async fn resolved(origin: &moq_net::origin::Producer, path: &str) -> #[cfg(test)] pub(crate) async fn announced(broadcast: &moq_net::broadcast::Consumer) -> Source { let origin = produce_origin(); - let dynamic = origin.dynamic_route("", Default::default()).unwrap(); + let dynamic = origin.dynamic_route(moq_net::Path::new("").unwrap(), Default::default()).unwrap(); let served = broadcast.clone(); tokio::spawn(async move { while let Ok(request) = dynamic.requested_broadcast().await { @@ -466,6 +466,7 @@ pub(crate) async fn announced(broadcast: &moq_net::broadcast::Consumer) -> Sourc #[cfg(test)] mod tests { use super::*; + use moq_net::Path; use hang::catalog::{H264, VideoConfig}; use moq_net::path::Relative; @@ -480,10 +481,10 @@ mod tests { #[tokio::test] async fn binding_retains_a_pending_request_across_cancelled_and_repeated_reads() { let origin = produce_origin(); - let _catalog = origin.publish("pub", Default::default()).unwrap(); + let _catalog = origin.publish(Path::new("pub").unwrap(), Default::default()).unwrap(); settle().await; let source = resolved(&origin, "pub").await; - let dynamic = origin.dynamic_route("media", Default::default()).unwrap(); + let dynamic = origin.dynamic_route(Path::new("media").unwrap(), Default::default()).unwrap(); let binding = source.bind(Some(&Relative::new("media")), None).unwrap(); let request = dynamic.requested_broadcast().await.unwrap(); @@ -516,7 +517,7 @@ mod tests { #[tokio::test(start_paused = true)] async fn a_binding_waits_for_the_first_announcement_and_keeps_it() { let origin = produce_origin(); - let _catalog = origin.publish("pub", Default::default()).unwrap(); + let _catalog = origin.publish(Path::new("pub").unwrap(), Default::default()).unwrap(); settle().await; let source = resolved(&origin, "pub").await; let media = Relative::new("media"); @@ -524,11 +525,11 @@ mod tests { settle().await; assert!(binding.poll_broadcast(&kio::Waiter::noop()).is_pending()); - let first_publisher = origin.publish("media", Default::default()).unwrap(); + let first_publisher = origin.publish(Path::new("media").unwrap(), Default::default()).unwrap(); let first = binding.broadcast().await.unwrap(); assert!(!first.is_closed()); - let _second = origin.publish("media", Default::default()).unwrap(); + let _second = origin.publish(Path::new("media").unwrap(), Default::default()).unwrap(); settle().await; assert!(binding.broadcast().await.unwrap().is_clone(&first)); assert!(source.resolve(Some(&media), None).await.unwrap().is_clone(&first)); @@ -552,12 +553,12 @@ mod tests { #[tokio::test(start_paused = true)] async fn a_source_keeps_the_broadcast_it_was_built_from() { let origin = produce_origin(); - let _old = origin.publish("live", Default::default()).unwrap(); + let _old = origin.publish(Path::new("live").unwrap(), Default::default()).unwrap(); settle().await; let consumer = origin.consume(); - let first = consumer.request_broadcast("live", None).await.unwrap(); + let first = consumer.request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); - let new = origin.publish("live", Default::default()).unwrap(); + let new = origin.publish(Path::new("live").unwrap(), Default::default()).unwrap(); let _late = new.create_track("late", None).unwrap(); settle().await; let source = Source::new(consumer, first.clone()); @@ -576,8 +577,8 @@ mod tests { use crate::container::test_util::Link; let healthy = produce_origin(); - let _catalog = healthy.publish("a/pub", Default::default()).unwrap(); - let _sibling = healthy.publish("a/source", Default::default()).unwrap(); + let _catalog = healthy.publish(Path::new("a/pub").unwrap(), Default::default()).unwrap(); + let _sibling = healthy.publish(Path::new("a/source").unwrap(), Default::default()).unwrap(); let stalled = produce_origin(); let subscriber = produce_origin(); let _healthy = Link::lazy(&healthy, &subscriber, true).await; @@ -585,7 +586,7 @@ mod tests { let timeout = std::time::Duration::from_secs(5); let consumer = subscriber.consume(); - let catalog = tokio::time::timeout(timeout, consumer.routed_broadcast("a/pub")) + let catalog = tokio::time::timeout(timeout, consumer.routed_broadcast(Path::new("a/pub").unwrap())) .await .expect("the catalog resolves") .unwrap(); @@ -601,7 +602,7 @@ mod tests { let binding = source.bind(Some(&Relative::new("./late")), None).unwrap(); settle().await; assert!(binding.poll_broadcast(&kio::Waiter::noop()).is_pending()); - let _late = healthy.publish("a/late", Default::default()).unwrap(); + let _late = healthy.publish(Path::new("a/late").unwrap(), Default::default()).unwrap(); let late = tokio::time::timeout(timeout, binding.broadcast()) .await .expect("the later sibling resolves") @@ -613,8 +614,8 @@ mod tests { #[tokio::test(start_paused = true)] async fn a_source_keeps_the_sibling_it_resolved() { let origin = produce_origin(); - let _catalog = origin.publish("a/pub", Default::default()).unwrap(); - let _old = origin.publish("a/source", Default::default()).unwrap(); + let _catalog = origin.publish(Path::new("a/pub").unwrap(), Default::default()).unwrap(); + let _old = origin.publish(Path::new("a/source").unwrap(), Default::default()).unwrap(); settle().await; let source = resolved(&origin, "a/pub").await; let sibling = Relative::new("./source"); @@ -623,7 +624,7 @@ mod tests { .await .expect("the sibling resolves"); - let new = origin.publish("a/source", Default::default()).unwrap(); + let new = origin.publish(Path::new("a/source").unwrap(), Default::default()).unwrap(); let _late = new.create_track("late", None).unwrap(); settle().await; assert!(source.resolve(Some(&sibling), None).await.unwrap().is_clone(&first)); @@ -648,8 +649,8 @@ mod tests { async fn a_reference_epoch_must_match_the_resolved_sibling() { let origin = produce_origin(); let (catalog, sibling, other) = (moq_net::Epoch::mint(), moq_net::Epoch::mint(), moq_net::Epoch::mint()); - let _catalog = origin.publish("a/pub", route(&catalog)).unwrap(); - let _sibling = origin.publish("a/source", route(&sibling)).unwrap(); + let _catalog = origin.publish(Path::new("a/pub").unwrap(), route(&catalog)).unwrap(); + let _sibling = origin.publish(Path::new("a/source").unwrap(), route(&sibling)).unwrap(); settle().await; let source = resolved(&origin, "a/pub").await; let rel = Relative::new("./source"); @@ -671,9 +672,9 @@ mod tests { async fn a_replaced_sibling_fails_a_reference_to_the_old_epoch() { let origin = produce_origin(); let (old_epoch, new_epoch) = (moq_net::Epoch::mint(), moq_net::Epoch::mint()); - let _catalog = origin.publish("a/pub", Default::default()).unwrap(); - let _old = origin.publish("a/source", route(&old_epoch)).unwrap(); - let _new = origin.publish("a/source", route(&new_epoch)).unwrap(); + let _catalog = origin.publish(Path::new("a/pub").unwrap(), Default::default()).unwrap(); + let _old = origin.publish(Path::new("a/source").unwrap(), route(&old_epoch)).unwrap(); + let _new = origin.publish(Path::new("a/source").unwrap(), route(&new_epoch)).unwrap(); settle().await; let source = resolved(&origin, "a/pub").await; let rel = Relative::new("./source"); @@ -693,14 +694,14 @@ mod tests { async fn a_conflicting_epoch_cannot_replace_a_pin() { let origin = produce_origin(); let (old_epoch, new_epoch) = (moq_net::Epoch::mint(), moq_net::Epoch::mint()); - let _catalog = origin.publish("a/pub", Default::default()).unwrap(); - let _old = origin.publish("a/source", route(&old_epoch)).unwrap(); + let _catalog = origin.publish(Path::new("a/pub").unwrap(), Default::default()).unwrap(); + let _old = origin.publish(Path::new("a/source").unwrap(), route(&old_epoch)).unwrap(); settle().await; let source = resolved(&origin, "a/pub").await; let rel = Relative::new("./source"); let first = source.resolve(Some(&rel), Some(&old_epoch)).await.unwrap(); - let _new = origin.publish("a/source", route(&new_epoch)).unwrap(); + let _new = origin.publish(Path::new("a/source").unwrap(), route(&new_epoch)).unwrap(); settle().await; // A rendition added later names the replacement: it fails, and the pin stays. let binding = source.bind(Some(&rel), Some(&new_epoch)).unwrap(); @@ -727,7 +728,7 @@ mod tests { async fn a_self_reference_epoch_checks_the_catalog_instance() { let origin = produce_origin(); let (catalog, other) = (moq_net::Epoch::mint(), moq_net::Epoch::mint()); - let _catalog = origin.publish("a/pub", route(&catalog)).unwrap(); + let _catalog = origin.publish(Path::new("a/pub").unwrap(), route(&catalog)).unwrap(); settle().await; let source = resolved(&origin, "a/pub").await; @@ -748,8 +749,8 @@ mod tests { #[tokio::test(start_paused = true)] async fn an_epochless_route_reads_an_epoch_reference_best_effort() { let origin = produce_origin(); - let _catalog = origin.publish("a/pub", Default::default()).unwrap(); - let _sibling = origin.publish("a/source", Default::default()).unwrap(); + let _catalog = origin.publish(Path::new("a/pub").unwrap(), Default::default()).unwrap(); + let _sibling = origin.publish(Path::new("a/source").unwrap(), Default::default()).unwrap(); settle().await; let source = resolved(&origin, "a/pub").await; let epoch = moq_net::Epoch::mint(); @@ -764,11 +765,11 @@ mod tests { #[tokio::test(start_paused = true)] async fn self_references_keep_the_catalog_broadcast_after_replacement() { let origin = produce_origin(); - let old = origin.publish("a/live", Default::default()).unwrap(); + let old = origin.publish(Path::new("a/live").unwrap(), Default::default()).unwrap(); settle().await; let source = resolved(&origin, "a/live").await; drop(old); - let _replacement = origin.publish("a/live", Default::default()).unwrap(); + let _replacement = origin.publish(Path::new("a/live").unwrap(), Default::default()).unwrap(); settle().await; for reference in [None, Some(""), Some("live"), Some("./live"), Some("../a/live")] { @@ -784,7 +785,7 @@ mod tests { #[tokio::test] async fn no_override_targets_catalog_broadcast() { let origin = produce_origin(); - let _producer = origin.create_broadcast("a/pub").unwrap(); + let _producer = origin.create_broadcast(Path::new("a/pub").unwrap()).unwrap(); _producer.announce(Default::default()).unwrap(); settle().await; @@ -809,7 +810,7 @@ mod tests { #[tokio::test] async fn subscribe_track_resolves_catalog_broadcast() { let origin = produce_origin(); - let producer = origin.create_broadcast("a/pub").unwrap(); + let producer = origin.create_broadcast(Path::new("a/pub").unwrap()).unwrap(); producer.announce(Default::default()).unwrap(); // The track must exist for the subscription to resolve (SUBSCRIBE_OK). let _video = producer.create_track("video", None).unwrap(); @@ -825,7 +826,7 @@ mod tests { #[tokio::test] async fn self_reference_targets_catalog_broadcast() { let origin = produce_origin(); - let producer = origin.create_broadcast("a/pub").unwrap(); + let producer = origin.create_broadcast(Path::new("a/pub").unwrap()).unwrap(); producer.announce(Default::default()).unwrap(); let _video = producer.create_track("video", None).unwrap(); settle().await; @@ -844,12 +845,12 @@ mod tests { async fn escaping_reference_is_rejected() { let origin = produce_origin(); - let catalog = origin.create_broadcast("a/pub").unwrap(); + let catalog = origin.create_broadcast(Path::new("a/pub").unwrap()).unwrap(); catalog.announce(Default::default()).unwrap(); let _catalog_video = catalog.create_track("video", None).unwrap(); // The broadcast an escaping reference would land on if it clamped at the root. - let clamped = origin.create_broadcast("elsewhere").unwrap(); + let clamped = origin.create_broadcast(Path::new("elsewhere").unwrap()).unwrap(); clamped.announce(Default::default()).unwrap(); let _clamped_video = clamped.create_track("video", None).unwrap(); settle().await; @@ -884,7 +885,7 @@ mod tests { /// A source over a broadcast created at `a/pub`, built without awaiting the origin. fn created(origin: &moq_net::origin::Producer) -> Source { - let broadcast = origin.create_broadcast("a/pub").unwrap().consume(); + let broadcast = origin.create_broadcast(Path::new("a/pub").unwrap()).unwrap().consume(); Source::new(origin.consume(), broadcast) } @@ -963,10 +964,10 @@ mod tests { async fn subscribe_track_resolves_referenced_broadcast() { let origin = produce_origin(); - let _catalog = origin.create_broadcast("a/pub").unwrap(); + let _catalog = origin.create_broadcast(Path::new("a/pub").unwrap()).unwrap(); _catalog.announce(Default::default()).unwrap(); - let referenced = origin.create_broadcast("a/source").unwrap(); + let referenced = origin.create_broadcast(Path::new("a/source").unwrap()).unwrap(); referenced.announce(Default::default()).unwrap(); let _video = referenced.create_track("video", None).unwrap(); settle().await; @@ -985,10 +986,10 @@ mod tests { async fn dot_resolves_output_parent() { let origin = produce_origin(); - let _catalog = origin.create_broadcast("a/source/transcode").unwrap(); + let _catalog = origin.create_broadcast(Path::new("a/source/transcode").unwrap()).unwrap(); _catalog.announce(Default::default()).unwrap(); - let referenced = origin.create_broadcast("a/source").unwrap(); + let referenced = origin.create_broadcast(Path::new("a/source").unwrap()).unwrap(); referenced.announce(Default::default()).unwrap(); let _video = referenced.create_track("video", None).unwrap(); settle().await; @@ -1005,10 +1006,10 @@ mod tests { async fn dot_resolves_one_segment_catalog_to_root() { let origin = produce_origin(); - let _catalog = origin.create_broadcast("top").unwrap(); + let _catalog = origin.create_broadcast(Path::new("top").unwrap()).unwrap(); _catalog.announce(Default::default()).unwrap(); - let root = origin.create_broadcast("").unwrap(); + let root = origin.create_broadcast(Path::new("").unwrap()).unwrap(); root.announce(Default::default()).unwrap(); let _video = root.create_track("video", None).unwrap(); settle().await; diff --git a/rs/moq-relay/src/auth.rs b/rs/moq-relay/src/auth.rs index 2490337aa91..799c4ae3ef5 100644 --- a/rs/moq-relay/src/auth.rs +++ b/rs/moq-relay/src/auth.rs @@ -433,28 +433,46 @@ impl Token { /// The token keeps the patterns the grant yields: the origin scopes by any /// pattern union, so `alice`, `*/chat`, and `alice/**` each mean exactly what /// they say. - pub fn new(path: &str, grant: &Grant) -> Self { - let root = grant.root.as_deref().unwrap_or(path); - Self { + /// + /// The dialed path is a URL path, whose one leading `/` is syntax rather than a + /// segment. An empty segment anywhere else is refused, not collapsed: a malformed + /// dialed path with [`Error::Request`], and a malformed grant with [`Error::Unavailable`]. + pub fn new(path: &str, grant: &Grant) -> Result { + let granted = |field: &str, value: &str| { + Path::new(value) + .map(|path| path.to_owned()) + .map_err(|err| Error::Unavailable(format!("grant {field} {value:?}: {err}"))) + }; + let root = match &grant.root { + Some(root) => granted("root", root)?, + None => { + let dialed = path.strip_prefix('/').unwrap_or(path); + Path::new(dialed) + .map_err(|err| Error::Request(format!("path {path:?}: {err}")))? + .to_owned() + } + }; + Ok(Self { path: path.to_string(), - root: Path::new(root).to_owned(), + root, mounts: grant .mounts .iter() - .map(|(at, target)| (Path::new(at).to_owned(), Path::new(target).to_owned())) - .collect(), + .map(|(at, target)| Ok((granted("mount", at)?, granted("mount", target)?))) + .collect::>()?, subscribe: grant.subscribe.clone(), publish: grant.publish.clone(), - tier: crate::configured_tier(grant.tier.clone()), - label: Path::new(grant.label.as_deref().unwrap_or_default()).to_owned(), + tier: crate::configured_tier(grant.tier.clone()) + .map_err(|err| Error::Unavailable(format!("grant tier: {err}")))?, + label: granted("label", grant.label.as_deref().unwrap_or_default())?, peer: grant.peer, upstream: grant.upstream, - } + }) } /// Rebuild the token from a re-checked grant, relative to the same dialed path, /// so a grant that drops its `root` alias resolves back to what was dialed. - pub(crate) fn recheck(&self, grant: &Grant) -> Self { + pub(crate) fn recheck(&self, grant: &Grant) -> Result { Self::new(&self.path, grant) } @@ -499,23 +517,23 @@ struct Source { impl Lease { /// Hold `consumer` for a session that dialed `path`, reducing its grant to /// what the origin scopes by. - pub fn new(path: &str, consumer: lease::Consumer) -> Self { + pub fn new(path: &str, consumer: lease::Consumer) -> Result { let grant = consumer.grant(); Self::granted(path, &grant, consumer) } /// Hold `consumer` with its token built from `grant`, a snapshot of it. A later /// update still reaches [`Self::ended`] as a change, which re-checks it. - fn granted(path: &str, grant: &Grant, consumer: lease::Consumer) -> Self { - Self { + fn granted(path: &str, grant: &Grant, consumer: lease::Consumer) -> Result { + Ok(Self { refresh: None, source: None, - token: Token::new(path, grant), + token: Token::new(path, grant)?, expires: grant.deadline(), consumer, session: None, stats: Default::default(), - } + }) } /// Take AUTH decisions before the protocol driver chooses its default acceptor. @@ -597,7 +615,9 @@ impl Lease { if let Err(reason) = still_valid(&grant) { return reason; } - let fresh = self.token.recheck(&grant); + let Ok(fresh) = self.token.recheck(&grant) else { + return "grant names an invalid path".into(); + }; if fresh.root != self.token.root { return lease::Reason::Narrowed; } @@ -869,7 +889,7 @@ impl Auth { // Build the token from the grant the admission checked: re-reading it could // pick up an update that skipped the check. let (consumer, grant) = self.decide(request.clone()).await?; - let mut lease = Lease::granted(&request.path, &grant, consumer); + let mut lease = Lease::granted(&request.path, &grant, consumer)?; lease.source = Some(Source { auth: self.clone(), request, @@ -897,7 +917,7 @@ impl Auth { /// Admit a session on a grant decided locally, bypassing the server: the LAN /// mesh credential, which the relay minted for itself. - pub(crate) fn admit_fixed(&self, path: &str, grant: Grant) -> Lease { + pub(crate) fn admit_fixed(&self, path: &str, grant: Grant) -> Result { Lease::new(path, lease::Consumer::fixed(grant)) } } @@ -1097,7 +1117,7 @@ mod tests { async fn an_invalid_label_at_revalidation_ends_the_lease() { let grant = Grant::new(moq_net::Pattern::all(), moq_net::Pattern::all()); let (producer, consumer) = lease::Producer::new(grant.clone()); - let mut lease = Lease::new("/room", consumer); + let mut lease = Lease::new("/room", consumer).unwrap(); let mut wildcard = grant; wildcard.label = Some("project/*".into()); producer.update(wildcard); @@ -1197,7 +1217,7 @@ mod tests { ("/rooms", "rooms", &[], &["chat"]), ] { let lease = auth.admit(auth.request(moq_auth::Transport::Quic, path)).await.unwrap(); - assert_eq!(lease.token().root, Path::new(root).to_owned(), "{path}"); + assert_eq!(lease.token().root, Path::new(root).unwrap().to_owned(), "{path}"); assert_eq!(lease.token().publish, patterns(publish), "{path}"); assert_eq!(lease.token().subscribe, patterns(subscribe), "{path}"); } @@ -1257,7 +1277,7 @@ mod tests { }); for request in [anonymous, certificate] { let lease = auth.admit(request).await.unwrap(); - assert_eq!(lease.token().root, Path::new("anon/room").to_owned()); + assert_eq!(lease.token().root, Path::new("anon/room").unwrap().to_owned()); assert_eq!(lease.token().subscribe, patterns(&["**"])); assert_eq!(lease.token().tier, Tier::default()); } @@ -1322,7 +1342,7 @@ mod tests { }; let admit = async { let lease = auth.admit(request()).await.expect("granted"); - assert_eq!(lease.token().root, Path::new("anon/room").to_owned()); + assert_eq!(lease.token().root, Path::new("anon/room").unwrap().to_owned()); assert!(matches!(auth.admit(request()).await, Err(Error::Refused(_)))); assert!(matches!(auth.admit(request()).await, Err(Error::Refused(_)))); assert!(matches!(auth.admit(request()).await, Err(Error::Unavailable(_)))); @@ -1363,7 +1383,7 @@ mod tests { let start = moq_clock::now(); let mut grant = Grant::new(patterns(&["**"]), patterns(&["**"])); grant.expires = Some(moq_clock::wall() + Duration::from_secs(10)); - let mut lease = Lease::new("/room", lease::Consumer::fixed(grant)); + let mut lease = Lease::new("/room", lease::Consumer::fixed(grant)).unwrap(); for _ in 0..9 { assert!(moq_clock::timeout(Duration::from_secs(1), lease.ended()).await.is_err()); } @@ -1384,7 +1404,7 @@ mod tests { assert!(matches!(grant.validate(), Err(moq_auth::Error::GrantExpired))); let start = moq_clock::now(); - let mut lease = Lease::new("/room", lease::Consumer::fixed(grant)); + let mut lease = Lease::new("/room", lease::Consumer::fixed(grant)).unwrap(); assert_eq!(lease.ended().await, lease::Reason::Expired); assert_eq!(moq_clock::now(), start, "no grace after expiry"); } @@ -1395,15 +1415,15 @@ mod tests { grant.root = Some("pid/room".into()); grant.tier = Some("gold".into()); grant.label = Some("project/key/123".into()); - let token = Token::new("/vanity/room", &grant); - assert_eq!(token.root, Path::new("pid/room").to_owned()); + let token = Token::new("/vanity/room", &grant).unwrap(); + assert_eq!(token.root, Path::new("pid/room").unwrap().to_owned()); assert_eq!(token.publish, patterns(&["alice/**"])); assert_eq!(token.subscribe, patterns(&["**"])); - assert_eq!(token.tier, Tier::new("gold")); - assert_eq!(token.label, Path::new("project/key/123").to_owned()); + assert_eq!(token.tier, Tier::new(Path::new("gold").unwrap())); + assert_eq!(token.label, Path::new("project/key/123").unwrap().to_owned()); let patterns = patterns(&["*/chat", "alice", ""]); - let token = Token::new("/", &Grant::new(patterns.clone(), Patterns::new())); + let token = Token::new("/", &Grant::new(patterns.clone(), Patterns::new())).unwrap(); assert_eq!(token.publish, patterns); assert!( token.label.is_empty(), @@ -1413,15 +1433,15 @@ mod tests { #[test] fn a_narrower_recheck_is_not_covered() { - let wide = Token::new("/room", &Grant::new(patterns(&["**"]), patterns(&["**"]))); - let narrow = Token::new("/room", &Grant::new(patterns(&["alice/**"]), patterns(&["**"]))); - let moved = Token::new("/other", &Grant::new(patterns(&["**"]), patterns(&["**"]))); + let wide = Token::new("/room", &Grant::new(patterns(&["**"]), patterns(&["**"]))).unwrap(); + let narrow = Token::new("/room", &Grant::new(patterns(&["alice/**"]), patterns(&["**"]))).unwrap(); + let moved = Token::new("/other", &Grant::new(patterns(&["**"]), patterns(&["**"]))).unwrap(); let mut mounted = Grant::new(patterns(&["**"]), patterns(&["**"])); mounted.mounts.insert(".svc".into(), ".svc/room".into()); - let mounted = Token::new("/room", &mounted); + let mounted = Token::new("/room", &mounted).unwrap(); assert_eq!( mounted.mounts, - [(Path::new(".svc").to_owned(), Path::new(".svc/room").to_owned())] + [(Path::new(".svc").unwrap().to_owned(), Path::new(".svc/room").unwrap().to_owned())] ); assert!(wide.covered_by(&wide)); assert!(narrow.covered_by(&wide)); @@ -1438,7 +1458,7 @@ mod tests { async fn a_recheck_that_flips_the_link_closes() { let grant = Grant::new(patterns(&["**"]), patterns(&["**"])); let (producer, consumer) = lease::Producer::new(grant.clone()); - let mut lease = Lease::new("/", consumer); + let mut lease = Lease::new("/", consumer).unwrap(); assert!(!lease.token().peer); let mut peer = grant; @@ -1449,7 +1469,7 @@ mod tests { // Routes already offered to (or withheld from) the session were filtered // by whether it is upstream, so flipping that closes it too. let (producer, consumer) = lease::Producer::new(peer.clone()); - let mut lease = Lease::new("/", consumer); + let mut lease = Lease::new("/", consumer).unwrap(); let mut upstream = peer; upstream.upstream = true; producer.update(upstream); @@ -1461,13 +1481,13 @@ mod tests { let everything = || Grant::new(patterns(&["**"]), patterns(&["**"])); let mut aliased = everything(); aliased.root = Some("pid/room".into()); - let token = Token::new("/vanity/room", &aliased); - assert_eq!(token.root, Path::new("pid/room").to_owned()); + let token = Token::new("/vanity/room", &aliased).unwrap(); + assert_eq!(token.root, Path::new("pid/room").unwrap().to_owned()); // The same alias still names the same root. - assert_eq!(token.recheck(&aliased).root, token.root); + assert_eq!(token.recheck(&aliased).unwrap().root, token.root); // A grant without the alias is relative to what was dialed, not to the old root. - assert_eq!(token.recheck(&everything()).root, Path::new("vanity/room").to_owned()); + assert_eq!(token.recheck(&everything()).unwrap().root, Path::new("vanity/room").unwrap().to_owned()); } } diff --git a/rs/moq-relay/src/auth/admission_tests.rs b/rs/moq-relay/src/auth/admission_tests.rs index 1bec4316f4a..d24f5268766 100644 --- a/rs/moq-relay/src/auth/admission_tests.rs +++ b/rs/moq-relay/src/auth/admission_tests.rs @@ -1,5 +1,6 @@ //! Admission and lease behavior for a gateway embedding the relay. +use moq_net::Path; use crate::{auth, cluster}; use moq_auth::{Grant, Pattern, Patterns, Role, Transport, lease}; @@ -111,7 +112,7 @@ async fn a_moved_gateway_tier_retags_its_stats() { .snapshot() .sessions() .into_iter() - .find(|(t, _)| *t == stats::Tier::new(tier)) + .find(|(t, _)| *t == stats::Tier::new(Path::new(tier).unwrap())) .map_or(0, |(_, presence)| presence.active()) }; diff --git a/rs/moq-relay/src/auth/refresh.rs b/rs/moq-relay/src/auth/refresh.rs index 61ebe01a16f..7a3c55fb7e6 100644 --- a/rs/moq-relay/src/auth/refresh.rs +++ b/rs/moq-relay/src/auth/refresh.rs @@ -154,7 +154,9 @@ impl Refresh { } fn valid(&self, grant: &Grant) -> bool { - let fresh = self.admitted.recheck(grant); + let Ok(fresh) = self.admitted.recheck(grant) else { + return false; + }; super::still_valid(grant).is_ok() && fresh.root == self.admitted.root && fresh.mounts == self.admitted.mounts @@ -379,7 +381,7 @@ impl Refresh { } } Event::Changed(id, Change::Grant(grant)) if self.valid(&grant) => { - let fresh = self.admitted.recheck(&grant); + let fresh = self.admitted.recheck(&grant).expect("valid() rechecked the grant"); let credential = self.credentials.get_mut(&id).expect("observed credential"); credential.expires = grant.deadline(); if credential.initial { @@ -464,6 +466,7 @@ fn with_jwt(query: Option<&str>, token: &str) -> String { #[expect(clippy::disallowed_methods, reason = "tests read the host clock directly")] mod tests { use super::*; + use moq_net::Path; use futures::FutureExt; use std::time::Duration; @@ -595,8 +598,8 @@ mod tests { async fn refused_before_setup(change: fn(&mut moq_auth::Grant)) { let (producer, consumer) = lease::Producer::new(grant("a/**", 3000)); let registry = moq_net::stats::Registry::new(Default::default()); - let stats = registry.tier(moq_net::stats::Tier::default()).session("room"); - let lease = super::super::Lease::new("/room", consumer).with_stats(stats.clone()); + let stats = registry.tier(moq_net::stats::Tier::default()).session(Path::new("room").unwrap()); + let lease = super::super::Lease::new("/room", consumer).unwrap().with_stats(stats.clone()); let (client_transport, server) = transports().await; let now = moq_net::time::Instant::now(); let origin = moq_tokio::origin::spawn(); @@ -699,8 +702,8 @@ mod tests { ] { let (producer, consumer) = lease::Producer::new(grant("a/**", 3000)); let registry = moq_net::stats::Registry::new(Default::default()); - let stats = registry.tier(moq_net::stats::Tier::default()).session("room"); - let lease = super::super::Lease::new("/room", consumer).with_stats(stats); + let stats = registry.tier(moq_net::stats::Tier::default()).session(Path::new("room").unwrap()); + let lease = super::super::Lease::new("/room", consumer).unwrap().with_stats(stats); let (client, supervising) = sessions(lease).await; producer.revoke(reason.clone()); supervising.await.unwrap(); diff --git a/rs/moq-relay/src/cluster.rs b/rs/moq-relay/src/cluster.rs index 58e3f6d69e3..a5740a6c7c2 100644 --- a/rs/moq-relay/src/cluster.rs +++ b/rs/moq-relay/src/cluster.rs @@ -1136,6 +1136,9 @@ pub struct Cluster { /// runtime so `/metrics` sees every refusal on the node. pub(crate) refusals: crate::refusals::Refusals, + /// Billing tier cluster-peer traffic records under, parsed from `--cluster-tier`. + tier: Tier, + /// Hands out the `conn` id every session logs under, inbound and outbound /// alike, so one id space covers the whole process and an id in the `/nodes` /// view always points at the same session in the logs. @@ -1225,6 +1228,7 @@ impl Cluster { }; let deprecated = config.deprecated(); anyhow::ensure!(deprecated.is_empty(), "{deprecated}"); + let tier = crate::configured_tier(config.tier.clone()).context("invalid --cluster-tier")?; // Reject a repeated static identity with conflicting policy up front, // matching the `--cluster-api-url` validation, instead of silently // keeping the first entry when dials spawn. @@ -1264,6 +1268,7 @@ impl Cluster { lan_auth: Arc::new(std::sync::OnceLock::new()), nodes, refusals: Default::default(), + tier, connection_ids: Arc::default(), critical, origin, @@ -1433,7 +1438,7 @@ impl Cluster { /// Billing tier cluster-peer traffic records under (`--cluster-tier`). /// An absent or empty label selects the default unprefixed tier. fn cluster_tier(&self) -> Tier { - crate::configured_tier(self.config.tier.clone()) + self.tier.clone() } /// Returns an [`origin::Producer`] scoped to this session's subscribe permissions. @@ -2028,7 +2033,7 @@ impl Cluster { }; // The link is one presence across reconnects: each session it dials records how it // ended, and the last one to end decides whether the link failed. - let stats = self.stats.tier(self.cluster_tier()).session(""); + let stats = self.stats.tier(self.cluster_tier()).session(moq_net::Path::empty()); let mut client = client .with_publisher(origin.consume().with_hidden(true)) .with_subscriber(origin) @@ -2317,6 +2322,7 @@ impl Default for Redial { #[expect(clippy::disallowed_methods, reason = "tests read the host clock directly")] mod tests { use super::*; + use moq_net::Path; use crate::Config as RelayConfig; #[tokio::test] @@ -2333,7 +2339,7 @@ mod tests { grant.upstream = upstream; let (_producer, consumer) = moq_auth::lease::Producer::new(grant); // A cluster-looking path alone never selects the peer policy. - let lease = auth::Lease::new("/.cluster/untrusted", consumer); + let lease = auth::Lease::new("/.cluster/untrusted", consumer).unwrap(); let limits = cluster.limits(&lease); assert_eq!((limits.announces, limits.requests), expected); } @@ -2344,8 +2350,8 @@ mod tests { #[tokio::test] async fn only_a_peer_grant_discovers_hidden_routes() { let cluster = new_cluster(Config::default()).expect("cluster"); - let _hidden = cluster.origin.publish(".stats/node", origin::Route::default()); - let _visible = cluster.origin.publish("room", origin::Route::default()); + let _hidden = cluster.origin.publish(Path::new(".stats/node").unwrap(), origin::Route::default()); + let _visible = cluster.origin.publish(Path::new("room").unwrap(), origin::Route::default()); let mut request = moq_auth::Request::new("test", moq_auth::Transport::Quic, "/"); request.tls = Some(moq_auth::Peer { name: "edge0".into(), @@ -2357,7 +2363,7 @@ mod tests { for session in [false, true] { let mut grant = moq_auth::Grant::new(moq_auth::Pattern::all(), moq_auth::Pattern::all()); grant.peer = peer; - let lease = auth::Lease::new("/", moq_auth::lease::Consumer::fixed(grant)); + let lease = auth::Lease::new("/", moq_auth::lease::Consumer::fixed(grant)).unwrap(); let admitted = match session { true => cluster.scope_session(lease, &request), false => cluster.scope(lease, &request), @@ -2410,26 +2416,26 @@ mod tests { let everything = || moq_net::Patterns::from(moq_net::Pattern::all()); let mut grant = moq_auth::Grant::new(everything(), everything()); grant.mounts.insert(".svc".into(), ".svc/pid".into()); - let token = auth::Token::new("/pid", &grant); + let token = auth::Token::new("/pid", &grant).unwrap(); let _worker = cluster .origin - .publish(".svc/pid/foo", origin::Route::default()) + .publish(Path::new(".svc/pid/foo").unwrap(), origin::Route::default()) .expect("publish at the fleet path"); let subscriber = cluster.subscriber(&token).expect("subscribe grant").consume(); let broadcast = subscriber - .request_broadcast(".svc/foo", None) + .request_broadcast(Path::new(".svc/foo").unwrap(), None) .await .expect("resolves through the mount"); assert_eq!(broadcast.info().path.as_str(), ".svc/foo"); let publisher = cluster.publisher(&token).expect("publish grant"); - assert!(publisher.create_broadcast(".svc/foo").is_err()); - publisher.create_broadcast("cam").expect("publish outside the mount"); + assert!(publisher.create_broadcast(Path::new(".svc/foo").unwrap()).is_err()); + publisher.create_broadcast(Path::new("cam").unwrap()).expect("publish outside the mount"); // A mount the origin refuses admits nothing rather than half a grant. grant.mounts.insert(".svc/x".into(), ".other".into()); - let token = auth::Token::new("/pid", &grant); + let token = auth::Token::new("/pid", &grant).unwrap(); assert!(cluster.subscriber(&token).is_none()); assert!(cluster.publisher(&token).is_none()); } @@ -2447,7 +2453,7 @@ mod tests { for (at, target) in mounts { grant.mounts.insert((*at).into(), (*target).into()); } - let token = auth::Token::new("/pid", &grant); + let token = auth::Token::new("/pid", &grant).unwrap(); assert!(cluster.subscriber(&token).is_none(), "{mounts:?}"); assert!(cluster.publisher(&token).is_none(), "{mounts:?}"); } @@ -2476,7 +2482,7 @@ mod tests { let stats = config.build(cluster.origin.clone()).expect("stats"); let cluster = cluster.with_stats(stats); - let path = moq_net::Path::new(".stats").join("node").join("test"); + let path = moq_net::Path::new(".stats/node/test").unwrap(); let consumer = cluster.origin.consume(); let route = tokio::time::timeout(std::time::Duration::from_secs(5), consumer.routed(&path)) .await @@ -2552,7 +2558,7 @@ mod tests { ..Default::default() }) .expect("cluster"); - assert_eq!(cluster.cluster_tier(), Tier::new("region/sjc")); + assert_eq!(cluster.cluster_tier(), Tier::new(Path::new("region/sjc").unwrap())); } /// Stand-in dial task: never makes progress, exposes an AbortHandle. @@ -3066,19 +3072,19 @@ mod tests { assert_eq!(cluster.origin.config().cache_duration, duration); assert_eq!(cluster.origin.config().pool.expiry(), Some(duration)); - let broadcast = origin.create_broadcast("cam").expect("create"); + let broadcast = origin.create_broadcast(Path::new("cam").unwrap()).expect("create"); broadcast.announce(Default::default()).expect("announce"); let mut track = broadcast.create_track("data", timed()).expect("track"); track.write_frame(moq_net::Timestamp::ZERO, b"hello").expect("write"); assert!(pool.used() > 0, "writes charge the constructed cache pool"); let consumer = cluster.origin.consume(); - tokio::time::timeout(Duration::from_secs(2), consumer.request_broadcast("cam", None)) + tokio::time::timeout(Duration::from_secs(2), consumer.request_broadcast(Path::new("cam").unwrap(), None)) .await .expect("broadcast resolves") .expect("broadcast present"); - let stats_path = moq_net::Path::new(".stats").join("node").join("test"); + let stats_path = moq_net::Path::new(".stats/node/test").unwrap(); tokio::time::timeout(Duration::from_secs(5), consumer.routed(&stats_path)) .await .expect("stats announced") @@ -3477,7 +3483,7 @@ mod tests { let node = new_cluster(Config::default()).expect("node cluster"); let fingerprint = new_cluster(Config::default()).expect("fingerprint cluster"); - let _from_node = node.origin.create_broadcast("from-node").expect("create"); + let _from_node = node.origin.create_broadcast(Path::new("from-node").unwrap()).expect("create"); _from_node.announce(Default::default()).expect("announce"); let mut listen = moq_tokio::listen::Config::default(); @@ -3532,7 +3538,7 @@ mod tests { // The dialer marks what the peer forwards: it entered at `node`, not here. assert_eq!(update.route.source(), origin::Source::Peer(node.origin.hop())); - let _from_fp = fingerprint.origin.create_broadcast("from-fingerprint").expect("create"); + let _from_fp = fingerprint.origin.create_broadcast(Path::new("from-fingerprint").unwrap()).expect("create"); _from_fp.announce(Default::default()).expect("announce"); let mut announced = node.origin.consume().announced(); loop { @@ -3816,7 +3822,7 @@ mod tests { let dialer = new_cluster(Config::default()) .expect("dialer cluster") .with_connect(Default::default(), quic); - let broadcast = dialer.origin.create_broadcast("from-dialer").expect("create"); + let broadcast = dialer.origin.create_broadcast(Path::new("from-dialer").unwrap()).expect("create"); broadcast.announce(Default::default()).expect("announce"); tokio::spawn(dialer.clone().supervise_remote(target, String::new())); (dialer, broadcast) @@ -3858,19 +3864,19 @@ mod tests { let cluster = new_cluster(Config::default()).expect("cluster"); let all: moq_net::Patterns = [moq_net::Pattern::all()].into_iter().collect(); - let client = auth::Token::new("/", &moq_auth::Grant::new(all.clone(), all.clone())); + let client = auth::Token::new("/", &moq_auth::Grant::new(all.clone(), all.clone())).unwrap(); let mut grant = moq_auth::Grant::new(all.clone(), all); grant.peer = true; - let peer = auth::Token::new("/", &grant); + let peer = auth::Token::new("/", &grant).unwrap(); let _ingest = cluster .publisher(&client) .expect("client") - .publish("ingest", Default::default()); + .publish(Path::new("ingest").unwrap(), Default::default()); let _forwarded = cluster .publisher(&peer) .expect("peer") - .publish("forwarded", Default::default()); + .publish(Path::new("forwarded").unwrap(), Default::default()); let mut announced = cluster.origin.consume().announced(); let forwarded = try_next_announced(&mut announced).expect("forwarded"); @@ -3894,25 +3900,25 @@ mod tests { let cluster = new_cluster(Config::default()).expect("cluster"); let all: moq_net::Patterns = [moq_net::Pattern::all()].into_iter().collect(); - let client = auth::Token::new("/", &moq_auth::Grant::new(all.clone(), all.clone())); + let client = auth::Token::new("/", &moq_auth::Grant::new(all.clone(), all.clone())).unwrap(); let mut grant = moq_auth::Grant::new(all.clone(), all); grant.peer = true; - let peer = auth::Token::new("/", &grant); + let peer = auth::Token::new("/", &grant).unwrap(); grant.upstream = true; - let core = auth::Token::new("/", &grant); + let core = auth::Token::new("/", &grant).unwrap(); let _ingest = cluster .publisher(&client) .expect("client") - .publish("ingest", Default::default()); + .publish(Path::new("ingest").unwrap(), Default::default()); let _mesh = cluster .publisher(&peer) .expect("peer") - .publish("mesh", Default::default()); + .publish(Path::new("mesh").unwrap(), Default::default()); let _core = cluster .publisher(&core) .expect("core") - .publish("core", Default::default()); + .publish(Path::new("core").unwrap(), Default::default()); let mut everyone = cluster.subscriber(&client).expect("client").consume().announced(); let mut prefixes = std::iter::from_fn(|| try_next_announced(&mut everyone)) diff --git a/rs/moq-relay/src/connection.rs b/rs/moq-relay/src/connection.rs index ec15b276a4e..963859188c4 100644 --- a/rs/moq-relay/src/connection.rs +++ b/rs/moq-relay/src/connection.rs @@ -308,7 +308,7 @@ impl Lifecycle { match self.cluster.verify_lan_credential(presented) { Some(true) => { tracing::info!("accepted LAN peer"); - let lease = self.auth.admit_fixed("/", self.cluster.lan_peer_grant()); + let lease = self.auth.admit_fixed("/", self.cluster.lan_peer_grant())?; return Ok((self.cluster.scope(lease, &request)?, None)); } Some(false) => { diff --git a/rs/moq-relay/src/internal.rs b/rs/moq-relay/src/internal.rs index c88929b32c1..3a8d8f2a2c0 100644 --- a/rs/moq-relay/src/internal.rs +++ b/rs/moq-relay/src/internal.rs @@ -873,6 +873,7 @@ fn render_uring(_out: &mut String, _workers: &[UringWorker]) {} #[expect(clippy::disallowed_methods, reason = "tests read the host clock directly")] mod tests { use super::*; + use moq_net::Path; #[tokio::test] async fn stun_metrics_are_present_only_for_a_configured_listener() { @@ -1210,7 +1211,7 @@ mod tests { #[test] fn request_metrics_never_open_a_session() { let stats = moq_net::stats::Registry::new(Default::default()); - let request = stats.tier(moq_net::stats::Tier::new("http")).request("root"); + let request = stats.tier(moq_net::stats::Tier::new(Path::new("http").unwrap())).request(Path::new("root").unwrap()); drop(request); let body = render_metrics(&stats.snapshot(), &[], &[]); assert!(body.contains("# TYPE moq_relay_requests_total counter"), "{body}"); @@ -1229,7 +1230,7 @@ mod tests { fn wire_metrics_include_internal_sessions_and_keep_final_totals() { let registry = moq_net::stats::Registry::new(Default::default()); for tier in ["internal", "edge"] { - let session = registry.tier(moq_net::stats::Tier::new(tier)).session(""); + let session = registry.tier(moq_net::stats::Tier::new(Path::new(tier).unwrap())).session(moq_net::Path::empty()); let source = moq_net::transport::Wire::new(); let guard = session.wire(source.clone()); source.set_sent_bytes(123); @@ -1255,8 +1256,8 @@ mod tests { async fn announce_metrics_keep_retired_totals() { let stats = moq_net::stats::Registry::new(Default::default()); let producer = - moq_tokio::origin::spawn().with_stats(stats.tier(moq_net::stats::Tier::new("edge")).session("root")); - let broadcast = producer.create_broadcast("demo/retired").unwrap(); + moq_tokio::origin::spawn().with_stats(stats.tier(moq_net::stats::Tier::new(Path::new("edge").unwrap())).session(Path::new("root").unwrap())); + let broadcast = producer.create_broadcast(Path::new("demo/retired").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); let body = render_metrics(&stats.snapshot(), &[], &[]); @@ -1298,19 +1299,19 @@ mod tests { // Default-tier egress: an untagged local publisher writes, a tagged egress // consumer reads it out, so publisher `bytes` advance on the default tier. - let default_ctx = stats.tier(Tier::default()).session("acme"); + let default_ctx = stats.tier(Tier::default()).session(Path::new("acme").unwrap()); let pub_origin = moq_tokio::origin::spawn(); let egress = pub_origin.consume().with_stats(default_ctx.clone()); let mut announced = egress.announced(); - let pub_source = pub_origin.create_broadcast("demo/x").unwrap(); + let pub_source = pub_origin.create_broadcast(Path::new("demo/x").unwrap()).unwrap(); pub_source.announce(Default::default()).unwrap(); let pub_track = pub_source.create_track("video", timed()).unwrap(); // Named-tier ingress: a tagged ingress producer writes, so subscriber // `bytes` advance on the regional tier. - let regional_ctx = stats.tier(Tier::new("region/sjc")).session("peer"); + let regional_ctx = stats.tier(Tier::new(Path::new("region/sjc").unwrap())).session(Path::new("peer").unwrap()); let sub_origin = moq_tokio::origin::spawn().with_stats(regional_ctx.clone()); - let sub_source = sub_origin.create_broadcast("demo/x").unwrap(); + let sub_source = sub_origin.create_broadcast(Path::new("demo/x").unwrap()).unwrap(); sub_source.announce(Default::default()).unwrap(); let sub_track = sub_source.create_track("audio", timed()).unwrap(); @@ -1322,7 +1323,7 @@ mod tests { let (update, active) = next_update(&mut announced).await.unwrap(); assert!(active); let bc = egress - .request_broadcast(moq_net::Path::new(update.prefix.as_str()), None) + .request_broadcast(moq_net::Path::new(update.prefix.as_str()).unwrap(), None) .await .unwrap(); let mut egress_sub = bc.track("video").unwrap().subscribe(None).await.unwrap(); diff --git a/rs/moq-relay/src/lib.rs b/rs/moq-relay/src/lib.rs index 278760ac7d5..4eaf52402fb 100644 --- a/rs/moq-relay/src/lib.rs +++ b/rs/moq-relay/src/lib.rs @@ -55,8 +55,11 @@ pub const DEFAULT_DRAIN_TIMEOUT: std::time::Duration = std::time::Duration::from /// Resolve an optional stats tier label. An absent or empty label selects the /// default unprefixed tier. -fn configured_tier(label: Option) -> moq_net::stats::Tier { - label.map(moq_net::stats::Tier::new).unwrap_or_default() +fn configured_tier(label: Option) -> Result { + Ok(match label { + Some(label) => moq_net::stats::Tier::new(moq_net::PathOwned::try_from(label)?), + None => Default::default(), + }) } pub use config::*; diff --git a/rs/moq-relay/src/refusals.rs b/rs/moq-relay/src/refusals.rs index 52debeb4ccb..642da660bc0 100644 --- a/rs/moq-relay/src/refusals.rs +++ b/rs/moq-relay/src/refusals.rs @@ -39,13 +39,17 @@ impl Refusals { } } pub(crate) fn record(&self, reason: RefusalKind) { - self.0.tier(Tier::default()).refuse("", reason); + self.0.tier(Tier::default()).refuse(moq_net::Path::empty(), reason); } pub(crate) fn record_auth(&self, err: &auth::Error) { if let auth::Error::Refused(refusal) = err { + // The refusal is recorded either way, under the default tier or root if the + // server named one with an empty segment. + let tier = refusal.tier.clone().and_then(|tier| moq_net::PathOwned::try_from(tier).ok()); + let root = refusal.root.as_deref().and_then(|root| moq_net::Path::new(root).ok()); self.0 - .tier(refusal.tier.clone().map(Tier::new).unwrap_or_default()) - .refuse(refusal.root.as_deref().unwrap_or(""), err.into()); + .tier(tier.map(Tier::new).unwrap_or_default()) + .refuse(root.unwrap_or_default(), err.into()); } else { self.record(err.into()); } diff --git a/rs/moq-relay/src/stats.rs b/rs/moq-relay/src/stats.rs index 4a18c34e296..7597270a85a 100644 --- a/rs/moq-relay/src/stats.rs +++ b/rs/moq-relay/src/stats.rs @@ -122,13 +122,18 @@ impl Config { if !self.enabled { return Ok(moq_stats::Producer::new(moq_stats::produce::Config::new())); } - let prefix = self.prefix.clone(); + let prefix = PathOwned::try_from(self.prefix.clone()).map_err(|err| anyhow::anyhow!("invalid stats.prefix: {err}"))?; let interval = self.interval(); anyhow::ensure!(interval != Some(Duration::ZERO), "stats.interval must be non-zero"); - let node = self.node.clone().map(PathOwned::from); + let node = self + .node + .clone() + .map(PathOwned::try_from) + .transpose() + .map_err(|err| anyhow::anyhow!("invalid stats.node: {err}"))?; let depth = self.depth; let linger = self.linger(); - tracing::info!(prefix, ?interval, node = ?node, depth, ?linger, "stats publishing enabled"); + tracing::info!(prefix = %prefix, ?interval, node = ?node, depth, ?linger, "stats publishing enabled"); let mut config = moq_stats::produce::Config::new() .with_origin(origin) .with_prefix(prefix) diff --git a/rs/moq-relay/src/web.rs b/rs/moq-relay/src/web.rs index 56a9ff01047..92bf0b261d6 100644 --- a/rs/moq-relay/src/web.rs +++ b/rs/moq-relay/src/web.rs @@ -1101,7 +1101,7 @@ async fn serve_fetch( // NOTE: The auth token is already scoped to the broadcast. // Block until a route covers the broadcast (within the fetch deadline) so // freshly-connected subscribers don't get a spurious 404 before the announce arrives. - let broadcast = origin.routed_broadcast("").await.map_err(|_| StatusCode::NOT_FOUND)?; + let broadcast = origin.routed_broadcast(moq_net::Path::empty()).await.map_err(|_| StatusCode::NOT_FOUND)?; let sequence = match params.group { FetchGroup::Num(sequence) => Some(sequence), FetchGroup::Latest => None, @@ -1373,7 +1373,7 @@ mod tests { }); let mut cluster = cluster::Cluster::new(crate::cluster::Options::default()).unwrap(); cluster.stats = Registry::new(Default::default()); - let broadcast = cluster.origin.create_broadcast("room").unwrap(); + let broadcast = cluster.origin.create_broadcast(moq_net::Path::new("room").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); let track = broadcast .create_track( @@ -1440,7 +1440,7 @@ mod tests { assert_eq!(report.traffic.len(), 2); assert_eq!(report.sessions.len(), 2); for label in ["first", "second"] { - let tier = Tier::new(label); + let tier = Tier::new(moq_net::Path::new(label).unwrap()); let traffic = report.traffic.iter().find(|entry| entry.tier == tier).unwrap(); assert_eq!(traffic.path.as_str(), "room"); assert_eq!( @@ -1475,7 +1475,7 @@ mod tests { .init("test", &moq_tokio::tls::Connect::default(), false) .unwrap(); let cluster = cluster::Cluster::new(crate::cluster::Options::default()).unwrap(); - let broadcast = cluster.origin.create_broadcast("room").unwrap(); + let broadcast = cluster.origin.create_broadcast(moq_net::Path::new("room").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); let track = broadcast .create_track( diff --git a/rs/moq-relay/tests/drills.rs b/rs/moq-relay/tests/drills.rs index a283908c9cf..6f2690fed27 100644 --- a/rs/moq-relay/tests/drills.rs +++ b/rs/moq-relay/tests/drills.rs @@ -416,7 +416,7 @@ struct Reader { async fn subscribe(origin: &moq_net::origin::Consumer, path: &str) -> Reader { // `routed_broadcast` parks until a route covers the path; `request_broadcast` // would race the announcement and report a live broadcast as unroutable. - let broadcast = tokio::time::timeout(TIMEOUT, origin.routed_broadcast(path)) + let broadcast = tokio::time::timeout(TIMEOUT, origin.routed_broadcast(moq_net::Path::new(path).unwrap())) .await .expect("announcement timed out") .expect("origin closed before announcing"); @@ -453,7 +453,7 @@ async fn cancel_under_backpressure_releases_the_reader(lane: Lane) { let url = path.url.clone(); let publisher = moq_tokio::origin::spawn(); - let broadcast = publisher.create_broadcast("live").expect("create broadcast"); + let broadcast = publisher.create_broadcast(moq_net::Path::new("live").unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("announce broadcast"); let mut track = broadcast.create_track(TRACK, timed()).expect("create track"); let publish_session = tokio::time::timeout( @@ -585,7 +585,7 @@ async fn relay_killed_mid_group_aborts_then_resumes(lane: Lane) { let url = path.url.clone(); let publisher = moq_tokio::origin::spawn(); - let broadcast = publisher.create_broadcast("live").expect("create broadcast"); + let broadcast = publisher.create_broadcast(moq_net::Path::new("live").unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("announce broadcast"); let mut track = broadcast.create_track(TRACK, timed()).expect("create track"); let mut publish_loop = client(&url).publish(publisher.consume()).expect("no connect url"); @@ -708,7 +708,7 @@ async fn interrupted_publisher_republishes_new_content(lane: Lane) { let mut announced = subscribed.announced(); let first = moq_tokio::origin::spawn(); - let broadcast = first.create_broadcast("live").expect("create broadcast"); + let broadcast = first.create_broadcast(moq_net::Path::new("live").unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("announce broadcast"); let mut track = broadcast.create_track(TRACK, timed()).expect("create track"); let first_session = tokio::time::timeout( @@ -746,7 +746,7 @@ async fn interrupted_publisher_republishes_new_content(lane: Lane) { // Restore: the same name, a new publisher, different content. let second = moq_tokio::origin::spawn(); - let broadcast = second.create_broadcast("live").expect("re-create broadcast"); + let broadcast = second.create_broadcast(moq_net::Path::new("live").unwrap()).expect("re-create broadcast"); broadcast.announce(Default::default()).expect("announce broadcast"); let mut track = broadcast.create_track(TRACK, timed()).expect("re-create track"); let second_session = tokio::time::timeout( @@ -1026,7 +1026,7 @@ async fn cross_cluster(lane: Lane, link: PeerLink) { let subscribe_path = Path::shaped(lane, &edge, bursty(), seed.wrapping_add(2)).await; let publisher = moq_tokio::origin::spawn(); - let broadcast = publisher.create_broadcast("live").expect("create broadcast"); + let broadcast = publisher.create_broadcast(moq_net::Path::new("live").unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("announce broadcast"); let mut track = broadcast.create_track(TRACK, timed()).expect("create track"); let url = publish_path.url.clone(); @@ -1361,7 +1361,7 @@ async fn no_publisher_never_delivers(lane: Lane) { let mut announced = subscribed.announced(); let (update, resolved) = tokio::join!( tokio::time::timeout(quiet, next_update(&mut announced)), - tokio::time::timeout(quiet, subscribed.routed_broadcast("live")), + tokio::time::timeout(quiet, subscribed.routed_broadcast(moq_net::Path::new("live").unwrap())), ); if let Ok(update) = update { let path = update.map(|(update, _)| update.prefix.to_string()); @@ -1419,7 +1419,7 @@ async fn subscriber_max_age_skips_bufferbloat(version: &str) { ) .await; let publisher = moq_tokio::origin::spawn(); - let broadcast = publisher.create_broadcast("live").unwrap(); + let broadcast = publisher.create_broadcast(moq_net::Path::new("live").unwrap()).unwrap(); let mut track = broadcast.create_track(TRACK, timed()).unwrap(); broadcast.announce(Default::default()).unwrap(); let mut dial = dial(); @@ -1447,7 +1447,7 @@ async fn subscriber_max_age_skips_bufferbloat(version: &str) { .await .unwrap(); write_group(&mut track, b"warmup"); - let remote = tokio::time::timeout(TIMEOUT, consumed.routed_broadcast("live")) + let remote = tokio::time::timeout(TIMEOUT, consumed.routed_broadcast(moq_net::Path::new("live").unwrap())) .await .unwrap() .unwrap(); diff --git a/rs/moq-relay/tests/integration/auth_lifetime.rs b/rs/moq-relay/tests/integration/auth_lifetime.rs index 7a45454b1bf..3b638127809 100644 --- a/rs/moq-relay/tests/integration/auth_lifetime.rs +++ b/rs/moq-relay/tests/integration/auth_lifetime.rs @@ -12,6 +12,7 @@ //! including an outage that keeps it until exactly `expires`, on a clock only //! the test moves. +use moq_net::Path; use std::collections::HashMap; use std::sync::{Arc, Mutex}; use std::time::Duration; @@ -249,7 +250,7 @@ fn room_url(scheme: &str, port: u16) -> url::Url { /// round-trips. Returns both sessions so the caller can watch them close. async fn connect_and_round_trip(url: &url::Url) -> (moq_tokio::Connection, moq_tokio::Connection) { let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast("test").expect("create broadcast"); + let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let track = broadcast.create_track("video", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); @@ -292,7 +293,7 @@ async fn connect_and_round_trip(url: &url::Url) -> (moq_tokio::Connection, moq_t assert_eq!(update.prefix.as_str(), "test"); assert!(active, "expected announce, got retraction"); let bc = sub_consumer - .request_broadcast("test", None) + .request_broadcast(Path::new("test").unwrap(), None) .await .expect("announced broadcast resolves"); @@ -510,7 +511,7 @@ async fn a_moved_tier_retags_the_live_session() { let (port, relay) = spawn_relay_with(build_auth(script.spawn().await), cluster).await; let url = room_url("tcp", port); - let moved = stats::Tier::new("moved"); + let moved = stats::Tier::new(Path::new("moved").unwrap()); let active = |tier: &stats::Tier| { registry .snapshot() @@ -546,7 +547,7 @@ async fn a_moved_tier_retags_the_live_session() { // A publisher whose track stays open across the move, and a subscriber to it. let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast("test").expect("create broadcast"); + let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("announce broadcast"); let track = broadcast.create_track("video", timed()).expect("create track"); let pub_session = tokio::time::timeout( @@ -582,7 +583,7 @@ async fn a_moved_tier_retags_the_live_session() { assert_eq!(update.prefix.as_str(), "test"); assert!(announced, "expected announce, got retraction"); let bc = sub_consumer - .request_broadcast("test", None) + .request_broadcast(Path::new("test").unwrap(), None) .await .expect("announced broadcast resolves"); let mut track_sub = bc.track("video").unwrap().subscribe(None).await.expect("subscribe"); @@ -691,7 +692,7 @@ async fn a_rechecked_grant_resizes_live_sessions() { let pub_origin = moq_tokio::origin::spawn(); let mut tracks = Vec::new(); for path in ["alice/audio", "alice/video"] { - let broadcast = pub_origin.create_broadcast(path).expect("create broadcast"); + let broadcast = pub_origin.create_broadcast(Path::new(path).unwrap()).expect("create broadcast"); let track = broadcast.create_track("media", timed()).expect("create track"); broadcast.announce(Default::default()).expect("announce broadcast"); tracks.push((broadcast, track)); @@ -724,7 +725,7 @@ async fn a_rechecked_grant_resizes_live_sessions() { let mut subs = Vec::new(); for path in ["alice/audio", "alice/video"] { - let broadcast = tokio::time::timeout(TIMEOUT, sub_consumer.routed_broadcast(path)) + let broadcast = tokio::time::timeout(TIMEOUT, sub_consumer.routed_broadcast(Path::new(path).unwrap())) .await .expect("announcement timeout") .expect("announced broadcast resolves"); @@ -787,7 +788,7 @@ async fn a_rechecked_grant_resizes_live_sessions() { // Undeafen: the path is announced again and a new subscription flows. script.on_revalidate(Answer::Grant(grant(Duration::from_secs(3600)))); - let broadcast = tokio::time::timeout(TIMEOUT, sub_consumer.routed_broadcast("alice/audio")) + let broadcast = tokio::time::timeout(TIMEOUT, sub_consumer.routed_broadcast(Path::new("alice/audio").unwrap())) .await .expect("the undeafened path was never announced again") .expect("announced broadcast resolves"); @@ -881,7 +882,7 @@ async fn http_routes_hold_a_lease() { // A publisher whose group stays open, so a fetch of it keeps streaming. let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast("test").expect("create broadcast"); + let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("announce"); let track = broadcast.create_track("video", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); @@ -1230,7 +1231,7 @@ async fn mtls_route_source(mtls_peer: bool) -> moq_net::origin::Source { config.tls.cert = Some(client_cert); config.tls.key = Some(client_key); let peer = moq_tokio::origin::spawn(); - let _forwarded = peer.create_broadcast("forwarded").expect("create"); + let _forwarded = peer.create_broadcast(Path::new("forwarded").unwrap()).expect("create"); _forwarded.announce(Default::default()).expect("announce"); let url: url::Url = format!("moql://127.0.0.1:{}/", addr.port()).parse().unwrap(); let _session = tokio::time::timeout( @@ -1651,10 +1652,10 @@ async fn in_band_tokens_widen_and_withdraw_live_prefixes() { config.init(Default::default()).unwrap().with_reconnect(false) }; let origin = moq_tokio::origin::spawn(); - let a = origin.create_broadcast("a/cam").unwrap(); + let a = origin.create_broadcast(Path::new("a/cam").unwrap()).unwrap(); let a_track = a.create_track("video", timed()).unwrap(); a.announce(Default::default()).unwrap(); - let b = origin.create_broadcast("b/cam").unwrap(); + let b = origin.create_broadcast(Path::new("b/cam").unwrap()).unwrap(); let b_track = b.create_track("video", timed()).unwrap(); b.announce(Default::default()).unwrap(); let publisher = tokio::time::timeout( @@ -1679,7 +1680,7 @@ async fn in_band_tokens_widen_and_withdraw_live_prefixes() { .await .unwrap() .unwrap(); - let a_read = tokio::time::timeout(TIMEOUT, read.routed_broadcast("a/cam")) + let a_read = tokio::time::timeout(TIMEOUT, read.routed_broadcast(Path::new("a/cam").unwrap())) .await .unwrap() .unwrap(); @@ -1691,7 +1692,7 @@ async fn in_band_tokens_widen_and_withdraw_live_prefixes() { .await .unwrap() .unwrap(); - let b_read = tokio::time::timeout(TIMEOUT, read.routed_broadcast("b/cam")) + let b_read = tokio::time::timeout(TIMEOUT, read.routed_broadcast(Path::new("b/cam").unwrap())) .await .expect("new prefix not announced") .unwrap(); @@ -1766,13 +1767,13 @@ async fn relay_request_limits_distinguish_clients_and_peers() { .established() .await .unwrap(); - let first = origin.create_broadcast("one").unwrap(); + let first = origin.create_broadcast(Path::new("one").unwrap()).unwrap(); first.announce(Default::default()).unwrap(); tokio::time::timeout(TIMEOUT, next_update(&mut observed)) .await .unwrap() .unwrap(); - let second = origin.create_broadcast("two").unwrap(); + let second = origin.create_broadcast(Path::new("two").unwrap()).unwrap(); second.announce(Default::default()).unwrap(); if peer { let (route, active) = tokio::time::timeout(TIMEOUT, next_update(&mut observed)) diff --git a/rs/moq-relay/tests/integration/cluster_drain.rs b/rs/moq-relay/tests/integration/cluster_drain.rs index beeffa14cce..abb8cede5c0 100644 --- a/rs/moq-relay/tests/integration/cluster_drain.rs +++ b/rs/moq-relay/tests/integration/cluster_drain.rs @@ -6,6 +6,7 @@ //! only when the test advances them, while the sockets carry traffic in real time. //! Each peer dials B through its own forwarder, which counts the sessions opened. +use moq_net::Path; use std::{ net::SocketAddr, sync::{Arc, Mutex}, @@ -112,7 +113,7 @@ async fn relay(name: &str) -> (Relay, SocketAddr, moq_net::broadcast::Producer) config.drain_timeout = Some(DRAIN.into()); let relay = Relay::load(config).await.expect("load relay").with_signals(false); let addr = relay.tcp_addr().expect("tcp listener"); - let broadcast = relay.cluster().origin.create_broadcast(name).expect("create broadcast"); + let broadcast = relay.cluster().origin.create_broadcast(Path::new(name).unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("announce"); (relay, addr, broadcast) } @@ -124,7 +125,7 @@ async fn peer(name: &str, forwarder: &Forwarder) -> (cluster::Cluster, moq_net:: let cluster = cluster::Cluster::new(cluster::Options::new(config)) .expect("cluster init") .with_connect(Default::default(), Default::default()); - let broadcast = cluster.origin.create_broadcast(name).expect("create broadcast"); + let broadcast = cluster.origin.create_broadcast(Path::new(name).unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("announce"); let started = cluster.clone().start().await.expect("cluster start"); tokio::spawn(started.run()); @@ -162,10 +163,10 @@ async fn draining_relay_keeps_its_peers_until_it_restarts_inner() { let (c, _c_broadcast) = peer("c", &forward_c).await; // The mesh converges: each side learns the other's broadcasts. - within("A learns b", a.origin.consume().routed("b")).await; - within("C learns b", c.origin.consume().routed("b")).await; - within("B learns a", b_origin.consume().routed("a")).await; - within("B learns c", b_origin.consume().routed("c")).await; + within("A learns b", a.origin.consume().routed(Path::new("b").unwrap())).await; + within("C learns b", c.origin.consume().routed(Path::new("b").unwrap())).await; + within("B learns a", b_origin.consume().routed(Path::new("a").unwrap())).await; + within("B learns c", b_origin.consume().routed(Path::new("c").unwrap())).await; assert_eq!(forward_a.sessions(b_addr), 1); assert_eq!(forward_c.sessions(b_addr), 1); @@ -199,8 +200,8 @@ async fn draining_relay_keeps_its_peers_until_it_restarts_inner() { pass(&clock, STEP).await; waited += STEP; } - within("B' learns a", b2_origin.consume().routed("a")).await; - within("B' learns c", b2_origin.consume().routed("c")).await; + within("B' learns a", b2_origin.consume().routed(Path::new("a").unwrap())).await; + within("B' learns c", b2_origin.consume().routed(Path::new("c").unwrap())).await; // And reconnects exactly once. pass(&clock, Duration::from_secs(30)).await; diff --git a/rs/moq-relay/tests/integration/cluster_idle.rs b/rs/moq-relay/tests/integration/cluster_idle.rs index 191e958d641..2bda16b8c39 100644 --- a/rs/moq-relay/tests/integration/cluster_idle.rs +++ b/rs/moq-relay/tests/integration/cluster_idle.rs @@ -5,6 +5,7 @@ //! timeout; moq-tokio's `defaults_apply_when_unset` pins the 10s default. #![cfg(feature = "quic")] +use moq_net::Path; use std::time::{Duration, Instant}; use moq_relay::cluster::{self, Peer}; @@ -51,7 +52,7 @@ async fn spawn_peer() -> (u16, tokio::runtime::Runtime) { let (bound, port) = tokio::sync::oneshot::channel(); runtime.spawn(async move { let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast("peer").expect("create broadcast"); + let broadcast = origin.create_broadcast(Path::new("peer").unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("announce"); let mut config = moq_tokio::listen::Config::default(); diff --git a/rs/moq-relay/tests/integration/cluster_unknown.rs b/rs/moq-relay/tests/integration/cluster_unknown.rs index 267bc3471a8..1bbfd778edd 100644 --- a/rs/moq-relay/tests/integration/cluster_unknown.rs +++ b/rs/moq-relay/tests/integration/cluster_unknown.rs @@ -2,6 +2,7 @@ //! The relay records that publisher as `Hop::UNKNOWN`; reflected cluster paths //! must not replace it while propagating around a redundant mesh. +use moq_net::Path; use std::time::Duration; use moq_relay::{Config, Relay}; @@ -147,7 +148,7 @@ impl Drop for Publisher { async fn publish_version(port: u16, version: &str) -> Publisher { let url: Url = format!("tcp://127.0.0.1:{port}").parse().expect("parse url"); let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast(PATH).expect("create broadcast"); + let broadcast = origin.create_broadcast(Path::new(PATH).unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let track = broadcast.create_track("video", timed()).expect("create track"); @@ -206,12 +207,12 @@ async fn read_first_frame(port: u16) -> Result, String> { // Wait for the announcement rather than asking the moment the session connects: // `request_broadcast` answers on the spot, so it would race the announcement that // makes the path routable. - tokio::time::timeout(TIMEOUT, consumer.routed(PATH)) + tokio::time::timeout(TIMEOUT, consumer.routed(Path::new(PATH).unwrap())) .await .map_err(|_| "routed timed out".to_string())? .ok_or_else(|| "origin closed before the broadcast was announced".to_string())?; let broadcast = consumer - .request_broadcast(PATH, None) + .request_broadcast(Path::new(PATH).unwrap(), None) .await .map_err(|err| format!("broadcast unroutable: {err}"))?; diff --git a/rs/moq-relay/tests/integration/connection.rs b/rs/moq-relay/tests/integration/connection.rs index c815699e013..6e204dccd7f 100644 --- a/rs/moq-relay/tests/integration/connection.rs +++ b/rs/moq-relay/tests/integration/connection.rs @@ -1,6 +1,7 @@ //! A relay [`Connection`](moq_relay::Connection) over the in-memory transport: admission, //! the cluster origin, and stats, with no socket and on Tokio's paused clock. +use moq_net::Path; use std::time::Duration; use moq_net::stats; @@ -19,7 +20,7 @@ async fn largest_quic_sequence_reaches_the_subscriber() { let auth = memory::public(&["**"], &[], &[]); let cluster = memory::cluster(); let publisher = moq_tokio::origin::spawn(); - let broadcast = publisher.create_broadcast("ladder").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("ladder").unwrap()).unwrap(); let info = moq_net::track::Info::default().with_timescale(moq_net::Timescale::MICRO); let track = broadcast.create_track("data", info).unwrap(); broadcast.announce(Default::default()).unwrap(); @@ -40,11 +41,11 @@ async fn largest_quic_sequence_reaches_the_subscriber() { ) .await .unwrap(); - tokio::time::timeout(TIMEOUT, subscriber.consume().routed("ladder")) + tokio::time::timeout(TIMEOUT, subscriber.consume().routed(Path::new("ladder").unwrap())) .await .unwrap() .unwrap(); - let remote = subscriber.consume().request_broadcast("ladder", None).await.unwrap(); + let remote = subscriber.consume().request_broadcast(Path::new("ladder").unwrap(), None).await.unwrap(); let mut sub = remote.track("data").unwrap().subscribe(None).await.unwrap(); for sequence in [5, 1 << 32, (1 << 53) - 1, (1 << 53) + 1, (1 << 62) - 1] { // Timestamps stop at 2^61 - 1, the most lite-05/06 can zigzag as a first frame. @@ -76,7 +77,7 @@ fn publish( moq_net::track::Producer, ) { let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast(name).expect("create broadcast"); + let broadcast = origin.create_broadcast(Path::new(name).unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("announce"); let info = moq_net::track::Info::default().with_timescale(moq_net::Timescale::MILLI); let track = broadcast.create_track("video", info).expect("create track"); @@ -233,7 +234,7 @@ async fn the_setup_path_reaches_the_decider_and_roots_the_grant() { assert_eq!(next_active(&mut announced).await, "room/cam"); let broadcast = consumer - .request_broadcast("room/cam", None) + .request_broadcast(Path::new("room/cam").unwrap(), None) .await .expect("announced broadcast resolves"); let mut track = broadcast diff --git a/rs/moq-relay/tests/integration/embed.rs b/rs/moq-relay/tests/integration/embed.rs index e4394add545..3ca5880f48b 100644 --- a/rs/moq-relay/tests/integration/embed.rs +++ b/rs/moq-relay/tests/integration/embed.rs @@ -9,6 +9,7 @@ #![cfg(feature = "_quic")] +use moq_net::Path; use std::net::{SocketAddr, TcpListener}; use std::time::Duration; @@ -262,7 +263,7 @@ async fn embed_and_stop(mut config: Config) { "authorization" ); - let broadcast = origin.create_broadcast("test").expect("create broadcast"); + let broadcast = origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("announce"); let track = broadcast.create_track("video", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); @@ -293,7 +294,7 @@ async fn embed_and_stop(mut config: Config) { .expect("origin closed"); assert_eq!(update.prefix.as_str(), "test"); assert!(active, "expected announce, got retraction"); - let announced = tokio::time::timeout(TIMEOUT, consumer.request_broadcast("test", None)) + let announced = tokio::time::timeout(TIMEOUT, consumer.request_broadcast(Path::new("test").unwrap(), None)) .await .expect("request timeout") .expect("announced broadcast resolves"); diff --git a/rs/moq-relay/tests/integration/goaway_cluster.rs b/rs/moq-relay/tests/integration/goaway_cluster.rs index cdf9b7328c7..75045d705e2 100644 --- a/rs/moq-relay/tests/integration/goaway_cluster.rs +++ b/rs/moq-relay/tests/integration/goaway_cluster.rs @@ -6,6 +6,7 @@ //! hands the live subscription over at a group boundary. A downstream consumer //! of the cluster origin observes contiguous groups and no unannounce. +use moq_net::Path; use std::collections::BTreeSet; use std::time::Duration; @@ -149,7 +150,7 @@ async fn cluster_continues_a_group_split_by_goaway_inner() { let _ = rustls::crypto::aws_lc_rs::default_provider().install_default(); let upstream_origin = moq_tokio::origin::spawn(); - let broadcast = upstream_origin.create_broadcast("cam").expect("create broadcast"); + let broadcast = upstream_origin.create_broadcast(Path::new("cam").unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("announce"); let track = broadcast.create_track("video", timed()).expect("create track"); @@ -171,9 +172,9 @@ async fn cluster_continues_a_group_split_by_goaway_inner() { let session_a = within("A accepts", accepted_a.recv()).await.expect("A accepts"); let consumer = cluster.origin.consume(); - within("routed via A", consumer.routed("cam")).await.expect("routed"); + within("routed via A", consumer.routed(Path::new("cam").unwrap())).await.expect("routed"); let bc = consumer - .request_broadcast("cam", None) + .request_broadcast(Path::new("cam").unwrap(), None) .await .expect("broadcast resolves"); let mut sub = within("subscribe", bc.track("video").expect("track").subscribe(None)) @@ -287,7 +288,7 @@ async fn cluster_migrates_on_upstream_goaway_inner() { tokio::time::timeout(TEST_TIMEOUT, async { // ── the shared "live" broadcast both siblings can serve ───────── let upstream_origin = moq_tokio::origin::spawn(); - let broadcast = upstream_origin.create_broadcast("cam").expect("create broadcast"); + let broadcast = upstream_origin.create_broadcast(Path::new("cam").unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let track = broadcast.create_track("video", timed()).expect("create track"); @@ -315,11 +316,11 @@ async fn cluster_migrates_on_upstream_goaway_inner() { // ── downstream consumer on the cluster origin ─────────────────── let consumer = cluster.origin.consume(); consumer - .routed("cam") + .routed(Path::new("cam").unwrap()) .await .expect("broadcast announced through sibling A"); let bc = consumer - .request_broadcast("cam", None) + .request_broadcast(Path::new("cam").unwrap(), None) .await .expect("broadcast resolves"); let mut sub = bc @@ -483,7 +484,7 @@ async fn cluster_diamond_goaway_seamless_failover_inner() { // ── TOP: origin server serving the same broadcast to both mids ────── let top_origin = moq_tokio::origin::spawn(); - let broadcast = top_origin.create_broadcast("diamond").expect("create broadcast"); + let broadcast = top_origin.create_broadcast(Path::new("diamond").unwrap()).expect("create broadcast"); broadcast .announce(moq_net::origin::Route::default().with_epoch(moq_net::Epoch::mint())) .expect("create broadcast"); @@ -563,8 +564,8 @@ async fn cluster_diamond_goaway_seamless_failover_inner() { let bc = within("broadcast resolves on the subscriber origin", async { let consumer = sub_origin.consume(); - consumer.routed("diamond").await?; - consumer.request_broadcast("diamond", None).await.ok() + consumer.routed(Path::new("diamond").unwrap()).await?; + consumer.request_broadcast(Path::new("diamond").unwrap(), None).await.ok() }) .await .expect("broadcast announced"); diff --git a/rs/moq-relay/tests/integration/hidden_cluster.rs b/rs/moq-relay/tests/integration/hidden_cluster.rs index f9e4ef7cd24..d525b12a67f 100644 --- a/rs/moq-relay/tests/integration/hidden_cluster.rs +++ b/rs/moq-relay/tests/integration/hidden_cluster.rs @@ -1,6 +1,7 @@ //! A cluster peer that predates the hidden opt-in still discovers the relay's //! `.`-named broadcasts, so a mixed-version mesh keeps its hidden paths. +use moq_net::Path; use std::time::Duration; use moq_relay::cluster::{self, Peer}; @@ -68,7 +69,7 @@ async fn old_peer_keeps_hidden_paths(version: moq_net::Version) { let cluster = cluster::Cluster::new(cluster::Options::new(cluster_config)) .expect("cluster init") .with_connect(client_config, Default::default()); - let node = cluster.origin.create_broadcast(".hidden/test").expect("create hidden"); + let node = cluster.origin.create_broadcast(Path::new(".hidden/test").unwrap()).expect("create hidden"); node.announce(Default::default()).expect("announce hidden"); let cluster_run = tokio::spawn(cluster.clone().start().await.expect("cluster start").run()); diff --git a/rs/moq-relay/tests/integration/public_rules.rs b/rs/moq-relay/tests/integration/public_rules.rs index d7f88715f2e..58abf10ef19 100644 --- a/rs/moq-relay/tests/integration/public_rules.rs +++ b/rs/moq-relay/tests/integration/public_rules.rs @@ -7,6 +7,7 @@ //! the dialed path, `anon/**` at `/anon` meant `anon/anon/**`, and at `/rooms/123` //! it let an anonymous client into `rooms/123/anon/**`. +use moq_net::Path; use std::time::Duration; use moq_relay::{auth, cluster, web}; @@ -67,7 +68,7 @@ fn url(port: u16, path: &str) -> url::Url { /// handles alive for as long as the broadcast should stay announced. async fn publish(url: url::Url, name: &str) -> Box { let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast(name).expect("create broadcast"); + let broadcast = origin.create_broadcast(Path::new(name).unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("announce"); let track = broadcast.create_track("video", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); @@ -117,7 +118,7 @@ async fn first_broadcast(url: url::Url) -> String { let name = update.prefix.to_string(); let broadcast = consumer - .request_broadcast(&name, None) + .request_broadcast(Path::new(&name).unwrap(), None) .await .expect("broadcast resolves"); let mut track = broadcast diff --git a/rs/moq-relay/tests/integration/refusals.rs b/rs/moq-relay/tests/integration/refusals.rs index 0cb68bf92a1..77aadf9fc29 100644 --- a/rs/moq-relay/tests/integration/refusals.rs +++ b/rs/moq-relay/tests/integration/refusals.rs @@ -3,6 +3,7 @@ #![cfg(feature = "_quic")] +use moq_net::Path; use std::net::SocketAddr; use std::time::Duration; @@ -244,11 +245,11 @@ async fn refused_only_stats_depth_one_has_root_totals_and_shared_embedder_metric 1, "native admission counts exactly once" ); - tokio::time::timeout(TIMEOUT, relay.origin.routed(".stats/node/test")) + tokio::time::timeout(TIMEOUT, relay.origin.routed(Path::new(".stats/node/test").unwrap())) .await .unwrap() .unwrap(); - let broadcast = tokio::time::timeout(TIMEOUT, relay.origin.request_broadcast(".stats/node/test", None)) + let broadcast = tokio::time::timeout(TIMEOUT, relay.origin.request_broadcast(Path::new(".stats/node/test").unwrap(), None)) .await .unwrap() .unwrap(); @@ -269,18 +270,18 @@ async fn refused_only_stats_depth_one_has_root_totals_and_shared_embedder_metric .expect("refusal-only root totals"); relay .stats - .tier(Tier::new("gateway")) - .refuse("tenant", RefusalKind::Forbidden); + .tier(Tier::new(Path::new("gateway").unwrap())) + .refuse(Path::new("tenant").unwrap(), RefusalKind::Forbidden); assert_eq!( relay.refused("forbidden").await, 1, "embedder stats and metrics share the counter" ); - tokio::time::timeout(TIMEOUT, relay.origin.routed(".stats/tenant/node/test")) + tokio::time::timeout(TIMEOUT, relay.origin.routed(Path::new(".stats/tenant/node/test").unwrap())) .await .unwrap() .unwrap(); - let broadcast = tokio::time::timeout(TIMEOUT, relay.origin.request_broadcast(".stats/tenant/node/test", None)) + let broadcast = tokio::time::timeout(TIMEOUT, relay.origin.request_broadcast(Path::new(".stats/tenant/node/test").unwrap(), None)) .await .unwrap() .unwrap(); @@ -311,11 +312,11 @@ async fn peer_zero_close_is_clean_and_application_close_counts_once() { config.stats.enabled = true; config.stats.node = Some("test".into()); let relay = start(config).await; - tokio::time::timeout(TIMEOUT, relay.origin.routed(".stats/node/test")) + tokio::time::timeout(TIMEOUT, relay.origin.routed(Path::new(".stats/node/test").unwrap())) .await .unwrap() .unwrap(); - let broadcast = relay.origin.request_broadcast(".stats/node/test", None).await.unwrap(); + let broadcast = relay.origin.request_broadcast(Path::new(".stats/node/test").unwrap(), None).await.unwrap(); let consumer = moq_stats::Consumer::new(broadcast, Default::default()); let mut totals = consumer.totals().await.unwrap(); for (index, error) in [moq_net::Error::Cancel, moq_net::Error::App(42)] diff --git a/rs/moq-relay/tests/integration/runtime_uring.rs b/rs/moq-relay/tests/integration/runtime_uring.rs index f586b950e30..e0fd2684e5e 100644 --- a/rs/moq-relay/tests/integration/runtime_uring.rs +++ b/rs/moq-relay/tests/integration/runtime_uring.rs @@ -11,7 +11,7 @@ use std::net::SocketAddr; use std::time::Duration; use moq_relay::{Config, Relay}; -use moq_tokio::moq_net; +use moq_tokio::moq_net::{self, Path}; use crate::logs::Logs; @@ -134,7 +134,7 @@ async fn uring_workers_serve_webtransport_and_raw_quic() { let raw_url: url::Url = format!("moql://127.0.0.1:{port}/uring").parse().expect("parse url"); let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast("test").expect("create broadcast"); + let broadcast = origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let track = broadcast.create_track("video", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); @@ -162,7 +162,7 @@ async fn uring_workers_serve_webtransport_and_raw_quic() { .expect("origin closed"); assert_eq!(update.prefix.as_str(), "test"); assert!(active, "expected announce, got retraction"); - let broadcast = tokio::time::timeout(TIMEOUT, consumer.request_broadcast("test", None)) + let broadcast = tokio::time::timeout(TIMEOUT, consumer.request_broadcast(Path::new("test").unwrap(), None)) .await .unwrap_or_else(|_| panic!("subscriber {index} request timeout")) .expect("announced broadcast resolves"); @@ -234,7 +234,7 @@ async fn uring_workers_serve_every_configured_version() { let running = tokio::spawn(relay.run()); let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast("test").expect("create broadcast"); + let broadcast = origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("announce broadcast"); let track = broadcast.create_track("video", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); @@ -272,7 +272,7 @@ async fn uring_workers_serve_every_configured_version() { // moq-lite-02 has no in-band path, so a raw QUIC session sits at the root. let path = update.prefix.as_str().to_owned(); assert!(active && path.ends_with("test"), "{scheme} {name}: announced {path}"); - let broadcast = tokio::time::timeout(TIMEOUT, consumer.request_broadcast(&path, None)) + let broadcast = tokio::time::timeout(TIMEOUT, consumer.request_broadcast(Path::new(&path).unwrap(), None)) .await .unwrap_or_else(|_| panic!("{scheme} {name}: request timeout")) .expect("announced broadcast resolves"); @@ -604,7 +604,7 @@ async fn an_mtls_client_authenticates_without_a_token() { // connecting proves nothing. let url: url::Url = format!("moql://127.0.0.1:{port}/mtls").parse().expect("parse url"); let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast("test").expect("create broadcast"); + let broadcast = origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let track = broadcast.create_track("video", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); @@ -625,7 +625,7 @@ async fn an_mtls_client_authenticates_without_a_token() { .expect("origin closed"); assert_eq!(update.prefix.as_str(), "test"); assert!(active, "expected announce, got retraction"); - let announced = tokio::time::timeout(TIMEOUT, consumer.request_broadcast("test", None)) + let announced = tokio::time::timeout(TIMEOUT, consumer.request_broadcast(Path::new("test").unwrap(), None)) .await .expect("request timeout") .expect("announced broadcast resolves"); @@ -683,7 +683,7 @@ async fn uring_workers_write_qlog_traces() { // rather than a connection that only ever exchanged Initials. let url: url::Url = format!("moql://127.0.0.1:{port}/qlog").parse().expect("parse url"); let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast("test").expect("create broadcast"); + let broadcast = origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let track = broadcast.create_track("video", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); diff --git a/rs/moq-relay/tests/integration/runtime_workers.rs b/rs/moq-relay/tests/integration/runtime_workers.rs index de40e7273f5..0899f9778e9 100644 --- a/rs/moq-relay/tests/integration/runtime_workers.rs +++ b/rs/moq-relay/tests/integration/runtime_workers.rs @@ -6,6 +6,7 @@ //! a build without one refuses `runtime.workers` at load. #![cfg(all(target_os = "linux", feature = "_quic"))] +use moq_net::Path; use std::time::Duration; use moq_relay::{Config, Relay}; @@ -89,7 +90,7 @@ async fn workers_serve_quic_and_share_one_origin() { // ── publisher ─────────────────────────────────────────────────── let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast("test").expect("create broadcast"); + let broadcast = origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let track = broadcast.create_track("video", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); @@ -117,7 +118,7 @@ async fn workers_serve_quic_and_share_one_origin() { .expect("origin closed"); assert_eq!(update.prefix.as_str(), "test"); assert!(active, "expected announce, got retraction"); - let broadcast = tokio::time::timeout(TIMEOUT, consumer.request_broadcast("test", None)) + let broadcast = tokio::time::timeout(TIMEOUT, consumer.request_broadcast(Path::new("test").unwrap(), None)) .await .unwrap_or_else(|_| panic!("subscriber {index} request timeout")) .expect("announced broadcast resolves"); diff --git a/rs/moq-relay/tests/integration/shutdown_signal.rs b/rs/moq-relay/tests/integration/shutdown_signal.rs index ee214e825cf..c195e349c7a 100644 --- a/rs/moq-relay/tests/integration/shutdown_signal.rs +++ b/rs/moq-relay/tests/integration/shutdown_signal.rs @@ -35,6 +35,7 @@ #![cfg(unix)] +use moq_net::Path; use std::sync::Mutex; use std::time::Duration; @@ -419,7 +420,7 @@ async fn a_reconnecting_client_rides_out_a_restart_inner() { let url: url::Url = format!("tcp://{addr}/").parse().expect("parse url"); let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast("cam").expect("create broadcast"); + let broadcast = origin.create_broadcast(Path::new("cam").unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("announce"); let mut publisher = moq_tokio::connect::Config::default(); // Redials paced well inside the drain, under a window that ends long before it. @@ -464,7 +465,7 @@ async fn a_reconnecting_client_rides_out_a_restart_inner() { .await .expect("connect"); tokio::select! { - res = consumer.routed_broadcast("cam") => { + res = consumer.routed_broadcast(Path::new("cam").unwrap()) => { res.expect("the publisher's broadcast never resolved"); } res = publisher.closed() => panic!("the publisher gave up during the restart: {res:?}"), diff --git a/rs/moq-relay/tests/integration/smoke.rs b/rs/moq-relay/tests/integration/smoke.rs index 4dc925b4f72..561825659f2 100644 --- a/rs/moq-relay/tests/integration/smoke.rs +++ b/rs/moq-relay/tests/integration/smoke.rs @@ -7,6 +7,7 @@ //! "axum-only-advertises-bare-`webtransport`" bug that silently downgraded //! relay clients to moq-lite-02. +use moq_net::Path; use std::time::Duration; use moq_relay::{Config, Connection, Relay, auth, cluster, web}; @@ -145,7 +146,7 @@ async fn relay_websocket_round_trip_uses_newest_version() { // ── publisher ─────────────────────────────────────────────────── let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast("test").expect("create broadcast"); + let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let track = broadcast.create_track("video", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); @@ -186,7 +187,7 @@ async fn relay_websocket_round_trip_uses_newest_version() { .await .expect("announcement timeout") .expect("origin closed"); - let path = moq_net::Path::new(update.prefix.as_str()).to_owned(); + let path = moq_net::Path::new(update.prefix.as_str()).unwrap().to_owned(); assert!(active, "expected announce, got retraction"); // Auth root for `/smoke` is "smoke"; the broadcast "test" announces underneath. assert_eq!(path.as_str(), "test"); @@ -284,7 +285,7 @@ async fn hidden_broadcasts_need_a_lite07_opt_in() { let url: url::Url = format!("ws://127.0.0.1:{port}/hidden").parse().expect("parse url"); let pub_origin = moq_tokio::origin::spawn(); - let hidden = pub_origin.create_broadcast(".x/y").expect("create hidden"); + let hidden = pub_origin.create_broadcast(Path::new(".x/y").unwrap()).expect("create hidden"); hidden.announce(Default::default()).expect("announce hidden"); let track = hidden.create_track("video", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); @@ -316,7 +317,7 @@ async fn hidden_broadcasts_need_a_lite07_opt_in() { // Announced after the hidden one, so any client that could see both lists the // hidden one first (the relay drains its table in path order). - let visible = pub_origin.create_broadcast("visible").expect("create visible"); + let visible = pub_origin.create_broadcast(Path::new("visible").unwrap()).expect("create visible"); visible.announce(Default::default()).expect("announce visible"); assert_eq!(announced_until(&mut opted, "visible").await, ["visible"]); @@ -347,7 +348,7 @@ async fn hidden_broadcasts_need_a_lite07_opt_in() { continue; } let bc = consumer - .request_broadcast(".x/y", None) + .request_broadcast(Path::new(".x/y").unwrap(), None) .await .expect("hidden broadcast resolves"); let mut sub = bc.track("video").unwrap().subscribe(None).await.expect("subscribe"); @@ -485,7 +486,7 @@ async fn relay_websocket_root_path_upgrades() { // ── publisher ─────────────────────────────────────────────────── let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast("test").expect("create broadcast"); + let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let track = broadcast.create_track("video", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); @@ -519,7 +520,7 @@ async fn relay_websocket_root_path_upgrades() { .await .expect("announcement timeout") .expect("origin closed"); - let path = moq_net::Path::new(update.prefix.as_str()).to_owned(); + let path = moq_net::Path::new(update.prefix.as_str()).unwrap().to_owned(); assert!(active, "expected announce, got retraction"); assert_eq!(path.as_str(), "test"); let bc = sub_consumer @@ -618,7 +619,7 @@ async fn internal_tcp_round_trip() { // ── publisher ─────────────────────────────────────────────────── let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast("test").expect("create broadcast"); + let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let track = broadcast.create_track("video", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); @@ -657,7 +658,7 @@ async fn internal_tcp_round_trip() { .await .expect("announcement timeout") .expect("origin closed"); - let path = moq_net::Path::new(update.prefix.as_str()).to_owned(); + let path = moq_net::Path::new(update.prefix.as_str()).unwrap().to_owned(); assert!(active, "expected announce, got retraction"); assert_eq!(path.as_str(), "test"); let bc = sub_consumer @@ -721,7 +722,7 @@ async fn internal_unix_round_trip() { // ── publisher ─────────────────────────────────────────────────── let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast("test").expect("create broadcast"); + let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let track = broadcast.create_track("video", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); @@ -760,7 +761,7 @@ async fn internal_unix_round_trip() { .expect("origin closed"); assert_eq!(update.prefix.as_str(), "test"); assert!(active, "expected announce, got retraction"); - let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast("test", None)) + let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast(Path::new("test").unwrap(), None)) .await .expect("request timeout") .expect("announced broadcast resolves"); @@ -813,7 +814,7 @@ fn path_versions() -> Vec { /// to that root). async fn path_round_trip(version: moq_net::Version, pub_url: url::Url, sub_url: url::Url, broadcast: &str) -> String { let pub_origin = moq_tokio::origin::spawn(); - let bc = pub_origin.create_broadcast(broadcast).expect("create broadcast"); + let bc = pub_origin.create_broadcast(Path::new(broadcast).unwrap()).expect("create broadcast"); bc.announce(Default::default()).expect("create broadcast"); let track = bc.create_track("video", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); @@ -841,7 +842,7 @@ async fn path_round_trip(version: moq_net::Version, pub_url: url::Url, sub_url: .await .expect("announcement timeout") .expect("origin closed"); - let path = moq_net::Path::new(update.prefix.as_str()).to_owned(); + let path = moq_net::Path::new(update.prefix.as_str()).unwrap().to_owned(); drop(track); drop(bc); diff --git a/rs/moq-relay/tests/integration/upstream_links.rs b/rs/moq-relay/tests/integration/upstream_links.rs index bef034a7554..708ffee9c61 100644 --- a/rs/moq-relay/tests/integration/upstream_links.rs +++ b/rs/moq-relay/tests/integration/upstream_links.rs @@ -7,6 +7,7 @@ //! dialed path: `/upstream` admits the dialer as an upstream peer, `/peer` as a //! plain one. +use moq_net::Path; use std::collections::BTreeMap; use std::time::Duration; @@ -151,7 +152,7 @@ impl Drop for Publisher { } fn publish(origin: &origin::Producer, path: &str) -> Publisher { - let broadcast = origin.publish(path, Default::default()).expect("publish"); + let broadcast = origin.publish(Path::new(path).unwrap(), Default::default()).expect("publish"); let track = broadcast.create_track("video", timed()).expect("create track"); let writer = tokio::spawn(async move { loop { @@ -172,7 +173,7 @@ fn publish(origin: &origin::Producer, path: &str) -> Publisher { /// Subscribe to `path` through `origin`'s routes and read one frame. async fn read_frame(origin: &origin::Producer, path: &str) { let consumer = origin.consume(); - let broadcast = within(&format!("route to {path}"), consumer.routed_broadcast(path)) + let broadcast = within(&format!("route to {path}"), consumer.routed_broadcast(Path::new(path).unwrap())) .await .unwrap_or_else(|err| panic!("{path} unroutable: {err}")); let subscription = moq_net::track::Subscription::default().with_max_delay(Duration::from_secs(1)); diff --git a/rs/moq-room/src/chat.rs b/rs/moq-room/src/chat.rs index 82b6c807e43..3189803790d 100644 --- a/rs/moq-room/src/chat.rs +++ b/rs/moq-room/src/chat.rs @@ -183,6 +183,7 @@ impl Subscriber { #[cfg(test)] mod tests { use super::*; + use moq_net::Path; #[tokio::test] async fn expires_idle_history_and_late_readers_only_see_retained_messages() { @@ -280,7 +281,7 @@ mod tests { #[tokio::test(start_paused = true)] async fn a_warm_copy_starts_at_the_newest_window() { let publisher = origin(1); - let broadcast = publisher.create_broadcast("room").unwrap(); + let broadcast = publisher.create_broadcast(Path::new("room").unwrap()).unwrap(); let track = broadcast.create_track(TRACK, info()).unwrap(); broadcast.announce(Default::default()).unwrap(); let mut demand = track.demand(); @@ -294,8 +295,8 @@ mod tests { let relay = origin(2); let _link = link(&publisher, &relay).await; let consumer = relay.consume(); - consumer.routed("room").await.unwrap(); - let remote = consumer.request_broadcast("room", None).await.unwrap(); + consumer.routed(Path::new("room").unwrap()).await.unwrap(); + let remote = consumer.request_broadcast(Path::new("room").unwrap(), None).await.unwrap(); // A first reader warms the relay's copy with the first window. { diff --git a/rs/moq-room/src/claims.rs b/rs/moq-room/src/claims.rs index 038273ab370..54fd2385fa2 100644 --- a/rs/moq-room/src/claims.rs +++ b/rs/moq-room/src/claims.rs @@ -25,6 +25,7 @@ pub fn claims(room: impl moq_net::AsPath, identity: impl moq_net::AsPath) -> Res #[cfg(test)] mod tests { use super::*; + use moq_net::Path; fn patterns(texts: &[&str]) -> moq_auth::Patterns { texts.iter().map(|text| text.parse().unwrap()).collect() @@ -33,7 +34,7 @@ mod tests { #[test] fn rejects_empty_identity() { for identity in ["", "/", "///"] { - assert!(matches!(claims("room", identity), Err(crate::Error::EmptyIdentity))); + assert!(matches!(claims(Path::new("room").unwrap(), Path::new(identity).unwrap()), Err(crate::Error::EmptyIdentity))); } } @@ -41,7 +42,7 @@ mod tests { fn rejects_wildcard_identity() { for identity in ["*", "alice*", "a/*/b", "**"] { assert!(matches!( - claims("room", identity), + claims(Path::new("room").unwrap(), Path::new(identity).unwrap()), Err(crate::Error::InvalidIdentity(_)) )); } @@ -49,7 +50,7 @@ mod tests { #[test] fn claims_root_the_token_and_scope_publish_to_identity() { - let c = claims("meet/demo", "alice").unwrap(); + let c = claims(Path::new("meet/demo").unwrap(), Path::new("alice").unwrap()).unwrap(); assert_eq!(c.root, "meet/demo"); assert_eq!(c.subscribe, patterns(&["**"])); assert_eq!(c.publish, patterns(&["alice/**"])); @@ -57,12 +58,12 @@ mod tests { #[test] fn claims_does_not_double_a_trailing_slash() { - assert_eq!(claims("meet/demo", "alice/").unwrap().publish, patterns(&["alice/**"])); + assert_eq!(claims(Path::new("meet/demo").unwrap(), Path::new("alice/").unwrap()).unwrap().publish, patterns(&["alice/**"])); } #[test] fn claims_accepts_a_multi_segment_identity() { - let c = claims("hang/room", "guest/uuid").unwrap(); + let c = claims(Path::new("hang/room").unwrap(), Path::new("guest/uuid").unwrap()).unwrap(); assert_eq!(c.root, "hang/room"); assert_eq!(c.publish, patterns(&["guest/uuid/**"])); } diff --git a/rs/moq-room/src/path.rs b/rs/moq-room/src/path.rs index 4bd2bc15ebe..4b6a9d1274c 100644 --- a/rs/moq-room/src/path.rs +++ b/rs/moq-room/src/path.rs @@ -49,19 +49,16 @@ pub fn kind_from_segment(segment: &str) -> Option { /// Returns `None` when there is no identity, or the last segment is not a kind. pub fn parse(path: impl AsPath) -> Option { let path = path.as_path(); - let mut parts: Vec<&str> = path.parts().collect(); - let last = parts.pop()?; - if parts.is_empty() { - return None; - } + let (identity, last) = path.as_str().rsplit_once('/')?; let kind = kind_from_segment(last)?; - let identity = Path::new(&parts.join("/")).to_owned(); + let identity = Path::new(identity).ok()?.to_owned(); Some(Parsed { identity, kind }) } /// The broadcast path a participant publishes for `kind`. pub fn broadcast_path(identity: impl AsPath, kind: Kind) -> PathOwned { - identity.as_path().join(format!("{}.hang", kind.as_str())) + let segment = PathOwned::try_from(format!("{}.hang", kind.as_str())).expect("a kind is one segment"); + identity.as_path().join(segment) } #[cfg(test)] @@ -69,20 +66,20 @@ mod tests { use super::*; fn p(s: &str) -> PathOwned { - Path::new(s).to_owned() + Path::new(s).unwrap().to_owned() } #[test] fn parse_splits_identity_and_kind() { assert_eq!( - parse(Path::new("alice/camera")), + parse(Path::new("alice/camera").unwrap()), Some(Parsed { identity: p("alice"), kind: Kind::Camera }) ); assert_eq!( - parse(Path::new("alice/screen")), + parse(Path::new("alice/screen").unwrap()), Some(Parsed { identity: p("alice"), kind: Kind::Screen @@ -93,11 +90,11 @@ mod tests { #[test] fn parse_accepts_hang_suffix() { assert_eq!( - parse(Path::new("alice/camera.hang")).map(|p| p.kind), + parse(Path::new("alice/camera.hang").unwrap()).map(|p| p.kind), Some(Kind::Camera) ); assert_eq!( - parse(Path::new("alice/screen.hang")).map(|p| p.kind), + parse(Path::new("alice/screen.hang").unwrap()).map(|p| p.kind), Some(Kind::Screen) ); } @@ -105,7 +102,7 @@ mod tests { #[test] fn parse_keeps_multi_segment_identity() { assert_eq!( - parse(Path::new("guest/uuid/camera")), + parse(Path::new("guest/uuid/camera").unwrap()), Some(Parsed { identity: p("guest/uuid"), kind: Kind::Camera @@ -115,9 +112,9 @@ mod tests { #[test] fn parse_rejects_unknown() { - assert_eq!(parse(Path::new("alice")), None); - assert_eq!(parse(Path::new("alice/chat")), None); - assert_eq!(parse(Path::new("camera")), None); + assert_eq!(parse(Path::new("alice").unwrap()), None); + assert_eq!(parse(Path::new("alice/chat").unwrap()), None); + assert_eq!(parse(Path::new("camera").unwrap()), None); assert_eq!(parse(Path::empty()), None); } diff --git a/rs/moq-room/src/room.rs b/rs/moq-room/src/room.rs index 65c6d54b903..4d77b5433d7 100644 --- a/rs/moq-room/src/room.rs +++ b/rs/moq-room/src/room.rs @@ -163,7 +163,7 @@ mod tests { } fn publish(origin: &origin::Producer, path: &str) -> broadcast::Producer { - let broadcast = origin.create_broadcast(path).expect(path); + let broadcast = origin.create_broadcast(Path::new(path).unwrap()).expect(path); broadcast.announce(Route::default()).expect("announce"); broadcast } @@ -171,7 +171,7 @@ mod tests { #[tokio::test] async fn yields_camera_and_skips_local_and_unknown() { let origin = origin(); - let local = Path::new("alice").to_owned(); + let local = Path::new("alice").unwrap().to_owned(); let mut room = Room::new(&origin.consume(), Some(local)); let _alice = publish(&origin, "alice/camera"); diff --git a/rs/moq-rtc/src/client/mod.rs b/rs/moq-rtc/src/client/mod.rs index 66addbbd070..f448f69f06d 100644 --- a/rs/moq-rtc/src/client/mod.rs +++ b/rs/moq-rtc/src/client/mod.rs @@ -93,6 +93,7 @@ impl Client { #[cfg(test)] mod tests { use super::*; + use moq_net::Path; #[tokio::test] async fn http_error_redacts_url() { @@ -102,7 +103,7 @@ mod tests { drop(listener); let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast("test").expect("create broadcast"); + let broadcast = origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); let url = format!("http://user:pass@{address}/whep/test?jwt=secret") .parse() .expect("WHEP URL"); diff --git a/rs/moq-rtc/src/egress.rs b/rs/moq-rtc/src/egress.rs index 9b3fea6c687..05694e23f29 100644 --- a/rs/moq-rtc/src/egress.rs +++ b/rs/moq-rtc/src/egress.rs @@ -602,6 +602,7 @@ pub fn dispatch(rtc: &mut str0m::Rtc, request: WriteRequest, wallclock: Instant) #[cfg(test)] #[expect(clippy::disallowed_methods, reason = "tests read the host clock directly")] mod tests { + use moq_net::Path; /// Build an origin producer, spawning its driver on the ambient runtime. fn produce_origin() -> moq_net::origin::Producer { let (producer, driver) = moq_net::origin::Producer::new(moq_net::origin::Config::default()); @@ -622,7 +623,7 @@ mod tests { #[test] fn catalog_codecs_ignores_codecs_available_only_via_escaping_references() { let origin = produce_origin(); - let source = moq_mux::Source::new(origin.consume(), origin.create_broadcast("a/pub").unwrap().consume()); + let source = moq_mux::Source::new(origin.consume(), origin.create_broadcast(Path::new("a/pub").unwrap()).unwrap().consume()); let mut catalog = Catalog::default(); let mut escaped_audio = AudioConfig::new(AudioCodec::Opus, 48_000, 2); @@ -657,7 +658,7 @@ mod tests { #[test] fn picks_the_best_video_rendition_whatever_its_name() { let origin = produce_origin(); - let source = moq_mux::Source::new(origin.consume(), origin.create_broadcast("a/pub").unwrap().consume()); + let source = moq_mux::Source::new(origin.consume(), origin.create_broadcast(Path::new("a/pub").unwrap()).unwrap().consume()); let mut catalog = Catalog::default(); let rendition = |height: u32| { @@ -697,7 +698,7 @@ mod tests { #[test] fn picks_the_preferred_codec_whatever_the_peer_offers_first() { let origin = produce_origin(); - let source = moq_mux::Source::new(origin.consume(), origin.create_broadcast("a/pub").unwrap().consume()); + let source = moq_mux::Source::new(origin.consume(), origin.create_broadcast(Path::new("a/pub").unwrap()).unwrap().consume()); let mut catalog = Catalog::default(); // An H.265 source beside its own H.264 compatibility transcode, which has the higher bitrate. @@ -747,7 +748,7 @@ mod tests { #[test] fn picks_the_best_opus_rendition_whatever_its_name() { let origin = produce_origin(); - let source = moq_mux::Source::new(origin.consume(), origin.create_broadcast("a/pub").unwrap().consume()); + let source = moq_mux::Source::new(origin.consume(), origin.create_broadcast(Path::new("a/pub").unwrap()).unwrap().consume()); let mut catalog = Catalog::default(); let opus = |bitrate: Option| { @@ -900,8 +901,8 @@ mod tests { #[tokio::test(start_paused = true)] async fn a_moved_rendition_follows_its_new_track() { let origin = produce_origin(); - let mut live = origin.publish("live", Default::default()).unwrap(); - let mut other = origin.publish("other", Default::default()).unwrap(); + let mut live = origin.publish(Path::new("live").unwrap(), Default::default()).unwrap(); + let mut other = origin.publish(Path::new("other").unwrap(), Default::default()).unwrap(); let mut catalog = moq_mux::catalog::Producer::new(&mut live, moq_mux::catalog::Config::default()).unwrap(); let track = |broadcast: &mut moq_net::broadcast::Producer, name: &str| { let info = moq_net::track::Info::default().with_timescale(moq_net::Timescale::MILLI); @@ -927,7 +928,7 @@ mod tests { }; point(&mut catalog, "a", None); - let broadcast = origin.consume().request_broadcast("live", None).await.unwrap(); + let broadcast = origin.consume().request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); let mut egress = EgressSource::new(moq_mux::Source::new(origin.consume(), broadcast)) .await .unwrap(); @@ -1242,7 +1243,7 @@ mod tests { assert_eq!(written(&mut writes).await.as_ref(), b"low-0"); // The better rendition lives in a broadcast whose request is never answered. - let _handler = origin.dynamic("missing").unwrap(); + let _handler = origin.dynamic(Path::new("missing").unwrap()).unwrap(); let mut config = VideoConfig::new(VideoCodec::VP8); config.container = hang::catalog::Container::Legacy; config.coded_width = Some(1920); diff --git a/rs/moq-rtc/src/lib.rs b/rs/moq-rtc/src/lib.rs index e62d042d533..0bee36778b7 100644 --- a/rs/moq-rtc/src/lib.rs +++ b/rs/moq-rtc/src/lib.rs @@ -72,6 +72,7 @@ pub use server::{Response, Server, whep, whip}; #[cfg(all(test, feature = "server"))] #[expect(clippy::disallowed_methods, reason = "tests read the host clock directly")] mod tests { + use moq_net::Path; use std::time::Duration; /// The next route and whether it is active. @@ -153,7 +154,7 @@ mod tests { origin: &moq_net::origin::Producer, epoch: moq_net::Epoch, ) -> (Box, moq_mux::catalog::Producer) { - let mut broadcast = origin.create_broadcast("source").expect("create source broadcast"); + let mut broadcast = origin.create_broadcast(Path::new("source").unwrap()).expect("create source broadcast"); broadcast .announce(moq_net::origin::Route::default().with_epoch(epoch)) .expect("announce source broadcast"); @@ -167,7 +168,7 @@ mod tests { /// Publish a replacement instance of `source`, returning once the origin serves it. async fn take_over(origin: &moq_net::origin::Producer) -> (Box, moq_mux::catalog::Producer) { let epoch = moq_net::Epoch::mint(); - let mut instances = moq_mux::follow::Instances::new(&origin.consume(), "source", Some(&epoch)).unwrap(); + let mut instances = moq_mux::follow::Instances::new(&origin.consume(), Path::new("source").unwrap(), Some(&epoch)).unwrap(); let (mut new, catalog) = publish_opus(origin, epoch); push(&mut *new, 20_000, NEW_PACKET); let started = tokio::time::timeout(TIMEOUT, instances.next()) @@ -204,7 +205,7 @@ mod tests { let origin = whep_origin.clone(); let sessions = sessions_tx.clone(); async move { - let response = server::whep::accept(&server, &origin, "source", &offer).await.unwrap(); + let response = server::whep::accept(&server, &origin, Path::new("source").unwrap(), &offer).await.unwrap(); let answer = response.answer.clone(); sessions.send(tokio::spawn(response.run())).await.unwrap(); answer @@ -215,7 +216,7 @@ mod tests { let output_origin = moq_tokio::origin::spawn(); let output = output_origin - .create_broadcast("output") + .create_broadcast(Path::new("output").unwrap()) .expect("create output broadcast"); let output_consumer = output.consume(); let client = Client::new(client::Config::default()); @@ -263,7 +264,7 @@ mod tests { let server = server.clone(); let origin = whip_origin.clone(); async move { - let response = server::whip::accept(&server, &origin, "ingested", &offer) + let response = server::whip::accept(&server, &origin, Path::new("ingested").unwrap(), &offer) .await .unwrap(); let answer = response.answer.clone(); @@ -277,13 +278,13 @@ mod tests { let client = Client::new(client::Config::default()); let url = format!("http://{address}/whip/ingested").parse().expect("WHIP URL"); let source = origin.consume(); - let pushed = tokio::spawn(async move { client.publish(url, source, "source").await }); + let pushed = tokio::spawn(async move { client.publish(url, source, Path::new("source").unwrap()).await }); let ingested = ingest_origin.consume(); - tokio::time::timeout(TIMEOUT, ingested.routed("ingested")) + tokio::time::timeout(TIMEOUT, ingested.routed(Path::new("ingested").unwrap())) .await .expect("WHIP negotiation timed out") .expect("the ingest origin closed"); - let ingested = ingested.request_broadcast("ingested", None).await.unwrap(); + let ingested = ingested.request_broadcast(Path::new("ingested").unwrap(), None).await.unwrap(); let mut played = opus_output(&ingested).await; assert_eq!(next_payload(&mut played).await, OPUS_PACKET); @@ -311,7 +312,7 @@ mod tests { let source_consumer = source_origin.consume(); let mut announcements = source_consumer.announced(); let mut source = source_origin - .create_broadcast("source") + .create_broadcast(Path::new("source").unwrap()) .expect("create source broadcast"); source .announce(moq_net::origin::Route::default()) @@ -351,7 +352,7 @@ mod tests { let origin = whip_origin.clone(); let sources = whip_sources.clone(); async move { - let response = server::whip::accept(&server, &origin, "ingested", &offer) + let response = server::whip::accept(&server, &origin, Path::new("ingested").unwrap(), &offer) .await .unwrap(); let answer = response.answer.clone(); @@ -369,7 +370,7 @@ mod tests { let origin = whep_origin.clone(); let sources = sources_tx.clone(); async move { - let response = server::whep::accept(&server, &origin, "ingested", &offer) + let response = server::whep::accept(&server, &origin, Path::new("ingested").unwrap(), &offer) .await .unwrap(); let answer = response.answer.clone(); @@ -390,7 +391,7 @@ mod tests { // Each client call resolves once its session ends, so the test drives them aside. let whip_client = tokio::spawn({ let client = client.clone(); - async move { client.publish(whip, source_consumer, "source").await } + async move { client.publish(whip, source_consumer, Path::new("source").unwrap()).await } }); let (whip_id, whip_task) = tokio::time::timeout(TIMEOUT, sources_rx.recv()) .await @@ -399,7 +400,7 @@ mod tests { let output_origin = moq_tokio::origin::spawn(); let output = output_origin - .create_broadcast("output") + .create_broadcast(Path::new("output").unwrap()) .expect("create output broadcast"); let output_consumer = output.consume(); let whep = format!("http://user:pass@{address}/whep/ingested?jwt=secret") @@ -430,7 +431,7 @@ mod tests { // linger; dropping the session, as an interrupt does, ends that at once. let ingested = server_origin .consume() - .request_broadcast("ingested", None) + .request_broadcast(Path::new("ingested").unwrap(), None) .await .unwrap(); assert!(!ingested.is_closed(), "the finished ingest lingers"); diff --git a/rs/moq-rtc/src/server/whep.rs b/rs/moq-rtc/src/server/whep.rs index b3584c4260b..c1d4097df64 100644 --- a/rs/moq-rtc/src/server/whep.rs +++ b/rs/moq-rtc/src/server/whep.rs @@ -97,7 +97,7 @@ async fn accept_offer( return Err(Error::InvalidSdp("expected Content-Type: application/sdp".into())); } let offer = std::str::from_utf8(&body).map_err(|err| Error::InvalidSdp(err.to_string()))?; - accept(server, subscriber, path, offer).await + accept(server, subscriber, moq_net::Path::new(path)?, offer).await } #[cfg(feature = "server")] @@ -215,7 +215,7 @@ async fn resolve(subscriber: &moq_net::origin::Consumer, path: moq_net::Path<'_> #[cfg(feature = "server")] fn status_for(err: &Error) -> StatusCode { match err { - Error::InvalidSdp(_) => StatusCode::BAD_REQUEST, + Error::InvalidSdp(_) | Error::Moq(moq_net::Error::EmptySegment) => StatusCode::BAD_REQUEST, Error::UnsupportedCodec(_) => StatusCode::UNSUPPORTED_MEDIA_TYPE, Error::SessionNotFound => StatusCode::NOT_FOUND, Error::Moq(moq_net::Error::Unauthorized) => StatusCode::UNAUTHORIZED, @@ -226,6 +226,7 @@ fn status_for(err: &Error) -> StatusCode { #[cfg(test)] mod tests { + use moq_net::Path; use std::time::Duration; use bytes::Bytes; @@ -283,7 +284,7 @@ mod tests { async fn a_broadcast_resolves_through_a_lazy_client_session() { let pub_origin = moq_tokio::origin::spawn(); - let mut source = pub_origin.create_broadcast("cam").expect("create broadcast"); + let mut source = pub_origin.create_broadcast(Path::new("cam").unwrap()).expect("create broadcast"); source .announce(moq_net::origin::Route::default()) .expect("announce broadcast"); @@ -298,7 +299,7 @@ mod tests { let (sub_origin, _connection, accept) = lazy_client(pub_origin).await; - let resolved = super::resolve(&sub_origin.consume(), moq_net::Path::new("cam")) + let resolved = super::resolve(&sub_origin.consume(), moq_net::Path::new("cam").unwrap()) .await .expect("the broadcast resolves"); assert!(!resolved.catalog_codecs().is_empty()); @@ -312,14 +313,14 @@ mod tests { #[tokio::test] async fn offers_ride_the_routers_scope_watch() { let pub_origin = moq_tokio::origin::spawn(); - let other = pub_origin.create_broadcast("other").expect("create broadcast"); + let other = pub_origin.create_broadcast(Path::new("other").unwrap()).expect("create broadcast"); other .announce(moq_net::origin::Route::default()) .expect("announce broadcast"); let (sub_origin, _connection, accept) = lazy_client(pub_origin).await; let _router = super::router(crate::server::Server::new(Default::default()), sub_origin.consume()); - let missing = sub_origin.consume().follow("missing").expect("follow"); + let missing = sub_origin.consume().follow(Path::new("missing").unwrap()).expect("follow"); moq_clock::timeout(TIMEOUT, missing.synced()) .await .expect("sync timed out"); @@ -327,7 +328,7 @@ mod tests { // Nothing watches `other` on its own, yet the synced lookup already discovered it. sub_origin .consume() - .request_broadcast("other", None) + .request_broadcast(Path::new("other").unwrap(), None) .await .expect("discovered through the scope watch"); diff --git a/rs/moq-rtc/src/server/whip.rs b/rs/moq-rtc/src/server/whip.rs index 9e8d6ad78e1..20a7fc1a365 100644 --- a/rs/moq-rtc/src/server/whip.rs +++ b/rs/moq-rtc/src/server/whip.rs @@ -81,7 +81,7 @@ async fn accept_offer( return Err(Error::InvalidSdp("expected Content-Type: application/sdp".into())); } let offer = std::str::from_utf8(&body).map_err(|err| Error::InvalidSdp(err.to_string()))?; - accept(server, publisher, path, offer).await + accept(server, publisher, moq_net::Path::new(path)?, offer).await } #[cfg(feature = "server")] @@ -187,7 +187,7 @@ fn is_sdp(headers: &HeaderMap) -> bool { #[cfg(feature = "server")] fn status_for(err: &Error) -> StatusCode { match err { - Error::InvalidSdp(_) => StatusCode::BAD_REQUEST, + Error::InvalidSdp(_) | Error::Moq(moq_net::Error::EmptySegment) => StatusCode::BAD_REQUEST, Error::UnsupportedCodec(_) => StatusCode::UNSUPPORTED_MEDIA_TYPE, Error::SessionNotFound => StatusCode::NOT_FOUND, Error::Moq(moq_net::Error::Unauthorized) => StatusCode::UNAUTHORIZED, @@ -222,8 +222,8 @@ mod tests { let server = Server::new(crate::server::Config::default()); let origin = moq_tokio::origin::spawn(); let consumer = origin.consume(); - let session = accept(&server, &origin, "live/cam0", &offer()).await.unwrap(); - let broadcast = consumer.request_broadcast("live/cam0", None).await.unwrap(); + let session = accept(&server, &origin, moq_net::Path::new("live/cam0").unwrap(), &offer()).await.unwrap(); + let broadcast = consumer.request_broadcast(moq_net::Path::new("live/cam0").unwrap(), None).await.unwrap(); let mut catalog = broadcast .track(hang::Catalog::DEFAULT_NAME) .unwrap() @@ -251,8 +251,8 @@ mod tests { let server = Server::new(crate::server::Config::default()); let origin = moq_tokio::origin::spawn(); let consumer = origin.consume(); - let _stale_session = accept(&server, &origin, "live/cam0", &offer()).await.unwrap(); - let stale = consumer.request_broadcast("live/cam0", None).await.unwrap(); + let _stale_session = accept(&server, &origin, moq_net::Path::new("live/cam0").unwrap(), &offer()).await.unwrap(); + let stale = consumer.request_broadcast(moq_net::Path::new("live/cam0").unwrap(), None).await.unwrap(); let mut catalog = stale .track(hang::Catalog::DEFAULT_NAME) .unwrap() @@ -260,7 +260,7 @@ mod tests { .await .unwrap(); - let _fresh_session = accept(&server, &origin, "live/cam0", &offer()).await.unwrap(); + let _fresh_session = accept(&server, &origin, moq_net::Path::new("live/cam0").unwrap(), &offer()).await.unwrap(); // The session binds a real UDP socket, so this runs on the wall clock. let stale_viewer = tokio::time::timeout(std::time::Duration::from_millis(200), async { loop { @@ -272,7 +272,7 @@ mod tests { }) .await; assert!(stale_viewer.is_err(), "the stale viewer ended: {stale_viewer:?}"); - let fresh = consumer.request_broadcast("live/cam0", None).await.unwrap(); + let fresh = consumer.request_broadcast(moq_net::Path::new("live/cam0").unwrap(), None).await.unwrap(); assert!(!fresh.is_clone(&stale), "viewers reach the reconnected session"); } } diff --git a/rs/moq-rtmp/src/dial.rs b/rs/moq-rtmp/src/dial.rs index 03232084290..66ae0d84202 100644 --- a/rs/moq-rtmp/src/dial.rs +++ b/rs/moq-rtmp/src/dial.rs @@ -569,7 +569,7 @@ impl Publisher { fn new(origin: &origin::Producer, path: &str, config: moq_mux::catalog::Config) -> anyhow::Result { let epoch = moq_net::Epoch::mint(); let mut broadcast = origin - .publish(path, moq_net::origin::Route::default().with_epoch(epoch.clone())) + .publish(&moq_net::Path::new(path)?, moq_net::origin::Route::default().with_epoch(epoch.clone())) .map_err(|err| anyhow::anyhow!("broadcast '{path}' could not be published: {err}"))?; let catalog = moq_mux::catalog::Producer::new(&mut broadcast, config)?; let handle = broadcast.clone(); @@ -629,6 +629,7 @@ impl Publisher { reason = "tests read the host clock directly" )] mod tests { + use moq_net::Path; use std::time::Duration; use super::*; @@ -696,7 +697,7 @@ mod tests { let mut vframe = vec![0x17, 0x01, 0x00, 0x00, 0x00]; vframe.extend_from_slice(&[0, 0, 0, 5, 0x65, 0x88, 0x84, 0x21, 0x00]); - let mut broadcast = origin.create_broadcast("live/cam0").unwrap(); + let mut broadcast = origin.create_broadcast(Path::new("live/cam0").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); let mut importer = FlvImport::new(broadcast.clone(), catalog.reserve()); @@ -726,27 +727,27 @@ mod tests { let server = tokio::spawn(async move { match accept_stream(server_io, peer).await.unwrap().unwrap() { Request::Publish(publish) => { - publish.with_linger(linger).accept(&ingest, "live/cam0").await.unwrap() + publish.with_linger(linger).accept(&ingest, Path::new("live/cam0").unwrap()).await.unwrap() } - Request::Play(play) => play.accept(&served, "live/cam0").await.unwrap(), + Request::Play(play) => play.accept(&served, Path::new("live/cam0").unwrap()).await.unwrap(), } }); let exported = upstream.consume(); let client = tokio::spawn(async move { let client = Client::with_stream(client_io, "live").await.unwrap(); match push { - true => client.publish("cam0", exported, "live/cam0").await.unwrap(), + true => client.publish("cam0", exported, Path::new("live/cam0").unwrap()).await.unwrap(), false => client .with_linger(linger) - .pull("cam0", &pulled, "live/cam0") + .pull("cam0", &pulled, Path::new("live/cam0").unwrap()) .await .unwrap(), } }); let consumer = downstream.consume(); - consumer.routed("live/cam0").await.unwrap(); - let copy = consumer.request_broadcast("live/cam0", None).await.unwrap(); + consumer.routed(Path::new("live/cam0").unwrap()).await.unwrap(); + let copy = consumer.request_broadcast(Path::new("live/cam0").unwrap(), None).await.unwrap(); // The catalog goes out once the keyframe landed, so the copy holds media to linger with. let mut listed = copy.track("catalog.json").unwrap().subscribe(None).await.unwrap(); assert!(listed.recv_group().await.unwrap().is_some()); @@ -786,7 +787,7 @@ mod tests { vseq.extend_from_slice(&[0x01, 0x00, 0x04, 0x68, 0xce, 0x3c, 0x80]); let mut vframe = vec![0x17, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, idr.len() as u8]; vframe.extend_from_slice(idr); - let mut broadcast = origin.create_broadcast("live/cam0").unwrap(); + let mut broadcast = origin.create_broadcast(Path::new("live/cam0").unwrap()).unwrap(); broadcast .announce(origin::Route::default().with_epoch(epoch.clone())) .unwrap(); @@ -810,18 +811,18 @@ mod tests { else { panic!("expected a publish request"); }; - let _ = publish.accept(&ingest, "live/cam0").await; + let _ = publish.accept(&ingest, Path::new("live/cam0").unwrap()).await; }); let exported = upstream.consume(); let pushed = tokio::spawn(async move { let client = Client::with_stream(client_io, "live").await.unwrap(); - client.publish("cam0", exported, "live/cam0").await + client.publish("cam0", exported, Path::new("live/cam0").unwrap()).await }); // Read what reaches the remote back out as FLV. let consumer = downstream.consume(); - consumer.routed("live/cam0").await.unwrap(); - let copy = consumer.request_broadcast("live/cam0", None).await.unwrap(); + consumer.routed(Path::new("live/cam0").unwrap()).await.unwrap(); + let copy = consumer.request_broadcast(Path::new("live/cam0").unwrap(), None).await.unwrap(); let source = moq_mux::Source::new(consumer, copy); let catalog = source .catalog::<()>(moq_mux::catalog::CatalogFormat::default()) @@ -838,7 +839,7 @@ mod tests { until(OLD_IDR).await; let epoch = moq_net::Epoch::mint(); - let mut instances = moq_mux::follow::Instances::new(&upstream.consume(), "live/cam0", Some(&epoch)).unwrap(); + let mut instances = moq_mux::follow::Instances::new(&upstream.consume(), Path::new("live/cam0").unwrap(), Some(&epoch)).unwrap(); let (_new, _new_catalog) = publish(&upstream, &epoch, NEW_IDR); tokio::time::timeout(Duration::from_secs(5), instances.next()) .await @@ -877,7 +878,7 @@ mod tests { vframe.extend_from_slice(&[0, 0, 0, 5, 0x65, 0x88, 0x84, 0x21, 0x00]); let server_origin = moq_tokio::origin::spawn(); - let mut broadcast = server_origin.create_broadcast("live/cam0").unwrap(); + let mut broadcast = server_origin.create_broadcast(Path::new("live/cam0").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); let mut importer = FlvImport::new(broadcast, catalog.reserve()); @@ -895,7 +896,7 @@ mod tests { let Request::Play(play) = request else { panic!("expected a play request"); }; - play.accept(&consumer, "live/cam0").await.unwrap(); + play.accept(&consumer, Path::new("live/cam0").unwrap()).await.unwrap(); }); // Client: dial, connect(`live`), play(`cam0`), republish into our own origin. @@ -904,15 +905,15 @@ mod tests { let pull_origin = client_origin.clone(); let pull = tokio::spawn(async move { let client = Client::connect(addr, "live").await.unwrap(); - client.pull("cam0", &pull_origin, "pulled/cam0").await.unwrap(); + client.pull("cam0", &pull_origin, Path::new("pulled/cam0").unwrap()).await.unwrap(); }); // The republished broadcast should show up in the client's origin. - tokio::time::timeout(Duration::from_secs(5), announced.routed("pulled/cam0")) + tokio::time::timeout(Duration::from_secs(5), announced.routed(Path::new("pulled/cam0").unwrap())) .await .expect("client republish timed out") .expect("broadcast announced in client origin"); - let broadcast = announced.request_broadcast("pulled/cam0", None).await.unwrap(); + let broadcast = announced.request_broadcast(Path::new("pulled/cam0").unwrap(), None).await.unwrap(); // It should carry a hang catalog track (proof the FLV demux produced real // media on the far side): subscribe to it and read one catalog frame. diff --git a/rs/moq-rtmp/src/server.rs b/rs/moq-rtmp/src/server.rs index d30a6eb3e45..5823783c5ae 100644 --- a/rs/moq-rtmp/src/server.rs +++ b/rs/moq-rtmp/src/server.rs @@ -1499,7 +1499,10 @@ impl Publisher { /// the FLV file header, so subsequent tags decode against an initialized demuxer. fn new(origin: &origin::Producer, path: &str, config: moq_mux::catalog::Config) -> anyhow::Result { let epoch = moq_net::Epoch::mint(); - let mut broadcast = origin.publish(path, moq_net::origin::Route::default().with_epoch(epoch.clone()))?; + let mut broadcast = origin.publish( + &moq_net::Path::new(path)?, + moq_net::origin::Route::default().with_epoch(epoch.clone()), + )?; let catalog = moq_mux::catalog::Producer::new(&mut broadcast, config)?; let handle = broadcast.clone(); let mut importer = FlvImport::new(broadcast, catalog.reserve()); @@ -1565,6 +1568,7 @@ impl Publisher { )] mod tests { use super::*; + use moq_net::Path; #[tokio::test(start_paused = true)] #[tracing_test::traced_test] async fn publish_metadata_drops_warn_once() { @@ -1741,7 +1745,7 @@ mod tests { let Some(Request::Publish(publish)) = accept_stream(stream, peer).await.unwrap() else { panic!("expected a publish request"); }; - publish.with_linger(linger).accept(&origin, "live/cam0").await.unwrap(); + publish.with_linger(linger).accept(&origin, Path::new("live/cam0").unwrap()).await.unwrap(); } /// An unpublish is a clean end: the finished broadcast stays up for the linger, then @@ -1758,8 +1762,8 @@ mod tests { let start = tokio::time::Instant::now(); let accept = tokio::spawn(accept_publish(server, origin.clone(), Duration::from_secs(10))); let broadcast = async { - consumer.routed("live/cam0").await.unwrap(); - consumer.request_broadcast("live/cam0", None).await.unwrap() + consumer.routed(Path::new("live/cam0").unwrap()).await.unwrap(); + consumer.request_broadcast(Path::new("live/cam0").unwrap(), None).await.unwrap() }; let (broadcast, ()) = tokio::join!(broadcast, publish_one_keyframe(client, leave)); @@ -1778,8 +1782,8 @@ mod tests { let (mut client, server) = tokio::io::duplex(64 * 1024); let accept = tokio::spawn(accept_publish(server, origin.clone(), Duration::ZERO)); let catalog = async { - consumer.routed("live/cam0").await.unwrap(); - let broadcast = consumer.request_broadcast("live/cam0", None).await.unwrap(); + consumer.routed(Path::new("live/cam0").unwrap()).await.unwrap(); + let broadcast = consumer.request_broadcast(Path::new("live/cam0").unwrap(), None).await.unwrap(); let track = broadcast.track(hang::Catalog::DEFAULT_NAME).unwrap(); track.subscribe(None).await.unwrap() }; @@ -1808,7 +1812,7 @@ mod tests { publish_one_keyframe(client, Leave::Unpublish).await; tokio::time::sleep(Duration::from_secs(5)).await; - let finished = consumer.request_broadcast("live/cam0", None).await.unwrap(); + let finished = consumer.request_broadcast(Path::new("live/cam0").unwrap(), None).await.unwrap(); let mut video = finished.track("0.flv-v").unwrap().subscribe(None).await.unwrap(); assert!( video.recv_group().await.unwrap().is_some(), @@ -2089,8 +2093,8 @@ mod tests { publisher.push(flv::TAG_VIDEO, 0, &vseq).unwrap(); let consumer = origin.consume(); - consumer.routed("live/cam0").await.unwrap(); - let broadcast = consumer.request_broadcast("live/cam0", None).await.unwrap(); + consumer.routed(Path::new("live/cam0").unwrap()).await.unwrap(); + let broadcast = consumer.request_broadcast(Path::new("live/cam0").unwrap(), None).await.unwrap(); let info = broadcast.track("0.flv-v").unwrap().query().await.unwrap(); assert_eq!(info.max_age, Some(Duration::from_secs(3))); } @@ -2117,7 +2121,7 @@ mod tests { // Publish the broadcast at `live/cam0` by feeding synthetic FLV to the importer. let origin = moq_tokio::origin::spawn(); - let mut broadcast = origin.create_broadcast("live/cam0").unwrap(); + let mut broadcast = origin.create_broadcast(Path::new("live/cam0").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); let mut importer = FlvImport::new(broadcast, catalog.reserve()); @@ -2136,7 +2140,7 @@ mod tests { let Request::Play(play) = request else { panic!("expected a play request"); }; - play.accept(&consumer, "live/cam0").await.unwrap(); + play.accept(&consumer, Path::new("live/cam0").unwrap()).await.unwrap(); }); let stream = TcpStream::connect(addr).await.unwrap(); @@ -2173,7 +2177,7 @@ mod tests { let mut vframe = vec![0x17, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, idr.len() as u8]; vframe.extend_from_slice(idr); - let mut broadcast = origin.create_broadcast("live/cam0").unwrap(); + let mut broadcast = origin.create_broadcast(Path::new("live/cam0").unwrap()).unwrap(); broadcast.announce(origin::Route::default().with_epoch(epoch)).unwrap(); let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); let mut importer = FlvImport::new(broadcast, catalog.reserve()); @@ -2200,7 +2204,7 @@ mod tests { let Some(Request::Play(play)) = server.accept().await else { panic!("expected a play request"); }; - play.accept(&play_origin, "live/cam0").await + play.accept(&play_origin, Path::new("live/cam0").unwrap()).await }); let (tx, mut media) = tokio::sync::mpsc::unbounded_channel(); let client = tokio::spawn(play_client(TcpStream::connect(addr).await.unwrap(), 0, &[], tx)); @@ -2215,7 +2219,7 @@ mod tests { assert_eq!(next().await.1[..2], [0x17, 0x01]); let epoch = moq_net::Epoch::mint(); - let mut instances = moq_mux::follow::Instances::new(&consumer, "live/cam0", Some(&epoch)).unwrap(); + let mut instances = moq_mux::follow::Instances::new(&consumer, Path::new("live/cam0").unwrap(), Some(&epoch)).unwrap(); let (_new, _new_catalog) = publish_avc(&origin, epoch, &[0x65, 0x99, 0x99, 0x99, 0x99]); tokio::time::timeout(Duration::from_secs(5), instances.next()) .await @@ -2244,7 +2248,7 @@ mod tests { const VP9_KEYFRAME_320X240: &[u8] = &[0x82, 0x49, 0x83, 0x42, 0x20, 0x13, 0xf0, 0x0e, 0xf0, 0x00]; let origin = moq_tokio::origin::spawn(); - let mut broadcast = origin.create_broadcast("live/cam0").unwrap(); + let mut broadcast = origin.create_broadcast(Path::new("live/cam0").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); let mut importer = FlvImport::new(broadcast, catalog.reserve()); @@ -2266,7 +2270,7 @@ mod tests { let Request::Play(play) = request else { panic!("expected a play request"); }; - play.accept(&consumer, "live/cam0").await.unwrap(); + play.accept(&consumer, Path::new("live/cam0").unwrap()).await.unwrap(); }); let stream = TcpStream::connect(addr).await.unwrap(); @@ -2521,7 +2525,7 @@ mod tests { let frames = multitrack_body(CODED_FRAMES, &[(0, nalu(0x88)), (1, nalu(0x99))]); let origin = moq_tokio::origin::spawn(); - let mut broadcast = origin.create_broadcast("live/cam0").unwrap(); + let mut broadcast = origin.create_broadcast(Path::new("live/cam0").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); let mut importer = FlvImport::new(broadcast, catalog.reserve()); @@ -2539,7 +2543,7 @@ mod tests { let Request::Play(play) = request else { panic!("expected a play request"); }; - play.accept(&consumer, "live/cam0").await.unwrap(); + play.accept(&consumer, Path::new("live/cam0").unwrap()).await.unwrap(); }); // The player advertises multitrack; collect the four video messages (two @@ -2595,7 +2599,7 @@ mod tests { tokio::time::pause(); let server_task = tokio::spawn(async move { - play.accept(&consumer, "live/missing").await.unwrap(); + play.accept(&consumer, Path::new("live/missing").unwrap()).await.unwrap(); }); tokio::task::yield_now().await; @@ -2657,18 +2661,18 @@ mod tests { panic!("expected a publish request"); }; let origin = origin.clone(); - tokio::spawn(async move { publish.accept(&origin, "live/cam0").await }); + tokio::spawn(async move { publish.accept(&origin, Path::new("live/cam0").unwrap()).await }); } }); let stale_client = tokio::spawn(async move { run_client(TcpStream::connect(addr).await.unwrap(), ClientMode::Publish).await; }); - tokio::time::timeout(Duration::from_secs(5), consumer.routed("live/cam0")) + tokio::time::timeout(Duration::from_secs(5), consumer.routed(Path::new("live/cam0").unwrap())) .await .expect("stale publish timed out") .unwrap(); - let stale = consumer.request_broadcast("live/cam0", None).await.unwrap(); + let stale = consumer.request_broadcast(Path::new("live/cam0").unwrap(), None).await.unwrap(); let mut catalog = stale .track(hang::Catalog::DEFAULT_NAME) .unwrap() @@ -2698,7 +2702,7 @@ mod tests { assert!(stale_viewer.is_err(), "the stale viewer ended: {stale_viewer:?}"); assert!(!stale_client.is_finished(), "the stale connection is still open"); - let fresh = consumer.request_broadcast("live/cam0", None).await.unwrap(); + let fresh = consumer.request_broadcast(Path::new("live/cam0").unwrap(), None).await.unwrap(); assert!(!fresh.is_clone(&stale), "viewers reach the reconnected publish"); stale_client.abort(); diff --git a/rs/moq-rtsp/src/client.rs b/rs/moq-rtsp/src/client.rs index b6d61705174..e9ce518c435 100644 --- a/rs/moq-rtsp/src/client.rs +++ b/rs/moq-rtsp/src/client.rs @@ -549,6 +549,7 @@ impl Ingest { reason = "tests read the host clock directly" )] mod tests { + use moq_net::Path; use std::time::Duration; use super::*; @@ -857,7 +858,7 @@ mod tests { for _ in 0..2 { let epoch = moq_net::Epoch::mint(); let route = moq_net::origin::Route::default().with_epoch(epoch.clone()); - let mut broadcast = origin.publish("camera", route).unwrap(); + let mut broadcast = origin.publish(Path::new("camera").unwrap(), route).unwrap(); let mut catalog = moq_mux::catalog::Producer::new(&mut broadcast, Default::default()).unwrap(); published_tx.send((epoch, broadcast.clone(), catalog.clone())).unwrap(); // The first session to return ends the run; dropping the other's pull diff --git a/rs/moq-srt/src/dial.rs b/rs/moq-srt/src/dial.rs index cc84e22a2c5..55cfbcc03dc 100644 --- a/rs/moq-srt/src/dial.rs +++ b/rs/moq-srt/src/dial.rs @@ -215,6 +215,7 @@ impl Mode { #[cfg(test)] #[expect(clippy::disallowed_methods, reason = "tests read the host clock directly")] mod tests { + use moq_net::Path; /// Build an origin producer, spawning its driver on the ambient runtime. fn produce_origin() -> moq_net::origin::Producer { let (producer, driver) = moq_net::origin::Producer::new(moq_net::origin::Config::default()); @@ -265,7 +266,7 @@ mod tests { // Runs until the caller disconnects, then closes at once. publish .with_linger(Duration::ZERO) - .accept(&origin, "ingested/cam0") + .accept(&origin, Path::new("ingested/cam0").unwrap()) .await .ok(); } @@ -306,7 +307,7 @@ mod tests { let resource = request.resource().to_string(); let is_subscribe = matches!(request, Request::Subscribe(_)); if let Request::Subscribe(subscribe) = request { - subscribe.accept(&consumer, "live/cam0").await.ok(); + subscribe.accept(&consumer, Path::new("live/cam0").unwrap()).await.ok(); } (resource, is_subscribe) }); diff --git a/rs/moq-srt/src/server.rs b/rs/moq-srt/src/server.rs index 8f04a759846..5c4f669163d 100644 --- a/rs/moq-srt/src/server.rs +++ b/rs/moq-srt/src/server.rs @@ -694,6 +694,7 @@ fn parse_stream_id(stream_id: Option<&StreamId>) -> Option<(String, ConnectionMo reason = "tests read the host clock directly" )] mod tests { + use moq_net::Path; use std::time::Instant as StdInstant; use super::*; @@ -913,7 +914,7 @@ mod tests { let (origin, driver) = moq_net::origin::Producer::new(moq_net::origin::Config::default()); tokio::spawn(moq_net::time::run(driver)); - let mut broadcast = origin.create_broadcast("marker").unwrap(); + let mut broadcast = origin.create_broadcast(Path::new("marker").unwrap()).unwrap(); broadcast.announce(moq_net::origin::Route::default()).unwrap(); let mut catalog = moq_mux::catalog::Producer::new( &mut broadcast, @@ -964,7 +965,7 @@ mod tests { panic!("m=request must create a subscribe request"); }; let consumer = origin.consume(); - let egress = tokio::spawn(async move { subscribe.accept(&consumer, "marker").await }); + let egress = tokio::spawn(async move { subscribe.accept(&consumer, Path::new("marker").unwrap()).await }); let mut receiver = caller.await.unwrap(); // Three seconds of program, then wait until the receiver is actually playing it @@ -1023,7 +1024,7 @@ mod tests { impl Instance { fn publish(origin: &moq_net::origin::Producer, track: &str) -> Self { let route = moq_net::origin::Route::default().with_epoch(moq_net::Epoch::mint()); - let mut broadcast = origin.publish("live", route).unwrap(); + let mut broadcast = origin.publish(Path::new("live").unwrap(), route).unwrap(); let mut catalog = moq_mux::catalog::Producer::new( &mut broadcast, moq_mux::catalog::Config::default() @@ -1102,7 +1103,7 @@ mod tests { subscribe .with_follow(follow) .with_stitch(stitch) - .accept(&consumer, "live") + .accept(&consumer, Path::new("live").unwrap()) .await }); (caller.await.unwrap(), task) diff --git a/rs/moq-srt/src/ts.rs b/rs/moq-srt/src/ts.rs index 23fde702674..ff07f95c518 100644 --- a/rs/moq-srt/src/ts.rs +++ b/rs/moq-srt/src/ts.rs @@ -75,15 +75,16 @@ impl Publisher { config: moq_mux::catalog::Config, program: Option, ) -> Result { + let path = moq_net::Path::new(path)?; // Each connection is its own publisher instance, so an encoder reconnecting // under the same stream id replaces the stale broadcast instead of resuming into // it. `ts::Programs` mints one per program likewise. let mut epoch = None; let importer = match program { - Some(Program::All) => Importer::All(Box::new(ts::Programs::new(origin.clone(), path, config))), + Some(Program::All) => Importer::All(Box::new(ts::Programs::new(origin.clone(), &path, config))), Some(Program::One(_)) | None => { let route = moq_net::origin::Route::default().with_epoch(epoch.insert(moq_net::Epoch::mint()).clone()); - let mut broadcast = origin.publish(path, route)?; + let mut broadcast = origin.publish(&path, route)?; let config = config.with_catalog(moq_mux::catalog::hang::Catalog::::default()); let catalog = moq_mux::catalog::Producer::new(&mut broadcast, config)?; let mut import = ts::Import::new(broadcast.clone(), catalog.reserve()); @@ -213,13 +214,14 @@ impl Subscriber { /// consumer's scope, or the origin closed). Otherwise waits for the broadcast /// to be announced, so a caller may connect before the publisher does. pub(crate) async fn new(origin: &origin::Consumer, path: &str, options: Options) -> Result> { - if origin.routed(path).await.is_none() { + let path = moq_net::Path::new(path)?; + if origin.routed(&path).await.is_none() { return Ok(None); } // Join the broadcast just announced. The export resolves any referenced sibling // broadcast (the catalog `broadcast` field) through the same origin. - let broadcast = origin.request_broadcast(path, None).await?; + let broadcast = origin.request_broadcast(&path, None).await?; let source = moq_mux::Source::new(origin.clone(), broadcast); let catalog = source.catalog::(moq_mux::catalog::CatalogFormat::Hang).await?; let export = ts::Export::new(source, catalog).with_delay(options.latency.max(MIN_DELAY)); @@ -255,6 +257,7 @@ impl Subscriber { reason = "tests read the host clock directly" )] mod tests { + use moq_net::Path; use moq_mux::catalog::hang::Container; use moq_mux::catalog::{CatalogFormat, Stream}; use tokio::time::timeout; @@ -475,11 +478,11 @@ mod tests { /// announced. async fn program(origin: &moq_net::origin::Producer, path: &str) -> (u16, Vec) { let consumer = origin.consume(); - timeout(Duration::from_secs(5), consumer.routed(path)) + timeout(Duration::from_secs(5), consumer.routed(Path::new(path).unwrap())) .await .expect("announce timed out") .expect("the broadcast is announced"); - let broadcast = consumer.request_broadcast(path, None).await.unwrap(); + let broadcast = consumer.request_broadcast(Path::new(path).unwrap(), None).await.unwrap(); let mut catalog = moq_mux::catalog::Consumer::::new(&broadcast, CatalogFormat::Hang) .await .unwrap(); @@ -515,7 +518,7 @@ mod tests { let origin = produce_origin(); let consumer = origin.consume(); let _stale = Publisher::new(&origin, "ingest", Default::default(), None).unwrap(); - let stale = consumer.request_broadcast("ingest", None).await.unwrap(); + let stale = consumer.request_broadcast(Path::new("ingest").unwrap(), None).await.unwrap(); let mut catalog = stale .track(hang::Catalog::DEFAULT_NAME) .unwrap() @@ -534,7 +537,7 @@ mod tests { }) .await; assert!(stale_viewer.is_err(), "the stale viewer ended: {stale_viewer:?}"); - let fresh = consumer.request_broadcast("ingest", None).await.unwrap(); + let fresh = consumer.request_broadcast(Path::new("ingest").unwrap(), None).await.unwrap(); assert!(!fresh.is_clone(&stale), "viewers reach the reconnected caller"); } @@ -556,7 +559,7 @@ mod tests { assert_eq!(program(&origin, "ingest/1").await, (1, vec![0x0101])); assert_eq!(program(&origin, "ingest/2").await, (2, vec![0x0201])); assert!( - timeout(Duration::from_secs(1), origin.consume().routed("ingest")) + timeout(Duration::from_secs(1), origin.consume().routed(Path::new("ingest").unwrap())) .await .is_err(), "nothing is published on the bare path" @@ -574,8 +577,8 @@ mod tests { publisher.feed(Bytes::from_static(BBB5S)).unwrap(); let consumer = origin.consume(); - consumer.routed("live/cam0").await.unwrap(); - let broadcast = consumer.request_broadcast("live/cam0", None).await.unwrap(); + consumer.routed(Path::new("live/cam0").unwrap()).await.unwrap(); + let broadcast = consumer.request_broadcast(Path::new("live/cam0").unwrap(), None).await.unwrap(); let start = tokio::time::Instant::now(); let wait = tokio::spawn(publisher.finish(linger).unwrap().wait()); tokio::time::sleep(linger / 2).await; @@ -608,8 +611,8 @@ mod tests { publisher.feed(Bytes::from(ts)).unwrap(); let consumer = origin.consume(); - consumer.routed("live/cam0").await.unwrap(); - let broadcast = consumer.request_broadcast("live/cam0", None).await.unwrap(); + consumer.routed(Path::new("live/cam0").unwrap()).await.unwrap(); + let broadcast = consumer.request_broadcast(Path::new("live/cam0").unwrap(), None).await.unwrap(); let info = broadcast.track("0.avc3").unwrap().query().await.unwrap(); assert_eq!(info.max_age, Some(Duration::from_secs(3))); } @@ -655,11 +658,11 @@ mod tests { let mut publisher = Publisher::new(&origin, "ingest", Default::default(), None).unwrap(); let consumer = origin.consume(); - timeout(Duration::from_secs(5), consumer.routed("ingest")) + timeout(Duration::from_secs(5), consumer.routed(Path::new("ingest").unwrap())) .await .expect("announce timed out") .expect("the ingest broadcast is announced"); - let broadcast = consumer.request_broadcast("ingest", None).await.unwrap(); + let broadcast = consumer.request_broadcast(Path::new("ingest").unwrap(), None).await.unwrap(); publisher.feed(bytes::Bytes::from_static(BBB5S)).unwrap(); diff --git a/rs/moq-stats/benches/aggregate.rs b/rs/moq-stats/benches/aggregate.rs index 6d75d3dd516..b7558db0245 100644 --- a/rs/moq-stats/benches/aggregate.rs +++ b/rs/moq-stats/benches/aggregate.rs @@ -14,6 +14,7 @@ reason = "custom timings measure the real time the work took, not the ambient clock" )] +use moq_net::Path; use std::time::{Duration, Instant}; use moq_net::{Epoch, origin}; @@ -40,7 +41,7 @@ struct Node { impl Node { fn new(origin: &origin::Producer, name: &str) -> Self { let source = origin - .create_broadcast(format!(".stats/acme/node/{name}").as_str()) + .create_broadcast(Path::new(format!(".stats/acme/node/{name}").as_str()).unwrap()) .unwrap(); let epoch = Epoch::mint(); source diff --git a/rs/moq-stats/benches/producer_tick.rs b/rs/moq-stats/benches/producer_tick.rs index b6cf32858e9..813171803a6 100644 --- a/rs/moq-stats/benches/producer_tick.rs +++ b/rs/moq-stats/benches/producer_tick.rs @@ -31,7 +31,7 @@ use std::time::{Duration, Instant}; use criterion::{BenchmarkId, Criterion, Throughput, criterion_group, criterion_main}; use futures::FutureExt; -use moq_net::{announce, broadcast, origin, stats}; +use moq_net::{Path, announce, broadcast, origin, stats}; use moq_stats::produce::bench::{Driver, FrameBytes}; struct Counter; @@ -108,7 +108,7 @@ impl Relay { .iter() .map(|path| { origin - .publish(path.as_str(), origin::Route::default()) + .publish(Path::new(path.as_str()).unwrap(), origin::Route::default()) .expect("publish path") }) .collect(); @@ -116,8 +116,8 @@ impl Relay { let mut sessions = Vec::with_capacity(tiers); let tier_labels: Vec<_> = (0..tiers) .map(|tier| { - let tier = stats::Tier::new(format!("t{tier}")); - let session = registry.tier(tier.clone()).session("root"); + let tier = stats::Tier::new(Path::try_from(format!("t{tier}")).unwrap()); + let session = registry.tier(tier.clone()).session(Path::new("root").unwrap()); let mut cursor = origin.consume().with_stats(session.clone()).announced(); while cursor.next().now_or_never().flatten().is_some() {} cursors.push(cursor); @@ -161,7 +161,7 @@ impl Relay { } for path in self.paths.iter().step_by(self.step) { for tier in &self.tiers { - moq_net::fuzz::bump_publisher_bytes(&self.registry, path.as_str(), tier, 1); + moq_net::fuzz::bump_publisher_bytes(&self.registry, Path::new(path.as_str()).unwrap(), tier, 1); } } } @@ -289,7 +289,7 @@ impl Presence { let names: Vec = (0..labels).map(|index| format!("room/{index:05}")).collect(); let sessions: Vec<_> = names .iter() - .map(|label| registry.tier(stats::Tier::default()).session(label.as_str())) + .map(|label| registry.tier(stats::Tier::default()).session(Path::new(label.as_str()).unwrap())) .collect(); // One set of wire counters per connection, independently of held presence tracks. let wire = sessions diff --git a/rs/moq-stats/src/aggregate.rs b/rs/moq-stats/src/aggregate.rs index 3713a4f742e..d8c67c74474 100644 --- a/rs/moq-stats/src/aggregate.rs +++ b/rs/moq-stats/src/aggregate.rs @@ -86,7 +86,7 @@ impl Config { impl Default for Config { fn default() -> Self { Self { - prefix: PathOwned::from(".stats"), + prefix: moq_net::Path::new(".stats").expect("a literal path"), depth: 0, encoding: Encoding::Plain, // Well above reconnect times; a longer grace only costs memory. @@ -967,6 +967,7 @@ fn resolve(origin: &origin::Consumer, path: &PathOwned, epoch: Opt #[cfg(test)] mod tests { + use moq_net::Path; /// A millisecond track: the frames written here carry timestamps. fn timed() -> moq_net::track::Info { moq_net::track::Info::default().with_timescale(moq_net::Timescale::MILLI) @@ -1010,7 +1011,7 @@ mod tests { Producer::new( produce::Config::new() .with_origin(origin.clone()) - .with_node(PathOwned::from(node.to_string())) + .with_node(Path::try_from(node.to_string()).unwrap()) .with_depth(1), ) } @@ -1030,18 +1031,18 @@ mod tests { /// `tier`/`label`, by driving a throwaway tagged broadcast. The broadcast lives /// on its own origin so it never lands on the stats origin. async fn feed(producer: &Producer, tier: Tier, label: &str, path: &str, bytes: usize) -> Feed { - let ctx = producer.registry().tier(tier).session(label); + let ctx = producer.registry().tier(tier).session(Path::new(label).unwrap()); let feed_origin = produce_origin(); let egress = feed_origin.consume().with_stats(ctx.clone()); let mut announced = egress.announced(); - let source = feed_origin.create_broadcast(path).expect("create_broadcast"); + let source = feed_origin.create_broadcast(Path::new(path).unwrap()).expect("create_broadcast"); source.announce(origin::Route::default()).expect("announce"); let track = source.create_track("video", timed()).expect("create_track"); let (_, active) = next_update(&mut announced).await.expect("announce"); assert!(active); - let consumer = egress.request_broadcast(path, None).await.expect("resolve"); + let consumer = egress.request_broadcast(Path::new(path).unwrap(), None).await.expect("resolve"); let mut sub = consumer.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = track.append_group().unwrap(); @@ -1108,7 +1109,7 @@ mod tests { impl NodeBroadcast { fn new(origin: &origin::Producer, group: &str, node: &str) -> Self { let path = format!(".stats/{group}/node/{node}"); - let source = origin.create_broadcast(path.as_str()).expect("create broadcast"); + let source = origin.create_broadcast(Path::new(path.as_str()).unwrap()).expect("create broadcast"); source.announce(origin::Route::default()).expect("announce"); let name = traffic_track(&Tier::default(), Role::Publisher, Encoding::Plain); let track = source.create_track(name, timed()).expect("create track"); @@ -1295,7 +1296,7 @@ mod tests { #[test] fn outgoing_epoch_metadata_migrates_without_choosing_a_grace_entry() { let origin = produce_origin(); - let path = PathOwned::from(".stats/acme/node/a"); + let path = Path::new(".stats/acme/node/a").unwrap(); let a: Epoch = "01900000-0000-7000-8000-000000000001".parse().unwrap(); let b: Epoch = "01900000-0000-7000-8000-000000000002".parse().unwrap(); let c: Epoch = "01900000-0000-7000-8000-000000000003".parse().unwrap(); @@ -1426,7 +1427,7 @@ mod tests { .unwrap(); assert_eq!(unversioned["acme/room"].bytes, 100); assert!(matches!( - merged.nodes[&(PathOwned::from(".stats/acme/node/a"), None)].reader, + merged.nodes[&(Path::new(".stats/acme/node/a").unwrap(), None)].reader, Reader::Active(_) )); } @@ -1441,7 +1442,7 @@ mod tests { .announce(origin::Route::default().with_epoch(epoch_b.clone())) .unwrap(); new.publish("acme/room", 30); - let pending = origin.consume().request_broadcast(".stats/acme/node/a", None); + let pending = origin.consume().request_broadcast(Path::new(".stats/acme/node/a").unwrap(), None); let front = futures::executor::block_on(kio::wait(|waiter| { driver.poll(now, waiter).unwrap(); pending.poll_ok(waiter) @@ -1466,7 +1467,7 @@ mod tests { (new, front, warm, driver) }); ready.wait(); - let key = (PathOwned::from(".stats/acme/node/a"), (!drop_epoch).then_some(epoch_a)); + let key = (Path::new(".stats/acme/node/a").unwrap(), (!drop_epoch).then_some(epoch_a)); let node = merged.nodes.get_mut(&key).unwrap(); advance(node, &merged.origin, &merged.config, &name, &Waiter::noop()); let old_bytes = node.last.as_ref().unwrap()["acme/room"].bytes; @@ -1761,8 +1762,8 @@ mod tests { // group. let _fa = feed(&node_a, Tier::default(), "acme", "acme/room", 8).await; let _fb = feed(&node_b, Tier::default(), "acme", "acme/room", 8).await; - let _sa = node_a.registry().tier(Tier::default()).session("acme"); - let _sb = node_b.registry().tier(Tier::default()).session("acme"); + let _sa = node_a.registry().tier(Tier::default()).session(Path::new("acme").unwrap()); + let _sb = node_b.registry().tier(Tier::default()).session(Path::new("acme").unwrap()); drive_tick().await; let agg = Consumer::new(origin.consume(), Config::new().with_depth(1)); @@ -1788,8 +1789,8 @@ mod tests { let _fa = feed(&node_a, Tier::default(), "acme", "acme/room", 8).await; let fb = feed(&node_b, Tier::default(), "acme", "acme/room", 8).await; - let _sa = node_a.registry().tier(Tier::default()).session("acme"); - let sb = node_b.registry().tier(Tier::default()).session("acme"); + let _sa = node_a.registry().tier(Tier::default()).session(Path::new("acme").unwrap()); + let sb = node_b.registry().tier(Tier::default()).session(Path::new("acme").unwrap()); drive_tick().await; let agg = Consumer::new(origin.consume(), Config::new().with_depth(1)); @@ -1884,7 +1885,7 @@ mod tests { impl TotalsNode { fn new(origin: &origin::Producer, node: &str) -> Self { let source = origin - .create_broadcast(format!(".stats/acme/node/{node}").as_str()) + .create_broadcast(Path::new(format!(".stats/acme/node/{node}").as_str()).unwrap()) .expect("create broadcast"); source.announce(origin::Route::default()).expect("announce"); let track = source @@ -1938,7 +1939,7 @@ mod tests { /// frames by hand. fn hand_merged() -> (Merged, (PathOwned, Option)) { let origin = produce_origin(); - let path = PathOwned::from(".stats/acme/node/a"); + let path = Path::new(".stats/acme/node/a").unwrap(); let mut merged = Merged::::new(origin.consume(), &Config::new().with_depth(1), "p".into()); merged.apply_announce( moq_net::announce::Announce { @@ -1960,7 +1961,7 @@ mod tests { value.sessions_failed.transport = failed; value }; - let path = PathOwned::from(".stats/acme/node/b"); + let path = Path::new(".stats/acme/node/b").unwrap(); merged.apply_announce( moq_net::announce::Announce { prefix: path.clone(), @@ -2286,7 +2287,7 @@ mod tests { drive_tick().await; let agg = Consumer::new(origin.consume(), Config::new().with_depth(1)); - let mut presence = agg.presence("acme"); + let mut presence = agg.presence(Path::new("acme").unwrap()); let grew = |before: &Presence, after: &Presence| !after.regressed(before); read_until(&mut presence.inner, grew, |frame| { frame.get("").is_some_and(|p| p.active() == 1) @@ -2323,7 +2324,7 @@ mod tests { drive_tick().await; let agg = Consumer::new(origin.consume(), Config::new().with_depth(1)); - let mut prefix = agg.prefix("acme"); + let mut prefix = agg.prefix(Path::new("acme").unwrap()); let grew = |before: &Prefix, after: &Prefix| !after.regressed(before); let live = |count| { move |frame: &PrefixFrame| { diff --git a/rs/moq-stats/src/consume.rs b/rs/moq-stats/src/consume.rs index 48ea226c8cb..6cb67dde293 100644 --- a/rs/moq-stats/src/consume.rs +++ b/rs/moq-stats/src/consume.rs @@ -174,6 +174,7 @@ impl PrefixConsumer { #[cfg(test)] mod tests { + use moq_net::Path; /// A millisecond track: the frames written here carry timestamps. fn timed() -> moq_net::track::Info { moq_net::track::Info::default().with_timescale(moq_net::Timescale::MILLI) @@ -204,7 +205,7 @@ mod tests { use std::time::Duration; - use moq_net::{Consume, PathOwned, Timestamp, announce, broadcast, origin, track}; + use moq_net::{Consume, Timestamp, announce, broadcast, origin, track}; use crate::{Encoding, Producer, Tier, produce}; @@ -215,7 +216,7 @@ mod tests { let producer = Producer::new( produce::Config::new() .with_origin(origin.clone()) - .with_node(PathOwned::from("sjc")), + .with_node(Path::new("sjc").unwrap()), ); (producer, origin) } @@ -243,18 +244,18 @@ mod tests { } async fn feed(producer: &Producer, tier: Tier, label: &str, path: &str) -> Feed { - let ctx = producer.registry().tier(tier).session(label); + let ctx = producer.registry().tier(tier).session(Path::new(label).unwrap()); let feed_origin = produce_origin(); let egress = feed_origin.consume().with_stats(ctx.clone()); let mut announced = egress.announced(); - let source = feed_origin.create_broadcast(path).unwrap(); + let source = feed_origin.create_broadcast(Path::new(path).unwrap()).unwrap(); source.announce(origin::Route::default()).unwrap(); let track = source.clone().create_track("video", timed()).unwrap(); let (_, active) = next_update(&mut announced).await.expect("announce"); assert!(active); - let consumer = egress.request_broadcast(path, None).await.expect("resolve"); + let consumer = egress.request_broadcast(Path::new(path).unwrap(), None).await.expect("resolve"); let sub = consumer.track("video").unwrap().subscribe(None).await.unwrap(); Feed { @@ -273,7 +274,7 @@ mod tests { assert!(active); origin .consume() - .request_broadcast(moq_net::Path::new(update.prefix.as_str()), None) + .request_broadcast(moq_net::Path::new(update.prefix.as_str()).unwrap(), None) .await .expect("resolve") } @@ -331,7 +332,7 @@ mod tests { assert_eq!(totals.sessions.active(), 1); // A presence track is produced once requested, so drive a drain. - let mut presence = std::pin::pin!(compressed.presence("acme")); + let mut presence = std::pin::pin!(compressed.presence(Path::new("acme").unwrap())); assert!(futures::poll!(presence.as_mut()).is_pending()); drive_tick().await; let mut presence = presence.await.expect("subscribe presence"); @@ -339,7 +340,7 @@ mod tests { assert_eq!(frame.get("").expect("default tier").active(), 1); // So is a prefix track. - let mut prefix = std::pin::pin!(compressed.prefix("foo")); + let mut prefix = std::pin::pin!(compressed.prefix(Path::new("foo").unwrap())); assert!(futures::poll!(prefix.as_mut()).is_pending()); drive_tick().await; let mut prefix = prefix.await.expect("subscribe prefix"); diff --git a/rs/moq-stats/src/lib.rs b/rs/moq-stats/src/lib.rs index a28cef42157..92ac50d8658 100644 --- a/rs/moq-stats/src/lib.rs +++ b/rs/moq-stats/src/lib.rs @@ -239,12 +239,8 @@ fn parse_keyed_track(name: &str, kind: &str) -> Option<(PathOwned, Encoding)> { "" => "", rest => rest.strip_suffix('/').filter(|key| !key.is_empty())?, }; - // Only a normalized key round-trips, so each key has exactly one name. - let path = Path::new(key); - if path.as_str() != key { - return None; - } - Some((path.to_owned(), encoding)) + // Only a valid key round-trips, so each key has exactly one name. + Some((Path::new(key).ok()?.to_owned(), encoding)) } /// A parsed stats broadcast path: `[/]/node[/]`. @@ -294,8 +290,8 @@ pub fn parse_node_path(prefix: impl AsPath, depth: usize, path: impl AsPath) -> let node = segments.collect::>().join("/"); Some(NodePath { - group: Path::new(&group.join("/")).to_owned(), - node: Path::new(&node).to_owned(), + group: PathOwned::try_from(group.join("/")).ok()?, + node: PathOwned::try_from(node).ok()?, }) } @@ -321,19 +317,19 @@ mod tests { #[test] fn parse_node_path_variants() { - let parse = |depth, path| parse_node_path(".stats", depth, path); + let parse = |depth, path| parse_node_path(Path::new(".stats").unwrap(), depth, Path::new(path).unwrap()); // Depth 0: no group segment. assert_eq!( parse(0, ".stats/node/sjc"), Some(NodePath { group: Path::empty().to_owned(), - node: Path::new("sjc").to_owned(), + node: Path::new("sjc").unwrap().to_owned(), }) ); assert_eq!( parse(0, ".stats/node/sjc/1").unwrap().node, - Path::new("sjc/1").to_owned(), + Path::new("sjc/1").unwrap().to_owned(), "multi-segment node" ); assert_eq!( @@ -349,8 +345,8 @@ mod tests { assert_eq!( parse(1, ".stats/acme/node/sjc"), Some(NodePath { - group: Path::new("acme").to_owned(), - node: Path::new("sjc").to_owned(), + group: Path::new("acme").unwrap().to_owned(), + node: Path::new("sjc").unwrap().to_owned(), }) ); // A shorter broadcast path yields a shorter group; still parses. @@ -365,7 +361,7 @@ mod tests { #[test] fn track_names() { let default = Tier::default(); - let regional = Tier::new("region/sjc"); + let regional = Tier::new(Path::new("region/sjc").unwrap()); assert_eq!( traffic_track(&default, Role::Publisher, Encoding::Plain), "publisher.json" @@ -385,20 +381,20 @@ mod tests { ); assert_eq!(totals_track(Encoding::Plain), "totals.json"); assert_eq!(totals_track(Encoding::Compressed), "totals.json.z"); - assert_eq!(presence_track("acme/live", Encoding::Plain), "acme/live/presence.json"); - assert_eq!(presence_track("", Encoding::Compressed), "presence.json.z"); - assert_eq!(prefix_track("acme/live", Encoding::Plain), "acme/live/prefix.json"); - assert_eq!(prefix_track("", Encoding::Compressed), "prefix.json.z"); + assert_eq!(presence_track(Path::new("acme/live").unwrap(), Encoding::Plain), "acme/live/presence.json"); + assert_eq!(presence_track(Path::new("").unwrap(), Encoding::Compressed), "presence.json.z"); + assert_eq!(prefix_track(Path::new("acme/live").unwrap(), Encoding::Plain), "acme/live/prefix.json"); + assert_eq!(prefix_track(Path::new("").unwrap(), Encoding::Compressed), "prefix.json.z"); } #[test] fn presence_track_names_round_trip() { for label in ["", "acme", "acme/live", "a.json", "x/presence.json", "publisher", "z"] { for encoding in [Encoding::Plain, Encoding::Compressed] { - let name = presence_track(label, encoding); + let name = presence_track(Path::new(label).unwrap(), encoding); assert_eq!( parse_presence_track(&name), - Some((PathOwned::from(label), encoding)), + Some((Path::new(label).unwrap(), encoding)), "{name}" ); } @@ -435,10 +431,10 @@ mod tests { "publisher", ] { for encoding in [Encoding::Plain, Encoding::Compressed] { - let name = prefix_track(path, encoding); + let name = prefix_track(Path::new(path).unwrap(), encoding); assert_eq!( parse_prefix_track(&name), - Some((PathOwned::from(path), encoding)), + Some((Path::new(path).unwrap(), encoding)), "{name}" ); assert_eq!(parse_presence_track(&name), None, "{name} is not a presence track"); diff --git a/rs/moq-stats/src/produce.rs b/rs/moq-stats/src/produce.rs index b35f35b1485..5bec8325423 100644 --- a/rs/moq-stats/src/produce.rs +++ b/rs/moq-stats/src/produce.rs @@ -79,7 +79,7 @@ impl Config { pub fn new() -> Self { Self { origin: None, - prefix: PathOwned::from(".stats"), + prefix: Path::new(".stats").expect("a literal path"), node: None, interval: Duration::from_secs(1), depth: 0, @@ -268,8 +268,8 @@ impl Task { drain.publish(moq_clock::now()); } } - fn node(&self) -> Option<&str> { - self.node.as_ref().map(moq_net::Path::as_str) + fn node(&self) -> Option<&Path<'static>> { + self.node.as_ref() } } @@ -350,7 +350,7 @@ impl Drain { if refused.iter().any(|name| name == key) { return None; } - match GroupPublisher::create(task, &Path::new(key)) { + match GroupPublisher::create(task, &Path::new(key).expect("a group key is a run of a path's segments")) { Some(group) => { groups.insert(key.to_string(), group); } @@ -1581,21 +1581,15 @@ fn group_key(path: &str, depth: usize) -> &str { } } -fn advertised_path(prefix: &Path, group: &Path, node: Option<&str>) -> PathOwned { +fn advertised_path(prefix: &Path, group: &Path, node: Option<&Path>) -> PathOwned { // `//node/`. The group segment is empty at depth 0. // The fixed `node` category leaves room for sibling categories (e.g. // `//cluster` for relay-mesh stats) under the same prefix. - let mut out = prefix.as_str().to_string(); - if !group.is_empty() { - out.push('/'); - out.push_str(group.as_str()); - } - out.push_str("/node"); - if let Some(node) = node { - out.push('/'); - out.push_str(node); + let path = prefix.join(group).join(Path::new("node").expect("a literal path")); + match node { + Some(node) => path.join(node), + None => path, } - PathOwned::from(out) } #[cfg(test)] @@ -1617,7 +1611,7 @@ mod tests { Arc::new(AtomicU64::new(0)), ); let frame = |n| Frame { - entries: vec![(PathOwned::from("a"), n)], + entries: vec![(Path::new("a").unwrap(), n)], }; let wanted = |track: &track::Producer| track.demand().wanted(); @@ -1740,7 +1734,7 @@ mod tests { let mut drain = Drain::new(Task { registry: registry.clone(), origin: origin.clone(), - prefix: ".stats".into(), + prefix: Path::new(".stats").unwrap(), node: None, depth: 0, linger: DEFAULT_LINGER, @@ -1753,7 +1747,7 @@ mod tests { link(&origin, &middle, version).await, link(&middle, &edge, version).await, ]; - let session = registry.tier(Tier::default()).session("room"); + let session = registry.tier(Tier::default()).session(Path::new("room").unwrap()); let counters = moq_net::transport::Wire::new(); let _wire = session.wire(counters.clone()); let store = |n: u64| { @@ -1768,8 +1762,8 @@ mod tests { let (route, active) = next_update(&mut events).await.unwrap(); assert!(active); assert_eq!(route.prefix.as_str(), ".stats/node"); - let broadcast = consumer.request_broadcast(".stats/node", None).await.unwrap(); - let name = presence_track("room", encoding); + let broadcast = consumer.request_broadcast(Path::new(".stats/node").unwrap(), None).await.unwrap(); + let name = presence_track(Path::new("room").unwrap(), encoding); let mut config = moq_json::snapshot::consumer::Config::default(); config.compression = encoding.compression(); let mut previous = None; @@ -1869,7 +1863,7 @@ mod tests { let consumer = broadcast.consume(); let mut pair = TrackPair::::create(&broadcast, "t.json", Arc::new(AtomicU64::new(0))).unwrap(); let mut publish = |key: &str, value: u64| { - pair.frame.entries.push((PathOwned::from(key.to_string()), value)); + pair.frame.entries.push((Path::try_from(key.to_string()).unwrap(), value)); pair.publish("t.json"); }; publish("small", 1); @@ -1945,7 +1939,7 @@ mod tests { let producer = Producer::new( Config::new() .with_origin(origin.clone()) - .with_node(node.map(|s| PathOwned::from(s.to_string()))), + .with_node(node.map(|s| Path::try_from(s.to_string()).unwrap())), ); (producer, origin) } @@ -1974,19 +1968,19 @@ mod tests { frames: usize, frame_size: usize, ) -> Feed { - let ctx = registry.tier(tier).session("feed"); + let ctx = registry.tier(tier).session(Path::new("feed").unwrap()); let origin = produce_origin(); // Egress (publisher side) is tagged; the local publisher stays untagged. let egress = origin.consume().with_stats(ctx); let mut announced = egress.announced(); - let source = origin.create_broadcast(path).expect("create_broadcast"); + let source = origin.create_broadcast(Path::new(path).unwrap()).expect("create_broadcast"); source.announce(origin::Route::default()).expect("announce"); let producer = source.create_track("video", timed()).expect("create_track"); let (_, active) = next_update(&mut announced).await.expect("announce"); assert!(active); - let consumer = egress.request_broadcast(path, None).await.expect("resolve"); + let consumer = egress.request_broadcast(Path::new(path).unwrap(), None).await.expect("resolve"); let sub = if subscribe { let mut sub = consumer @@ -2029,7 +2023,7 @@ mod tests { assert!(active); let broadcast = origin .consume() - .request_broadcast(moq_net::Path::new(update.prefix.as_str()), None) + .request_broadcast(moq_net::Path::new(update.prefix.as_str()).unwrap(), None) .await .expect("resolve"); (update.prefix.as_str().to_string(), broadcast) @@ -2145,7 +2139,7 @@ mod tests { Producer::new( Config::new() .with_origin(origin.clone()) - .with_node(PathOwned::from("sjc")), + .with_node(Path::new("sjc").unwrap()), ) } @@ -2193,7 +2187,7 @@ mod tests { }; let stats = origin .consume() - .request_broadcast(path.as_str(), None) + .request_broadcast(Path::new(path.as_str()).unwrap(), None) .await .expect("resolve"); let mut old = subscribe(&stats, "publisher.json").await; @@ -2211,7 +2205,7 @@ mod tests { let stats = origin .consume() - .request_broadcast(path.as_str(), None) + .request_broadcast(Path::new(path.as_str()).unwrap(), None) .await .expect("resolve"); assert_eq!(read_last_frame(&stats, "publisher.json").await["foo/bar"].bytes, 30); @@ -2312,16 +2306,16 @@ mod tests { let data = produce_origin(); let source = data .clone() - .with_stats(registry.tier(Tier::default()).session("publisher")) - .publish("foo/bar", origin::Route::default()) + .with_stats(registry.tier(Tier::default()).session(Path::new("publisher").unwrap())) + .publish(Path::new("foo/bar").unwrap(), origin::Route::default()) .expect("publish"); let mut video = source.create_track("video", timed()).expect("create_track"); let egress = data .consume() - .with_stats(registry.tier(Tier::default()).session("viewer")); + .with_stats(registry.tier(Tier::default()).session(Path::new("viewer").unwrap())); async fn view(egress: &origin::Consumer, video: &mut track::Producer, size: usize) { - let broadcast = egress.request_broadcast("foo/bar", None).await.expect("resolve"); + let broadcast = egress.request_broadcast(Path::new("foo/bar").unwrap(), None).await.expect("resolve"); let mut sub = broadcast .track("video") .expect("track") @@ -2380,7 +2374,7 @@ mod tests { let producer = Producer::new( Config::new() .with_origin(origin.clone()) - .with_node(PathOwned::from("sjc")) + .with_node(Path::new("sjc").unwrap()) .with_depth(1) .with_linger(linger), ); @@ -2414,7 +2408,7 @@ mod tests { async fn wire_totals_restart_after_a_group_epoch_ends() { let (producer, origin, mut events) = grouped_producer(Duration::ZERO); let registry = producer.registry(); - let session = registry.tier(Tier::default()).session("acme/live"); + let session = registry.tier(Tier::default()).session(Path::new("acme/live").unwrap()); let counters = moq_net::transport::Wire::new(); counters.set_sent_bytes(71); counters.set_received_bytes(29); @@ -2423,7 +2417,7 @@ mod tests { let [(path, true, old_epoch)] = &take_epochs(&mut events)[..] else { panic!("expected the wire root's group"); }; - let broadcast = origin.consume().request_broadcast(path, None).await.expect("resolve"); + let broadcast = origin.consume().request_broadcast(Path::new(path).unwrap(), None).await.expect("resolve"); let totals = default_totals(&broadcast).await.sessions; assert_eq!((totals.wire_tx, totals.wire_rx), (71, 29)); drop(wire); @@ -2433,7 +2427,7 @@ mod tests { } assert_eq!(take_epochs(&mut events), [(path.clone(), false, old_epoch.clone())]); - let session = registry.tier(Tier::default()).session("acme/live"); + let session = registry.tier(Tier::default()).session(Path::new("acme/live").unwrap()); let _wire = session.wire(moq_net::transport::Wire::new()); drive_tick().await; let [(new_path, true, new_epoch)] = &take_epochs(&mut events)[..] else { @@ -2443,7 +2437,7 @@ mod tests { assert!(new_epoch > old_epoch); let broadcast = origin .consume() - .request_broadcast(new_path, None) + .request_broadcast(Path::new(new_path).unwrap(), None) .await .expect("resolve"); let totals = default_totals(&broadcast).await.sessions; @@ -2465,8 +2459,8 @@ mod tests { panic!("expected both groups to announce, got {started:?}"); }; assert_eq!((acme_path.as_str(), feed_path.as_str()), (ACME, FEED)); - let acme = origin.consume().request_broadcast(ACME, None).await.expect("resolve"); - let sessions = origin.consume().request_broadcast(FEED, None).await.expect("resolve"); + let acme = origin.consume().request_broadcast(Path::new(ACME).unwrap(), None).await.expect("resolve"); + let sessions = origin.consume().request_broadcast(Path::new(FEED).unwrap(), None).await.expect("resolve"); assert_eq!(read_last_frame(&acme, "publisher.json").await["acme/live"].bytes, 100); // The viewer leaves: both groups empty but stay announced. The path map @@ -2536,7 +2530,7 @@ mod tests { new_acme > acme_epoch && new_feed > feed_epoch, "a returning group mints a new epoch" ); - let acme = origin.consume().request_broadcast(ACME, None).await.expect("resolve"); + let acme = origin.consume().request_broadcast(Path::new(ACME).unwrap(), None).await.expect("resolve"); assert_eq!(read_last_frame(&acme, "publisher.json").await["acme/live"].bytes, 25); assert_eq!( default_totals(&acme).await.publisher.bytes, @@ -2597,13 +2591,13 @@ mod tests { let (producer, origin, mut events) = grouped_producer(Duration::from_secs(10)); let registry = producer.registry(); - let session = registry.tier(Tier::default()).session("acme/live"); + let session = registry.tier(Tier::default()).session(Path::new("acme/live").unwrap()); drive_tick().await; let [(path, true, epoch)] = &take_epochs(&mut events)[..] else { panic!("expected the session's group to announce"); }; assert_eq!(path, ACME); - let acme = origin.consume().request_broadcast(ACME, None).await.expect("resolve"); + let acme = origin.consume().request_broadcast(Path::new(ACME).unwrap(), None).await.expect("resolve"); let mut held = hold(&acme).await; // The session leaves: the group lingers with every hold still live. @@ -2622,14 +2616,14 @@ mod tests { assert!(held.iter_mut().all(ended), "every held track ends with the group"); // A reader follows the next announcement and holds the same tracks anew. - let _again = registry.tier(Tier::default()).session("acme/live"); + let _again = registry.tier(Tier::default()).session(Path::new("acme/live").unwrap()); drive_tick().await; let [(path, true, newer)] = &take_epochs(&mut events)[..] else { panic!("expected the group to announce again"); }; assert_eq!(path, ACME); assert!(newer > epoch, "a returning group mints a new epoch"); - let acme = origin.consume().request_broadcast(ACME, None).await.expect("resolve"); + let acme = origin.consume().request_broadcast(Path::new(ACME).unwrap(), None).await.expect("resolve"); let [_tier, mut presence, _prefix] = hold(&acme).await; let frame = try_presence(&mut presence).expect("answered at once"); assert_eq!(frame[""].active(), 1, "served from the new epoch"); @@ -2638,9 +2632,9 @@ mod tests { #[tokio::test(start_paused = true)] async fn session_track_surfaces_by_root() { let (producer, origin) = test_producer(Some("sjc")); - let _a = producer.registry().tier(Tier::default()).session("acme"); - let _b = producer.registry().tier(Tier::default()).session("acme"); - let _c = producer.registry().tier(Tier::new("region/sjc")).session("peer"); + let _a = producer.registry().tier(Tier::default()).session(Path::new("acme").unwrap()); + let _b = producer.registry().tier(Tier::default()).session(Path::new("acme").unwrap()); + let _c = producer.registry().tier(Tier::new(Path::new("region/sjc").unwrap())).session(Path::new("peer").unwrap()); drive_tick().await; @@ -2667,7 +2661,7 @@ mod tests { #[tokio::test(start_paused = true)] async fn request_root_stays_in_the_frame_while_held() { let (producer, origin) = test_producer(Some("sjc")); - let first = producer.registry().tier(Tier::default()).request("acme"); + let first = producer.registry().tier(Tier::default()).request(Path::new("acme").unwrap()); drive_tick().await; let (_, broadcast) = announced(&origin).await; let mut track = subscribe(&broadcast, "sessions.json").await; @@ -2685,7 +2679,7 @@ mod tests { drive_tick().await; assert!(!drain(&mut track).contains(&None), "an idle request stays"); - let second = producer.registry().tier(Tier::default()).request("acme"); + let second = producer.registry().tier(Tier::default()).request(Path::new("acme").unwrap()); drive_tick().await; assert_eq!(drain(&mut track), [Some(2)]); @@ -2699,9 +2693,9 @@ mod tests { #[tokio::test(start_paused = true)] async fn totals_split_sessions_by_tier() { let (producer, origin) = test_producer(Some("sjc")); - let _a = producer.registry().tier(Tier::default()).session("acme"); - let b = producer.registry().tier(Tier::default()).session("beta"); - let _c = producer.registry().tier(Tier::new("region/sjc")).session("peer"); + let _a = producer.registry().tier(Tier::default()).session(Path::new("acme").unwrap()); + let b = producer.registry().tier(Tier::default()).session(Path::new("beta").unwrap()); + let _c = producer.registry().tier(Tier::new(Path::new("region/sjc").unwrap())).session(Path::new("peer").unwrap()); drive_tick().await; let (_, broadcast) = announced(&origin).await; @@ -2730,10 +2724,10 @@ mod tests { let _beta = feed(registry, Tier::default(), "beta/live", true, 1, 7).await; drive_tick().await; - let acme = origin.consume().request_broadcast(ACME, None).await.expect("resolve"); + let acme = origin.consume().request_broadcast(Path::new(ACME).unwrap(), None).await.expect("resolve"); let beta = origin .consume() - .request_broadcast(".stats/beta/node/sjc", None) + .request_broadcast(Path::new(".stats/beta/node/sjc").unwrap(), None) .await .expect("resolve"); assert_eq!(default_totals(&acme).await.publisher.bytes, 100); @@ -2744,7 +2738,7 @@ mod tests { /// the producer adopts the request. async fn hold_presence(broadcast: &moq_net::broadcast::Consumer, label: &str) -> track::Ordered { let subscribing = broadcast - .track(&presence_track(label, Encoding::Plain)) + .track(&presence_track(Path::new(label).unwrap(), Encoding::Plain)) .expect("track") .subscribe(None); drive_tick().await; @@ -2758,9 +2752,9 @@ mod tests { async fn presence_track_is_cumulative_while_held() { let (producer, origin) = test_producer(Some("sjc")); let registry = producer.registry(); - let first = registry.tier(Tier::default()).session("acme/live"); - let _other = registry.tier(Tier::new("rtmp")).session("acme/live"); - let _unrelated = registry.tier(Tier::default()).session("beta"); + let first = registry.tier(Tier::default()).session(Path::new("acme/live").unwrap()); + let _other = registry.tier(Tier::new(Path::new("rtmp").unwrap())).session(Path::new("acme/live").unwrap()); + let _unrelated = registry.tier(Tier::default()).session(Path::new("beta").unwrap()); drive_tick().await; let (_, broadcast) = announced(&origin).await; @@ -2784,7 +2778,7 @@ mod tests { assert_eq!(frame[""].active(), 0); // A new session under the label continues the count. - let _again = registry.tier(Tier::default()).session("acme/live"); + let _again = registry.tier(Tier::default()).session(Path::new("acme/live").unwrap()); drive_tick().await; let mut last = None; while let Some(frame) = try_presence(&mut track) { @@ -2804,7 +2798,7 @@ mod tests { let mut drain = Drain::new(Task { registry: registry.clone(), origin: origin.clone(), - prefix: PathOwned::from(".stats"), + prefix: Path::new(".stats").unwrap(), node: None, depth: 0, linger: DEFAULT_LINGER, @@ -2818,13 +2812,13 @@ mod tests { }; let broadcast = origin .consume() - .request_broadcast(".stats/node", None) + .request_broadcast(Path::new(".stats/node").unwrap(), None) .await .expect("resolve"); // Let the request reach the stats broadcast's queue before the drain. let subscribing = broadcast - .track(&presence_track("", Encoding::Plain)) + .track(&presence_track(Path::new("").unwrap(), Encoding::Plain)) .expect("track") .subscribe(None); for _ in 0..8 { @@ -2835,7 +2829,7 @@ mod tests { assert_eq!(try_presence(&mut track), Some(PresenceFrame::new()), "held at zero"); // The label records while held: the same subscription carries it. - let _session = registry.tier(Tier::default()).session(""); + let _session = registry.tier(Tier::default()).session(Path::new("").unwrap()); tick(); assert_eq!(try_presence(&mut track).expect("recorded")[""].active(), 1); @@ -2858,10 +2852,10 @@ mod tests { let (producer, origin, _events) = grouped_producer(DEFAULT_LINGER); let _f = feed(producer.registry(), Tier::default(), "acme/live", true, 1, 42).await; drive_tick().await; - let acme = origin.consume().request_broadcast(ACME, None).await.expect("resolve"); + let acme = origin.consume().request_broadcast(Path::new(ACME).unwrap(), None).await.expect("resolve"); let subscribing = acme - .track(&presence_track("beta", Encoding::Plain)) + .track(&presence_track(Path::new("beta").unwrap(), Encoding::Plain)) .expect("track") .subscribe(None); drive_tick().await; @@ -2872,7 +2866,7 @@ mod tests { let pending: Vec<_> = (0..3) .map(|i| { - acme.track(&presence_track(format!("acme/{i}").as_str(), Encoding::Plain)) + acme.track(&presence_track(Path::new(format!("acme/{i}").as_str()).unwrap(), Encoding::Plain)) .expect("track") .subscribe(None) }) @@ -2885,7 +2879,7 @@ mod tests { // A held label's compressed flavor shares the live pair. let subscribing = acme - .track(&presence_track("acme/0", Encoding::Compressed)) + .track(&presence_track(Path::new("acme/0").unwrap(), Encoding::Compressed)) .expect("track") .subscribe(None); drive_tick().await; @@ -2896,7 +2890,7 @@ mod tests { /// producer adopts the request. async fn hold_prefix(broadcast: &moq_net::broadcast::Consumer, path: &str) -> track::Ordered { let subscribing = broadcast - .track(&prefix_track(path, Encoding::Plain)) + .track(&prefix_track(Path::new(path).unwrap(), Encoding::Plain)) .expect("track") .subscribe(None); drive_tick().await; @@ -2937,10 +2931,10 @@ mod tests { let _own = feed(registry, Tier::default(), "acme", true, 1, 1).await; let _live = feed(registry, Tier::default(), "acme/live", true, 1, 10).await; let _cam = feed(registry, Tier::default(), "acme/live/cam", true, 1, 100).await; - let _rtmp = feed(registry, Tier::new("rtmp"), "acme/vod", true, 1, 1000).await; + let _rtmp = feed(registry, Tier::new(Path::new("rtmp").unwrap()), "acme/vod", true, 1, 1000).await; let _other = feed(registry, Tier::default(), "beta/live", true, 1, 5).await; drive_tick().await; - let acme = origin.consume().request_broadcast(ACME, None).await.expect("resolve"); + let acme = origin.consume().request_broadcast(Path::new(ACME).unwrap(), None).await.expect("resolve"); let mut track = hold_prefix(&acme, "acme").await; let frame = last_prefix(&mut track).expect("answered at once"); @@ -2968,7 +2962,7 @@ mod tests { ["acme"; Path::MAX_PARTS + 1].join("/"), ] { let subscribing = acme - .track(&prefix_track(path.as_str(), Encoding::Plain)) + .track(&prefix_track(Path::new(path.as_str()).unwrap(), Encoding::Plain)) .expect("track") .subscribe(None); drive_tick().await; @@ -2990,14 +2984,14 @@ mod tests { let data = produce_origin(); let source = data .clone() - .with_stats(registry.tier(Tier::default()).session("publisher")) - .publish("acme/live", origin::Route::default()) + .with_stats(registry.tier(Tier::default()).session(Path::new("publisher").unwrap())) + .publish(Path::new("acme/live").unwrap(), origin::Route::default()) .expect("publish"); let video = source.create_track("video", timed()).expect("create_track"); let egress = data .consume() - .with_stats(registry.tier(Tier::default()).session("viewer")); - let broadcast = egress.request_broadcast("acme/live", None).await.expect("resolve"); + .with_stats(registry.tier(Tier::default()).session(Path::new("viewer").unwrap())); + let broadcast = egress.request_broadcast(Path::new("acme/live").unwrap(), None).await.expect("resolve"); let mut subs = Vec::new(); for _ in 0..300 { let track = broadcast.track("video").expect("track"); @@ -3074,7 +3068,7 @@ mod tests { let mut drain = Drain::new(Task { registry: registry.clone(), origin: origin.clone(), - prefix: PathOwned::from(".stats"), + prefix: Path::new(".stats").unwrap(), node: None, depth: 0, linger: DEFAULT_LINGER, @@ -3088,12 +3082,12 @@ mod tests { }; let broadcast = origin .consume() - .request_broadcast(".stats/node", None) + .request_broadcast(Path::new(".stats/node").unwrap(), None) .await .expect("resolve"); let subscribing = broadcast - .track(&prefix_track("acme", Encoding::Plain)) + .track(&prefix_track(Path::new("acme").unwrap(), Encoding::Plain)) .expect("track") .subscribe(None); for _ in 0..8 { @@ -3174,25 +3168,25 @@ mod tests { #[test] fn advertised_path_with_and_without_node() { - let prefix = Path::new(".stats"); + let prefix = Path::new(".stats").unwrap(); let empty = Path::empty(); assert_eq!( - advertised_path(&prefix, &empty, Some("sjc")).as_str(), + advertised_path(&prefix, &empty, Some(&Path::new("sjc").unwrap())).as_str(), ".stats/node/sjc" ); assert_eq!( - advertised_path(&prefix, &empty, Some("sjc/1")).as_str(), + advertised_path(&prefix, &empty, Some(&Path::new("sjc/1").unwrap())).as_str(), ".stats/node/sjc/1" ); assert_eq!(advertised_path(&prefix, &empty, None).as_str(), ".stats/node"); assert_eq!( - advertised_path(&prefix, &Path::new("acme"), Some("sjc")).as_str(), + advertised_path(&prefix, &Path::new("acme").unwrap(), Some(&Path::new("sjc").unwrap())).as_str(), ".stats/acme/node/sjc" ); - let prefix = Path::new("metrics"); + let prefix = Path::new("metrics").unwrap(); assert_eq!( - advertised_path(&prefix, &Path::new("demo/room"), Some("lon")).as_str(), + advertised_path(&prefix, &Path::new("demo/room").unwrap(), Some(&Path::new("lon").unwrap())).as_str(), "metrics/demo/room/node/lon" ); } @@ -3250,7 +3244,7 @@ mod tests { assert!(parsed.is_empty(), "an idle tier serves zeros"); // The tier records: the same subscription carries the data. - let _rtmp = feed(producer.registry(), Tier::new("rtmp"), "foo/live", true, 1, 7).await; + let _rtmp = feed(producer.registry(), Tier::new(Path::new("rtmp").unwrap()), "foo/live", true, 1, 7).await; drive_tick().await; let frame = next_frame(&mut sub).await; let parsed: BTreeMap = serde_json::from_slice(&frame.payload).expect("json"); @@ -3323,7 +3317,7 @@ mod tests { } // ...then the tier records its first traffic before the next tick. - let _rtmp = feed(producer.registry(), Tier::new("rtmp"), "foo/live", true, 1, 7).await; + let _rtmp = feed(producer.registry(), Tier::new(Path::new("rtmp").unwrap()), "foo/live", true, 1, 7).await; drive_tick().await; // The queued subscription resolves and carries the tier's first data. @@ -3411,7 +3405,7 @@ mod tests { ); // The tier records while the request is parked: the flush adopts it. - let _rt = feed(producer.registry(), Tier::new("rt"), "foo/live", true, 1, 9).await; + let _rt = feed(producer.registry(), Tier::new(Path::new("rt").unwrap()), "foo/live", true, 1, 9).await; drive_tick().await; let mut sub = subscribing.await.expect("adopted by the flush").ordered(); let frame = next_frame(&mut sub).await; @@ -3431,7 +3425,7 @@ mod tests { let mut frame = Frame::default(); let mut map = BTreeMap::new(); for (path, bytes) in [("room/b", 2), ("room/a", 1), ("other", 3), ("room/a/cam", 4)] { - frame.entries.push((PathOwned::from(path), traffic(bytes))); + frame.entries.push((Path::new(path).unwrap(), traffic(bytes))); map.insert(path.to_string(), traffic(bytes)); } frame.entries.sort_unstable_by(|a, b| a.0.cmp(&b.0)); @@ -3488,7 +3482,7 @@ mod tests { for t in 0..tiers { let tier = match t { 0 => Tier::default(), - t => Tier::new(format!("tier{t}")), + t => Tier::new(Path::try_from(format!("tier{t}")).unwrap()), }; for b in 0..broadcasts { feeds.push(feed(®istry, tier.clone(), &format!("room{b}/cam"), true, 1, 8).await); @@ -3498,7 +3492,7 @@ mod tests { let mut drain = Drain::new(Task { registry, origin: produce_origin(), - prefix: PathOwned::from(".stats"), + prefix: Path::new(".stats").unwrap(), node: None, depth, linger: DEFAULT_LINGER, @@ -3515,7 +3509,7 @@ mod tests { let _held = hold.then(|| { let tick = drain.tick; let group = drain.groups.get_mut(group_key("room0/cam", depth)).expect("group"); - group.adopt_prefix(&drain.report, PathOwned::from("room0"), PendingPair::default(), tick); + group.adopt_prefix(&drain.report, Path::new("room0").unwrap(), PendingPair::default(), tick); group.prefixes["room0"].pair.plain.track.subscribe(None) }); drain.collect(); diff --git a/rs/moq-stats/src/produce_bench.rs b/rs/moq-stats/src/produce_bench.rs index 84418f2e631..71138fc63d8 100644 --- a/rs/moq-stats/src/produce_bench.rs +++ b/rs/moq-stats/src/produce_bench.rs @@ -36,7 +36,7 @@ impl Driver { let task = Task { registry, origin, - prefix: PathOwned::from(".stats"), + prefix: PathOwned::try_from(".stats").expect("a literal path"), node: None, depth: 0, linger: Duration::from_secs(300), @@ -59,7 +59,7 @@ impl Driver { /// track. pub fn hold_presence(&mut self, label: &str) -> track::Subscriber { let group = self.drain.groups.get_mut("").expect("the depth 0 broadcast"); - let label = PathOwned::from(label.to_string()); + let label = moq_net::Path::new(label).expect("a valid bench label").to_owned(); group.adopt_presence(&self.drain.report, label.clone(), PendingPair::default()); group.presence[&label].pair.plain.track.subscribe(None) } @@ -71,7 +71,7 @@ impl Driver { let group = self.drain.groups.get_mut("").expect("the depth 0 broadcast"); group.adopt_prefix( &self.drain.report, - PathOwned::from(path.to_string()), + moq_net::Path::new(path).expect("a valid bench path").to_owned(), PendingPair::default(), tick, ); diff --git a/rs/moq-tokio/examples/chat.rs b/rs/moq-tokio/examples/chat.rs index 7e025da587e..1376db44eda 100644 --- a/rs/moq-tokio/examples/chat.rs +++ b/rs/moq-tokio/examples/chat.rs @@ -43,7 +43,7 @@ async fn run_broadcast(origin: moq_net::origin::Producer) -> anyhow::Result<()> // but in this example we'll only create one. The live route announces it. // NOTE: The path is empty because we're using the URL to scope the broadcast. // If you put "alice" here, it would be published as "anon/chat-example/alice". - let broadcast = origin.create_broadcast("").context("failed to create broadcast")?; + let broadcast = origin.create_broadcast(moq_net::Path::empty()).context("failed to create broadcast")?; broadcast .announce(Default::default()) .context("failed to announce broadcast")?; diff --git a/rs/moq-tokio/examples/clock.rs b/rs/moq-tokio/examples/clock.rs index 4a6a78703eb..279f3dff09e 100644 --- a/rs/moq-tokio/examples/clock.rs +++ b/rs/moq-tokio/examples/clock.rs @@ -65,7 +65,7 @@ async fn main() -> anyhow::Result<()> { match config.role { Command::Publish => { let broadcast = origin - .create_broadcast(&config.broadcast) + .create_broadcast(Path::new(&config.broadcast).unwrap()) .context("failed to create broadcast")?; let info = moq_net::track::Info::default().with_timescale(moq_net::Timescale::MILLI); let track = broadcast.create_track(track, info)?; @@ -97,11 +97,11 @@ async fn main() -> anyhow::Result<()> { // instead. This also makes the subscriber reconnect-aware. tracing::info!(broadcast = %config.broadcast, "waiting for broadcast to be online"); - let path: moq_net::Path<'_> = config.broadcast.into(); + let path = moq_net::PathOwned::try_from(config.broadcast).context("invalid broadcast name")?; let scope = moq_net::Patterns::from(moq_net::Pattern::subtree(path.as_str()).context("invalid broadcast name")?); let consumer = origin - .scope("", &scope) + .scope(moq_net::Path::empty(), &scope) .context("not allowed to consume broadcast")? .consume(); let mut announced = consumer.announced(); diff --git a/rs/moq-tokio/src/client.rs b/rs/moq-tokio/src/client.rs index 1d82aa33d03..20fb9adf560 100644 --- a/rs/moq-tokio/src/client.rs +++ b/rs/moq-tokio/src/client.rs @@ -812,6 +812,7 @@ async fn connect_session( #[expect(clippy::disallowed_methods, reason = "tests read the host clock directly")] mod tests { use super::*; + use moq_net::Path; /// A millisecond track: the frames written here carry timestamps. #[cfg(all(feature = "websocket", feature = "quic"))] @@ -1320,7 +1321,7 @@ mod tests { #[tokio::test] async fn broadcast_race_quic_wins() { let pub_origin = crate::origin::spawn(); - let broadcast = pub_origin.create_broadcast("test").expect("failed to create broadcast"); + let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("failed to create broadcast"); broadcast .announce(Default::default()) .expect("failed to create broadcast"); @@ -1412,7 +1413,7 @@ mod tests { }; assert_eq!(update.prefix.as_str(), "test"); let broadcast = sub_consumer - .request_broadcast("test", None) + .request_broadcast(Path::new("test").unwrap(), None) .await .expect("broadcast resolves"); let mut track = broadcast diff --git a/rs/moq-tokio/src/connection.rs b/rs/moq-tokio/src/connection.rs index 24eb9cf367a..359f2cd67ac 100644 --- a/rs/moq-tokio/src/connection.rs +++ b/rs/moq-tokio/src/connection.rs @@ -1903,6 +1903,7 @@ fn terminal(state: &State) -> Error { )] mod tests { use super::*; + use moq_net::Path; /// A millisecond track: the frames written here carry timestamps. fn timed() -> moq_net::track::Info { @@ -3261,7 +3262,7 @@ mod tests { // Two relays of one fleet, serving the same live broadcast. let origin = crate::origin::spawn(); - let broadcast = origin.create_broadcast("cam").unwrap(); + let broadcast = origin.create_broadcast(Path::new("cam").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); let track = broadcast.create_track("video", timed()).unwrap(); let (addr_a, mut accepted_a, _task_a) = serve(origin.clone()).await; @@ -3288,7 +3289,7 @@ mod tests { let session_a = tokio::time::timeout(WAIT, accepted_a.recv()).await.unwrap().unwrap(); let consumer = subscriber.consume(); - let cam = tokio::time::timeout(WAIT, consumer.routed_broadcast("cam")) + let cam = tokio::time::timeout(WAIT, consumer.routed_broadcast(Path::new("cam").unwrap())) .await .unwrap() .unwrap(); @@ -3369,9 +3370,9 @@ mod tests { session.drain().send(moq_net::goaway::Goaway::new()).unwrap(); // A broadcast announced after the GOAWAY still arrives: the drained session serves. - let late = origin.create_broadcast("late").unwrap(); + let late = origin.create_broadcast(Path::new("late").unwrap()).unwrap(); late.announce(Default::default()).unwrap(); - tokio::time::timeout(WAIT, subscriber.consume().routed("late")) + tokio::time::timeout(WAIT, subscriber.consume().routed(Path::new("late").unwrap())) .await .expect("the drained session stopped serving") .unwrap(); diff --git a/rs/moq-tokio/src/origin.rs b/rs/moq-tokio/src/origin.rs index 1f282558525..254af7069ec 100644 --- a/rs/moq-tokio/src/origin.rs +++ b/rs/moq-tokio/src/origin.rs @@ -38,6 +38,7 @@ pub fn spawn_config(config: moq_net::origin::Config) -> moq_net::origin::Produce #[cfg(test)] mod tests { use super::*; + use moq_net::Path; /// The next route and whether it is active. async fn next_update(announced: &mut moq_net::announce::Consumer) -> Option<(moq_net::announce::Announce, bool)> { @@ -56,7 +57,7 @@ mod tests { let origin = spawn(); let mut announced = origin.consume().announced(); - let broadcast = origin.create_broadcast("cam").expect("create broadcast"); + let broadcast = origin.create_broadcast(Path::new("cam").unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let (update, active) = next_update(&mut announced).await.expect("announce"); diff --git a/rs/moq-tokio/src/server.rs b/rs/moq-tokio/src/server.rs index a358afd1195..23fcaf5c2cd 100644 --- a/rs/moq-tokio/src/server.rs +++ b/rs/moq-tokio/src/server.rs @@ -1899,6 +1899,7 @@ impl Request { )] mod tests { use super::*; + use moq_net::Path; /// A dead loop's channel closes before its handle resolves; that close must not /// read as a clean stop, or `accept` would disable the stream arm and hang. @@ -2470,7 +2471,7 @@ mod tests { quic: None, deadline, } - .with_stats(registry.tier(Default::default()).session("room")); + .with_stats(registry.tier(Default::default()).session(Path::new("room").unwrap())); let Err(err) = request.ok().await else { panic!("a reply the peer never took completed"); }; @@ -2664,7 +2665,7 @@ mod tests { let _ = std::fs::remove_file(&path); let origin = crate::origin::spawn(); - let broadcast = origin.create_broadcast("test").expect("create broadcast"); + let broadcast = origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("announce broadcast"); let track = broadcast.create_track("video", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); @@ -2720,7 +2721,7 @@ mod tests { .expect("origin closed"); assert_eq!(update.prefix.as_str(), "test"); assert!(active); - let broadcast = consumer.request_broadcast("test", None).await.expect("resolve"); + let broadcast = consumer.request_broadcast(Path::new("test").unwrap(), None).await.expect("resolve"); let mut track = broadcast .track("video") diff --git a/rs/moq-tokio/src/webrtc/tests.rs b/rs/moq-tokio/src/webrtc/tests.rs index ec31323c4ed..35e328266d4 100644 --- a/rs/moq-tokio/src/webrtc/tests.rs +++ b/rs/moq-tokio/src/webrtc/tests.rs @@ -16,7 +16,7 @@ fn protocol() -> &'static str { /// A one-frame broadcast named `test` and the handles that keep it alive. fn broadcast(payload: &[u8]) -> (moq_net::origin::Producer, impl Sized) { let origin = crate::origin::spawn(); - let broadcast = origin.create_broadcast("test").unwrap(); + let broadcast = origin.create_broadcast(moq_net::Path::new("test").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); let track = broadcast .create_track( @@ -64,7 +64,7 @@ async fn transfer(offerer: &Offerer, answerer: &Answerer, payload: &[u8]) { panic!("expected the broadcast to be announced"); }; assert_eq!(route.prefix.as_str(), "test"); - let broadcast = consumer.request_broadcast("test", None).await.unwrap(); + let broadcast = consumer.request_broadcast(moq_net::Path::new("test").unwrap(), None).await.unwrap(); let mut track = broadcast.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = track.recv_group().await.unwrap().unwrap(); group.read_frame().await.unwrap().unwrap() diff --git a/rs/moq-tokio/tests/integration/backend.rs b/rs/moq-tokio/tests/integration/backend.rs index 687b0086966..338c5557491 100644 --- a/rs/moq-tokio/tests/integration/backend.rs +++ b/rs/moq-tokio/tests/integration/backend.rs @@ -1,5 +1,6 @@ //! Integration tests for QUIC and the iroh transport. +use moq_net::Path; use std::time::Duration; /// A millisecond track: the frames written here carry timestamps. @@ -114,7 +115,7 @@ async fn connect_test(config: ConnectTest<'_>) { // ── publisher (server) ────────────────────────────────────────── let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast("test").expect("failed to create broadcast"); + let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("failed to create broadcast"); broadcast .announce(Default::default()) .expect("failed to create broadcast"); @@ -189,7 +190,7 @@ async fn connect_test(config: ConnectTest<'_>) { .expect("origin closed"); assert_eq!(update.prefix.as_str(), "test"); assert!(active, "expected announce, got retraction"); - let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast("test", None)) + let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast(Path::new("test").unwrap(), None)) .await .expect("request timed out") .expect("announced broadcast resolves"); @@ -599,7 +600,7 @@ async fn iroh_connect_test(version: Option<&str>) { // ── publisher (server) ────────────────────────────────────────── let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast("test").expect("failed to create broadcast"); + let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("failed to create broadcast"); broadcast .announce(Default::default()) .expect("failed to create broadcast"); @@ -703,7 +704,7 @@ async fn iroh_connect_test(version: Option<&str>) { .expect("origin closed"); assert_eq!(update.prefix.as_str(), "test"); assert!(active, "expected announce, got retraction"); - let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast("test", None)) + let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast(Path::new("test").unwrap(), None)) .await .expect("request timed out") .expect("announced broadcast resolves"); @@ -830,7 +831,7 @@ async fn quic_client_close_drains_finished_track() { .expect("client runtime"); runtime.block_on(async move { let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast("test").expect("failed to create broadcast"); + let broadcast = origin.create_broadcast(Path::new("test").unwrap()).expect("failed to create broadcast"); broadcast.announce(Default::default()).expect("failed to announce"); let mut track = broadcast .create_track("video", timed()) @@ -878,7 +879,7 @@ async fn quic_client_close_drains_finished_track() { .await .expect("announce timed out") .expect("origin closed"); - let broadcast = tokio::time::timeout(TIMEOUT, consumer.request_broadcast("test", None)) + let broadcast = tokio::time::timeout(TIMEOUT, consumer.request_broadcast(Path::new("test").unwrap(), None)) .await .expect("request timed out") .expect("announced broadcast resolves"); @@ -944,7 +945,7 @@ async fn quic_client_close_drains_migrated_predecessor() { .expect("client runtime"); runtime.block_on(async move { let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast("test").expect("failed to create broadcast"); + let broadcast = origin.create_broadcast(Path::new("test").unwrap()).expect("failed to create broadcast"); broadcast.announce(Default::default()).expect("failed to announce"); let mut track = broadcast .create_track("video", timed()) @@ -999,7 +1000,7 @@ async fn quic_client_close_drains_migrated_predecessor() { .await .expect("announce timed out") .expect("origin closed"); - let broadcast = tokio::time::timeout(TIMEOUT, consumer.request_broadcast("test", None)) + let broadcast = tokio::time::timeout(TIMEOUT, consumer.request_broadcast(Path::new("test").unwrap(), None)) .await .expect("request timed out") .expect("announced broadcast resolves"); @@ -1086,7 +1087,7 @@ async fn quic_client_close_keeps_predecessor_handover() { .expect("client runtime"); runtime.block_on(async move { let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast("test").expect("failed to create broadcast"); + let broadcast = origin.create_broadcast(Path::new("test").unwrap()).expect("failed to create broadcast"); broadcast.announce(Default::default()).expect("failed to announce"); // Never finished, so the predecessor serving it cannot drain. let mut track = broadcast @@ -1136,7 +1137,7 @@ async fn quic_client_close_keeps_predecessor_handover() { .await .expect("announce timed out") .expect("origin closed"); - let broadcast = tokio::time::timeout(TIMEOUT, consumer.request_broadcast("test", None)) + let broadcast = tokio::time::timeout(TIMEOUT, consumer.request_broadcast(Path::new("test").unwrap(), None)) .await .expect("request timed out") .expect("announced broadcast resolves"); diff --git a/rs/moq-tokio/tests/integration/broadcast.rs b/rs/moq-tokio/tests/integration/broadcast.rs index 2387a63c146..b90bdb18c6b 100644 --- a/rs/moq-tokio/tests/integration/broadcast.rs +++ b/rs/moq-tokio/tests/integration/broadcast.rs @@ -8,6 +8,7 @@ //! This covers raw QUIC (moqt://) and WebTransport (https://) transports, //! exercising every protocol version the library supports. +use moq_net::Path; use moq_tokio::moq_net::{self, Hop}; use std::time::Duration; @@ -29,7 +30,7 @@ async fn broadcast_test(scheme: &str, client_version: Option<&str>, server_versi // ── publisher (server) ────────────────────────────────────────── let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast("test").expect("failed to create broadcast"); + let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("failed to create broadcast"); broadcast .announce(Default::default()) .expect("failed to create broadcast"); @@ -97,7 +98,7 @@ async fn broadcast_test(scheme: &str, client_version: Option<&str>, server_versi assert_eq!(update.prefix.as_str(), "test"); assert!(active, "expected announce, got retraction"); - let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast("test", None)) + let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast(Path::new("test").unwrap(), None)) .await .expect("request timed out") .expect("announced broadcast resolves"); @@ -142,7 +143,7 @@ async fn lite05_timestamp_roundtrip(scheme: &str) { use moq_tokio::moq_net::{Timescale, Timestamp}; let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast("test").expect("failed to create broadcast"); + let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("failed to create broadcast"); broadcast .announce(Default::default()) .expect("failed to create broadcast"); @@ -206,7 +207,7 @@ async fn lite05_timestamp_roundtrip(scheme: &str) { .expect("origin closed"); assert_eq!(update.prefix.as_str(), "test"); assert!(active, "expected announce, got retraction"); - let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast("test", None)) + let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast(Path::new("test").unwrap(), None)) .await .expect("request timed out") .expect("announced broadcast resolves"); @@ -258,7 +259,7 @@ async fn lite05_fetch_roundtrip(scheme: &str) { use moq_tokio::moq_net::{Timescale, Timestamp}; let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast("test").expect("failed to create broadcast"); + let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("failed to create broadcast"); broadcast .announce(Default::default()) .expect("failed to create broadcast"); @@ -320,7 +321,7 @@ async fn lite05_fetch_roundtrip(scheme: &str) { .expect("origin closed"); assert_eq!(update.prefix.as_str(), "test"); assert!(active, "expected announce, got retraction"); - let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast("test", None)) + let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast(Path::new("test").unwrap(), None)) .await .expect("request timed out") .expect("announced broadcast resolves"); @@ -373,7 +374,7 @@ async fn broadcast_moq_lite_05_fetch_webtransport() { /// refusal. async fn transport_fetch_roundtrip(version: &str) { let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast("test").expect("failed to create broadcast"); + let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("failed to create broadcast"); broadcast .announce(Default::default()) .expect("failed to announce broadcast"); @@ -430,7 +431,7 @@ async fn transport_fetch_roundtrip(version: &str) { .await .expect("announce timed out") .expect("origin closed"); - let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast("test", None)) + let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast(Path::new("test").unwrap(), None)) .await .expect("request timed out") .expect("announced broadcast resolves"); @@ -503,7 +504,7 @@ async fn lite05_fetch_during_subscribe(scheme: &str) { use moq_tokio::moq_net::{Timescale, Timestamp}; let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast("test").expect("failed to create broadcast"); + let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("failed to create broadcast"); broadcast .announce(Default::default()) .expect("failed to create broadcast"); @@ -567,7 +568,7 @@ async fn lite05_fetch_during_subscribe(scheme: &str) { .expect("origin closed"); assert_eq!(update.prefix.as_str(), "test"); assert!(active, "expected announce, got retraction"); - let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast("test", None)) + let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast(Path::new("test").unwrap(), None)) .await .expect("request timed out") .expect("announced broadcast resolves"); @@ -627,7 +628,7 @@ async fn broadcast_moq_lite_05_fetch_during_subscribe_webtransport() { #[tokio::test] async fn broadcast_moq_lite_05_untimed_track() { let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast("test").expect("create broadcast"); + let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let track = broadcast.create_track("video", None).expect("create track"); @@ -675,7 +676,7 @@ async fn broadcast_moq_lite_05_untimed_track() { assert!(active, "expected announce"); let bc = tokio::time::timeout( TIMEOUT, - sub_consumer.request_broadcast(moq_net::Path::new(update.prefix.as_str()), None), + sub_consumer.request_broadcast(moq_net::Path::new(update.prefix.as_str()).unwrap(), None), ) .await .expect("request timed out") @@ -722,7 +723,7 @@ async fn broadcast_moq_lite_05_untimed_track() { #[tokio::test] async fn broadcast_moq_transport_20_current_group_join() { let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast("test").expect("create broadcast"); + let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("announce"); let track = broadcast.create_track("video", timed()).expect("create track"); @@ -773,7 +774,7 @@ async fn broadcast_moq_transport_20_current_group_join() { assert!(announced_active, "expected an announce"); let remote = tokio::time::timeout( TIMEOUT, - sub_consumer.request_broadcast(moq_net::Path::new(announced.prefix.as_str()), None), + sub_consumer.request_broadcast(moq_net::Path::new(announced.prefix.as_str()).unwrap(), None), ) .await .expect("request timed out") @@ -847,7 +848,7 @@ async fn announce_lifecycle_test(version: &str) { let pub_origin = moq_tokio::origin::spawn(); // Announced before the client connects, so it rides the initial set. - let first = pub_origin.create_broadcast("room/first").expect("create broadcast"); + let first = pub_origin.create_broadcast(Path::new("room/first").unwrap()).expect("create broadcast"); first.announce(Default::default()).expect("create broadcast"); let mut server_config = moq_tokio::listen::Config::default(); @@ -888,7 +889,7 @@ async fn announce_lifecycle_test(version: &str) { assert!(active, "expected initial announce"); // A live announce after the initial set. - let second = pub_origin.create_broadcast("room/second").expect("create broadcast"); + let second = pub_origin.create_broadcast(Path::new("room/second").unwrap()).expect("create broadcast"); second.announce(Default::default()).expect("create broadcast"); let (update, active) = next_announce(&mut announcements).await; assert_eq!(update.prefix.as_str(), "room/second"); @@ -902,7 +903,7 @@ async fn announce_lifecycle_test(version: &str) { assert!(!active, "expected retraction"); // Re-announce the same path: a fresh announce assigning a fresh id. - let _second = pub_origin.create_broadcast("room/second").expect("create broadcast"); + let _second = pub_origin.create_broadcast(Path::new("room/second").unwrap()).expect("create broadcast"); _second.announce(Default::default()).expect("create broadcast"); let (update, active) = next_announce(&mut announcements).await; assert_eq!(update.prefix.as_str(), "room/second"); @@ -915,14 +916,14 @@ async fn announce_lifecycle_test(version: &str) { let (update, active) = next_announce(&mut announcements).await; assert_eq!(update.prefix.as_str(), "room/first"); assert!(!active, "expected the replaced retraction"); - let _replacement = pub_origin.create_broadcast("room/first").expect("create replacement"); + let _replacement = pub_origin.create_broadcast(Path::new("room/first").unwrap()).expect("create replacement"); _replacement.announce(Default::default()).expect("create replacement"); let (update, active) = next_announce(&mut announcements).await; assert_eq!(update.prefix.as_str(), "room/first"); assert!(active, "expected the replacement announce"); // A sentinel proves no stray event for "first" snuck in behind the replacement. - let _sentinel = pub_origin.create_broadcast("room/sentinel").expect("create broadcast"); + let _sentinel = pub_origin.create_broadcast(Path::new("room/sentinel").unwrap()).expect("create broadcast"); _sentinel.announce(Default::default()).expect("create broadcast"); let (update, active) = next_announce(&mut announcements).await; assert_eq!(update.prefix.as_str(), "room/sentinel"); @@ -977,7 +978,7 @@ async fn broadcast_route_migration() { let origin_a = moq_tokio::origin::spawn(); let mut hops_a = moq_net::Hops::new(); hops_a.push(publisher).unwrap(); - let broadcast_a = origin_a.create_broadcast("test").expect("create broadcast"); + let broadcast_a = origin_a.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); broadcast_a .announce( moq_net::origin::Route::default() @@ -1002,7 +1003,7 @@ async fn broadcast_route_migration() { let mut hops_b = moq_net::Hops::new(); hops_b.push(publisher).unwrap(); hops_b.push(Hop::new(0x1234).unwrap()).unwrap(); - let broadcast_b = origin_b.create_broadcast("test").expect("create broadcast"); + let broadcast_b = origin_b.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); broadcast_b .announce( moq_net::origin::Route::default() @@ -1091,7 +1092,7 @@ async fn broadcast_route_migration() { let subscription = moq_net::track::Subscription::default() .with_range(1..) .with_max_delay(Duration::from_secs(10)); - let broadcast = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast("test", None)) + let broadcast = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast(Path::new("test").unwrap(), None)) .await .expect("request timeout") .expect("routed broadcast resolves"); @@ -1171,7 +1172,7 @@ async fn rejoin_skips_a_stale_warm_cache(version: &str) { }; let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast("test").expect("create broadcast"); + let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("announce"); let track = broadcast.create_track("audio", timed()).expect("create track"); let live = track.clone(); @@ -1213,7 +1214,7 @@ async fn rejoin_skips_a_stale_warm_cache(version: &str) { .expect("connect failed"); assert!(next_announce(&mut announcements).await.1); - let remote = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast("test", None)) + let remote = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast(Path::new("test").unwrap(), None)) .await .expect("request timeout") .expect("broadcast resolves"); @@ -1287,7 +1288,7 @@ async fn broadcast_rejoin_replays_a_current_warm_cache() { async fn rejoin_replays_a_current_warm_cache(version: &str, open: bool) { let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast("test").expect("create broadcast"); + let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("announce"); let track = broadcast.create_track("catalog.json", timed()).expect("create track"); let live = track.clone(); @@ -1333,7 +1334,7 @@ async fn rejoin_replays_a_current_warm_cache(version: &str, open: bool) { .expect("connect failed"); assert!(next_announce(&mut announcements).await.1); - let remote = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast("test", None)) + let remote = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast(Path::new("test").unwrap(), None)) .await .expect("request timeout") .expect("broadcast resolves"); @@ -1412,7 +1413,7 @@ async fn route_reannounce_test(version: Option<&str>) { let publisher_hop = Hop::new(0x4444).unwrap(); let mut initial_hops = moq_net::Hops::new(); initial_hops.push(publisher_hop).unwrap(); - let producer = origin.create_broadcast("test").expect("create broadcast"); + let producer = origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); producer .announce(moq_net::origin::Route::default().with_hops(initial_hops)) .expect("announce"); @@ -1467,7 +1468,7 @@ async fn route_reannounce_test(version: Option<&str>) { assert!(active, "expected announce"); let initial = update.route; - let broadcast = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast("test", None)) + let broadcast = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast(Path::new("test").unwrap(), None)) .await .expect("request timeout") .expect("routed broadcast resolves"); @@ -1729,7 +1730,7 @@ async fn max_age_test(version: &str, published: Option) -> Option) -> Option u64 { #[tokio::test] async fn idle_subscription_releases_the_viewer_count() { let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast("test").expect("create broadcast"); + let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let track = broadcast.create_track("video", timed()).expect("create track"); @@ -2647,7 +2648,7 @@ async fn idle_subscription_releases_the_viewer_count() { // The publisher counts viewers through a stats context, exactly like the relay. let registry = moq_net::stats::Registry::new(moq_net::stats::Config::new()); - let stats = registry.tier(moq_net::stats::Tier::default()).session(""); + let stats = registry.tier(moq_net::stats::Tier::default()).session(moq_net::Path::empty()); let sub_origin = moq_tokio::origin::spawn(); let sub_consumer = sub_origin.consume(); @@ -2680,7 +2681,7 @@ async fn idle_subscription_releases_the_viewer_count() { assert!(active, "expected announce"); let bc = tokio::time::timeout( TIMEOUT, - sub_consumer.request_broadcast(moq_net::Path::new(update.prefix.as_str()), None), + sub_consumer.request_broadcast(moq_net::Path::new(update.prefix.as_str()).unwrap(), None), ) .await .expect("request timed out") @@ -2913,7 +2914,7 @@ async fn a_dead_session_unannounces_while_the_reconnect_retries() { let url: url::Url = format!("https://localhost:{}", addr.port()).parse().unwrap(); let pub_origin = moq_tokio::origin::spawn(); - let _broadcast = pub_origin.create_broadcast("live").expect("create broadcast"); + let _broadcast = pub_origin.create_broadcast(Path::new("live").unwrap()).expect("create broadcast"); _broadcast.announce(Default::default()).expect("create broadcast"); // Accept the first session and hand it back so the test can kill it. Later @@ -2974,7 +2975,7 @@ async fn announce_interest_unauthorized_keeps_session_alive() { // ── publisher (server): only allowed to announce under "allowed" ── let pub_origin = moq_tokio::origin::spawn(); let broadcast = pub_origin - .create_broadcast("allowed/test") + .create_broadcast(Path::new("allowed/test").unwrap()) .expect("failed to create broadcast"); broadcast .announce(Default::default()) @@ -2991,7 +2992,7 @@ async fn announce_interest_unauthorized_keeps_session_alive() { let publish = pub_origin .consume() .scope( - "", + moq_net::Path::empty(), &moq_net::Patterns::from(moq_net::Pattern::subtree("allowed").unwrap()), ) .expect("failed to scope publish origin"); @@ -3003,7 +3004,7 @@ async fn announce_interest_unauthorized_keeps_session_alive() { let sub_origin = moq_tokio::origin::spawn(); let consume = sub_origin .scope( - "", + moq_net::Path::empty(), &["allowed", "denied"] .into_iter() .map(|prefix| moq_net::Pattern::subtree(prefix).unwrap()) @@ -3070,7 +3071,7 @@ async fn wildcard_scope_test(version: &str, server_scope: &str) { "room/bob/chat", "lobby/alice/chat", ] { - let broadcast = pub_origin.create_broadcast(path).expect("create broadcast"); + let broadcast = pub_origin.create_broadcast(Path::new(path).unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("announce"); let track = broadcast.create_track("data", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); @@ -3083,7 +3084,7 @@ async fn wildcard_scope_test(version: &str, server_scope: &str) { // The server's own grant excludes bob: the client never learns of his chat. let publish = pub_origin .consume() - .scope("", &scope(server_scope)) + .scope(moq_net::Path::empty(), &scope(server_scope)) .expect("scope publish origin"); let mut server_config = moq_tokio::listen::Config::default(); @@ -3097,7 +3098,7 @@ async fn wildcard_scope_test(version: &str, server_scope: &str) { // ── subscriber (client): every room's chat ── let sub_origin = moq_tokio::origin::spawn(); let consume = sub_origin - .scope("", &scope("room/*/chat")) + .scope(moq_net::Path::empty(), &scope("room/*/chat")) .expect("scope consume origin"); let sub_consumer = consume.consume(); let mut announcements = sub_consumer.announced(); @@ -3139,7 +3140,7 @@ async fn wildcard_scope_test(version: &str, server_scope: &str) { ); // The granted path serves; the excluded ones are refused before the wire. - let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast("room/alice/chat", None)) + let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast(Path::new("room/alice/chat").unwrap(), None)) .await .expect("request timed out") .expect("announced broadcast resolves"); @@ -3157,10 +3158,10 @@ async fn wildcard_scope_test(version: &str, server_scope: &str) { assert_eq!(frame.payload.as_ref(), b"room/alice/chat"); // The server grant excludes bob's chat, so that otherwise-authorized request is // unroutable. Audio and lobby never pass the client's own scope and are unauthorized. - let refused = sub_consumer.request_broadcast("room/bob/chat", None).await.err(); + let refused = sub_consumer.request_broadcast(Path::new("room/bob/chat").unwrap(), None).await.err(); assert!(matches!(refused, Some(moq_net::Error::Unroutable)), "{refused:?}"); for path in ["room/alice/audio", "lobby/alice/chat"] { - let refused = sub_consumer.request_broadcast(path, None).await.err(); + let refused = sub_consumer.request_broadcast(Path::new(path).unwrap(), None).await.err(); assert!( matches!(refused, Some(moq_net::Error::Unauthorized)), "{path}: {refused:?}" @@ -3211,7 +3212,7 @@ async fn publish_only_client_to_subscribe_only_server() { let sub_origin = moq_tokio::origin::spawn(); let consume = sub_origin .scope( - "", + moq_net::Path::empty(), &["allowed", "denied"] .into_iter() .map(|prefix| moq_net::Pattern::subtree(prefix).unwrap()) @@ -3241,7 +3242,7 @@ async fn publish_only_client_to_subscribe_only_server() { .expect("origin closed"); assert_eq!(update.prefix.as_str(), "allowed/test"); assert!(active, "expected announce, got retraction"); - let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast("allowed/test", None)) + let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast(Path::new("allowed/test").unwrap(), None)) .await .expect("request timed out") .expect("announced broadcast resolves"); @@ -3278,7 +3279,7 @@ async fn publish_only_client_to_subscribe_only_server() { // ── publisher (client): only allowed to serve under "allowed" ── let pub_origin = moq_tokio::origin::spawn(); let broadcast = pub_origin - .create_broadcast("allowed/test") + .create_broadcast(Path::new("allowed/test").unwrap()) .expect("failed to create broadcast"); broadcast .announce(Default::default()) @@ -3295,7 +3296,7 @@ async fn publish_only_client_to_subscribe_only_server() { let publish = pub_origin .consume() .scope( - "", + moq_net::Path::empty(), &moq_net::Patterns::from(moq_net::Pattern::subtree("allowed").unwrap()), ) .expect("failed to scope publish origin"); @@ -3358,7 +3359,7 @@ async fn goaway_test(scheme: &str, version: &str, expect_wire_timeout: bool) { // ── publisher (server) ────────────────────────────────────────── let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast("test").expect("failed to create broadcast"); + let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("failed to create broadcast"); broadcast .announce(Default::default()) .expect("failed to create broadcast"); @@ -3426,7 +3427,7 @@ async fn goaway_test(scheme: &str, version: &str, expect_wire_timeout: bool) { .expect("origin closed"); assert_eq!(update.prefix.as_str(), "test"); assert!(active, "expected announce, got retraction"); - let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast("test", None)) + let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast(Path::new("test").unwrap(), None)) .await .expect("request timed out") .expect("announced broadcast resolves"); diff --git a/rs/moq-tokio/tests/integration/max_age.rs b/rs/moq-tokio/tests/integration/max_age.rs index fe1233b0aac..131326a260f 100644 --- a/rs/moq-tokio/tests/integration/max_age.rs +++ b/rs/moq-tokio/tests/integration/max_age.rs @@ -1,5 +1,6 @@ //! Real WebSocket sessions through a Rust relay, with Rust and JavaScript at either end. //! The JS arm needs Bun and runs in the interop workflow; the Rust arm runs in normal CI. +use moq_net::Path; use std::{process::Stdio, time::Duration}; use tokio::io::{AsyncBufReadExt, BufReader}; @@ -36,7 +37,7 @@ async fn relay(version: moq_net::Version, javascript: Option) -> anyhow::R Ok::<_, anyhow::Error>(()) }); let publisher = moq_tokio::origin::spawn(); - let broadcast = publisher.create_broadcast("age")?; + let broadcast = publisher.create_broadcast(Path::new("age").unwrap())?; let tracks: Vec<_> = AGES .into_iter() .enumerate() @@ -102,7 +103,7 @@ async fn relay(version: moq_net::Version, javascript: Option) -> anyhow::R .ok_or_else(|| anyhow::anyhow!("announcements closed"))?, moq_net::announce::Event::Start(_) ) {} - let front = consumer.request_broadcast("age", None).await?; + let front = consumer.request_broadcast(Path::new("age").unwrap(), None).await?; for (i, age) in AGES.into_iter().enumerate() { let track = front.track(&i.to_string())?.subscribe(None).await?; anyhow::ensure!( diff --git a/rs/moq-tokio/tests/integration/receive_credit.rs b/rs/moq-tokio/tests/integration/receive_credit.rs index 22a413e7fbd..10caa376b0e 100644 --- a/rs/moq-tokio/tests/integration/receive_credit.rs +++ b/rs/moq-tokio/tests/integration/receive_credit.rs @@ -12,6 +12,7 @@ #![cfg(feature = "quic")] +use moq_net::Path; use std::{process::Stdio, sync::Arc, time::Duration}; use bytes::Bytes; @@ -78,7 +79,7 @@ async fn setup_through( let version: moq_net::Version = version.parse().expect("version"); let publisher = moq_tokio::origin::spawn(); - let broadcast = publisher.create_broadcast("room").expect("broadcast"); + let broadcast = publisher.create_broadcast(Path::new("room").unwrap()).expect("broadcast"); broadcast.announce(Default::default()).expect("announce"); let mut config = moq_tokio::listen::Config::default(); @@ -166,11 +167,11 @@ fn rand_seed() -> u64 { /// Broadcast `room`, once the peer announces it into `origin`. async fn room(origin: &moq_net::origin::Producer) -> moq_net::broadcast::Consumer { let consumer = origin.consume(); - tokio::time::timeout(TIMEOUT, consumer.routed("room")) + tokio::time::timeout(TIMEOUT, consumer.routed(Path::new("room").unwrap())) .await .expect("announce timeout") .expect("routed"); - tokio::time::timeout(TIMEOUT, consumer.request_broadcast("room", None)) + tokio::time::timeout(TIMEOUT, consumer.request_broadcast(Path::new("room").unwrap(), None)) .await .expect("resolve timeout") .expect("broadcast resolves") @@ -428,7 +429,7 @@ async fn reversed(version: &str) -> Reversed { ); let publisher = moq_tokio::origin::spawn(); - let broadcast = publisher.create_broadcast("room").expect("broadcast"); + let broadcast = publisher.create_broadcast(Path::new("room").unwrap()).expect("broadcast"); broadcast.announce(Default::default()).expect("announce"); let subscriber = moq_tokio::origin::spawn(); let session = |conn: driver::Connection| { diff --git a/rs/moq-tokio/tests/integration/subscription_end_integrity.rs b/rs/moq-tokio/tests/integration/subscription_end_integrity.rs index e6fb3675db0..3f2f9441528 100644 --- a/rs/moq-tokio/tests/integration/subscription_end_integrity.rs +++ b/rs/moq-tokio/tests/integration/subscription_end_integrity.rs @@ -24,6 +24,7 @@ //! separate question (it has nothing to await today); this test is only about the //! signal the subscriber gets when it could not. +use moq_net::Path; use std::time::Duration; use moq_tokio::moq_net; @@ -49,7 +50,7 @@ const STALL: Duration = Duration::from_millis(300); /// the subscriber read and the error its subscription ended with, if any. async fn round(drop_session: bool) -> (usize, Option) { let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast("test").expect("create broadcast"); + let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("announce"); let track = broadcast.create_track("video", timed()).expect("create track"); @@ -84,9 +85,9 @@ async fn round(drop_session: bool) -> (usize, Option) { .await .expect("client connect"); - consumer.routed("test").await.expect("routed"); + consumer.routed(Path::new("test").unwrap()).await.expect("routed"); let remote = consumer - .request_broadcast("test", None) + .request_broadcast(Path::new("test").unwrap(), None) .await .expect("broadcast resolves"); let mut sub = remote.track("video").unwrap().subscribe(None).await.expect("subscribe"); diff --git a/rs/moq-tokio/tests/integration/unannounce.rs b/rs/moq-tokio/tests/integration/unannounce.rs index e40aa15d674..67315127fbe 100644 --- a/rs/moq-tokio/tests/integration/unannounce.rs +++ b/rs/moq-tokio/tests/integration/unannounce.rs @@ -1,6 +1,7 @@ //! Integration test: an unannounced broadcast still releases a track's demand //! once its last subscriber leaves. +use moq_net::Path; use std::time::Duration; use moq_tokio::moq_net; @@ -10,9 +11,9 @@ use moq_tokio::moq_net; /// publisher's demand to go unused. async fn release(unannounce: bool, settle: bool) { let origin = moq_tokio::origin::spawn(); - let broadcast = origin.publish("a/b", moq_net::origin::Route::default()).unwrap(); + let broadcast = origin.publish(Path::new("a/b").unwrap(), moq_net::origin::Route::default()).unwrap(); let track = broadcast.create_track("t", None).unwrap(); - let consumer = origin.consume().request_broadcast("a/b", None).await.unwrap(); + let consumer = origin.consume().request_broadcast(Path::new("a/b").unwrap(), None).await.unwrap(); let sub = consumer.track("t").unwrap().subscribe(None).await.unwrap(); crate::wanted(track.demand()).await.unwrap(); diff --git a/rs/moq-transcode/examples/transcode.rs b/rs/moq-transcode/examples/transcode.rs index 2546c1d2d87..5d8b87667f7 100644 --- a/rs/moq-transcode/examples/transcode.rs +++ b/rs/moq-transcode/examples/transcode.rs @@ -32,12 +32,13 @@ struct Args { async fn main() -> anyhow::Result<()> { moq_tokio::Log::new(tracing::Level::INFO).init()?; let args = Args::parse(); - let source_path = moq_net::PathOwned::from(args.source); - let output_path = moq_net::PathOwned::from( + let source_path = moq_net::PathOwned::try_from(args.source).context("invalid source path")?; + let output_path = moq_net::PathOwned::try_from( args.output .clone() .unwrap_or_else(|| format!("{source_path}/transcode.hang")), - ); + ) + .context("invalid output path")?; // Publish the derivative through one origin and consume the source through // another, over a single auto-reconnecting session. diff --git a/rs/moq-transcode/src/lib.rs b/rs/moq-transcode/src/lib.rs index c194ca66861..a4c6e9d51e9 100644 --- a/rs/moq-transcode/src/lib.rs +++ b/rs/moq-transcode/src/lib.rs @@ -224,6 +224,7 @@ impl Drop for Transcoder { #[cfg(test)] #[expect(clippy::disallowed_methods, reason = "tests read the host clock directly")] mod tests { + use moq_net::Path; use super::*; @@ -812,7 +813,7 @@ mod tests { // the output must be minted through an origin: a standalone producer has no path, and // `..` from it would escape, failing the catalog read below. let origin = moq_tokio::origin::spawn(); - let output = origin.create_broadcast("room/transcode").unwrap(); + let output = origin.create_broadcast(Path::new("room/transcode").unwrap()).unwrap(); let consumer = output.consume(); let transcoder = tokio::spawn(run(source.broadcast.consume(), output, config)); diff --git a/rs/moq-uring/benches/session_lite.rs b/rs/moq-uring/benches/session_lite.rs index 86076f1fca4..9d7b8b7ba4a 100644 --- a/rs/moq-uring/benches/session_lite.rs +++ b/rs/moq-uring/benches/session_lite.rs @@ -23,7 +23,7 @@ mod linux { use std::time::Instant; use criterion::{BenchmarkId, Criterion, Throughput}; - use moq_net::origin; + use moq_net::{Path, origin}; use moq_uring::{Config, Error, Worker, quic, udp}; use super::support; @@ -112,7 +112,7 @@ mod linux { }); }); - let broadcast = pub_origin.create_broadcast("bench").expect("create broadcast"); + let broadcast = pub_origin.create_broadcast(Path::new("bench").unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let track = broadcast.create_track("data", timed()).expect("create track"); @@ -176,9 +176,9 @@ mod linux { }); let bc = { let consumer = sub_origin.consume(); - consumer.routed("bench").await.expect("broadcast announced"); + consumer.routed(Path::new("bench").unwrap()).await.expect("broadcast announced"); consumer - .request_broadcast("bench", None) + .request_broadcast(Path::new("bench").unwrap(), None) .await .expect("broadcast resolves") }; diff --git a/rs/moq-uring/tests/integration/receive_credit.rs b/rs/moq-uring/tests/integration/receive_credit.rs index 08a3d44272d..b30f49e1f91 100644 --- a/rs/moq-uring/tests/integration/receive_credit.rs +++ b/rs/moq-uring/tests/integration/receive_credit.rs @@ -12,6 +12,7 @@ #![cfg(all(target_os = "linux", feature = "quic"))] +use moq_net::Path; use crate::support; use std::net::UdpSocket; @@ -89,7 +90,7 @@ fn partial_frame_gives_way() { }); }); - let broadcast = pub_origin.create_broadcast("room").expect("create broadcast"); + let broadcast = pub_origin.create_broadcast(Path::new("room").unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("announce"); let low = broadcast.create_track("low", timed()).expect("low track"); let high = broadcast.create_track("high", timed()).expect("high track"); @@ -154,10 +155,10 @@ fn partial_frame_gives_way() { }); let consumer = sub.consume(); - within(&handle, "the route", consumer.routed("room")) + within(&handle, "the route", consumer.routed(Path::new("room").unwrap())) .await .expect("routed"); - let remote = within(&handle, "the broadcast", consumer.request_broadcast("room", None)) + let remote = within(&handle, "the broadcast", consumer.request_broadcast(Path::new("room").unwrap(), None)) .await .expect("broadcast resolves"); let subscribe = |name: &str, priority: i8| { @@ -310,10 +311,10 @@ fn javascript_partial_frame_gives_way() { }); let consumer = sub.consume(); - within(&handle, "the route", consumer.routed("room")) + within(&handle, "the route", consumer.routed(Path::new("room").unwrap())) .await .expect("routed"); - let remote = within(&handle, "the broadcast", consumer.request_broadcast("room", None)) + let remote = within(&handle, "the broadcast", consumer.request_broadcast(Path::new("room").unwrap(), None)) .await .expect("broadcast resolves"); let subscribe = |name: &str, priority: i8| { diff --git a/rs/moq-uring/tests/integration/session.rs b/rs/moq-uring/tests/integration/session.rs index 33f060b6ea0..496ecc23bec 100644 --- a/rs/moq-uring/tests/integration/session.rs +++ b/rs/moq-uring/tests/integration/session.rs @@ -10,6 +10,7 @@ #![cfg(all(target_os = "linux", feature = "quic"))] +use moq_net::Path; use crate::support; use std::net::UdpSocket; @@ -56,7 +57,7 @@ fn lite_session_over_the_worker() { // Content ready before anyone connects: one broadcast, one track, one // finished group. - let broadcast = pub_origin.create_broadcast("test").expect("create broadcast"); + let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let track = broadcast.create_track("data", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); @@ -135,9 +136,9 @@ fn lite_session_over_the_worker() { let bc = { let consumer = sub.consume(); - consumer.routed("test").await.expect("broadcast announced"); + consumer.routed(Path::new("test").unwrap()).await.expect("broadcast announced"); consumer - .request_broadcast("test", None) + .request_broadcast(Path::new("test").unwrap(), None) .await .expect("broadcast resolves") }; @@ -195,7 +196,7 @@ fn two_lite_sessions_share_the_server_socket() { }); }); - let broadcast = pub_origin.create_broadcast("test").expect("create broadcast"); + let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let track = broadcast.create_track("data", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); @@ -276,9 +277,9 @@ fn two_lite_sessions_share_the_server_socket() { let bc = { let consumer = sub.consume(); - consumer.routed("test").await.expect("broadcast announced"); + consumer.routed(Path::new("test").unwrap()).await.expect("broadcast announced"); consumer - .request_broadcast("test", None) + .request_broadcast(Path::new("test").unwrap(), None) .await .expect("broadcast resolves") }; diff --git a/rs/moq-uring/tests/integration/web.rs b/rs/moq-uring/tests/integration/web.rs index 443991e144d..74c7c11cc53 100644 --- a/rs/moq-uring/tests/integration/web.rs +++ b/rs/moq-uring/tests/integration/web.rs @@ -7,6 +7,7 @@ #![cfg(all(target_os = "linux", feature = "quic"))] +use moq_net::Path; use crate::support; use std::net::UdpSocket; @@ -264,7 +265,7 @@ fn lite_session_over_webtransport() { rt.block_on(moq_net::time::run(pub_driver)); }); - let broadcast = pub_origin.create_broadcast("test").expect("create broadcast"); + let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let track = broadcast.create_track("data", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); @@ -294,9 +295,9 @@ fn lite_session_over_webtransport() { let bc = { let consumer = sub_origin.consume(); - consumer.routed("test").await.expect("broadcast announced"); + consumer.routed(Path::new("test").unwrap()).await.expect("broadcast announced"); consumer - .request_broadcast("test", None) + .request_broadcast(Path::new("test").unwrap(), None) .await .expect("broadcast resolves") }; diff --git a/rs/moq-video/src/decode/decoder.rs b/rs/moq-video/src/decode/decoder.rs index 025831f4980..ee4f90fd92f 100644 --- a/rs/moq-video/src/decode/decoder.rs +++ b/rs/moq-video/src/decode/decoder.rs @@ -377,7 +377,7 @@ mod tests { allow(dead_code, unused_imports, reason = "only the `openh264` feature uses it") )] - use moq_net::Timestamp; + use moq_net::{Path, Timestamp}; use super::backend::{self, Codec, probe}; use crate::encode::{Config as EncodeConfig, Encoder, Kind as EncodeKind}; @@ -611,7 +611,7 @@ mod tests { let (origin, driver) = moq_net::origin::Producer::new(Default::default()); tokio::spawn(moq_net::time::run(driver)); - let mut source = origin.publish("test", Default::default()).unwrap(); + let mut source = origin.publish(Path::new("test").unwrap(), Default::default()).unwrap(); let mut source_catalog = moq_mux::catalog::Producer::new(&mut source, moq_mux::catalog::Config::default()).unwrap(); let track = source @@ -653,7 +653,7 @@ mod tests { .unwrap(); producer.finish().unwrap(); - let broadcast = origin.consume().request_broadcast("test", None).await.unwrap(); + let broadcast = origin.consume().request_broadcast(Path::new("test").unwrap(), None).await.unwrap(); let catalog = moq_mux::catalog::Consumer::<()>::new(&broadcast, moq_mux::catalog::CatalogFormat::Hang) .await .unwrap(); diff --git a/test/interop/clients/rust/audio.rs b/test/interop/clients/rust/audio.rs index 73e86881dec..c499ca13d64 100644 --- a/test/interop/clients/rust/audio.rs +++ b/test/interop/clients/rust/audio.rs @@ -41,7 +41,7 @@ async fn main() -> anyhow::Result<()> { .established() .await?; - let broadcast = consumer.routed_broadcast(&args[2]).await?; + let broadcast = consumer.routed_broadcast(moq_tokio::moq_net::Path::new(&args[2])?).await?; let source = moq_mux::Source::new(consumer, broadcast.clone()); let mut catalogs = moq_mux::catalog::Consumer::<()>::new(&broadcast, CatalogFormat::Hang).await?; // A lazy publisher (the browser) may add audio in a later catalog update. diff --git a/test/interop/clients/rust/control.rs b/test/interop/clients/rust/control.rs index f56217d3279..eb2ca19feab 100644 --- a/test/interop/clients/rust/control.rs +++ b/test/interop/clients/rust/control.rs @@ -13,7 +13,7 @@ async fn main() -> anyhow::Result<()> { let version: moq_net::Version = args[2].parse().map_err(anyhow::Error::msg)?; let origin = moq_tokio::origin::spawn(); let consumer = origin.consume(); - let broadcast = origin.create_broadcast("control")?; + let broadcast = origin.create_broadcast(moq_net::Path::new("control")?)?; let _published = if args[1] == "status" { let track = broadcast.create_track("video", moq_net::track::Info::default().with_priority(2))?; let mut group = track.create_group(moq_net::group::Info { sequence: 4 })?; @@ -58,7 +58,7 @@ async fn main() -> anyhow::Result<()> { ensure!(session.version() == version, "wrong negotiated version"); if args[1] == "credit" { // The JS peer has one usable track slot beyond any namespace discovery. - let remote = consumer.routed_broadcast("control").await?; + let remote = consumer.routed_broadcast(moq_net::Path::new("control")?).await?; let mut first = remote.track("first")?.subscribe(None).await?; let second = remote.track("second")?; let mut pending = Box::pin(second.subscribe(None)); diff --git a/test/interop/clients/rust/finish.rs b/test/interop/clients/rust/finish.rs index 0ee58a5472e..d22f93a4a3f 100644 --- a/test/interop/clients/rust/finish.rs +++ b/test/interop/clients/rust/finish.rs @@ -77,7 +77,7 @@ async fn main() -> anyhow::Result<()> { .await?; let mut stdin = tokio::io::BufReader::new(tokio::io::stdin()); if args.role == "publish" { - let mut broadcast = origin.create_broadcast(&args.broadcast)?; + let mut broadcast = origin.create_broadcast(moq_net::Path::new(&args.broadcast)?)?; let mut catalog = moq_mux::catalog::Producer::<()>::new(&mut broadcast, Default::default())?; let mut media = moq_mux::import::TrackStream::video( broadcast.reserve_track("video")?, @@ -95,7 +95,7 @@ async fn main() -> anyhow::Result<()> { println!("finish ready linger_us={}", LINGER.as_micros()); linger.wait().await; println!("finish ended"); - let health = origin.create_broadcast(format!("{}.health", args.broadcast))?; + let health = origin.create_broadcast(moq_net::PathOwned::try_from(format!("{}.health", args.broadcast))?)?; let mut track = health.create_track("live", moq_net::track::Info::default())?; track.write_frame(None, b"session-alive".to_vec())?; track.finish()?; @@ -116,7 +116,7 @@ async fn main() -> anyhow::Result<()> { ensure!(command == "read\n", "finish read phase was not released"); moq_clock::timeout(args.timeout, async { let mut routes = consumer.announced(); - let broadcast = consumer.routed_broadcast(&args.broadcast).await?; + let broadcast = consumer.routed_broadcast(moq_net::Path::new(&args.broadcast)?).await?; let mut catalogs = moq_mux::catalog::Consumer::<()>::new(&broadcast, moq_mux::catalog::CatalogFormat::Hang).await?; let catalog = loop { @@ -161,7 +161,7 @@ async fn main() -> anyhow::Result<()> { break; } } - let health = consumer.routed_broadcast(format!("{}.health", args.broadcast)).await?; + let health = consumer.routed_broadcast(moq_net::PathOwned::try_from(format!("{}.health", args.broadcast))?).await?; let mut track = health.track("live")?.subscribe(None).await?; let mut group = track.recv_group().await?.context("no health group")?; let frame = group.read_frame().await?.context("no health frame")?; diff --git a/test/interop/clients/rust/goaway-client.rs b/test/interop/clients/rust/goaway-client.rs index 5984d6bb272..869a543cb60 100644 --- a/test/interop/clients/rust/goaway-client.rs +++ b/test/interop/clients/rust/goaway-client.rs @@ -43,7 +43,7 @@ async fn main() -> anyhow::Result<()> { // Drafts 14 and 16 carry no epoch, so nothing proves the replacement serves the same // publisher: the held reader ends with the old route and the application requests again. let legacy = ["moq-transport-14", "moq-transport-16"].contains(&version.as_str()); - let broadcast = consumer.routed_broadcast("handover").await?; + let broadcast = consumer.routed_broadcast(moq_tokio::moq_net::Path::new("handover")?).await?; let mut track = broadcast.track("video")?.subscribe(None).await?; let input = child.stdin.as_mut().context("stdin")?; for sequence in 0..2 { @@ -54,7 +54,7 @@ async fn main() -> anyhow::Result<()> { ); // The server wrote this group just after cutting the original, so only the // replacement, already its largest, can serve it. - let broadcast = consumer.routed_broadcast("handover").await?; + let broadcast = consumer.routed_broadcast(moq_tokio::moq_net::Path::new("handover")?).await?; track = broadcast.track("video")?.subscribe(None).await?; } let mut group = track.recv_group().await?.context("reader ended during GOAWAY")?; @@ -68,7 +68,7 @@ async fn main() -> anyhow::Result<()> { input.write_all(b"first group\n").await?; // The first endpoint's publisher scope excludes this broadcast, so its bytes // prove that the replacement session is serving beyond its SETUP handshake. - let ready = consumer.routed_broadcast("replacement").await?; + let ready = consumer.routed_broadcast(moq_tokio::moq_net::Path::new("replacement")?).await?; let mut marker = ready.track("ready")?.subscribe(None).await?; let mut marker = marker.recv_group().await?.context("replacement marker")?; ensure!( diff --git a/test/interop/clients/rust/goaway.rs b/test/interop/clients/rust/goaway.rs index ac2c9e49d67..a477aaac8ce 100644 --- a/test/interop/clients/rust/goaway.rs +++ b/test/interop/clients/rust/goaway.rs @@ -34,7 +34,7 @@ async fn main() -> anyhow::Result<()> { // Without an epoch, JS re-subscribes instead of retaining its reader across the move. let legacy = ["moq-transport-14", "moq-transport-16"].contains(&args[1].as_str()); let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast("handover")?; + let broadcast = origin.create_broadcast(moq_net::Path::new("handover")?)?; let mut track = broadcast.create_track("video", moq_net::track::Info::default())?; broadcast.announce(moq_net::origin::Route::default().with_epoch(moq_net::Epoch::mint()))?; let (mut first, first_url) = endpoint(&origin, version).await?; diff --git a/test/interop/clients/rust/tail.rs b/test/interop/clients/rust/tail.rs index ac55b7946bd..a60cea7b731 100644 --- a/test/interop/clients/rust/tail.rs +++ b/test/interop/clients/rust/tail.rs @@ -74,7 +74,7 @@ async fn main() -> anyhow::Result<()> { match args[1].as_str() { "publish" => { - let broadcast = origin.create_broadcast(&args[3])?; + let broadcast = origin.create_broadcast(moq_net::Path::new(&args[3])?)?; let mut track = broadcast.create_track( "tail", moq_net::track::Info::default() @@ -129,7 +129,7 @@ async fn main() -> anyhow::Result<()> { .connect(url) .established() .await?; - let broadcast = consumer.routed_broadcast(&args[3]).await?; + let broadcast = consumer.routed_broadcast(moq_net::Path::new(&args[3])?).await?; let remote = broadcast.track("tail")?; if status { // Query before subscribing so draft-18+ must use TRACK_STATUS, From 881498d2ac7d10e9d621f00455931ed065121577 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sat, 24 Oct 2026 22:52:37 -0700 Subject: [PATCH 06/67] wip: strict JS Path.from and test fixes Co-Authored-By: Claude Opus 5.5 --- js/moq-boy/src/element.tsx | 8 ++-- js/moq-boy/src/game.ts | 4 +- js/net/src/lite/announce.test.ts | 6 +-- js/net/src/origin.test.ts | 17 ------- js/net/src/origin.ts | 23 +++------- js/net/src/path.test.ts | 75 +++++-------------------------- js/net/src/path.ts | 54 +++++++++++----------- js/room/src/token.test.ts | 12 ++--- js/room/src/token.ts | 2 +- js/watch/src/msf.ts | 8 ++-- rs/moq-auth/src/path.rs | 5 ++- rs/moq-net/src/ietf/subscriber.rs | 2 +- rs/moq-room/src/claims.rs | 14 +++--- rs/moq-stats/src/produce.rs | 6 +-- 14 files changed, 77 insertions(+), 159 deletions(-) diff --git a/js/moq-boy/src/element.tsx b/js/moq-boy/src/element.tsx index a0c9c0ba93b..70f06bb77b3 100644 --- a/js/moq-boy/src/element.tsx +++ b/js/moq-boy/src/element.tsx @@ -120,7 +120,7 @@ export default class MoqBoy extends HTMLElement { /** The path prefix for game broadcasts, mirrored by the `prefix-game` attribute. */ get prefixGame(): string { - return this.#gamePrefixOverride.peek() ?? `${this.#prefix.peek()}/game`; + return this.#gamePrefixOverride.peek() ?? Moq.Path.from(this.#prefix.peek(), "game"); } set prefixGame(value: string) { @@ -129,7 +129,7 @@ export default class MoqBoy extends HTMLElement { /** The path prefix for viewer broadcasts, mirrored by the `prefix-viewer` attribute. */ get prefixViewer(): string { - return this.#viewerPrefixOverride.peek() ?? `${this.#prefix.peek()}/viewer`; + return this.#viewerPrefixOverride.peek() ?? Moq.Path.from(this.#prefix.peek(), "viewer"); } set prefixViewer(value: string) { @@ -138,8 +138,8 @@ export default class MoqBoy extends HTMLElement { #runDiscovery(effect: Moq.Signals.Effect) { const base = effect.get(this.#prefix); - const gamePrefix = effect.get(this.#gamePrefixOverride) ?? `${base}/game`; - const viewerPrefix = effect.get(this.#viewerPrefixOverride) ?? `${base}/viewer`; + const gamePrefix = effect.get(this.#gamePrefixOverride) ?? Moq.Path.from(base, "game"); + const viewerPrefix = effect.get(this.#viewerPrefixOverride) ?? Moq.Path.from(base, "viewer"); const prefix = Moq.Path.from(gamePrefix); // The origin's stream spans reconnects: entries retract when the session dies and diff --git a/js/moq-boy/src/game.ts b/js/moq-boy/src/game.ts index 660b49cc72c..e89719915e9 100644 --- a/js/moq-boy/src/game.ts +++ b/js/moq-boy/src/game.ts @@ -130,7 +130,7 @@ export class Game { // Video pipeline. this.broadcast = new Watch.Broadcast({ origin: config.origin, - name: Moq.Path.from(`${gamePrefix}/${sessionId}`), + name: Moq.Path.from(gamePrefix, sessionId), enabled: true, }); this.#signals.cleanup(() => this.broadcast.close()); @@ -318,7 +318,7 @@ export class Game { this.viewerId.set(viewerId); const viewerBroadcast = origin.createBroadcast( - Moq.Path.from(`${this.#viewerPrefix}/${this.sessionId}/${viewerId}`), + Moq.Path.from(this.#viewerPrefix, this.sessionId, viewerId), ); viewerBroadcast.announce({ epoch: Moq.Epoch.mint() }); effect.cleanup(() => { diff --git a/js/net/src/lite/announce.test.ts b/js/net/src/lite/announce.test.ts index 9263e6bbc10..8de89665fab 100644 --- a/js/net/src/lite/announce.test.ts +++ b/js/net/src/lite/announce.test.ts @@ -171,14 +171,14 @@ async function requestRoundTrip(msg: AnnounceRequest, version: Version): Promise // Draft04/05 carry the subscriber's Hop ID so the publisher can skip reflected // announces before they hit the wire. test("AnnounceRequest carries excludeHop on draft-05", async () => { - const got = await requestRoundTrip(new AnnounceRequest(Path.from("room/"), HopSchema.parse(42n)), Version.DRAFT_05); + const got = await requestRoundTrip(new AnnounceRequest(Path.from("room"), HopSchema.parse(42n)), Version.DRAFT_05); expect(got.excludeHop).toBe(HopSchema.parse(42n)); }); // Draft06 dropped the field: the receiver's reflected-announce check catches the same // loops, so a value set locally is simply not sent and decodes as zero. test("AnnounceRequest drops excludeHop on draft-06", async () => { - const msg = new AnnounceRequest(Path.from("room/"), HopSchema.parse(42n)); + const msg = new AnnounceRequest(Path.from("room"), HopSchema.parse(42n)); const got = await requestRoundTrip(msg, Version.DRAFT_06); expect(got.excludeHop).toBe(UNKNOWN_HOP); @@ -190,7 +190,7 @@ test("AnnounceRequest drops excludeHop on draft-06", async () => { // Draft07 carries the hidden opt-in; every earlier version decodes as not opted in. test("AnnounceRequest carries hidden from draft-07", async () => { for (const hidden of [false, true]) { - const msg = new AnnounceRequest(Path.from("room/"), UNKNOWN_HOP, hidden); + const msg = new AnnounceRequest(Path.from("room"), UNKNOWN_HOP, hidden); expect((await requestRoundTrip(msg, Version.DRAFT_07)).hidden).toBe(hidden); expect((await requestRoundTrip(msg, Version.DRAFT_06)).hidden).toBe(false); } diff --git a/js/net/src/origin.test.ts b/js/net/src/origin.test.ts index 9d723b44fb6..1433b81dcde 100644 --- a/js/net/src/origin.test.ts +++ b/js/net/src/origin.test.ts @@ -2648,20 +2648,3 @@ test("published names refuse navigation segments", () => { origin.close(); } }); - -test("published names refuse empty segments", () => { - const origin = new Producer(); - try { - for (const name of ["/room/cam", "room/cam/", "room//cam", "/"]) { - expect(() => origin.createBroadcast(name)).toThrow("empty segment"); - expect(() => origin.dynamic(name)).toThrow("empty segment"); - } - // A scope root is a prefix, normalized like a subscription, so it never refuses a name below it. - const scoped = origin.scope(Path.from("room/"), new Path.Patterns([Path.Pattern.all()])); - scoped.createBroadcast("cam").close(); - // The root path has no segments, so none of them is empty. - origin.createBroadcast("").close(); - } finally { - origin.close(); - } -}); diff --git a/js/net/src/origin.ts b/js/net/src/origin.ts index 9fa076576b7..4afc110529e 100644 --- a/js/net/src/origin.ts +++ b/js/net/src/origin.ts @@ -480,15 +480,6 @@ function publishPath(path: Path.Valid): void { } } -// Checked before normalization, which would otherwise give one name several spellings. -// Normalization only removes slashes, so a string without an empty segment is already valid. -function publishInput(path: string): Path.Valid { - if (path.startsWith("/") || path.endsWith("/") || path.includes("//")) { - throw new Error("broadcast path contains an empty segment"); - } - return path as Path.Valid; -} - /** Reactive backing state shared by origin producers and consumers. */ class OriginState { // Both tables decouple the application producing into the origin from the @@ -1066,7 +1057,7 @@ export interface Table { readonly discovery: Getter; /** Create an unannounced broadcast at `path`; see {@link Producer.createBroadcast}. */ - createBroadcast(path: string): broadcast.Producer; + createBroadcast(path: Path.Valid): broadcast.Producer; /** Resolve `path`, optionally waiting for an announcement; see {@link Consumer.request}. */ request(path: Path.Valid, options?: RequestOptions): Requesting; @@ -1075,7 +1066,7 @@ export interface Table { announced(scope?: Path.Pattern, options?: announce.Options): announce.Consumer; /** Advertise a prefix and serve requests under it; see {@link Producer.dynamic}. */ - dynamic(prefix: string): Dynamic; + dynamic(prefix: Path.Valid): Dynamic; /** Insert a route with protocol metadata. @internal */ dynamicRoute( @@ -1201,11 +1192,9 @@ export class Producer implements Table { * application still holds a consumer clone. Announce with a {@link Route.epoch} * (`Epoch.mint()` per run) so a restart replaces the old broadcast rather than resuming * into it; at the same epoch, a local broadcast competes on cost and wins ties. - * - * Throws when `name` has a leading, trailing, or doubled `/`, or a `.` or `..` segment. */ - createBroadcast(name: string): broadcast.Producer { - const path = this.#scope.path(publishInput(name)); + createBroadcast(path: Path.Valid): broadcast.Producer { + path = this.#scope.path(path); if (this.#borrowed?.closed) throw new Error("origin handle is closed"); publishPath(path); const created = this.#state.created; @@ -1281,8 +1270,8 @@ export class Producer implements Table { * the returned {@link Dynamic} lives. A consumer resolving a path under it that * no announced local broadcast wins is handed to the handle as a {@link Request}. */ - dynamic(prefix: string): Dynamic { - return this.#insertRoute(publishInput(prefix), Route.default, true, true); + dynamic(prefix: Path.Valid): Dynamic { + return this.#insertRoute(prefix, Route.default, true, true); } /** Insert an originated claim with route metadata that answers through `accept`, for tests and benches. @internal */ diff --git a/js/net/src/path.test.ts b/js/net/src/path.test.ts index 82189ee22ab..d2bbe68170b 100644 --- a/js/net/src/path.test.ts +++ b/js/net/src/path.test.ts @@ -4,16 +4,17 @@ import * as Path from "./path.ts"; /** Brand a literal as a relative reference; the tests feed raw strings on purpose. */ const asRel = (s: string) => s as Path.Relative; -test("Path constructor trims leading and trailing slashes", () => { - expect(Path.from("/foo/bar/")).toBe("foo/bar" as Path.Valid); - expect(Path.from("///foo/bar///")).toBe("foo/bar" as Path.Valid); +test("from refuses empty segments", () => { + for (const raw of ["/foo", "foo/", "/foo/bar/", "foo//bar", "/", "//"]) { + expect(() => Path.from(raw)).toThrow("empty segment"); + expect(() => Path.from("ok", raw)).toThrow("empty segment"); + } expect(Path.from("foo/bar")).toBe("foo/bar" as Path.Valid); }); -test("Path constructor handles empty paths", () => { - expect(Path.from("")).toBe("" as Path.Valid); - expect(Path.from("/")).toBe("" as Path.Valid); - expect(Path.from("///")).toBe("" as Path.Valid); +test("from treats the empty path as the root", () => { + expect(Path.from("")).toBe(Path.empty()); + expect(Path.from()).toBe(Path.empty()); }); test("hasPrefix matches exact paths", () => { @@ -40,12 +41,6 @@ test("hasPrefix handles empty prefix", () => { expect(Path.hasPrefix(Path.empty(), path)).toBe(true); }); -test("hasPrefix ignores trailing slashes in prefix", () => { - const path = Path.from("foo/bar"); - expect(Path.hasPrefix(Path.from("foo/"), path)).toBe(true); - expect(Path.hasPrefix(Path.from("foo/bar/"), path)).toBe(true); -}); - test("stripPrefix strips valid prefixes", () => { const path = Path.from("foo/bar/baz"); @@ -111,49 +106,6 @@ test("join handles multiple joins", () => { expect(path).toBe("api/v1/users/123" as Path.Valid); }); -test("equals checks correctly", () => { - const path1 = Path.from("foo/bar"); - const path2 = Path.from("/foo/bar/"); - const path3 = Path.from("foo/baz"); - - expect(path1 === path2).toBe(true); - expect(path1 === path3).toBe(false); -}); - -test("handles paths with multiple consecutive slashes", () => { - const path = Path.from("foo//bar///baz"); - // Multiple consecutive slashes are collapsed to single slashes - expect(path).toBe("foo/bar/baz" as Path.Valid); -}); - -test("removes multiple slashes comprehensively", () => { - // Test various multiple slash scenarios - expect(Path.from("foo//bar")).toBe("foo/bar" as Path.Valid); - expect(Path.from("foo///bar")).toBe("foo/bar" as Path.Valid); - expect(Path.from("foo////bar")).toBe("foo/bar" as Path.Valid); - - // Multiple occurrences of double slashes - expect(Path.from("foo//bar//baz")).toBe("foo/bar/baz" as Path.Valid); - expect(Path.from("a//b//c//d")).toBe("a/b/c/d" as Path.Valid); - - // Mixed slash counts - expect(Path.from("foo//bar///baz////qux")).toBe("foo/bar/baz/qux" as Path.Valid); - - // With leading and trailing slashes - expect(Path.from("//foo//bar//")).toBe("foo/bar" as Path.Valid); - expect(Path.from("///foo///bar///")).toBe("foo/bar" as Path.Valid); - - // Edge case: only slashes - expect(Path.from("//")).toBe("" as Path.Valid); - expect(Path.from("////")).toBe("" as Path.Valid); - - // Test that operations work correctly with normalized paths - const pathWithSlashes = Path.from("foo//bar///baz"); - expect(Path.hasPrefix(Path.from("foo/bar"), pathWithSlashes)).toBe(true); - expect(Path.stripPrefix(Path.from("foo"), pathWithSlashes)).toBe("bar/baz" as Path.Valid); - expect(Path.join(pathWithSlashes, Path.from("qux"))).toBe("foo/bar/baz/qux" as Path.Valid); -}); - test("handles special characters", () => { const path = Path.from("foo-bar_baz.txt"); expect(path).toBe("foo-bar_baz.txt" as Path.Valid); @@ -171,11 +123,6 @@ test("from handles empty strings in arguments", () => { expect(Path.from("", "foo", "bar", "")).toBe("foo/bar" as Path.Valid); }); -test("from sanitizes multiple arguments with slashes", () => { - expect(Path.from("/foo/", "/bar/", "/baz/")).toBe("foo/bar/baz" as Path.Valid); - expect(Path.from("foo//", "//bar", "baz")).toBe("foo/bar/baz" as Path.Valid); -}); - test("resolve replaces the base name", () => { expect(Path.resolve(Path.from("a/b"), asRel("c"))).toBe(Path.from("a/c")); expect(Path.resolve(Path.from("a/b"), asRel("c/d"))).toBe(Path.from("a/c/d")); @@ -295,7 +242,7 @@ test("normalizeRelative preserves an all-dot reference", () => { test("parts splits a path into its components", () => { expect(Path.parts(Path.from(""))).toEqual([]); expect(Path.parts(Path.from("foo"))).toEqual(["foo"]); - expect(Path.parts(Path.from("/foo//bar/"))).toEqual(["foo", "bar"]); + expect(Path.parts(Path.from("foo/bar"))).toEqual(["foo", "bar"]); }); test("decode enforces the max part count", () => { @@ -308,11 +255,11 @@ test("decode never allocates per slash of a hostile path", () => { // A peer can send a path as large as a control message; splitting it would hold one entry per // slash, so decode must count separators and stop at the limit instead. const slashes = "/".repeat(1024 * 1024); - const parts = "a/".repeat(1024 * 1024); + const parts = `${"a/".repeat(1024 * 1024)}a`; const split = spyOn(String.prototype, "split"); const indexOf = spyOn(String.prototype, "indexOf"); try { - expect(Path.decode(slashes)).toBe(Path.empty()); + expect(() => Path.decode(slashes)).toThrow("empty segment"); indexOf.mockClear(); let error: unknown; try { diff --git a/js/net/src/path.ts b/js/net/src/path.ts index e79ac672a52..1f3ec921e4e 100644 --- a/js/net/src/path.ts +++ b/js/net/src/path.ts @@ -4,26 +4,24 @@ * This module provides path-aware operations that respect delimiter boundaries, * preventing issues like "foo" matching "foobar". * - * Paths are automatically trimmed of leading and trailing slashes on creation, - * making all slashes implicit at boundaries. A path names a point in the origin's - * tree from its root; a leading slash never escapes that root. The same type names - * an exact broadcast and the prefix a route or announcement covers, so a broadcast's - * own path is the prefix it announces. See {@link Relative} for `..`-style references. + * A path is a run of non-empty segments separated by `/`, so it has exactly one spelling: + * {@link from} throws on a leading, trailing, or doubled slash rather than collapsing it. + * The empty path is the root, which prefixes every path; a prefix needs no trailing slash. + * A path names a point in the origin's tree from its root. The same type names an exact + * broadcast and the prefix a route or announcement covers, so a broadcast's own path is + * the prefix it announces. See {@link Relative} for `..`-style references. * * {@link Pattern} and {@link Patterns} are re-exported from `@moq/pattern`, the owner of - * the v1 grammar and algebra. Literal path construction and wire decoding retain - * their existing behavior. + * the v1 grammar and algebra. * * @example * ```typescript - * // Creation automatically trims slashes - * const path1 = Path.from("/foo/bar/"); - * const path2 = Path.from("foo/bar"); - * console.log(path1 === path2); // true + * // Multiple arguments are joined with "/", and an empty one is the root + * const path = Path.from("api", "", "v1/users"); + * console.log(path); // "api/v1/users" * - * // Multiple arguments are joined with "/" - * const path3 = Path.from("api", "v1", "users"); - * console.log(path3); // "api/v1/users" + * // A slash at a boundary or a doubled one is an empty segment + * Path.from("/api/v1"); // throws * * // Safe prefix matching * const base = Path.from("api/v1"); @@ -36,7 +34,7 @@ * @module */ -/** A normalized broadcast path. */ +/** A broadcast path: non-empty segments separated by `/`, or the empty root. */ export type Valid = string & { __brand: "Name" }; /** @@ -56,11 +54,18 @@ export type Relative = string & { __brand: "Relative" }; */ export const MAX_PARTS = 32; -/** Build a path from one or more components, joining with "/" and trimming redundant slashes. */ +/** + * Build a path by joining components with "/", where an empty component is the root. + * + * Throws when a component has a leading, trailing, or doubled `/`. + */ export function from(...paths: string[]): Valid { - // Join paths with "/" and then remove leading and trailing slashes, and collapse multiple slashes into one. - const joined = paths.join("/"); - return joined.replace(/\/+/g, "/").replace(/^\/+/, "").replace(/\/+$/, "") as Valid; + for (const path of paths) { + if (path.startsWith("/") || path.endsWith("/") || path.includes("//")) { + throw new Error("path contains an empty segment"); + } + } + return paths.filter((path) => path !== "").join("/") as Valid; } /** Split a path into its slash-separated parts. The empty path has no parts. */ @@ -71,11 +76,10 @@ export function parts(path: Valid): string[] { /** * Validate an untrusted wire string as a path, enforcing {@link MAX_PARTS}. * - * Throws when the path has too many parts; use at wire decode sites. + * Throws when the path has an empty segment or too many parts; use at wire decode sites. */ export function decode(raw: string): Valid { - const path = from(raw); - return encode(path); + return encode(from(raw)); } /** @@ -108,7 +112,6 @@ export function encode(path: Valid): Valid { * ```typescript * const path = Path.from("foo/bar"); * console.log(Path.hasPrefix(Path.from("foo"), path)); // true - * console.log(Path.hasPrefix(Path.from("foo/"), path)); // true (trailing slash ignored) * console.log(Path.hasPrefix(Path.from("fo"), path)); // false * * const path2 = Path.from("foobar"); @@ -144,9 +147,6 @@ export function hasPrefix(prefix: Valid, path: Valid): boolean { * const suffix = Path.stripPrefix(Path.from("foo"), path); * console.log(suffix); // "bar/baz" * - * const suffix2 = Path.stripPrefix(Path.from("foo/"), path); - * console.log(suffix2); // "bar/baz" - * * const noMatch = Path.stripPrefix(Path.from("notfound"), path); * console.log(noMatch); // null * ``` @@ -186,7 +186,7 @@ export function join(path: Valid, other: Valid): Valid { } else if (other === "") { return path; } else { - // Since paths are trimmed, we always need to add a slash + // Neither side has a boundary slash, so exactly one joins them return `${path}/${other}` as Valid; } } diff --git a/js/room/src/token.test.ts b/js/room/src/token.test.ts index ce4245c81ef..f75dc0febcd 100644 --- a/js/room/src/token.test.ts +++ b/js/room/src/token.test.ts @@ -9,8 +9,10 @@ test("claims root the token at the room and scope publish to the identity", () = }); }); -test("claims does not double a trailing slash on publish", () => { - expect(claims("meet/demo", "alice/").publish).toEqual(["alice/**"]); +test("claims rejects an identity with an empty segment", () => { + for (const identity of ["alice/", "/alice", "a//b"]) { + expect(() => claims("room", identity)).toThrow("empty segment"); + } }); test("claims accepts a multi-segment identity", () => { @@ -21,10 +23,8 @@ test("claims accepts a multi-segment identity", () => { }); }); -test("claims rejects empty normalized identities", () => { - for (const identity of ["", "/", "///"]) { - expect(() => claims("room", identity)).toThrow(); - } +test("claims rejects an empty identity", () => { + expect(() => claims("room", "")).toThrow("must not be empty"); }); test("claims rejects identities with wildcards", () => { diff --git a/js/room/src/token.ts b/js/room/src/token.ts index 75a64c46049..71e9dd771f8 100644 --- a/js/room/src/token.ts +++ b/js/room/src/token.ts @@ -24,7 +24,7 @@ export type Claims = { * * `root` is the room prefix, `subscribe` is `**` (everything under the room), and * `publish` is `/**` so a participant cannot publish at anyone else's - * paths. Throws on an identity that is empty after normalization or contains `*`, + * paths. Throws on an identity that is empty, has an empty segment, or contains `*`, * since a wildcard would let the participant publish as someone else. */ export function claims(room: string, identity: string): Claims { diff --git a/js/watch/src/msf.ts b/js/watch/src/msf.ts index cd5e2336115..45d9a819e9f 100644 --- a/js/watch/src/msf.ts +++ b/js/watch/src/msf.ts @@ -128,10 +128,12 @@ export function toHang(msf: Msf.Catalog, base?: Path.Valid): Catalog.Root { if (track.namespace !== undefined) { if (base === undefined) throw new Error(`MSF track ${track.name} namespace requires the catalog broadcast path`); - const target = Path.from(track.namespace); - // Normalizing an MSF namespace must not select different content. - if (target !== track.namespace) + let target: Path.Valid; + try { + target = Path.from(track.namespace); + } catch { throw new Error(`MSF track ${track.name} namespace cannot be referenced from the catalog`); + } if (!namesCatalog(target, base)) { const relative = Path.relative(target, base); if (relative === undefined) diff --git a/rs/moq-auth/src/path.rs b/rs/moq-auth/src/path.rs index b857473106b..8cf0ea68a24 100644 --- a/rs/moq-auth/src/path.rs +++ b/rs/moq-auth/src/path.rs @@ -3,8 +3,9 @@ //! A token's root and a connection's path are literal paths, so overlapping them is //! prefix arithmetic; everything beneath is a pattern from `moq-pattern`, re-exported //! from this crate so a token minting service does not pull in the wire stack. The -//! normalization and boundary rules must stay identical to `moq_net::Path`, which the -//! relay applies to the same strings. +//! boundary rules must stay identical to `moq_net::Path`, which the relay applies to +//! the same strings. `moq_net::Path` refuses the empty segments [`normalize`] drops, so +//! a string spelled with one is refused there rather than read as another path. //! //! Every function below assumes its arguments are already [`normalize`]d. diff --git a/rs/moq-net/src/ietf/subscriber.rs b/rs/moq-net/src/ietf/subscriber.rs index 40095514b98..9203afd2935 100644 --- a/rs/moq-net/src/ietf/subscriber.rs +++ b/rs/moq-net/src/ietf/subscriber.rs @@ -6831,7 +6831,7 @@ mod tests { settle().await; } for entry in entries { - cursor.assert_next_active(Path::new(*entry).unwrap()); + cursor.assert_next_active(Path::new(entry).unwrap()); } assert_eq!(cursor.is_synced(), synced, "{entries:?}"); } diff --git a/rs/moq-room/src/claims.rs b/rs/moq-room/src/claims.rs index 54fd2385fa2..d924fe49ac4 100644 --- a/rs/moq-room/src/claims.rs +++ b/rs/moq-room/src/claims.rs @@ -7,7 +7,7 @@ /// /// `root` is the room prefix, `subscribe` is `**` (everything under the room), /// and `publish` is `/**` so a participant cannot publish at anyone -/// else's paths. An identity that is empty after normalization or contains `*` is +/// else's paths. An identity that is empty or contains `*` is /// refused, since a wildcard would let the participant publish as someone else. pub fn claims(room: impl moq_net::AsPath, identity: impl moq_net::AsPath) -> Result { let room = room.as_path(); @@ -33,9 +33,10 @@ mod tests { #[test] fn rejects_empty_identity() { - for identity in ["", "/", "///"] { - assert!(matches!(claims(Path::new("room").unwrap(), Path::new(identity).unwrap()), Err(crate::Error::EmptyIdentity))); - } + assert!(matches!( + claims(Path::new("room").unwrap(), Path::empty()), + Err(crate::Error::EmptyIdentity) + )); } #[test] @@ -56,11 +57,6 @@ mod tests { assert_eq!(c.publish, patterns(&["alice/**"])); } - #[test] - fn claims_does_not_double_a_trailing_slash() { - assert_eq!(claims(Path::new("meet/demo").unwrap(), Path::new("alice/").unwrap()).unwrap().publish, patterns(&["alice/**"])); - } - #[test] fn claims_accepts_a_multi_segment_identity() { let c = claims(Path::new("hang/room").unwrap(), Path::new("guest/uuid").unwrap()).unwrap(); diff --git a/rs/moq-stats/src/produce.rs b/rs/moq-stats/src/produce.rs index 5bec8325423..6fb90378c6e 100644 --- a/rs/moq-stats/src/produce.rs +++ b/rs/moq-stats/src/produce.rs @@ -2126,11 +2126,11 @@ mod tests { /// all-empty one. Observed through the announced path, since the task /// announces at construction. #[tokio::test(start_paused = true)] - async fn new_normalizes_and_drops_empty_node() { - let (_producer, origin) = test_producer(Some("/sjc//1/")); + async fn new_drops_empty_node() { + let (_producer, origin) = test_producer(Some("sjc/1")); assert_eq!(announced(&origin).await.0, ".stats/node/sjc/1"); - let (_producer, origin) = test_producer(Some("///")); + let (_producer, origin) = test_producer(Some("")); assert_eq!(announced(&origin).await.0, ".stats/node"); } From ccc45a70b0ab25e48ed76c2b6122a913e4b5764f Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sat, 24 Oct 2026 22:55:19 -0700 Subject: [PATCH 07/67] wip: document strict paths in the lite draft, concept doc, and MIGRATE guides Co-Authored-By: Claude Opus 5.5 --- cpp/moq/MIGRATE.md | 4 ++++ cpp/obs/MIGRATE.md | 4 ++++ dart/moq/MIGRATE.md | 4 ++++ doc/concept/moq-lite.md | 5 +++++ drafts/draft-lcurley-moq-lite.md | 3 +++ go/wrapper/MIGRATE.md | 4 ++++ js/net/MIGRATE.md | 9 ++++----- js/room/MIGRATE.md | 4 ++++ kt/moq/MIGRATE.md | 4 ++++ py/moq-rs/MIGRATE.md | 4 ++++ rs/moq-c/MIGRATE.md | 4 ++++ rs/moq-cli/MIGRATE.md | 4 ++++ rs/moq-ffi/MIGRATE.md | 4 ++++ rs/moq-net/MIGRATE.md | 11 ++++++----- rs/moq-relay/MIGRATE.md | 5 +++++ swift/MIGRATE.md | 4 ++++ 16 files changed, 67 insertions(+), 10 deletions(-) diff --git a/cpp/moq/MIGRATE.md b/cpp/moq/MIGRATE.md index 6ca4ebcf703..43431a84fd5 100644 --- a/cpp/moq/MIGRATE.md +++ b/cpp/moq/MIGRATE.md @@ -2,6 +2,10 @@ ## Unreleased +### Paths with an empty segment are refused (#6648) + +Publishing, serving, or requesting a broadcast at a path with a leading, trailing, or doubled `/` fails instead of collapsing it. Pass the canonical path, such as `room/cam`. + ### First release There is no published C++ package to migrate from. Start with the current headers and examples, and build the wrapper, generated bindings, and native library together. diff --git a/cpp/obs/MIGRATE.md b/cpp/obs/MIGRATE.md index f69a6a0ad13..46c1e23b432 100644 --- a/cpp/obs/MIGRATE.md +++ b/cpp/obs/MIGRATE.md @@ -4,6 +4,10 @@ How to update your OBS setup for each breaking change, newest first. ## Unreleased +### Broadcast names with an empty segment are refused (#6648) + +A broadcast name with a leading, trailing, or doubled `/` fails to publish or play instead of being collapsed. Use the canonical name, such as `room/cam`. + Connection state and first-dial failures now arrive through one lifecycle watcher. UI reads no longer poll the Client or Session for failure separately. ### Key logging is opt-in (#5907) diff --git a/dart/moq/MIGRATE.md b/dart/moq/MIGRATE.md index b20e5bbafb8..d115db5d641 100644 --- a/dart/moq/MIGRATE.md +++ b/dart/moq/MIGRATE.md @@ -4,6 +4,10 @@ How to update your code for each breaking change, newest first. ## Unreleased +### Paths with an empty segment are refused (#6648) + +Publishing, serving, or requesting a broadcast at a path with a leading, trailing, or doubled `/` throws instead of collapsing it. Pass the canonical path, such as `room/cam`. + ### Connection state `Moq.connect` returns a connecting native session. Replace status, connect-count, and failure polls with `session.state()` and `session.stateChanged(after: state.revision)`. `ConnectionState` carries `phase`, `connects`, `failure`, and `version`; `ConnectionPhase` replaces `ConnectionStatus`. diff --git a/doc/concept/moq-lite.md b/doc/concept/moq-lite.md index e074b96f011..0fbf94f1035 100644 --- a/doc/concept/moq-lite.md +++ b/doc/concept/moq-lite.md @@ -29,6 +29,11 @@ carries [publisher epochs](#publisher-epochs). | **Frame** | A sized chunk of bytes. | Object | | **Datagram** | One unreliable frame sent as a QUIC datagram instead of a group. | Datagram | +A broadcast is named by a path: non-empty segments joined by `/`, such as +`room/alice`. A path never starts or ends with `/` or doubles one, so each name +has one spelling, and every API and peer refuses one that does. The empty path +is the root, which prefixes every path. + ## Discovery A session can ask for announcements matching a path prefix. The peer replies diff --git a/drafts/draft-lcurley-moq-lite.md b/drafts/draft-lcurley-moq-lite.md index 31d894cb187..5700ba93c06 100644 --- a/drafts/draft-lcurley-moq-lite.md +++ b/drafts/draft-lcurley-moq-lite.md @@ -127,6 +127,7 @@ Any broadcasts and subscriptions are transparently proxied by the CDN behind the ## Broadcast A Broadcast is a collection of Tracks named by a path. This corresponds to a MoqTransport's "track namespace". +A path is a sequence of non-empty segments joined by `/` (0x2F), so it never starts or ends with `/` or contains two in a row; the empty path has no segments and prefixes every path. A publisher instance is identified by an Epoch, carried on its routes (see [ANNOUNCE_START](#announce-start)): a path and an Epoch name one Broadcast, and a publisher MUST NOT serve different content under the same pair. A restarted publisher mints a new Epoch rather than reusing the path's old one, while replicas of the same content MAY share one. A route without an Epoch names no instance: nothing says another route serves the same bytes. @@ -1798,6 +1799,8 @@ The `Message Length` describes the payload size on the wire. ## moq-lite-07 +- A path never has an empty segment, so a leading, trailing, or doubled `/` is a PROTOCOL_VIOLATION rather than a second spelling of the same path. + - Added the SETUP `Implementation` parameter (0x6): the sender's software as `name/version` product tokens. Earlier versions with a Setup Stream ignore it as an unknown parameter. - Hop IDs span 64 bits; a relay sends 0 in place of one an earlier version's varint cannot carry. diff --git a/go/wrapper/MIGRATE.md b/go/wrapper/MIGRATE.md index c1f214e6a81..24136d27013 100644 --- a/go/wrapper/MIGRATE.md +++ b/go/wrapper/MIGRATE.md @@ -4,6 +4,10 @@ How to update your code for each breaking change, newest first. ## Unreleased +### Paths with an empty segment are refused (#6648) + +Publishing, serving, or requesting a broadcast at a path with a leading, trailing, or doubled `/` returns an error instead of collapsing it. Pass the canonical path, such as `room/cam`. + ### Connection state `Dial` returns a connecting native client. Replace `Session.Status`, `Connects`, and `Failure` with `State()` and `StateChanged(ctx, state.Revision)`. `ConnectionState` carries `Phase`, `Connects`, `Failure`, and `Version`; `ConnectionPhase` replaces `ConnectionStatus`. Cancelling a state wait only cancels that wait. Cancel the session itself to stop its dial. diff --git a/js/net/MIGRATE.md b/js/net/MIGRATE.md index bee7414ee87..ecec42d1b63 100644 --- a/js/net/MIGRATE.md +++ b/js/net/MIGRATE.md @@ -4,17 +4,16 @@ How to update your code for each breaking change, newest first. ## Unreleased -### Published names refuse empty segments +### `Path.from` refuses empty segments (#6648) -`Origin.Producer.createBroadcast` and `dynamic` take the name as a plain `string` and throw on a leading, trailing, or doubled `/` rather than relying on `Path.from` to collapse it, so a name has one spelling. -Pass the canonical name (`room/cam`, not `/room/cam/` or `room//cam`); a `Path.Valid` is already canonical and still works. -Scope roots and subscription paths keep normalizing. +`Path.from` throws on a component with a leading, trailing, or doubled `/` instead of collapsing it, so a path has one spelling, and `Path.decode` refuses one off the wire. +Pass canonical components: `Path.from("room/cam")` or `Path.from(prefix, "cam")`, where an empty component is the root, rather than `` Path.from(`${prefix}/cam`) `` or `Path.from("room/")`. ### Published names refuse navigation segments Broadcast creation and route publication now refuse literal `.` and `..` segments, including segments in the producer's root. Resolve relative references before publishing, or rename broadcasts that used these segments. -Path normalization, relative references, and subscription paths retain their semantics. +Relative references and subscription paths retain their semantics. ### A listing says whether a removed track finished (#6399) diff --git a/js/room/MIGRATE.md b/js/room/MIGRATE.md index 323ee407a1f..2c7e449b43f 100644 --- a/js/room/MIGRATE.md +++ b/js/room/MIGRATE.md @@ -4,6 +4,10 @@ How to update your code for each breaking change, newest first. ## Unreleased +### `claims` refuses an identity with an empty segment (#6648) + +`claims(room, identity)` throws on an identity with a leading, trailing, or doubled `/` instead of collapsing it: pass `alice`, not `alice/`. + ### Chat events carry their send time `Chat.Subscriber.recv()` returns `{ value, at }`: `value` is the event `recv()` used to return, and `at` is its frame's timestamp. diff --git a/kt/moq/MIGRATE.md b/kt/moq/MIGRATE.md index c42780b3615..3128111e03d 100644 --- a/kt/moq/MIGRATE.md +++ b/kt/moq/MIGRATE.md @@ -4,6 +4,10 @@ How to update your code for each breaking change, newest first. ## Unreleased +### Paths with an empty segment are refused (#6648) + +Publishing, serving, or requesting a broadcast at a path with a leading, trailing, or doubled `/` throws instead of collapsing it. Pass the canonical path, such as `room/cam`. + ### Connection state `Moq.connect` returns a connecting native session. Replace `status()`, `connects()`, and failure polls with `session.state()` and `session.stateChanged(state.revision)`. `ConnectionState` carries `phase`, `connects`, `failure`, and `version`; `ConnectionPhase` replaces `ConnectionStatus`. diff --git a/py/moq-rs/MIGRATE.md b/py/moq-rs/MIGRATE.md index 1ce345d17f7..1bda4efaf02 100644 --- a/py/moq-rs/MIGRATE.md +++ b/py/moq-rs/MIGRATE.md @@ -4,6 +4,10 @@ How to update your code for each breaking change, newest first. ## Unreleased +### Paths with an empty segment are refused (#6648) + +Publishing, serving, or requesting a broadcast at a path with a leading, trailing, or doubled `/` raises instead of collapsing it. Pass the canonical path, such as `room/cam`. + ### Connection state Client entry returns a connecting native session. Replace `Session.status()`, `connects()`, and both `failure()` polls with `state()` and `await state_changed(state.revision)`. The `ConnectionState` fields include `phase`, `connects`, `failure`, and `version`; `ConnectionPhase` replaces `ConnectionStatus`. Wait for `CONNECTED` when work requires an established transport, or await `closed()` for the terminal result. diff --git a/rs/moq-c/MIGRATE.md b/rs/moq-c/MIGRATE.md index 27fed02ed2a..c10627e73ca 100644 --- a/rs/moq-c/MIGRATE.md +++ b/rs/moq-c/MIGRATE.md @@ -4,6 +4,10 @@ How to update your code for each breaking change, newest first. ## Unreleased +### Paths with an empty segment are refused (#6648) + +`moq_origin_create_broadcast`, `moq_origin_dynamic`, `moq_origin_announced_broadcast`, and `moq_origin_request` return an error for a path with a leading, trailing, or doubled `/` instead of collapsing it. Pass the canonical path, such as `room/cam`. + ### Sessions report a lifecycle snapshot `moq_session_connect` and `moq_session_request_accept` take a `moq_state_callback` instead of a `moq_status_callback`: `void on_state(void *user_data, const moq_connection_state *state)`. diff --git a/rs/moq-cli/MIGRATE.md b/rs/moq-cli/MIGRATE.md index 84620196579..27dfd2490ba 100644 --- a/rs/moq-cli/MIGRATE.md +++ b/rs/moq-cli/MIGRATE.md @@ -4,6 +4,10 @@ How to update your invocation and config for each breaking change, newest first. ## Unreleased +### `--broadcast` refuses empty segments (#6648) + +A broadcast name or prefix with a leading, trailing, or doubled `/` is an error instead of being collapsed: pass `--broadcast room/cam`, not `/room/cam/`. + ### `import --linger` sets how long a finished broadcast stays up A cleanly ended import used to stay up for its `--max-age`; it now stays up for `--linger` (default 30 s), counted from the end, and `--max-age` only sets retention. diff --git a/rs/moq-ffi/MIGRATE.md b/rs/moq-ffi/MIGRATE.md index 056aa8a1fe4..e58d72c1291 100644 --- a/rs/moq-ffi/MIGRATE.md +++ b/rs/moq-ffi/MIGRATE.md @@ -5,6 +5,10 @@ These are the UniFFI names; each language wrapper has its own `MIGRATE.md` in it ## Unreleased +### Paths with an empty segment are refused (#6648) + +`MoqOriginProducer::create_broadcast` and `dynamic`, and `MoqOriginConsumer::announced_broadcast` and `request_broadcast`, return an error for a path with a leading, trailing, or doubled `/` instead of collapsing it. Pass the canonical path, such as `room/cam`. + ### Connection state `MoqClient::connect` returns a connecting session without waiting for its first dial to succeed, natively and in the browser. Read `MoqSession::state()` and pass its `revision` to `state_changed(after)` to observe first-dial failures and reconnects. `MoqConnectionState` carries `phase`, `connects`, `failure`, and `version` together. These replace `status()`, `connects()`, and both `failure()` polls. Cancel the returned session to stop dialing; cancelling or releasing the client does not close it. diff --git a/rs/moq-net/MIGRATE.md b/rs/moq-net/MIGRATE.md index d6f404bebfe..d685e069867 100644 --- a/rs/moq-net/MIGRATE.md +++ b/rs/moq-net/MIGRATE.md @@ -9,18 +9,19 @@ How to update your code for each breaking change, newest first. Rename `moq_net::stats::Refusal` to `moq_net::stats::RefusalKind`, so it no longer shares a name with `moq_auth::Refusal`; its variants and `Refusals` are unchanged. Replace `moq_net::time::now()` with `moq_net::time::Instant::now()`, the one way to read the clock. -### Published names refuse empty segments +### Building a `Path` refuses empty segments (#6648) -`origin::Producer::create_broadcast` and `dynamic` refuse a string name with a leading, trailing, or doubled `/` with `Error::EmptySegment`, instead of collapsing it, so a name has one spelling. -Pass the canonical name (`room/cam`, not `/room/cam/` or `room//cam`); a `Path` is already canonical and still works. -`AsPath` gains a provided `is_normalized` method. Scope roots and subscription paths keep normalizing. +`Path::new` returns `Result` and fails with `Error::EmptySegment` on a leading, trailing, or doubled `/` instead of collapsing it, so a path has one spelling. The empty path is still the root. +`AsPath` is implemented only for `Path` and `&Path`, so every API taking a path takes one built up front: replace `origin.create_broadcast("room/cam")` with `origin.create_broadcast(Path::new("room/cam")?)`, and convert an owned `String` with `PathOwned::try_from(s)?` or `s.parse::()?`. `From<&str>` and `From` are gone. +A prefix needs no trailing `/`: `Path::new("room")?` covers `room/cam`. +moq-lite decoding refuses a path with an empty segment as a protocol violation. ### Published names refuse navigation segments Broadcast creation and route publication now refuse literal `.` and `..` segments, including segments in the producer's root. Resolve relative references before publishing, or rename broadcasts that used these segments. Rust reports `Error::NavigationSegment`; the existing protocol error codes carry the refusal to a peer. -Path normalization, relative references, and subscription paths retain their semantics. +Relative references and subscription paths retain their semantics. ### A listing says whether a removed track finished (#6399) diff --git a/rs/moq-relay/MIGRATE.md b/rs/moq-relay/MIGRATE.md index bbff7c893fc..ed5bb85675b 100644 --- a/rs/moq-relay/MIGRATE.md +++ b/rs/moq-relay/MIGRATE.md @@ -5,6 +5,11 @@ Rolling a cluster across a release also follows the [upgrade guide](https://moq. ## Unreleased +### Paths with an empty segment are refused (#6648) + +A session dialed at a URL path with a trailing or doubled `/`, such as `/room/` or `/room//cam`, is refused instead of collapsed; dial `/room`. An auth grant whose `root`, `mounts`, or `label` has one is refused as unavailable, and `stats.prefix`, `stats.node`, and `--cluster-tier` with one refuse to start. +Embedders: `auth::Token::new` and `auth::Lease::new` return a `Result`. + ### Auth `server_name` is the SNI only (#6509) The auth request's `server_name` no longer falls back to the HTTP `Host` header, `:authority`, or the WebTransport CONNECT host: it is absent over plain `http://` and `ws://` and for an IP-literal dial, while HTTPS and `wss://` report the SNI. diff --git a/swift/MIGRATE.md b/swift/MIGRATE.md index 998978ed32a..5f90afb1420 100644 --- a/swift/MIGRATE.md +++ b/swift/MIGRATE.md @@ -4,6 +4,10 @@ How to update your code for each breaking change, newest first. ## Unreleased +### Paths with an empty segment are refused (#6648) + +Publishing, serving, or requesting a broadcast at a path with a leading, trailing, or doubled `/` throws instead of collapsing it. Pass the canonical path, such as `room/cam`. + ### Connection state `Client.connect(to:)` returns a connecting native session. Replace `status()`, `connects()`, and both `failure()` polls with `state()` and `stateChanged(after: state.revision)`. Use `ConnectionState.phase`, `connects`, `failure`, and `version`; `ConnectionPhase` replaces `ConnectionStatus`. From 3650160db9b3be2773c1f61e976d34018ec8866e Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sat, 24 Oct 2026 23:15:19 -0700 Subject: [PATCH 08/67] wip: format and fix moq-wasm Co-Authored-By: Claude Opus 5.5 --- js/moq-boy/src/game.ts | 4 +- js/net/MIGRATE.md | 2 +- rs/hang/examples/video.rs | 4 +- rs/moq-audio/src/decode/consumer.rs | 5 +- rs/moq-bench/src/connection.rs | 12 +- rs/moq-c/src/origin.rs | 19 +- rs/moq-c/src/publish.rs | 10 +- rs/moq-c/src/test.rs | 7 +- rs/moq-cli/src/announced.rs | 4 +- rs/moq-cli/src/archive.rs | 14 +- rs/moq-cli/src/complete.rs | 4 +- rs/moq-cli/src/fetch.rs | 4 +- rs/moq-cli/src/hls.rs | 9 +- rs/moq-cli/src/main.rs | 19 +- rs/moq-cli/src/play/media.rs | 4 +- rs/moq-cli/src/publish.rs | 24 +- rs/moq-cli/src/report.rs | 8 +- rs/moq-cli/src/srt.rs | 2 +- rs/moq-cli/src/transcode.rs | 6 +- rs/moq-cli/tests/integration/epochs.rs | 19 +- rs/moq-cli/tests/integration/export.rs | 6 +- rs/moq-cli/tests/integration/import.rs | 20 +- rs/moq-cli/tests/integration/report.rs | 5 +- rs/moq-cli/tests/integration/rtsp.rs | 10 +- rs/moq-ffi/src/test.rs | 2 +- rs/moq-gst/src/sink/session.rs | 5 +- rs/moq-gst/src/source/imp.rs | 5 +- rs/moq-hls/src/export/mod.rs | 184 +- rs/moq-hls/src/export/rendition.rs | 12 +- rs/moq-hls/src/server/mod.rs | 20 +- rs/moq-hls/src/server/routes.rs | 71 +- rs/moq-mux/benches/catalog.rs | 3 +- rs/moq-mux/benches/containers.rs | 10 +- rs/moq-mux/benches/export.rs | 20 +- rs/moq-mux/benches/ts_programs.rs | 6 +- rs/moq-mux/src/catalog/hang/consumer.rs | 8 +- rs/moq-mux/src/container/consumer.rs | 2 +- rs/moq-mux/src/container/source.rs | 28 +- rs/moq-mux/src/container/test_util.rs | 2 +- rs/moq-mux/src/container/ts/export_test.rs | 103 +- rs/moq-mux/src/container/ts/health.rs | 6 +- rs/moq-mux/src/container/ts/programs.rs | 60 +- rs/moq-mux/src/follow.rs | 22 +- rs/moq-mux/src/linger.rs | 10 +- rs/moq-mux/src/source.rs | 67 +- rs/moq-net/benches/announce.rs | 2 +- rs/moq-net/benches/auth.rs | 13 +- rs/moq-net/benches/interests.rs | 2 +- rs/moq-net/benches/memory.rs | 5 +- rs/moq-net/benches/origin.rs | 216 ++- rs/moq-net/benches/session.rs | 32 +- rs/moq-net/benches/stats.rs | 20 +- rs/moq-net/benches/synced.rs | 2 +- rs/moq-net/benches/viewers.rs | 8 +- rs/moq-net/src/auth.rs | 18 +- rs/moq-net/src/coding/writer.rs | 10 +- rs/moq-net/src/fuzz.rs | 4 +- rs/moq-net/src/ietf/publisher.rs | 250 ++- rs/moq-net/src/ietf/publisher/tracks.rs | 14 +- rs/moq-net/src/ietf/session.rs | 17 +- rs/moq-net/src/ietf/subscriber.rs | 78 +- rs/moq-net/src/lite/announce.rs | 6 +- rs/moq-net/src/lite/ietf.rs | 48 +- rs/moq-net/src/lite/publisher.rs | 149 +- rs/moq-net/src/lite/subscriber.rs | 20 +- rs/moq-net/src/model/follow.rs | 71 +- rs/moq-net/src/model/origin.rs | 1488 +++++++++++++---- rs/moq-net/src/path/mod.rs | 5 +- rs/moq-net/src/server.rs | 7 +- rs/moq-net/src/stats.rs | 58 +- rs/moq-net/tests/announce_allocs.rs | 20 +- .../integration/announce_covering_route.rs | 11 +- .../tests/integration/announce_to_serve.rs | 13 +- rs/moq-net/tests/integration/auth.rs | 96 +- .../tests/integration/broadcast_close.rs | 2 +- .../tests/integration/catalog_acquisition.rs | 8 +- rs/moq-net/tests/integration/catalog_churn.rs | 7 +- .../tests/integration/catalog_handover.rs | 15 +- rs/moq-net/tests/integration/compress.rs | 18 +- rs/moq-net/tests/integration/control_stats.rs | 8 +- rs/moq-net/tests/integration/datagram.rs | 17 +- .../tests/integration/dial_split_horizon.rs | 2 +- rs/moq-net/tests/integration/drained_claim.rs | 8 +- rs/moq-net/tests/integration/empty_group.rs | 2 +- .../tests/integration/empty_replacement.rs | 2 +- rs/moq-net/tests/integration/extensions.rs | 2 +- rs/moq-net/tests/integration/fetch_cancel.rs | 8 +- rs/moq-net/tests/integration/fetch_fanout.rs | 12 +- .../tests/integration/fetch_from_feed.rs | 2 +- rs/moq-net/tests/integration/fetch_only.rs | 2 +- .../integration/finished_broadcast_mock.rs | 2 +- rs/moq-net/tests/integration/finite_relay.rs | 2 +- rs/moq-net/tests/integration/goaway.rs | 15 +- rs/moq-net/tests/integration/group_order.rs | 2 +- .../tests/integration/history_groups.rs | 12 +- .../tests/integration/idle_cancel_refetch.rs | 2 +- rs/moq-net/tests/integration/idle_session.rs | 2 +- .../tests/integration/ietf_conformance.rs | 14 +- .../tests/integration/late_lower_group.rs | 2 +- .../tests/integration/lazy_discovery.rs | 32 +- rs/moq-net/tests/integration/mesh_withdraw.rs | 10 +- rs/moq-net/tests/integration/model.rs | 9 +- rs/moq-net/tests/integration/multi_cdn.rs | 9 +- rs/moq-net/tests/integration/partial_group.rs | 2 +- rs/moq-net/tests/integration/quiet_catalog.rs | 7 +- rs/moq-net/tests/integration/range_anchors.rs | 13 +- .../tests/integration/received_rewind.rs | 2 +- rs/moq-net/tests/integration/refresh.rs | 14 +- rs/moq-net/tests/integration/rejoin.rs | 59 +- .../tests/integration/relay_upstream_close.rs | 2 +- rs/moq-net/tests/integration/replacement.rs | 38 +- rs/moq-net/tests/integration/request_caps.rs | 13 +- rs/moq-net/tests/integration/restart.rs | 42 +- rs/moq-net/tests/integration/route_change.rs | 42 +- rs/moq-net/tests/integration/session_close.rs | 7 +- rs/moq-net/tests/integration/session_panic.rs | 2 +- .../integration/settled_end_survives_abort.rs | 2 +- rs/moq-net/tests/integration/source_errors.rs | 2 +- rs/moq-net/tests/integration/stream_credit.rs | 6 +- .../tests/integration/subscribe_priority.rs | 2 +- .../tests/integration/subscribe_ranges.rs | 2 +- .../tests/integration/subscribe_tracks.rs | 2 +- .../tests/integration/subscriber_max_age.rs | 5 +- .../integration/subscription_end_integrity.rs | 2 +- .../integration/track_abort_over_session.rs | 13 +- .../tests/integration/track_info_cancel.rs | 8 +- .../tests/integration/track_stream_demand.rs | 12 +- rs/moq-net/tests/integration/track_tail.rs | 2 +- rs/moq-net/tests/integration/tracks.rs | 2 +- rs/moq-net/tests/integration/tracks_ietf.rs | 2 +- .../tests/integration/unannounce_release.rs | 11 +- rs/moq-net/tests/integration/untimed.rs | 14 +- rs/moq-net/tests/integration/wide_hop.rs | 18 +- rs/moq-net/tests/integration/wide_sequence.rs | 24 +- rs/moq-net/tests/integration/zero_copy.rs | 2 +- rs/moq-relay/src/auth.rs | 10 +- rs/moq-relay/src/auth/admission_tests.rs | 2 +- rs/moq-relay/src/auth/refresh.rs | 14 +- rs/moq-relay/src/cluster.rs | 40 +- rs/moq-relay/src/internal.rs | 19 +- rs/moq-relay/src/refusals.rs | 5 +- rs/moq-relay/src/stats.rs | 3 +- rs/moq-relay/src/web.rs | 15 +- rs/moq-relay/tests/drills.rs | 20 +- .../tests/integration/auth_lifetime.rs | 27 +- .../tests/integration/cluster_drain.rs | 11 +- .../tests/integration/cluster_idle.rs | 4 +- .../tests/integration/cluster_unknown.rs | 4 +- rs/moq-relay/tests/integration/connection.rs | 10 +- rs/moq-relay/tests/integration/embed.rs | 4 +- .../tests/integration/goaway_cluster.rs | 21 +- .../tests/integration/hidden_cluster.rs | 5 +- .../tests/integration/public_rules.rs | 4 +- rs/moq-relay/tests/integration/refusals.rs | 43 +- .../tests/integration/runtime_uring.rs | 16 +- .../tests/integration/runtime_workers.rs | 4 +- .../tests/integration/shutdown_signal.rs | 4 +- rs/moq-relay/tests/integration/smoke.rs | 39 +- .../tests/integration/upstream_links.rs | 13 +- rs/moq-room/src/chat.rs | 5 +- rs/moq-rtc/src/client/mod.rs | 4 +- rs/moq-rtc/src/egress.rs | 26 +- rs/moq-rtc/src/lib.rs | 22 +- rs/moq-rtc/src/server/whep.rs | 13 +- rs/moq-rtc/src/server/whip.rs | 27 +- rs/moq-rtmp/src/dial.rs | 51 +- rs/moq-rtmp/src/server.rs | 43 +- rs/moq-srt/src/ts.rs | 41 +- rs/moq-stats/benches/producer_tick.rs | 6 +- rs/moq-stats/src/aggregate.rs | 42 +- rs/moq-stats/src/consume.rs | 5 +- rs/moq-stats/src/lib.rs | 20 +- rs/moq-stats/src/produce.rs | 187 ++- rs/moq-tokio/examples/chat.rs | 4 +- rs/moq-tokio/src/client.rs | 4 +- rs/moq-tokio/src/origin.rs | 4 +- rs/moq-tokio/src/server.rs | 9 +- rs/moq-tokio/src/webrtc/tests.rs | 5 +- rs/moq-tokio/tests/integration/backend.rs | 42 +- rs/moq-tokio/tests/integration/broadcast.rs | 298 ++-- .../tests/integration/receive_credit.rs | 8 +- .../integration/subscription_end_integrity.rs | 4 +- rs/moq-tokio/tests/integration/unannounce.rs | 10 +- rs/moq-uring/benches/session_lite.rs | 9 +- .../tests/integration/receive_credit.rs | 26 +- rs/moq-uring/tests/integration/session.rs | 20 +- rs/moq-uring/tests/integration/web.rs | 11 +- rs/moq-video/src/decode/decoder.rs | 6 +- rs/moq-wasm/src/lib.rs | 5 +- test/interop/clients/rust/audio.rs | 4 +- test/interop/clients/rust/finish.rs | 4 +- test/interop/clients/rust/goaway-client.rs | 12 +- 192 files changed, 4191 insertions(+), 1275 deletions(-) diff --git a/js/moq-boy/src/game.ts b/js/moq-boy/src/game.ts index e89719915e9..256e4538d33 100644 --- a/js/moq-boy/src/game.ts +++ b/js/moq-boy/src/game.ts @@ -317,9 +317,7 @@ export class Game { const viewerId = Math.random().toString(36).slice(2, 8); this.viewerId.set(viewerId); - const viewerBroadcast = origin.createBroadcast( - Moq.Path.from(this.#viewerPrefix, this.sessionId, viewerId), - ); + const viewerBroadcast = origin.createBroadcast(Moq.Path.from(this.#viewerPrefix, this.sessionId, viewerId)); viewerBroadcast.announce({ epoch: Moq.Epoch.mint() }); effect.cleanup(() => { viewerBroadcast.close(); diff --git a/js/net/MIGRATE.md b/js/net/MIGRATE.md index ecec42d1b63..c934ce1fba4 100644 --- a/js/net/MIGRATE.md +++ b/js/net/MIGRATE.md @@ -7,7 +7,7 @@ How to update your code for each breaking change, newest first. ### `Path.from` refuses empty segments (#6648) `Path.from` throws on a component with a leading, trailing, or doubled `/` instead of collapsing it, so a path has one spelling, and `Path.decode` refuses one off the wire. -Pass canonical components: `Path.from("room/cam")` or `Path.from(prefix, "cam")`, where an empty component is the root, rather than `` Path.from(`${prefix}/cam`) `` or `Path.from("room/")`. +Pass canonical components: `Path.from("room/cam")` or `Path.from(prefix, "cam")`, where an empty component is the root, rather than ``Path.from(`${prefix}/cam`)`` or `Path.from("room/")`. ### Published names refuse navigation segments diff --git a/rs/hang/examples/video.rs b/rs/hang/examples/video.rs index de9094ee922..701a7f41572 100644 --- a/rs/hang/examples/video.rs +++ b/rs/hang/examples/video.rs @@ -82,7 +82,9 @@ fn create_track(broadcast: &mut moq_net::broadcast::Producer) -> anyhow::Result< async fn run_broadcast(origin: moq_net::origin::Producer) -> anyhow::Result<()> { // Create a broadcast on the origin and announce its path. // NOTE: The path is empty because we're using the URL to scope the broadcast. - let mut broadcast = origin.create_broadcast(moq_net::Path::empty()).context("failed to create broadcast")?; + let mut broadcast = origin + .create_broadcast(moq_net::Path::empty()) + .context("failed to create broadcast")?; broadcast .announce(Default::default()) .context("failed to announce broadcast")?; diff --git a/rs/moq-audio/src/decode/consumer.rs b/rs/moq-audio/src/decode/consumer.rs index d4d0c76caae..ac869a27af8 100644 --- a/rs/moq-audio/src/decode/consumer.rs +++ b/rs/moq-audio/src/decode/consumer.rs @@ -833,7 +833,10 @@ mod tests { let _link = link(&publisher, &relay).await; let consumer = relay.consume(); consumer.routed(Path::new("bcast").unwrap()).await.unwrap(); - let remote = consumer.request_broadcast(Path::new("bcast").unwrap(), None).await.unwrap(); + let remote = consumer + .request_broadcast(Path::new("bcast").unwrap(), None) + .await + .unwrap(); // A first reader warms the relay's copy with every group. { diff --git a/rs/moq-bench/src/connection.rs b/rs/moq-bench/src/connection.rs index f673ad2029a..eeeb137b87c 100644 --- a/rs/moq-bench/src/connection.rs +++ b/rs/moq-bench/src/connection.rs @@ -985,15 +985,21 @@ mod tests { // Our own broadcast: in the namespace, but excluded via the `own` set // (paths relative to the namespace, matching the scoped announce consumer). - let _previous = origin.create_broadcast(Path::new("bench/previous/0/0").unwrap()).unwrap(); + let _previous = origin + .create_broadcast(Path::new("bench/previous/0/0").unwrap()) + .unwrap(); _previous.announce(Default::default()).unwrap(); - let _own = origin.create_broadcast(Path::new("bench/current/9/9").unwrap()).unwrap(); + let _own = origin + .create_broadcast(Path::new("bench/current/9/9").unwrap()) + .unwrap(); _own.announce(Default::default()).unwrap(); let own = HashSet::from(["9/9".to_string()]); // One legitimate peer under the bench namespace with a single finished group. - let peer = origin.create_broadcast(Path::new("bench/current/0/0").unwrap()).unwrap(); + let peer = origin + .create_broadcast(Path::new("bench/current/0/0").unwrap()) + .unwrap(); peer.announce(Default::default()).unwrap(); let track = peer.create_track(TRACK, timed()).unwrap(); let mut group = track.append_group().unwrap(); diff --git a/rs/moq-c/src/origin.rs b/rs/moq-c/src/origin.rs index 83bfcf42d1e..ee34db8697b 100644 --- a/rs/moq-c/src/origin.rs +++ b/rs/moq-c/src/origin.rs @@ -217,7 +217,12 @@ impl Origin { /// The callback fires a broadcast handle (> 0) for each instance serving the path, until a /// single terminal code (`0` on close, negative on error). Returns a task handle for /// cancellation via [`Self::consume_announced_close`]. - pub fn consume_announced(&mut self, origin: Id, path: moq_net::PathOwned, on_broadcast: OnStatus) -> Result { + pub fn consume_announced( + &mut self, + origin: Id, + path: moq_net::PathOwned, + on_broadcast: OnStatus, + ) -> Result { let origin = self.active.get(origin).ok_or(Error::OriginNotFound)?; origin.driver.check()?; let driver = origin.driver.clone(); @@ -457,7 +462,11 @@ mod supervision_tests { .unwrap(); let mut publish = crate::publish::Publish::default(); let broadcast = publish - .create(origins.create_broadcast(origin, Path::new("retained").unwrap()).unwrap()) + .create( + origins + .create_broadcast(origin, Path::new("retained").unwrap()) + .unwrap(), + ) .unwrap(); origins.close(origin).unwrap(); *trigger @@ -471,7 +480,11 @@ mod supervision_tests { )); let healthy = origins.create().unwrap(); let broadcast = publish - .create(origins.create_broadcast(healthy, Path::new("healthy").unwrap()).unwrap()) + .create( + origins + .create_broadcast(healthy, Path::new("healthy").unwrap()) + .unwrap(), + ) .unwrap(); publish.announce(broadcast, Default::default()).unwrap(); } diff --git a/rs/moq-c/src/publish.rs b/rs/moq-c/src/publish.rs index 651de9cd3f8..96c0494e299 100644 --- a/rs/moq-c/src/publish.rs +++ b/rs/moq-c/src/publish.rs @@ -1150,7 +1150,10 @@ mod supervision_tests { let (origin, completion, trigger) = crate::ffi::panicking_origin(); let mut publish = Publish::default(); let broadcast = publish - .create((origin.create_broadcast(Path::new("retained").unwrap()).unwrap(), completion.clone())) + .create(( + origin.create_broadcast(Path::new("retained").unwrap()).unwrap(), + completion.clone(), + )) .unwrap(); let container = publish .container( @@ -1174,7 +1177,10 @@ mod supervision_tests { let (origin, completion, trigger) = crate::ffi::panicking_origin(); let mut publish = Publish::default(); let broadcast = publish - .create((origin.create_broadcast(Path::new("retained").unwrap()).unwrap(), completion.clone())) + .create(( + origin.create_broadcast(Path::new("retained").unwrap()).unwrap(), + completion.clone(), + )) .unwrap(); let producer = &publish.broadcast(broadcast).unwrap().producer; // A dynamic handle outlives the consumed broadcast, so only an explicit close ends it. diff --git a/rs/moq-c/src/test.rs b/rs/moq-c/src/test.rs index e2db238f44f..4fc6b0153d1 100644 --- a/rs/moq-c/src/test.rs +++ b/rs/moq-c/src/test.rs @@ -3708,7 +3708,12 @@ fn consume_announced_close_cancels() { fn publish(origin: u32, path: &str, route: moq_net::origin::Route) -> moq_net::broadcast::Producer { let _runtime = crate::ffi::RUNTIME.enter(); let origin = crate::Id::try_from(origin).unwrap(); - State::lock().origin.get(origin).unwrap().publish(Path::new(path).unwrap(), route).unwrap() + State::lock() + .origin + .get(origin) + .unwrap() + .publish(Path::new(path).unwrap(), route) + .unwrap() } /// Publish `path` on `origin` under a fresh epoch, as each run of a publisher does. diff --git a/rs/moq-cli/src/announced.rs b/rs/moq-cli/src/announced.rs index f91a7b4481e..4f0c839af25 100644 --- a/rs/moq-cli/src/announced.rs +++ b/rs/moq-cli/src/announced.rs @@ -210,7 +210,9 @@ mod tests { let broadcasts = ["demo/a", "demo/b", "other/c"] .into_iter() .map(|path| { - let broadcast = origin.create_broadcast(moq_net::Path::new(path).unwrap()).expect("broadcast"); + let broadcast = origin + .create_broadcast(moq_net::Path::new(path).unwrap()) + .expect("broadcast"); broadcast.announce(Default::default()).expect("announce"); (path, broadcast) }) diff --git a/rs/moq-cli/src/archive.rs b/rs/moq-cli/src/archive.rs index fbb309d226a..b58ae7f67ee 100644 --- a/rs/moq-cli/src/archive.rs +++ b/rs/moq-cli/src/archive.rs @@ -250,7 +250,9 @@ pub async fn import( let store = open(&args.store)?; // A second handle lists the recording's timelines while the reader owns the first. let listing = open(&args.store)?; - let broadcast = origin.create_broadcast(moq_net::Path::new(&name)?).context("failed to create broadcast")?; + let broadcast = origin + .create_broadcast(moq_net::Path::new(&name)?) + .context("failed to create broadcast")?; let mut timelines = store .timelines() .await @@ -415,7 +417,10 @@ mod tests { assert!(running.start(&epochless)); assert!(!running.done(&epochless)); - let pinned = (moq_net::Path::new("live/b").unwrap().to_owned(), Some(moq_net::Epoch::mint())); + let pinned = ( + moq_net::Path::new("live/b").unwrap().to_owned(), + Some(moq_net::Epoch::mint()), + ); assert!(running.start(&pinned)); assert!(!running.start(&pinned)); assert!(running.done(&pinned)); @@ -474,7 +479,10 @@ mod tests { let hostile = format!("live/a/@{epoch}"); let nested = key( &Path::from("rec"), - &(moq_net::Path::new(&hostile).unwrap().to_owned(), Some(moq_net::Epoch::mint())), + &( + moq_net::Path::new(&hostile).unwrap().to_owned(), + Some(moq_net::Epoch::mint()), + ), ) .unwrap(); assert!(nested.prefix_match(&victim).is_none(), "{nested} is under {victim}"); diff --git a/rs/moq-cli/src/complete.rs b/rs/moq-cli/src/complete.rs index 39f1619f45c..06efaf9036e 100644 --- a/rs/moq-cli/src/complete.rs +++ b/rs/moq-cli/src/complete.rs @@ -428,7 +428,9 @@ mod tests { let _ = moq_tokio::crypto::install_default(); let origin = moq_tokio::origin::spawn(); - let _alpha = origin.create_broadcast(moq_tokio::moq_net::Path::new("alpha").unwrap()).expect("alpha"); + let _alpha = origin + .create_broadcast(moq_tokio::moq_net::Path::new("alpha").unwrap()) + .expect("alpha"); _alpha.announce(Default::default()).expect("alpha"); let mut config = moq_tokio::listen::Config::default(); diff --git a/rs/moq-cli/src/fetch.rs b/rs/moq-cli/src/fetch.rs index 4ce6d18e983..2c3b594862d 100644 --- a/rs/moq-cli/src/fetch.rs +++ b/rs/moq-cli/src/fetch.rs @@ -191,7 +191,9 @@ mod tests { impl Fixture { async fn new() -> Self { let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast(moq_net::Path::new("demo").unwrap()).expect("broadcast"); + let broadcast = origin + .create_broadcast(moq_net::Path::new("demo").unwrap()) + .expect("broadcast"); broadcast.announce(Default::default()).expect("announce"); let data = broadcast.create_track("data", timed()).expect("data track"); diff --git a/rs/moq-cli/src/hls.rs b/rs/moq-cli/src/hls.rs index 49a92dbbd14..3f7ff9e0ede 100644 --- a/rs/moq-cli/src/hls.rs +++ b/rs/moq-cli/src/hls.rs @@ -159,7 +159,9 @@ pub async fn import(target: ImportTarget, args: ImportArgs, epoch: moq_net::Epoc linger, bandwidth, } = target; - let mut producer = origin.create_broadcast(moq_net::Path::new(&name)?).context("failed to create broadcast")?; + let mut producer = origin + .create_broadcast(moq_net::Path::new(&name)?) + .context("failed to create broadcast")?; let config = moq_mux::catalog::Config::default() .with_max_age(max_age) @@ -434,7 +436,10 @@ mod test { let importing = tokio::spawn(import(target, args, moq_net::Epoch::mint())); announced.next().await.expect("announced"); - let broadcast = consumer.request_broadcast(moq_net::Path::new("hls").unwrap(), None).await.unwrap(); + let broadcast = consumer + .request_broadcast(moq_net::Path::new("hls").unwrap(), None) + .await + .unwrap(); let mut catalogs = hang::catalog::Catalog::<()>::subscribe(&broadcast).await.unwrap(); let catalog = catalogs.next().await.unwrap().expect("a catalog"); let name = catalog.audio.renditions.keys().next().expect("an audio rendition"); diff --git a/rs/moq-cli/src/main.rs b/rs/moq-cli/src/main.rs index f177b9bfbd0..5f613e706f4 100644 --- a/rs/moq-cli/src/main.rs +++ b/rs/moq-cli/src/main.rs @@ -747,7 +747,9 @@ fn spawn_import( let name = require_broadcast(name, "import ts --program all")?; Publish::ts_programs(origin.clone(), moq_net::PathOwned::try_from(name)?, config) } else { - let broadcast = origin.create_broadcast(moq_net::Path::new(&name)?).context("failed to create broadcast")?; + let broadcast = origin + .create_broadcast(moq_net::Path::new(&name)?) + .context("failed to create broadcast")?; Publish::new(broadcast, &format, config)? } .with_linger(linger); @@ -804,7 +806,9 @@ fn spawn_import( #[cfg(feature = "capture")] ImportSource::Capture(capture) => { warn_if_missing_format(&name); - let broadcast = origin.create_broadcast(moq_net::Path::new(&name)?).context("failed to create broadcast")?; + let broadcast = origin + .create_broadcast(moq_net::Path::new(&name)?) + .context("failed to create broadcast")?; let mut publish = Publish::capture(broadcast, &capture, bandwidth.clone(), max_age)?; publish.announce(epoch)?; local = Some(publish); @@ -1164,7 +1168,10 @@ mod tests { let listener = cli.moq.server_config().init_streams().unwrap().listen().await.unwrap(); let addr = listener.tcp_local_addr().unwrap(); let cluster = moq_relay::cluster::Cluster::new(Default::default()).unwrap(); - let broadcast = cluster.origin.create_broadcast(moq_net::Path::new("probe").unwrap()).unwrap(); + let broadcast = cluster + .origin + .create_broadcast(moq_net::Path::new("probe").unwrap()) + .unwrap(); broadcast.announce(Default::default()).unwrap(); let info = moq_net::track::Info::default().with_timescale(moq_net::Timescale::MILLI); let track = broadcast.create_track("status", info).unwrap(); @@ -1261,7 +1268,11 @@ mod tests { .unwrap(); // Media proves the CLI admitted the session, even on a transport that establishes early. let payload = tokio::time::timeout(TIMEOUT, async { - let broadcast = listening.consumer.routed_broadcast(moq_net::Path::new("probe").unwrap()).await.unwrap(); + let broadcast = listening + .consumer + .routed_broadcast(moq_net::Path::new("probe").unwrap()) + .await + .unwrap(); let mut track = broadcast .track("status") .unwrap() diff --git a/rs/moq-cli/src/play/media.rs b/rs/moq-cli/src/play/media.rs index 3f2c040332b..5a1d43021c9 100644 --- a/rs/moq-cli/src/play/media.rs +++ b/rs/moq-cli/src/play/media.rs @@ -1657,7 +1657,9 @@ mod tests { #[tokio::test(start_paused = true)] async fn a_refused_broadcast_ends_the_player() { let origin = moq_tokio::origin::spawn(); - let handler = origin.dynamic_route(moq_net::Path::empty(), Default::default()).unwrap(); + let handler = origin + .dynamic_route(moq_net::Path::empty(), Default::default()) + .unwrap(); let recorder = Recorder::default(); let player = tokio::spawn(media(&origin, Duration::from_millis(50), recorder.clone()).run()); let request = handler.requested_broadcast().await.unwrap(); diff --git a/rs/moq-cli/src/publish.rs b/rs/moq-cli/src/publish.rs index 0b5ed8ef101..0f38918650e 100644 --- a/rs/moq-cli/src/publish.rs +++ b/rs/moq-cli/src/publish.rs @@ -432,7 +432,11 @@ impl Publish { /// The programs aren't known until the PAT arrives, so each broadcast is created then and /// announced once its catalog has named a servable track, and [`announce`](Self::announce) has /// nothing to do. - pub fn ts_programs(origin: moq_net::origin::Producer, name: moq_net::PathOwned, config: moq_mux::catalog::Config) -> Self { + pub fn ts_programs( + origin: moq_net::origin::Producer, + name: moq_net::PathOwned, + config: moq_mux::catalog::Config, + ) -> Self { Self { source: Source::Stream { decoder: PublishDecoder::TsPrograms(Box::new(ts::Programs::new(origin, name, config))), @@ -1041,7 +1045,10 @@ pub(crate) mod tests { /// A source for the broadcast at `path`, resolved through `origin`. async fn resolved(origin: &moq_net::origin::Producer, path: &str) -> moq_mux::Source { let consumer = origin.consume(); - let broadcast = consumer.request_broadcast(moq_net::Path::new(path).unwrap(), None).await.unwrap(); + let broadcast = consumer + .request_broadcast(moq_net::Path::new(path).unwrap(), None) + .await + .unwrap(); moq_mux::Source::new(consumer, broadcast) } @@ -1304,10 +1311,15 @@ pub(crate) mod tests { // the lead holds; the jump is in the copy after it. const WAIT: Duration = Duration::from_secs(10); decoder.decode_chunk(&lead).unwrap(); - let consumer = tokio::time::timeout(WAIT, remote.consume().routed_broadcast(moq_net::Path::new("pt.hang").unwrap())) - .await - .unwrap() - .unwrap(); + let consumer = tokio::time::timeout( + WAIT, + remote + .consume() + .routed_broadcast(moq_net::Path::new("pt.hang").unwrap()), + ) + .await + .unwrap() + .unwrap(); let mut catalogs = hang::catalog::Catalog::<()>::subscribe(&consumer).await.unwrap(); let catalog = tokio::time::timeout(WAIT, catalogs.next()) .await diff --git a/rs/moq-cli/src/report.rs b/rs/moq-cli/src/report.rs index 3d136838463..eb2bfbc8b76 100644 --- a/rs/moq-cli/src/report.rs +++ b/rs/moq-cli/src/report.rs @@ -648,7 +648,9 @@ mod tests { #[tokio::test(start_paused = true)] async fn an_ended_feedback_reader_stops_after_draining() { let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast(moq_net::Path::new("viewer.echo").unwrap()).unwrap(); + let broadcast = origin + .create_broadcast(moq_net::Path::new("viewer.echo").unwrap()) + .unwrap(); let track = broadcast.create_track(hang::echo::TRACK, None).unwrap(); let mut feedback = moq_json::snapshot::Producer::::new(track, Default::default()); broadcast.announce(Default::default()).unwrap(); @@ -692,7 +694,9 @@ mod tests { #[tokio::test(start_paused = true)] async fn a_hidden_prefix_finds_its_feedback() { let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast(moq_net::Path::new(".viewers/alice.echo").unwrap()).unwrap(); + let broadcast = origin + .create_broadcast(moq_net::Path::new(".viewers/alice.echo").unwrap()) + .unwrap(); let track = broadcast.create_track(hang::echo::TRACK, None).unwrap(); let mut feedback = moq_json::snapshot::Producer::::new(track, Default::default()); broadcast.announce(Default::default()).unwrap(); diff --git a/rs/moq-cli/src/srt.rs b/rs/moq-cli/src/srt.rs index 468912e1349..1f784561225 100644 --- a/rs/moq-cli/src/srt.rs +++ b/rs/moq-cli/src/srt.rs @@ -102,7 +102,7 @@ pub async fn listen_import( linger, bandwidth, } = target; -let name = moq_net::PathOwned::try_from(name)?; + let name = moq_net::PathOwned::try_from(name)?; let mut server = Server::bind(addr, latency).await?; tracing::info!(%addr, %name, "SRT listening (import)"); notify_ready(); diff --git a/rs/moq-cli/src/transcode.rs b/rs/moq-cli/src/transcode.rs index ff66b2d4f05..a7d19f1810e 100644 --- a/rs/moq-cli/src/transcode.rs +++ b/rs/moq-cli/src/transcode.rs @@ -227,7 +227,8 @@ mod tests { }; let old = origin.publish(moq_net::Path::new("source").unwrap(), route()).unwrap(); let _old_dynamic = old.dynamic(); - let mut derivatives = moq_mux::follow::Instances::new(&publish.consume(), moq_net::Path::new("derived").unwrap(), None).unwrap(); + let mut derivatives = + moq_mux::follow::Instances::new(&publish.consume(), moq_net::Path::new("derived").unwrap(), None).unwrap(); let following = Following { origin: origin.consume(), publish: publish.clone(), @@ -274,7 +275,8 @@ mod tests { let route = || moq_net::origin::Route::default().with_epoch(moq_net::Epoch::mint()); let mut old = origin.publish(moq_net::Path::new("source").unwrap(), route()).unwrap(); let mut catalog = moq_mux::catalog::Producer::new(&mut old, Default::default()).unwrap(); - let mut derivatives = moq_mux::follow::Instances::new(&publish.consume(), moq_net::Path::new("derived").unwrap(), None).unwrap(); + let mut derivatives = + moq_mux::follow::Instances::new(&publish.consume(), moq_net::Path::new("derived").unwrap(), None).unwrap(); let following = Following { origin: origin.consume(), publish: publish.clone(), diff --git a/rs/moq-cli/tests/integration/epochs.rs b/rs/moq-cli/tests/integration/epochs.rs index d8a0f4da8c5..ac0ef64e3f9 100644 --- a/rs/moq-cli/tests/integration/epochs.rs +++ b/rs/moq-cli/tests/integration/epochs.rs @@ -83,7 +83,9 @@ struct Published { fn publish(origin: &origin::Producer, epoch: &Epoch, tag: &str) -> Published { let route = origin::Route::default().with_epoch(epoch.clone()); - let mut broadcast = origin.publish(Path::new("live/catalog.hang").unwrap(), route.clone()).unwrap(); + let mut broadcast = origin + .publish(Path::new("live/catalog.hang").unwrap(), route.clone()) + .unwrap(); let sibling = origin.publish(Path::new("live/media").unwrap(), route).unwrap(); let media = sibling .create_track( @@ -159,7 +161,10 @@ async fn replacement(version: &str) { assert!(matches!(catalog_follow.next().await, Some(announce::Event::Start(_)))); assert!(matches!(media_follow.next().await, Some(announce::Event::Start(_)))); - let held = viewer.request_broadcast(Path::new("live/catalog.hang").unwrap(), None).await.unwrap(); + let held = viewer + .request_broadcast(Path::new("live/catalog.hang").unwrap(), None) + .await + .unwrap(); let old = moq_mux::Source::new(viewer.clone(), held); let mut catalog = old.catalog::<()>(moq_mux::catalog::CatalogFormat::Hang).await.unwrap(); let snapshot = catalog.next().await.unwrap().unwrap(); @@ -255,7 +260,10 @@ async fn replacement(version: &str) { // Fresh catalog handles start fresh pins instead of sharing the old Source's cache. let fresh = moq_mux::Source::new( viewer.clone(), - viewer.request_broadcast(Path::new("live/catalog.hang").unwrap(), None).await.unwrap(), + viewer + .request_broadcast(Path::new("live/catalog.hang").unwrap(), None) + .await + .unwrap(), ); let mut fresh_catalog = fresh .catalog::<()>(moq_mux::catalog::CatalogFormat::Hang) @@ -283,7 +291,10 @@ async fn replacement(version: &str) { changed(&mut media_follow).await; }) .await; - let returned = viewer.request_broadcast(Path::new("live/media").unwrap(), None).await.unwrap(); + let returned = viewer + .request_broadcast(Path::new("live/media").unwrap(), None) + .await + .unwrap(); let mut returned = returned.track("audio").unwrap().subscribe(None).await.unwrap(); write(&first.media, "A:3"); let returned_frame = read(&mut returned).await; diff --git a/rs/moq-cli/tests/integration/export.rs b/rs/moq-cli/tests/integration/export.rs index 52e109f2a8c..740c8edd941 100644 --- a/rs/moq-cli/tests/integration/export.rs +++ b/rs/moq-cli/tests/integration/export.rs @@ -558,7 +558,11 @@ async fn the_same_instance_within_the_follow_continues() { } export.output_past(0).await; assert!(split < LONG.len(), "the capture has a tail after the export joined"); - let old = relay.origin.request_broadcast(Path::new("demo").unwrap(), None).await.unwrap(); + let old = relay + .origin + .request_broadcast(Path::new("demo").unwrap(), None) + .await + .unwrap(); assert_eq!(old.info().epoch.as_ref(), Some(&epoch)); let clock = catalog.snapshot().clock; connection.abort(moq_net::Error::Cancel); diff --git a/rs/moq-cli/tests/integration/import.rs b/rs/moq-cli/tests/integration/import.rs index b86ae1ba5e4..e9f5d624971 100644 --- a/rs/moq-cli/tests/integration/import.rs +++ b/rs/moq-cli/tests/integration/import.rs @@ -93,9 +93,13 @@ async fn import_delivers_the_catalog_finish_at_eof() { panic!("the first announce event is {event:?}, not a start"); }; assert_eq!(announce.prefix.as_str(), "demo"); - let broadcast = running(&mut child, "the broadcast", consumer.request_broadcast(Path::new("demo").unwrap(), None)) - .await - .expect("announced broadcast resolves"); + let broadcast = running( + &mut child, + "the broadcast", + consumer.request_broadcast(Path::new("demo").unwrap(), None), + ) + .await + .expect("announced broadcast resolves"); let mut catalogs = hang::catalog::Catalog::<()>::subscribe(&broadcast) .await .expect("subscribe to the catalog"); @@ -168,9 +172,13 @@ async fn a_short_import_drains_its_media_to_a_waiting_subscriber() { running(&mut child, "the announce", announced.next()) .await .expect("origin closed"); - let broadcast = running(&mut child, "the broadcast", consumer.request_broadcast(Path::new("demo").unwrap(), None)) - .await - .expect("announced broadcast resolves"); + let broadcast = running( + &mut child, + "the broadcast", + consumer.request_broadcast(Path::new("demo").unwrap(), None), + ) + .await + .expect("announced broadcast resolves"); let mut catalogs = running( &mut child, "the catalog subscription", diff --git a/rs/moq-cli/tests/integration/report.rs b/rs/moq-cli/tests/integration/report.rs index cbb1e8876b7..690cc1c70c7 100644 --- a/rs/moq-cli/tests/integration/report.rs +++ b/rs/moq-cli/tests/integration/report.rs @@ -389,7 +389,10 @@ async fn export_echo_reports_what_the_export_reads() { let (expected, _) = written(CLIP); // A publisher soliciting feedback under `viewers`, a sibling of its broadcast. - let mut broadcast = relay.origin.create_broadcast(Path::new("demo").unwrap()).expect("create the broadcast"); + let mut broadcast = relay + .origin + .create_broadcast(Path::new("demo").unwrap()) + .expect("create the broadcast"); let config = moq_mux::catalog::Config::default() .with_max_age(Some(Duration::from_secs(1))) .with_catalog(moq_mux::catalog::hang::Catalog::::default()); diff --git a/rs/moq-cli/tests/integration/rtsp.rs b/rs/moq-cli/tests/integration/rtsp.rs index 5d9981266a4..24a71e72432 100644 --- a/rs/moq-cli/tests/integration/rtsp.rs +++ b/rs/moq-cli/tests/integration/rtsp.rs @@ -68,9 +68,13 @@ async fn next_broadcast( moq_net::announce::Event::End(_) | moq_net::announce::Event::Update(_) => {} } } - let broadcast = running(child, "the broadcast", consumer.request_broadcast(Path::new("camera").unwrap(), None)) - .await - .expect("announced broadcast resolves"); + let broadcast = running( + child, + "the broadcast", + consumer.request_broadcast(Path::new("camera").unwrap(), None), + ) + .await + .expect("announced broadcast resolves"); let mut catalogs = running( child, "the catalog", diff --git a/rs/moq-ffi/src/test.rs b/rs/moq-ffi/src/test.rs index 40ec4e97c65..ec52281b8b8 100644 --- a/rs/moq-ffi/src/test.rs +++ b/rs/moq-ffi/src/test.rs @@ -1,4 +1,3 @@ -use moq_net::Path; use super::origin::*; use super::producer::*; use super::server::{MoqServer, MoqServerConfig, MoqServerTls}; @@ -20,6 +19,7 @@ use crate::session::{ MoqBackoff, MoqCongestionControl, MoqConnectionPhase, MoqQuicConfig, MoqWebSocketConfig, moq_client_defaults, moq_qlog_supported, moq_versions, }; +use moq_net::Path; use std::future::Future; use std::sync::Arc; diff --git a/rs/moq-gst/src/sink/session.rs b/rs/moq-gst/src/sink/session.rs index 4a21278f4e2..3ae43b81939 100644 --- a/rs/moq-gst/src/sink/session.rs +++ b/rs/moq-gst/src/sink/session.rs @@ -278,7 +278,10 @@ impl Session { // lingers, rather than resuming viewers into the old run's group sequence. Reconnects keep it. let epoch = moq_net::Epoch::mint(); gst::info!(CAT, "publishing {} under epoch {epoch}", settings.broadcast); - let mut broadcast = origin.publish(&moq_net::Path::new(&settings.broadcast)?, moq_net::origin::Route::default().with_epoch(epoch))?; + let mut broadcast = origin.publish( + &moq_net::Path::new(&settings.broadcast)?, + moq_net::origin::Route::default().with_epoch(epoch), + )?; let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default())?; let status = Arc::new(Status::default()); diff --git a/rs/moq-gst/src/source/imp.rs b/rs/moq-gst/src/source/imp.rs index 89104882729..1a8569f1b51 100644 --- a/rs/moq-gst/src/source/imp.rs +++ b/rs/moq-gst/src/source/imp.rs @@ -3073,7 +3073,10 @@ mod session_tests { /// The `cam` broadcast a rendition of `room` references as `./cam`, under `route`. fn sibling(origin: &moq_net::origin::Producer, route: moq_net::origin::Route) -> Self { - let publisher = Self::build(origin.create_broadcast(Path::new("cam").unwrap()).unwrap(), video_rendition()); + let publisher = Self::build( + origin.create_broadcast(Path::new("cam").unwrap()).unwrap(), + video_rendition(), + ); publisher.broadcast.announce(route).unwrap(); publisher } diff --git a/rs/moq-hls/src/export/mod.rs b/rs/moq-hls/src/export/mod.rs index 73e19277e23..ba43c43d488 100644 --- a/rs/moq-hls/src/export/mod.rs +++ b/rs/moq-hls/src/export/mod.rs @@ -770,7 +770,9 @@ mod tests { #[tokio::test] async fn escaping_broadcast_reference_is_not_advertised() { let origin = produce_origin(); - let _broadcast = origin.create_broadcast(Path::new("a/pub").unwrap()).expect("publish allowed"); + let _broadcast = origin + .create_broadcast(Path::new("a/pub").unwrap()) + .expect("publish allowed"); _broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let upstream = crate::resolved(&origin, "a/pub").await; @@ -876,7 +878,9 @@ mod tests { #[tokio::test] async fn estimate_only_catalog_update_keeps_the_rendition() { let origin = produce_origin(); - let _broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let _broadcast = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); _broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let upstream = empty_upstream(&origin, "live").await; @@ -945,7 +949,9 @@ mod tests { #[tokio::test] async fn estimated_framerate_keeps_the_rendition() { let origin = produce_origin(); - let _broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let _broadcast = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); _broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let upstream = empty_upstream(&origin, "live").await; @@ -998,7 +1004,9 @@ mod tests { #[tokio::test] async fn estimate_before_first_init_reaches_aac_descriptor() { let origin = produce_origin(); - let _broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let _broadcast = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); _broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let upstream = empty_upstream(&origin, "live").await; @@ -1030,7 +1038,9 @@ mod tests { #[tokio::test] async fn decoder_config_change_rebuilds_the_rendition() { let origin = produce_origin(); - let _broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let _broadcast = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); _broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let upstream = empty_upstream(&origin, "live").await; @@ -1082,7 +1092,9 @@ mod tests { #[tokio::test] async fn master_lists_only_playable_renditions() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let mut broadcast = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); @@ -1144,7 +1156,9 @@ mod tests { #[tokio::test(start_paused = true)] async fn a_disabled_rendition_leaves_the_master_and_keeps_its_playlist() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let mut broadcast = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); @@ -1734,7 +1748,9 @@ mod tests { #[tokio::test(start_paused = true)] async fn a_transmuxed_segment_keeps_its_init_with_an_unfinished_tail() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let mut broadcast = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); let (mut catalog, mut registration, _media) = publish_vp8(&mut broadcast); registration .set(hang::catalog::VideoConfig::new(hang::catalog::VideoCodec::VP8)) @@ -1765,7 +1781,9 @@ mod tests { #[tokio::test(start_paused = true)] async fn a_blocked_init_bootstrap_does_not_hide_a_cached_init() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let mut broadcast = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); let (mut catalog, mut registration, _media) = publish_vp8(&mut broadcast); registration .set(hang::catalog::VideoConfig::new(hang::catalog::VideoCodec::VP8)) @@ -1802,7 +1820,9 @@ mod tests { #[tokio::test] async fn a_reconfigure_versions_the_init_url() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let mut broadcast = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let (_catalog, mut registration, _media) = publish_vp8(&mut broadcast); @@ -1847,7 +1867,9 @@ mod tests { #[tokio::test] async fn a_generation_versions_segment_urls_and_a_new_one_resets_the_window() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let mut broadcast = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let (_catalog, _registration, mut media) = publish_vp8(&mut broadcast); @@ -1904,7 +1926,9 @@ mod tests { #[tokio::test] async fn a_new_generation_rebuilds_an_inline_init() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let mut broadcast = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); @@ -1955,7 +1979,9 @@ mod tests { #[tokio::test] async fn serves_playlist_and_segments_from_the_timeline() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let mut broadcast = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); @@ -2043,7 +2069,9 @@ mod tests { #[tokio::test] async fn a_duration_marker_times_the_hls_trailing_sample() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let mut broadcast = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); @@ -2087,7 +2115,9 @@ mod tests { #[tokio::test] async fn serves_dash_manifest_and_time_addressed_segments() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let mut broadcast = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); @@ -2193,7 +2223,9 @@ mod tests { #[tokio::test] async fn root_clock_times_playlists_and_manifest() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let mut broadcast = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; @@ -2253,7 +2285,9 @@ mod tests { #[tokio::test] async fn manifest_falls_back_to_arrival_anchor_without_a_clock() { let origin = produce_origin(); - let broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let broadcast = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; @@ -2330,7 +2364,9 @@ mod tests { } let origin = produce_origin(); - let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let mut broadcast = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); @@ -2520,7 +2556,9 @@ mod tests { #[tokio::test] async fn dash_manifest_turns_static_when_finished() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let mut broadcast = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let mut catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); @@ -2582,7 +2620,9 @@ mod tests { #[tokio::test] async fn renditions_snap_to_their_own_keyframes() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let mut broadcast = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); @@ -2671,7 +2711,9 @@ mod tests { #[tokio::test] async fn an_audio_only_broadcast_segments_on_its_audio() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let mut broadcast = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); @@ -2723,7 +2765,9 @@ mod tests { #[tokio::test] async fn target_duration_follows_the_observed_segments() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let mut broadcast = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); @@ -2763,7 +2807,9 @@ mod tests { #[tokio::test] async fn audio_and_video_segments_are_aligned() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let mut broadcast = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); @@ -2856,7 +2902,9 @@ mod tests { #[tokio::test] async fn dropping_the_broadcaster_keeps_a_cursor_drainable() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let mut broadcast = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let mut catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); @@ -3096,7 +3144,9 @@ mod tests { origin: &moq_net::origin::Producer, payload: &'static [u8], ) -> (Box, hang::catalog::VideoConfig) { - let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let mut broadcast = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); @@ -3193,7 +3243,9 @@ mod tests { payload: &'static [u8], recorder: Option, ) -> Box { - let broadcast = origin.create_broadcast(Path::new("media").unwrap()).expect("publish allowed"); + let broadcast = origin + .create_broadcast(Path::new("media").unwrap()) + .expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); let track = broadcast.create_track("video0", timed()).unwrap(); @@ -3214,7 +3266,9 @@ mod tests { let origin = produce_origin(); // The catalog broadcast carries the catalog and the timeline; the media lives next door. - let mut live = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let mut live = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); live.announce(Default::default()).expect("publish allowed"); let catalog = moq_mux::catalog::Producer::new(&mut live, moq_mux::catalog::Config::default()).unwrap(); let recorder = catalog.enroll_test("video0").unwrap(); @@ -3344,14 +3398,18 @@ mod tests { const NEW: &[u8] = b"NEWNEWNEWNEWNEWN"; let origin = produce_origin(); - let mut live = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let mut live = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); live.announce(Default::default()).expect("publish allowed"); let catalog = moq_mux::catalog::Producer::new(&mut live, moq_mux::catalog::Config::default()).unwrap(); let recorder = catalog.enroll_test("video0").unwrap(); let mut old_media = moq_net::broadcast::Info::new().produce(); let _old_track = write_routed_media(&mut old_media, OLD, recorder, 0); - let old_server = origin.dynamic_route(Path::new("media").unwrap(), sibling_route(10)).unwrap(); + let old_server = origin + .dynamic_route(Path::new("media").unwrap(), sibling_route(10)) + .unwrap(); settle().await; let upstream = crate::resolved(&origin, "live").await; @@ -3396,7 +3454,9 @@ mod tests { } // A publisher serving the path afterwards, with rows recorded for it, is never bound. - let new_server = origin.dynamic_route(Path::new("media").unwrap(), sibling_route(11)).unwrap(); + let new_server = origin + .dynamic_route(Path::new("media").unwrap(), sibling_route(11)) + .unwrap(); let _ = rendition.snapshot(); assert!( tokio::time::timeout(Duration::from_secs(1), new_server.requested_broadcast()) @@ -3425,14 +3485,18 @@ mod tests { const KEYFRAME: &[u8] = &[0x10, 0x00, 0x00, 0x9d, 0x01, 0x2a, 0x40, 0x01, 0xf0, 0x00]; let origin = produce_origin(); - let mut live = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let mut live = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); live.announce(Default::default()).expect("publish allowed"); let catalog = moq_mux::catalog::Producer::new(&mut live, moq_mux::catalog::Config::default()).unwrap(); let recorder = catalog.enroll_test("video0").unwrap(); let mut media = moq_net::broadcast::Info::new().produce(); let _track = write_routed_media(&mut media, KEYFRAME, recorder, 0); - let server = origin.dynamic_route(Path::new("media").unwrap(), sibling_route(10)).unwrap(); + let server = origin + .dynamic_route(Path::new("media").unwrap(), sibling_route(10)) + .unwrap(); settle().await; let upstream = crate::resolved(&origin, "live").await; @@ -3482,14 +3546,18 @@ mod tests { const NEW: &[u8] = b"NEWNEWNEWNEWNEWN"; let origin = produce_origin(); - let mut live = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let mut live = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); live.announce(Default::default()).expect("publish allowed"); let catalog = moq_mux::catalog::Producer::new(&mut live, moq_mux::catalog::Config::default()).unwrap(); let recorder = catalog.enroll_test("video0").unwrap(); let mut media = moq_net::broadcast::Info::new().produce(); let _track = write_routed_media(&mut media, NEW, recorder, 0); - let server = origin.dynamic_route(Path::new("media").unwrap(), sibling_route(11)).unwrap(); + let server = origin + .dynamic_route(Path::new("media").unwrap(), sibling_route(11)) + .unwrap(); settle().await; let upstream = crate::resolved(&origin, "live").await; @@ -3521,14 +3589,18 @@ mod tests { const NEW: &[u8] = b"NEWNEWNEWNEWNEWN"; let origin = produce_origin(); - let mut live = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let mut live = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); live.announce(Default::default()).expect("publish allowed"); let catalog = moq_mux::catalog::Producer::new(&mut live, moq_mux::catalog::Config::default()).unwrap(); let recorder = catalog.enroll_test("video0").unwrap(); let mut old_media = moq_net::broadcast::Info::new().produce(); let _old_track = write_routed_media(&mut old_media, OLD, recorder, 0); - let old_server = origin.dynamic_route(Path::new("media").unwrap(), sibling_route(10)).unwrap(); + let old_server = origin + .dynamic_route(Path::new("media").unwrap(), sibling_route(10)) + .unwrap(); settle().await; let upstream = crate::resolved(&origin, "live").await; @@ -3553,7 +3625,9 @@ mod tests { .expect("the old retained segment drains"); assert!(contains(&served, OLD)); - let new_server = origin.dynamic_route(Path::new("media").unwrap(), sibling_route(11)).unwrap(); + let new_server = origin + .dynamic_route(Path::new("media").unwrap(), sibling_route(11)) + .unwrap(); let mut new_media = moq_net::broadcast::Info::new().produce(); let recorder = catalog.enroll_test("video0").unwrap(); let _new_track = write_routed_media(&mut new_media, NEW, recorder, 6_000_000); @@ -3586,13 +3660,17 @@ mod tests { const OLD: &[u8] = b"OLDOLDOLDOLDOLDO"; let origin = produce_origin(); - let mut live = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let mut live = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); live.announce(Default::default()).expect("publish allowed"); let catalog = moq_mux::catalog::Producer::new(&mut live, moq_mux::catalog::Config::default()).unwrap(); let recorder = catalog.enroll_test("video0").unwrap(); let mut media = moq_net::broadcast::Info::new().produce(); let track = write_routed_media(&mut media, OLD, recorder, 0); - let server = origin.dynamic_route(Path::new("media").unwrap(), sibling_route(10)).unwrap(); + let server = origin + .dynamic_route(Path::new("media").unwrap(), sibling_route(10)) + .unwrap(); settle().await; let upstream = crate::resolved(&origin, "live").await; @@ -3635,7 +3713,9 @@ mod tests { const OLD: &[u8] = b"OLDOLDOLDOLDOLDO"; let origin = produce_origin(); - let mut live = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let mut live = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); live.announce(Default::default()).expect("publish allowed"); let catalog = moq_mux::catalog::Producer::new(&mut live, moq_mux::catalog::Config::default()).unwrap(); let recorder = catalog.enroll_test("video0").unwrap(); @@ -3652,7 +3732,9 @@ mod tests { .await .expect("the catalog's rows are listed before the sibling resolves"); - let server = origin.dynamic_route(Path::new("media").unwrap(), sibling_route(10)).unwrap(); + let server = origin + .dynamic_route(Path::new("media").unwrap(), sibling_route(10)) + .unwrap(); let _ = rendition.snapshot(); accept_sibling(&server, &media).await; let served = rendition @@ -3671,7 +3753,9 @@ mod tests { #[tokio::test] async fn removing_a_rendition_ends_its_segment_cursor() { let origin = produce_origin(); - let broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let broadcast = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let upstream = crate::resolved(&origin, "live").await; @@ -3704,7 +3788,9 @@ mod tests { #[tokio::test] async fn a_rendition_appears_once_its_timeline_is_advertised() { let origin = produce_origin(); - let broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let broadcast = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let upstream = crate::resolved(&origin, "live").await; @@ -3749,7 +3835,9 @@ mod tests { #[tokio::test] async fn dropping_the_broadcaster_releases_its_renditions() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let mut broadcast = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); @@ -3807,7 +3895,9 @@ mod tests { #[tokio::test] async fn record_cursors_yield_renditions_and_segments() { let origin = produce_origin(); - let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let mut broadcast = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); @@ -4417,7 +4507,9 @@ mod tests { const NEW: &[u8] = b"NEWNEWNEWNEWNEWN"; let origin = produce_origin(); - let mut broadcast = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let mut broadcast = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); broadcast.announce(Default::default()).expect("publish allowed"); settle().await; let catalog = moq_mux::catalog::Producer::new(&mut broadcast, moq_mux::catalog::Config::default()).unwrap(); diff --git a/rs/moq-hls/src/export/rendition.rs b/rs/moq-hls/src/export/rendition.rs index 4f76580ad8f..81567334fdd 100644 --- a/rs/moq-hls/src/export/rendition.rs +++ b/rs/moq-hls/src/export/rendition.rs @@ -1360,13 +1360,17 @@ mod tests { async fn pending_reads_preserve_a_later_authorization_refusal() { let origin = moq_tokio::origin::spawn(); let broadcast = origin.create_broadcast(Path::new("room/live").unwrap()).unwrap(); - let dynamic = origin.dynamic_route(Path::new("room/secret").unwrap(), Default::default()).unwrap(); + let dynamic = origin + .dynamic_route(Path::new("room/secret").unwrap(), Default::default()) + .unwrap(); let source = moq_mux::Source::new(origin.consume(), broadcast.consume()); let mut config = VideoConfig::new(hang::catalog::VideoCodec::VP8); config.broadcast = Some(moq_net::path::Relative::new("./secret").to_owned()); let rendition = Arc::new(Rendition::video("video".into(), &config, &source, Archive::default(), None).unwrap()); let request = dynamic.requested_broadcast().await.unwrap(); - let other = origin.dynamic_route(Path::new("room/hidden").unwrap(), Default::default()).unwrap(); + let other = origin + .dynamic_route(Path::new("room/hidden").unwrap(), Default::default()) + .unwrap(); config.broadcast = Some(moq_net::path::Relative::new("./hidden").to_owned()); let resolving = Arc::new(Rendition::video("video".into(), &config, &source, Archive::default(), None).unwrap()); let other_request = other.requested_broadcast().await.unwrap(); @@ -1524,7 +1528,9 @@ mod tests { #[test] fn a_gone_publisher_is_unservable_and_an_ietf_miss_is_not() { let origin = produce_origin(); - let producer = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let producer = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); let live = producer.consume(); let ietf_miss = over_ietf_miss(); assert!( diff --git a/rs/moq-hls/src/server/mod.rs b/rs/moq-hls/src/server/mod.rs index ccc595982ab..18579bda57c 100644 --- a/rs/moq-hls/src/server/mod.rs +++ b/rs/moq-hls/src/server/mod.rs @@ -422,7 +422,9 @@ mod tests { async fn closed_broadcaster() -> Arc { let origin = produce_origin(); - let producer = origin.create_broadcast(Path::new("gone").unwrap()).expect("publish allowed"); + let producer = origin + .create_broadcast(Path::new("gone").unwrap()) + .expect("publish allowed"); producer.announce(Default::default()).expect("publish allowed"); settle().await; let broadcaster = Broadcaster::new(crate::resolved(&origin, "gone").await, Config::default()); @@ -444,7 +446,9 @@ mod tests { .lock() .unwrap() .insert("live".to_string(), Arc::new(Followed::new(stale.clone()))); - let _producer = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let _producer = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); _producer.announce(Default::default()).expect("publish allowed"); settle().await; @@ -460,7 +464,9 @@ mod tests { #[tokio::test] async fn dropping_the_server_releases_its_broadcasters() { let origin = produce_origin(); - let producer = origin.create_broadcast(Path::new("live").unwrap()).expect("publish allowed"); + let producer = origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish allowed"); producer.announce(Default::default()).expect("publish allowed"); settle().await; @@ -504,12 +510,16 @@ mod tests { let (old_epoch, new_epoch) = (moq_net::Epoch::mint(), moq_net::Epoch::mint()); let route = |epoch: &moq_net::Epoch| moq_net::origin::Route::default().with_epoch(epoch.clone()); - let old = origin.publish(Path::new("live").unwrap(), route(&old_epoch)).expect("publish allowed"); + let old = origin + .publish(Path::new("live").unwrap(), route(&old_epoch)) + .expect("publish allowed"); settle().await; let first = server.broadcaster("live").await.expect("broadcast announced"); assert_eq!(first.instance().as_ref(), old_epoch.as_str()); - let new = origin.publish(Path::new("live").unwrap(), route(&new_epoch)).expect("publish allowed"); + let new = origin + .publish(Path::new("live").unwrap(), route(&new_epoch)) + .expect("publish allowed"); eventually(async || { let current = server.broadcaster("live").await.expect("broadcast announced"); current.instance().as_ref() == new_epoch.as_str() diff --git a/rs/moq-hls/src/server/routes.rs b/rs/moq-hls/src/server/routes.rs index 56f98f6217d..ccb1d0e2908 100644 --- a/rs/moq-hls/src/server/routes.rs +++ b/rs/moq-hls/src/server/routes.rs @@ -402,7 +402,10 @@ mod tests { #[tokio::test] async fn respond_serves_a_route_rewritten_into_scope() { let pair = lite_pair().await; - let mut broadcast = pair.pub_origin.create_broadcast(Path::new("live").unwrap()).expect("publish"); + let mut broadcast = pair + .pub_origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish"); broadcast.announce(Default::default()).expect("announce"); let (_catalog, _registration, _track, mut media) = publish_video(&mut broadcast, video_config(), timed()); write_three_gops(&mut media); @@ -446,7 +449,10 @@ mod tests { "moq-lite-05", ] { let pair = lite_pair_on(version, moq_net::Hop::random()).await; - let mut broadcast = pair.pub_origin.create_broadcast(Path::new("live").unwrap()).expect("publish"); + let mut broadcast = pair + .pub_origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish"); broadcast.announce(Default::default()).expect("announce"); // A hinted timeline is declared before any media, so the rendition is listed early. let hinted = moq_mux::timeline::Config::default().with_duration_hint(Duration::from_secs(2)); @@ -713,7 +719,10 @@ mod tests { config }) .await; - let mut broadcast = pair.pub_origin.create_broadcast(Path::new("live").unwrap()).expect("publish"); + let mut broadcast = pair + .pub_origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish"); broadcast.announce(Default::default()).expect("announce"); let (_catalog, _registration, _track, mut media) = publish_video(&mut broadcast, video_config(), timed()); write_three_gops(&mut media); @@ -738,7 +747,10 @@ mod tests { #[tokio::test] async fn a_disconnected_publisher_on_the_catalog_broadcast_answers_404() { let pair = lite_pair().await; - let mut broadcast = pair.pub_origin.create_broadcast(Path::new("live").unwrap()).expect("publish"); + let mut broadcast = pair + .pub_origin + .create_broadcast(Path::new("live").unwrap()) + .expect("publish"); broadcast.announce(Default::default()).expect("announce"); let (catalog, registration, track, mut media) = publish_video(&mut broadcast, video_config(), timed()); write_three_gops(&mut media); @@ -753,10 +765,15 @@ mod tests { ) .await; - let remote = tokio::time::timeout(TIMEOUT, pair.sub_origin.consume().request_broadcast(Path::new("live").unwrap(), None)) - .await - .expect("remote resolve timed out") - .expect("remote broadcast"); + let remote = tokio::time::timeout( + TIMEOUT, + pair.sub_origin + .consume() + .request_broadcast(Path::new("live").unwrap(), None), + ) + .await + .expect("remote resolve timed out") + .expect("remote broadcast"); drop((catalog, registration, track, media, broadcast)); tokio::time::timeout(TIMEOUT, remote.closed()) .await @@ -774,7 +791,10 @@ mod tests { #[tokio::test] async fn lookups_ride_the_servers_scope_watch() { let pair = lite_pair().await; - let other = pair.pub_origin.create_broadcast(Path::new("room/other").unwrap()).expect("other"); + let other = pair + .pub_origin + .create_broadcast(Path::new("room/other").unwrap()) + .expect("other"); other.announce(Default::default()).expect("announce other"); let server = Server::new(pair.sub_origin.consume(), crate::export::Config::default()); @@ -809,9 +829,15 @@ mod tests { "moq-lite-07-wip", ] { let pair = lite_pair_on(version, moq_net::origin::Config::default()).await; - let catalog = pair.pub_origin.create_broadcast(Path::new("room/live").unwrap()).expect("catalog"); + let catalog = pair + .pub_origin + .create_broadcast(Path::new("room/live").unwrap()) + .expect("catalog"); catalog.announce(Default::default()).expect("announce catalog"); - let media = pair.pub_origin.create_broadcast(Path::new("room/source").unwrap()).expect("media"); + let media = pair + .pub_origin + .create_broadcast(Path::new("room/source").unwrap()) + .expect("media"); media.announce(Default::default()).expect("announce media"); let origin = pair.sub_origin.consume(); @@ -955,11 +981,17 @@ mod tests { #[tokio::test] async fn a_disconnected_sibling_publisher_answers_404() { let pair = lite_pair().await; - let mut catalog_broadcast = pair.pub_origin.create_broadcast(Path::new("room/live").unwrap()).expect("catalog"); + let mut catalog_broadcast = pair + .pub_origin + .create_broadcast(Path::new("room/live").unwrap()) + .expect("catalog"); catalog_broadcast .announce(Default::default()) .expect("announce catalog"); - let media_broadcast = pair.pub_origin.create_broadcast(Path::new("room/source").unwrap()).expect("media"); + let media_broadcast = pair + .pub_origin + .create_broadcast(Path::new("room/source").unwrap()) + .expect("media"); media_broadcast.announce(Default::default()).expect("announce media"); let catalog = @@ -989,10 +1021,15 @@ mod tests { .await; // Waited on rather than requested once: a client only asks about what it watches. - let remote_media = tokio::time::timeout(TIMEOUT, pair.sub_origin.consume().routed_broadcast(Path::new("room/source").unwrap())) - .await - .expect("sibling resolve timed out") - .expect("sibling broadcast"); + let remote_media = tokio::time::timeout( + TIMEOUT, + pair.sub_origin + .consume() + .routed_broadcast(Path::new("room/source").unwrap()), + ) + .await + .expect("sibling resolve timed out") + .expect("sibling broadcast"); // Only the sibling goes: the catalog keeps listing the rendition, so the request // reaches the media fetch rather than missing the rendition. media_broadcast.close(); diff --git a/rs/moq-mux/benches/catalog.rs b/rs/moq-mux/benches/catalog.rs index 596414aea38..451bb23e5b6 100644 --- a/rs/moq-mux/benches/catalog.rs +++ b/rs/moq-mux/benches/catalog.rs @@ -112,7 +112,8 @@ impl Fanout { black_box(rendition.jitter); if let Some(reference) = &rendition.broadcast { assert!( - moq_net::Path::new("room/catalog").unwrap() + moq_net::Path::new("room/catalog") + .unwrap() .try_resolve(reference) .unwrap() .as_str() diff --git a/rs/moq-mux/benches/containers.rs b/rs/moq-mux/benches/containers.rs index 377069fce91..f593ca5b3c3 100644 --- a/rs/moq-mux/benches/containers.rs +++ b/rs/moq-mux/benches/containers.rs @@ -88,13 +88,19 @@ async fn prepare(video: Video, payload: &Bytes) -> (moq_mux::Source, impl Stream catalog.finish().unwrap(); let (origin, driver) = moq_net::origin::Producer::new(Default::default()); let driver = tokio::spawn(moq_net::time::run(driver)); - let dynamic = origin.dynamic_route(moq_net::Path::empty(), Default::default()).unwrap(); + let dynamic = origin + .dynamic_route(moq_net::Path::empty(), Default::default()) + .unwrap(); let requests = tokio::spawn(async move { while let Ok(request) = dynamic.requested_broadcast().await { request.accept(consumer.clone()); } }); - let resolved = origin.consume().request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); + let resolved = origin + .consume() + .request_broadcast(Path::new("bench").unwrap(), None) + .await + .unwrap(); let source = moq_mux::Source::new(origin.consume(), resolved); let stream = source.catalog::<()>(CatalogFormat::Hang).await.unwrap(); let fixture = Fixture { diff --git a/rs/moq-mux/benches/export.rs b/rs/moq-mux/benches/export.rs index 1e72d1faac7..10e4e7d59bf 100644 --- a/rs/moq-mux/benches/export.rs +++ b/rs/moq-mux/benches/export.rs @@ -59,13 +59,19 @@ async fn prepare(tracks: usize, frames: usize) -> (moq_mux::Source, moq_mux::cat catalog.finish().unwrap(); let (origin, driver) = moq_net::origin::Producer::new(Default::default()); let driver = tokio::spawn(moq_net::time::run(driver)); - let dynamic = origin.dynamic_route(moq_net::Path::empty(), Default::default()).unwrap(); + let dynamic = origin + .dynamic_route(moq_net::Path::empty(), Default::default()) + .unwrap(); let requests = tokio::spawn(async move { while let Ok(request) = dynamic.requested_broadcast().await { request.accept(consumer.clone()); } }); - let resolved = origin.consume().request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); + let resolved = origin + .consume() + .request_broadcast(Path::new("bench").unwrap(), None) + .await + .unwrap(); let source = moq_mux::Source::new(origin.consume(), resolved); let fixture = Fixture { _published: Box::new((broadcast, catalog, publishers)), @@ -223,13 +229,19 @@ async fn prepare_video( catalog.finish().unwrap(); let (origin, driver) = moq_net::origin::Producer::new(Default::default()); let driver = tokio::spawn(moq_net::time::run(driver)); - let dynamic = origin.dynamic_route(moq_net::Path::empty(), Default::default()).unwrap(); + let dynamic = origin + .dynamic_route(moq_net::Path::empty(), Default::default()) + .unwrap(); let requests = tokio::spawn(async move { while let Ok(request) = dynamic.requested_broadcast().await { request.accept(consumer.clone()); } }); - let resolved = origin.consume().request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); + let resolved = origin + .consume() + .request_broadcast(Path::new("bench").unwrap(), None) + .await + .unwrap(); let source = moq_mux::Source::new(origin.consume(), resolved); ( source, diff --git a/rs/moq-mux/benches/ts_programs.rs b/rs/moq-mux/benches/ts_programs.rs index e425fb51f18..23ee1f0717b 100644 --- a/rs/moq-mux/benches/ts_programs.rs +++ b/rs/moq-mux/benches/ts_programs.rs @@ -184,7 +184,11 @@ fn multiplex(programs: u16, undescribed: u16, bitrate: u64) -> Vec { /// A fresh importer, with the origin driver it needs kept alive but unpolled. fn setup() -> (moq_mux::container::ts::Programs, impl Sized) { let (origin, driver) = moq_net::origin::Producer::new(Default::default()); - let programs = moq_mux::container::ts::Programs::new(origin, Path::new("bench.hang").unwrap(), moq_mux::catalog::Config::default()); + let programs = moq_mux::container::ts::Programs::new( + origin, + Path::new("bench.hang").unwrap(), + moq_mux::catalog::Config::default(), + ); (programs, driver) } diff --git a/rs/moq-mux/src/catalog/hang/consumer.rs b/rs/moq-mux/src/catalog/hang/consumer.rs index bf2c595c5a5..5b838d5e366 100644 --- a/rs/moq-mux/src/catalog/hang/consumer.rs +++ b/rs/moq-mux/src/catalog/hang/consumer.rs @@ -131,7 +131,9 @@ mod test { /// resolves against. fn publish_catalog(published: Catalog<()>) -> Result> { let origin = crate::source::produce_origin(); - let broadcast = origin.create_broadcast(Path::new("a/pub").unwrap()).expect("broadcast should create"); + let broadcast = origin + .create_broadcast(Path::new("a/pub").unwrap()) + .expect("broadcast should create"); let track = broadcast .create_track(hang::Catalog::DEFAULT_NAME, hang::Catalog::default_track_info()) .expect("catalog track should create"); @@ -170,7 +172,9 @@ mod test { .expect("catalog track should create"); let origin = crate::source::produce_origin(); - let dynamic = origin.dynamic_route(Path::new("").unwrap(), Default::default()).unwrap(); + let dynamic = origin + .dynamic_route(Path::new("").unwrap(), Default::default()) + .unwrap(); let requesting = origin.consume().request_broadcast(Path::new("a/pub").unwrap(), None); let served = broadcast.consume(); // The handler hands its route back: dropping it would retract the route and end diff --git a/rs/moq-mux/src/container/consumer.rs b/rs/moq-mux/src/container/consumer.rs index bd950303fbe..29e3baa4b84 100644 --- a/rs/moq-mux/src/container/consumer.rs +++ b/rs/moq-mux/src/container/consumer.rs @@ -969,10 +969,10 @@ impl std::ops::Deref for GroupBuffer { #[cfg(test)] mod tests { - use moq_net::Path; use super::Container as ContainerTrait; use super::*; use crate::catalog::hang::Container; + use moq_net::Path; use std::time::Duration; use bytes::Bytes; diff --git a/rs/moq-mux/src/container/source.rs b/rs/moq-mux/src/container/source.rs index b8898750009..440cedc6b54 100644 --- a/rs/moq-mux/src/container/source.rs +++ b/rs/moq-mux/src/container/source.rs @@ -776,8 +776,8 @@ pub(crate) fn build_video_transform(config: &VideoConfig) -> Option(&origin, route()); std::ops::DerefMut::deref_mut(&mut catalog.modify().unwrap()); - let back = origin.consume().routed_broadcast(Path::new("live").unwrap()).await.unwrap(); + let back = origin + .consume() + .routed_broadcast(Path::new("live").unwrap()) + .await + .unwrap(); let stream = crate::catalog::Consumer::new(&back, Default::default()).await.unwrap(); let mut export = export.follow(back, stream).unwrap(); frames.extend(drain_frames(&mut export).await); @@ -8489,7 +8493,11 @@ async fn a_return_keeps_catalog_and_group_history() { crate::clock::fake_host_wall(wall + start.elapsed()); broadcast.announce(route).unwrap(); assert_eq!(catalog.snapshot().clock, clock, "a return must keep the catalog clock"); - let back = origin.consume().routed_broadcast(Path::new("live").unwrap()).await.unwrap(); + let back = origin + .consume() + .routed_broadcast(Path::new("live").unwrap()) + .await + .unwrap(); assert_eq!(back.info().epoch.as_ref(), Some(&epoch)); assert!(!back.is_clone(&old), "the withdrawn front is replaced"); let stream = crate::catalog::Consumer::new(&back, Default::default()).await.unwrap(); @@ -8537,7 +8545,11 @@ async fn a_switch_carries_through_an_instance_that_never_built_its_tables() { // Switched to an instance whose catalog lists nothing, so it never builds its tables... let (_bare, _bare_catalog) = publish_live::<()>(&origin, route()); - let bare = origin.consume().request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); + let bare = origin + .consume() + .request_broadcast(Path::new("live").unwrap(), None) + .await + .unwrap(); let stream = crate::catalog::Consumer::new(&bare, Default::default()).await.unwrap(); let mut export = export.follow(bare, stream).unwrap(); assert!( @@ -8548,7 +8560,11 @@ async fn a_switch_carries_through_an_instance_that_never_built_its_tables() { // ...and then to another. let (mut new, mut new_catalog) = publish_live::<()>(&origin, route()); let mut new_audio = aac_rendition(&mut new, &mut new_catalog, "b.aac"); - let replacement = origin.consume().request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); + let replacement = origin + .consume() + .request_broadcast(Path::new("live").unwrap(), None) + .await + .unwrap(); let stream = crate::catalog::Consumer::new(&replacement, Default::default()) .await .unwrap(); @@ -8599,7 +8615,11 @@ async fn another_instance_is_a_full_program_switch() { let (mut new, mut new_catalog) = publish_live::<()>(&origin, route()); let mut video = h264_rendition(&mut new, &mut new_catalog, "video.avc1"); let mut new_audio = aac_rendition(&mut new, &mut new_catalog, "b.aac"); - let replacement = origin.consume().request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); + let replacement = origin + .consume() + .request_broadcast(Path::new("live").unwrap(), None) + .await + .unwrap(); let stream = crate::catalog::Consumer::new(&replacement, Default::default()) .await .unwrap(); @@ -8685,7 +8705,11 @@ async fn a_switch_moving_the_pmt_advances_the_pat() { let before = drain_frames(&mut export).await; let (_new, mut new_catalog, mut new_track) = publish(0x200); - let replacement = origin.consume().request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); + let replacement = origin + .consume() + .request_broadcast(Path::new("live").unwrap(), None) + .await + .unwrap(); let stream = crate::catalog::Consumer::new(&replacement, Default::default()) .await .unwrap(); @@ -8743,7 +8767,11 @@ async fn export_stats_count_only_returned_output() { drop((broadcast, catalog, track)); let (mut broadcast, mut catalog) = publish_live::<()>(&origin, route()); let mut track = aac_rendition(&mut broadcast, &mut catalog, "a.aac"); - let back = origin.consume().routed_broadcast(Path::new("live").unwrap()).await.unwrap(); + let back = origin + .consume() + .routed_broadcast(Path::new("live").unwrap()) + .await + .unwrap(); let stream = crate::catalog::Consumer::new(&back, Default::default()).await.unwrap(); let mut export = export.follow(back, stream).unwrap(); for ms in (1_000..1_200).step_by(20) { @@ -9208,7 +9236,10 @@ async fn a_follower_awaits_a_return_catalog_until_it_fails() { ); let second = origin - .publish(Path::new("live").unwrap(), moq_net::origin::Route::default().with_epoch(epoch)) + .publish( + Path::new("live").unwrap(), + moq_net::origin::Route::default().with_epoch(epoch), + ) .unwrap(); let silent = second.create_track(hang::Catalog::DEFAULT_NAME, None).unwrap(); assert!( @@ -9244,7 +9275,10 @@ async fn a_follower_keeps_following_when_a_return_goes_before_it_resolves() { // Back, but its catalog request is never answered before it goes again. let second = origin - .publish(Path::new("live").unwrap(), moq_net::origin::Route::default().with_epoch(epoch)) + .publish( + Path::new("live").unwrap(), + moq_net::origin::Route::default().with_epoch(epoch), + ) .unwrap(); let unanswered = second.dynamic(); assert!( @@ -9266,7 +9300,10 @@ async fn a_follower_keeps_following_when_a_return_goes_before_it_resolves() { /// returned task is aborted, which ends the broadcast. fn publish_refusing(origin: &moq_net::origin::Producer, epoch: &moq_net::Epoch) -> tokio::task::JoinHandle<()> { let broadcast = origin - .publish(Path::new("live").unwrap(), moq_net::origin::Route::default().with_epoch(epoch.clone())) + .publish( + Path::new("live").unwrap(), + moq_net::origin::Route::default().with_epoch(epoch.clone()), + ) .unwrap(); let mut dynamic = broadcast.dynamic(); tokio::spawn(async move { @@ -9557,7 +9594,9 @@ async fn a_follower_takes_its_own_instance_winning_back_for_no_replacement() { let mut follower = super::Follower::new(open_export(source).await.unwrap()).unwrap(); // A more specific route takes the path for a while, then goes. - let exact = origin.publish(Path::new("pool/job").unwrap(), route(moq_net::Epoch::mint())).unwrap(); + let exact = origin + .publish(Path::new("pool/job").unwrap(), route(moq_net::Epoch::mint())) + .unwrap(); assert!( tokio::time::timeout(Duration::from_secs(1), follower.next()) .await @@ -9736,16 +9775,22 @@ async fn a_follower_continues_through_a_same_epoch_handoff_after_a_gap() { async fn a_follower_ignores_a_covering_prefix_while_the_exact_route_serves() { let origin = crate::source::produce_origin(); let route = |epoch| moq_net::origin::Route::default().with_epoch(epoch); - let mut exact = origin.publish(Path::new("pool/job").unwrap(), route(moq_net::Epoch::mint())).unwrap(); + let mut exact = origin + .publish(Path::new("pool/job").unwrap(), route(moq_net::Epoch::mint())) + .unwrap(); let catalog = crate::catalog::Producer::<()>::new(&mut exact, Default::default()).unwrap(); let source = crate::source::resolved(&origin, "pool/job").await; let mut follower = super::Follower::new(open_export(source).await.unwrap()).unwrap(); let quiet = Duration::from_secs(1); - let pool = origin.dynamic_route(Path::new("pool").unwrap(), route(moq_net::Epoch::mint())).unwrap(); + let pool = origin + .dynamic_route(Path::new("pool").unwrap(), route(moq_net::Epoch::mint())) + .unwrap(); assert!(tokio::time::timeout(quiet, follower.next()).await.is_err(), "a start"); drop(pool); - let pool = origin.dynamic_route(Path::new("pool").unwrap(), route(moq_net::Epoch::mint())).unwrap(); + let pool = origin + .dynamic_route(Path::new("pool").unwrap(), route(moq_net::Epoch::mint())) + .unwrap(); assert!(tokio::time::timeout(quiet, follower.next()).await.is_err(), "a restart"); drop(pool); assert!(tokio::time::timeout(quiet, follower.next()).await.is_err(), "an end"); @@ -10033,7 +10078,11 @@ async fn a_switch_reads_the_instance_it_followed() { for ms in (0..200).step_by(20) { write_aac(&mut followed_audio, ms); } - let broadcast = origin.consume().request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); + let broadcast = origin + .consume() + .request_broadcast(Path::new("live").unwrap(), None) + .await + .unwrap(); // Replaced again, ten seconds ahead, before the switched export requests its track. let (mut newer, mut newer_catalog) = publish_live::<()>(&origin, Default::default()); @@ -10734,7 +10783,11 @@ async fn a_track_renamed_on_its_pid_across_returns_retires_the_one_before() { for round in 1..=4 { tokio::time::sleep(Duration::from_secs(1)).await; let (mut broadcast, mut catalog) = publish_live::(&origin, route()); - let back = origin.consume().routed_broadcast(Path::new("live").unwrap()).await.unwrap(); + let back = origin + .consume() + .routed_broadcast(Path::new("live").unwrap()) + .await + .unwrap(); let stream = crate::catalog::Consumer::new(&back, Default::default()).await.unwrap(); export = export.follow(back, stream).unwrap(); drain_frames(&mut export).await; @@ -10790,7 +10843,11 @@ async fn a_track_renamed_on_its_pid_across_a_return_is_quiet_from_its_listing() tokio::time::sleep(Duration::from_secs(10)).await; let (mut broadcast, mut catalog) = publish_live::(&origin, route()); - let back = origin.consume().routed_broadcast(Path::new("live").unwrap()).await.unwrap(); + let back = origin + .consume() + .routed_broadcast(Path::new("live").unwrap()) + .await + .unwrap(); let stream = crate::catalog::Consumer::new(&back, Default::default()).await.unwrap(); let mut export = export.follow(back, stream).unwrap(); drain_frames(&mut export).await; @@ -10843,7 +10900,11 @@ async fn a_switch_follows_the_last_pmt_out() { let (mut new, mut new_catalog) = publish_live::(&origin, route()); let mut audio = aac_rendition(&mut new, &mut new_catalog, "b.aac"); - let replacement = origin.consume().request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); + let replacement = origin + .consume() + .request_broadcast(Path::new("live").unwrap(), None) + .await + .unwrap(); let stream = crate::catalog::Consumer::new(&replacement, Default::default()) .await .unwrap(); @@ -10871,7 +10932,11 @@ async fn a_switch_past_an_instance_that_laid_no_tables_follows_the_last_pmt_out( let origin = crate::source::produce_origin(); let route = || moq_net::origin::Route::default().with_epoch(moq_net::Epoch::mint()); let follow = async |export: Export<_>| { - let replacement = origin.consume().request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); + let replacement = origin + .consume() + .request_broadcast(Path::new("live").unwrap(), None) + .await + .unwrap(); let stream = crate::catalog::Consumer::new(&replacement, Default::default()) .await .unwrap(); diff --git a/rs/moq-mux/src/container/ts/health.rs b/rs/moq-mux/src/container/ts/health.rs index 78e6dfa7614..0b03fb7bc1b 100644 --- a/rs/moq-mux/src/container/ts/health.rs +++ b/rs/moq-mux/src/container/ts/health.rs @@ -1001,7 +1001,11 @@ mod test { #[test] fn a_multiplex_counts_each_fault_once() { let origin = crate::source::produce_origin(); - let mut programs = Programs::new(origin, Path::new("event.hang").unwrap(), crate::catalog::Config::default()); + let mut programs = Programs::new( + origin, + Path::new("event.hang").unwrap(), + crate::catalog::Config::default(), + ); let mut data = super::super::import::test::two_programs(); let mut corrupt = vec![0x47, 0x9f, 0xff, 0x10]; corrupt.resize(188, 0xff); diff --git a/rs/moq-mux/src/container/ts/programs.rs b/rs/moq-mux/src/container/ts/programs.rs index ac0ba34cd2f..da58ae6647b 100644 --- a/rs/moq-mux/src/container/ts/programs.rs +++ b/rs/moq-mux/src/container/ts/programs.rs @@ -460,7 +460,11 @@ mod test { #[tokio::test] async fn a_pat_spanning_two_packets_is_read_whole() { let origin = crate::source::produce_origin(); - let mut programs = Programs::new(origin.clone(), Path::new("event.hang").unwrap(), catalog::Config::default()); + let mut programs = Programs::new( + origin.clone(), + Path::new("event.hang").unwrap(), + catalog::Config::default(), + ); let input = fifty_programs(); for chunk in input.chunks(100) { programs.decode(chunk).unwrap(); @@ -468,7 +472,11 @@ mod test { programs.finish().unwrap(); assert_eq!(programs.programs.len(), 1, "only program 50 has a PMT"); - let consumer = origin.consume().request_broadcast(Path::new("event/50.hang").unwrap(), None).await.unwrap(); + let consumer = origin + .consume() + .request_broadcast(Path::new("event/50.hang").unwrap(), None) + .await + .unwrap(); let catalog = hang::catalog::Catalog::<()>::subscribe(&consumer) .await .unwrap() @@ -504,7 +512,11 @@ mod test { /// How many audio renditions the catalog `path` publishes lists. async fn renditions(origin: &moq_net::origin::Producer, path: &str) -> usize { - let consumer = origin.consume().request_broadcast(Path::new(path).unwrap(), None).await.unwrap(); + let consumer = origin + .consume() + .request_broadcast(Path::new(path).unwrap(), None) + .await + .unwrap(); let catalog = hang::catalog::Catalog::<()>::subscribe(&consumer) .await .unwrap() @@ -520,7 +532,11 @@ mod test { #[tokio::test] async fn a_pat_in_two_sections_starts_every_program() { let origin = crate::source::produce_origin(); - let mut programs = Programs::new(origin.clone(), Path::new("event.hang").unwrap(), catalog::Config::default()); + let mut programs = Programs::new( + origin.clone(), + Path::new("event.hang").unwrap(), + catalog::Config::default(), + ); programs.decode(&two_section_pat()).unwrap(); programs.finish().unwrap(); assert_eq!(programs.programs.len(), 2); @@ -533,7 +549,11 @@ mod test { #[tokio::test] async fn only_programs_a_pmt_describes_publish() { let origin = crate::source::produce_origin(); - let mut programs = Programs::new(origin.clone(), Path::new("event.hang").unwrap(), catalog::Config::default()); + let mut programs = Programs::new( + origin.clone(), + Path::new("event.hang").unwrap(), + catalog::Config::default(), + ); // Pairs of programs share a PMT PID, so 6 waits on the PID that starts 7. let pmt_pid = |program: u16| 0x0100 + program / 2; let mut cc = 0; @@ -572,7 +592,11 @@ mod test { #[tokio::test] async fn a_later_pat_revises_the_waiting_programs() { let origin = crate::source::produce_origin(); - let mut programs = Programs::new(origin.clone(), Path::new("event.hang").unwrap(), catalog::Config::default()); + let mut programs = Programs::new( + origin.clone(), + Path::new("event.hang").unwrap(), + catalog::Config::default(), + ); let mut cc = 0; let mut data = psi_packets(0, &mut cc, &[], &pat_section(&[(1, 0x0100), (2, 0x0101)])); let revised = psi::section(0x00, 1, 1, 0, 0, &[0x00, 0x01, 0xe2, 0x00]); @@ -598,7 +622,11 @@ mod test { #[tokio::test] async fn a_program_starts_on_the_last_pmt_in_its_packet() { let origin = crate::source::produce_origin(); - let mut programs = Programs::new(origin.clone(), Path::new("event.hang").unwrap(), catalog::Config::default()); + let mut programs = Programs::new( + origin.clone(), + Path::new("event.hang").unwrap(), + catalog::Config::default(), + ); let mut data = psi_packets(0, &mut 0, &[], &pat_section(&[(1, 0x0100)])); let mut sections = pmt_section(1, 0, &[(MP2, 0x0062, &[])]); sections.extend(pmt_section(1, 1, &[(MP2, 0x0061, &[])])); @@ -614,7 +642,11 @@ mod test { #[tokio::test] async fn a_pmt_spanning_two_packets_starts_its_program() { let origin = crate::source::produce_origin(); - let mut programs = Programs::new(origin.clone(), Path::new("event.hang").unwrap(), catalog::Config::default()); + let mut programs = Programs::new( + origin.clone(), + Path::new("event.hang").unwrap(), + catalog::Config::default(), + ); let mut data = psi_packets(0, &mut 0, &[], &pat_section(&[(1, 0x0100)])); let mut private = vec![0x80, 200]; private.resize(202, 0); @@ -877,7 +909,11 @@ mod test { #[tokio::test] async fn every_program_publishes_its_own_broadcast() { let origin = crate::source::produce_origin(); - let mut programs = Programs::new(origin.clone(), Path::new("event.hang").unwrap(), catalog::Config::default()); + let mut programs = Programs::new( + origin.clone(), + Path::new("event.hang").unwrap(), + catalog::Config::default(), + ); let input = two_programs(); let before = moq_clock::wall(); @@ -891,7 +927,11 @@ mod test { let after = moq_clock::wall(); for (path, fills) in [("event/1.hang", [0xAA, 0xBB]), ("event/2.hang", [0xCC, 0xDD])] { - let consumer = origin.consume().request_broadcast(Path::new(path).unwrap(), None).await.unwrap(); + let consumer = origin + .consume() + .request_broadcast(Path::new(path).unwrap(), None) + .await + .unwrap(); let catalog = hang::catalog::Catalog::<()>::subscribe(&consumer) .await .unwrap() diff --git a/rs/moq-mux/src/follow.rs b/rs/moq-mux/src/follow.rs index 75bd44ac8fc..0882378f718 100644 --- a/rs/moq-mux/src/follow.rs +++ b/rs/moq-mux/src/follow.rs @@ -112,8 +112,8 @@ impl Instances { #[cfg(test)] mod tests { use super::*; - use moq_net::Path; use crate::source::{produce_origin, resolved}; + use moq_net::Path; use moq_net::path::Relative; /// Let the origin's driver run the fronts that announcements started. @@ -160,7 +160,9 @@ mod tests { let mut follow = source.follow(Some(&Relative::new("./source")), None).unwrap(); quiet(&mut follow).await; - let first = origin.publish(Path::new("a/source").unwrap(), Default::default()).unwrap(); + let first = origin + .publish(Path::new("a/source").unwrap(), Default::default()) + .unwrap(); let started = followed(&mut follow).await.expect("a start"); assert_eq!(started.info().path.as_str(), "a/source"); @@ -168,7 +170,9 @@ mod tests { assert!(followed(&mut follow).await.is_none(), "an end"); quiet(&mut follow).await; - let _second = origin.publish(Path::new("a/source").unwrap(), Default::default()).unwrap(); + let _second = origin + .publish(Path::new("a/source").unwrap(), Default::default()) + .unwrap(); let restarted = followed(&mut follow).await.expect("a start"); assert!(!restarted.is_clone(&started)); } @@ -180,7 +184,9 @@ mod tests { let origin = produce_origin(); let (old_epoch, new_epoch) = (moq_net::Epoch::mint(), moq_net::Epoch::mint()); let _catalog = origin.publish(Path::new("a/pub").unwrap(), Default::default()).unwrap(); - let _old = origin.publish(Path::new("a/source").unwrap(), route(&old_epoch)).unwrap(); + let _old = origin + .publish(Path::new("a/source").unwrap(), route(&old_epoch)) + .unwrap(); settle().await; let source = resolved(&origin, "a/pub").await; let rel = Relative::new("./source"); @@ -189,7 +195,9 @@ mod tests { let old = followed(&mut any).await.unwrap(); assert!(followed(&mut named).await.unwrap().is_clone(&old)); - let new = origin.publish(Path::new("a/source").unwrap(), route(&new_epoch)).unwrap(); + let new = origin + .publish(Path::new("a/source").unwrap(), route(&new_epoch)) + .unwrap(); let replaced = followed(&mut any).await.unwrap(); assert_eq!(replaced.info().epoch.as_ref(), Some(&new_epoch)); assert!(followed(&mut named).await.is_none(), "another epoch ends it"); @@ -215,7 +223,9 @@ mod tests { let mut named = source .follow(Some(&Relative::new("./source")), Some(&moq_net::Epoch::mint())) .unwrap(); - let _sibling = origin.publish(Path::new("a/source").unwrap(), Default::default()).unwrap(); + let _sibling = origin + .publish(Path::new("a/source").unwrap(), Default::default()) + .unwrap(); assert!(followed(&mut named).await.is_some()); } diff --git a/rs/moq-mux/src/linger.rs b/rs/moq-mux/src/linger.rs index ab7d8ec0213..136f53e9104 100644 --- a/rs/moq-mux/src/linger.rs +++ b/rs/moq-mux/src/linger.rs @@ -84,7 +84,9 @@ mod tests { /// A broadcast at [`PATH`] whose one track, `video`, has three finished groups. fn finished(origin: &moq_net::origin::Producer) -> (moq_net::broadcast::Producer, moq_net::track::Producer) { - let broadcast = origin.publish(Path::new(PATH).unwrap(), moq_net::origin::Route::default()).unwrap(); + let broadcast = origin + .publish(Path::new(PATH).unwrap(), moq_net::origin::Route::default()) + .unwrap(); let track = broadcast.create_track("video", None).unwrap(); for _ in 0..3 { let mut group = track.append_group().unwrap(); @@ -113,7 +115,11 @@ mod tests { let linger = tokio::spawn(Linger::new([broadcast], track, Duration::from_secs(30)).wait()); moq_clock::sleep(Duration::from_secs(29)).await; - let late = origin.consume().request_broadcast(Path::new(PATH).unwrap(), None).await.unwrap(); + let late = origin + .consume() + .request_broadcast(Path::new(PATH).unwrap(), None) + .await + .unwrap(); let video = late.track("video").unwrap(); for sequence in 0..3 { let mut group = video.fetch_group(sequence, None).await.unwrap(); diff --git a/rs/moq-mux/src/source.rs b/rs/moq-mux/src/source.rs index 91e86066bd6..a98e31fa108 100644 --- a/rs/moq-mux/src/source.rs +++ b/rs/moq-mux/src/source.rs @@ -451,7 +451,9 @@ pub(crate) async fn resolved(origin: &moq_net::origin::Producer, path: &str) -> #[cfg(test)] pub(crate) async fn announced(broadcast: &moq_net::broadcast::Consumer) -> Source { let origin = produce_origin(); - let dynamic = origin.dynamic_route(moq_net::Path::new("").unwrap(), Default::default()).unwrap(); + let dynamic = origin + .dynamic_route(moq_net::Path::new("").unwrap(), Default::default()) + .unwrap(); let served = broadcast.clone(); tokio::spawn(async move { while let Ok(request) = dynamic.requested_broadcast().await { @@ -466,8 +468,8 @@ pub(crate) async fn announced(broadcast: &moq_net::broadcast::Consumer) -> Sourc #[cfg(test)] mod tests { use super::*; - use moq_net::Path; use hang::catalog::{H264, VideoConfig}; + use moq_net::Path; use moq_net::path::Relative; /// Let the origin's driver run the fronts that requests and announcements @@ -484,7 +486,9 @@ mod tests { let _catalog = origin.publish(Path::new("pub").unwrap(), Default::default()).unwrap(); settle().await; let source = resolved(&origin, "pub").await; - let dynamic = origin.dynamic_route(Path::new("media").unwrap(), Default::default()).unwrap(); + let dynamic = origin + .dynamic_route(Path::new("media").unwrap(), Default::default()) + .unwrap(); let binding = source.bind(Some(&Relative::new("media")), None).unwrap(); let request = dynamic.requested_broadcast().await.unwrap(); @@ -556,7 +560,10 @@ mod tests { let _old = origin.publish(Path::new("live").unwrap(), Default::default()).unwrap(); settle().await; let consumer = origin.consume(); - let first = consumer.request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); + let first = consumer + .request_broadcast(Path::new("live").unwrap(), None) + .await + .unwrap(); let new = origin.publish(Path::new("live").unwrap(), Default::default()).unwrap(); let _late = new.create_track("late", None).unwrap(); @@ -577,8 +584,12 @@ mod tests { use crate::container::test_util::Link; let healthy = produce_origin(); - let _catalog = healthy.publish(Path::new("a/pub").unwrap(), Default::default()).unwrap(); - let _sibling = healthy.publish(Path::new("a/source").unwrap(), Default::default()).unwrap(); + let _catalog = healthy + .publish(Path::new("a/pub").unwrap(), Default::default()) + .unwrap(); + let _sibling = healthy + .publish(Path::new("a/source").unwrap(), Default::default()) + .unwrap(); let stalled = produce_origin(); let subscriber = produce_origin(); let _healthy = Link::lazy(&healthy, &subscriber, true).await; @@ -602,7 +613,9 @@ mod tests { let binding = source.bind(Some(&Relative::new("./late")), None).unwrap(); settle().await; assert!(binding.poll_broadcast(&kio::Waiter::noop()).is_pending()); - let _late = healthy.publish(Path::new("a/late").unwrap(), Default::default()).unwrap(); + let _late = healthy + .publish(Path::new("a/late").unwrap(), Default::default()) + .unwrap(); let late = tokio::time::timeout(timeout, binding.broadcast()) .await .expect("the later sibling resolves") @@ -615,7 +628,9 @@ mod tests { async fn a_source_keeps_the_sibling_it_resolved() { let origin = produce_origin(); let _catalog = origin.publish(Path::new("a/pub").unwrap(), Default::default()).unwrap(); - let _old = origin.publish(Path::new("a/source").unwrap(), Default::default()).unwrap(); + let _old = origin + .publish(Path::new("a/source").unwrap(), Default::default()) + .unwrap(); settle().await; let source = resolved(&origin, "a/pub").await; let sibling = Relative::new("./source"); @@ -624,7 +639,9 @@ mod tests { .await .expect("the sibling resolves"); - let new = origin.publish(Path::new("a/source").unwrap(), Default::default()).unwrap(); + let new = origin + .publish(Path::new("a/source").unwrap(), Default::default()) + .unwrap(); let _late = new.create_track("late", None).unwrap(); settle().await; assert!(source.resolve(Some(&sibling), None).await.unwrap().is_clone(&first)); @@ -673,8 +690,12 @@ mod tests { let origin = produce_origin(); let (old_epoch, new_epoch) = (moq_net::Epoch::mint(), moq_net::Epoch::mint()); let _catalog = origin.publish(Path::new("a/pub").unwrap(), Default::default()).unwrap(); - let _old = origin.publish(Path::new("a/source").unwrap(), route(&old_epoch)).unwrap(); - let _new = origin.publish(Path::new("a/source").unwrap(), route(&new_epoch)).unwrap(); + let _old = origin + .publish(Path::new("a/source").unwrap(), route(&old_epoch)) + .unwrap(); + let _new = origin + .publish(Path::new("a/source").unwrap(), route(&new_epoch)) + .unwrap(); settle().await; let source = resolved(&origin, "a/pub").await; let rel = Relative::new("./source"); @@ -695,13 +716,17 @@ mod tests { let origin = produce_origin(); let (old_epoch, new_epoch) = (moq_net::Epoch::mint(), moq_net::Epoch::mint()); let _catalog = origin.publish(Path::new("a/pub").unwrap(), Default::default()).unwrap(); - let _old = origin.publish(Path::new("a/source").unwrap(), route(&old_epoch)).unwrap(); + let _old = origin + .publish(Path::new("a/source").unwrap(), route(&old_epoch)) + .unwrap(); settle().await; let source = resolved(&origin, "a/pub").await; let rel = Relative::new("./source"); let first = source.resolve(Some(&rel), Some(&old_epoch)).await.unwrap(); - let _new = origin.publish(Path::new("a/source").unwrap(), route(&new_epoch)).unwrap(); + let _new = origin + .publish(Path::new("a/source").unwrap(), route(&new_epoch)) + .unwrap(); settle().await; // A rendition added later names the replacement: it fails, and the pin stays. let binding = source.bind(Some(&rel), Some(&new_epoch)).unwrap(); @@ -750,7 +775,9 @@ mod tests { async fn an_epochless_route_reads_an_epoch_reference_best_effort() { let origin = produce_origin(); let _catalog = origin.publish(Path::new("a/pub").unwrap(), Default::default()).unwrap(); - let _sibling = origin.publish(Path::new("a/source").unwrap(), Default::default()).unwrap(); + let _sibling = origin + .publish(Path::new("a/source").unwrap(), Default::default()) + .unwrap(); settle().await; let source = resolved(&origin, "a/pub").await; let epoch = moq_net::Epoch::mint(); @@ -765,11 +792,15 @@ mod tests { #[tokio::test(start_paused = true)] async fn self_references_keep_the_catalog_broadcast_after_replacement() { let origin = produce_origin(); - let old = origin.publish(Path::new("a/live").unwrap(), Default::default()).unwrap(); + let old = origin + .publish(Path::new("a/live").unwrap(), Default::default()) + .unwrap(); settle().await; let source = resolved(&origin, "a/live").await; drop(old); - let _replacement = origin.publish(Path::new("a/live").unwrap(), Default::default()).unwrap(); + let _replacement = origin + .publish(Path::new("a/live").unwrap(), Default::default()) + .unwrap(); settle().await; for reference in [None, Some(""), Some("live"), Some("./live"), Some("../a/live")] { @@ -986,7 +1017,9 @@ mod tests { async fn dot_resolves_output_parent() { let origin = produce_origin(); - let _catalog = origin.create_broadcast(Path::new("a/source/transcode").unwrap()).unwrap(); + let _catalog = origin + .create_broadcast(Path::new("a/source/transcode").unwrap()) + .unwrap(); _catalog.announce(Default::default()).unwrap(); let referenced = origin.create_broadcast(Path::new("a/source").unwrap()).unwrap(); diff --git a/rs/moq-net/benches/announce.rs b/rs/moq-net/benches/announce.rs index 99aa70a1d19..24dd4d7e303 100644 --- a/rs/moq-net/benches/announce.rs +++ b/rs/moq-net/benches/announce.rs @@ -16,8 +16,8 @@ //! //! Run with `cargo bench -p moq-net --features fuzz --bench announce`. -use moq_net::Path; use criterion::{BatchSize, BenchmarkId, Criterion, Throughput, criterion_group, criterion_main}; +use moq_net::Path; use moq_net::{ Hop, Hops, PathOwned, announce, fuzz::{AnnounceWriter, Announced, decode_announces, encode_announces}, diff --git a/rs/moq-net/benches/auth.rs b/rs/moq-net/benches/auth.rs index b653ba084b9..94ed204159e 100644 --- a/rs/moq-net/benches/auth.rs +++ b/rs/moq-net/benches/auth.rs @@ -13,10 +13,10 @@ #[path = "../tests/integration/support/mod.rs"] mod support; -use moq_net::Path; use bytes::Bytes; use criterion::{BenchmarkId, Criterion, Throughput, criterion_group, criterion_main}; use futures::future::join_all; +use moq_net::Path; use moq_net::{Hop, Session, Version, auth, origin}; use std::time::Duration; use support::{harness, mock::create_mock_session_pair}; @@ -187,7 +187,11 @@ fn renewal(c: &mut Criterion) { let auths = runtime .block_on(async { [handle.add("a").await.unwrap().0, handle.add("b").await.unwrap().0] }); let broadcasts: Vec<_> = (0..routes) - .map(|route| origin.create_broadcast(Path::new(format!("room/{route}").as_str()).unwrap()).unwrap()) + .map(|route| { + origin + .create_broadcast(Path::new(format!("room/{route}").as_str()).unwrap()) + .unwrap() + }) .collect(); let mut swap = |auth: &auth::Auth, touched: usize| { for broadcast in broadcasts.iter().take(touched) { @@ -267,8 +271,9 @@ fn waiting(c: &mut Criterion) { generation += 1; let broadcasts: Vec<_> = (0..paths) .map(|path| { - let broadcast = - publish.create_broadcast(Path::new(format!("{prefix}{path}").as_str()).unwrap()).unwrap(); + let broadcast = publish + .create_broadcast(Path::new(format!("{prefix}{path}").as_str()).unwrap()) + .unwrap(); broadcast.announce(Default::default()).unwrap(); broadcast }) diff --git a/rs/moq-net/benches/interests.rs b/rs/moq-net/benches/interests.rs index d6ca426af99..6619e29829a 100644 --- a/rs/moq-net/benches/interests.rs +++ b/rs/moq-net/benches/interests.rs @@ -14,8 +14,8 @@ //! //! Run with `cargo bench -p moq-net --features fuzz --bench interests`. -use moq_net::Path; use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main}; +use moq_net::Path; use moq_net::{Hop, Pattern, Patterns, announce, fuzz, origin}; /// `(watches, sessions)` shapes. diff --git a/rs/moq-net/benches/memory.rs b/rs/moq-net/benches/memory.rs index fff061188a2..946e210a57f 100644 --- a/rs/moq-net/benches/memory.rs +++ b/rs/moq-net/benches/memory.rs @@ -144,7 +144,10 @@ impl Link { let consumer = subscriber.consume(); consumer.routed(Path::new("bench").unwrap()).await.unwrap(); - let remote = consumer.request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); + let remote = consumer + .request_broadcast(Path::new("bench").unwrap(), None) + .await + .unwrap(); let mut subscribers = Vec::new(); for index in 0..streams { let track = remote.track(&format!("{index}")).unwrap(); diff --git a/rs/moq-net/benches/origin.rs b/rs/moq-net/benches/origin.rs index 23b6cfc5057..ecbe8327923 100644 --- a/rs/moq-net/benches/origin.rs +++ b/rs/moq-net/benches/origin.rs @@ -78,7 +78,11 @@ fn fanout(publishers: usize, subscribers: usize) -> Fanout { let (producer, driver) = origin::Producer::new(origin::Config::default()); let consumer = producer.consume(); let publishers = (0..publishers) - .map(|i| producer.publish(Path::try_from(format!("room/{i}")).unwrap(), origin::Route::default()).unwrap()) + .map(|i| { + producer + .publish(Path::try_from(format!("room/{i}")).unwrap(), origin::Route::default()) + .unwrap() + }) .collect(); let mut subscribers: Vec = (0..subscribers).map(|_| consumer.announced()).collect(); // Drain the replay so each iteration measures only what it adds. @@ -128,7 +132,11 @@ fn bench_pending_churn(c: &mut Criterion) { group.bench_function(format!("{routes}routes_{readers}readers"), |b| { let (producer, _driver) = origin::Producer::new(origin::Config::default()); let _routes: Vec<_> = (0..routes) - .map(|i| producer.publish(Path::try_from(format!("z/{i}")).unwrap(), origin::Route::default()).unwrap()) + .map(|i| { + producer + .publish(Path::try_from(format!("z/{i}")).unwrap(), origin::Route::default()) + .unwrap() + }) .collect(); let mut cursors: Vec<_> = (0..readers).map(|_| producer.consume().announced()).collect(); let mut sequence = 0u64; @@ -136,7 +144,10 @@ fn bench_pending_churn(c: &mut Criterion) { sequence += 1; drop( producer - .publish(Path::try_from(format!("a/{sequence}")).unwrap(), origin::Route::default()) + .publish( + Path::try_from(format!("a/{sequence}")).unwrap(), + origin::Route::default(), + ) .unwrap(), ); }); @@ -166,7 +177,11 @@ fn bench_withdraw(c: &mut Criterion) { .poll(moq_net::time::Instant::now(), &kio::Waiter::noop()) .unwrap(); let routes: Vec<_> = (0..publishers) - .map(|i| producer.dynamic_route(Path::try_from(format!("room/{i}")).unwrap(), peer_route(9, 1)).unwrap()) + .map(|i| { + producer + .dynamic_route(Path::try_from(format!("room/{i}")).unwrap(), peer_route(9, 1)) + .unwrap() + }) .collect(); let mut cursors: Vec<_> = (0..subscribers).map(|_| producer.consume().announced()).collect(); for cursor in &mut cursors { @@ -220,10 +235,18 @@ fn bench_withdraw_wave(c: &mut Criterion) { .poll(moq_net::time::Instant::now(), &kio::Waiter::noop()) .unwrap(); let near: Vec<_> = (0..broadcasts) - .map(|i| producer.dynamic_route(Path::try_from(format!("room/{i}")).unwrap(), route(&[9, 2])).unwrap()) + .map(|i| { + producer + .dynamic_route(Path::try_from(format!("room/{i}")).unwrap(), route(&[9, 2])) + .unwrap() + }) .collect(); let far: Vec<_> = (0..broadcasts) - .map(|i| producer.dynamic_route(Path::try_from(format!("room/{i}")).unwrap(), route(&[9, 3, 4])).unwrap()) + .map(|i| { + producer + .dynamic_route(Path::try_from(format!("room/{i}")).unwrap(), route(&[9, 3, 4])) + .unwrap() + }) .collect(); let mut cursors: Vec<_> = (0..subscribers).map(|_| producer.consume().announced()).collect(); for cursor in &mut cursors { @@ -267,13 +290,23 @@ fn bench_route_churn(c: &mut Criterion) { group.bench_function(id, |b| { let (producer, _driver) = origin::Producer::new(origin::Config::default()); let _routes: Vec<_> = (0..broadcasts) - .map(|i| producer.dynamic_route(Path::try_from(format!("room/{i}")).unwrap(), peer_route(1, 1)).unwrap()) + .map(|i| { + producer + .dynamic_route(Path::try_from(format!("room/{i}")).unwrap(), peer_route(1, 1)) + .unwrap() + }) .collect(); let mut cursors: Vec<_> = (0..subscribers).map(|_| producer.consume().announced()).collect(); for cursor in &mut cursors { while cursor.try_next().is_some() {} } - b.iter(|| drop(producer.dynamic_route(Path::new("room/0").unwrap(), peer_route(2, 5)).unwrap())); + b.iter(|| { + drop( + producer + .dynamic_route(Path::new("room/0").unwrap(), peer_route(2, 5)) + .unwrap(), + ) + }); for cursor in &mut cursors { assert!(cursor.try_next().is_none(), "the winner is unchanged"); } @@ -297,16 +330,25 @@ fn bench_announce_mounted(c: &mut Criterion) { let _publishers: Vec<_> = (0..publishers) .map(|i| { producer - .publish(Path::try_from(format!(".svc/p0/{i}")).unwrap(), origin::Route::default()) + .publish( + Path::try_from(format!(".svc/p0/{i}")).unwrap(), + origin::Route::default(), + ) .unwrap() }) .collect(); let mut cursors: Vec = (0..subscribers) .map(|project| { producer - .mount(Path::try_from(format!("p{project}/.svc")).unwrap(), Path::new(".svc/p0").unwrap()) + .mount( + Path::try_from(format!("p{project}/.svc")).unwrap(), + Path::new(".svc/p0").unwrap(), + ) .unwrap() - .scope(Path::try_from(format!("p{project}")).unwrap(), &Patterns::from(Pattern::all())) + .scope( + Path::try_from(format!("p{project}")).unwrap(), + &Patterns::from(Pattern::all()), + ) .unwrap() .consume() .with_hidden(true) @@ -318,7 +360,9 @@ fn bench_announce_mounted(c: &mut Criterion) { } b.iter(|| { - let handle = producer.publish(Path::new(".svc/p0/incoming").unwrap(), origin::Route::default()).unwrap(); + let handle = producer + .publish(Path::new(".svc/p0/incoming").unwrap(), origin::Route::default()) + .unwrap(); for cursor in &mut cursors { cursor.next().now_or_never().flatten().expect("announce delivered"); } @@ -348,7 +392,10 @@ fn bench_announce_fleet(c: &mut Criterion) { .flat_map(|project| (0..nodes).map(move |node| (project, node))) .map(|(project, node)| { producer - .publish(Path::try_from(format!(".stats/p{project}/node/edge{node}")).unwrap(), origin::Route::default()) + .publish( + Path::try_from(format!(".stats/p{project}/node/edge{node}")).unwrap(), + origin::Route::default(), + ) .unwrap() }) .collect(); @@ -412,7 +459,10 @@ fn bench_announce_duplicate(c: &mut Criterion) { b.iter(|| { let handle = producer - .dynamic_route(Path::new(PATH).unwrap(), peer_route(duplicates as u64 + 1, INCUMBENT_COST - 1)) + .dynamic_route( + Path::new(PATH).unwrap(), + peer_route(duplicates as u64 + 1, INCUMBENT_COST - 1), + ) .unwrap(); for cursor in &mut cursors { cursor.next().now_or_never().flatten().expect("announce delivered"); @@ -516,7 +566,9 @@ fn bench_announce_fronts(c: &mut Criterion) { let (producer, mut driver) = origin::Producer::new(origin::Config::default()); let consumer = producer.consume(); // Served but never answered: every request under it parks a front. - let _served = producer.dynamic_route(Path::new("room").unwrap(), origin::Route::default()).unwrap(); + let _served = producer + .dynamic_route(Path::new("room").unwrap(), origin::Route::default()) + .unwrap(); let _requests: Vec<_> = (0..fronts) .map(|i| consumer.request_broadcast(Path::try_from(format!("room/{i}")).unwrap(), None)) .collect(); @@ -524,7 +576,9 @@ fn bench_announce_fronts(c: &mut Criterion) { // Run each front once so it parks on its upstream request. driver.poll(moq_net::time::Instant::now(), &waiter).unwrap(); b.iter(|| { - let handle = producer.publish(Path::new("other/incoming").unwrap(), origin::Route::default()).unwrap(); + let handle = producer + .publish(Path::new("other/incoming").unwrap(), origin::Route::default()) + .unwrap(); driver.poll(moq_net::time::Instant::now(), &waiter).unwrap(); drop(handle); driver.poll(moq_net::time::Instant::now(), &waiter).unwrap(); @@ -558,7 +612,10 @@ fn bench_serve_idle(c: &mut Criterion) { let dynamics: Vec<_> = (0..routes) .map(|i| { producer - .dynamic_route(Path::try_from(format!(".stats/p{}/node/edge{i}", i % 8)).unwrap(), origin::Route::default()) + .dynamic_route( + Path::try_from(format!(".stats/p{}/node/edge{i}", i % 8)).unwrap(), + origin::Route::default(), + ) .unwrap() }) .collect(); @@ -608,7 +665,10 @@ fn bench_request(c: &mut Criterion) { for publishers in [100, 1_000] { let mut fleet = fanout(publishers, 0); // A broadcast above the misses covers them without serving them. - let _covering = fleet.producer.publish(Path::new("room").unwrap(), origin::Route::default()).unwrap(); + let _covering = fleet + .producer + .publish(Path::new("room").unwrap(), origin::Route::default()) + .unwrap(); let waiter = kio::Waiter::noop(); group.bench_function(BenchmarkId::new("local", publishers), |b| { b.iter(|| { @@ -715,12 +775,18 @@ fn bench_unroutable_churn(c: &mut Criterion) { group.bench_function(id, |b| { let (producer, mut driver) = origin::Producer::new(origin::Config::default()); let consumer = producer.consume(); - let server = producer.dynamic_route(Path::new("room").unwrap(), origin::Route::default()).unwrap(); - let unrelated = producer.dynamic_route(Path::new("other").unwrap(), origin::Route::default()).unwrap(); + let server = producer + .dynamic_route(Path::new("room").unwrap(), origin::Route::default()) + .unwrap(); + let unrelated = producer + .dynamic_route(Path::new("other").unwrap(), origin::Route::default()) + .unwrap(); let mut waiting = Waiting::new( (0..requesters) .map(|i| { - consumer.routed_broadcast(Path::try_from(format!("room/job-{}", if distinct { i } else { 0 })).unwrap()) + consumer.routed_broadcast( + Path::try_from(format!("room/job-{}", if distinct { i } else { 0 })).unwrap(), + ) }) .collect(), ); @@ -782,7 +848,11 @@ fn bench_retire(c: &mut Criterion) { let mut fleet = fanout(fronts + 1, 0); let waiter = kio::Waiter::noop(); let held: Vec<_> = (0..fronts) - .map(|i| fleet.consumer.request_broadcast(Path::try_from(format!("room/{i}")).unwrap(), None)) + .map(|i| { + fleet + .consumer + .request_broadcast(Path::try_from(format!("room/{i}")).unwrap(), None) + }) .collect(); fleet.driver.poll(moq_net::time::Instant::now(), &waiter).unwrap(); let _held: Vec<_> = held @@ -840,7 +910,11 @@ fn pool(members: usize, paths: usize, cursors: usize) -> Pool { let consumer = producer.consume(); let cursors = (0..cursors).map(|_| consumer.announced()).collect(); let members: Vec<_> = (0..members) - .map(|i| producer.dynamic_route(Path::new("pool").unwrap(), pool_route(POOL_HOP + i as u64)).unwrap()) + .map(|i| { + producer + .dynamic_route(Path::new("pool").unwrap(), pool_route(POOL_HOP + i as u64)) + .unwrap() + }) .collect(); let waiter = kio::Waiter::noop(); @@ -899,7 +973,10 @@ fn bench_pool_churn(c: &mut Criterion) { let waiter = kio::Waiter::noop(); let hop = POOL_HOP + members as u64; b.iter(|| { - let joined = pool.producer.dynamic_route(Path::new("pool").unwrap(), pool_route(hop)).unwrap(); + let joined = pool + .producer + .dynamic_route(Path::new("pool").unwrap(), pool_route(hop)) + .unwrap(); pool.driver.poll(moq_net::time::Instant::now(), &waiter).unwrap(); drop(joined); pool.driver.poll(moq_net::time::Instant::now(), &waiter).unwrap(); @@ -927,7 +1004,10 @@ fn bench_pool_cursors(c: &mut Criterion) { let waiter = kio::Waiter::noop(); let hop = POOL_HOP + members as u64; b.iter(|| { - let joined = pool.producer.dynamic_route(Path::new("pool").unwrap(), pool_route(hop)).unwrap(); + let joined = pool + .producer + .dynamic_route(Path::new("pool").unwrap(), pool_route(hop)) + .unwrap(); pool.driver.poll(moq_net::time::Instant::now(), &waiter).unwrap(); drop(joined); pool.driver.poll(moq_net::time::Instant::now(), &waiter).unwrap(); @@ -959,20 +1039,29 @@ fn bench_handoff(c: &mut Criterion) { runtime.spawn(moq_net::time::run(driver)); let consumer = producer.consume(); let _others: Vec<_> = (0..publishers) - .map(|i| producer.publish(Path::try_from(format!("room/{i}")).unwrap(), origin::Route::default()).unwrap()) + .map(|i| { + producer + .publish(Path::try_from(format!("room/{i}")).unwrap(), origin::Route::default()) + .unwrap() + }) .collect(); b.iter_custom(|iterations| { runtime.block_on(async { let mut total = Duration::ZERO; for _ in 0..iterations { - let incumbent = producer.publish(Path::new("room/live").unwrap(), origin::Route::default()).unwrap(); + let incumbent = producer + .publish(Path::new("room/live").unwrap(), origin::Route::default()) + .unwrap(); let track = incumbent.create_track("video", timed()).unwrap(); let mut first = track.append_group().unwrap(); first.write_frame(Timestamp::ZERO, b"one".as_ref()).unwrap(); first.finish().unwrap(); - let resolved = consumer.request_broadcast(Path::new("room/live").unwrap(), None).await.unwrap(); + let resolved = consumer + .request_broadcast(Path::new("room/live").unwrap(), None) + .await + .unwrap(); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); subscription.recv_group().await.unwrap().expect("first group"); @@ -984,7 +1073,10 @@ fn bench_handoff(c: &mut Criterion) { second.finish().unwrap(); // Announcing is what makes the standby a route the front can take. standby.announce(origin::Route::default()).unwrap(); - let replaced = consumer.request_broadcast(Path::new("room/live").unwrap(), None).await.unwrap(); + let replaced = consumer + .request_broadcast(Path::new("room/live").unwrap(), None) + .await + .unwrap(); let mut replacement = replaced.track("video").unwrap().subscribe(None).await.unwrap(); let group = replacement.recv_group().await.unwrap().expect("standby group"); total += started.elapsed(); @@ -1041,7 +1133,9 @@ async fn watching(routes: usize, subscribers: usize) -> Watching { let mut broadcasts = Vec::new(); let mut tracks = Vec::new(); for index in 0..routes { - let broadcast = relay.publish(Path::try_from(watched_path(index)).unwrap(), origin::Route::default()).unwrap(); + let broadcast = relay + .publish(Path::try_from(watched_path(index)).unwrap(), origin::Route::default()) + .unwrap(); tracks.push(broadcast.create_track("video", timed()).unwrap()); broadcasts.push(broadcast); } @@ -1053,7 +1147,11 @@ async fn watching(routes: usize, subscribers: usize) -> Watching { let mut subscriptions = Vec::new(); for index in 0..subscribers { - let remote = received.consume().routed_broadcast(Path::try_from(watched_path(index)).unwrap()).await.unwrap(); + let remote = received + .consume() + .routed_broadcast(Path::try_from(watched_path(index)).unwrap()) + .await + .unwrap(); let subscription = remote.track("video").unwrap().subscribe(None).await.unwrap(); subscriptions.push(subscription); } @@ -1174,12 +1272,18 @@ fn bench_relay(c: &mut Criterion) { .unwrap(); let (producer, driver) = origin::Producer::new(origin::Config::default()); runtime.spawn(moq_net::time::run(driver)); - let broadcast = producer.publish(Path::new("room/live").unwrap(), origin::Route::default()).unwrap(); + let broadcast = producer + .publish(Path::new("room/live").unwrap(), origin::Route::default()) + .unwrap(); let sources: Vec<_> = (0..tracks) .map(|i| broadcast.create_track(format!("{i}"), timed()).unwrap()) .collect(); let mut subscriptions = runtime.block_on(async { - let resolved = producer.consume().request_broadcast(Path::new("room/live").unwrap(), None).await.unwrap(); + let resolved = producer + .consume() + .request_broadcast(Path::new("room/live").unwrap(), None) + .await + .unwrap(); let mut subscriptions = Vec::new(); for i in 0..tracks { let track = resolved.track(&format!("{i}")).unwrap(); @@ -1234,10 +1338,16 @@ fn bench_passthrough(c: &mut Criterion) { .unwrap(); let (producer, driver) = origin::Producer::new(origin::Config::default()); runtime.spawn(moq_net::time::run(driver)); - let broadcast = producer.publish(Path::new("room/live").unwrap(), origin::Route::default()).unwrap(); + let broadcast = producer + .publish(Path::new("room/live").unwrap(), origin::Route::default()) + .unwrap(); let source = broadcast.create_track("0", timed()).unwrap(); let mut subscriptions = runtime.block_on(async { - let resolved = producer.consume().request_broadcast(Path::new("room/live").unwrap(), None).await.unwrap(); + let resolved = producer + .consume() + .request_broadcast(Path::new("room/live").unwrap(), None) + .await + .unwrap(); let track = resolved.track("0").unwrap(); let mut subscriptions = Vec::with_capacity(readers); for _ in 0..readers { @@ -1289,13 +1399,19 @@ fn bench_parked(c: &mut Criterion) { .unwrap(); let (producer, driver) = origin::Producer::new(origin::Config::default()); runtime.spawn(moq_net::time::run(driver)); - let broadcast = producer.publish(Path::new("room/live").unwrap(), origin::Route::default()).unwrap(); + let broadcast = producer + .publish(Path::new("room/live").unwrap(), origin::Route::default()) + .unwrap(); let sources: Vec<_> = (0..tracks) .map(|i| broadcast.create_track(format!("{i}"), None).unwrap()) .collect(); let _writers: Vec<_> = sources.iter().map(|source| source.append_group().unwrap()).collect(); let (subscriptions, mut groups) = runtime.block_on(async { - let resolved = producer.consume().request_broadcast(Path::new("room/live").unwrap(), None).await.unwrap(); + let resolved = producer + .consume() + .request_broadcast(Path::new("room/live").unwrap(), None) + .await + .unwrap(); let mut subscriptions = Vec::new(); let mut groups = Vec::new(); for i in 0..tracks { @@ -1403,10 +1519,15 @@ async fn copy_walk(tracks: usize, copies: usize) -> CopyWalk { let epoch = Epoch::mint(); let first = Generation::build(&producer, tracks); first.route(&epoch); - let resolved = moq_clock::timeout(COPY_WAIT, producer.consume().request_broadcast(Path::new(COPY_PATH).unwrap(), None)) - .await - .expect("front did not resolve") - .expect("front refused"); + let resolved = moq_clock::timeout( + COPY_WAIT, + producer + .consume() + .request_broadcast(Path::new(COPY_PATH).unwrap(), None), + ) + .await + .expect("front did not resolve") + .expect("front refused"); let mut subscribers = Vec::with_capacity(tracks); for i in 0..tracks { let track = resolved.track(&format!("{i}")).unwrap(); @@ -1564,10 +1685,15 @@ async fn resume_overlap(shape: ResumeShape, ordered: bool) -> ResumeOverlap { (broadcast, track) }; let mut generations = vec![generation(&mut (0..retained))]; - let resolved = moq_clock::timeout(COPY_WAIT, producer.consume().request_broadcast(Path::new(COPY_PATH).unwrap(), None)) - .await - .expect("front did not resolve") - .expect("front refused"); + let resolved = moq_clock::timeout( + COPY_WAIT, + producer + .consume() + .request_broadcast(Path::new(COPY_PATH).unwrap(), None), + ) + .await + .expect("front did not resolve") + .expect("front refused"); let track = resolved.track("0").unwrap(); // A budget covering every group, so none is written off as late. let subscription = track::Subscription::default().with_max_delay(Duration::from_secs(3600)); diff --git a/rs/moq-net/benches/session.rs b/rs/moq-net/benches/session.rs index 1c36b620ab2..2c2001a6d3d 100644 --- a/rs/moq-net/benches/session.rs +++ b/rs/moq-net/benches/session.rs @@ -378,7 +378,10 @@ impl Cluster { this.pools.push(pool); for index in 0..shape.broadcasts { let broadcast = origin - .publish(Path::try_from(path(publisher * shape.broadcasts + index)).unwrap(), Default::default()) + .publish( + Path::try_from(path(publisher * shape.broadcasts + index)).unwrap(), + Default::default(), + ) .unwrap(); this.tracks.push( broadcast @@ -449,7 +452,12 @@ struct Viewer { impl Viewer { /// Resolve `path` and subscribe to each of its `tracks`. async fn watch(&mut self, path: &str, tracks: &[impl AsRef], subscription: Option) { - let broadcast = self.origin.consume().routed_broadcast(Path::new(path).unwrap()).await.unwrap(); + let broadcast = self + .origin + .consume() + .routed_broadcast(Path::new(path).unwrap()) + .await + .unwrap(); for track in tracks { self.subscribers.push( broadcast @@ -512,7 +520,12 @@ impl Room { let mut viewer = cluster.join((viewer + 1) % shape.relays).await; for broadcast in broadcasts { if shape.fetch { - let source = viewer.origin.consume().routed_broadcast(Path::try_from(path(broadcast)).unwrap()).await.unwrap(); + let source = viewer + .origin + .consume() + .routed_broadcast(Path::try_from(path(broadcast)).unwrap()) + .await + .unwrap(); viewer.fetches.push((broadcast, source.track(TRACK).unwrap())); } else { viewer.watch(&path(broadcast), &[TRACK], shape.subscription()).await; @@ -908,7 +921,9 @@ impl DashRoom { for node in 1..shape.relays { for project in 0..shape.projects { let path = format!(".stats/{project}/node/{node}"); - let broadcast = cluster.relays[node].publish(Path::new(path.as_str()).unwrap(), Default::default()).unwrap(); + let broadcast = cluster.relays[node] + .publish(Path::new(path.as_str()).unwrap(), Default::default()) + .unwrap(); for name in &names { tracks.push(broadcast.create_track(name.as_str(), timed()).unwrap()); } @@ -1056,7 +1071,14 @@ impl ChurnRoom { for _ in 0..shape.sessions { let mut viewer = cluster.join(0).await; viewer.watch(&path(0), &held, None).await; - broadcasts.push(viewer.origin.consume().routed_broadcast(Path::try_from(path(0)).unwrap()).await.unwrap()); + broadcasts.push( + viewer + .origin + .consume() + .routed_broadcast(Path::try_from(path(0)).unwrap()) + .await + .unwrap(), + ); viewers.push(viewer); } Self { diff --git a/rs/moq-net/benches/stats.rs b/rs/moq-net/benches/stats.rs index 047c1880ae0..b8c6e09eaae 100644 --- a/rs/moq-net/benches/stats.rs +++ b/rs/moq-net/benches/stats.rs @@ -4,9 +4,9 @@ //! //! Run with `cargo bench -p moq-net --bench stats`. -use moq_net::Path; use criterion::{BenchmarkId, Criterion, Throughput, criterion_group, criterion_main}; use futures::FutureExt; +use moq_net::Path; use moq_net::{announce, broadcast, fuzz, origin, stats, transport}; /// `(broadcasts, tiers)` shapes; every broadcast records under every tier. @@ -25,11 +25,17 @@ fn registry(broadcasts: usize, tiers: usize) -> Registry { let registry = stats::Registry::new(stats::Config::new()); let (producer, driver) = origin::Producer::new(origin::Config::default()); let publishers = (0..broadcasts) - .map(|i| producer.publish(Path::try_from(format!("room/{i}")).unwrap(), origin::Route::default()).unwrap()) + .map(|i| { + producer + .publish(Path::try_from(format!("room/{i}")).unwrap(), origin::Route::default()) + .unwrap() + }) .collect(); let cursors = (0..tiers) .map(|t| { - let session = registry.tier(stats::Tier::new(Path::try_from(format!("tier{t}")).unwrap())).session(Path::new("root").unwrap()); + let session = registry + .tier(stats::Tier::new(Path::try_from(format!("tier{t}")).unwrap())) + .session(Path::new("root").unwrap()); let mut cursor = producer.consume().with_stats(session).announced(); // Each announce the cursor replays records under its tier. while cursor.next().now_or_never().flatten().is_some() {} @@ -109,7 +115,8 @@ fn session_report(c: &mut Criterion) { let contexts: Vec<_> = (0..labels) .flat_map(|label| { let handle = handle.clone(); - (0..sessions).map(move |_| handle.session(Path::try_from(format!("project/key/{label}")).unwrap())) + (0..sessions) + .map(move |_| handle.session(Path::try_from(format!("project/key/{label}")).unwrap())) }) .collect(); let wires: Vec<_> = contexts @@ -166,7 +173,10 @@ fn retag(c: &mut Criterion) { session.retag(tier.clone(), Path::new("project/moved").unwrap()); } for session in moving.iter().rev() { - session.retag(tier.clone(), Path::try_from(format!("project/key/{}", labels - 1)).unwrap()); + session.retag( + tier.clone(), + Path::try_from(format!("project/key/{}", labels - 1)).unwrap(), + ); } }); }); diff --git a/rs/moq-net/benches/synced.rs b/rs/moq-net/benches/synced.rs index 6cb229faf0f..1770ec3200b 100644 --- a/rs/moq-net/benches/synced.rs +++ b/rs/moq-net/benches/synced.rs @@ -13,8 +13,8 @@ //! //! Run with `cargo bench -p moq-net --features fuzz --bench synced`. -use moq_net::Path; use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main}; +use moq_net::Path; use moq_net::{Hop, Pattern, Patterns, announce, fuzz, origin}; /// `(streams, consumers)` shapes. diff --git a/rs/moq-net/benches/viewers.rs b/rs/moq-net/benches/viewers.rs index bd502f677a8..32637557790 100644 --- a/rs/moq-net/benches/viewers.rs +++ b/rs/moq-net/benches/viewers.rs @@ -76,7 +76,9 @@ impl Room { let (producer, driver) = origin::Producer::new(origin::Config::default()); let _sources = (0..broadcasts) .map(|i| { - let broadcast = producer.publish(Path::try_from(format!("room/{i}")).unwrap(), origin::Route::default()).unwrap(); + let broadcast = producer + .publish(Path::try_from(format!("room/{i}")).unwrap(), origin::Route::default()) + .unwrap(); let track = broadcast.create_track("video", timed()).unwrap(); let mut group = track.append_group().unwrap(); group.write_frame(Timestamp::ZERO, b"frame".as_ref()).unwrap(); @@ -113,7 +115,9 @@ impl Room { fn join(&mut self, n: usize) -> moq_net::track::Subscriber { let session = moq_net::fuzz::excluding(self.producer.consume(), Hop::random()); let path = format!("room/{}", n % self.broadcasts); - let resolved = self.drive(session.request_broadcast(Path::try_from(path).unwrap(), None)).unwrap(); + let resolved = self + .drive(session.request_broadcast(Path::try_from(path).unwrap(), None)) + .unwrap(); let mut subscription = self.drive(resolved.track("video").unwrap().subscribe(None)).unwrap(); self.drive(subscription.recv_group()) .unwrap() diff --git a/rs/moq-net/src/auth.rs b/rs/moq-net/src/auth.rs index 0bdd8654470..69ceca078cb 100644 --- a/rs/moq-net/src/auth.rs +++ b/rs/moq-net/src/auth.rs @@ -2454,7 +2454,11 @@ mod tests { let busy = Error::Session(SessionError::TooManyRequests); assert_eq!(handle.retry(id, &busy), Some(RETRY_INITIAL)); - let mut gate = Gate::new(handle.clone(), crate::Path::new("room").unwrap().to_owned(), Direction::Publish); + let mut gate = Gate::new( + handle.clone(), + crate::Path::new("room").unwrap().to_owned(), + Direction::Publish, + ); let waiter = kio::Waiter::noop(); assert!( gate.poll_ready(&waiter).is_pending(), @@ -2492,7 +2496,11 @@ mod tests { fn an_empty_token_never_holds_a_request() { let handle = Link::new(true); let _setup = handle.present(Bytes::new(), true).unwrap(); - let mut gate = Gate::new(handle, crate::Path::new("room").unwrap().to_owned(), Direction::Subscribe); + let mut gate = Gate::new( + handle, + crate::Path::new("room").unwrap().to_owned(), + Direction::Subscribe, + ); assert!(gate.poll_ready(&kio::Waiter::noop()).is_ready()); } @@ -2502,7 +2510,11 @@ mod tests { let first = handle.present(Bytes::from_static(b"first"), false).unwrap(); handle.granted(first.presented.id, Grant::all()); let _unanswered = handle.present(Bytes::from_static(b"renewal"), false).unwrap(); - let mut gate = Gate::new(handle, crate::Path::new("room").unwrap().to_owned(), Direction::Subscribe); + let mut gate = Gate::new( + handle, + crate::Path::new("room").unwrap().to_owned(), + Direction::Subscribe, + ); assert!(gate.poll_ready(&kio::Waiter::noop()).is_ready()); } diff --git a/rs/moq-net/src/coding/writer.rs b/rs/moq-net/src/coding/writer.rs index 12261b482a8..51b85e74996 100644 --- a/rs/moq-net/src/coding/writer.rs +++ b/rs/moq-net/src/coding/writer.rs @@ -417,7 +417,9 @@ mod tests { stats::{Bytes, Control, Registry, Tier}, }; let stats = Registry::new(Default::default()); - let session = stats.tier(Tier::new(Path::new("internal").unwrap())).session(Path::new("").unwrap()); + let session = stats + .tier(Tier::new(Path::new("internal").unwrap())) + .session(Path::new("").unwrap()); let gate = kio::Producer::new(false); let mut writer = Writer::new(SinkSend::gated(Log::default(), gate.consume()), lite::Version::Lite07).with_stats(&session); @@ -433,7 +435,11 @@ mod tests { assert!(writer.poll_flush(&mut Context::from_waker(Waker::noop())).is_pending()); assert_eq!( stats.snapshot().control(), - vec![(Tier::new(Path::new("internal").unwrap()), Control::Probe, Bytes { tx: size, rx: 0 })] + vec![( + Tier::new(Path::new("internal").unwrap()), + Control::Probe, + Bytes { tx: size, rx: 0 } + )] ); writer .buffer(&lite::Track { diff --git a/rs/moq-net/src/fuzz.rs b/rs/moq-net/src/fuzz.rs index 70a15d7db21..10bfc9bc24c 100644 --- a/rs/moq-net/src/fuzz.rs +++ b/rs/moq-net/src/fuzz.rs @@ -1372,7 +1372,9 @@ mod tests { let _driver = driver; let tier = crate::stats::Tier::new(Path::new("t").unwrap()); let session = registry.tier(tier.clone()).session(Path::new("root").unwrap()); - let _broadcast = origin.publish(Path::new("room/1").unwrap(), crate::origin::Route::default()).unwrap(); + let _broadcast = origin + .publish(Path::new("room/1").unwrap(), crate::origin::Route::default()) + .unwrap(); let mut cursor = origin.consume().with_stats(session).announced(); while cursor.next().now_or_never().flatten().is_some() {} diff --git a/rs/moq-net/src/ietf/publisher.rs b/rs/moq-net/src/ietf/publisher.rs index 9050c2002ba..d61025f5003 100644 --- a/rs/moq-net/src/ietf/publisher.rs +++ b/rs/moq-net/src/ietf/publisher.rs @@ -9157,7 +9157,9 @@ mod serve_tests { async fn track_status_narrowed_while_answering_is_reset() { for version in ALL_VERSIONS { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let broadcast = origin.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); + let broadcast = origin + .publish(Path::new("room").unwrap(), crate::origin::Route::default()) + .unwrap(); let _track = broadcast.create_track("video", None).unwrap(); settle().await; @@ -9425,7 +9427,10 @@ mod serve_tests { for version in [Version::Draft21, Version::Draft22] { for path in [".", "./child", ".session", ".session/extension"] { let h = serve(version); - let claim = h._origin.dynamic_route(Path::new("").unwrap(), crate::origin::Route::default()).unwrap(); + let claim = h + ._origin + .dynamic_route(Path::new("").unwrap(), crate::origin::Route::default()) + .unwrap(); settle().await; let stream = Stream::open(&mut crate::driver::Transport::new(h.session.clone()), version) .await @@ -10833,10 +10838,16 @@ mod serve_tests { /// published with `info`. async fn across_a_hop(info: track::Info) -> track::Info { let upstream = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); - let broadcast = upstream.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); + let broadcast = upstream + .publish(Path::new("room").unwrap(), crate::origin::Route::default()) + .unwrap(); let _track = broadcast.create_track("video", info).unwrap(); let (downstream, _sessions) = crate::lite::ietf::test_hop(&upstream, "room", [true, true]).await; - let broadcast = downstream.consume().request_broadcast(Path::new("room").unwrap(), None).await.unwrap(); + let broadcast = downstream + .consume() + .request_broadcast(Path::new("room").unwrap(), None) + .await + .unwrap(); broadcast.track("video").unwrap().query().await.unwrap() } @@ -11415,7 +11426,9 @@ mod serve_tests { async fn a_standalone_fetch_narrowed_while_responding_stops() { for version in FETCH_DRAFTS { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let broadcast = origin.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); + let broadcast = origin + .publish(Path::new("room").unwrap(), crate::origin::Route::default()) + .unwrap(); let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); let mut group = track.create_group(group::Info { sequence: 0 }).unwrap(); group.write_frame(timestamp(), b"0-0".to_vec()).unwrap(); @@ -11511,7 +11524,9 @@ mod serve_tests { }, ] { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let broadcast = origin.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); + let broadcast = origin + .publish(Path::new("room").unwrap(), crate::origin::Route::default()) + .unwrap(); let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); let mut group = track.create_group(group::Info { sequence: 0 }).unwrap(); group.write_frame(timestamp(), PAYLOAD.to_vec()).unwrap(); @@ -11620,7 +11635,9 @@ mod serve_tests { .flat_map(|version| [false, true].map(|token| (version, token))) { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let broadcast = origin.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); + let broadcast = origin + .publish(Path::new("room").unwrap(), crate::origin::Route::default()) + .unwrap(); let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); let mut group = track.create_group(group::Info { sequence: 0 }).unwrap(); group.write_frame(timestamp(), b"joined-prefix".to_vec()).unwrap(); @@ -11757,11 +11774,17 @@ mod serve_tests { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let (claim, published) = match parked { Parked::Resolving => ( - Some(origin.dynamic_route(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap()), + Some( + origin + .dynamic_route(Path::new("room").unwrap(), crate::origin::Route::default()) + .unwrap(), + ), None, ), Parked::Acking | Parked::Ending => { - let broadcast = origin.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); + let broadcast = origin + .publish(Path::new("room").unwrap(), crate::origin::Route::default()) + .unwrap(); let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); match parked { // One published group, so the subscription parks at the live edge. @@ -11947,7 +11970,9 @@ mod serve_tests { let mut idle = None; match setup { Setup::Resolving => { - let route = origin.dynamic_route(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); + let route = origin + .dynamic_route(Path::new("room").unwrap(), crate::origin::Route::default()) + .unwrap(); let request = { let requested = std::pin::pin!(route.requested_broadcast()); match futures::future::select(requested, serving.as_mut()).await { @@ -11958,7 +11983,9 @@ mod serve_tests { claim = Some((route, request)); } Setup::Subscribing => { - let broadcast = origin.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); + let broadcast = origin + .publish(Path::new("room").unwrap(), crate::origin::Route::default()) + .unwrap(); let mut dynamic = broadcast.dynamic(); let request = { let requested = std::pin::pin!(dynamic.requested_track()); @@ -11970,7 +11997,9 @@ mod serve_tests { asked = Some((broadcast, dynamic, request)); } Setup::Live => { - let broadcast = origin.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); + let broadcast = origin + .publish(Path::new("room").unwrap(), crate::origin::Route::default()) + .unwrap(); let mut track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); track.set_idle(); serve_until(serving.as_mut(), "the upstream subscription", || { @@ -12428,7 +12457,9 @@ mod serve_tests { /// its script. fn serve_on(version: Version, auth: crate::auth::Link, session: ScriptedSession) -> Serve { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let broadcast = origin.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); + let broadcast = origin + .publish(Path::new("room").unwrap(), crate::origin::Route::default()) + .unwrap(); let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); let log = session.log.clone(); @@ -14334,7 +14365,10 @@ mod tests { let mut local_hops = crate::Hops::new(); local_hops.push(other).unwrap(); let local = origin - .announce(Path::new("from/us").unwrap(), crate::origin::Route::default().with_hops(local_hops)) + .announce( + Path::new("from/us").unwrap(), + crate::origin::Route::default().with_hops(local_hops), + ) .unwrap(); (publisher, consumer, vec![echoed, local]) @@ -14500,13 +14534,19 @@ mod tests { let mut clean = crate::Hops::new(); clean.push(crate::Hop::new(778).unwrap()).unwrap(); let _clean = origin - .announce(Path::new("cam-clean").unwrap(), crate::origin::Route::default().with_hops(clean)) + .announce( + Path::new("cam-clean").unwrap(), + crate::origin::Route::default().with_hops(clean), + ) .unwrap(); // A chain with no room left for our own hop cannot be forwarded. let mut full = crate::Hops::new(); while full.push(crate::Hop::new(100 + full.len() as u64).unwrap()).is_ok() {} let _full = origin - .announce(Path::new("cam-full").unwrap(), crate::origin::Route::default().with_hops(full)) + .announce( + Path::new("cam-full").unwrap(), + crate::origin::Route::default().with_hops(full), + ) .unwrap(); settle().await; @@ -14602,7 +14642,10 @@ mod tests { let mut clean_hops = crate::Hops::new(); clean_hops.push(clean_publisher).unwrap(); let clean = origin - .announce(Path::new("route-flip-cam").unwrap(), crate::origin::Route::default().with_hops(clean_hops)) + .announce( + Path::new("route-flip-cam").unwrap(), + crate::origin::Route::default().with_hops(clean_hops), + ) .unwrap(); settle().await; assert!(futures::poll!(run.as_mut()).is_pending()); @@ -14658,7 +14701,9 @@ mod tests { const VERSION: Version = Version::Draft17; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _cam = origin.announce(Path::new("lonely-cam").unwrap(), crate::origin::Route::default()).unwrap(); + let _cam = origin + .announce(Path::new("lonely-cam").unwrap(), crate::origin::Route::default()) + .unwrap(); settle().await; // Every stream is answered with the same refusal, so a retry would show up as a @@ -14713,7 +14758,10 @@ mod tests { for epochs in [true, false] { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let _old = origin - .announce(Path::new("cam").unwrap(), crate::origin::Route::default().with_epoch(crate::Epoch::mint())) + .announce( + Path::new("cam").unwrap(), + crate::origin::Route::default().with_epoch(crate::Epoch::mint()), + ) .unwrap(); settle().await; @@ -14842,7 +14890,9 @@ mod tests { let consumer = origin.consume(); // Announced before the peer subscribes: it must only hit the wire after. - let early = origin.announce(Path::new("early-cam").unwrap(), crate::origin::Route::default()).unwrap(); + let early = origin + .announce(Path::new("early-cam").unwrap(), crate::origin::Route::default()) + .unwrap(); settle().await; // Stream 1 is the peer's SUBSCRIBE_NAMESPACE (the peer stays quiet after); @@ -14886,7 +14936,9 @@ mod tests { ); // A later announce reaches the same subscription. - let _late = origin.announce(Path::new("late-cam").unwrap(), crate::origin::Route::default()).unwrap(); + let _late = origin + .announce(Path::new("late-cam").unwrap(), crate::origin::Route::default()) + .unwrap(); for _ in 0..100 { assert!(futures::poll!(run.as_mut()).is_pending()); if occurrences(&log, b"late-cam") >= 1 { @@ -14928,7 +14980,9 @@ mod tests { const VERSION: Version = Version::Draft17; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _local = origin.announce(Path::new("local-cam").unwrap(), crate::origin::Route::default()).unwrap(); + let _local = origin + .announce(Path::new("local-cam").unwrap(), crate::origin::Route::default()) + .unwrap(); settle().await; // The only stream is the PUBLISH_NAMESPACE request we open ourselves. @@ -14972,7 +15026,9 @@ mod tests { async fn publish_namespace_withdraws_by_reset_from_draft_17() { for version in [Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft22] { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let local = origin.announce(Path::new("local-cam").unwrap(), crate::origin::Route::default()).unwrap(); + let local = origin + .announce(Path::new("local-cam").unwrap(), crate::origin::Route::default()) + .unwrap(); settle().await; let session = @@ -15036,7 +15092,9 @@ mod tests { const VERSION: Version = Version::Draft17; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _local = origin.announce(Path::new("local-cam").unwrap(), crate::origin::Route::default()).unwrap(); + let _local = origin + .announce(Path::new("local-cam").unwrap(), crate::origin::Route::default()) + .unwrap(); settle().await; let ok = crate::lite::test_transport::Log::default(); @@ -15128,8 +15186,12 @@ mod tests { scoped, } = case; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _cam = origin.announce(Path::new("cam").unwrap(), crate::origin::Route::default()).unwrap(); - let _stats = origin.announce(Path::new(".stats/node").unwrap(), crate::origin::Route::default()).unwrap(); + let _cam = origin + .announce(Path::new("cam").unwrap(), crate::origin::Route::default()) + .unwrap(); + let _stats = origin + .announce(Path::new(".stats/node").unwrap(), crate::origin::Route::default()) + .unwrap(); settle().await; // Stream 1 is the peer's SUBSCRIBE_NAMESPACE; stream 2, if opened at all, is our @@ -15149,7 +15211,10 @@ mod tests { let consume = match scoped { true => origin .consume() - .scope(Path::new("").unwrap(), &crate::Pattern::subtree(".stats").unwrap().into()) + .scope( + Path::new("").unwrap(), + &crate::Pattern::subtree(".stats").unwrap().into(), + ) .unwrap(), false => origin.consume(), }; @@ -15303,7 +15368,9 @@ mod tests { async fn a_non_solicit_subscribe_namespace_carries_namespace() { for version in [Version::Draft16, Version::Draft18] { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let early = origin.announce(Path::new("early-cam").unwrap(), crate::origin::Route::default()).unwrap(); + let early = origin + .announce(Path::new("early-cam").unwrap(), crate::origin::Route::default()) + .unwrap(); settle().await; let session = crate::lite::test_transport::ScriptedSession::per_stream(vec![Vec::new()]); @@ -15346,7 +15413,9 @@ mod tests { "{version:?}: existing match", ); - let _late = origin.announce(Path::new("late-cam").unwrap(), crate::origin::Route::default()).unwrap(); + let _late = origin + .announce(Path::new("late-cam").unwrap(), crate::origin::Route::default()) + .unwrap(); for _ in 0..100 { assert!(futures::poll!(run.as_mut()).is_pending()); if occurrences(&log, b"late-cam") >= 1 { @@ -15395,7 +15464,9 @@ mod tests { const VERSION: Version = Version::Draft14; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let first = origin.announce(Path::new("first-cam").unwrap(), crate::origin::Route::default()).unwrap(); + let first = origin + .announce(Path::new("first-cam").unwrap(), crate::origin::Route::default()) + .unwrap(); settle().await; // The first advertisement has send capacity, and the peer answers it. @@ -15430,7 +15501,9 @@ mod tests { // Send capacity runs out before the second advertisement can send its header. set_gate(&gate, false); - let _second = origin.announce(Path::new("second-cam").unwrap(), crate::origin::Route::default()).unwrap(); + let _second = origin + .announce(Path::new("second-cam").unwrap(), crate::origin::Route::default()) + .unwrap(); settle().await; // Retiring the first needs no new stream, so the loop has to reach @@ -15520,7 +15593,10 @@ mod tests { // One epoch, so the second route re-prices the instance rather than restart it. let epoch = crate::Epoch::mint(); let cam = origin - .announce(Path::new("solo-cam").unwrap(), crate::origin::Route::default().with_epoch(epoch.clone())) + .announce( + Path::new("solo-cam").unwrap(), + crate::origin::Route::default().with_epoch(epoch.clone()), + ) .unwrap(); settle().await; @@ -15695,7 +15771,10 @@ mod tests { // We start carrying it: a free route outranks the cold one. let _warm = origin - .announce(Path::new("cam").unwrap(), crate::origin::Route::default().with_epoch(epoch).with_cost(0)) + .announce( + Path::new("cam").unwrap(), + crate::origin::Route::default().with_epoch(epoch).with_cost(0), + ) .unwrap(); // The request consumed id 1, so the update takes the next of our parity. The @@ -15786,7 +15865,10 @@ mod tests { peer.push(&counted); // Repricing sends the REQUEST_UPDATE whose OK is counted. let _warm = origin - .announce(Path::new("cam").unwrap(), crate::origin::Route::default().with_epoch(epoch).with_cost(0)) + .announce( + Path::new("cam").unwrap(), + crate::origin::Route::default().with_epoch(epoch).with_cost(0), + ) .unwrap(); let res = moq_clock::timeout(Duration::from_secs(5), run) @@ -15961,7 +16043,10 @@ mod tests { .present(bytes::Bytes::from_static(b"second-secret"), false) .unwrap(); let cam = origin - .announce(Path::new("cam").unwrap(), crate::origin::Route::default().with_auth(first)) + .announce( + Path::new("cam").unwrap(), + crate::origin::Route::default().with_auth(first), + ) .unwrap(); settle().await; @@ -16032,7 +16117,10 @@ mod tests { .present(bytes::Bytes::from_static(b"second-secret"), false) .unwrap(); let cam = origin - .announce(Path::new("cam").unwrap(), crate::origin::Route::default().with_auth(first)) + .announce( + Path::new("cam").unwrap(), + crate::origin::Route::default().with_auth(first), + ) .unwrap(); settle().await; @@ -16075,7 +16163,10 @@ mod tests { .present(bytes::Bytes::from_static(b"second-secret"), false) .unwrap(); let cam = origin - .announce(Path::new("cam").unwrap(), crate::origin::Route::default().with_auth(first)) + .announce( + Path::new("cam").unwrap(), + crate::origin::Route::default().with_auth(first), + ) .unwrap(); settle().await; @@ -16121,7 +16212,10 @@ mod tests { .present(bytes::Bytes::from_static(b"foreign-secret"), false) .unwrap(); let _cam = origin - .announce(Path::new("cam").unwrap(), crate::origin::Route::default().with_auth(foreign)) + .announce( + Path::new("cam").unwrap(), + crate::origin::Route::default().with_auth(foreign), + ) .unwrap(); settle().await; @@ -16147,7 +16241,9 @@ mod tests { let origin = unheld_origin(); let auth = crate::auth::Link::ietf(false); let token = auth.present(bytes::Bytes::from_static(b"late-secret"), false).unwrap(); - let cam = origin.announce(Path::new("cam").unwrap(), crate::origin::Route::default()).unwrap(); + let cam = origin + .announce(Path::new("cam").unwrap(), crate::origin::Route::default()) + .unwrap(); settle().await; let ok = publish_namespace_ok(VERSION).await; @@ -16177,7 +16273,10 @@ mod tests { .present(bytes::Bytes::from_static(b"second-secret"), false) .unwrap(); let cam = origin - .announce(Path::new("cam").unwrap(), crate::origin::Route::default().with_auth(first)) + .announce( + Path::new("cam").unwrap(), + crate::origin::Route::default().with_auth(first), + ) .unwrap(); settle().await; @@ -16208,10 +16307,16 @@ mod tests { let auth = crate::auth::Link::ietf(false); let present = |token: &'static [u8]| auth.present(bytes::Bytes::from_static(token), false).unwrap(); let a = origin - .announce(Path::new("cam-a").unwrap(), crate::origin::Route::default().with_auth(present(b"a-first"))) + .announce( + Path::new("cam-a").unwrap(), + crate::origin::Route::default().with_auth(present(b"a-first")), + ) .unwrap(); let b = origin - .announce(Path::new("cam-b").unwrap(), crate::origin::Route::default().with_auth(present(b"b-first"))) + .announce( + Path::new("cam-b").unwrap(), + crate::origin::Route::default().with_auth(present(b"b-first")), + ) .unwrap(); settle().await; @@ -16235,7 +16340,9 @@ mod tests { "cam-b's renewal waited on cam-a's answer" ); - let _c = origin.announce(Path::new("cam-c").unwrap(), crate::origin::Route::default()).unwrap(); + let _c = origin + .announce(Path::new("cam-c").unwrap(), crate::origin::Route::default()) + .unwrap(); poll_until(&mut run, &log, b"cam-c", 1).await; assert_eq!( occurrences(&log, b"cam-c"), @@ -16254,7 +16361,9 @@ mod tests { for fin in [true, false] { let origin = unheld_origin(); - let _cam = origin.announce(Path::new("cam").unwrap(), crate::origin::Route::default()).unwrap(); + let _cam = origin + .announce(Path::new("cam").unwrap(), crate::origin::Route::default()) + .unwrap(); settle().await; let (session, peer) = memory::pair(memory::Config::default()); @@ -16322,7 +16431,14 @@ mod tests { let origin = unheld_origin(); let mut cams: HashMap<&str, _> = ["a-cam", "b-cam"] .into_iter() - .map(|name| (name, origin.announce(Path::new(name).unwrap(), crate::origin::Route::default()).unwrap())) + .map(|name| { + ( + name, + origin + .announce(Path::new(name).unwrap(), crate::origin::Route::default()) + .unwrap(), + ) + }) .collect(); settle().await; @@ -16411,7 +16527,10 @@ mod tests { let auth = crate::auth::Link::ietf(false); let token = auth.present(bytes::Bytes::from(vec![0; 70_000]), false).unwrap(); let _cam = origin - .announce(Path::new("cam").unwrap(), crate::origin::Route::default().with_auth(token)) + .announce( + Path::new("cam").unwrap(), + crate::origin::Route::default().with_auth(token), + ) .unwrap(); settle().await; @@ -16476,7 +16595,10 @@ mod tests { let auth = crate::auth::Link::ietf(false); let present = |token: &'static [u8]| auth.present(bytes::Bytes::from_static(token), false).unwrap(); let cam = origin - .announce(Path::new("cam").unwrap(), crate::origin::Route::default().with_auth(present(b"first"))) + .announce( + Path::new("cam").unwrap(), + crate::origin::Route::default().with_auth(present(b"first")), + ) .unwrap(); settle().await; @@ -16531,7 +16653,10 @@ mod tests { let auth = crate::auth::Link::ietf(false); let present = |token: &'static [u8]| auth.present(bytes::Bytes::from_static(token), false).unwrap(); let cam = origin - .announce(Path::new("cam").unwrap(), crate::origin::Route::default().with_auth(present(b"first"))) + .announce( + Path::new("cam").unwrap(), + crate::origin::Route::default().with_auth(present(b"first")), + ) .unwrap(); settle().await; @@ -16667,7 +16792,10 @@ mod tests { peer.push(&refusal); let _warm = origin - .announce(Path::new("cam").unwrap(), crate::origin::Route::default().with_epoch(epoch).with_cost(0)) + .announce( + Path::new("cam").unwrap(), + crate::origin::Route::default().with_epoch(epoch).with_cost(0), + ) .unwrap(); for _ in 0..100 { @@ -16698,7 +16826,9 @@ mod tests { async fn close_withdraws_legacy_namespaces_without_closing_the_origin() { const VERSION: Version = Version::Draft14; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _cam = origin.announce(Path::new("closing-cam").unwrap(), crate::origin::Route::default()).unwrap(); + let _cam = origin + .announce(Path::new("closing-cam").unwrap(), crate::origin::Route::default()) + .unwrap(); settle().await; let session = crate::lite::test_transport::ScriptedSession::per_stream(vec![publish_namespace_ok(VERSION).await]); @@ -16742,8 +16872,12 @@ mod tests { const VERSION: Version = Version::Draft14; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _first = origin.announce(Path::new("first-cam").unwrap(), crate::origin::Route::default()).unwrap(); - let _second = origin.announce(Path::new("second-cam").unwrap(), crate::origin::Route::default()).unwrap(); + let _first = origin + .announce(Path::new("first-cam").unwrap(), crate::origin::Route::default()) + .unwrap(); + let _second = origin + .announce(Path::new("second-cam").unwrap(), crate::origin::Route::default()) + .unwrap(); settle().await; // Every stream opens and then goes silent: an exhausted script parks rather than @@ -16789,7 +16923,9 @@ mod tests { async fn an_unanswered_advertisement_is_withdrawn() { for version in [Version::Draft14, Version::Draft15, Version::Draft16, Version::Draft17] { let origin = unheld_origin(); - let _cam = origin.announce(Path::new("cam").unwrap(), crate::origin::Route::default()).unwrap(); + let _cam = origin + .announce(Path::new("cam").unwrap(), crate::origin::Route::default()) + .unwrap(); settle().await; // The peer takes the request and answers nothing. @@ -16842,7 +16978,9 @@ mod tests { Version::Draft19, ] { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _cam = origin.announce(Path::new("lonely-cam").unwrap(), crate::origin::Route::default()).unwrap(); + let _cam = origin + .announce(Path::new("lonely-cam").unwrap(), crate::origin::Route::default()) + .unwrap(); settle().await; let session = crate::lite::test_transport::ScriptedSession::new(publish_namespace_ok(version).await).without_credit(); @@ -16893,7 +17031,9 @@ mod tests { const VERSION: Version = Version::Draft14; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _cam = origin.announce(Path::new("lonely-cam").unwrap(), crate::origin::Route::default()).unwrap(); + let _cam = origin + .announce(Path::new("lonely-cam").unwrap(), crate::origin::Route::default()) + .unwrap(); settle().await; // No send capacity from the start: an admitted header cannot finish. diff --git a/rs/moq-net/src/ietf/publisher/tracks.rs b/rs/moq-net/src/ietf/publisher/tracks.rs index 09ba76141ad..229052f6cca 100644 --- a/rs/moq-net/src/ietf/publisher/tracks.rs +++ b/rs/moq-net/src/ietf/publisher/tracks.rs @@ -1347,7 +1347,9 @@ mod tests { fn harness_with(version: Version, config: memory::Config, declared: peer::Peer) -> Harness { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let broadcast = origin.publish(Path::new("room/cam").unwrap(), crate::origin::Route::default()).unwrap(); + let broadcast = origin + .publish(Path::new("room/cam").unwrap(), crate::origin::Route::default()) + .unwrap(); let tracks = ["video", "audio"] .into_iter() .map(|name| (name, broadcast.create_track(name, crate::track::Info::timed()).unwrap())) @@ -1514,7 +1516,10 @@ mod tests { let (_stream, _, name, _) = h.publish().await; assert_eq!(name, "captions", "{version}"); - let mic = h._origin.publish(Path::new("room/mic").unwrap(), crate::origin::Route::default()).unwrap(); + let mic = h + ._origin + .publish(Path::new("room/mic").unwrap(), crate::origin::Route::default()) + .unwrap(); let _audio = mic.create_track("audio", crate::track::Info::timed()).unwrap(); let (_stream, namespace, name, _) = h.publish().await; assert_eq!((namespace.as_str(), name.as_str()), ("room/mic", "audio"), "{version}"); @@ -2506,7 +2511,10 @@ mod tests { moq_clock::sleep(Duration::from_millis(10)).await; // A new instance takes the path while the old one goes on: only its route ends. - let _restarted = h._origin.publish(Path::new("room/cam").unwrap(), crate::origin::Route::default()).unwrap(); + let _restarted = h + ._origin + .publish(Path::new("room/cam").unwrap(), crate::origin::Route::default()) + .unwrap(); let (id, body) = next(&mut stream).await; assert_eq!(id, ietf::PublishDone::ID, "{version}"); let done: ietf::PublishDone = body.message(version).unwrap(); diff --git a/rs/moq-net/src/ietf/session.rs b/rs/moq-net/src/ietf/session.rs index 6e25aac32d6..7f4cc2cf24d 100644 --- a/rs/moq-net/src/ietf/session.rs +++ b/rs/moq-net/src/ietf/session.rs @@ -2043,7 +2043,10 @@ mod tests { fn watch(origin: &crate::origin::Producer, prefix: &str) -> crate::announce::Consumer { origin .consume() - .scope(Path::new(prefix).unwrap(), &crate::Patterns::from(crate::Pattern::all())) + .scope( + Path::new(prefix).unwrap(), + &crate::Patterns::from(crate::Pattern::all()), + ) .unwrap() .announced() } @@ -2344,7 +2347,9 @@ mod tests { /// enough: the question is only whether the bytes went out unasked. async fn announce_occurrences(peer_declared: Option) -> usize { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _cam = origin.announce(Path::new("solo-cam").unwrap(), crate::origin::Route::default()).unwrap(); + let _cam = origin + .announce(Path::new("solo-cam").unwrap(), crate::origin::Route::default()) + .unwrap(); // An open gate: an unsolicited PUBLISH_NAMESPACE can reach the wire. let gate = kio::Producer::new(true); @@ -2450,7 +2455,9 @@ mod tests { fn auth_session(auth: bool) -> AuthSession { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let cam = origin.announce(Path::new("solo-cam").unwrap(), crate::origin::Route::default()).unwrap(); + let cam = origin + .announce(Path::new("solo-cam").unwrap(), crate::origin::Route::default()) + .unwrap(); let gate = kio::Producer::new(true); let session = crate::lite::test_transport::SinkSession::gated_bi(gate.consume()); @@ -3011,7 +3018,9 @@ mod tests { // Stall before the type, then after it while the body has not arrived. for stalled in [Vec::new(), vec![ietf::Subscribe::ID as u8]] { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let broadcast = origin.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); + let broadcast = origin + .publish(Path::new("room").unwrap(), crate::origin::Route::default()) + .unwrap(); let mut track = broadcast.create_track("video", None).unwrap(); let session = crate::lite::test_transport::ScriptedSession::new(Vec::new()) .with_incoming_bidis(vec![stalled, subscribe.clone()]); diff --git a/rs/moq-net/src/ietf/subscriber.rs b/rs/moq-net/src/ietf/subscriber.rs index 9203afd2935..5cba1e443f9 100644 --- a/rs/moq-net/src/ietf/subscriber.rs +++ b/rs/moq-net/src/ietf/subscriber.rs @@ -6334,7 +6334,9 @@ mod tests { async fn a_rooted_subscriber_asks_for_its_scope_not_its_root() { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let scope = crate::Patterns::from(crate::Pattern::subtree("cam").unwrap()); - let scoped = origin.scope(Path::new("rootns").unwrap(), &scope).expect("scope the origin"); + let scoped = origin + .scope(Path::new("rootns").unwrap(), &scope) + .expect("scope the origin"); let gate = kio::Producer::new(true); let session = crate::lite::test_transport::SinkSession::gated_bi(gate.consume()); @@ -6424,7 +6426,9 @@ mod tests { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let consumer = origin.consume(); let scope = crate::Patterns::from(crate::Pattern::subtree("cam").unwrap()); - let scoped = origin.scope(Path::new("rootns").unwrap(), &scope).expect("scope the origin"); + let scoped = origin + .scope(Path::new("rootns").unwrap(), &scope) + .expect("scope the origin"); let session = crate::lite::test_transport::ScriptedSession::new(namespace_response(VERSION, "x.hang").await); let (tasks, _task_set) = crate::util::TaskSet::new(); @@ -6849,8 +6853,12 @@ mod tests { let stream = Stream::open(&mut crate::driver::Transport::new(session.clone()), VERSION) .await .unwrap(); - let mut run = - std::pin::pin!(subscriber.run_subscribe_namespace(stream, crate::Path::new("").unwrap().to_owned(), snapshot, live)); + let mut run = std::pin::pin!(subscriber.run_subscribe_namespace( + stream, + crate::Path::new("").unwrap().to_owned(), + snapshot, + live + )); for _ in 0..10 { assert!(futures::poll!(run.as_mut()).is_pending()); settle().await; @@ -8577,8 +8585,14 @@ mod tests { for version in [Version::Draft18, Version::Draft19, Version::Draft22] { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let source = origin.publish(Path::new("broadcast").unwrap(), Default::default()).unwrap(); - let resolved = origin.consume().request_broadcast(Path::new("broadcast").unwrap(), None).await.unwrap(); + let source = origin + .publish(Path::new("broadcast").unwrap(), Default::default()) + .unwrap(); + let resolved = origin + .consume() + .request_broadcast(Path::new("broadcast").unwrap(), None) + .await + .unwrap(); let peer = Arc::new(Peer { version, dynamic: Mutex::new(Some(source.dynamic())), @@ -8915,7 +8929,11 @@ mod tests { let advert = subscriber.route(None, &cluster::Peer::default()).expect("route"); subscriber - .start_announce(crate::Path::new("room/host").unwrap().to_owned(), advert, Admit::Session(None)) + .start_announce( + crate::Path::new("room/host").unwrap().to_owned(), + advert, + Admit::Session(None), + ) .unwrap(); let mut announced = consumer.announced(); @@ -8952,7 +8970,10 @@ mod tests { // What we are publishing to the peer: a real upstream route. let upstream = crate::Hops::try_from(vec![crate::Hop::new(7).unwrap()]).unwrap(); let _source = origin - .announce(Path::new("room/host").unwrap(), crate::origin::Route::default().with_hops(upstream.clone())) + .announce( + Path::new("room/host").unwrap(), + crate::origin::Route::default().with_hops(upstream.clone()), + ) .unwrap(); announced.expect_next_active(Path::new("room/host").unwrap()).await; let _advertised = publishing.expect_next_active(Path::new("room/host").unwrap()).await; @@ -8975,7 +8996,11 @@ mod tests { ); let advert = subscriber.route(None, &cluster::Peer::default()).expect("route"); subscriber - .start_announce(crate::Path::new("room/host").unwrap().to_owned(), advert, Admit::Session(None)) + .start_announce( + crate::Path::new("room/host").unwrap().to_owned(), + advert, + Admit::Session(None), + ) .unwrap(); // No announce churn: the upstream route stays the best one, on both cursors. @@ -9015,7 +9040,11 @@ mod tests { ); let advert = subscriber.route(None, &cluster::Peer::default()).expect("route"); subscriber - .start_announce(crate::Path::new("room/host").unwrap().to_owned(), advert, Admit::Session(None)) + .start_announce( + crate::Path::new("room/host").unwrap().to_owned(), + advert, + Admit::Session(None), + ) .unwrap(); subscriber }; @@ -13231,7 +13260,9 @@ mod stitch_tests { ) -> (Vec, crate::lite::test_transport::Log) { use crate::lite::test_transport::Sent; let origin = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); - let broadcast = origin.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); + let broadcast = origin + .publish(Path::new("room").unwrap(), crate::origin::Route::default()) + .unwrap(); let track = broadcast .create_track( "video", @@ -14000,7 +14031,9 @@ mod stitch_tests { { { let origin = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); - let broadcast = origin.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); + let broadcast = origin + .publish(Path::new("room").unwrap(), crate::origin::Route::default()) + .unwrap(); let track = broadcast .create_track("video", accepted_info(&Default::default(), version)) .unwrap(); @@ -14130,7 +14163,9 @@ mod stitch_tests { .flat_map(|egress| [END_OF_GROUP, END_OF_TRACK].map(|status| (egress, status))); for (egress, status) in pairs { let origin = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); - let broadcast = origin.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); + let broadcast = origin + .publish(Path::new("room").unwrap(), crate::origin::Route::default()) + .unwrap(); let track = broadcast .create_track("video", accepted_info(&Default::default(), ingress)) .unwrap(); @@ -15928,7 +15963,8 @@ mod joining_fetch_tests { let track = consumer.track("video").unwrap(); let mut subscribing = Box::pin(track.subscribe(None)); let request = dynamic.requested_track().await.unwrap(); - let mut serving = Box::pin(subscriber.run_subscribe(Path::new("broadcast").unwrap(), dynamic, None, request)); + let mut serving = + Box::pin(subscriber.run_subscribe(Path::new("broadcast").unwrap(), dynamic, None, request)); assert!(futures::poll!(serving.as_mut()).is_pending()); let received = (&mut subscribing).now_or_never().expect("SUBSCRIBE_OK").unwrap(); let mut fetch = Box::pin(track.fetch_group(4, None)); @@ -16643,7 +16679,12 @@ mod joining_fetch_tests { subscriber .clone() - .run_group_fetch(Path::new("broadcast").unwrap().to_owned(), "video".into(), request, None) + .run_group_fetch( + Path::new("broadcast").unwrap().to_owned(), + "video".into(), + request, + None, + ) .await; assert!(fetch.await.is_err(), "the accepted group was aborted"); @@ -16715,7 +16756,12 @@ mod joining_fetch_tests { subscriber .clone() - .run_group_fetch(Path::new("broadcast").unwrap().to_owned(), "video".into(), request, None) + .run_group_fetch( + Path::new("broadcast").unwrap().to_owned(), + "video".into(), + request, + None, + ) .await; assert_eq!( diff --git a/rs/moq-net/src/lite/announce.rs b/rs/moq-net/src/lite/announce.rs index 7d687f69b3c..e9dce4637c0 100644 --- a/rs/moq-net/src/lite/announce.rs +++ b/rs/moq-net/src/lite/announce.rs @@ -1008,7 +1008,8 @@ mod tests { #[test] fn unknown_announce_type_is_skipped() { let mut body = Vec::new(); - Path::new("room/cam").unwrap() + Path::new("room/cam") + .unwrap() .encode(&mut Encoder::new(&mut body, Version::Lite06.into()), Version::Lite06) .unwrap(); Hops::new() @@ -1075,7 +1076,8 @@ mod tests { fn announce_request_rejects_a_bad_hidden_flag() { let mut buf = Vec::new(); let mut body = Vec::new(); - Path::new("room").unwrap() + Path::new("room") + .unwrap() .encode(&mut Encoder::new(&mut body, Version::Lite07.into()), Version::Lite07) .unwrap(); body.push(2); diff --git a/rs/moq-net/src/lite/ietf.rs b/rs/moq-net/src/lite/ietf.rs index a4fd7018cff..2bcde66a899 100644 --- a/rs/moq-net/src/lite/ietf.rs +++ b/rs/moq-net/src/lite/ietf.rs @@ -1136,10 +1136,13 @@ mod hop_tests { } async fn subscribe(origin: &crate::origin::Producer) -> (track::Consumer, track::Subscriber) { - let broadcast = moq_clock::timeout(TIMEOUT, origin.consume().request_broadcast(Path::new("room").unwrap(), None)) - .await - .expect("no broadcast") - .unwrap(); + let broadcast = moq_clock::timeout( + TIMEOUT, + origin.consume().request_broadcast(Path::new("room").unwrap(), None), + ) + .await + .expect("no broadcast") + .unwrap(); let track = broadcast.track("video").unwrap(); let subscriber = moq_clock::timeout(TIMEOUT, track.subscribe(None)) .await @@ -1165,7 +1168,9 @@ mod hop_tests { for offer in [[true, true], [true, false], [false, true]] { let negotiated = offer == [true, true]; let upstream = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); - let broadcast = upstream.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); + let broadcast = upstream + .publish(Path::new("room").unwrap(), crate::origin::Route::default()) + .unwrap(); let mut info = track::Info::timed().with_timescale(Timescale::MILLI); info.max_age = Some(Duration::from_secs(7)); info.priority = 9; @@ -1277,14 +1282,19 @@ mod hop_tests { /// Subscribe across a negotiated hop to a track with `info`. async fn subscribe_across_info(info: track::Info) -> Result<(), crate::Error> { let upstream = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); - let broadcast = upstream.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); + let broadcast = upstream + .publish(Path::new("room").unwrap(), crate::origin::Route::default()) + .unwrap(); let _track = broadcast.create_track("video", info).unwrap(); let (downstream, _sessions) = test_hop(&upstream, "room", [true, true]).await; - let broadcast = moq_clock::timeout(TIMEOUT, downstream.consume().request_broadcast(Path::new("room").unwrap(), None)) - .await - .expect("no broadcast") - .unwrap(); + let broadcast = moq_clock::timeout( + TIMEOUT, + downstream.consume().request_broadcast(Path::new("room").unwrap(), None), + ) + .await + .expect("no broadcast") + .unwrap(); moq_clock::timeout(TIMEOUT, broadcast.track("video").unwrap().subscribe(None)) .await .expect("no answer") @@ -1386,7 +1396,9 @@ mod hop_tests { #[moq_clock::test] async fn plain_media_crosses_unchanged() { let upstream = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); - let broadcast = upstream.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); + let broadcast = upstream + .publish(Path::new("room").unwrap(), crate::origin::Route::default()) + .unwrap(); let mut track = broadcast .create_track("video", track::Info::timed().with_timescale(Timescale::MILLI)) .unwrap(); @@ -1429,7 +1441,9 @@ mod hop_tests { for offer in [[true, true], [true, false], [false, true]] { let negotiated = offer == [true, true]; let upstream = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); - let broadcast = upstream.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); + let broadcast = upstream + .publish(Path::new("room").unwrap(), crate::origin::Route::default()) + .unwrap(); let info = track::Info { properties: draft22(Vec::new()), ..track::Info::timed() @@ -1439,7 +1453,11 @@ mod hop_tests { head.write_frame(ts(100), b"frame".to_vec()).unwrap(); head.finish().unwrap(); let (downstream, sessions) = test_hop(&upstream, "room", offer).await; - let broadcast = downstream.consume().request_broadcast(Path::new("room").unwrap(), None).await.unwrap(); + let broadcast = downstream + .consume() + .request_broadcast(Path::new("room").unwrap(), None) + .await + .unwrap(); // A listing cannot carry the provenance, so it lists the track untimed even when // negotiated: a relay re-listing it would otherwise advertise it as native lite. let mut tracks = broadcast.tracks().unwrap(); @@ -1500,7 +1518,9 @@ mod hop_tests { #[moq_clock::test] async fn compressed_media_crosses_a_negotiated_hop() { let upstream = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); - let broadcast = upstream.publish(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap(); + let broadcast = upstream + .publish(Path::new("room").unwrap(), crate::origin::Route::default()) + .unwrap(); let info = track::Info::timed() .with_timescale(Timescale::MILLI) .with_compress(true); diff --git a/rs/moq-net/src/lite/publisher.rs b/rs/moq-net/src/lite/publisher.rs index 883d3d4fc33..896ffac3021 100644 --- a/rs/moq-net/src/lite/publisher.rs +++ b/rs/moq-net/src/lite/publisher.rs @@ -2576,15 +2576,22 @@ mod announce_test { .collect(); assert_eq!( initial, - vec![(Path::new("a").unwrap(), origin::Cost::new(3)), (Path::new("b").unwrap(), origin::Cost::new(6))] + vec![ + (Path::new("a").unwrap(), origin::Cost::new(3)), + (Path::new("b").unwrap(), origin::Cost::new(6)) + ] ); } #[test] fn synced_survives_a_removed_initial_route_and_live_churn() { let origin = Hop::new(1).unwrap().produce(); - let removed = origin.announce(Path::new("z/removed").unwrap(), origin::Route::default()).unwrap(); - let _initial = origin.announce(Path::new("z/retained").unwrap(), origin::Route::default()).unwrap(); + let removed = origin + .announce(Path::new("z/removed").unwrap(), origin::Route::default()) + .unwrap(); + let _initial = origin + .announce(Path::new("z/retained").unwrap(), origin::Route::default()) + .unwrap(); let consumer = origin.consume(); let mut announced = consumer.announced(); let budget = kio::Producer::new(0usize); @@ -2601,13 +2608,21 @@ mod announce_test { ), reader: Reader::new(crate::transport::boxed::RecvStream::new(PendingRecv), Version::Lite07), }; - let mut run = AnnounceRun::new(crate::Path::new("").unwrap().to_owned(), consumer.hop(), Version::Lite07); + let mut run = AnnounceRun::new( + crate::Path::new("").unwrap().to_owned(), + consumer.hop(), + Version::Lite07, + ); let waiter = kio::Waiter::noop(); assert!(run.poll(&mut stream, &consumer, &mut announced, &waiter).is_pending()); drop(removed); let mut churn = Vec::new(); for limit in 1..=4 { - churn.push(origin.announce(Path::try_from(format!("a/{limit}")).unwrap(), origin::Route::default()).unwrap()); + churn.push( + origin + .announce(Path::try_from(format!("a/{limit}")).unwrap(), origin::Route::default()) + .unwrap(), + ); *budget.write().ok().unwrap() = limit; assert!(run.poll(&mut stream, &consumer, &mut announced, &waiter).is_pending()); } @@ -2625,8 +2640,12 @@ mod announce_test { #[test] fn a_partial_regrant_cannot_overtake_an_initial_route() { let origin = Hop::new(1).unwrap().produce(); - let _a = origin.announce(Path::new("a").unwrap(), origin::Route::default()).unwrap(); - let _b = origin.announce(Path::new("b").unwrap(), origin::Route::default()).unwrap(); + let _a = origin + .announce(Path::new("a").unwrap(), origin::Route::default()) + .unwrap(); + let _b = origin + .announce(Path::new("b").unwrap(), origin::Route::default()) + .unwrap(); let consumer = origin.consume(); let mut announced = consumer.announced(); let budget = kio::Producer::new(1usize); @@ -2643,7 +2662,11 @@ mod announce_test { ), reader: Reader::new(crate::transport::boxed::RecvStream::new(PendingRecv), Version::Lite07), }; - let mut run = AnnounceRun::new(crate::Path::new("").unwrap().to_owned(), consumer.hop(), Version::Lite07); + let mut run = AnnounceRun::new( + crate::Path::new("").unwrap().to_owned(), + consumer.hop(), + Version::Lite07, + ); let waiter = kio::Waiter::noop(); assert!(run.poll(&mut stream, &consumer, &mut announced, &waiter).is_pending()); let auth = crate::auth::Link::new(false); @@ -2667,8 +2690,12 @@ mod announce_test { #[test] fn synced_cuts_a_regrant_burst_at_the_initial_bound() { let origin = Hop::new(1).unwrap().produce(); - let _a = origin.announce(Path::new("a").unwrap(), origin::Route::default()).unwrap(); - let _b = origin.announce(Path::new("b").unwrap(), origin::Route::default()).unwrap(); + let _a = origin + .announce(Path::new("a").unwrap(), origin::Route::default()) + .unwrap(); + let _b = origin + .announce(Path::new("b").unwrap(), origin::Route::default()) + .unwrap(); let consumer = origin.consume(); let mut announced = consumer.announced(); let budget = kio::Producer::new(0usize); @@ -2685,7 +2712,11 @@ mod announce_test { ), reader: Reader::new(crate::transport::boxed::RecvStream::new(PendingRecv), Version::Lite07), }; - let mut run = AnnounceRun::new(crate::Path::new("").unwrap().to_owned(), consumer.hop(), Version::Lite07); + let mut run = AnnounceRun::new( + crate::Path::new("").unwrap().to_owned(), + consumer.hop(), + Version::Lite07, + ); let waiter = kio::Waiter::noop(); assert!(run.poll(&mut stream, &consumer, &mut announced, &waiter).is_pending()); let auth = crate::auth::Link::new(false); @@ -2694,7 +2725,9 @@ mod announce_test { panic!("the changed grant is ready"); }; run.regrant(&mut stream, &consumer, restricted).unwrap(); - let _live = origin.announce(Path::new("c").unwrap(), origin::Route::default()).unwrap(); + let _live = origin + .announce(Path::new("c").unwrap(), origin::Route::default()) + .unwrap(); run.regrant(&mut stream, &consumer, crate::auth::Permit::default()) .unwrap(); *budget.write().ok().unwrap() = 4; @@ -2723,8 +2756,12 @@ mod announce_test { #[test] fn a_seen_retraction_can_precede_synced() { let origin = Hop::new(1).unwrap().produce(); - let first = origin.announce(Path::new("a").unwrap(), origin::Route::default()).unwrap(); - let unseen = origin.announce(Path::new("b").unwrap(), origin::Route::default()).unwrap(); + let first = origin + .announce(Path::new("a").unwrap(), origin::Route::default()) + .unwrap(); + let unseen = origin + .announce(Path::new("b").unwrap(), origin::Route::default()) + .unwrap(); let consumer = origin.consume(); let mut announced = consumer.announced(); let budget = kio::Producer::new(1usize); @@ -2741,7 +2778,11 @@ mod announce_test { ), reader: Reader::new(crate::transport::boxed::RecvStream::new(PendingRecv), Version::Lite07), }; - let mut run = AnnounceRun::new(crate::Path::new("").unwrap().to_owned(), consumer.hop(), Version::Lite07); + let mut run = AnnounceRun::new( + crate::Path::new("").unwrap().to_owned(), + consumer.hop(), + Version::Lite07, + ); let waiter = kio::Waiter::noop(); assert!(run.poll(&mut stream, &consumer, &mut announced, &waiter).is_pending()); drop(unseen); @@ -2781,7 +2822,11 @@ mod announce_test { ), reader: Reader::new(crate::transport::boxed::RecvStream::new(PendingRecv), Version::Lite07), }; - let mut run = AnnounceRun::new(crate::Path::new("").unwrap().to_owned(), consumer.hop(), Version::Lite07); + let mut run = AnnounceRun::new( + crate::Path::new("").unwrap().to_owned(), + consumer.hop(), + Version::Lite07, + ); assert!( run.poll(&mut stream, &consumer, &mut announced, &kio::Waiter::noop()) .is_pending() @@ -2880,9 +2925,14 @@ mod announce_test { #[moq_clock::test] async fn a_silent_upstream_never_delays_the_answer() { let origin = Hop::new(1).unwrap().produce(); - let _route = origin.announce(Path::new("cam").unwrap(), crate::origin::Route::default()).unwrap(); + let _route = origin + .announce(Path::new("cam").unwrap(), crate::origin::Route::default()) + .unwrap(); // An upstream that never answers its announce request. - let _silent = origin.clone().with_link(crate::origin::Link::Upstream).snapshot(Path::new("").unwrap()); + let _silent = origin + .clone() + .with_link(crate::origin::Link::Upstream) + .snapshot(Path::new("").unwrap()); let log = Log::default(); let writes = log.writes.clone(); @@ -2971,7 +3021,10 @@ mod announce_test { let late = h .origin - .announce(Path::new("mic").unwrap(), crate::origin::Route::default().with_hops(pub_hops())) + .announce( + Path::new("mic").unwrap(), + crate::origin::Route::default().with_hops(pub_hops()), + ) .unwrap(); settle().await; match h.wire.take_announces().as_slice() { @@ -3164,10 +3217,16 @@ mod announce_test { let tainted = Hops::try_from(vec![peer]).unwrap(); let _tainted = origin - .announce(Path::new("echoed").unwrap(), crate::origin::Route::default().with_hops(tainted)) + .announce( + Path::new("echoed").unwrap(), + crate::origin::Route::default().with_hops(tainted), + ) .unwrap(); let _clean = origin - .announce(Path::new("local").unwrap(), crate::origin::Route::default().with_hops(pub_hops())) + .announce( + Path::new("local").unwrap(), + crate::origin::Route::default().with_hops(pub_hops()), + ) .unwrap(); let log = Log::default(); @@ -3203,7 +3262,10 @@ mod announce_test { let mut h = harness().await; let _late = h .origin - .announce(Path::new("mic").unwrap(), crate::origin::Route::default().with_hops(pub_hops())) + .announce( + Path::new("mic").unwrap(), + crate::origin::Route::default().with_hops(pub_hops()), + ) .unwrap(); settle().await; match h.wire.take_announces().as_slice() { @@ -6215,7 +6277,11 @@ mod serve_group_test { broadcast.announce(Default::default()).unwrap(); let relay = origin(2); let _upstream = connect(version, &publisher, &relay).await; - let remote = relay.consume().routed_broadcast(Path::new("room").unwrap()).await.unwrap(); + let remote = relay + .consume() + .routed_broadcast(Path::new("room").unwrap()) + .await + .unwrap(); let mut keeper = match warm { true => Some( remote @@ -6240,7 +6306,11 @@ mod serve_group_test { moq_clock::sim::advance(Duration::from_secs(1)).await; let subscriber = origin(3); let _downstream = connect(version, &relay, &subscriber).await; - let remote = subscriber.consume().routed_broadcast(Path::new("room").unwrap()).await.unwrap(); + let remote = subscriber + .consume() + .routed_broadcast(Path::new("room").unwrap()) + .await + .unwrap(); let mut live = remote .track("test") .unwrap() @@ -6985,7 +7055,10 @@ mod tests { let mut local_hops = Hops::new(); local_hops.push(upstream).unwrap(); let _local = origin - .dynamic_route(Path::new("local").unwrap(), crate::origin::Route::default().with_hops(local_hops)) + .dynamic_route( + Path::new("local").unwrap(), + crate::origin::Route::default().with_hops(local_hops), + ) .unwrap(); // A SETUP that declares no origin of its own, so only the assigned one applies. @@ -7019,7 +7092,10 @@ mod tests { "served the peer its own route" ); assert!( - serving.request_broadcast(Path::new("local/x").unwrap(), None).now_or_never().is_none(), + serving + .request_broadcast(Path::new("local/x").unwrap(), None) + .now_or_never() + .is_none(), "withheld an independent route" ); } @@ -7049,7 +7125,10 @@ mod tests { let mut clean_hops = Hops::new(); clean_hops.push(clean_publisher).unwrap(); let _clean = origin - .announce(Path::new("local").unwrap(), crate::origin::Route::default().with_hops(clean_hops)) + .announce( + Path::new("local").unwrap(), + crate::origin::Route::default().with_hops(clean_hops), + ) .unwrap(); let gate = kio::Producer::new(true); @@ -7088,7 +7167,9 @@ mod tests { async fn announce_init_broadcast_ends() { let self_origin = crate::Hop::new(1).unwrap(); let origin = crate::origin::Config::new(self_origin).produce(); - let cam = origin.announce(Path::new("cam").unwrap(), crate::origin::Route::default()).unwrap(); + let cam = origin + .announce(Path::new("cam").unwrap(), crate::origin::Route::default()) + .unwrap(); let gate = kio::Producer::new(true); let session = SinkSession::gated_bi(gate.consume()); @@ -7124,7 +7205,9 @@ mod tests { async fn withdraw_before_init_sends_the_initial_burst() { let self_origin = crate::Hop::new(1).unwrap(); let origin = crate::origin::Config::new(self_origin).produce(); - let _cam = origin.announce(Path::new("cam").unwrap(), crate::origin::Route::default()).unwrap(); + let _cam = origin + .announce(Path::new("cam").unwrap(), crate::origin::Route::default()) + .unwrap(); let gate = kio::Producer::new(true); let session = SinkSession::gated_bi(gate.consume()); @@ -7457,7 +7540,13 @@ mod tests { let mut _route = None; let mut held = None; match wait { - Wait::Broadcast => _route = Some(origin.dynamic_route(Path::new("room").unwrap(), crate::origin::Route::default()).unwrap()), + Wait::Broadcast => { + _route = Some( + origin + .dynamic_route(Path::new("room").unwrap(), crate::origin::Route::default()) + .unwrap(), + ) + } Wait::Track => { let broadcast = origin.create_broadcast(Path::new("room").unwrap()).unwrap(); let dynamic = broadcast.dynamic(); diff --git a/rs/moq-net/src/lite/subscriber.rs b/rs/moq-net/src/lite/subscriber.rs index 1df65294ce4..afd44838df3 100644 --- a/rs/moq-net/src/lite/subscriber.rs +++ b/rs/moq-net/src/lite/subscriber.rs @@ -4764,7 +4764,8 @@ mod tests { assert!(announced.ready.is_empty()); let consumer = origin.consume(); - let request = moq_clock::sim::spawn(async move { consumer.request_broadcast(Path::new("room/7").unwrap(), None).await }); + let request = + moq_clock::sim::spawn(async move { consumer.request_broadcast(Path::new("room/7").unwrap(), None).await }); let ready = kio::wait(|waiter| announced.ready.poll_pop(waiter)).await.unwrap(); assert_eq!(ready.as_str(), "room/7"); @@ -4816,7 +4817,10 @@ mod tests { announced: &mut Announced, ) -> (crate::broadcast::Consumer, SourceServe) { let consumer = origin.consume(); - let request = moq_clock::sim::spawn(async move { consumer.request_broadcast(Path::new("pool/p").unwrap(), None).await }); + let request = + moq_clock::sim::spawn( + async move { consumer.request_broadcast(Path::new("pool/p").unwrap(), None).await }, + ); let ready = kio::wait(|waiter| announced.ready.poll_pop(waiter)).await.unwrap(); announced.ready.try_push(ready).unwrap(); announced.poll_serve(subscriber, &kio::Waiter::noop()); @@ -4878,7 +4882,8 @@ mod tests { announced.poll_serve(&subscriber, &kio::Waiter::noop()); let consumer = origin.consume(); - let request = moq_clock::sim::spawn(async move { consumer.request_broadcast(Path::new("pool/p").unwrap(), None).await }); + let request = + moq_clock::sim::spawn(async move { consumer.request_broadcast(Path::new("pool/p").unwrap(), None).await }); let ready = kio::wait(|waiter| announced.ready.poll_pop(waiter)).await.unwrap(); announced.ready.try_push(ready).unwrap(); announced.poll_serve(&subscriber, &kio::Waiter::noop()); @@ -5070,7 +5075,9 @@ mod tests { let origin = origin::Config::new(relay).produce(); let assigned = crate::Hop::new(777).unwrap(); - let local = origin.publish(Path::new("room/host").unwrap(), origin::Route::default()).unwrap(); + let local = origin + .publish(Path::new("room/host").unwrap(), origin::Route::default()) + .unwrap(); let track = local.create_track("video", crate::track::Info::timed()).unwrap(); let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"local".as_ref()).unwrap(); @@ -5079,7 +5086,10 @@ mod tests { // The peer's own subscription, excluding the hop the server minted for // it, is served from the local front before anything is announced back. let peer = origin.consume().excluding(assigned); - let resolved = peer.request_broadcast(Path::new("room/host").unwrap(), None).await.expect("resolves"); + let resolved = peer + .request_broadcast(Path::new("room/host").unwrap(), None) + .await + .expect("resolves"); let mut sub = resolved .track("video") .unwrap() diff --git a/rs/moq-net/src/model/follow.rs b/rs/moq-net/src/model/follow.rs index f17b666ab76..9d874d5bf96 100644 --- a/rs/moq-net/src/model/follow.rs +++ b/rs/moq-net/src/model/follow.rs @@ -340,7 +340,9 @@ mod tests { assert_eq!(followed(&mut follow).await, ("start", "pool".into())); // A route beneath the path serves another broadcast. - let _beneath = origin.publish(Path::new("pool/job/thumbnail").unwrap(), Route::default()).unwrap(); + let _beneath = origin + .publish(Path::new("pool/job/thumbnail").unwrap(), Route::default()) + .unwrap(); quiet(&mut follow).await; // The path itself, from the same instance, takes over without a restart. @@ -371,8 +373,12 @@ mod tests { #[moq_clock::test] async fn follow_starts_on_the_serving_route_when_joining_late() { let origin = Hop::new(1).unwrap().produce(); - let _pool = origin.dynamic_route(Path::new("pool").unwrap(), Route::default()).unwrap(); - let _exact = origin.publish(Path::new("pool/job").unwrap(), Route::default()).unwrap(); + let _pool = origin + .dynamic_route(Path::new("pool").unwrap(), Route::default()) + .unwrap(); + let _exact = origin + .publish(Path::new("pool/job").unwrap(), Route::default()) + .unwrap(); let mut follow = origin.consume().follow(Path::new("pool/job").unwrap()).unwrap(); assert_eq!(followed(&mut follow).await, ("start", "pool/job".into())); @@ -408,7 +414,9 @@ mod tests { #[moq_clock::test] async fn follow_hands_over_to_a_prefix_that_started_before_the_last_change() { let origin = Hop::new(1).unwrap().produce(); - let exact = origin.publish(Path::new("pool/job").unwrap(), route(&Epoch::mint())).unwrap(); + let exact = origin + .publish(Path::new("pool/job").unwrap(), route(&Epoch::mint())) + .unwrap(); let mut follow = origin.consume().follow(Path::new("pool/job").unwrap()).unwrap(); assert_eq!(followed(&mut follow).await, ("start", "pool/job".into())); @@ -427,10 +435,14 @@ mod tests { let origin = Hop::new(1).unwrap().produce(); let mut follow = origin.consume().follow(Path::new("pool/job").unwrap()).unwrap(); - let _pool = origin.dynamic_route(Path::new("pool").unwrap(), Route::default()).unwrap(); + let _pool = origin + .dynamic_route(Path::new("pool").unwrap(), Route::default()) + .unwrap(); assert_eq!(followed(&mut follow).await, ("start", "pool".into())); - let _exact = origin.publish(Path::new("pool/job").unwrap(), Route::default()).unwrap(); + let _exact = origin + .publish(Path::new("pool/job").unwrap(), Route::default()) + .unwrap(); assert_eq!(followed(&mut follow).await, ("restart", "pool/job".into())); } @@ -447,7 +459,9 @@ mod tests { .unwrap(); let mut follow = origin.consume().follow(Path::new("room/alice").unwrap()).unwrap(); - let first = origin.publish(Path::new("room/alice").unwrap(), Route::default().with_cost(5)).unwrap(); + let first = origin + .publish(Path::new("room/alice").unwrap(), Route::default().with_cost(5)) + .unwrap(); let event = moq_clock::timeout(Duration::from_secs(1), follow.next()) .await .unwrap() @@ -458,7 +472,9 @@ mod tests { ); // A republish is another instance of the route that serves the path. - let _second = origin.publish(Path::new("room/alice").unwrap(), Route::default().with_cost(5)).unwrap(); + let _second = origin + .publish(Path::new("room/alice").unwrap(), Route::default().with_cost(5)) + .unwrap(); drop(first); let event = moq_clock::timeout(Duration::from_secs(1), follow.next()) .await @@ -503,7 +519,10 @@ mod tests { async fn announced_hands_out_a_held_takeover_once() { let origin = Hop::new(1).unwrap().produce(); let dynamic = origin.dynamic(Path::new("live").unwrap()).unwrap(); - let mut announced = origin.consume().announced_broadcast(Path::new("live").unwrap(), None).unwrap(); + let mut announced = origin + .consume() + .announced_broadcast(Path::new("live").unwrap(), None) + .unwrap(); // The wait is on the dynamic route's answer when the exact path takes over without an epoch. let (_takeover, _publish) = futures::join!(available(&mut announced), async { @@ -519,7 +538,10 @@ mod tests { async fn announced_hands_out_a_dropped_takeover_again() { let origin = Hop::new(1).unwrap().produce(); let dynamic = origin.dynamic(Path::new("live").unwrap()).unwrap(); - let mut announced = origin.consume().announced_broadcast(Path::new("live").unwrap(), None).unwrap(); + let mut announced = origin + .consume() + .announced_broadcast(Path::new("live").unwrap(), None) + .unwrap(); let (dropped, _publish) = futures::join!(available(&mut announced), async { let _unanswered = requested(&dynamic).await; @@ -539,7 +561,10 @@ mod tests { async fn announced_hands_out_a_gap_while_resolving_once() { let origin = Hop::new(1).unwrap().produce(); let dynamic = origin.dynamic(Path::new("").unwrap()).unwrap(); - let mut announced = origin.consume().announced_broadcast(Path::new("live").unwrap(), None).unwrap(); + let mut announced = origin + .consume() + .announced_broadcast(Path::new("live").unwrap(), None) + .unwrap(); let (_arrival, _publish) = futures::join!(available(&mut announced), async { let _unanswered = requested(&dynamic).await; @@ -557,7 +582,10 @@ mod tests { async fn announced_hands_out_the_instance_again_after_an_end() { let origin = Hop::new(1).unwrap().produce(); let epoch = Epoch::mint(); - let mut announced = origin.consume().announced_broadcast(Path::new("live").unwrap(), None).unwrap(); + let mut announced = origin + .consume() + .announced_broadcast(Path::new("live").unwrap(), None) + .unwrap(); let exact = origin.publish(Path::new("live").unwrap(), route(&epoch)).unwrap(); let first = available(&mut announced).await; @@ -577,15 +605,23 @@ mod tests { let origin = Hop::new(1).unwrap().produce(); let epoch = Epoch::mint(); let _first = origin.publish(Path::new("live").unwrap(), route(&epoch)).unwrap(); - let mut announced = origin.consume().announced_broadcast(Path::new("live").unwrap(), epoch.clone()).unwrap(); + let mut announced = origin + .consume() + .announced_broadcast(Path::new("live").unwrap(), epoch.clone()) + .unwrap(); let pinned = available(&mut announced).await; assert_eq!(pinned.info().epoch.as_ref(), Some(&epoch)); - let _second = origin.publish(Path::new("live").unwrap(), route(&Epoch::mint())).unwrap(); + let _second = origin + .publish(Path::new("live").unwrap(), route(&Epoch::mint())) + .unwrap(); none(&mut announced).await; // Unpinned, the same takeover is followed. - let mut unpinned = origin.consume().announced_broadcast(Path::new("live").unwrap(), None).unwrap(); + let mut unpinned = origin + .consume() + .announced_broadcast(Path::new("live").unwrap(), None) + .unwrap(); let current = available(&mut unpinned).await; assert_ne!(current.info().epoch.as_ref(), Some(&epoch)); } @@ -607,6 +643,9 @@ mod tests { let origin = Hop::new(1).unwrap().produce(); let scope = Patterns::from(Pattern::subtree("pool/job/cam").unwrap()); let scoped = origin.consume().scope(Path::new("").unwrap(), &scope).unwrap(); - assert!(matches!(scoped.follow(Path::new("pool/job").unwrap()), Err(Error::Unauthorized))); + assert!(matches!( + scoped.follow(Path::new("pool/job").unwrap()), + Err(Error::Unauthorized) + )); } } diff --git a/rs/moq-net/src/model/origin.rs b/rs/moq-net/src/model/origin.rs index 60bced08515..afed62461f3 100644 --- a/rs/moq-net/src/model/origin.rs +++ b/rs/moq-net/src/model/origin.rs @@ -7113,7 +7113,9 @@ mod tests { ..Default::default() }; let (producer, _driver) = Producer::new(config); - let scoped = producer.scope(Path::new("room").unwrap(), &Patterns::from(Pattern::all())).unwrap(); + let scoped = producer + .scope(Path::new("room").unwrap(), &Patterns::from(Pattern::all())) + .unwrap(); assert_eq!(scoped.config().max_hops.get(), 6); assert_eq!(scoped.consume().forwardable().horizon.max_hops, HopLimit::new(6)); } @@ -7258,7 +7260,9 @@ mod tests { let mut announced = consumer.announced(); announced.assert_next_wait(); - let announcement = producer.announce(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let announcement = producer + .announce(Path::new("room/alice").unwrap(), Route::default()) + .unwrap(); let route = announced.expect_next_active(Path::new("room/alice").unwrap()).await; assert!(route.hops.is_empty()); assert_eq!(route.cost, Cost::default()); @@ -7277,7 +7281,9 @@ mod tests { let mut announced = producer.consume().announced(); assert!(!announced.is_synced(), "a snapshot in flight holds it"); - let _alice = producer.announce(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let _alice = producer + .announce(Path::new("room/alice").unwrap(), Route::default()) + .unwrap(); drop(snapshot); assert!(!announced.is_synced(), "never before an earlier event is read"); @@ -7285,7 +7291,9 @@ mod tests { assert!(announced.is_synced()); // A later announcement is news, not part of what it synced with. - let _bob = producer.announce(Path::new("room/bob").unwrap(), Route::default()).unwrap(); + let _bob = producer + .announce(Path::new("room/bob").unwrap(), Route::default()) + .unwrap(); assert!(announced.is_synced()); } @@ -7297,7 +7305,9 @@ mod tests { assert!(empty.is_synced(), "nothing to wait on"); empty.assert_next_wait(); - let _alice = producer.announce(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let _alice = producer + .announce(Path::new("room/alice").unwrap(), Route::default()) + .unwrap(); let mut announced = producer.consume().announced(); assert!(!announced.is_synced(), "the replay is owed"); announced.assert_next_active(Path::new("room/alice").unwrap()); @@ -7307,9 +7317,13 @@ mod tests { #[test] fn initial_routes_precede_live_prefixes() { let producer = origin(1).produce(); - let _initial = producer.announce(Path::new("z/initial").unwrap(), Route::default()).unwrap(); + let _initial = producer + .announce(Path::new("z/initial").unwrap(), Route::default()) + .unwrap(); let mut announced = producer.consume().announced(); - let _live = producer.announce(Path::new("a/live").unwrap(), Route::default()).unwrap(); + let _live = producer + .announce(Path::new("a/live").unwrap(), Route::default()) + .unwrap(); announced.assert_next_active(Path::new("z/initial").unwrap()); assert!(announced.is_synced()); } @@ -7317,10 +7331,14 @@ mod tests { #[test] fn stalled_initial_replay_collapses_churn_without_a_backlog() { let producer = origin(1).produce(); - let initial = producer.announce(Path::new("z/initial").unwrap(), Route::default()).unwrap(); + let initial = producer + .announce(Path::new("z/initial").unwrap(), Route::default()) + .unwrap(); let mut announced = producer.consume().announced(); for i in 0..1_000 { - let transient = producer.announce(Path::try_from(format!("a/{i}")).unwrap(), Route::default()).unwrap(); + let transient = producer + .announce(Path::try_from(format!("a/{i}")).unwrap(), Route::default()) + .unwrap(); initial.update(Route::default().with_cost(i)).unwrap(); drop(transient); assert_eq!(announced.state.read().pending.len(), 1); @@ -7337,7 +7355,9 @@ mod tests { let snapshot = producer.snapshot(Path::new("").unwrap()); let mut announced = producer.consume().announced(); - let alice = producer.announce(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let alice = producer + .announce(Path::new("room/alice").unwrap(), Route::default()) + .unwrap(); drop(snapshot); assert!(!announced.is_synced()); drop(alice); @@ -7350,7 +7370,9 @@ mod tests { fn an_update_is_not_owed() { let producer = origin(1).produce(); let mut announced = producer.consume().announced(); - let alice = producer.announce(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let alice = producer + .announce(Path::new("room/alice").unwrap(), Route::default()) + .unwrap(); announced.assert_next_active(Path::new("room/alice").unwrap()); let snapshot = producer.snapshot(Path::new("").unwrap()); @@ -7396,7 +7418,10 @@ mod tests { drop(other); // A local view never waits on a peer's routes. - let _peer = producer.clone().with_link(Link::Peer).snapshot(Path::new("room").unwrap()); + let _peer = producer + .clone() + .with_link(Link::Peer) + .snapshot(Path::new("room").unwrap()); assert!(producer.consume().local().announced().is_synced()); assert!(!producer.consume().announced().is_synced()); } @@ -7485,22 +7510,34 @@ mod tests { async fn hidden_routes_need_an_opt_in() { let producer = origin(1).produce(); let consumer = producer.consume(); - let _visible = producer.announce(Path::new("room/alice").unwrap(), Route::default()).unwrap(); - let _stats = producer.announce(Path::new(".stats/node").unwrap(), Route::default()).unwrap(); - let _nested = producer.announce(Path::new("room/.internal").unwrap(), Route::default()).unwrap(); + let _visible = producer + .announce(Path::new("room/alice").unwrap(), Route::default()) + .unwrap(); + let _stats = producer + .announce(Path::new(".stats/node").unwrap(), Route::default()) + .unwrap(); + let _nested = producer + .announce(Path::new("room/.internal").unwrap(), Route::default()) + .unwrap(); // Only a leading dot hides: a suffix is part of the name. - let _suffix = producer.announce(Path::new("room/catalog.pro").unwrap(), Route::default()).unwrap(); + let _suffix = producer + .announce(Path::new("room/catalog.pro").unwrap(), Route::default()) + .unwrap(); let mut announced = consumer.announced(); announced.expect_next_active(Path::new("room/alice").unwrap()).await; - announced.expect_next_active(Path::new("room/catalog.pro").unwrap()).await; + announced + .expect_next_active(Path::new("room/catalog.pro").unwrap()) + .await; announced.assert_next_wait(); let mut announced = consumer.clone().with_hidden(true).announced(); announced.expect_next_active(Path::new(".stats/node").unwrap()).await; announced.expect_next_active(Path::new("room/.internal").unwrap()).await; announced.expect_next_active(Path::new("room/alice").unwrap()).await; - announced.expect_next_active(Path::new("room/catalog.pro").unwrap()).await; + announced + .expect_next_active(Path::new("room/catalog.pro").unwrap()) + .await; announced.assert_next_wait(); // Naming the dot segment lists what is under it, by root or by pattern. @@ -7510,7 +7547,10 @@ mod tests { .announced(); announced.expect_next_active(Path::new("node").unwrap()).await; announced.assert_next_wait(); - let mut announced = consumer.scope(Path::new("").unwrap(), &scopes(&["room/.internal"])).unwrap().announced(); + let mut announced = consumer + .scope(Path::new("").unwrap(), &scopes(&["room/.internal"])) + .unwrap() + .announced(); announced.expect_next_active(Path::new("room/.internal").unwrap()).await; announced.assert_next_wait(); @@ -7520,10 +7560,16 @@ mod tests { announced.expect_next_active(Path::new(".stats/node").unwrap()).await; announced.expect_next_active(Path::new("room/.internal").unwrap()).await; announced.assert_next_wait(); - let room = consumer.scope(Path::new("").unwrap(), &scopes(&["room"])).unwrap().beyond(&consumer); + let room = consumer + .scope(Path::new("").unwrap(), &scopes(&["room"])) + .unwrap() + .beyond(&consumer); let mut announced = room.announced(); announced.assert_next_wait(); - let stats = consumer.scope(Path::new("").unwrap(), &scopes(&[".stats"])).unwrap().beyond(&consumer); + let stats = consumer + .scope(Path::new("").unwrap(), &scopes(&[".stats"])) + .unwrap() + .beyond(&consumer); let mut announced = stats.announced(); announced.expect_next_active(Path::new(".stats/node").unwrap()).await; announced.assert_next_wait(); @@ -7539,7 +7585,10 @@ mod tests { broadcast.announce(Route::default()).unwrap(); consumer.announced().assert_next_wait(); - let resolved = consumer.request_broadcast(Path::new(".stats/node").unwrap(), None).await.expect("resolves"); + let resolved = consumer + .request_broadcast(Path::new(".stats/node").unwrap(), None) + .await + .expect("resolves"); assert_eq!(resolved.info().path.as_str(), ".stats/node"); } @@ -7547,7 +7596,10 @@ mod tests { fn mounted(producer: &Producer, pid: &str, patterns: &[&str]) -> Consumer { let patterns: Patterns = patterns.iter().map(|pattern| pattern.parse().unwrap()).collect(); producer - .mount(Path::try_from(format!("{pid}/.svc")).unwrap(), Path::try_from(format!(".svc/{pid}")).unwrap()) + .mount( + Path::try_from(format!("{pid}/.svc")).unwrap(), + Path::try_from(format!(".svc/{pid}")).unwrap(), + ) .unwrap() .scope(Path::new(pid).unwrap(), &patterns) .unwrap() @@ -7560,11 +7612,15 @@ mod tests { #[cfg(feature = "async")] async fn mount_resolves_on_the_target_front() { let producer = origin(1).produce(); - let server = producer.dynamic_route(Path::new(".svc").unwrap(), Route::default()).unwrap(); + let server = producer + .dynamic_route(Path::new(".svc").unwrap(), Route::default()) + .unwrap(); let project = mounted(&producer, "p1", &["**"]); let through = project.request_broadcast(Path::new(".svc/foo").unwrap(), None); - let direct = producer.consume().request_broadcast(Path::new(".svc/p1/foo").unwrap(), None); + let direct = producer + .consume() + .request_broadcast(Path::new(".svc/p1/foo").unwrap(), None); let request = queued(&server).await; assert_eq!(request.path().as_str(), ".svc/p1/foo"); @@ -7586,10 +7642,18 @@ mod tests { async fn mount_presents_target_routes_under_the_mount() { let producer = origin(1).produce(); let _claim = producer.announce(Path::new(".svc").unwrap(), Route::default()).unwrap(); - let foo = producer.publish(Path::new(".svc/p1/foo").unwrap(), Route::default()).unwrap(); - let _other = producer.publish(Path::new(".svc/p2/bar").unwrap(), Route::default()).unwrap(); - let _cam = producer.publish(Path::new("p1/cam").unwrap(), Route::default()).unwrap(); - let _shadowed = producer.publish(Path::new("p1/.svc/forged").unwrap(), Route::default()).unwrap(); + let foo = producer + .publish(Path::new(".svc/p1/foo").unwrap(), Route::default()) + .unwrap(); + let _other = producer + .publish(Path::new(".svc/p2/bar").unwrap(), Route::default()) + .unwrap(); + let _cam = producer + .publish(Path::new("p1/cam").unwrap(), Route::default()) + .unwrap(); + let _shadowed = producer + .publish(Path::new("p1/.svc/forged").unwrap(), Route::default()) + .unwrap(); let project = mounted(&producer, "p1", &["**"]); // A dot segment hides the mount like any other. @@ -7618,7 +7682,11 @@ mod tests { announced.assert_next_wait(); // The shadowed path never resolves: the mount answers for it. - let err = project.request_broadcast(Path::new(".svc/forged").unwrap(), None).await.err().unwrap(); + let err = project + .request_broadcast(Path::new(".svc/forged").unwrap(), None) + .await + .err() + .unwrap(); assert!(matches!(err, Error::NotFound | Error::Unroutable), "{err:?}"); } @@ -7628,11 +7696,18 @@ mod tests { #[cfg(feature = "async")] async fn mount_authorizes_the_named_path() { let producer = origin(1).produce(); - let _foo = producer.publish(Path::new(".svc/p1/foo").unwrap(), Route::default()).unwrap(); - let _bar = producer.publish(Path::new(".svc/p1/bar").unwrap(), Route::default()).unwrap(); + let _foo = producer + .publish(Path::new(".svc/p1/foo").unwrap(), Route::default()) + .unwrap(); + let _bar = producer + .publish(Path::new(".svc/p1/bar").unwrap(), Route::default()) + .unwrap(); let granted = mounted(&producer, "p1", &["foo", ".svc/foo"]); - granted.request_broadcast(Path::new(".svc/foo").unwrap(), None).await.expect("granted"); + granted + .request_broadcast(Path::new(".svc/foo").unwrap(), None) + .await + .expect("granted"); let refused = granted .request_broadcast(Path::new(".svc/bar").unwrap(), None) .now_or_never() @@ -7653,7 +7728,11 @@ mod tests { // Another project's mount reaches its own target, never this one's. let other = mounted(&producer, "p2", &["**"]); other.clone().with_hidden(true).announced().assert_next_wait(); - let err = other.request_broadcast(Path::new(".svc/foo").unwrap(), None).await.err().unwrap(); + let err = other + .request_broadcast(Path::new(".svc/foo").unwrap(), None) + .await + .err() + .unwrap(); assert!(matches!(err, Error::Unroutable)); } @@ -7662,7 +7741,9 @@ mod tests { #[moq_clock::test] async fn mount_captures_the_named_path() { let producer = origin(1).produce(); - let _foo = producer.publish(Path::new(".svc/p1/foo").unwrap(), Route::default()).unwrap(); + let _foo = producer + .publish(Path::new(".svc/p1/foo").unwrap(), Route::default()) + .unwrap(); let project = mounted(&producer, "p1", &["**"]).with_hidden(true); let Some(AnnounceEvent::Start(update)) = project.announced().try_next() else { @@ -7671,7 +7752,9 @@ mod tests { assert_eq!(update.prefix.as_str(), ".svc/foo"); assert_eq!(update.captures, Some(vec![".svc/foo".parse::().unwrap()])); - let inside = project.scope(Path::new(".svc").unwrap(), &Patterns::from(Pattern::all())).unwrap(); + let inside = project + .scope(Path::new(".svc").unwrap(), &Patterns::from(Pattern::all())) + .unwrap(); let Some(AnnounceEvent::Start(update)) = inside.announced().try_next() else { panic!("expected foo to start"); }; @@ -7686,7 +7769,9 @@ mod tests { async fn mount_keeps_a_max_depth_target() { let producer = origin(1).produce(); let deep = vec!["d"; Path::MAX_PARTS].join("/"); - let _leaf = producer.publish(Path::new(deep.as_str()).unwrap(), Route::default()).unwrap(); + let _leaf = producer + .publish(Path::new(deep.as_str()).unwrap(), Route::default()) + .unwrap(); let project = producer .mount(Path::new("p1/.svc").unwrap(), Path::new(deep.as_str()).unwrap()) .unwrap() @@ -7700,9 +7785,15 @@ mod tests { announced.assert_next_wait(); // Beneath the mount the target has no room: refused, never handed to a route. - let err = project.request_broadcast(Path::new(".svc/x").unwrap(), None).await.err().unwrap(); + let err = project + .request_broadcast(Path::new(".svc/x").unwrap(), None) + .await + .err() + .unwrap(); assert!(matches!(err, Error::BoundsExceeded(_)), "{err:?}"); - let inside = project.scope(Path::new(".svc/x").unwrap(), &Patterns::from(Pattern::all())).unwrap(); + let inside = project + .scope(Path::new(".svc/x").unwrap(), &Patterns::from(Pattern::all())) + .unwrap(); inside.announced().assert_next_wait(); } @@ -7713,7 +7804,9 @@ mod tests { let producer = origin(1).produce(); let _near = producer.publish(Path::new("t/x").unwrap(), Route::default()).unwrap(); let deep = format!("t/{}", vec!["d"; Path::MAX_PARTS - 1].join("/")); - let _deep = producer.publish(Path::new(deep.as_str()).unwrap(), Route::default()).unwrap(); + let _deep = producer + .publish(Path::new(deep.as_str()).unwrap(), Route::default()) + .unwrap(); let project = producer .mount(Path::new("p1/a/b").unwrap(), Path::new("t").unwrap()) .unwrap() @@ -7741,7 +7834,10 @@ mod tests { .unwrap() .scope(Path::new("p1").unwrap(), &Patterns::from(Pattern::all())) .unwrap(); - assert!(matches!(project.create_broadcast(Path::new(".svc/foo").unwrap()), Err(Error::Unauthorized))); + assert!(matches!( + project.create_broadcast(Path::new(".svc/foo").unwrap()), + Err(Error::Unauthorized) + )); assert!(matches!( project.dynamic_route(Path::new(".svc").unwrap(), Route::default()), Err(Error::Unauthorized) @@ -7758,24 +7854,54 @@ mod tests { async fn mount_never_widens_a_scope() { let (producer, _driver) = Producer::new(Config::new(origin(1))); let project = producer.scope(Path::new("").unwrap(), &scopes(&["p1"])).unwrap(); - assert!(matches!(project.mount(Path::new("p1/.svc").unwrap(), Path::new(".svc/p1").unwrap()), Err(Error::Unauthorized))); + assert!(matches!( + project.mount(Path::new("p1/.svc").unwrap(), Path::new(".svc/p1").unwrap()), + Err(Error::Unauthorized) + )); - let mounted = producer.mount(Path::new("p1/.svc").unwrap(), Path::new(".svc/p1").unwrap()).unwrap(); - assert!(matches!(mounted.mount(Path::new("p1/.svc/x").unwrap(), Path::new(".other").unwrap()), Err(Error::Duplicate))); - assert!(matches!(mounted.mount(Path::new("p1").unwrap(), Path::new(".other").unwrap()), Err(Error::Duplicate))); + let mounted = producer + .mount(Path::new("p1/.svc").unwrap(), Path::new(".svc/p1").unwrap()) + .unwrap(); + assert!(matches!( + mounted.mount(Path::new("p1/.svc/x").unwrap(), Path::new(".other").unwrap()), + Err(Error::Duplicate) + )); + assert!(matches!( + mounted.mount(Path::new("p1").unwrap(), Path::new(".other").unwrap()), + Err(Error::Duplicate) + )); // A target through a mount would read the subtree the mount shadows. - assert!(matches!(mounted.mount(Path::new("p2").unwrap(), Path::new("p1/.svc/x").unwrap()), Err(Error::Duplicate))); - assert!(matches!(mounted.mount(Path::new("p2").unwrap(), Path::new("p1").unwrap()), Err(Error::Duplicate))); + assert!(matches!( + mounted.mount(Path::new("p2").unwrap(), Path::new("p1/.svc/x").unwrap()), + Err(Error::Duplicate) + )); + assert!(matches!( + mounted.mount(Path::new("p2").unwrap(), Path::new("p1").unwrap()), + Err(Error::Duplicate) + )); // A mount point on a target would chain through it, in either order. - assert!(matches!(mounted.mount(Path::new(".svc/p1/x").unwrap(), Path::new(".other").unwrap()), Err(Error::Duplicate))); - assert!(matches!(mounted.mount(Path::new(".svc").unwrap(), Path::new(".other").unwrap()), Err(Error::Duplicate))); - mounted.mount(Path::new("p1/.other").unwrap(), Path::new(".other/p1").unwrap()).unwrap(); + assert!(matches!( + mounted.mount(Path::new(".svc/p1/x").unwrap(), Path::new(".other").unwrap()), + Err(Error::Duplicate) + )); + assert!(matches!( + mounted.mount(Path::new(".svc").unwrap(), Path::new(".other").unwrap()), + Err(Error::Duplicate) + )); + mounted + .mount(Path::new("p1/.other").unwrap(), Path::new(".other/p1").unwrap()) + .unwrap(); // Mount points may share a target. - mounted.mount(Path::new("p2/.svc").unwrap(), Path::new(".svc/p1").unwrap()).unwrap(); + mounted + .mount(Path::new("p2/.svc").unwrap(), Path::new(".svc/p1").unwrap()) + .unwrap(); // A mount point overlapping its own target is refused like any other overlap. for (at, target) in [("a", "a/b"), ("a/b", "a"), ("a", "a")] { assert!( - matches!(producer.mount(Path::new(at).unwrap(), Path::new(target).unwrap()), Err(Error::Duplicate)), + matches!( + producer.mount(Path::new(at).unwrap(), Path::new(target).unwrap()), + Err(Error::Duplicate) + ), "{at} -> {target}" ); } @@ -7787,7 +7913,10 @@ mod tests { let (producer, _driver) = Producer::new(Config::new(origin(1))); for at in ["*", "p1/*", "p1/**", "p1/a*"] { assert!( - matches!(producer.mount(Path::new(at).unwrap(), Path::new(".svc/p1").unwrap()), Err(Error::InvalidPath(_))), + matches!( + producer.mount(Path::new(at).unwrap(), Path::new(".svc/p1").unwrap()), + Err(Error::InvalidPath(_)) + ), "{at}" ); } @@ -7800,14 +7929,19 @@ mod tests { async fn mount_egress_counts_under_the_named_path() { let registry = stats::Registry::new(stats::Config::new()); let producer = origin(1).produce(); - let _foo = producer.publish(Path::new(".svc/p1/foo").unwrap(), Route::default()).unwrap(); + let _foo = producer + .publish(Path::new(".svc/p1/foo").unwrap(), Route::default()) + .unwrap(); let project = mounted(&producer, "p1", &["**"]) .with_stats(registry.tier(stats::Tier::default()).session(Path::new("p1").unwrap())) .with_hidden(true); let mut announced = project.announced(); announced.expect_next_active(Path::new(".svc/foo").unwrap()).await; - project.request_broadcast(Path::new(".svc/foo").unwrap(), None).await.expect("resolves"); + project + .request_broadcast(Path::new(".svc/foo").unwrap(), None) + .await + .expect("resolves"); let mut report = stats::Report::default(); registry.report(&mut report); @@ -7827,7 +7961,9 @@ mod tests { let mut announced = consumer.announced(); let mut opted = consumer.clone().with_hidden(true).announced(); - let hidden = producer.announce(Path::new(".stats/node").unwrap(), Route::default()).unwrap(); + let hidden = producer + .announce(Path::new(".stats/node").unwrap(), Route::default()) + .unwrap(); announced.assert_next_wait(); opted.expect_next_active(Path::new(".stats/node").unwrap()).await; @@ -7839,7 +7975,9 @@ mod tests { #[moq_clock::test] async fn a_replayed_route_retracted_before_delivery_cancels() { let producer = origin(1).produce(); - let alice = producer.announce(Path::new("alice").unwrap(), Route::default()).unwrap(); + let alice = producer + .announce(Path::new("alice").unwrap(), Route::default()) + .unwrap(); let mut announced = producer.consume().announced(); drop(alice); announced.assert_next_wait(); @@ -7859,13 +7997,31 @@ mod tests { peer.assert_next_wait(); broadcast.announce(Route::default().with_cost(3)).unwrap(); - assert_eq!(announced.expect_next_active(Path::new("room/alice").unwrap()).await.cost, Cost::new(3)); - assert_eq!(peer.expect_next_active(Path::new("room/alice").unwrap()).await.cost, Cost::new(3)); + assert_eq!( + announced + .expect_next_active(Path::new("room/alice").unwrap()) + .await + .cost, + Cost::new(3) + ); + assert_eq!( + peer.expect_next_active(Path::new("room/alice").unwrap()).await.cost, + Cost::new(3) + ); // Announcing again re-prices in place. broadcast.announce(Route::default().with_cost(1)).unwrap(); - assert_eq!(announced.expect_next_active(Path::new("room/alice").unwrap()).await.cost, Cost::new(1)); - assert_eq!(peer.expect_next_active(Path::new("room/alice").unwrap()).await.cost, Cost::new(1)); + assert_eq!( + announced + .expect_next_active(Path::new("room/alice").unwrap()) + .await + .cost, + Cost::new(1) + ); + assert_eq!( + peer.expect_next_active(Path::new("room/alice").unwrap()).await.cost, + Cost::new(1) + ); // Off the air: the route retracts for everyone and the path is unroutable. broadcast.unannounce(); @@ -7873,7 +8029,11 @@ mod tests { peer.expect_next_ended(Path::new("room/alice").unwrap()).await; broadcast.unannounce(); announced.assert_next_wait(); - let err = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.err().unwrap(); + let err = consumer + .request_broadcast(Path::new("room/alice").unwrap(), None) + .await + .err() + .unwrap(); assert!(matches!(err, Error::Unroutable)); // Back on the air, then the end of the broadcast retracts for good. @@ -7909,7 +8069,9 @@ mod tests { async fn publish_creates_and_announces_together() { let producer = origin(1).produce(); let mut announced = producer.consume().announced(); - let _broadcast = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let _broadcast = producer + .publish(Path::new("room/alice").unwrap(), Route::default()) + .unwrap(); announced.expect_next_active(Path::new("room/alice").unwrap()).await; } @@ -7924,8 +8086,12 @@ mod tests { #[moq_clock::test] async fn announce_replays_to_late_cursor() { let producer = origin(1).produce(); - let _a = producer.announce(Path::new("room/alice").unwrap(), Route::default()).unwrap(); - let _b = producer.announce(Path::new("room/bob").unwrap(), Route::default()).unwrap(); + let _a = producer + .announce(Path::new("room/alice").unwrap(), Route::default()) + .unwrap(); + let _b = producer + .announce(Path::new("room/bob").unwrap(), Route::default()) + .unwrap(); let mut announced = producer.consume().announced(); // Replay follows the table traversal order. @@ -7956,7 +8122,10 @@ mod tests { let producer = origin(1).produce(); let _a = producer.announce(Path::new("").unwrap(), Route::default()).unwrap(); - let consumer = producer.consume().scope(Path::new("").unwrap(), &scopes(&["room"])).unwrap(); + let consumer = producer + .consume() + .scope(Path::new("").unwrap(), &scopes(&["room"])) + .unwrap(); let mut announced = consumer.announced(); announced.expect_next_active(Path::new("").unwrap()).await; } @@ -7964,7 +8133,9 @@ mod tests { #[moq_clock::test] async fn cursor_root_strips_prefix() { let producer = origin(1).produce(); - let _a = producer.announce(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let _a = producer + .announce(Path::new("room/alice").unwrap(), Route::default()) + .unwrap(); let consumer = producer .consume() @@ -7980,14 +8151,20 @@ mod tests { let mut announced = producer.consume().announced(); let expensive = producer - .announce(Path::new("room").unwrap(), Route::default().with_hops(hops(&[10])).with_cost(5)) + .announce( + Path::new("room").unwrap(), + Route::default().with_hops(hops(&[10])).with_cost(5), + ) .unwrap(); let route = announced.expect_next_active(Path::new("room").unwrap()).await; assert_eq!(route.cost, Cost::new(5)); // A cheaper route for the same prefix takes over in place. let cheap = producer - .announce(Path::new("room").unwrap(), Route::default().with_hops(hops(&[20])).with_cost(1)) + .announce( + Path::new("room").unwrap(), + Route::default().with_hops(hops(&[20])).with_cost(1), + ) .unwrap(); let route = announced.expect_next_active(Path::new("room").unwrap()).await; assert_eq!(route.cost, Cost::new(1)); @@ -8025,7 +8202,10 @@ mod tests { let _pool: Vec = order .map(|id| { producer - .dynamic_route(Path::new("pool").unwrap(), Route::default().with_hops(hops(&[id])).with_cost(3)) + .dynamic_route( + Path::new("pool").unwrap(), + Route::default().with_hops(hops(&[id])).with_cost(3), + ) .unwrap() }) .collect(); @@ -8080,7 +8260,10 @@ mod tests { let _new = producer.announce(Path::new("room").unwrap(), route).unwrap(); match epoch { - None => assert_eq!(announced.expect_next_restarted(Path::new("room").unwrap()).await.hops, hops(&[10])), + None => assert_eq!( + announced.expect_next_restarted(Path::new("room").unwrap()).await.hops, + hops(&[10]) + ), Some(_) => announced.assert_next_wait(), } @@ -8095,7 +8278,9 @@ mod tests { async fn a_reprice_is_an_update() { let producer = origin(1).produce(); let mut announced = producer.consume().announced(); - let route = producer.dynamic_route(Path::new("room").unwrap(), Route::default().with_cost(3)).unwrap(); + let route = producer + .dynamic_route(Path::new("room").unwrap(), Route::default().with_cost(3)) + .unwrap(); announced.expect_next_active(Path::new("room").unwrap()).await; route.update_route(Route::default().with_cost(5)).unwrap(); @@ -8118,7 +8303,10 @@ mod tests { let route = producer .dynamic_route(Path::new("room").unwrap(), Route::default().with_auth(first.clone())) .unwrap(); - assert_eq!(announced.expect_next_active(Path::new("room").unwrap()).await.auth, Some(first)); + assert_eq!( + announced.expect_next_active(Path::new("room").unwrap()).await.auth, + Some(first) + ); route.update_route(Route::default().with_auth(second.clone())).unwrap(); match announced.next().await.expect("no next") { @@ -8145,12 +8333,18 @@ mod tests { let mut announced = consumer.announced(); let peer = producer.clone().with_link(Link::Peer); let old = peer - .dynamic_route(Path::new("pool/job-0").unwrap(), Route::default().with_hops(hops(&[11]))) + .dynamic_route( + Path::new("pool/job-0").unwrap(), + Route::default().with_hops(hops(&[11])), + ) .unwrap(); announced.expect_next_active(Path::new("pool/job-0").unwrap()).await; let new = peer - .dynamic_route(Path::new("pool/job-0").unwrap(), Route::default().with_hops(hops(&[10]))) + .dynamic_route( + Path::new("pool/job-0").unwrap(), + Route::default().with_hops(hops(&[10])), + ) .unwrap(); announced.assert_next_wait(); @@ -8162,7 +8356,13 @@ mod tests { assert!(new.poll_requested_broadcast(&kio::Waiter::noop()).is_pending()); drop(old); - assert_eq!(announced.expect_next_restarted(Path::new("pool/job-0").unwrap()).await.hops, hops(&[10])); + assert_eq!( + announced + .expect_next_restarted(Path::new("pool/job-0").unwrap()) + .await + .hops, + hops(&[10]) + ); let pending = consumer.request_broadcast(Path::new("pool/job-0").unwrap(), None); let request = queued(&new).await; @@ -8187,15 +8387,24 @@ mod tests { let consumer = producer.consume(); let mut announced = consumer.announced(); let _old = producer - .dynamic_route(Path::new("pool/job-0").unwrap(), Route::default().with_hops(hops(&[old_hop]))) + .dynamic_route( + Path::new("pool/job-0").unwrap(), + Route::default().with_hops(hops(&[old_hop])), + ) .unwrap(); announced.expect_next_active(Path::new("pool/job-0").unwrap()).await; let new = producer - .dynamic_route(Path::new("pool/job-0").unwrap(), Route::default().with_hops(hops(&[new_hop]))) + .dynamic_route( + Path::new("pool/job-0").unwrap(), + Route::default().with_hops(hops(&[new_hop])), + ) .unwrap(); assert_eq!( - announced.expect_next_restarted(Path::new("pool/job-0").unwrap()).await.hops, + announced + .expect_next_restarted(Path::new("pool/job-0").unwrap()) + .await + .hops, hops(&[new_hop]) ); @@ -8219,7 +8428,10 @@ mod tests { claims .scope(Path::new("").unwrap(), &scopes(&[scope])) .unwrap() - .dynamic_route(Path::new(prefix).unwrap(), Route::default().with_hops(hops(&[hop])).with_cost(cost)) + .dynamic_route( + Path::new(prefix).unwrap(), + Route::default().with_hops(hops(&[hop])).with_cost(cost), + ) .unwrap() }; (producer, claim) @@ -8269,7 +8481,10 @@ mod tests { .scope(Path::new("").unwrap(), &scopes(&["room/video"])) .unwrap() .announced(); - assert_eq!(video.expect_next_active(Path::new("room").unwrap()).await.cost, Cost::new(5)); + assert_eq!( + video.expect_next_active(Path::new("room").unwrap()).await.cost, + Cost::new(5) + ); let _sticky = hold(&consumer, "room/video/b", &b).await; drop(chat); @@ -8288,14 +8503,23 @@ mod tests { let _w = claim("pool", "pool/other", 10, 2); let r = claim("pool", "pool/job", 11, 5); let mut announced = consumer.announced(); - assert_eq!(announced.expect_next_active(Path::new("pool").unwrap()).await.cost, Cost::new(2)); + assert_eq!( + announced.expect_next_active(Path::new("pool").unwrap()).await.cost, + Cost::new(2) + ); let (_answer, sticky) = hold(&consumer, "pool/job", &r).await; let _y = claim("pool", "pool/other", 12, 1); - assert_eq!(announced.expect_next_restarted(Path::new("pool").unwrap()).await.cost, Cost::new(1)); + assert_eq!( + announced.expect_next_restarted(Path::new("pool").unwrap()).await.cost, + Cost::new(1) + ); quiet(&mut announced).await; // The path still resolves through the front's route, so the re-request joins it. - let joined = consumer.request_broadcast(Path::new("pool/job").unwrap(), None).await.unwrap(); + let joined = consumer + .request_broadcast(Path::new("pool/job").unwrap(), None) + .await + .unwrap(); assert!(joined.is_clone(&sticky)); let _z = claim("pool", "pool/job", 13, 3); @@ -8313,18 +8537,30 @@ mod tests { let a = claim("room", "room/job", 10, 5); let _b = claim("room", "room/other", 11, 2); let mut announced = consumer.announced(); - assert_eq!(announced.expect_next_active(Path::new("room").unwrap()).await.cost, Cost::new(2)); + assert_eq!( + announced.expect_next_active(Path::new("room").unwrap()).await.cost, + Cost::new(2) + ); let _sticky = hold(&consumer, "room/job", &a).await; let c = producer - .dynamic_route(Path::new("room").unwrap(), Route::default().with_hops(hops(&[12])).with_cost(1)) + .dynamic_route( + Path::new("room").unwrap(), + Route::default().with_hops(hops(&[12])).with_cost(1), + ) .unwrap(); - assert_eq!(announced.expect_next_restarted(Path::new("room").unwrap()).await.cost, Cost::new(1)); + assert_eq!( + announced.expect_next_restarted(Path::new("room").unwrap()).await.cost, + Cost::new(1) + ); quiet(&mut announced).await; c.update_route(Route::default().with_hops(hops(&[12])).with_cost(3)) .unwrap(); - assert_eq!(announced.expect_next_restarted(Path::new("room").unwrap()).await.cost, Cost::new(2)); + assert_eq!( + announced.expect_next_restarted(Path::new("room").unwrap()).await.cost, + Cost::new(2) + ); quiet(&mut announced).await; } @@ -8338,12 +8574,18 @@ mod tests { let a = claim("room", "room", 10, 5); let b = claim("room", "room", 11, 9); let mut announced = consumer.announced(); - assert_eq!(announced.expect_next_active(Path::new("room").unwrap()).await.cost, Cost::new(5)); + assert_eq!( + announced.expect_next_active(Path::new("room").unwrap()).await.cost, + Cost::new(5) + ); let _sticky = hold(&consumer, "room/job", &a).await; b.update_route(Route::default().with_hops(hops(&[11])).with_cost(3)) .unwrap(); - assert_eq!(announced.expect_next_restarted(Path::new("room").unwrap()).await.cost, Cost::new(3)); + assert_eq!( + announced.expect_next_restarted(Path::new("room").unwrap()).await.cost, + Cost::new(3) + ); quiet(&mut announced).await; } @@ -8366,7 +8608,10 @@ mod tests { let producer = origin(1).produce(); let assigned = origin(777); let _echoed = producer - .announce(Path::new("echoed").unwrap(), Route::default().with_hops(hops(&[0])).with_via(assigned)) + .announce( + Path::new("echoed").unwrap(), + Route::default().with_hops(hops(&[0])).with_via(assigned), + ) .unwrap(); let _local = producer .announce(Path::new("local").unwrap(), Route::default().with_hops(hops(&[10]))) @@ -8383,14 +8628,20 @@ mod tests { let mut announced = producer.consume().announced(); let _anonymous = producer - .announce(Path::new("room").unwrap(), Route::default().with_hops(hops(&[0])).with_cost(1)) + .announce( + Path::new("room").unwrap(), + Route::default().with_hops(hops(&[0])).with_cost(1), + ) .unwrap(); let route = announced.expect_next_active(Path::new("room").unwrap()).await; assert!(route.is_anonymous()); assert_eq!(route.cost, Cost::new(1)); let _identified = producer - .announce(Path::new("room").unwrap(), Route::default().with_hops(hops(&[10])).with_cost(5)) + .announce( + Path::new("room").unwrap(), + Route::default().with_hops(hops(&[10])).with_cost(5), + ) .unwrap(); let route = announced.expect_next_active(Path::new("room").unwrap()).await; assert!(!route.is_anonymous()); @@ -8403,13 +8654,19 @@ mod tests { let mut announced = producer.consume().announced(); let expensive = producer - .announce(Path::new("room").unwrap(), Route::default().with_hops(hops(&[0])).with_cost(5)) + .announce( + Path::new("room").unwrap(), + Route::default().with_hops(hops(&[0])).with_cost(5), + ) .unwrap(); let route = announced.expect_next_active(Path::new("room").unwrap()).await; assert_eq!(route.cost, Cost::new(5)); let _cheap = producer - .announce(Path::new("room").unwrap(), Route::default().with_hops(hops(&[0, 7])).with_cost(1)) + .announce( + Path::new("room").unwrap(), + Route::default().with_hops(hops(&[0, 7])).with_cost(1), + ) .unwrap(); let route = announced.expect_next_active(Path::new("room").unwrap()).await; assert!(route.is_anonymous()); @@ -8436,7 +8693,10 @@ mod tests { announced.expect_next_active(Path::new("room").unwrap()).await; let _identified = producer - .announce(Path::new("room").unwrap(), Route::default().with_hops(hops(&[10, 20])).with_cost(5)) + .announce( + Path::new("room").unwrap(), + Route::default().with_hops(hops(&[10, 20])).with_cost(5), + ) .unwrap(); let route = announced.expect_next_active(Path::new("room").unwrap()).await; assert!(!route.is_anonymous()); @@ -8450,10 +8710,16 @@ mod tests { let consumer = producer.consume(); let anonymous = producer - .dynamic_route(Path::new("room").unwrap(), Route::default().with_hops(hops(&[0])).with_cost(1)) + .dynamic_route( + Path::new("room").unwrap(), + Route::default().with_hops(hops(&[0])).with_cost(1), + ) .unwrap(); let identified = producer - .dynamic_route(Path::new("room").unwrap(), Route::default().with_hops(hops(&[10])).with_cost(5)) + .dynamic_route( + Path::new("room").unwrap(), + Route::default().with_hops(hops(&[10])).with_cost(5), + ) .unwrap(); let _pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); @@ -8474,10 +8740,16 @@ mod tests { let demoted = producer .clone() .with_preference(Preference::new(-1)) - .dynamic_route(Path::new("room").unwrap(), Route::default().with_hops(hops(&[10])).with_cost(1)) + .dynamic_route( + Path::new("room").unwrap(), + Route::default().with_hops(hops(&[10])).with_cost(1), + ) .unwrap(); let unranked = producer - .dynamic_route(Path::new("room").unwrap(), Route::default().with_hops(hops(&[11])).with_cost(5)) + .dynamic_route( + Path::new("room").unwrap(), + Route::default().with_hops(hops(&[11])).with_cost(5), + ) .unwrap(); let _pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); @@ -8509,7 +8781,10 @@ mod tests { let mut announced = producer.consume().announced(); let dynamic = producer - .dynamic_route(Path::new("room").unwrap(), Route::default().with_epoch(epoch()).with_cost(5)) + .dynamic_route( + Path::new("room").unwrap(), + Route::default().with_epoch(epoch()).with_cost(5), + ) .unwrap(); announced.expect_next_active(Path::new("room").unwrap()).await; dynamic.update_route(dynamic.route().with_cost(1)).unwrap(); @@ -8552,8 +8827,12 @@ mod tests { let producer = origin(1).produce(); // Broad and cheap; narrow and expensive. Both present relative to a cursor // rooted below them, and the narrow one is what a request there resolves. - let _broad = producer.announce(Path::new("room").unwrap(), Route::default().with_cost(1)).unwrap(); - let _narrow = producer.announce(Path::new("room/alice").unwrap(), Route::default().with_cost(9)).unwrap(); + let _broad = producer + .announce(Path::new("room").unwrap(), Route::default().with_cost(1)) + .unwrap(); + let _narrow = producer + .announce(Path::new("room/alice").unwrap(), Route::default().with_cost(9)) + .unwrap(); let consumer = producer .consume() @@ -8570,10 +8849,15 @@ mod tests { async fn capture_change_retracts_before_reannouncing_a_presented_prefix() { let producer = origin(1).produce(); let _broad = producer.announce(Path::new("room").unwrap(), Route::default()).unwrap(); - let exact = producer.announce(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let exact = producer + .announce(Path::new("room/alice").unwrap(), Route::default()) + .unwrap(); let consumer = producer .consume() - .scope(Path::new("").unwrap(), &Patterns::from("room/*".parse::().unwrap())) + .scope( + Path::new("").unwrap(), + &Patterns::from("room/*".parse::().unwrap()), + ) .unwrap() .scope(Path::new("room/alice").unwrap(), &Patterns::from(Pattern::all())) .unwrap(); @@ -8631,9 +8915,18 @@ mod tests { let mut announced = consumer.announced(); let _local = producer - .publish(Path::new("room/alice").unwrap(), Route::default().with_epoch(epoch()).with_cost(5)) + .publish( + Path::new("room/alice").unwrap(), + Route::default().with_epoch(epoch()).with_cost(5), + ) .unwrap(); - assert_eq!(announced.expect_next_active(Path::new("room/alice").unwrap()).await.cost, Cost::new(5)); + assert_eq!( + announced + .expect_next_active(Path::new("room/alice").unwrap()) + .await + .cost, + Cost::new(5) + ); let server = producer .dynamic_route( @@ -8664,11 +8957,19 @@ mod tests { let _epoched = producer .publish(Path::new("room/alice").unwrap(), Route::default().with_epoch(epoch())) .unwrap(); - let _plain = producer.publish(Path::new("room/bob").unwrap(), Route::default()).unwrap(); + let _plain = producer + .publish(Path::new("room/bob").unwrap(), Route::default()) + .unwrap(); - let alice = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.unwrap(); + let alice = consumer + .request_broadcast(Path::new("room/alice").unwrap(), None) + .await + .unwrap(); assert_eq!(alice.info().epoch, Some(epoch())); - let bob = consumer.request_broadcast(Path::new("room/bob").unwrap(), None).await.unwrap(); + let bob = consumer + .request_broadcast(Path::new("room/bob").unwrap(), None) + .await + .unwrap(); assert_eq!(bob.info().epoch, None); } @@ -8681,7 +8982,10 @@ mod tests { let consumer = producer.consume(); let _local = producer - .publish(Path::new("room/alice").unwrap(), Route::default().with_epoch(epoch()).with_cost(5)) + .publish( + Path::new("room/alice").unwrap(), + Route::default().with_epoch(epoch()).with_cost(5), + ) .unwrap(); let first = consumer .request_broadcast(Path::new("room/alice").unwrap(), None) @@ -8698,7 +9002,10 @@ mod tests { let upstream = broadcast::Info::new().produce(); request.accept(&upstream); - let second = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); + let second = consumer + .request_broadcast(Path::new("room/alice").unwrap(), None) + .await + .expect("resolves"); assert!(first.is_clone(&second), "the newcomer joins the front"); } @@ -8720,10 +9027,15 @@ mod tests { async fn a_front_lists_its_source() { let producer = origin(1).produce(); let consumer = producer.consume(); - let source = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let source = producer + .publish(Path::new("room/alice").unwrap(), Route::default()) + .unwrap(); let video = source.create_track("video", None).unwrap(); - let front = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.unwrap(); + let front = consumer + .request_broadcast(Path::new("room/alice").unwrap(), None) + .await + .unwrap(); let mut tracks = front.tracks().unwrap(); assert_eq!(listed(&mut tracks).await, "+video"); assert_eq!(listed(&mut tracks).await, "synced"); @@ -8744,12 +9056,17 @@ mod tests { async fn a_front_ends_its_listing_with_its_sources() { let producer = origin(1).produce(); let consumer = producer.consume(); - let source = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let source = producer + .publish(Path::new("room/alice").unwrap(), Route::default()) + .unwrap(); let lister = source.dynamic().lister().unwrap(); lister.add("video", crate::track::Info::default()).unwrap(); lister.synced(); - let front = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.unwrap(); + let front = consumer + .request_broadcast(Path::new("room/alice").unwrap(), None) + .await + .unwrap(); let mut tracks = front.tracks().unwrap(); assert_eq!(listed(&mut tracks).await, "+video"); assert_eq!(listed(&mut tracks).await, "synced"); @@ -8767,12 +9084,18 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let local = producer - .publish(Path::new("room/alice").unwrap(), Route::default().with_epoch(epoch()).with_cost(5)) + .publish( + Path::new("room/alice").unwrap(), + Route::default().with_epoch(epoch()).with_cost(5), + ) .unwrap(); let _a = local.create_track("a", None).unwrap(); let _b = local.create_track("b", None).unwrap(); - let front = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.unwrap(); + let front = consumer + .request_broadcast(Path::new("room/alice").unwrap(), None) + .await + .unwrap(); let mut tracks = front.tracks().unwrap(); assert_eq!(listed(&mut tracks).await, "+a"); assert_eq!(listed(&mut tracks).await, "+b"); @@ -8800,7 +9123,9 @@ mod tests { async fn a_front_through_a_covering_prefix_lists_nothing() { let producer = origin(1).produce(); let consumer = producer.consume(); - let server = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); + let server = producer + .dynamic_route(Path::new("room").unwrap(), Route::default()) + .unwrap(); let pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); let upstream = broadcast::Info::new().produce(); let _video = upstream.create_track("video", None).unwrap(); @@ -8820,14 +9145,21 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); - let _local = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); - let server = producer.dynamic_route(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let _local = producer + .publish(Path::new("room/alice").unwrap(), Route::default()) + .unwrap(); + let server = producer + .dynamic_route(Path::new("room/alice").unwrap(), Route::default()) + .unwrap(); // Were the claim to win, the request would park on its handler forever. - let resolved = moq_clock::timeout(Duration::from_secs(1), consumer.request_broadcast(Path::new("room/alice").unwrap(), None)) - .await - .expect("the newer hopless route won the tie") - .expect("resolves"); + let resolved = moq_clock::timeout( + Duration::from_secs(1), + consumer.request_broadcast(Path::new("room/alice").unwrap(), None), + ) + .await + .expect("the newer hopless route won the tie") + .expect("resolves"); assert_eq!(resolved.info().path.as_str(), "room/alice"); assert!(server.poll_requested_broadcast(&kio::Waiter::noop()).is_pending()); } @@ -8837,9 +9169,11 @@ mod tests { #[moq_clock::test] async fn announce_stats_follow_the_advertisement() { let registry = stats::Registry::new(stats::Config::new()); - let producer = origin(1) - .produce() - .with_stats(registry.tier(stats::Tier::default()).session(Path::new("root").unwrap())); + let producer = origin(1).produce().with_stats( + registry + .tier(stats::Tier::default()) + .session(Path::new("root").unwrap()), + ); let announces = || { registry .snapshot() @@ -8883,11 +9217,23 @@ mod tests { .unwrap(); announced.expect_next_active(Path::new("room/alice").unwrap()).await; let _local = producer - .publish(Path::new("room/alice").unwrap(), Route::default().with_epoch(epoch()).with_cost(2)) + .publish( + Path::new("room/alice").unwrap(), + Route::default().with_epoch(epoch()).with_cost(2), + ) .unwrap(); - assert!(announced.expect_next_active(Path::new("room/alice").unwrap()).await.hops.is_empty()); + assert!( + announced + .expect_next_active(Path::new("room/alice").unwrap()) + .await + .hops + .is_empty() + ); - let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); + let resolved = consumer + .request_broadcast(Path::new("room/alice").unwrap(), None) + .await + .expect("resolves"); assert_eq!(resolved.info().path.as_str(), "room/alice"); for _ in 0..20 { moq_clock::sim::yield_now().await; @@ -8903,11 +9249,20 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); - let broadcast = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); - let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); + let broadcast = producer + .publish(Path::new("room/alice").unwrap(), Route::default()) + .unwrap(); + let resolved = consumer + .request_broadcast(Path::new("room/alice").unwrap(), None) + .await + .expect("resolves"); broadcast.unannounce(); - let err = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.err().unwrap(); + let err = consumer + .request_broadcast(Path::new("room/alice").unwrap(), None) + .await + .err() + .unwrap(); assert!(matches!(err, Error::Unroutable), "joined a retracted front: {err}"); settle(|| resolved.is_closed()).await; assert!(!broadcast.consume().is_closed(), "the broadcast itself lives on"); @@ -8930,9 +9285,14 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); - let broadcast = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let broadcast = producer + .publish(Path::new("room/alice").unwrap(), Route::default()) + .unwrap(); let mut dynamic = broadcast.dynamic(); - let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); + let resolved = consumer + .request_broadcast(Path::new("room/alice").unwrap(), None) + .await + .expect("resolves"); let track = resolved.track("video").unwrap(); let subscribing = moq_clock::sim::spawn(async move { track.subscribe(None).await }); let request = moq_clock::timeout(Duration::from_secs(1), dynamic.requested_track()) @@ -8962,7 +9322,10 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let server = producer - .dynamic_route(Path::new("room/alice").unwrap(), Route::default().with_hops(hops(&[10]))) + .dynamic_route( + Path::new("room/alice").unwrap(), + Route::default().with_hops(hops(&[10])), + ) .unwrap(); let pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); let upstream = broadcast::Info::new().produce(); @@ -9100,7 +9463,9 @@ mod tests { let fronts = || producer.shared.lock().fronts.len(); let peer = producer.consume().excluding(origin(7)); - let _local = producer.consume().request_broadcast(Path::new("room/alice").unwrap(), None); + let _local = producer + .consume() + .request_broadcast(Path::new("room/alice").unwrap(), None); let _peer = peer.request_broadcast(Path::new("room/alice").unwrap(), None); assert_eq!(fronts(), 1, "a hop no chain names excludes nothing"); @@ -9160,10 +9525,15 @@ mod tests { async fn a_request_racing_a_front_retiring_never_joins_it_ending() { let producer = origin(1).produce(); let consumer = producer.consume(); - let _broadcast = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let _broadcast = producer + .publish(Path::new("room/alice").unwrap(), Route::default()) + .unwrap(); let fronts = || producer.shared.lock().fronts.len(); - let first = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); + let first = consumer + .request_broadcast(Path::new("room/alice").unwrap(), None) + .await + .expect("resolves"); let front = first.weak(); drop(first); let again = consumer @@ -9221,7 +9591,9 @@ mod tests { async fn a_front_whose_broadcast_closes_ends() { let producer = origin(1).produce(); let consumer = producer.consume(); - let _published = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let _published = producer + .publish(Path::new("room/alice").unwrap(), Route::default()) + .unwrap(); let path = consumer.absolute(Path::new("room/alice").unwrap()).to_owned(); let broadcast = broadcast::Info::new().produce(); // Held, so the front waits on its holder rather than retiring on its own. @@ -9259,7 +9631,10 @@ mod tests { .unwrap(); // The same publisher, also reached through the peer, at a price the plain front skips. let _echo = producer - .dynamic_route(Path::new("room").unwrap(), Route::default().with_hops(hops(&[10, 7])).with_cost(100)) + .dynamic_route( + Path::new("room").unwrap(), + Route::default().with_hops(hops(&[10, 7])).with_cost(100), + ) .unwrap(); let upstream = broadcast::Info::new().produce(); let source = upstream.create_track("video", crate::track::Info::timed()).unwrap(); @@ -9267,12 +9642,17 @@ mod tests { group.write_frame(crate::Timestamp::ZERO, b"live".as_ref()).unwrap(); let fronts = || producer.shared.lock().fronts.len(); - let pending = producer.consume().request_broadcast(Path::new("room/alice").unwrap(), None); + let pending = producer + .consume() + .request_broadcast(Path::new("room/alice").unwrap(), None); queued(&server).await.accept(&upstream); let _viewer = pending.await.expect("the plain front resolves"); let peer = producer.consume().excluding(origin(7)); - let peered = peer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); + let peered = peer + .request_broadcast(Path::new("room/alice").unwrap(), None) + .await + .expect("resolves"); assert_eq!(fronts(), 2, "the peer has a front of its own"); let mut subscription = peered.track("video").unwrap().subscribe(None).await.unwrap(); next_group(&mut subscription).await.unwrap().expect("the live group"); @@ -9295,7 +9675,10 @@ mod tests { let peer = producer.consume().excluding(origin(7)); let mut view = peer.announced(); let incumbent = producer - .dynamic_route(Path::new("room").unwrap(), Route::default().with_epoch(epoch()).with_hops(hops(&[10]))) + .dynamic_route( + Path::new("room").unwrap(), + Route::default().with_epoch(epoch()).with_hops(hops(&[10])), + ) .unwrap(); view.expect_next_active(Path::new("room").unwrap()).await; @@ -9306,7 +9689,10 @@ mod tests { // The same publisher, now also reached through the peer, outlives the incumbent. let echo = producer - .dynamic_route(Path::new("room").unwrap(), Route::default().with_epoch(epoch()).with_hops(hops(&[10, 7]))) + .dynamic_route( + Path::new("room").unwrap(), + Route::default().with_epoch(epoch()).with_hops(hops(&[10, 7])), + ) .unwrap(); drop(incumbent); drop(source); @@ -9340,7 +9726,9 @@ mod tests { Route::default().with_epoch(epoch()).with_hops(hops(&[10])).with_cost(5), ) .unwrap(); - let pending = producer.consume().request_broadcast(Path::new("room/alice").unwrap(), None); + let pending = producer + .consume() + .request_broadcast(Path::new("room/alice").unwrap(), None); let upstream = broadcast::Info::new().produce(); let mut dynamic = upstream.dynamic(); queued(&first_server).await.accept(&upstream); @@ -9503,9 +9891,14 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); - let broadcast = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let broadcast = producer + .publish(Path::new("room/alice").unwrap(), Route::default()) + .unwrap(); let mut dynamic = broadcast.dynamic(); - let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); + let resolved = consumer + .request_broadcast(Path::new("room/alice").unwrap(), None) + .await + .expect("resolves"); let track = resolved.track("video").unwrap(); let subscribing = moq_clock::sim::spawn(async move { track.subscribe(None).await }); let request = moq_clock::timeout(Duration::from_secs(1), dynamic.requested_track()) @@ -9560,8 +9953,13 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); - let broadcast = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); - let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); + let broadcast = producer + .publish(Path::new("room/alice").unwrap(), Route::default()) + .unwrap(); + let resolved = consumer + .request_broadcast(Path::new("room/alice").unwrap(), None) + .await + .expect("resolves"); broadcast.unannounce(); broadcast.announce(Route::default()).unwrap(); @@ -9569,7 +9967,10 @@ mod tests { moq_clock::sim::yield_now().await; } assert!(!resolved.is_closed(), "the front ended across a reannouncement"); - let again = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); + let again = consumer + .request_broadcast(Path::new("room/alice").unwrap(), None) + .await + .expect("resolves"); assert!(again.is_clone(&resolved)); } @@ -9590,7 +9991,10 @@ mod tests { assert!(matches!(err, Error::Unroutable)); broadcast.announce(Route::default()).unwrap(); - let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); + let resolved = consumer + .request_broadcast(Path::new("room/alice").unwrap(), None) + .await + .expect("resolves"); assert_eq!(resolved.info().path.as_str(), "room/alice"); drop(broadcast); @@ -9608,7 +10012,9 @@ mod tests { async fn create_broadcast_accepts_a_max_depth_path() { let producer = origin(1).produce(); let path = vec!["a"; Path::MAX_PARTS].join("/"); - let _broadcast = producer.create_broadcast(Path::new(path.as_str()).unwrap()).expect("max depth is allowed"); + let _broadcast = producer + .create_broadcast(Path::new(path.as_str()).unwrap()) + .expect("max depth is allowed"); let deeper = vec!["a"; Path::MAX_PARTS + 1].join("/"); assert!(matches!( producer.create_broadcast(Path::new(deeper.as_str()).unwrap()), @@ -9620,8 +10026,12 @@ mod tests { #[cfg(feature = "async")] async fn duplicate_routes_aggregate_until_the_last_leaves() { let producer = origin(1).produce(); - let first = producer.dynamic_route(Path::new("live").unwrap(), Route::default().with_cost(3)).unwrap(); - let second = producer.dynamic_route(Path::new("live").unwrap(), Route::default().with_cost(1)).unwrap(); + let first = producer + .dynamic_route(Path::new("live").unwrap(), Route::default().with_cost(3)) + .unwrap(); + let second = producer + .dynamic_route(Path::new("live").unwrap(), Route::default().with_cost(1)) + .unwrap(); let mut announced = producer.consume().announced(); let Some(Some(AnnounceEvent::Start(update))) = announced.next().now_or_never() else { @@ -9633,7 +10043,10 @@ mod tests { // Without an epoch the survivor is another source. drop(second); - assert_eq!(announced.expect_next_restarted(Path::new("live").unwrap()).await.cost, Cost::new(3)); + assert_eq!( + announced.expect_next_restarted(Path::new("live").unwrap()).await.cost, + Cost::new(3) + ); drop(first); announced.expect_next_ended(Path::new("live").unwrap()).await; @@ -9686,7 +10099,9 @@ mod tests { assert!(matches!(refused, Err(Error::Unroutable))); assert!(dynamic.requested_broadcast().now_or_never().is_none()); - let _pending = producer.consume().request_broadcast(Path::new("room/chat").unwrap(), None); + let _pending = producer + .consume() + .request_broadcast(Path::new("room/chat").unwrap(), None); let request = queued(&dynamic).await; assert_eq!(request.path().as_str(), "room/chat"); } @@ -9696,7 +10111,10 @@ mod tests { let producer = origin(1).produce(); let scoped = |pattern: &str| { producer - .scope(Path::new("").unwrap(), &Patterns::from(pattern.parse::().unwrap())) + .scope( + Path::new("").unwrap(), + &Patterns::from(pattern.parse::().unwrap()), + ) .unwrap() }; let _chat = scoped("*/chat") @@ -9711,7 +10129,10 @@ mod tests { .scope(Path::new("").unwrap(), &scopes(&["room/video"])) .unwrap() .announced(); - assert_eq!(video.expect_next_active(Path::new("").unwrap()).await.cost, Cost::new(5)); + assert_eq!( + video.expect_next_active(Path::new("").unwrap()).await.cost, + Cost::new(5) + ); } #[moq_clock::test] @@ -9734,33 +10155,63 @@ mod tests { let chat = producer .scope(Path::new("").unwrap(), &scopes(&["room/live/chat"])) .unwrap() - .dynamic_route(Path::new("room/live").unwrap(), Route::default().with_hops(hops(&[7])).with_cost(1)) + .dynamic_route( + Path::new("room/live").unwrap(), + Route::default().with_hops(hops(&[7])).with_cost(1), + ) .unwrap(); - assert_eq!(all.expect_next_active(Path::new("room/live").unwrap()).await.cost, Cost::new(1)); - assert_eq!(rooted.expect_next_active(Path::new("").unwrap()).await.cost, Cost::new(1)); + assert_eq!( + all.expect_next_active(Path::new("room/live").unwrap()).await.cost, + Cost::new(1) + ); + assert_eq!( + rooted.expect_next_active(Path::new("").unwrap()).await.cost, + Cost::new(1) + ); excluded.assert_next_wait(); video.assert_next_wait(); let video_route = producer .scope(Path::new("").unwrap(), &scopes(&["room/live/video"])) .unwrap() - .dynamic_route(Path::new("room/live").unwrap(), Route::default().with_hops(hops(&[8])).with_cost(5)) + .dynamic_route( + Path::new("room/live").unwrap(), + Route::default().with_hops(hops(&[8])).with_cost(5), + ) .unwrap(); all.assert_next_wait(); rooted.assert_next_wait(); - assert_eq!(excluded.expect_next_active(Path::new("room/live").unwrap()).await.cost, Cost::new(5)); - assert_eq!(video.expect_next_active(Path::new("room/live").unwrap()).await.cost, Cost::new(5)); + assert_eq!( + excluded.expect_next_active(Path::new("room/live").unwrap()).await.cost, + Cost::new(5) + ); + assert_eq!( + video.expect_next_active(Path::new("room/live").unwrap()).await.cost, + Cost::new(5) + ); chat.update_route(Route::default().with_hops(hops(&[7])).with_cost(9)) .unwrap(); - assert_eq!(all.expect_next_active(Path::new("room/live").unwrap()).await.cost, Cost::new(5)); - assert_eq!(rooted.expect_next_active(Path::new("").unwrap()).await.cost, Cost::new(5)); + assert_eq!( + all.expect_next_active(Path::new("room/live").unwrap()).await.cost, + Cost::new(5) + ); + assert_eq!( + rooted.expect_next_active(Path::new("").unwrap()).await.cost, + Cost::new(5) + ); excluded.assert_next_wait(); video.assert_next_wait(); drop(video_route); - assert_eq!(all.expect_next_active(Path::new("room/live").unwrap()).await.cost, Cost::new(9)); - assert_eq!(rooted.expect_next_active(Path::new("").unwrap()).await.cost, Cost::new(9)); + assert_eq!( + all.expect_next_active(Path::new("room/live").unwrap()).await.cost, + Cost::new(9) + ); + assert_eq!( + rooted.expect_next_active(Path::new("").unwrap()).await.cost, + Cost::new(9) + ); excluded.expect_next_ended(Path::new("room/live").unwrap()).await; video.expect_next_ended(Path::new("room/live").unwrap()).await; } @@ -9769,7 +10220,9 @@ mod tests { #[cfg(feature = "async")] async fn root_cursor_keeps_the_more_specific_covering_route() { let producer = origin(1).produce(); - let broad = producer.dynamic_route(Path::new("room").unwrap(), Route::default().with_cost(1)).unwrap(); + let broad = producer + .dynamic_route(Path::new("room").unwrap(), Route::default().with_cost(1)) + .unwrap(); let narrow = producer .dynamic_route(Path::new("room/live").unwrap(), Route::default().with_cost(9)) .unwrap(); @@ -9778,14 +10231,23 @@ mod tests { .scope(Path::new("room/live/video").unwrap(), &Patterns::from(Pattern::all())) .unwrap() .announced(); - assert_eq!(announced.expect_next_active(Path::new("").unwrap()).await.cost, Cost::new(9)); + assert_eq!( + announced.expect_next_active(Path::new("").unwrap()).await.cost, + Cost::new(9) + ); broad.update_route(Route::default().with_cost(0)).unwrap(); announced.assert_next_wait(); narrow.update_route(Route::default().with_cost(8)).unwrap(); - assert_eq!(announced.expect_next_active(Path::new("").unwrap()).await.cost, Cost::new(8)); + assert_eq!( + announced.expect_next_active(Path::new("").unwrap()).await.cost, + Cost::new(8) + ); drop(narrow); - assert_eq!(announced.expect_next_active(Path::new("").unwrap()).await.cost, Cost::new(0)); + assert_eq!( + announced.expect_next_active(Path::new("").unwrap()).await.cost, + Cost::new(0) + ); } #[moq_clock::test] @@ -9828,7 +10290,9 @@ mod tests { async fn announce_consumer_is_a_stream() { use futures::StreamExt; let producer = origin(1).produce(); - let server = producer.dynamic_route(Path::new("live").unwrap(), Route::default()).unwrap(); + let server = producer + .dynamic_route(Path::new("live").unwrap(), Route::default()) + .unwrap(); let mut announced = producer.consume().announced(); let mut next = || StreamExt::next(&mut announced).now_or_never(); let Some(Some(AnnounceEvent::Start(update))) = next() else { @@ -9843,7 +10307,9 @@ mod tests { #[moq_clock::test] async fn dynamic_retracts() { let producer = origin(1).produce(); - let server = producer.dynamic_route(Path::new("live").unwrap(), Route::default()).unwrap(); + let server = producer + .dynamic_route(Path::new("live").unwrap(), Route::default()) + .unwrap(); let mut announced = producer.consume().announced(); announced.expect_next_active(Path::new("live").unwrap()).await; @@ -9875,7 +10341,9 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); - let server = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); + let server = producer + .dynamic_route(Path::new("room").unwrap(), Route::default()) + .unwrap(); let pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); let request = queued(&server).await; @@ -9889,7 +10357,10 @@ mod tests { assert_eq!(resolved.info().path.as_str(), "room/alice"); // A repeat request shares the served broadcast instead of re-asking. - let again = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); + let again = consumer + .request_broadcast(Path::new("room/alice").unwrap(), None) + .await + .expect("resolves"); assert!(again.is_clone(&resolved)); } @@ -9898,7 +10369,9 @@ mod tests { async fn served_requests_coalesce() { let producer = origin(1).produce(); let consumer = producer.consume(); - let server = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); + let server = producer + .dynamic_route(Path::new("room").unwrap(), Route::default()) + .unwrap(); let first = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); let second = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); @@ -9920,7 +10393,9 @@ mod tests { async fn retract_rejects_pending_requests() { let producer = origin(1).produce(); let consumer = producer.consume(); - let server = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); + let server = producer + .dynamic_route(Path::new("room").unwrap(), Route::default()) + .unwrap(); let pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); drop(server); @@ -9946,9 +10421,15 @@ mod tests { // Three identical routes, oldest first: the newest identical route wins // requests, and swapping between them emits no announce update. - let standby_server = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); - let second_server = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); - let incumbent_server = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); + let standby_server = producer + .dynamic_route(Path::new("room").unwrap(), Route::default()) + .unwrap(); + let second_server = producer + .dynamic_route(Path::new("room").unwrap(), Route::default()) + .unwrap(); + let incumbent_server = producer + .dynamic_route(Path::new("room").unwrap(), Route::default()) + .unwrap(); let mut resolving = Box::pin(consumer.routed_broadcast(Path::new("room/alice").unwrap())); assert!((&mut resolving).now_or_never().is_none()); @@ -10001,9 +10482,14 @@ mod tests { let mut announced = producer.consume().announced(); let _ingest = producer - .dynamic_route(Path::new("client").unwrap(), Route::default().with_hops(hops(&[5])).with_via(origin(5))) + .dynamic_route( + Path::new("client").unwrap(), + Route::default().with_hops(hops(&[5])).with_via(origin(5)), + ) + .unwrap(); + let _gateway = producer + .publish(Path::new("gateway").unwrap(), Route::default()) .unwrap(); - let _gateway = producer.publish(Path::new("gateway").unwrap(), Route::default()).unwrap(); let _forwarded = peer .dynamic_route( Path::new("forwarded").unwrap(), @@ -10011,18 +10497,40 @@ mod tests { ) .unwrap(); - assert_eq!(announced.expect_next_active(Path::new("client").unwrap()).await.source(), Source::Local); - assert_eq!(announced.expect_next_active(Path::new("gateway").unwrap()).await.source(), Source::Local); assert_eq!( - announced.expect_next_active(Path::new("forwarded").unwrap()).await.source(), + announced + .expect_next_active(Path::new("client").unwrap()) + .await + .source(), + Source::Local + ); + assert_eq!( + announced + .expect_next_active(Path::new("gateway").unwrap()) + .await + .source(), + Source::Local + ); + assert_eq!( + announced + .expect_next_active(Path::new("forwarded").unwrap()) + .await + .source(), Source::Peer(origin(7)) ); // The mark survives narrowing the handle. - let scoped = peer.scope(Path::new("room").unwrap(), &Patterns::from(Pattern::all())).unwrap(); - let _nested = scoped.dynamic_route(Path::new("x").unwrap(), Route::default().with_via(origin(8))).unwrap(); + let scoped = peer + .scope(Path::new("room").unwrap(), &Patterns::from(Pattern::all())) + .unwrap(); + let _nested = scoped + .dynamic_route(Path::new("x").unwrap(), Route::default().with_via(origin(8))) + .unwrap(); assert_eq!( - announced.expect_next_active(Path::new("room/x").unwrap()).await.source(), + announced + .expect_next_active(Path::new("room/x").unwrap()) + .await + .source(), Source::Peer(origin(8)) ); } @@ -10054,10 +10562,14 @@ mod tests { .with_hops(hops(chain)) .with_via(origin(via)) }; - let near = peer.dynamic_route(Path::new("room").unwrap(), route(&[9, 2], 2)).unwrap(); + let near = peer + .dynamic_route(Path::new("room").unwrap(), route(&[9, 2], 2)) + .unwrap(); announced.assert_try_next_active(Path::new("room").unwrap()); - let _far = peer.dynamic_route(Path::new("room").unwrap(), route(&[9, 3, 4], 4)).unwrap(); + let _far = peer + .dynamic_route(Path::new("room").unwrap(), route(&[9, 3, 4], 4)) + .unwrap(); drop(near); assert!(announced.try_next().is_none(), "the update is held"); step(Duration::from_millis(1)).await; @@ -10092,8 +10604,14 @@ mod tests { let mut near = Vec::new(); let mut far = Vec::new(); for i in 0..k { - near.push(peer.dynamic_route(Path::try_from(format!("room/{i}")).unwrap(), route(&[9, 2], 2)).unwrap()); - far.push(peer.dynamic_route(Path::try_from(format!("room/{i}")).unwrap(), route(&[9, 3, 4], 4)).unwrap()); + near.push( + peer.dynamic_route(Path::try_from(format!("room/{i}")).unwrap(), route(&[9, 2], 2)) + .unwrap(), + ); + far.push( + peer.dynamic_route(Path::try_from(format!("room/{i}")).unwrap(), route(&[9, 3, 4], 4)) + .unwrap(), + ); } let mut announced = producer.consume().announced(); for _ in 0..k { @@ -10138,12 +10656,18 @@ mod tests { .with_hops(hops(chain)) .with_via(origin(via)) }; - let near = peer.dynamic_route(Path::new("room").unwrap(), route(&[9, 2], 2)).unwrap(); + let near = peer + .dynamic_route(Path::new("room").unwrap(), route(&[9, 2], 2)) + .unwrap(); announced.expect_next_active(Path::new("room").unwrap()).await; // The best route changes twice; the consumer sees only the last, once. - let far = peer.dynamic_route(Path::new("room").unwrap(), route(&[9, 3, 4], 4)).unwrap(); - let farther = peer.dynamic_route(Path::new("room").unwrap(), route(&[9, 5, 6, 7], 7)).unwrap(); + let far = peer + .dynamic_route(Path::new("room").unwrap(), route(&[9, 3, 4], 4)) + .unwrap(); + let farther = peer + .dynamic_route(Path::new("room").unwrap(), route(&[9, 5, 6, 7], 7)) + .unwrap(); let start = moq_clock::now(); drop(near); drop(far); @@ -10171,30 +10695,40 @@ mod tests { let route = |chain: &[u64], via| Route::default().with_hops(hops(chain)).with_via(origin(via)); - let near = peer.dynamic_route(Path::new("named").unwrap(), route(&[9, 2], 2)).unwrap(); + let near = peer + .dynamic_route(Path::new("named").unwrap(), route(&[9, 2], 2)) + .unwrap(); announced.expect_next_active(Path::new("named").unwrap()).await; drop(near); announced.expect_next_ended(Path::new("named").unwrap()).await; let start = moq_clock::now(); - let _stale = peer.dynamic_route(Path::new("named").unwrap(), route(&[9, 3, 4], 4)).unwrap(); + let _stale = peer + .dynamic_route(Path::new("named").unwrap(), route(&[9, 3, 4], 4)) + .unwrap(); match announced.next().await.unwrap() { AnnounceEvent::Start(announce) => assert_eq!(announce.route.hops, hops(&[9, 3, 4])), other => panic!("should be a start: got {other:?}"), } assert!(moq_clock::now() - start >= RETRACT_QUARANTINE); - let near = peer.dynamic_route(Path::new("anonymous").unwrap(), route(&[0, 2], 2)).unwrap(); + let near = peer + .dynamic_route(Path::new("anonymous").unwrap(), route(&[0, 2], 2)) + .unwrap(); announced.expect_next_active(Path::new("anonymous").unwrap()).await; drop(near); announced.expect_next_ended(Path::new("anonymous").unwrap()).await; - let _other = peer.dynamic_route(Path::new("anonymous").unwrap(), route(&[0, 3, 4], 4)).unwrap(); + let _other = peer + .dynamic_route(Path::new("anonymous").unwrap(), route(&[0, 3, 4], 4)) + .unwrap(); announced.expect_next_active(Path::new("anonymous").unwrap()).await; // Retract and announce cycles at one clock reading queue the prefix once, // whether or not the route names its publisher. let queued = announced.anchoring.len(); for chain in [[9, 2], [0, 2], [9, 2], [0, 2]] { - let churn = peer.dynamic_route(Path::new("churn").unwrap(), route(&chain, 2)).unwrap(); + let churn = peer + .dynamic_route(Path::new("churn").unwrap(), route(&chain, 2)) + .unwrap(); announced.expect_next_active(Path::new("churn").unwrap()).await; drop(churn); announced.expect_next_ended(Path::new("churn").unwrap()).await; @@ -10203,7 +10737,9 @@ mod tests { // A quarantine is forgotten once it ends: the cursor wakes to anchor it, // then again to drop it. - let gone = peer.dynamic_route(Path::new("gone").unwrap(), route(&[9, 2], 2)).unwrap(); + let gone = peer + .dynamic_route(Path::new("gone").unwrap(), route(&[9, 2], 2)) + .unwrap(); announced.expect_next_active(Path::new("gone").unwrap()).await; drop(gone); announced.expect_next_ended(Path::new("gone").unwrap()).await; @@ -10229,7 +10765,10 @@ mod tests { let direct = || Route::default().with_hops(hops(&[9, 2])).with_via(origin(2)); let first = peer.dynamic_route(Path::new("room").unwrap(), direct()).unwrap(); let relayed = peer - .dynamic_route(Path::new("room").unwrap(), Route::default().with_hops(hops(&[9, 2, 3])).with_via(origin(3))) + .dynamic_route( + Path::new("room").unwrap(), + Route::default().with_hops(hops(&[9, 2, 3])).with_via(origin(3)), + ) .unwrap(); announced.expect_next_active(Path::new("room").unwrap()).await; announced.assert_next_wait(); @@ -10347,7 +10886,10 @@ mod tests { let mut local = producer.consume().local().announced(); let _forwarded = peer - .dynamic_route(Path::new("remote").unwrap(), Route::default().with_hops(hops(&[7])).with_via(origin(7))) + .dynamic_route( + Path::new("remote").unwrap(), + Route::default().with_hops(hops(&[7])).with_via(origin(7)), + ) .unwrap(); local.assert_next_wait(); @@ -10355,7 +10897,10 @@ mod tests { // and retracts from the local view when the local route goes, even though // the peer's still covers it. let _shadow = peer - .dynamic_route(Path::new("both").unwrap(), Route::default().with_hops(hops(&[7])).with_via(origin(7))) + .dynamic_route( + Path::new("both").unwrap(), + Route::default().with_hops(hops(&[7])).with_via(origin(7)), + ) .unwrap(); let ingest = producer .dynamic_route( @@ -10363,7 +10908,10 @@ mod tests { Route::default().with_hops(hops(&[5])).with_via(origin(5)).with_cost(9), ) .unwrap(); - assert_eq!(local.expect_next_active(Path::new("both").unwrap()).await.source(), Source::Local); + assert_eq!( + local.expect_next_active(Path::new("both").unwrap()).await.source(), + Source::Local + ); drop(ingest); local.expect_next_ended(Path::new("both").unwrap()).await; @@ -10399,7 +10947,10 @@ mod tests { let mut everyone = producer.consume().announced(); let _core = core - .dynamic_route(Path::new("core").unwrap(), Route::default().with_hops(hops(&[7])).with_via(origin(7))) + .dynamic_route( + Path::new("core").unwrap(), + Route::default().with_hops(hops(&[7])).with_via(origin(7)), + ) .unwrap(); assert_eq!( everyone.expect_next_active(Path::new("core").unwrap()).await.source(), @@ -10408,17 +10959,26 @@ mod tests { toward_core.assert_next_wait(); let _mesh = peer - .dynamic_route(Path::new("mesh").unwrap(), Route::default().with_hops(hops(&[8])).with_via(origin(8))) + .dynamic_route( + Path::new("mesh").unwrap(), + Route::default().with_hops(hops(&[8])).with_via(origin(8)), + ) .unwrap(); assert_eq!( - toward_core.expect_next_active(Path::new("mesh").unwrap()).await.source(), + toward_core + .expect_next_active(Path::new("mesh").unwrap()) + .await + .source(), Source::Peer(origin(8)) ); // A path both an upstream and a mesh peer reach: the upstream route is // cheaper, yet the upstream view selects the mesh peer's. let _cheap = core - .dynamic_route(Path::new("both").unwrap(), Route::default().with_hops(hops(&[7])).with_via(origin(7))) + .dynamic_route( + Path::new("both").unwrap(), + Route::default().with_hops(hops(&[7])).with_via(origin(7)), + ) .unwrap(); let mesh = peer .dynamic_route( @@ -10427,7 +10987,10 @@ mod tests { ) .unwrap(); assert_eq!( - toward_core.expect_next_active(Path::new("both").unwrap()).await.source(), + toward_core + .expect_next_active(Path::new("both").unwrap()) + .await + .source(), Source::Peer(origin(8)) ); drop(mesh); @@ -10460,7 +11023,9 @@ mod tests { async fn handler_rejection_is_final() { let producer = origin(1).produce(); let consumer = producer.consume(); - let server = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); + let server = producer + .dynamic_route(Path::new("room").unwrap(), Route::default()) + .unwrap(); let pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); let request = queued(&server).await; @@ -10512,7 +11077,9 @@ mod tests { let mut announced = producer.consume().announced(); let claim = producer.dynamic(Path::new("room").unwrap()).unwrap(); announced.assert_next_active(Path::new("room").unwrap()); - let pending = producer.consume().request_broadcast(Path::new("room/alice").unwrap(), None); + let pending = producer + .consume() + .request_broadcast(Path::new("room/alice").unwrap(), None); let epoch = crate::Epoch::mint(); let prepared = queued(&claim).await.prepare(epoch.clone()).unwrap(); let answer = prepared.broadcast().clone(); @@ -10533,7 +11100,9 @@ mod tests { async fn a_refused_prepared_answer_cannot_announce_later() { let producer = origin(1).produce(); let claim = producer.dynamic(Path::new("room").unwrap()).unwrap(); - let _pending = producer.consume().request_broadcast(Path::new("room/alice").unwrap(), None); + let _pending = producer + .consume() + .request_broadcast(Path::new("room/alice").unwrap(), None); let prepared = queued(&claim).await.prepare(crate::Epoch::mint()).unwrap(); let answer = prepared.broadcast().clone(); @@ -10562,7 +11131,9 @@ mod tests { let mut announced = producer.consume().announced(); let claim = producer.dynamic(Path::new("room").unwrap()).unwrap(); announced.assert_next_active(Path::new("room").unwrap()); - let _pending = producer.consume().request_broadcast(Path::new("room/alice").unwrap(), None); + let _pending = producer + .consume() + .request_broadcast(Path::new("room/alice").unwrap(), None); let prepared = queued(&claim).await.prepare(crate::Epoch::mint()).unwrap(); drop(claim); @@ -10579,7 +11150,9 @@ mod tests { let mut announced = producer.consume().announced(); let claim = producer.dynamic(Path::new("room").unwrap()).unwrap(); announced.assert_next_active(Path::new("room").unwrap()); - let _pending = producer.consume().request_broadcast(Path::new("room/alice").unwrap(), None); + let _pending = producer + .consume() + .request_broadcast(Path::new("room/alice").unwrap(), None); let prepared = queued(&claim).await.prepare(crate::Epoch::mint()).unwrap(); claim @@ -10606,7 +11179,9 @@ mod tests { let _published = queued(&claim).await.prepare(epoch.clone()).unwrap().publish().unwrap(); pending.await.expect("resolves"); - let pinned = consumer.request_broadcast(Path::new("room/alice").unwrap(), epoch.clone()).await; + let pinned = consumer + .request_broadcast(Path::new("room/alice").unwrap(), epoch.clone()) + .await; assert_eq!(pinned.expect("resolves").info().epoch.as_ref(), Some(&epoch)); let stale = consumer.request_broadcast(Path::new("room/alice").unwrap(), crate::Epoch::mint()); assert!(matches!(stale.await, Err(Error::Unroutable))); @@ -10618,7 +11193,9 @@ mod tests { async fn an_application_claim_cannot_accept_an_arbitrary_broadcast() { let producer = origin(1).produce(); let claim = producer.dynamic(Path::new("room").unwrap()).unwrap(); - let _pending = producer.consume().request_broadcast(Path::new("room/alice").unwrap(), None); + let _pending = producer + .consume() + .request_broadcast(Path::new("room/alice").unwrap(), None); queued(&claim).await.accept(broadcast::Info::new().produce()); } @@ -10629,9 +11206,15 @@ mod tests { async fn refusal_never_falls_through() { let producer = origin(1).produce(); let consumer = producer.consume(); - let catch_all = producer.dynamic_route(Path::new("").unwrap(), Route::default()).unwrap(); - let winner = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); - let sibling = producer.dynamic_route(Path::new("room").unwrap(), Route::default().with_cost(2)).unwrap(); + let catch_all = producer + .dynamic_route(Path::new("").unwrap(), Route::default()) + .unwrap(); + let winner = producer + .dynamic_route(Path::new("room").unwrap(), Route::default()) + .unwrap(); + let sibling = producer + .dynamic_route(Path::new("room").unwrap(), Route::default().with_cost(2)) + .unwrap(); let mut pending = Box::pin(consumer.request_broadcast(Path::new("room/alice").unwrap(), None)); assert!((&mut pending).now_or_never().is_none()); @@ -10657,7 +11240,9 @@ mod tests { async fn superseded_refusal_does_not_end_the_request() { let producer = origin(1).produce(); let consumer = producer.consume(); - let stale = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); + let stale = producer + .dynamic_route(Path::new("room").unwrap(), Route::default()) + .unwrap(); let mut pending = Box::pin(consumer.request_broadcast(Path::new("room/alice").unwrap(), None)); assert!((&mut pending).now_or_never().is_none()); @@ -10684,13 +11269,17 @@ mod tests { async fn refusal_from_a_beaten_route_asks_the_new_winner() { let producer = origin(1).produce(); let consumer = producer.consume(); - let stale = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); + let stale = producer + .dynamic_route(Path::new("room").unwrap(), Route::default()) + .unwrap(); let mut pending = Box::pin(consumer.request_broadcast(Path::new("room/alice").unwrap(), None)); assert!((&mut pending).now_or_never().is_none()); let request = queued(&stale).await; - let winner = producer.dynamic_route(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let winner = producer + .dynamic_route(Path::new("room/alice").unwrap(), Route::default()) + .unwrap(); request.reject(Error::NotFound); let source = broadcast::Info::new().produce(); queued(&winner).await.accept(&source); @@ -10711,7 +11300,9 @@ mod tests { async fn routed_broadcast_waits_out_a_rejection() { let producer = origin(1).produce(); let consumer = producer.consume(); - let server = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); + let server = producer + .dynamic_route(Path::new("room").unwrap(), Route::default()) + .unwrap(); let mut resolving = Box::pin(consumer.routed_broadcast(Path::new("room/alice").unwrap())); assert!((&mut resolving).now_or_never().is_none()); @@ -10740,7 +11331,9 @@ mod tests { async fn routed_broadcast_reports_teardown_as_closed() { let (producer, driver) = Producer::new(Config::new(origin(1))); let consumer = producer.consume(); - let _server = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); + let _server = producer + .dynamic_route(Path::new("room").unwrap(), Route::default()) + .unwrap(); // Park on the covering route, past the loop's closed check. let mut resolving = Box::pin(consumer.routed_broadcast(Path::new("room/alice").unwrap())); @@ -10763,7 +11356,9 @@ mod tests { async fn routed_broadcast_wakes_for_a_local_broadcast() { let producer = origin(1).produce(); let consumer = producer.consume(); - let server = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); + let server = producer + .dynamic_route(Path::new("room").unwrap(), Route::default()) + .unwrap(); let mut resolving = Box::pin(consumer.routed_broadcast(Path::new("room/alice").unwrap())); assert!((&mut resolving).now_or_never().is_none()); @@ -10774,7 +11369,9 @@ mod tests { assert!((&mut resolving).now_or_never().is_none()); // The more specific route wins outright over the handler's prefix. - let _local = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let _local = producer + .publish(Path::new("room/alice").unwrap(), Route::default()) + .unwrap(); let resolved = resolving.await.expect("resolves locally"); assert_eq!(resolved.info().path.as_str(), "room/alice"); assert!(server.poll_requested_broadcast(&kio::Waiter::noop()).is_pending()); @@ -10787,7 +11384,9 @@ mod tests { async fn late_track_on_a_served_front_replays() { let producer = origin(1).produce(); let consumer = producer.consume(); - let server = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); + let server = producer + .dynamic_route(Path::new("room").unwrap(), Route::default()) + .unwrap(); let source = broadcast::Info::new().produce(); for name in ["a", "b"] { @@ -10827,10 +11426,14 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); - let broad_server = producer.dynamic_route(Path::new("").unwrap(), Route::default()).unwrap(); + let broad_server = producer + .dynamic_route(Path::new("").unwrap(), Route::default()) + .unwrap(); // A narrow advertise-only claim: requests under it must NOT route to the // broad server; they fall through to the (absent) fallback handler. - let _narrow = producer.announce(Path::new(".dash").unwrap(), Route::default()).unwrap(); + let _narrow = producer + .announce(Path::new(".dash").unwrap(), Route::default()) + .unwrap(); let err = consumer .request_broadcast(Path::new(".dash/pid").unwrap(), None) @@ -10852,7 +11455,9 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let mut announced = consumer.announced(); - let dynamic = producer.dynamic_route(Path::new("").unwrap(), Route::default()).unwrap(); + let dynamic = producer + .dynamic_route(Path::new("").unwrap(), Route::default()) + .unwrap(); // The root claim is advertised like any other prefix. announced.expect_next_active(Path::new("").unwrap()).await; @@ -10886,8 +11491,13 @@ mod tests { #[cfg(feature = "async")] async fn out_of_scope_request_never_reaches_the_dynamic_handler() { let producer = origin(1).produce(); - let dynamic = producer.dynamic_route(Path::new("").unwrap(), Route::default()).unwrap(); - let scoped = producer.consume().scope(Path::new("").unwrap(), &scopes(&["tenant-a"])).unwrap(); + let dynamic = producer + .dynamic_route(Path::new("").unwrap(), Route::default()) + .unwrap(); + let scoped = producer + .consume() + .scope(Path::new("").unwrap(), &scopes(&["tenant-a"])) + .unwrap(); // `tenant-a-other` shares a character prefix but not a segment, so this // also pins that the check is segment-aware rather than textual. @@ -10914,7 +11524,9 @@ mod tests { assert!((&mut fut).now_or_never().is_none()); // A covering prefix resolves the wait. - let _a = producer.announce(Path::new("room").unwrap(), Route::default().with_cost(3)).unwrap(); + let _a = producer + .announce(Path::new("room").unwrap(), Route::default().with_cost(3)) + .unwrap(); let route = fut.now_or_never().expect("covered").expect("routed"); assert_eq!(route.cost, Cost::new(3)); @@ -10933,11 +11545,15 @@ mod tests { let consumer = producer.consume(); // A deeper route does not cover the shorter path. - let _deep = producer.announce(Path::new("room/alice/cam").unwrap(), Route::default()).unwrap(); + let _deep = producer + .announce(Path::new("room/alice/cam").unwrap(), Route::default()) + .unwrap(); let mut fut = consumer.routed(Path::new("room/alice").unwrap()).boxed(); assert!((&mut fut).now_or_never().is_none()); - let _exact = producer.announce(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let _exact = producer + .announce(Path::new("room/alice").unwrap(), Route::default()) + .unwrap(); fut.now_or_never().expect("covered").expect("routed"); } @@ -10971,7 +11587,9 @@ mod tests { let mut announced = consumer.announced(); announced.expect_next_active(Path::new("room").unwrap()).await; - let _server = producer.dynamic_route(Path::new("served").unwrap(), Route::default()).unwrap(); + let _server = producer + .dynamic_route(Path::new("served").unwrap(), Route::default()) + .unwrap(); let pending = consumer.request_broadcast(Path::new("served/path").unwrap(), None); drop(driver); @@ -10982,8 +11600,14 @@ mod tests { // Pending requests reject; new work refuses. assert!(matches!(pending.now_or_never().expect("rejected"), Err(Error::Closed))); - assert!(matches!(producer.announce(Path::new("x").unwrap(), Route::default()), Err(Error::Closed))); - assert!(matches!(producer.create_broadcast(Path::new("x").unwrap()), Err(Error::Closed))); + assert!(matches!( + producer.announce(Path::new("x").unwrap(), Route::default()), + Err(Error::Closed) + )); + assert!(matches!( + producer.create_broadcast(Path::new("x").unwrap()), + Err(Error::Closed) + )); let err = consumer .request_broadcast(Path::new("y").unwrap(), None) .now_or_never() @@ -11004,7 +11628,9 @@ mod tests { let (producer, driver) = Producer::new(Config::new(origin(1))); let snapshot = producer.snapshot(Path::new("room").unwrap()); let mut announced = producer.consume().announced(); - let _alice = producer.announce(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let _alice = producer + .announce(Path::new("room/alice").unwrap(), Route::default()) + .unwrap(); drop(driver); assert!(!announced.is_synced(), "the queue is still owed"); @@ -11016,8 +11642,12 @@ mod tests { #[test] fn internal_route_requests_are_closed_on_teardown() { let (producer, mut driver) = Producer::new(Config::new(origin(1))); - let server = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); - let _pending = producer.consume().request_broadcast(Path::new("room/alice").unwrap(), None); + let server = producer + .dynamic_route(Path::new("room").unwrap(), Route::default()) + .unwrap(); + let _pending = producer + .consume() + .request_broadcast(Path::new("room/alice").unwrap(), None); driver.poll(Instant::now(), &kio::Waiter::noop()).unwrap(); let Poll::Ready(Ok(request)) = server.poll_requested_broadcast(&kio::Waiter::noop()) else { panic!("front requested its route"); @@ -11048,7 +11678,10 @@ mod tests { let consumer = producer.consume(); let server = producer - .dynamic_route(Path::new("room").unwrap(), Route::default().with_epoch(epoch()).with_hops(hops(first))) + .dynamic_route( + Path::new("room").unwrap(), + Route::default().with_epoch(epoch()).with_hops(hops(first)), + ) .unwrap(); let pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); @@ -11091,7 +11724,10 @@ mod tests { /// back its handle, ready to answer the front's re-request. fn standby(&self, first: &[u64]) -> Dynamic { self.producer - .dynamic_route(Path::new("room").unwrap(), Route::default().with_epoch(epoch()).with_hops(hops(first))) + .dynamic_route( + Path::new("room").unwrap(), + Route::default().with_epoch(epoch()).with_hops(hops(first)), + ) .unwrap() } } @@ -11145,7 +11781,10 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let first = producer - .dynamic_route(Path::new("room").unwrap(), Route::default().with_hops(hops(&[10])).with_cost(5)) + .dynamic_route( + Path::new("room").unwrap(), + Route::default().with_hops(hops(&[10])).with_cost(5), + ) .unwrap(); let pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); let source = broadcast::Info::new().produce(); @@ -11156,7 +11795,10 @@ mod tests { deliver(&track, &mut subscription, b"first").await; let second = producer - .dynamic_route(Path::new("room").unwrap(), Route::default().with_hops(hops(&[11])).with_cost(1)) + .dynamic_route( + Path::new("room").unwrap(), + Route::default().with_hops(hops(&[11])).with_cost(1), + ) .unwrap(); deliver(&track, &mut subscription, b"pinned").await; @@ -11188,7 +11830,10 @@ mod tests { ) .unwrap(); let old_track = old.create_track("video", crate::track::Info::timed()).unwrap(); - let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); + let resolved = consumer + .request_broadcast(Path::new("room/alice").unwrap(), None) + .await + .expect("resolves"); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); deliver(&old_track, &mut subscription, b"old").await; @@ -11201,7 +11846,10 @@ mod tests { let new_track = new.create_track("video", crate::track::Info::timed()).unwrap(); deliver(&old_track, &mut subscription, b"sticky").await; - let replaced = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); + let replaced = consumer + .request_broadcast(Path::new("room/alice").unwrap(), None) + .await + .expect("resolves"); assert!(!replaced.is_clone(&resolved)); let mut fresh = replaced.track("video").unwrap().subscribe(None).await.unwrap(); deliver(&new_track, &mut fresh, b"new").await; @@ -11227,10 +11875,16 @@ mod tests { let consumer = producer.consume(); let first = crate::Epoch::mint(); let old = producer - .publish(Path::new("room/alice").unwrap(), Route::default().with_epoch(first.clone())) + .publish( + Path::new("room/alice").unwrap(), + Route::default().with_epoch(first.clone()), + ) .unwrap(); let _old_track = old.create_track("video", crate::track::Info::timed()).unwrap(); - let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); + let resolved = consumer + .request_broadcast(Path::new("room/alice").unwrap(), None) + .await + .expect("resolves"); assert_eq!( resolved.info().epoch.as_ref(), Some(&first), @@ -11239,7 +11893,10 @@ mod tests { let epoch = crate::Epoch::mint(); let new = producer - .publish(Path::new("room/alice").unwrap(), Route::default().with_epoch(epoch.clone())) + .publish( + Path::new("room/alice").unwrap(), + Route::default().with_epoch(epoch.clone()), + ) .unwrap(); let new_track = new.create_track("video", crate::track::Info::timed()).unwrap(); let named = consumer.request_broadcast(Path::new("room/alice").unwrap(), epoch.clone()); @@ -11270,14 +11927,20 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let old = producer - .dynamic_route(Path::new("room").unwrap(), Route::default().with_epoch(crate::Epoch::mint())) + .dynamic_route( + Path::new("room").unwrap(), + Route::default().with_epoch(crate::Epoch::mint()), + ) .unwrap(); let pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); let request = queued(&old).await; // The answer and the newer epoch land in the same tick. let new = producer - .publish(Path::new("room/alice").unwrap(), Route::default().with_epoch(crate::Epoch::mint())) + .publish( + Path::new("room/alice").unwrap(), + Route::default().with_epoch(crate::Epoch::mint()), + ) .unwrap(); let new_track = new.create_track("video", crate::track::Info::timed()).unwrap(); let stale = broadcast::Info::new().produce(); @@ -11327,7 +11990,11 @@ mod tests { matches!(pinned.await, Err(Error::Unroutable)), "a request pinned to the old epoch resolved" ); - let cached = dynamic.state.lock().served.get(&Path::new("room/alice").unwrap().to_owned()); + let cached = dynamic + .state + .lock() + .served + .get(&Path::new("room/alice").unwrap().to_owned()); assert!( cached.is_some_and(|cached| cached.consume().is_clone(&fresh.consume())), "the old answer was cached" @@ -11356,7 +12023,10 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let dynamic = producer - .dynamic_route(Path::new("room").unwrap(), Route::default().with_epoch(crate::Epoch::mint())) + .dynamic_route( + Path::new("room").unwrap(), + Route::default().with_epoch(crate::Epoch::mint()), + ) .unwrap(); let pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); queued(&dynamic).await.reject(Error::NotFound); @@ -11411,7 +12081,9 @@ mod tests { async fn losing_an_epoch_is_another_instance() { let producer = origin(1).produce(); let consumer = producer.consume(); - let dynamic = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); + let dynamic = producer + .dynamic_route(Path::new("room").unwrap(), Route::default()) + .unwrap(); let pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); let old = broadcast::Info::new().produce(); let _old_track = old.create_track("video", crate::track::Info::timed()).unwrap(); @@ -11467,7 +12139,13 @@ mod tests { // The older one still stands, so it comes back once the newer one goes. drop(new); - assert_eq!(announced.expect_next_restarted(Path::new("room/alice").unwrap()).await.epoch, Some(old)); + assert_eq!( + announced + .expect_next_restarted(Path::new("room/alice").unwrap()) + .await + .epoch, + Some(old) + ); } /// A peer naming one publisher instance is never handed another. @@ -11481,7 +12159,9 @@ mod tests { .unwrap(); let other: crate::Epoch = "01900000-0000-7000-8000-000000000002".parse().unwrap(); - let refused = consumer.request_broadcast(Path::new("room/alice").unwrap(), other).await; + let refused = consumer + .request_broadcast(Path::new("room/alice").unwrap(), other) + .await; assert!(matches!(refused, Err(Error::Unroutable))); let named = consumer .request_broadcast(Path::new("room/alice").unwrap(), epoch()) @@ -11495,7 +12175,9 @@ mod tests { #[cfg(feature = "async")] async fn a_route_without_an_epoch_resolves_without_one() { let producer = origin(1).produce(); - let _broadcast = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let _broadcast = producer + .publish(Path::new("room/alice").unwrap(), Route::default()) + .unwrap(); let resolved = producer .consume() .request_broadcast(Path::new("room/alice").unwrap(), None) @@ -11658,11 +12340,17 @@ mod tests { None => producer.consume(), }; let incumbent = producer - .dynamic_route(Path::new("room").unwrap(), Route::default().with_epoch(epoch()).with_hops(hops(&[10]))) + .dynamic_route( + Path::new("room").unwrap(), + Route::default().with_epoch(epoch()).with_hops(hops(&[10])), + ) .unwrap(); // The same publisher, reached through the requesting peer. let echo = producer - .dynamic_route(Path::new("room").unwrap(), Route::default().with_epoch(epoch()).with_hops(hops(&[10, 7]))) + .dynamic_route( + Path::new("room").unwrap(), + Route::default().with_epoch(epoch()).with_hops(hops(&[10, 7])), + ) .unwrap(); let pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); @@ -11773,7 +12461,9 @@ mod tests { settle(|| consumer.get_broadcast(Path::new("room/alice").unwrap()).is_none()).await; settle(|| { matches!( - consumer.request_broadcast(Path::new("room/alice").unwrap(), None).now_or_never(), + consumer + .request_broadcast(Path::new("room/alice").unwrap(), None) + .now_or_never(), Some(Err(Error::Unroutable)) ) }) @@ -11880,11 +12570,21 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); - let first = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); - let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); + let first = producer + .publish(Path::new("room/alice").unwrap(), Route::default()) + .unwrap(); + let resolved = consumer + .request_broadcast(Path::new("room/alice").unwrap(), None) + .await + .expect("resolves"); - let second = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); - let again = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); + let second = producer + .publish(Path::new("room/alice").unwrap(), Route::default()) + .unwrap(); + let again = consumer + .request_broadcast(Path::new("room/alice").unwrap(), None) + .await + .expect("resolves"); assert!(!again.is_clone(&resolved)); // Losing one source leaves the path served; losing both frees it. @@ -11894,7 +12594,9 @@ mod tests { settle(|| consumer.get_broadcast(Path::new("room/alice").unwrap()).is_none()).await; // The path is free again for a fresh broadcast. - let _third = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let _third = producer + .publish(Path::new("room/alice").unwrap(), Route::default()) + .unwrap(); assert!(consumer.get_broadcast(Path::new("room/alice").unwrap()).is_some()); } @@ -11911,10 +12613,15 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); - let broadcast = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let broadcast = producer + .publish(Path::new("room/alice").unwrap(), Route::default()) + .unwrap(); let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); - let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); + let resolved = consumer + .request_broadcast(Path::new("room/alice").unwrap(), None) + .await + .expect("resolves"); let mut subscription = resolved .track("video") .unwrap() @@ -12004,7 +12711,9 @@ mod tests { let server = producer .dynamic_route(Path::new("room").unwrap(), Route::default().with_hops(hops(&[10]))) .unwrap(); - let pending = producer.consume().request_broadcast(Path::new("room/alice").unwrap(), None); + let pending = producer + .consume() + .request_broadcast(Path::new("room/alice").unwrap(), None); let source = broadcast::Info::new().produce(); queued(&server).await.accept(&source); let resolved = pending.await.unwrap(); @@ -12027,13 +12736,18 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); - let broadcast = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let broadcast = producer + .publish(Path::new("room/alice").unwrap(), Route::default()) + .unwrap(); let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"cached".as_ref()).unwrap(); group.finish().unwrap(); - let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); + let resolved = consumer + .request_broadcast(Path::new("room/alice").unwrap(), None) + .await + .expect("resolves"); let mut subscription = resolved .track("video") .unwrap() @@ -12131,7 +12845,11 @@ mod tests { let producer = origin(1).produce(); let broadcast = producer.publish(Path::new("live").unwrap(), Route::default()).unwrap(); let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); - let resolved = producer.consume().request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); + let resolved = producer + .consume() + .request_broadcast(Path::new("live").unwrap(), None) + .await + .unwrap(); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); let mut aborted = track.append_group().unwrap(); @@ -12164,7 +12882,9 @@ mod tests { let leaf = origin(1).produce(); let leaf_consumer = leaf.consume(); - let broadcast = leaf.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let broadcast = leaf + .publish(Path::new("room/alice").unwrap(), Route::default()) + .unwrap(); let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"cached".as_ref()).unwrap(); @@ -12267,7 +12987,10 @@ mod tests { .publish(Path::new("room/alice").unwrap(), Route::default().with_epoch(epoch())) .unwrap(); let track = first.create_track("video", crate::track::Info::timed()).unwrap(); - let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); + let resolved = consumer + .request_broadcast(Path::new("room/alice").unwrap(), None) + .await + .expect("resolves"); let mut subscription = resolved .track("video") .unwrap() @@ -12316,9 +13039,14 @@ mod tests { ) { let producer = origin(1).produce(); let server = producer - .dynamic_route(Path::new("room").unwrap(), Route::default().with_epoch(epoch()).with_hops(hops(&[10]))) + .dynamic_route( + Path::new("room").unwrap(), + Route::default().with_epoch(epoch()).with_hops(hops(&[10])), + ) .unwrap(); - let pending = producer.consume().request_broadcast(Path::new("room/alice").unwrap(), None); + let pending = producer + .consume() + .request_broadcast(Path::new("room/alice").unwrap(), None); let upstream = broadcast::Info::new().produce(); let old = upstream.create_track("video", crate::track::Info::timed()).unwrap(); queued(&server).await.accept(&upstream); @@ -12363,7 +13091,11 @@ mod tests { #[cfg(feature = "async")] async fn a_returning_reader_is_not_stranded_on_a_dropped_copy() { let (producer, _server, upstream, old, mut subscription) = remote_front().await; - let resolved = producer.consume().request_broadcast(Path::new("room/alice").unwrap(), None).await.unwrap(); + let resolved = producer + .consume() + .request_broadcast(Path::new("room/alice").unwrap(), None) + .await + .unwrap(); // No handler and no track: refuses "video" with NotFound. let _second = producer @@ -12421,7 +13153,11 @@ mod tests { #[cfg(feature = "async")] async fn a_parked_track_serves_whole_groups_from_its_copy() { let (producer, _server, _upstream, old, subscription) = remote_front().await; - let resolved = producer.consume().request_broadcast(Path::new("room/alice").unwrap(), None).await.unwrap(); + let resolved = producer + .consume() + .request_broadcast(Path::new("room/alice").unwrap(), None) + .await + .unwrap(); let mut open = old.append_group().unwrap(); open.write_frame(crate::Timestamp::ZERO, b"open".as_ref()).unwrap(); drop(subscription); @@ -12454,7 +13190,11 @@ mod tests { #[cfg(feature = "async")] async fn a_new_source_unparks_the_old_copy() { let (producer, _server, _upstream, old, subscription) = remote_front().await; - let resolved = producer.consume().request_broadcast(Path::new("room/alice").unwrap(), None).await.unwrap(); + let resolved = producer + .consume() + .request_broadcast(Path::new("room/alice").unwrap(), None) + .await + .unwrap(); drop(subscription); moq_clock::timeout(Duration::from_secs(1), old.demand().until(|wanted| wanted.is_none())) .await @@ -12488,7 +13228,10 @@ mod tests { .publish(Path::new("room/alice").unwrap(), Route::default().with_epoch(epoch())) .unwrap(); let track = first.create_track("video", crate::track::Info::timed()).unwrap(); - let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); + let resolved = consumer + .request_broadcast(Path::new("room/alice").unwrap(), None) + .await + .expect("resolves"); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"before".as_ref()).unwrap(); @@ -12525,7 +13268,10 @@ mod tests { .publish(Path::new("room/alice").unwrap(), Route::default().with_epoch(epoch())) .unwrap(); let track = first.create_track("video", crate::track::Info::timed()).unwrap(); - let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); + let resolved = consumer + .request_broadcast(Path::new("room/alice").unwrap(), None) + .await + .expect("resolves"); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"before".as_ref()).unwrap(); @@ -12581,7 +13327,10 @@ mod tests { .publish(Path::new("room/alice").unwrap(), Route::default().with_epoch(epoch())) .unwrap(); let track = first.create_track("video", crate::track::Info::timed()).unwrap(); - let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); + let resolved = consumer + .request_broadcast(Path::new("room/alice").unwrap(), None) + .await + .expect("resolves"); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"before".as_ref()).unwrap(); @@ -12619,7 +13368,10 @@ mod tests { let producer = origin(1).produce(); let _a = producer.announce(Path::new("").unwrap(), Route::default()).unwrap(); - let consumer = producer.consume().scope(Path::new("").unwrap(), &scopes(&["alpha", "beta"])).unwrap(); + let consumer = producer + .consume() + .scope(Path::new("").unwrap(), &scopes(&["alpha", "beta"])) + .unwrap(); let mut announced = consumer.announced(); announced.expect_next_active(Path::new("").unwrap()).await; announced.assert_next_wait(); @@ -12630,7 +13382,9 @@ mod tests { let producer = origin(1).produce(); // The root grant is `**`, the old empty prefix. - let root = producer.scope(Path::new("").unwrap(), &Patterns::from(Pattern::all())).unwrap(); + let root = producer + .scope(Path::new("").unwrap(), &Patterns::from(Pattern::all())) + .unwrap(); assert_eq!(root.allowed(), Patterns::from(Pattern::all())); // `foo/**` keeps the old `foo` prefix meaning. @@ -12638,18 +13392,31 @@ mod tests { assert_eq!(scoped.allowed(), scopes(&["room"])); // Multiple prefixes round-trip, with overlap collapsed. - let multi = producer.scope(Path::new("").unwrap(), &scopes(&["room", "room/chat", "anon"])).unwrap(); + let multi = producer + .scope(Path::new("").unwrap(), &scopes(&["room", "room/chat", "anon"])) + .unwrap(); assert_eq!(multi.allowed(), scopes(&["room", "anon"])); // The consumer side reports the same way. - let consumer = producer.consume().scope(Path::new("").unwrap(), &scopes(&["room"])).unwrap(); + let consumer = producer + .consume() + .scope(Path::new("").unwrap(), &scopes(&["room"])) + .unwrap(); assert_eq!(consumer.allowed(), scopes(&["room"])); for text in ["room", "", "*room", "room/*", "*", "**/room", "room/**/chat", "*.hang"] { let union = Patterns::from(text.parse::().unwrap()); - assert_eq!(producer.scope(Path::new("").unwrap(), &union).expect(text).allowed(), union, "{text}"); assert_eq!( - producer.consume().scope(Path::new("").unwrap(), &union).expect(text).allowed(), + producer.scope(Path::new("").unwrap(), &union).expect(text).allowed(), + union, + "{text}" + ); + assert_eq!( + producer + .consume() + .scope(Path::new("").unwrap(), &union) + .expect(text) + .allowed(), union, "{text}" ); @@ -12672,11 +13439,25 @@ mod tests { .scope(Path::new("").unwrap(), &scopes(&["room/a", "other/deep/head"])) .unwrap() .announced(); - let route = producer.announce(Path::new("room/a/b/c").unwrap(), Route::default()).unwrap(); + let route = producer + .announce(Path::new("room/a/b/c").unwrap(), Route::default()) + .unwrap(); { let table = producer.shared.lock(); - assert!(table.routes.root.find(Path::new("room/a/b/c").unwrap().parts()).is_some()); - assert!(table.routes.root.find(Path::new("other/deep/head").unwrap().parts()).is_some()); + assert!( + table + .routes + .root + .find(Path::new("room/a/b/c").unwrap().parts()) + .is_some() + ); + assert!( + table + .routes + .root + .find(Path::new("other/deep/head").unwrap().parts()) + .is_some() + ); assert_eq!(table.routes.root.cursors_below, 2); } @@ -12712,7 +13493,9 @@ mod tests { let (producer, driver) = Producer::new(Config::new(origin(1))); let run = moq_clock::sim::spawn(crate::time::run(driver)); let consumer = producer.consume(); - let server = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); + let server = producer + .dynamic_route(Path::new("room").unwrap(), Route::default()) + .unwrap(); drop(producer); let pending = consumer.request_broadcast(Path::new("room/alice").unwrap(), None); @@ -12739,9 +13522,14 @@ mod tests { let (producer, driver) = Producer::new(Config::new(origin(1))); let run = moq_clock::sim::spawn(crate::time::run(driver)); let consumer = producer.consume(); - let broadcast = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let broadcast = producer + .publish(Path::new("room/alice").unwrap(), Route::default()) + .unwrap(); let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); - let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); + let resolved = consumer + .request_broadcast(Path::new("room/alice").unwrap(), None) + .await + .expect("resolves"); let sub = resolved.track("video").unwrap().subscribe(None).await.unwrap(); broadcast.unannounce(); @@ -12764,9 +13552,14 @@ mod tests { let (producer, driver) = Producer::new(Config::new(origin(1))); let run = moq_clock::sim::spawn(crate::time::run(driver)); let consumer = producer.consume(); - let broadcast = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let broadcast = producer + .publish(Path::new("room/alice").unwrap(), Route::default()) + .unwrap(); let mut track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); - let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); + let resolved = consumer + .request_broadcast(Path::new("room/alice").unwrap(), None) + .await + .expect("resolves"); let sub = resolved.track("video").unwrap().subscribe(None).await.unwrap(); let pending = resolved.track("video").unwrap().subscribe(None); @@ -12792,9 +13585,14 @@ mod tests { async fn a_track_unread_as_its_broadcast_ends_releases_its_source() { let producer = origin(1).produce(); let consumer = producer.consume(); - let broadcast = producer.publish(Path::new("room/alice").unwrap(), Route::default()).unwrap(); + let broadcast = producer + .publish(Path::new("room/alice").unwrap(), Route::default()) + .unwrap(); let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); - let resolved = consumer.request_broadcast(Path::new("room/alice").unwrap(), None).await.expect("resolves"); + let resolved = consumer + .request_broadcast(Path::new("room/alice").unwrap(), None) + .await + .expect("resolves"); let sub = resolved.track("video").unwrap().subscribe(None).await.unwrap(); moq_clock::timeout(Duration::from_secs(1), track.demand().until(|wanted| wanted.is_some())) .await @@ -12864,12 +13662,19 @@ mod tests { async fn watch_wakes_only_for_covering_changes() { let producer = origin(1).produce(); let waiter = kio::Waiter::noop(); - let watch = producer.shared.lock().watch(&producer.shared, &Path::new("room/a").unwrap()); + let watch = producer + .shared + .lock() + .watch(&producer.shared, &Path::new("room/a").unwrap()); let seen = watch.seen(); // A route beside the path or beneath it covers nothing at the path. - let _other = producer.announce(Path::new("other").unwrap(), Route::default()).unwrap(); - let _below = producer.announce(Path::new("room/a/b").unwrap(), Route::default()).unwrap(); + let _other = producer + .announce(Path::new("other").unwrap(), Route::default()) + .unwrap(); + let _below = producer + .announce(Path::new("room/a/b").unwrap(), Route::default()) + .unwrap(); assert!(watch.poll_changed(&waiter, seen).is_pending()); // A route above it does, and so does its retraction. @@ -12905,7 +13710,9 @@ mod tests { ..Default::default() }); let consumer = producer.consume(); - let _served = producer.dynamic_route(Path::new("room").unwrap(), Route::default()).unwrap(); + let _served = producer + .dynamic_route(Path::new("room").unwrap(), Route::default()) + .unwrap(); // A consumer outlives its producer by design, so the task set can refuse // submissions while the origin is still open. The front's task is then // dropped on the spot, taking its `Watch` with it: the request must not @@ -12918,8 +13725,14 @@ mod tests { async fn published_names_refuse_navigation_segments() { let producer = origin(1).produce(); for path in ["room/./cam", "room/../cam", ".", ".."] { - assert!(producer.create_broadcast(Path::new(path).unwrap()).is_err(), "created {path}"); - assert!(producer.announce(Path::new(path).unwrap(), Route::default()).is_err(), "announced {path}"); + assert!( + producer.create_broadcast(Path::new(path).unwrap()).is_err(), + "created {path}" + ); + assert!( + producer.announce(Path::new(path).unwrap(), Route::default()).is_err(), + "announced {path}" + ); } let scoped = producer .scope(Path::new("room/..").unwrap(), &Patterns::from_iter([Pattern::all()])) @@ -12952,7 +13765,10 @@ mod tests { let producer = origin(1).produce(); // An empty union grants nothing: scoping is refused, like a disjoint prefix. - assert!(matches!(producer.scope(Path::new("").unwrap(), &Patterns::new()), Err(Error::Unauthorized))); + assert!(matches!( + producer.scope(Path::new("").unwrap(), &Patterns::new()), + Err(Error::Unauthorized) + )); assert!(matches!( producer.consume().scope(Path::new("").unwrap(), &Patterns::new()), Err(Error::Unauthorized) @@ -12975,12 +13791,19 @@ mod tests { )); // A literal root rebases the grant without changing its meaning. - let rooted = nested.scope(Path::new("room/chat").unwrap(), &Patterns::from(Pattern::all())).unwrap(); + let rooted = nested + .scope(Path::new("room/chat").unwrap(), &Patterns::from(Pattern::all())) + .unwrap(); assert_eq!(rooted.allowed(), scopes(&[""])); // Publishing through the nested view lands where the root says. let broadcast = nested.create_broadcast(Path::new("room/chat/live").unwrap()).unwrap(); - assert!(producer.consume().get_broadcast(Path::new("room/chat/live").unwrap()).is_some()); + assert!( + producer + .consume() + .get_broadcast(Path::new("room/chat/live").unwrap()) + .is_some() + ); broadcast.close(); } @@ -12988,17 +13811,28 @@ mod tests { async fn scope_intersects_and_rebases_arbitrary_grants() { let producer = origin(1).produce(); let rooms = producer - .scope(Path::new("").unwrap(), &Patterns::from("room/*".parse::().unwrap())) + .scope( + Path::new("").unwrap(), + &Patterns::from("room/*".parse::().unwrap()), + ) .unwrap(); let chats = rooms - .scope(Path::new("").unwrap(), &Patterns::from("*/chat".parse::().unwrap())) + .scope( + Path::new("").unwrap(), + &Patterns::from("*/chat".parse::().unwrap()), + ) .unwrap(); assert_eq!(chats.allowed(), Patterns::from("room/chat".parse::().unwrap())); let exact = producer - .scope(Path::new("").unwrap(), &Patterns::from("room/alice".parse::().unwrap())) + .scope( + Path::new("").unwrap(), + &Patterns::from("room/alice".parse::().unwrap()), + ) + .unwrap(); + let rooted = exact + .scope(Path::new("room").unwrap(), &Patterns::from(Pattern::all())) .unwrap(); - let rooted = exact.scope(Path::new("room").unwrap(), &Patterns::from(Pattern::all())).unwrap(); assert_eq!(rooted.allowed(), Patterns::from("alice".parse::().unwrap())); assert!(matches!( exact.scope(Path::new("room/bob").unwrap(), &Patterns::from(Pattern::all())), @@ -13010,7 +13844,12 @@ mod tests { exact.create_broadcast(Path::new("room/alice/cam").unwrap()), Err(Error::Unauthorized) )); - assert!(producer.consume().get_broadcast(Path::new("room/alice").unwrap()).is_some()); + assert!( + producer + .consume() + .get_broadcast(Path::new("room/alice").unwrap()) + .is_some() + ); drop(broadcast); } @@ -13019,11 +13858,16 @@ mod tests { let producer = origin(1).produce(); let consumer = producer .consume() - .scope(Path::new("").unwrap(), &Patterns::from("room/*/chat".parse::().unwrap())) + .scope( + Path::new("").unwrap(), + &Patterns::from("room/*/chat".parse::().unwrap()), + ) .unwrap(); let mut announced = consumer.announced(); - let alice = producer.create_broadcast(Path::new("room/alice/chat").unwrap()).unwrap(); + let alice = producer + .create_broadcast(Path::new("room/alice/chat").unwrap()) + .unwrap(); alice.announce(Route::default()).unwrap(); let Some(AnnounceEvent::Start(update)) = announced.try_next() else { panic!("expected alice's chat"); @@ -13031,7 +13875,9 @@ mod tests { assert_eq!(update.prefix.as_str(), "room/alice/chat"); assert_eq!(update.captures, Some(vec!["alice".parse::().unwrap()])); - let audio = producer.create_broadcast(Path::new("room/alice/audio").unwrap()).unwrap(); + let audio = producer + .create_broadcast(Path::new("room/alice/audio").unwrap()) + .unwrap(); audio.announce(Route::default()).unwrap(); announced.assert_next_wait(); @@ -13050,7 +13896,9 @@ mod tests { #[moq_clock::test] async fn local_broadcast_wins_announcement_ties() { let producer = origin(1).produce(); - let remote = producer.announce(Path::new("room/alice").unwrap(), Route::default().with_cost(9)).unwrap(); + let remote = producer + .announce(Path::new("room/alice").unwrap(), Route::default().with_cost(9)) + .unwrap(); let local = producer.create_broadcast(Path::new("room/alice").unwrap()).unwrap(); local.announce(Route::default()).unwrap(); diff --git a/rs/moq-net/src/path/mod.rs b/rs/moq-net/src/path/mod.rs index 0935f4f4059..46a47ec319d 100644 --- a/rs/moq-net/src/path/mod.rs +++ b/rs/moq-net/src/path/mod.rs @@ -549,7 +549,10 @@ impl TryFrom for Path<'_> { Ok(if s.is_empty() { Path::empty() } else { - Path(Repr::Shared { buf: s.into(), start: 0 }) + Path(Repr::Shared { + buf: s.into(), + start: 0, + }) }) } } diff --git a/rs/moq-net/src/server.rs b/rs/moq-net/src/server.rs index 8504f96eeaf..7c7023eb7ee 100644 --- a/rs/moq-net/src/server.rs +++ b/rs/moq-net/src/server.rs @@ -1030,8 +1030,8 @@ impl Drop for Handshake { #[cfg(test)] mod tests { use super::*; - use crate::Path; use crate::Hop; + use crate::Path; use crate::model::ProduceTest; use std::{ collections::VecDeque, @@ -1702,7 +1702,10 @@ mod tests { let mut local_hops = crate::Hops::new(); local_hops.push(other).unwrap(); let _local = origin - .announce(Path::new("local-route").unwrap(), crate::origin::Route::default().with_hops(local_hops)) + .announce( + Path::new("local-route").unwrap(), + crate::origin::Route::default().with_hops(local_hops), + ) .unwrap(); let (session, driver) = request.ok().await.unwrap(); diff --git a/rs/moq-net/src/stats.rs b/rs/moq-net/src/stats.rs index 8462b9dab86..cd5aef198d2 100644 --- a/rs/moq-net/src/stats.rs +++ b/rs/moq-net/src/stats.rs @@ -2273,7 +2273,9 @@ mod tests { let after = stats.snapshot(); assert_eq!(before.sessions(), after.sessions(), "retirement keeps outcomes once"); let disabled = Registry::disabled(); - disabled.tier(Tier::default()).refuse(Path::new("root").unwrap(), RefusalKind::Refused); + disabled + .tier(Tier::default()) + .refuse(Path::new("root").unwrap(), RefusalKind::Refused); disabled .tier(Tier::default()) .session(Path::new("root").unwrap()) @@ -2321,12 +2323,11 @@ mod tests { /// The [`Presence`] for `(tier, label)`, or `None` if absent. fn session_snapshot(stats: &Registry, tier: &Tier, label: &str) -> Option { - stats - .shared() - .sessions - .lock() - .get(tier) - .and_then(|labels| labels.get(&Path::new(label).unwrap().to_owned()).map(|c| c.snapshot().0)) + stats.shared().sessions.lock().get(tier).and_then(|labels| { + labels + .get(&Path::new(label).unwrap().to_owned()) + .map(|c| c.snapshot().0) + }) } fn test_stats() -> Registry { @@ -2337,7 +2338,9 @@ mod tests { fn default_and_named_tiers_are_independent() { let stats = test_stats(); let default = stats.tier(Tier::default()).session(Path::new("root").unwrap()); - let regional = stats.tier(Tier::new(Path::new("region/sjc").unwrap())).session(Path::new("root").unwrap()); + let regional = stats + .tier(Tier::new(Path::new("region/sjc").unwrap())) + .session(Path::new("root").unwrap()); default.egress(Path::new("demo/bbb").unwrap()).meter().bytes(100); regional.ingress(Path::new("demo/bbb").unwrap()).meter().bytes(7); @@ -2359,7 +2362,10 @@ mod tests { let stats = test_stats(); let tier = stats.tier(Tier::default()); - let (s1, s2) = (tier.session(Path::new("acme").unwrap()), tier.session(Path::new("acme").unwrap())); + let (s1, s2) = ( + tier.session(Path::new("acme").unwrap()), + tier.session(Path::new("acme").unwrap()), + ); let announces = Slots::new(10).with_stats(&s1, Cap::Announces); let subscriptions = Slots::new(10).with_stats(&s2, Cap::Subscriptions); let other = Slots::new(10).with_stats(&s2, Cap::Announces); @@ -2455,7 +2461,10 @@ mod tests { let regional_subscriber = slot(Tier::new(Path::new("region/sjc").unwrap()), Role::Subscriber); assert_eq!(regional_subscriber.bytes, 7, "regional ingress isolated by tier/role"); assert_eq!(slot(Tier::default(), Role::Subscriber).bytes, 0); - assert_eq!(slot(Tier::new(Path::new("region/sjc").unwrap()), Role::Publisher).bytes, 0); + assert_eq!( + slot(Tier::new(Path::new("region/sjc").unwrap()), Role::Publisher).bytes, + 0 + ); let sessions = |tier| { snap.sessions() @@ -2470,7 +2479,10 @@ mod tests { "two default-tier sessions under one label" ); assert_eq!(default_sessions.sessions_ended, 0, "guards still held"); - assert_eq!(sessions(Tier::new(Path::new("region/sjc").unwrap())).sessions_started, 1); + assert_eq!( + sessions(Tier::new(Path::new("region/sjc").unwrap())).sessions_started, + 1 + ); } fn drain(stats: &Registry) -> Report { @@ -2484,7 +2496,9 @@ mod tests { // A reused report is cleared, not appended to, and keeps its buffers. let stats = test_stats(); let ctx = stats.tier(Tier::default()).session(Path::new("root").unwrap()); - let _scopes: Vec<_> = (0..8).map(|i| ctx.egress(Path::new(format!("b/{i}").as_str()).unwrap())).collect(); + let _scopes: Vec<_> = (0..8) + .map(|i| ctx.egress(Path::new(format!("b/{i}").as_str()).unwrap())) + .collect(); let mut report = Report::default(); stats.report(&mut report); @@ -2674,7 +2688,9 @@ mod tests { let worker = std::thread::spawn(move || { for i in 0..256 { let path = format!("root/{i}"); - let session = worker_stats.tier(Tier::default()).session(Path::new(path.as_str()).unwrap()); + let session = worker_stats + .tier(Tier::default()) + .session(Path::new(path.as_str()).unwrap()); session.ingress(Path::new(path.as_str()).unwrap()).meter().bytes(1); drop(session); drain(&worker_stats); @@ -3026,9 +3042,17 @@ mod tests { let stats = test_stats(); let raw = || tier_counters(&stats, "demo/bbb", &Tier::default()).publisher.snapshot(); - let v1 = stats.tier(Tier::default()).session(Path::new("a").unwrap()).egress(Path::new("demo/bbb").unwrap()).subscribe(); + let v1 = stats + .tier(Tier::default()) + .session(Path::new("a").unwrap()) + .egress(Path::new("demo/bbb").unwrap()) + .subscribe(); assert_eq!(raw().broadcasts_started, 1); - let v2 = stats.tier(Tier::default()).session(Path::new("b").unwrap()).egress(Path::new("demo/bbb").unwrap()).subscribe(); + let v2 = stats + .tier(Tier::default()) + .session(Path::new("b").unwrap()) + .egress(Path::new("demo/bbb").unwrap()) + .subscribe(); assert_eq!(raw().broadcasts_started, 2, "two distinct contexts => two viewers"); drop(v1); @@ -3062,7 +3086,9 @@ mod tests { #[test] fn request_admission_survives_clones_retiering_and_retirement_without_presence() { let stats = test_stats(); - let request = stats.tier(Tier::new(Path::new("old").unwrap())).request(Path::new("root").unwrap()); + let request = stats + .tier(Tier::new(Path::new("old").unwrap())) + .request(Path::new("root").unwrap()); let clone = request.clone(); request.egress(Path::new("root/video").unwrap()).meter().bytes(7); request.retag(Tier::new(Path::new("new").unwrap()), Path::new("root").unwrap()); diff --git a/rs/moq-net/tests/announce_allocs.rs b/rs/moq-net/tests/announce_allocs.rs index 2c6c4783e55..65eed718b68 100644 --- a/rs/moq-net/tests/announce_allocs.rs +++ b/rs/moq-net/tests/announce_allocs.rs @@ -58,16 +58,30 @@ fn peer_route(peer: u64, cost: u64) -> origin::Route { /// again, with `cursors` cursors rooted at `root` watching it. fn churn_allocs(root: &str, cursors: usize) -> usize { let (producer, _driver) = origin::Producer::new(origin::Config::default()); - let _winner = producer.dynamic_route(Path::new("room/a").unwrap(), peer_route(1, 1)).unwrap(); + let _winner = producer + .dynamic_route(Path::new("room/a").unwrap(), peer_route(1, 1)) + .unwrap(); let all = Patterns::from(Pattern::all()); let mut cursors: Vec<_> = (0..cursors) - .map(|_| producer.consume().scope(Path::new(root).unwrap(), &all).unwrap().announced()) + .map(|_| { + producer + .consume() + .scope(Path::new(root).unwrap(), &all) + .unwrap() + .announced() + }) .collect(); for cursor in &mut cursors { while cursor.try_next().is_some() {} } - let cycle = || drop(producer.dynamic_route(Path::new("room/a").unwrap(), peer_route(2, 5)).unwrap()); + let cycle = || { + drop( + producer + .dynamic_route(Path::new("room/a").unwrap(), peer_route(2, 5)) + .unwrap(), + ) + }; // Reach the steady state first, with every table grown to what it settles at. for _ in 0..4 { cycle(); diff --git a/rs/moq-net/tests/integration/announce_covering_route.rs b/rs/moq-net/tests/integration/announce_covering_route.rs index 7ad4c5108a9..4de7d355ae2 100644 --- a/rs/moq-net/tests/integration/announce_covering_route.rs +++ b/rs/moq-net/tests/integration/announce_covering_route.rs @@ -7,8 +7,8 @@ //! `.dash/nobody` sees it at its own root. Across a session the publisher must //! translate it into the requested scope rather than end the session. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; @@ -62,7 +62,10 @@ async fn covering(version: Option<&str>) -> Vec { (subscriber.consume(), Some(connect_mock(options).await)) } }; - let mut announced = observer.scope(Path::new(REQUESTED).unwrap(), &everything).unwrap().announced(); + let mut announced = observer + .scope(Path::new(REQUESTED).unwrap(), &everything) + .unwrap() + .announced(); let mut log = Vec::new(); let served = publisher.create_broadcast(Path::new(SERVED).unwrap()).unwrap(); @@ -70,7 +73,9 @@ async fn covering(version: Option<&str>) -> Vec { moq_clock::sleep(SETTLE).await; log.push(format!("served: {:?}", drain(&mut announced))); - let below = publisher.create_broadcast(Path::try_from(format!("{REQUESTED}/cam")).unwrap()).unwrap(); + let below = publisher + .create_broadcast(Path::try_from(format!("{REQUESTED}/cam")).unwrap()) + .unwrap(); below.announce(Default::default()).unwrap(); moq_clock::sleep(SETTLE).await; log.push(format!("below: {:?}", drain(&mut announced))); diff --git a/rs/moq-net/tests/integration/announce_to_serve.rs b/rs/moq-net/tests/integration/announce_to_serve.rs index ff4760755a3..dd0e143feab 100644 --- a/rs/moq-net/tests/integration/announce_to_serve.rs +++ b/rs/moq-net/tests/integration/announce_to_serve.rs @@ -10,8 +10,8 @@ //! Deterministic: time is paused and the runtime is single-threaded, so settling //! is a virtual sleep. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; @@ -62,10 +62,13 @@ fn drain(announced: &mut moq_net::announce::Consumer) -> Vec { /// How a request for the path answers. async fn request(consumer: &origin::Consumer) -> Result { - consumer.request_broadcast(Path::new(PATH).unwrap(), None).await.map_err(|err| match err { - Error::Unroutable => "unroutable".to_string(), - err => err.to_string(), - }) + consumer + .request_broadcast(Path::new(PATH).unwrap(), None) + .await + .map_err(|err| match err { + Error::Unroutable => "unroutable".to_string(), + err => err.to_string(), + }) } fn outcome(result: &Result) -> String { diff --git a/rs/moq-net/tests/integration/auth.rs b/rs/moq-net/tests/integration/auth.rs index 54832f4cd88..8c91b0d5a44 100644 --- a/rs/moq-net/tests/integration/auth.rs +++ b/rs/moq-net/tests/integration/auth.rs @@ -4,8 +4,8 @@ //! tokens union, and a publication outside the grant fails loud. Every case runs on //! moq-lite-07-wip and on moq-transport with the MoQ Auth extension. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; @@ -651,7 +651,11 @@ async fn a_broadcast_published_before_the_grant_is_checked(version: &'static str let pair = connect(Options { version: Some(version), client_publish: Some(publisher.clone()), - server_subscribe: Some(produce_origin(1).scope(Path::new("").unwrap(), &patterns(&["baz"])).unwrap()), + server_subscribe: Some( + produce_origin(1) + .scope(Path::new("").unwrap(), &patterns(&["baz"])) + .unwrap(), + ), ..Default::default() }) .await; @@ -1068,7 +1072,11 @@ async fn exact_and_subtree_grants_admit_their_broadcast(version: &'static str) { group .write_frame(moq_net::Timestamp::from_millis(0).unwrap(), b"frame".as_ref()) .unwrap(); - let remote = received.consume().routed_broadcast(Path::new("ch1").unwrap()).await.unwrap(); + let remote = received + .consume() + .routed_broadcast(Path::new("ch1").unwrap()) + .await + .unwrap(); let prefs = moq_net::track::Subscription::default().with_max_delay(Duration::from_secs(10)); let mut sub = remote.track("video").unwrap().subscribe(prefs).await.unwrap(); sub.recv_group().await.unwrap().expect("a group"); @@ -1126,7 +1134,11 @@ async fn a_live_subscription_survives_union_renewal(version: &'static str) { requests.next().await.unwrap().accept(grant(&[], &["room"])) }); let first = first.unwrap(); - let remote = received.consume().routed_broadcast(Path::new("room/x").unwrap()).await.unwrap(); + let remote = received + .consume() + .routed_broadcast(Path::new("room/x").unwrap()) + .await + .unwrap(); let mut group = published.append_group().unwrap(); group .write_frame(moq_net::Timestamp::from_millis(0).unwrap(), b"first".as_ref()) @@ -1197,11 +1209,19 @@ async fn a_revoked_grant_cancels_its_subscriptions(version: &'static str) { let mut group = up_track.append_group().unwrap(); group.write_frame(ts(0), b"up".as_ref()).unwrap(); - let remote = received.consume().routed_broadcast(Path::new("room/x").unwrap()).await.unwrap(); + let remote = received + .consume() + .routed_broadcast(Path::new("room/x").unwrap()) + .await + .unwrap(); let mut down_sub = remote.track("video").unwrap().subscribe(prefs()).await.unwrap(); down_sub.recv_group().await.unwrap().unwrap(); - let remote = server_origin.consume().routed_broadcast(Path::new("up/y").unwrap()).await.unwrap(); + let remote = server_origin + .consume() + .routed_broadcast(Path::new("up/y").unwrap()) + .await + .unwrap(); let mut up_sub = remote.track("video").unwrap().subscribe(prefs()).await.unwrap(); up_sub.recv_group().await.unwrap().unwrap(); @@ -1390,7 +1410,9 @@ async fn a_wildcard_grant_is_enforced(version: &'static str) { } assert_eq!(pair.client_transport.close_reason(), None); - let bad = publisher.create_broadcast(Path::new("room/alice/mic").unwrap()).unwrap(); + let bad = publisher + .create_broadcast(Path::new("room/alice/mic").unwrap()) + .unwrap(); bad.announce(Default::default()).unwrap(); assert!(matches!( pair.server.closed().await, @@ -1577,10 +1599,18 @@ async fn a_narrowing_deafens_one_path(version: &'static str) { let mut group = video_track.append_group().unwrap(); group.write_frame(ts(0), b"v".as_ref()).unwrap(); - let remote = received.consume().routed_broadcast(Path::new("room/alice/audio").unwrap()).await.unwrap(); + let remote = received + .consume() + .routed_broadcast(Path::new("room/alice/audio").unwrap()) + .await + .unwrap(); let mut audio_sub = remote.track("opus").unwrap().subscribe(prefs()).await.unwrap(); audio_sub.recv_group().await.unwrap().unwrap(); - let remote = received.consume().routed_broadcast(Path::new("room/alice/video").unwrap()).await.unwrap(); + let remote = received + .consume() + .routed_broadcast(Path::new("room/alice/video").unwrap()) + .await + .unwrap(); let mut video_sub = remote.track("h264").unwrap().subscribe(prefs()).await.unwrap(); video_sub.recv_group().await.unwrap().unwrap(); @@ -1629,10 +1659,14 @@ async fn a_narrowing_aborts_what_the_peer_published(version: &'static str) { let prefs = || moq_net::track::Subscription::default().with_max_delay(Duration::from_secs(10)); let client_origin = produce_origin(2); - let mic = client_origin.create_broadcast(Path::new("room/bob/mic").unwrap()).unwrap(); + let mic = client_origin + .create_broadcast(Path::new("room/bob/mic").unwrap()) + .unwrap(); let mic_track = mic.create_track("opus", timed()).unwrap(); mic.announce(Default::default()).unwrap(); - let cam = client_origin.create_broadcast(Path::new("room/bob/cam").unwrap()).unwrap(); + let cam = client_origin + .create_broadcast(Path::new("room/bob/cam").unwrap()) + .unwrap(); let cam_track = cam.create_track("h264", timed()).unwrap(); cam.announce(Default::default()).unwrap(); @@ -1650,10 +1684,18 @@ async fn a_narrowing_aborts_what_the_peer_published(version: &'static str) { let mut group = cam_track.append_group().unwrap(); group.write_frame(ts(0), b"c".as_ref()).unwrap(); - let remote = relay.consume().routed_broadcast(Path::new("room/bob/mic").unwrap()).await.unwrap(); + let remote = relay + .consume() + .routed_broadcast(Path::new("room/bob/mic").unwrap()) + .await + .unwrap(); let mut mic_sub = remote.track("opus").unwrap().subscribe(prefs()).await.unwrap(); mic_sub.recv_group().await.unwrap().unwrap(); - let remote = relay.consume().routed_broadcast(Path::new("room/bob/cam").unwrap()).await.unwrap(); + let remote = relay + .consume() + .routed_broadcast(Path::new("room/bob/cam").unwrap()) + .await + .unwrap(); let mut cam_sub = remote.track("h264").unwrap().subscribe(prefs()).await.unwrap(); cam_sub.recv_group().await.unwrap().unwrap(); @@ -1698,7 +1740,11 @@ async fn a_narrowing_resets_a_fetch_in_flight(version: &'static str) { }) .await; - let remote = received.consume().routed_broadcast(Path::new("room/x").unwrap()).await.unwrap(); + let remote = received + .consume() + .routed_broadcast(Path::new("room/x").unwrap()) + .await + .unwrap(); let mut fetched = remote.track("video").unwrap().fetch_group(0, None).await.unwrap(); let frame = fetched.read_frame().await.unwrap().expect("first frame"); assert_eq!(frame.payload.as_ref(), b"first"); @@ -1760,7 +1806,11 @@ async fn a_widening_brings_back_a_deafened_path(version: &'static str) { let mut group = audio_track.append_group().unwrap(); group.write_frame(ts(0), b"a".as_ref()).unwrap(); - let remote = received.consume().routed_broadcast(Path::new("room/alice/audio").unwrap()).await.unwrap(); + let remote = received + .consume() + .routed_broadcast(Path::new("room/alice/audio").unwrap()) + .await + .unwrap(); let mut sub = remote.track("opus").unwrap().subscribe(prefs()).await.unwrap(); sub.recv_group().await.unwrap().unwrap(); @@ -1772,7 +1822,11 @@ async fn a_widening_brings_back_a_deafened_path(version: &'static str) { pair.server.auth().authorize(&grant(&[], &["room"])); wait_announced(&received.consume(), "room/alice/audio", true).await; - let remote = received.consume().routed_broadcast(Path::new("room/alice/audio").unwrap()).await.unwrap(); + let remote = received + .consume() + .routed_broadcast(Path::new("room/alice/audio").unwrap()) + .await + .unwrap(); let mut sub = remote.track("opus").unwrap().subscribe(prefs()).await.unwrap(); let mut group = audio_track.append_group().unwrap(); group.write_frame(ts(1), b"a".as_ref()).unwrap(); @@ -1802,7 +1856,9 @@ async fn a_widening_brings_back_what_the_peer_published(version: &'static str) { let prefs = || moq_net::track::Subscription::default().with_max_delay(Duration::from_secs(10)); let client_origin = produce_origin(2); - let mic = client_origin.create_broadcast(Path::new("room/bob/mic").unwrap()).unwrap(); + let mic = client_origin + .create_broadcast(Path::new("room/bob/mic").unwrap()) + .unwrap(); let mic_track = mic.create_track("opus", timed()).unwrap(); mic.announce(Default::default()).unwrap(); @@ -1821,7 +1877,11 @@ async fn a_widening_brings_back_what_the_peer_published(version: &'static str) { pair.server.auth().authorize(&grant(&["room"], &[])); wait_announced(&relay.consume(), "room/bob/mic", true).await; - let remote = relay.consume().routed_broadcast(Path::new("room/bob/mic").unwrap()).await.unwrap(); + let remote = relay + .consume() + .routed_broadcast(Path::new("room/bob/mic").unwrap()) + .await + .unwrap(); let mut sub = remote.track("opus").unwrap().subscribe(prefs()).await.unwrap(); let mut group = mic_track.append_group().unwrap(); group.write_frame(ts(0), b"m".as_ref()).unwrap(); diff --git a/rs/moq-net/tests/integration/broadcast_close.rs b/rs/moq-net/tests/integration/broadcast_close.rs index 07cd44e0291..94aa0734c33 100644 --- a/rs/moq-net/tests/integration/broadcast_close.rs +++ b/rs/moq-net/tests/integration/broadcast_close.rs @@ -5,8 +5,8 @@ //! [`Error::Unroutable`](moq_net::Error::Unroutable), a fresh request for the path //! answers the same, and the broadcast can never be announced again. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; diff --git a/rs/moq-net/tests/integration/catalog_acquisition.rs b/rs/moq-net/tests/integration/catalog_acquisition.rs index 17412e25ce6..1fd3e1d2cc6 100644 --- a/rs/moq-net/tests/integration/catalog_acquisition.rs +++ b/rs/moq-net/tests/integration/catalog_acquisition.rs @@ -2,8 +2,8 @@ //! Initial catalog acquisition while the same publisher gains a second session. -use moq_net::Path; use crate::support; +use moq_net::Path; use moq_net::{Error, Hop, Version, origin}; use support::harness::{MockConnectOptions, MockPair, connect_mock}; @@ -34,7 +34,11 @@ async fn acquisition(version: &str, carries_epoch: bool) { .announce(origin::Route::default().with_epoch(moq_net::Epoch::mint())) .unwrap(); let _old = link(version, &publisher, &subscriber, 100).await; - let remote = subscriber.consume().routed_broadcast(Path::new("live").unwrap()).await.unwrap(); + let remote = subscriber + .consume() + .routed_broadcast(Path::new("live").unwrap()) + .await + .unwrap(); let mut announced = subscriber.consume().follow(Path::new("live").unwrap()).unwrap(); let old_cost = match announced.next().await { Some(moq_net::announce::Event::Start(announce)) => announce.route.cost, diff --git a/rs/moq-net/tests/integration/catalog_churn.rs b/rs/moq-net/tests/integration/catalog_churn.rs index 0192e2e140f..107331f1763 100644 --- a/rs/moq-net/tests/integration/catalog_churn.rs +++ b/rs/moq-net/tests/integration/catalog_churn.rs @@ -9,8 +9,8 @@ //! on, and every fetch gets the whole group written so far. A failing seed is //! shrunk to the ops it needs, which the report names. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; @@ -266,7 +266,10 @@ impl Topology { /// A fresh request for the broadcast; `None` when refused, as with no route right now. async fn request(&self, step: usize) -> Result, Failure> { - let request = self.subscriber.consume().request_broadcast(Path::new("live").unwrap(), None); + let request = self + .subscriber + .consume() + .request_broadcast(Path::new("live").unwrap(), None); match moq_clock::timeout(READ_TIMEOUT, request).await { Ok(result) => Ok(result.ok()), Err(_) => Err(stuck(format!("{step}: request hung"))), diff --git a/rs/moq-net/tests/integration/catalog_handover.rs b/rs/moq-net/tests/integration/catalog_handover.rs index 14bc31fc2a0..13d55f603bf 100644 --- a/rs/moq-net/tests/integration/catalog_handover.rs +++ b/rs/moq-net/tests/integration/catalog_handover.rs @@ -11,8 +11,8 @@ //! so a reader that starts at frame 0 must not be refused as lagged and left with //! no catalog. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; @@ -168,10 +168,15 @@ impl Topology { /// A new reader on `R`: a fresh broadcast request and a floorless subscription. async fn reader(&self) -> Reader { - let remote = moq_clock::timeout(READ_TIMEOUT, self.subscriber.consume().request_broadcast(Path::new("live").unwrap(), None)) - .await - .expect("request hung") - .expect("request refused"); + let remote = moq_clock::timeout( + READ_TIMEOUT, + self.subscriber + .consume() + .request_broadcast(Path::new("live").unwrap(), None), + ) + .await + .expect("request hung") + .expect("request refused"); let sub = moq_clock::timeout(READ_TIMEOUT, remote.track("catalog.json").unwrap().subscribe(None)) .await .expect("subscribe hung") diff --git a/rs/moq-net/tests/integration/compress.rs b/rs/moq-net/tests/integration/compress.rs index f8135919acc..c14659b85b6 100644 --- a/rs/moq-net/tests/integration/compress.rs +++ b/rs/moq-net/tests/integration/compress.rs @@ -5,8 +5,8 @@ //! Negotiated IETF and lite-07 hops keep DEFLATE slices as received. Peers that cannot //! signal compression receive the plain frames the relay inflates once for all of them. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; @@ -107,7 +107,10 @@ async fn relay(published: Published, hops: [&str; 2], subscription: moq_net::tra let consumer = origin.consume(); consumer.routed(Path::new("bcast").unwrap()).await.unwrap(); - let remote = consumer.request_broadcast(Path::new("bcast").unwrap(), None).await.unwrap(); + let remote = consumer + .request_broadcast(Path::new("bcast").unwrap(), None) + .await + .unwrap(); let subscriber = remote.track("data").unwrap().subscribe(subscription).await.unwrap(); support::harness::subscribed(&track).await; @@ -310,7 +313,10 @@ async fn datagrams_meter_the_bytes_on_the_wire() { let consumer = origin.consume(); consumer.routed(Path::new("bcast").unwrap()).await.unwrap(); - let remote = consumer.request_broadcast(Path::new("bcast").unwrap(), None).await.unwrap(); + let remote = consumer + .request_broadcast(Path::new("bcast").unwrap(), None) + .await + .unwrap(); let mut subscriber = remote.track("data").unwrap().subscribe(None).await.unwrap(); support::harness::subscribed(&track).await; @@ -418,7 +424,11 @@ async fn ietf_fetch_keeps_the_stored_form() { options.client_subscribe = Some(origin.clone()); let _pair = connect_mock(options).await; origin.consume().routed(Path::new("bcast").unwrap()).await.unwrap(); - let remote = origin.consume().request_broadcast(Path::new("bcast").unwrap(), None).await.unwrap(); + let remote = origin + .consume() + .request_broadcast(Path::new("bcast").unwrap(), None) + .await + .unwrap(); let consumer = remote.track("data").unwrap(); assert_eq!(consumer.query().await.unwrap().compress, version != "moq-transport-16"); let mut fetched = consumer.fetch_group(0, moq_net::group::Fetch::default()).await.unwrap(); diff --git a/rs/moq-net/tests/integration/control_stats.rs b/rs/moq-net/tests/integration/control_stats.rs index 4df59a7734f..369898719fc 100644 --- a/rs/moq-net/tests/integration/control_stats.rs +++ b/rs/moq-net/tests/integration/control_stats.rs @@ -2,11 +2,11 @@ //! Control counters cross real protocol drivers, including legacy multiplexing. -use moq_net::Path; use crate::support::{ harness::{MockConnectOptions, connect_mock, now, spawn, subscribed}, mock::create_mock_session_pair, }; +use moq_net::Path; use moq_net::{ Timescale, Timestamp, origin, stats::{Control, Registry, Tier}, @@ -47,7 +47,11 @@ async fn control_classes_cross_lite_and_ietf_sessions_without_counting_payload() .unwrap(); broadcast.announce(Default::default()).unwrap(); subscriber.consume().routed(Path::new("room").unwrap()).await.unwrap(); - let remote = subscriber.consume().request_broadcast(Path::new("room").unwrap(), None).await.unwrap(); + let remote = subscriber + .consume() + .request_broadcast(Path::new("room").unwrap(), None) + .await + .unwrap(); let mut sub = remote.track("video").unwrap().subscribe(None).await.unwrap(); subscribed(&track).await; let mut group = track.append_group().unwrap(); diff --git a/rs/moq-net/tests/integration/datagram.rs b/rs/moq-net/tests/integration/datagram.rs index 9ea5efa87d9..2df78586f4a 100644 --- a/rs/moq-net/tests/integration/datagram.rs +++ b/rs/moq-net/tests/integration/datagram.rs @@ -7,8 +7,8 @@ //! delivery through the model. The mock delivers queued datagrams //! deterministically, so every wait here is on an observable event. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; @@ -57,7 +57,10 @@ async fn connect_datagram_track() -> Fixture { let consumer = consumer_origin.consume(); consumer.routed(Path::new("bench").unwrap()).await.unwrap(); - let remote = consumer.request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); + let remote = consumer + .request_broadcast(Path::new("bench").unwrap(), None) + .await + .unwrap(); let subscriber = remote.track("datagrams").unwrap().subscribe(None).await.unwrap(); // The subscriber is handed over once TRACK_INFO answers, before its SUBSCRIBE reaches // the publisher, and a datagram only goes to a subscription already there. @@ -152,7 +155,10 @@ async fn ietf_delivers_datagrams_on(version: &str) { let consumer = consumer_origin.consume(); consumer.routed(Path::new("bench").unwrap()).await.unwrap(); - let remote = consumer.request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); + let remote = consumer + .request_broadcast(Path::new("bench").unwrap(), None) + .await + .unwrap(); let mut subscriber = remote.track("datagrams").unwrap().subscribe(None).await.unwrap(); // A group first, so the subscription's alias is bound before any datagram lands. @@ -263,7 +269,10 @@ async fn a_fetched_datagram_is_refused_per_version() { let consumer = nodes.last().unwrap().consume(); consumer.routed(Path::new("room").unwrap()).await.unwrap(); - let remote = consumer.request_broadcast(Path::new("room").unwrap(), None).await.unwrap(); + let remote = consumer + .request_broadcast(Path::new("room").unwrap(), None) + .await + .unwrap(); let err = match remote.track("datagrams").unwrap().fetch_group(sequence, None).await { Ok(_) => panic!("{versions:?}: a datagram was fetched"), Err(err) => err, diff --git a/rs/moq-net/tests/integration/dial_split_horizon.rs b/rs/moq-net/tests/integration/dial_split_horizon.rs index 8c49e9fde74..8cd2cbd729e 100644 --- a/rs/moq-net/tests/integration/dial_split_horizon.rs +++ b/rs/moq-net/tests/integration/dial_split_horizon.rs @@ -8,8 +8,8 @@ //! anonymous dial: the accepting side already stamps one, and the dialing side //! has to as well. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; diff --git a/rs/moq-net/tests/integration/drained_claim.rs b/rs/moq-net/tests/integration/drained_claim.rs index 4e7c6a626a9..ee735ee2675 100644 --- a/rs/moq-net/tests/integration/drained_claim.rs +++ b/rs/moq-net/tests/integration/drained_claim.rs @@ -9,8 +9,8 @@ //! once unread lets the next viewer reach worker `B`, which wins the path now, rather //! than the drained worker. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::{cell::RefCell, rc::Rc, time::Duration}; @@ -84,7 +84,11 @@ impl Worker { /// Read the first frame of `video` at `pool/p` through `relay`. async fn watch(relay: &origin::Producer) -> String { - let broadcast = relay.consume().request_broadcast(Path::new("pool/p").unwrap(), None).await.unwrap(); + let broadcast = relay + .consume() + .request_broadcast(Path::new("pool/p").unwrap(), None) + .await + .unwrap(); let mut subscription = broadcast.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = subscription.recv_group().await.unwrap().expect("a group"); let frame = group.read_frame().await.unwrap().expect("a frame"); diff --git a/rs/moq-net/tests/integration/empty_group.rs b/rs/moq-net/tests/integration/empty_group.rs index 0003ea1cc93..2ef96e032a6 100644 --- a/rs/moq-net/tests/integration/empty_group.rs +++ b/rs/moq-net/tests/integration/empty_group.rs @@ -4,8 +4,8 @@ //! to 17 its stream is a bare header with no FIRST_OBJECT bit, which must not read as a //! group missing its head. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; diff --git a/rs/moq-net/tests/integration/empty_replacement.rs b/rs/moq-net/tests/integration/empty_replacement.rs index 59712f4c3b5..31f4ba5250f 100644 --- a/rs/moq-net/tests/integration/empty_replacement.rs +++ b/rs/moq-net/tests/integration/empty_replacement.rs @@ -6,8 +6,8 @@ //! contradicts a received group, which the relay treats as a protocol violation and closes //! the whole session. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; diff --git a/rs/moq-net/tests/integration/extensions.rs b/rs/moq-net/tests/integration/extensions.rs index ad77cfdbab4..ae99c015870 100644 --- a/rs/moq-net/tests/integration/extensions.rs +++ b/rs/moq-net/tests/integration/extensions.rs @@ -5,8 +5,8 @@ //! //! Deterministic: paused time over the mock transport. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; diff --git a/rs/moq-net/tests/integration/fetch_cancel.rs b/rs/moq-net/tests/integration/fetch_cancel.rs index c619edabb4d..4517c64301e 100644 --- a/rs/moq-net/tests/integration/fetch_cancel.rs +++ b/rs/moq-net/tests/integration/fetch_cancel.rs @@ -7,8 +7,8 @@ //! (lite has no FETCH_OK, so one that never answers would pin them for good) or is //! partway through the group. A group cut short is aborted, never cached as whole. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; @@ -175,7 +175,11 @@ async fn a_refetch_within_the_linger_stays_on_the_relay(version: &str) { broadcast.announce(Default::default()).unwrap(); moq_clock::sleep(Duration::from_secs(1)).await; - let consumer = relay.consume().request_broadcast(Path::new("room").unwrap(), None).await.unwrap(); + let consumer = relay + .consume() + .request_broadcast(Path::new("room").unwrap(), None) + .await + .unwrap(); let mut waiting = Box::pin(consumer.track("video").unwrap().fetch_group(0, None)); let request = match futures::future::select(std::pin::pin!(dynamic.requested_track()), &mut waiting).await { futures::future::Either::Left((request, _)) => request.expect("the track request reaches the publisher"), diff --git a/rs/moq-net/tests/integration/fetch_fanout.rs b/rs/moq-net/tests/integration/fetch_fanout.rs index f6ff36f2f08..8a6e038f1cb 100644 --- a/rs/moq-net/tests/integration/fetch_fanout.rs +++ b/rs/moq-net/tests/integration/fetch_fanout.rs @@ -3,8 +3,8 @@ //! A relay fetches each group's payload upstream once, independently of how many //! viewers ask for it, and keeps serving the cached copy after a reader leaves. -use moq_net::Path; use crate::support; +use moq_net::Path; use moq_net::{Hop, Version, origin, track}; use std::time::Duration; use support::harness::{MockConnectOptions, connect_mock}; @@ -20,7 +20,9 @@ async fn sequential_viewers_share_the_relays_fetched_groups() { for version in ["moq-lite-05", "moq-lite-06", "moq-lite-07-wip"] { let version: Version = version.parse().unwrap(); let publisher = origin(1); - let broadcast = publisher.publish(Path::new("room").unwrap(), Default::default()).unwrap(); + let broadcast = publisher + .publish(Path::new("room").unwrap(), Default::default()) + .unwrap(); let track = broadcast .create_track( "video", @@ -39,7 +41,11 @@ async fn sequential_viewers_share_the_relays_fetched_groups() { options.server_publish = Some(relay.consume()); options.client_subscribe = Some(viewer.clone()); let pair = connect_mock(options).await; - let remote = viewer.consume().routed_broadcast(Path::new("room").unwrap()).await.unwrap(); + let remote = viewer + .consume() + .routed_broadcast(Path::new("room").unwrap()) + .await + .unwrap(); viewers.push((viewer, pair, remote)); } for round in 0..3 { diff --git a/rs/moq-net/tests/integration/fetch_from_feed.rs b/rs/moq-net/tests/integration/fetch_from_feed.rs index f55dfe12bf5..2cac187e501 100644 --- a/rs/moq-net/tests/integration/fetch_from_feed.rs +++ b/rs/moq-net/tests/integration/fetch_from_feed.rs @@ -4,8 +4,8 @@ //! subscription: a group the feed delivers is served, and one it never will is a miss, //! never a version error that a caller would retry forever. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; diff --git a/rs/moq-net/tests/integration/fetch_only.rs b/rs/moq-net/tests/integration/fetch_only.rs index 54ec47eb7bf..f4f0e199f3d 100644 --- a/rs/moq-net/tests/integration/fetch_only.rs +++ b/rs/moq-net/tests/integration/fetch_only.rs @@ -6,8 +6,8 @@ //! fetchable, and a relay's fetch-only demand puts no live subscription upstream to race //! the fetches that report where the track ends. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::sync::Arc; use std::sync::atomic::{AtomicBool, Ordering}; diff --git a/rs/moq-net/tests/integration/finished_broadcast_mock.rs b/rs/moq-net/tests/integration/finished_broadcast_mock.rs index 83646367790..aef5dcd43ec 100644 --- a/rs/moq-net/tests/integration/finished_broadcast_mock.rs +++ b/rs/moq-net/tests/integration/finished_broadcast_mock.rs @@ -14,8 +14,8 @@ //! writes the track and ends it with no await in between, so the session has sent //! nothing when the broadcast ends. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; diff --git a/rs/moq-net/tests/integration/finite_relay.rs b/rs/moq-net/tests/integration/finite_relay.rs index f2362e612de..0dce75aabf1 100644 --- a/rs/moq-net/tests/integration/finite_relay.rs +++ b/rs/moq-net/tests/integration/finite_relay.rs @@ -8,8 +8,8 @@ //! last until those groups drain: a relay cancels its upstream subscription once nobody //! subscribes, and the publisher then resets every group still on the wire. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; diff --git a/rs/moq-net/tests/integration/goaway.rs b/rs/moq-net/tests/integration/goaway.rs index e11ab64484e..0ba9094eaff 100644 --- a/rs/moq-net/tests/integration/goaway.rs +++ b/rs/moq-net/tests/integration/goaway.rs @@ -6,8 +6,8 @@ //! network I/O), so these tests are reliable without sleeps: every wait is on //! an observable event. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; @@ -375,7 +375,9 @@ async fn goaway_keeps_new_subscribes(version: Version) { moq_clock::timeout(TEST_TIMEOUT, async { // Server publishes a broadcast with one live track. let pub_origin = produce_origin(Hop::random()); - let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); + let broadcast = pub_origin + .create_broadcast(Path::new("test").unwrap()) + .expect("create broadcast"); broadcast.announce(moq_net::origin::Route::default()).expect("announce"); let track = broadcast.create_track("video", timed()).expect("create track"); // A second track with content ready for the subscribe opened after the GOAWAY. @@ -397,7 +399,10 @@ async fn goaway_keeps_new_subscribes(version: Version) { // Subscribe BEFORE the GOAWAY and receive a first group. let sub = sub_origin.consume(); sub.routed(Path::new("test").unwrap()).await.expect("route announced"); - let bc = sub.request_broadcast(Path::new("test").unwrap(), None).await.expect("broadcast resolves"); + let bc = sub + .request_broadcast(Path::new("test").unwrap(), None) + .await + .expect("broadcast resolves"); let mut existing = bc.track("video").unwrap().subscribe(None).await.expect("subscribe"); let mut group = track.append_group().expect("append group"); @@ -485,7 +490,9 @@ async fn goaway_keeps_new_subscribes_moq_transport_19() { async fn goaway_drains_routes(version: Version) { moq_clock::timeout(TEST_TIMEOUT, async { let pub_origin = produce_origin(Hop::random()); - let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); + let broadcast = pub_origin + .create_broadcast(Path::new("test").unwrap()) + .expect("create broadcast"); broadcast.announce(moq_net::origin::Route::default()).expect("announce"); let sub_origin = produce_origin(Hop::random()); diff --git a/rs/moq-net/tests/integration/group_order.rs b/rs/moq-net/tests/integration/group_order.rs index 1ee1748e7e1..153dec73306 100644 --- a/rs/moq-net/tests/integration/group_order.rs +++ b/rs/moq-net/tests/integration/group_order.rs @@ -7,8 +7,8 @@ //! the hop into the subscriber and releases them by send order, the way a congested //! sender would transmit them. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; diff --git a/rs/moq-net/tests/integration/history_groups.rs b/rs/moq-net/tests/integration/history_groups.rs index 52a9ac9a21b..a2be64f4765 100644 --- a/rs/moq-net/tests/integration/history_groups.rs +++ b/rs/moq-net/tests/integration/history_groups.rs @@ -8,8 +8,8 @@ //! would drop the older group for good. The mock holds the publisher's group streams and //! releases them newest first to make that race deterministic. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; @@ -223,7 +223,10 @@ async fn a_late_subscriber_receives_the_relays_cached_history() { let first_pair = connect_mock(options).await; let consumer = first.consume(); consumer.routed(Path::new("bcast").unwrap()).await.unwrap(); - let remote = consumer.request_broadcast(Path::new("bcast").unwrap(), None).await.unwrap(); + let remote = consumer + .request_broadcast(Path::new("bcast").unwrap(), None) + .await + .unwrap(); let subscription = Subscription::default().with_max_delay(FOREVER).with_range(0..); let first_subscription = subscription.clone(); let first_reader = moq_clock::sim::spawn(async move { @@ -261,7 +264,10 @@ async fn a_late_subscriber_receives_the_relays_cached_history() { let late_pair = connect_mock(options).await; let consumer = late.consume(); consumer.routed(Path::new("bcast").unwrap()).await.unwrap(); - let remote = consumer.request_broadcast(Path::new("bcast").unwrap(), None).await.unwrap(); + let remote = consumer + .request_broadcast(Path::new("bcast").unwrap(), None) + .await + .unwrap(); let mut late_sub = remote.track("history").unwrap().subscribe(subscription).await.unwrap(); moq_clock::timeout(TIMEOUT, read_history(&mut late_sub)) .await diff --git a/rs/moq-net/tests/integration/idle_cancel_refetch.rs b/rs/moq-net/tests/integration/idle_cancel_refetch.rs index ca7f44c96d1..5f65ac50a1e 100644 --- a/rs/moq-net/tests/integration/idle_cancel_refetch.rs +++ b/rs/moq-net/tests/integration/idle_cancel_refetch.rs @@ -3,8 +3,8 @@ //! A relay whose last reader leaves mid-group cancels the idle upstream subscription. A later //! fetch of that group still gets every frame (#5348, a release-line regression). -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; diff --git a/rs/moq-net/tests/integration/idle_session.rs b/rs/moq-net/tests/integration/idle_session.rs index 673dd259f64..198a69dafea 100644 --- a/rs/moq-net/tests/integration/idle_session.rs +++ b/rs/moq-net/tests/integration/idle_session.rs @@ -4,8 +4,8 @@ //! no transport stats reads while nothing moves. A server holds thousands of these, //! so a fixed-interval timer per session adds up to whole cores. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::{ sync::{ diff --git a/rs/moq-net/tests/integration/ietf_conformance.rs b/rs/moq-net/tests/integration/ietf_conformance.rs index 01c708b97cb..d2d43ed80bb 100644 --- a/rs/moq-net/tests/integration/ietf_conformance.rs +++ b/rs/moq-net/tests/integration/ietf_conformance.rs @@ -2,8 +2,8 @@ //! Moxygen announces one prefix, then serves its sixteen-field test namespaces. -use moq_net::Path; use crate::support::harness::{MockConnectOptions, connect_mock, spawn}; +use moq_net::Path; use moq_net::{Hop, Version, broadcast, origin}; use std::sync::Arc; @@ -22,7 +22,11 @@ async fn routing(version: &str, cluster: bool) { let publisher = origin(1); let relay = origin(2); let reader = origin(4); - let prefix = Arc::new(publisher.dynamic_route(Path::new(PREFIX).unwrap(), Default::default()).unwrap()); + let prefix = Arc::new( + publisher + .dynamic_route(Path::new(PREFIX).unwrap(), Default::default()) + .unwrap(), + ); let broadcast = broadcast::Info::new().produce(); let track = broadcast.create_track("test", moq_net::track::Info::default()).unwrap(); let serving = prefix.clone(); @@ -55,7 +59,11 @@ async fn routing(version: &str, cluster: bool) { links.push(connect_mock(options).await); reader.consume().routed(Path::new(NAMESPACE).unwrap()).await.unwrap(); - let remote = reader.consume().request_broadcast(Path::new(NAMESPACE).unwrap(), None).await.unwrap(); + let remote = reader + .consume() + .request_broadcast(Path::new(NAMESPACE).unwrap(), None) + .await + .unwrap(); let mut subscription = remote.track("test").unwrap().subscribe(None).await.unwrap(); crate::support::harness::subscribed(&track).await; let mut group = track.append_group().unwrap(); diff --git a/rs/moq-net/tests/integration/late_lower_group.rs b/rs/moq-net/tests/integration/late_lower_group.rs index f83193b9b61..8a3f88f0b81 100644 --- a/rs/moq-net/tests/integration/late_lower_group.rs +++ b/rs/moq-net/tests/integration/late_lower_group.rs @@ -7,8 +7,8 @@ //! is dropped. Lite-06 and later encode a floor of group 0 as 0, which is the only //! spelling of both an omitted floor and group 0; the draft says that 0 is group 0. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; diff --git a/rs/moq-net/tests/integration/lazy_discovery.rs b/rs/moq-net/tests/integration/lazy_discovery.rs index 9325ebe89aa..44feddbdfdf 100644 --- a/rs/moq-net/tests/integration/lazy_discovery.rs +++ b/rs/moq-net/tests/integration/lazy_discovery.rs @@ -88,7 +88,12 @@ impl Lazy { /// Whether the client's origin routes `path` right now. async fn routes(&self, path: &str) -> bool { - match self.subscriber.consume().request_broadcast(Path::new(path).unwrap(), None).await { + match self + .subscriber + .consume() + .request_broadcast(Path::new(path).unwrap(), None) + .await + { Ok(_) => true, Err(Error::Unroutable) => false, Err(err) => panic!("{path}: {err}"), @@ -259,7 +264,12 @@ async fn a_resolved_broadcast_keeps_its_route() { let lazy = Lazy::new(version).await; let mut watch = lazy.watch("a"); synced(&mut watch).await; - let broadcast = lazy.subscriber.consume().request_broadcast(Path::new("a/x").unwrap(), None).await.unwrap(); + let broadcast = lazy + .subscriber + .consume() + .request_broadcast(Path::new("a/x").unwrap(), None) + .await + .unwrap(); drop(watch); moq_clock::sleep(LINGERED).await; @@ -304,7 +314,11 @@ async fn a_relay_link_asks_for_everything() { assert_eq!(lazy.requests(), 1, "{version}"); // Read through a plain handle: one taken from an upstream link hides its routes. for path in ["a/x", "b/y"] { - relay.consume().request_broadcast(Path::new(path).unwrap(), None).await.unwrap(); + relay + .consume() + .request_broadcast(Path::new(path).unwrap(), None) + .await + .unwrap(); } } } @@ -323,7 +337,11 @@ async fn a_server_asks_for_everything() { options.server_subscribe = Some(relay.clone()); let _pair = connect_mock(options).await; moq_clock::sleep(SETTLE).await; - relay.consume().request_broadcast(Path::new("a/x").unwrap(), None).await.unwrap(); + relay + .consume() + .request_broadcast(Path::new("a/x").unwrap(), None) + .await + .unwrap(); } } @@ -499,7 +517,11 @@ async fn ietf_a_relay_link_asks_for_everything() { let relay = produce_origin(2); let _lazy = Lazy::with(version, relay.clone().with_link(moq_net::origin::Link::Peer)).await; for path in ["a/x", "b/y"] { - relay.consume().request_broadcast(Path::new(path).unwrap(), None).await.unwrap(); + relay + .consume() + .request_broadcast(Path::new(path).unwrap(), None) + .await + .unwrap(); } } } diff --git a/rs/moq-net/tests/integration/mesh_withdraw.rs b/rs/moq-net/tests/integration/mesh_withdraw.rs index 34637ca50b6..d49abee3a26 100644 --- a/rs/moq-net/tests/integration/mesh_withdraw.rs +++ b/rs/moq-net/tests/integration/mesh_withdraw.rs @@ -7,8 +7,8 @@ //! withdrawn; a relay that selects them in turn re-advertises each stale path, and //! the cluster walks all of them before it converges (path hunting). -use moq_net::Path; use crate::support; +use moq_net::Path; use std::{collections::HashMap, time::Duration}; @@ -225,7 +225,9 @@ async fn partial_mesh_withdraw_retracts_once() { let mut watched: Vec<_> = nodes.iter().map(|node| watch(node.consume().announced())).collect(); for publisher in [5, 13, 22, 26, 32] { - let broadcast = nodes[publisher].create_broadcast(Path::try_from(format!("room/{publisher}")).unwrap()).unwrap(); + let broadcast = nodes[publisher] + .create_broadcast(Path::try_from(format!("room/{publisher}")).unwrap()) + .unwrap(); broadcast.announce(Default::default()).unwrap(); moq_clock::sim::idle().await; for (relay, watched) in watched.iter_mut().enumerate() { @@ -741,7 +743,9 @@ async fn hop_limit_falls_back_to_a_forwardable_route() { // Three hops at the relay once the sender is appended: in the cap, but full. let _cheap = far.dynamic_route(Path::new("room").unwrap(), route(100, 2, 1)).unwrap(); // Two hops at the relay, so it has room for the relay's own. - let pricey = near.dynamic_route(Path::new("room").unwrap(), route(200, 1, 50)).unwrap(); + let pricey = near + .dynamic_route(Path::new("room").unwrap(), route(200, 1, 50)) + .unwrap(); moq_clock::sim::idle().await; let started = drain(&mut sent); assert_eq!( diff --git a/rs/moq-net/tests/integration/model.rs b/rs/moq-net/tests/integration/model.rs index 1ad0f9adf7b..32663ccfc8f 100644 --- a/rs/moq-net/tests/integration/model.rs +++ b/rs/moq-net/tests/integration/model.rs @@ -30,7 +30,9 @@ fn origin_front_serves_media_with_only_explicit_polls() { broadcast.announce(origin::Route::default()).unwrap(); // Resolving and subscribing pass through the origin's core front tasks. - let requesting = origin.consume().request_broadcast(Path::new("room/live").unwrap(), None); + let requesting = origin + .consume() + .request_broadcast(Path::new("room/live").unwrap(), None); assert!(requesting.poll_ok(&waiter).is_pending()); driver.poll(now, &waiter).unwrap(); let receiving: broadcast::Consumer = ready(requesting.poll_ok(&waiter)).unwrap(); @@ -45,7 +47,10 @@ fn origin_front_serves_media_with_only_explicit_polls() { // Driver teardown also works without any executor-owned tasks. drop(driver); - assert!(matches!(origin.create_broadcast(Path::new("after-close").unwrap()), Err(Error::Closed))); + assert!(matches!( + origin.create_broadcast(Path::new("after-close").unwrap()), + Err(Error::Closed) + )); } #[test] diff --git a/rs/moq-net/tests/integration/multi_cdn.rs b/rs/moq-net/tests/integration/multi_cdn.rs index 810750e5f3d..e7a21c68b56 100644 --- a/rs/moq-net/tests/integration/multi_cdn.rs +++ b/rs/moq-net/tests/integration/multi_cdn.rs @@ -11,8 +11,8 @@ //! that cannot carry the epoch (before draft-17) makes each move a restart and a //! re-request. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; @@ -189,7 +189,12 @@ impl Topology { } async fn subscribe(&self) -> mpsc::UnboundedReceiver { - let remote = self.subscriber.consume().request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); + let remote = self + .subscriber + .consume() + .request_broadcast(Path::new("live").unwrap(), None) + .await + .unwrap(); let prefs = track::Subscription::default().with_max_delay(Duration::from_secs(60)); read(remote.track("video").unwrap().subscribe(prefs).await.unwrap()) } diff --git a/rs/moq-net/tests/integration/partial_group.rs b/rs/moq-net/tests/integration/partial_group.rs index d6c93d94a34..8326c106bc3 100644 --- a/rs/moq-net/tests/integration/partial_group.rs +++ b/rs/moq-net/tests/integration/partial_group.rs @@ -4,8 +4,8 @@ //! reaches the next hop as finished. The served stream resets with `Old`, so a relay does //! not cache the frames it already has as the whole group. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; diff --git a/rs/moq-net/tests/integration/quiet_catalog.rs b/rs/moq-net/tests/integration/quiet_catalog.rs index ffc5e5b7c16..14a4436df5f 100644 --- a/rs/moq-net/tests/integration/quiet_catalog.rs +++ b/rs/moq-net/tests/integration/quiet_catalog.rs @@ -5,8 +5,8 @@ //! catalog does not produce one, so a reader that never received the snapshot //! must still get it. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::{future::Future, time::Duration}; @@ -61,7 +61,10 @@ fn publish(origin: &origin::Producer) -> (broadcast::Producer, track::Producer) async fn request(origin: &origin::Producer) -> broadcast::Consumer { let consumer = origin.consume(); consumer.routed(Path::new("live").unwrap()).await.unwrap(); - consumer.request_broadcast(Path::new("live").unwrap(), None).await.unwrap() + consumer + .request_broadcast(Path::new("live").unwrap(), None) + .await + .unwrap() } /// Subscribe without a floor and expect the snapshot as group 0. diff --git a/rs/moq-net/tests/integration/range_anchors.rs b/rs/moq-net/tests/integration/range_anchors.rs index c80a5d46534..3fb0e9bb71e 100644 --- a/rs/moq-net/tests/integration/range_anchors.rs +++ b/rs/moq-net/tests/integration/range_anchors.rs @@ -5,8 +5,8 @@ //! the anchor the same way. A copy received over any other wire refuses the anchor instead //! of resolving it against the part of the track it happens to hold. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; @@ -65,10 +65,13 @@ async fn read(version: Option<&str>, range: Range) -> Result, Error> { let _pair; let remote = match version { // Through the origin, as a reader of a local route. - None => moq_clock::timeout(TIMEOUT, publisher.consume().request_broadcast(Path::new("room").unwrap(), None)) - .await - .expect("resolve timeout") - .expect("broadcast resolves"), + None => moq_clock::timeout( + TIMEOUT, + publisher.consume().request_broadcast(Path::new("room").unwrap(), None), + ) + .await + .expect("resolve timeout") + .expect("broadcast resolves"), Some(version) => { _pair = peer(version.parse::().unwrap(), &publisher, &subscriber).await; let consumer = subscriber.consume(); diff --git a/rs/moq-net/tests/integration/received_rewind.rs b/rs/moq-net/tests/integration/received_rewind.rs index fb822afd70e..80cacd602c4 100644 --- a/rs/moq-net/tests/integration/received_rewind.rs +++ b/rs/moq-net/tests/integration/received_rewind.rs @@ -7,8 +7,8 @@ //! cannot tell that from media time, so its copy is untimed and every hop past it sees an //! untimed track that nothing can refuse. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; diff --git a/rs/moq-net/tests/integration/refresh.rs b/rs/moq-net/tests/integration/refresh.rs index 418c74ff653..7e77b0866b6 100644 --- a/rs/moq-net/tests/integration/refresh.rs +++ b/rs/moq-net/tests/integration/refresh.rs @@ -1,8 +1,8 @@ #![cfg(feature = "async")] //! Refresh joins traverse real protocol hops, judged independently from each cache. -use moq_net::Path; use crate::support::harness::{MockConnectOptions, connect_mock, peer, spawn, subscribed}; +use moq_net::Path; use moq_net::{Hop, Version, origin, track}; use std::time::Duration; @@ -46,7 +46,11 @@ async fn json_snapshot_refresh_crosses_a_two_relay_cluster() { links.push(connect_mock(options).await); } reader.consume().routed(Path::new("room").unwrap()).await.unwrap(); - let remote = reader.consume().request_broadcast(Path::new("room").unwrap(), None).await.unwrap(); + let remote = reader + .consume() + .request_broadcast(Path::new("room").unwrap(), None) + .await + .unwrap(); let remote = remote.track("state").unwrap(); let mut baseline = remote.subscribe(None).await.unwrap(); assert_eq!(baseline.info().refresh, Some(ratio)); @@ -165,7 +169,11 @@ async fn ratio_joins_cross_two_relays() { links.push(connect_mock(options).await); } b.consume().routed(Path::new("room").unwrap()).await.unwrap(); - let remote = b.consume().request_broadcast(Path::new("room").unwrap(), None).await.unwrap(); + let remote = b + .consume() + .request_broadcast(Path::new("room").unwrap(), None) + .await + .unwrap(); let remote = remote.track("data").unwrap(); let mut baseline = remote.subscribe(None).await.unwrap(); assert_eq!(baseline.info().refresh, (name == "moq-lite-07-wip").then_some(1)); diff --git a/rs/moq-net/tests/integration/rejoin.rs b/rs/moq-net/tests/integration/rejoin.rs index 4d87cc5501e..a58dc049af2 100644 --- a/rs/moq-net/tests/integration/rejoin.rs +++ b/rs/moq-net/tests/integration/rejoin.rs @@ -2,8 +2,8 @@ //! A reader leaving and rejoining a track relayed over the in-memory mock transport. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; @@ -57,7 +57,10 @@ async fn rejoin_recovers_the_group_reset_on_leave() { let consumer = relay.consume(); consumer.routed(Path::new("bench").unwrap()).await.unwrap(); - let remote = consumer.request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); + let remote = consumer + .request_broadcast(Path::new("bench").unwrap(), None) + .await + .unwrap(); let ts = |ms| Timestamp::from_millis(ms).unwrap(); let prefs = || track::Subscription::default().with_max_delay(Duration::from_secs(10)); @@ -150,7 +153,10 @@ async fn rejoin_skips_a_cache_kept_by_another_handle() { let consumer = relay.consume(); consumer.routed(Path::new("bench").unwrap()).await.unwrap(); - let remote = consumer.request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); + let remote = consumer + .request_broadcast(Path::new("bench").unwrap(), None) + .await + .unwrap(); let ts = |ms| Timestamp::from_millis(ms).unwrap(); // Held for fetches only: it keeps the relay's copy without subscribing. @@ -222,7 +228,10 @@ async fn rejoin_mid_group_keeps_the_head_for_later_readers() { let consumer = client.consume(); consumer.routed(Path::new("bench").unwrap()).await.unwrap(); - let remote = consumer.request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); + let remote = consumer + .request_broadcast(Path::new("bench").unwrap(), None) + .await + .unwrap(); let mut sub = remote.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = sub.recv_group().await.unwrap().unwrap(); assert_eq!(group.read_frame().await.unwrap().unwrap().payload, b"a0".as_ref()); @@ -234,7 +243,11 @@ async fn rejoin_mid_group_keeps_the_head_for_later_readers() { assert_eq!(rejoined.read_frame().await.unwrap().unwrap().payload, b"a0".as_ref()); crate::support::wanted(track.demand()).await.unwrap(); - let later = relay.consume().request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); + let later = relay + .consume() + .request_broadcast(Path::new("bench").unwrap(), None) + .await + .unwrap(); let mut sub = later.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = sub.recv_group().await.unwrap().unwrap(); assert_eq!(group.sequence, 0, "{version}"); @@ -294,7 +307,10 @@ async fn rejoin_goes_live_without_the_join_head() { let consumer = client.consume(); consumer.routed(Path::new("bench").unwrap()).await.unwrap(); - let remote = consumer.request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); + let remote = consumer + .request_broadcast(Path::new("bench").unwrap(), None) + .await + .unwrap(); let mut sub = remote.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = sub.recv_group().await.unwrap().unwrap(); assert_eq!(group.read_frame().await.unwrap().unwrap().payload, b"a0".as_ref()); @@ -321,7 +337,11 @@ async fn rejoin_goes_live_without_the_join_head() { .unwrap(); next.finish().unwrap(); - let local = relay.consume().request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); + let local = relay + .consume() + .request_broadcast(Path::new("bench").unwrap(), None) + .await + .unwrap(); let mut sub = local.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = sub.recv_group().await.unwrap().unwrap(); assert_eq!(group.sequence, 1, "{version}"); @@ -358,7 +378,10 @@ async fn rejoin_during_the_cancel_skips_the_cache() { let consumer = relay.consume(); consumer.routed(Path::new("bench").unwrap()).await.unwrap(); - let remote = consumer.request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); + let remote = consumer + .request_broadcast(Path::new("bench").unwrap(), None) + .await + .unwrap(); let ts = |ms| Timestamp::from_millis(ms).unwrap(); let mut group = track.append_group().unwrap(); @@ -418,7 +441,10 @@ async fn rejoin_waits_for_the_answers_first_frame() { let consumer = relay.consume(); consumer.routed(Path::new("bench").unwrap()).await.unwrap(); - let remote = consumer.request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); + let remote = consumer + .request_broadcast(Path::new("bench").unwrap(), None) + .await + .unwrap(); let ts = |ms| Timestamp::from_millis(ms).unwrap(); // Held for fetches only: it keeps the relay's copy without subscribing. @@ -503,7 +529,10 @@ async fn leaving_after_the_cache_window_keeps_the_latest_group() { let pair = connect_mock(options).await; let consumer = client.consume(); consumer.routed(Path::new("bench").unwrap()).await.unwrap(); - let remote = consumer.request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); + let remote = consumer + .request_broadcast(Path::new("bench").unwrap(), None) + .await + .unwrap(); (remote, pair) } }; @@ -566,7 +595,10 @@ async fn rejoin_keeps_source_timestamps() { let consumer = client.consume(); consumer.routed(Path::new("bench").unwrap()).await.unwrap(); - let remote = consumer.request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); + let remote = consumer + .request_broadcast(Path::new("bench").unwrap(), None) + .await + .unwrap(); // Far from any arrival time, so a frame stamped on arrival cannot pass. let ts = |ms| Timestamp::from_millis(ms).unwrap(); @@ -669,7 +701,10 @@ async fn quiet_catalog_survives_cache_expiry(version: Version, takeover: bool) { let pair = connect_mock(options).await; let consumer = client.consume(); consumer.routed(Path::new("bench").unwrap()).await.unwrap(); - let remote = consumer.request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); + let remote = consumer + .request_broadcast(Path::new("bench").unwrap(), None) + .await + .unwrap(); let sub = remote.track("catalog").unwrap().subscribe(None).await.unwrap(); (sub, remote, pair) } diff --git a/rs/moq-net/tests/integration/relay_upstream_close.rs b/rs/moq-net/tests/integration/relay_upstream_close.rs index 996bcbfb9c9..d2fe648df19 100644 --- a/rs/moq-net/tests/integration/relay_upstream_close.rs +++ b/rs/moq-net/tests/integration/relay_upstream_close.rs @@ -11,8 +11,8 @@ //! the subscriber are held, with a one-message stream buffer, so the relay still holds //! most of the track when the upstream session ends. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; diff --git a/rs/moq-net/tests/integration/replacement.rs b/rs/moq-net/tests/integration/replacement.rs index 92b3ff43bbf..4e06b2c049d 100644 --- a/rs/moq-net/tests/integration/replacement.rs +++ b/rs/moq-net/tests/integration/replacement.rs @@ -10,8 +10,8 @@ //! of failing `Unroutable`. With an epoch the replacement continues the instance: no //! `Restart`, and the old handle keeps working. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; @@ -96,7 +96,11 @@ async fn replace(version: &str, epoch: Option) { other => panic!("{version}: expected the broadcast, got {other:?}"), } - let old = viewer.consume().request_broadcast(Path::new("cam").unwrap(), None).await.unwrap(); + let old = viewer + .consume() + .request_broadcast(Path::new("cam").unwrap(), None) + .await + .unwrap(); let mut sticky = subscribe(&old, "video").await.unwrap(); write(&video, "video:0"); assert_eq!(read(&mut sticky).await, "video:0", "{version}"); @@ -138,7 +142,11 @@ async fn replace(version: &str, epoch: Option) { } // Following the restart resolves the path afresh, and the new handle serves. - let fresh = viewer.consume().request_broadcast(Path::new("cam").unwrap(), None).await.unwrap(); + let fresh = viewer + .consume() + .request_broadcast(Path::new("cam").unwrap(), None) + .await + .unwrap(); assert!(!fresh.is_clone(&old), "{version}: joined the retired broadcast"); let mut followed = subscribe(&fresh, "meta").await.unwrap(); write(&meta, "meta:0"); @@ -204,7 +212,9 @@ async fn route_death(version: &str, relayed: bool, wait: Duration) { let relay = produce_origin(2); let viewer = produce_origin(3); - let cam = publisher.publish(Path::new("cam").unwrap(), origin::Route::default()).unwrap(); + let cam = publisher + .publish(Path::new("cam").unwrap(), origin::Route::default()) + .unwrap(); let video = cam.create_track("video", timed()).unwrap(); let upstream = if relayed { &relay } else { &viewer }; @@ -216,7 +226,11 @@ async fn route_death(version: &str, relayed: bool, wait: Duration) { let mut announced = viewer.consume().announced(); next_event(&mut announced).await; - let old = viewer.consume().request_broadcast(Path::new("cam").unwrap(), None).await.unwrap(); + let old = viewer + .consume() + .request_broadcast(Path::new("cam").unwrap(), None) + .await + .unwrap(); let mut sticky = subscribe(&old, "video").await.unwrap(); write(&video, "video:0"); assert_eq!(read(&mut sticky).await, "video:0", "{version}"); @@ -278,7 +292,9 @@ async fn restart_while_the_old_session_lingers(version: &str, old_hop: u64, new_ let viewer = produce_origin(3); let old = produce_origin(old_hop); - let old_cam = old.publish(Path::new("cam").unwrap(), origin::Route::default()).unwrap(); + let old_cam = old + .publish(Path::new("cam").unwrap(), origin::Route::default()) + .unwrap(); let _old_video = old_cam.create_track("video", timed()).unwrap(); let old_session = link(version, &old, &viewer).await; let mut announced = viewer.consume().announced(); @@ -289,12 +305,18 @@ async fn restart_while_the_old_session_lingers(version: &str, old_hop: u64, new_ old_session.server_transport.set_latency(Duration::from_secs(3600)); let new = produce_origin(new_hop); - let new_cam = new.publish(Path::new("cam").unwrap(), origin::Route::default()).unwrap(); + let new_cam = new + .publish(Path::new("cam").unwrap(), origin::Route::default()) + .unwrap(); let new_video = new_cam.create_track("video", timed()).unwrap(); let _new_session = link(version, &new, &viewer).await; moq_clock::sleep(PAST_HOLD).await; - let cam = viewer.consume().request_broadcast(Path::new("cam").unwrap(), None).await.unwrap(); + let cam = viewer + .consume() + .request_broadcast(Path::new("cam").unwrap(), None) + .await + .unwrap(); let mut video = subscribe(&cam, "video") .await .unwrap_or_else(|err| panic!("{version} ({old_hop} -> {new_hop}): {err}")); diff --git a/rs/moq-net/tests/integration/request_caps.rs b/rs/moq-net/tests/integration/request_caps.rs index 93b93ece132..2349829f595 100644 --- a/rs/moq-net/tests/integration/request_caps.rs +++ b/rs/moq-net/tests/integration/request_caps.rs @@ -6,8 +6,8 @@ //! limits size is granted back as requests close, so a client that keeps opening and closing //! requests within them never stalls. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; @@ -83,10 +83,13 @@ async fn closed_requests_are_granted_back() { // A window of 8 requests, far fewer than the rounds below. Doubling the limit leaves // room for an UNSUBSCRIBE still in flight when the next SUBSCRIBE lands. let setup = setup(version, limits(0, 4), ROUNDS).await; - let broadcast = moq_clock::timeout(TIMEOUT, setup.client.consume().routed_broadcast(Path::new("bcast").unwrap())) - .await - .expect("announce timeout") - .unwrap(); + let broadcast = moq_clock::timeout( + TIMEOUT, + setup.client.consume().routed_broadcast(Path::new("bcast").unwrap()), + ) + .await + .expect("announce timeout") + .unwrap(); for round in 0..ROUNDS { let track = broadcast.track(&format!("t{round}")).unwrap(); diff --git a/rs/moq-net/tests/integration/restart.rs b/rs/moq-net/tests/integration/restart.rs index a2f6364bc21..1ba7aed1356 100644 --- a/rs/moq-net/tests/integration/restart.rs +++ b/rs/moq-net/tests/integration/restart.rs @@ -9,8 +9,8 @@ //! retires its copy of the old source, so a new subscriber never sees the old //! instance's cached groups. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::{cell::RefCell, rc::Rc, time::Duration}; @@ -106,7 +106,11 @@ async fn read(subscription: &mut track::Subscriber) -> String { } async fn subscribe(origin: &origin::Producer, path: &str) -> (broadcast::Consumer, track::Subscriber) { - let broadcast = origin.consume().request_broadcast(Path::new(path).unwrap(), None).await.unwrap(); + let broadcast = origin + .consume() + .request_broadcast(Path::new(path).unwrap(), None) + .await + .unwrap(); let subscription = broadcast.track("video").unwrap().subscribe(None).await.unwrap(); (broadcast, subscription) } @@ -122,7 +126,9 @@ async fn relay_chain(version: &str) { let _upstream = link(version, &publisher, &relay).await; let _downstream = link(version, &relay, &viewer).await; - let old = publisher.publish(Path::new("live").unwrap(), origin::Route::default()).unwrap(); + let old = publisher + .publish(Path::new("live").unwrap(), origin::Route::default()) + .unwrap(); let old_track = old.create_track("video", timed()).unwrap(); let mut announced = viewer.consume().announced(); match next_event(&mut announced).await { @@ -137,7 +143,9 @@ async fn relay_chain(version: &str) { } // The publisher restarts without an epoch, its old session still open. - let new = publisher.publish(Path::new("live").unwrap(), origin::Route::default()).unwrap(); + let new = publisher + .publish(Path::new("live").unwrap(), origin::Route::default()) + .unwrap(); let new_track = new.create_track("video", timed()).unwrap(); expect_restart(version, &mut announced, "live").await; @@ -183,7 +191,11 @@ struct Worker { impl Worker { fn new(hop: u64) -> Self { let origin = produce_origin(hop); - let claim = Rc::new(origin.dynamic_route(Path::new("pool").unwrap(), origin::Route::default()).unwrap()); + let claim = Rc::new( + origin + .dynamic_route(Path::new("pool").unwrap(), origin::Route::default()) + .unwrap(), + ); let outputs = Rc::new(RefCell::new(Vec::new())); let (handler, served) = (claim.clone(), outputs.clone()); drop(moq_clock::sim::spawn(async move { @@ -428,7 +440,11 @@ async fn dynamic_epoch_second_route_keeps_winning() { "dropping a shared epoch delivered {event:?}" ); } - let fresh = origin.consume().request_broadcast(Path::new("live/cam").unwrap(), None).await.unwrap(); + let fresh = origin + .consume() + .request_broadcast(Path::new("live/cam").unwrap(), None) + .await + .unwrap(); assert!(fresh.is_clone(&resolved), "the epoch's broadcast was replaced"); assert_eq!((first.answered(), second.answered()), (1, 1)); // The same epoch serves the same bytes: group 0 was delivered, so it resumes at 1. @@ -548,7 +564,9 @@ async fn withdrawal_refuses_new_fetches_but_keeps_open_reads() { let publisher = produce_origin(1); let viewer = produce_origin(2); let _session = link(version, &publisher, &viewer).await; - let source = publisher.publish(Path::new("live").unwrap(), origin::Route::default()).unwrap(); + let source = publisher + .publish(Path::new("live").unwrap(), origin::Route::default()) + .unwrap(); let produced = source.create_track("video", timed()).unwrap(); let mut announced = viewer.consume().announced(); assert!(matches!(next_event(&mut announced).await, announce::Event::Start(_))); @@ -584,7 +602,9 @@ async fn a_more_specific_source_cannot_fill_a_held_covering_track() { let track = held.track("video").unwrap(); old.write(0, "old:0"); assert_eq!(read(&mut subscription).await, "old:0"); - let replacement = publisher.publish(Path::new("live/job").unwrap(), origin::Route::default()).unwrap(); + let replacement = publisher + .publish(Path::new("live/job").unwrap(), origin::Route::default()) + .unwrap(); let replacement_track = replacement.create_track("video", timed()).unwrap(); write(&replacement_track, "new:0"); write(&replacement_track, "new:1"); @@ -644,7 +664,11 @@ impl Pool { /// subscription through it is reset once the exact route arrives: the cold-start reset /// accepted until announce takeover lands. async fn claimed(origin: &origin::Producer, path: &str) -> (broadcast::Consumer, track::Subscriber) { - let cold = origin.consume().request_broadcast(Path::new(path).unwrap(), None).await.unwrap(); + let cold = origin + .consume() + .request_broadcast(Path::new(path).unwrap(), None) + .await + .unwrap(); drop(cold.track("video").unwrap().subscribe(None).await); settle().await; subscribe(origin, path).await diff --git a/rs/moq-net/tests/integration/route_change.rs b/rs/moq-net/tests/integration/route_change.rs index dba1857d04f..121de83b7c5 100644 --- a/rs/moq-net/tests/integration/route_change.rs +++ b/rs/moq-net/tests/integration/route_change.rs @@ -16,8 +16,8 @@ //! Two publishers sharing one explicit epoch, a redundant pair, are one source the //! same way. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::collections::BTreeMap; use std::time::Duration; @@ -126,7 +126,10 @@ impl Topology { let consumer = subscriber.consume(); consumer.routed(Path::new("live").unwrap()).await.unwrap(); - let remote = consumer.request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); + let remote = consumer + .request_broadcast(Path::new("live").unwrap(), None) + .await + .unwrap(); let prefs = track::Subscription::default().with_max_delay(Duration::from_secs(60)); let sub = remote.track("video").unwrap().subscribe(prefs).await.unwrap(); @@ -389,7 +392,10 @@ async fn better_route_restarts(version: &str) { let mut group = topology.track.append_group().unwrap(); group.write_frame(Timestamp::ZERO, payload(0, 0)).unwrap(); assert_eq!(next(&mut rx).await, (0, payload(0, 0)), "{version}"); - let incumbent = consumer.request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); + let incumbent = consumer + .request_broadcast(Path::new("live").unwrap(), None) + .await + .unwrap(); topology.trigger(Trigger::BetterRoute).await; match announced.next().await.expect("announced") { @@ -405,7 +411,10 @@ async fn better_route_restarts(version: &str) { assert_eq!(next(&mut rx).await, (0, payload(0, 1)), "{version}"); // A re-request resolves the better route on a fresh broadcast. - let replaced = consumer.request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); + let replaced = consumer + .request_broadcast(Path::new("live").unwrap(), None) + .await + .unwrap(); assert!(!replaced.is_clone(&incumbent), "{version}: joined the replaced front"); let sub = replaced.track("video").unwrap().subscribe(None).await.unwrap(); let mut fresh = read(sub); @@ -532,7 +541,10 @@ async fn lagging_route_dies(version: Version) { async fn subscribe(origin: &origin::Producer) -> track::Subscriber { let consumer = origin.consume(); consumer.routed(Path::new("live").unwrap()).await.unwrap(); - let remote = consumer.request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); + let remote = consumer + .request_broadcast(Path::new("live").unwrap(), None) + .await + .unwrap(); let preferences = track::Subscription::default().with_max_delay(Duration::from_secs(60)); remote.track("video").unwrap().subscribe(preferences).await.unwrap() } @@ -659,7 +671,10 @@ async fn undetected_outage(budget: Duration) -> BTreeMap> { let consumer = e.consume(); consumer.routed(Path::new("live").unwrap()).await.unwrap(); - let remote = consumer.request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); + let remote = consumer + .request_broadcast(Path::new("live").unwrap(), None) + .await + .unwrap(); let prefs = track::Subscription::default().with_max_delay(budget); let mut rx = read(remote.track("video").unwrap().subscribe(prefs).await.unwrap()); let m2_e = priced_link(version, &m2, &e, Some(1_000)).await; @@ -805,7 +820,10 @@ async fn redundant_pair_fails_over(version: &str, loss: Loss) { settle().await; let consumer = subscriber.consume(); - let remote = consumer.request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); + let remote = consumer + .request_broadcast(Path::new("live").unwrap(), None) + .await + .unwrap(); let prefs = track::Subscription::default().with_max_delay(Duration::from_secs(60)); let mut rx = read(remote.track("video").unwrap().subscribe(prefs).await.unwrap()); @@ -915,7 +933,10 @@ async fn replaced_behind_a_relay(version: &str, epoch: Option, r let consumer = downstream.consume(); consumer.routed(Path::new("live").unwrap()).await.unwrap(); - let remote = consumer.request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); + let remote = consumer + .request_broadcast(Path::new("live").unwrap(), None) + .await + .unwrap(); let prefs = track::Subscription::default().with_max_delay(Duration::from_secs(60)); let mut rx = read(remote.track("video").unwrap().subscribe(prefs).await.unwrap()); @@ -1031,7 +1052,10 @@ async fn producer_replaced(version: &str) { let consumer = subscriber.consume(); consumer.routed(Path::new("live").unwrap()).await.unwrap(); - let remote = consumer.request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); + let remote = consumer + .request_broadcast(Path::new("live").unwrap(), None) + .await + .unwrap(); let prefs = track::Subscription::default().with_max_delay(Duration::from_secs(60)); let sub = remote.track("video").unwrap().subscribe(prefs).await.unwrap(); let mut rx = read(sub); diff --git a/rs/moq-net/tests/integration/session_close.rs b/rs/moq-net/tests/integration/session_close.rs index 6ee3cb0ec6b..9860961159c 100644 --- a/rs/moq-net/tests/integration/session_close.rs +++ b/rs/moq-net/tests/integration/session_close.rs @@ -5,8 +5,8 @@ //! //! Deterministic: simulated time over the mock transport. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; @@ -119,7 +119,10 @@ async fn track_info_interest_precedes_a_subscription() { let _pair = connect_mock(options).await; let consumer = subscriber.consume(); consumer.routed(Path::new("bcast").unwrap()).await.unwrap(); - let remote = consumer.request_broadcast(Path::new("bcast").unwrap(), None).await.unwrap(); + let remote = consumer + .request_broadcast(Path::new("bcast").unwrap(), None) + .await + .unwrap(); let copy = remote.track("video").unwrap(); copy.query().await.expect("TRACK_INFO"); crate::support::wanted(track.demand()) diff --git a/rs/moq-net/tests/integration/session_panic.rs b/rs/moq-net/tests/integration/session_panic.rs index 50636699858..0ae87092ed1 100644 --- a/rs/moq-net/tests/integration/session_panic.rs +++ b/rs/moq-net/tests/integration/session_panic.rs @@ -9,8 +9,8 @@ //! //! Deterministic: simulated time over the mock transport. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; diff --git a/rs/moq-net/tests/integration/settled_end_survives_abort.rs b/rs/moq-net/tests/integration/settled_end_survives_abort.rs index 60743126d4d..4c5c40bf8b9 100644 --- a/rs/moq-net/tests/integration/settled_end_survives_abort.rs +++ b/rs/moq-net/tests/integration/settled_end_survives_abort.rs @@ -5,8 +5,8 @@ //! the session dying, ends the track cleanly but must not throw those groups away: a //! consumer that has not read them yet still gets them, then the clean end. -use moq_net::Path; use crate::support; +use moq_net::Path; use moq_net::{Error, Hop, Timestamp}; diff --git a/rs/moq-net/tests/integration/source_errors.rs b/rs/moq-net/tests/integration/source_errors.rs index 751c1704480..45627216c88 100644 --- a/rs/moq-net/tests/integration/source_errors.rs +++ b/rs/moq-net/tests/integration/source_errors.rs @@ -6,8 +6,8 @@ //! Each case runs publisher -> relay -> far over two mock sessions. moq-lite only: //! moq-transport's PUBLISH_DONE registry has no code for either error. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; diff --git a/rs/moq-net/tests/integration/stream_credit.rs b/rs/moq-net/tests/integration/stream_credit.rs index 98755333403..d676c883774 100644 --- a/rs/moq-net/tests/integration/stream_credit.rs +++ b/rs/moq-net/tests/integration/stream_credit.rs @@ -35,7 +35,11 @@ async fn one_stream_credit_serves_every_backlogged_group() { options.client_subscribe = Some(viewer.clone()); let _pair = connect_mock(options).await; - let remote = viewer.consume().routed_broadcast(Path::new("live").unwrap()).await.unwrap(); + let remote = viewer + .consume() + .routed_broadcast(Path::new("live").unwrap()) + .await + .unwrap(); let prefs = track::Subscription::default().with_max_delay(Duration::from_secs(30)); let mut subscribers = Vec::new(); for i in 0..tracks.len() { diff --git a/rs/moq-net/tests/integration/subscribe_priority.rs b/rs/moq-net/tests/integration/subscribe_priority.rs index c0c49bbff59..4eb04ac5ca0 100644 --- a/rs/moq-net/tests/integration/subscribe_priority.rs +++ b/rs/moq-net/tests/integration/subscribe_priority.rs @@ -3,8 +3,8 @@ //! One upstream subscription carries the aggregate priority of the subscribers it serves, //! and follows it as they come and go, directly and through a relay. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; diff --git a/rs/moq-net/tests/integration/subscribe_ranges.rs b/rs/moq-net/tests/integration/subscribe_ranges.rs index d99ddcc12ec..68dc1df018e 100644 --- a/rs/moq-net/tests/integration/subscribe_ranges.rs +++ b/rs/moq-net/tests/integration/subscribe_ranges.rs @@ -3,8 +3,8 @@ //! Subscribers asking for different ranges of one track share a single upstream //! subscription, and each still gets the groups its own range asks for. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; diff --git a/rs/moq-net/tests/integration/subscribe_tracks.rs b/rs/moq-net/tests/integration/subscribe_tracks.rs index 9ad4c561391..f074f2acbb8 100644 --- a/rs/moq-net/tests/integration/subscribe_tracks.rs +++ b/rs/moq-net/tests/integration/subscribe_tracks.rs @@ -5,8 +5,8 @@ //! //! Deterministic: paused time and a single-threaded runtime over the mock transport. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; diff --git a/rs/moq-net/tests/integration/subscriber_max_age.rs b/rs/moq-net/tests/integration/subscriber_max_age.rs index bc3422bf0ad..982576b7ba3 100644 --- a/rs/moq-net/tests/integration/subscriber_max_age.rs +++ b/rs/moq-net/tests/integration/subscriber_max_age.rs @@ -53,7 +53,10 @@ async fn relay_forwards_the_most_tolerant_subscriber_max_age() { broadcast.announce(Default::default()).unwrap(); let consumer = viewer.consume(); consumer.routed(Path::new("live").unwrap()).await.unwrap(); - let remote = consumer.request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); + let remote = consumer + .request_broadcast(Path::new("live").unwrap(), None) + .await + .unwrap(); let cache = remote.track("catalog").unwrap(); let prefs = |millis| track::Subscription::default().with_max_delay(Duration::from_millis(millis)); let mut short = cache.subscribe(prefs(250)).await.unwrap(); diff --git a/rs/moq-net/tests/integration/subscription_end_integrity.rs b/rs/moq-net/tests/integration/subscription_end_integrity.rs index 43b781b7966..f5afc71c406 100644 --- a/rs/moq-net/tests/integration/subscription_end_integrity.rs +++ b/rs/moq-net/tests/integration/subscription_end_integrity.rs @@ -19,8 +19,8 @@ //! Deterministic: paused time, single-threaded runtime, and every "let the session //! send" step is an idle-advance rather than a race. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; diff --git a/rs/moq-net/tests/integration/track_abort_over_session.rs b/rs/moq-net/tests/integration/track_abort_over_session.rs index 7e7f6f2891f..8b3f268e1f8 100644 --- a/rs/moq-net/tests/integration/track_abort_over_session.rs +++ b/rs/moq-net/tests/integration/track_abort_over_session.rs @@ -3,8 +3,8 @@ //! A track aborted by its publisher while the broadcast stays announced, read by a //! subscriber on the far side of one session. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; @@ -40,7 +40,10 @@ async fn after_abort(version: &str, hops: u32) { let _pair2 = connect_mock(options).await; let consumer = if hops == 2 { far.consume() } else { relay.consume() }; consumer.routed(Path::new("bench").unwrap()).await.unwrap(); - let remote = consumer.request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); + let remote = consumer + .request_broadcast(Path::new("bench").unwrap(), None) + .await + .unwrap(); let mut sub = remote.track("video").unwrap().subscribe(None).await.unwrap(); let mut open = track.append_group().unwrap(); open.write_frame(Timestamp::ZERO, b"head".as_ref()).unwrap(); @@ -83,7 +86,11 @@ async fn recreate(finish: bool) { .announce(moq_net::origin::Route::default().with_epoch(moq_net::Epoch::mint())) .unwrap(); let track = broadcast.create_track("video", timed()).unwrap(); - let remote = origin.consume().request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); + let remote = origin + .consume() + .request_broadcast(Path::new("bench").unwrap(), None) + .await + .unwrap(); let mut sub = remote.track("video").unwrap().subscribe(None).await.unwrap(); let mut open = track.create_group(moq_net::group::Info { sequence: 2 }).unwrap(); open.write_frame(Timestamp::ZERO, b"head".as_ref()).unwrap(); diff --git a/rs/moq-net/tests/integration/track_info_cancel.rs b/rs/moq-net/tests/integration/track_info_cancel.rs index 50ea41e2eef..0c0d8d16871 100644 --- a/rs/moq-net/tests/integration/track_info_cancel.rs +++ b/rs/moq-net/tests/integration/track_info_cancel.rs @@ -8,8 +8,8 @@ //! with its stream credit spent) pins them for good, and a relay retrying across //! routes accumulates them until it runs out of memory. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; @@ -86,7 +86,11 @@ async fn withdrawn_broadcast_releases_track_info(version: &str, answered: bool, options.server_publish = Some(publisher.consume()); options.client_subscribe = Some(reader.clone()); let pair = connect_mock(options).await; - let remote = reader.consume().routed_broadcast(Path::new("room").unwrap()).await.unwrap(); + let remote = reader + .consume() + .routed_broadcast(Path::new("room").unwrap()) + .await + .unwrap(); let mut query = remote.track("video").unwrap().query(); let request = match futures::future::select(std::pin::pin!(dynamic.requested_track()), &mut query).await { futures::future::Either::Left((request, _)) => request.expect("TRACK reaches the publisher"), diff --git a/rs/moq-net/tests/integration/track_stream_demand.rs b/rs/moq-net/tests/integration/track_stream_demand.rs index f1e6d9f898f..a833d016554 100644 --- a/rs/moq-net/tests/integration/track_stream_demand.rs +++ b/rs/moq-net/tests/integration/track_stream_demand.rs @@ -8,8 +8,8 @@ //! publisher watching its demand sees one `used` edge for a viewer, not `used`, `unused`, //! `used` with a round trip per hop in between. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::{cell::RefCell, rc::Rc, time::Duration}; @@ -129,7 +129,10 @@ async fn one_used_edge(version: &str, relays: usize, reorder: bool) { .await .unwrap_or_else(|_| panic!("{label}: never announced")) .unwrap(); - let remote = consumer.request_broadcast(Path::new("room").unwrap(), None).await.unwrap(); + let remote = consumer + .request_broadcast(Path::new("room").unwrap(), None) + .await + .unwrap(); let subscribing = remote.track("video").unwrap().subscribe(None); if reorder { @@ -225,7 +228,10 @@ async fn bare_handle_is_lazy(version: &str, relays: usize) { .await .unwrap_or_else(|_| panic!("{label}: never announced")) .unwrap(); - let remote = consumer.request_broadcast(Path::new("room").unwrap(), None).await.unwrap(); + let remote = consumer + .request_broadcast(Path::new("room").unwrap(), None) + .await + .unwrap(); let handle = remote.track("video").unwrap(); moq_clock::sleep(Duration::from_secs(1)).await; diff --git a/rs/moq-net/tests/integration/track_tail.rs b/rs/moq-net/tests/integration/track_tail.rs index 7a07d954b04..f6be3d4f534 100644 --- a/rs/moq-net/tests/integration/track_tail.rs +++ b/rs/moq-net/tests/integration/track_tail.rs @@ -11,8 +11,8 @@ //! //! Time is paused, so the one-second grace for a group that never arrives is free. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; diff --git a/rs/moq-net/tests/integration/tracks.rs b/rs/moq-net/tests/integration/tracks.rs index 365fc4e6c12..03174cd3216 100644 --- a/rs/moq-net/tests/integration/tracks.rs +++ b/rs/moq-net/tests/integration/tracks.rs @@ -3,8 +3,8 @@ //! A moq-lite-07 TRACKS listing over a session and through a relay: each hop syncs with //! what it holds at once, and the upstream's tracks follow as live adds. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; diff --git a/rs/moq-net/tests/integration/tracks_ietf.rs b/rs/moq-net/tests/integration/tracks_ietf.rs index cead26e34ac..93870b8f1a1 100644 --- a/rs/moq-net/tests/integration/tracks_ietf.rs +++ b/rs/moq-net/tests/integration/tracks_ietf.rs @@ -6,8 +6,8 @@ //! //! Deterministic: paused time and a single-threaded runtime over the mock transport. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; diff --git a/rs/moq-net/tests/integration/unannounce_release.rs b/rs/moq-net/tests/integration/unannounce_release.rs index db6043634dd..e59c0ef7a14 100644 --- a/rs/moq-net/tests/integration/unannounce_release.rs +++ b/rs/moq-net/tests/integration/unannounce_release.rs @@ -3,8 +3,8 @@ //! A relay reading a broadcast that its publisher unannounced still cancels its upstream //! subscription once its last reader leaves, so the publisher's demand goes unused. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; @@ -25,12 +25,17 @@ async fn release(version: Version) { options.client_subscribe = Some(relay.clone()); let _pair = connect_mock(options).await; - let broadcast = publisher.publish(Path::new("a/b").unwrap(), moq_net::origin::Route::default()).unwrap(); + let broadcast = publisher + .publish(Path::new("a/b").unwrap(), moq_net::origin::Route::default()) + .unwrap(); let track = broadcast.create_track("t", None).unwrap(); let consumer = relay.consume(); consumer.routed(Path::new("a/b").unwrap()).await.expect("routed"); - let remote = consumer.request_broadcast(Path::new("a/b").unwrap(), None).await.expect("resolves"); + let remote = consumer + .request_broadcast(Path::new("a/b").unwrap(), None) + .await + .expect("resolves"); let sub = remote.track("t").unwrap().subscribe(None).await.expect("subscribes"); crate::support::wanted(track.demand()).await.unwrap(); diff --git a/rs/moq-net/tests/integration/untimed.rs b/rs/moq-net/tests/integration/untimed.rs index 37539168abf..cf78371c33e 100644 --- a/rs/moq-net/tests/integration/untimed.rs +++ b/rs/moq-net/tests/integration/untimed.rs @@ -7,8 +7,8 @@ //! encoder writes its send time instead, and their receivers drop every timestamp, which //! leaves a timed track untimed too. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; @@ -186,7 +186,11 @@ async fn an_explicit_start_holds_on_an_untimed_track() { } moq_clock::sleep(Duration::from_secs(1)).await; - let consumer = chain.nodes[1].consume().request_broadcast(Path::new("room").unwrap(), None).await.unwrap(); + let consumer = chain.nodes[1] + .consume() + .request_broadcast(Path::new("room").unwrap(), None) + .await + .unwrap(); let subscription = track::Subscription::default() .with_range(2..) .with_max_delay(Duration::from_secs(30)); @@ -243,7 +247,11 @@ async fn a_fetched_untimed_frame_arrives_untimed() { broadcast.announce(Default::default()).unwrap(); moq_clock::sleep(Duration::from_secs(1)).await; - let consumer = chain.nodes[1].consume().request_broadcast(Path::new("room").unwrap(), None).await.unwrap(); + let consumer = chain.nodes[1] + .consume() + .request_broadcast(Path::new("room").unwrap(), None) + .await + .unwrap(); let mut waiting = Box::pin(consumer.track("video").unwrap().fetch_group(0, None)); let request = match futures::future::select(std::pin::pin!(dynamic.requested_track()), &mut waiting).await { futures::future::Either::Left((request, _)) => request.expect("the track request reaches the publisher"), diff --git a/rs/moq-net/tests/integration/wide_hop.rs b/rs/moq-net/tests/integration/wide_hop.rs index d8b9b55a147..658687351c1 100644 --- a/rs/moq-net/tests/integration/wide_hop.rs +++ b/rs/moq-net/tests/integration/wide_hop.rs @@ -3,8 +3,8 @@ //! Hop IDs span 64 bits. A link whose varint stops at 2^62 - 1 carries a larger //! one as 0, the reserved unknown hop. -use moq_net::Path; use crate::support; +use moq_net::Path; use moq_net::{Hop, Version, cache, origin}; use support::harness::peer; @@ -29,13 +29,23 @@ async fn widest_hop_crosses_each_varint_form() { let upstream: Version = "moq-transport-18".parse().unwrap(); let _upstream = peer(upstream, &source, &relay).await; let _downstream = peer(downstream.parse().unwrap(), &relay, &sink).await; - let _route = source.dynamic_route(Path::new("room").unwrap(), origin::Route::default()).unwrap(); + let _route = source + .dynamic_route(Path::new("room").unwrap(), origin::Route::default()) + .unwrap(); moq_clock::sim::idle().await; let ids = |route: origin::Route| route.hops.iter().map(|hop| hop.id()).collect::>(); - let at_relay = relay.consume().routed(Path::new("room").unwrap()).await.expect("relay learned the route"); + let at_relay = relay + .consume() + .routed(Path::new("room").unwrap()) + .await + .expect("relay learned the route"); assert_eq!(ids(at_relay), [u64::MAX], "{downstream}"); - let at_sink = sink.consume().routed(Path::new("room").unwrap()).await.expect("sink learned the route"); + let at_sink = sink + .consume() + .routed(Path::new("room").unwrap()) + .await + .expect("sink learned the route"); assert_eq!(ids(at_sink), [forwarded, 2], "{downstream}"); } } diff --git a/rs/moq-net/tests/integration/wide_sequence.rs b/rs/moq-net/tests/integration/wide_sequence.rs index 3ed48c6dd31..becc96cd6a9 100644 --- a/rs/moq-net/tests/integration/wide_sequence.rs +++ b/rs/moq-net/tests/integration/wide_sequence.rs @@ -2,8 +2,8 @@ //! Group sequence boundaries, directly and through a forwarding origin. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; @@ -37,7 +37,11 @@ async fn largest_quic_sequence_reaches_the_subscriber() { None }; client.consume().routed(Path::new("ladder").unwrap()).await.unwrap(); - let remote = client.consume().request_broadcast(Path::new("ladder").unwrap(), None).await.unwrap(); + let remote = client + .consume() + .request_broadcast(Path::new("ladder").unwrap(), None) + .await + .unwrap(); let mut sub = remote.track("data").unwrap().subscribe(None).await.unwrap(); for sequence in [5, 1 << 32, (1 << 53) - 1, (1 << 53) + 1, (1 << 62) - 1] { // Timestamps stop at 2^61 - 1, the most lite-05/06 can zigzag as a first frame. @@ -102,13 +106,20 @@ async fn wide_sequence_fails_only_its_subscription() { // lite-07 carries the full 64 bits, so the relay holds the group. relay.consume().routed(Path::new("bench").unwrap()).await.unwrap(); - let cached = relay.consume().request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); + let cached = relay + .consume() + .request_broadcast(Path::new("bench").unwrap(), None) + .await + .unwrap(); let mut sub = cached.track("wide").unwrap().subscribe(None).await.unwrap(); assert_eq!(sub.recv_group().await.unwrap().unwrap().sequence, WIDE); let consumer = client.consume(); consumer.routed(Path::new("bench").unwrap()).await.unwrap(); - let remote = consumer.request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); + let remote = consumer + .request_broadcast(Path::new("bench").unwrap(), None) + .await + .unwrap(); let result = moq_clock::timeout(Duration::from_secs(5), async { let mut sub = remote.track("wide").unwrap().subscribe(None).await?; @@ -158,7 +169,10 @@ async fn a_later_wide_group_fails_only_that_subscription() { let consumer = client.consume(); consumer.routed(Path::new("bench").unwrap()).await.unwrap(); - let remote = consumer.request_broadcast(Path::new("bench").unwrap(), None).await.unwrap(); + let remote = consumer + .request_broadcast(Path::new("bench").unwrap(), None) + .await + .unwrap(); let mut sub = remote.track("wide").unwrap().subscribe(None).await.unwrap(); let mut group = sub.recv_group().await.unwrap().unwrap(); diff --git a/rs/moq-net/tests/integration/zero_copy.rs b/rs/moq-net/tests/integration/zero_copy.rs index ed5bcc18679..652f63581c2 100644 --- a/rs/moq-net/tests/integration/zero_copy.rs +++ b/rs/moq-net/tests/integration/zero_copy.rs @@ -4,8 +4,8 @@ //! publisher hands the payload to the transport, and the subscriber reads it back, //! without a copy on either side. -use moq_net::Path; use crate::support; +use moq_net::Path; use std::time::Duration; diff --git a/rs/moq-relay/src/auth.rs b/rs/moq-relay/src/auth.rs index 799c4ae3ef5..a0733f0871b 100644 --- a/rs/moq-relay/src/auth.rs +++ b/rs/moq-relay/src/auth.rs @@ -1441,7 +1441,10 @@ mod tests { let mounted = Token::new("/room", &mounted).unwrap(); assert_eq!( mounted.mounts, - [(Path::new(".svc").unwrap().to_owned(), Path::new(".svc/room").unwrap().to_owned())] + [( + Path::new(".svc").unwrap().to_owned(), + Path::new(".svc/room").unwrap().to_owned() + )] ); assert!(wide.covered_by(&wide)); assert!(narrow.covered_by(&wide)); @@ -1487,7 +1490,10 @@ mod tests { // The same alias still names the same root. assert_eq!(token.recheck(&aliased).unwrap().root, token.root); // A grant without the alias is relative to what was dialed, not to the old root. - assert_eq!(token.recheck(&everything()).unwrap().root, Path::new("vanity/room").unwrap().to_owned()); + assert_eq!( + token.recheck(&everything()).unwrap().root, + Path::new("vanity/room").unwrap().to_owned() + ); } } diff --git a/rs/moq-relay/src/auth/admission_tests.rs b/rs/moq-relay/src/auth/admission_tests.rs index d24f5268766..ea2cbec0879 100644 --- a/rs/moq-relay/src/auth/admission_tests.rs +++ b/rs/moq-relay/src/auth/admission_tests.rs @@ -1,8 +1,8 @@ //! Admission and lease behavior for a gateway embedding the relay. -use moq_net::Path; use crate::{auth, cluster}; use moq_auth::{Grant, Pattern, Patterns, Role, Transport, lease}; +use moq_net::Path; fn patterns(texts: &[&str]) -> Patterns { texts.iter().map(|text| text.parse::().unwrap()).collect() diff --git a/rs/moq-relay/src/auth/refresh.rs b/rs/moq-relay/src/auth/refresh.rs index 7a3c55fb7e6..aa71e4f32ec 100644 --- a/rs/moq-relay/src/auth/refresh.rs +++ b/rs/moq-relay/src/auth/refresh.rs @@ -466,8 +466,8 @@ fn with_jwt(query: Option<&str>, token: &str) -> String { #[expect(clippy::disallowed_methods, reason = "tests read the host clock directly")] mod tests { use super::*; - use moq_net::Path; use futures::FutureExt; + use moq_net::Path; use std::time::Duration; fn grant(prefix: &str, seconds: u64) -> Grant { @@ -598,8 +598,12 @@ mod tests { async fn refused_before_setup(change: fn(&mut moq_auth::Grant)) { let (producer, consumer) = lease::Producer::new(grant("a/**", 3000)); let registry = moq_net::stats::Registry::new(Default::default()); - let stats = registry.tier(moq_net::stats::Tier::default()).session(Path::new("room").unwrap()); - let lease = super::super::Lease::new("/room", consumer).unwrap().with_stats(stats.clone()); + let stats = registry + .tier(moq_net::stats::Tier::default()) + .session(Path::new("room").unwrap()); + let lease = super::super::Lease::new("/room", consumer) + .unwrap() + .with_stats(stats.clone()); let (client_transport, server) = transports().await; let now = moq_net::time::Instant::now(); let origin = moq_tokio::origin::spawn(); @@ -702,7 +706,9 @@ mod tests { ] { let (producer, consumer) = lease::Producer::new(grant("a/**", 3000)); let registry = moq_net::stats::Registry::new(Default::default()); - let stats = registry.tier(moq_net::stats::Tier::default()).session(Path::new("room").unwrap()); + let stats = registry + .tier(moq_net::stats::Tier::default()) + .session(Path::new("room").unwrap()); let lease = super::super::Lease::new("/room", consumer).unwrap().with_stats(stats); let (client, supervising) = sessions(lease).await; producer.revoke(reason.clone()); diff --git a/rs/moq-relay/src/cluster.rs b/rs/moq-relay/src/cluster.rs index a5740a6c7c2..868aa8e201a 100644 --- a/rs/moq-relay/src/cluster.rs +++ b/rs/moq-relay/src/cluster.rs @@ -2322,8 +2322,8 @@ impl Default for Redial { #[expect(clippy::disallowed_methods, reason = "tests read the host clock directly")] mod tests { use super::*; - use moq_net::Path; use crate::Config as RelayConfig; + use moq_net::Path; #[tokio::test] async fn request_limits_follow_the_admitted_grant() { @@ -2350,8 +2350,12 @@ mod tests { #[tokio::test] async fn only_a_peer_grant_discovers_hidden_routes() { let cluster = new_cluster(Config::default()).expect("cluster"); - let _hidden = cluster.origin.publish(Path::new(".stats/node").unwrap(), origin::Route::default()); - let _visible = cluster.origin.publish(Path::new("room").unwrap(), origin::Route::default()); + let _hidden = cluster + .origin + .publish(Path::new(".stats/node").unwrap(), origin::Route::default()); + let _visible = cluster + .origin + .publish(Path::new("room").unwrap(), origin::Route::default()); let mut request = moq_auth::Request::new("test", moq_auth::Transport::Quic, "/"); request.tls = Some(moq_auth::Peer { name: "edge0".into(), @@ -2431,7 +2435,9 @@ mod tests { let publisher = cluster.publisher(&token).expect("publish grant"); assert!(publisher.create_broadcast(Path::new(".svc/foo").unwrap()).is_err()); - publisher.create_broadcast(Path::new("cam").unwrap()).expect("publish outside the mount"); + publisher + .create_broadcast(Path::new("cam").unwrap()) + .expect("publish outside the mount"); // A mount the origin refuses admits nothing rather than half a grant. grant.mounts.insert(".svc/x".into(), ".other".into()); @@ -3079,10 +3085,13 @@ mod tests { assert!(pool.used() > 0, "writes charge the constructed cache pool"); let consumer = cluster.origin.consume(); - tokio::time::timeout(Duration::from_secs(2), consumer.request_broadcast(Path::new("cam").unwrap(), None)) - .await - .expect("broadcast resolves") - .expect("broadcast present"); + tokio::time::timeout( + Duration::from_secs(2), + consumer.request_broadcast(Path::new("cam").unwrap(), None), + ) + .await + .expect("broadcast resolves") + .expect("broadcast present"); let stats_path = moq_net::Path::new(".stats/node/test").unwrap(); tokio::time::timeout(Duration::from_secs(5), consumer.routed(&stats_path)) @@ -3483,7 +3492,10 @@ mod tests { let node = new_cluster(Config::default()).expect("node cluster"); let fingerprint = new_cluster(Config::default()).expect("fingerprint cluster"); - let _from_node = node.origin.create_broadcast(Path::new("from-node").unwrap()).expect("create"); + let _from_node = node + .origin + .create_broadcast(Path::new("from-node").unwrap()) + .expect("create"); _from_node.announce(Default::default()).expect("announce"); let mut listen = moq_tokio::listen::Config::default(); @@ -3538,7 +3550,10 @@ mod tests { // The dialer marks what the peer forwards: it entered at `node`, not here. assert_eq!(update.route.source(), origin::Source::Peer(node.origin.hop())); - let _from_fp = fingerprint.origin.create_broadcast(Path::new("from-fingerprint").unwrap()).expect("create"); + let _from_fp = fingerprint + .origin + .create_broadcast(Path::new("from-fingerprint").unwrap()) + .expect("create"); _from_fp.announce(Default::default()).expect("announce"); let mut announced = node.origin.consume().announced(); loop { @@ -3822,7 +3837,10 @@ mod tests { let dialer = new_cluster(Config::default()) .expect("dialer cluster") .with_connect(Default::default(), quic); - let broadcast = dialer.origin.create_broadcast(Path::new("from-dialer").unwrap()).expect("create"); + let broadcast = dialer + .origin + .create_broadcast(Path::new("from-dialer").unwrap()) + .expect("create"); broadcast.announce(Default::default()).expect("announce"); tokio::spawn(dialer.clone().supervise_remote(target, String::new())); (dialer, broadcast) diff --git a/rs/moq-relay/src/internal.rs b/rs/moq-relay/src/internal.rs index 3a8d8f2a2c0..a134e0c97fc 100644 --- a/rs/moq-relay/src/internal.rs +++ b/rs/moq-relay/src/internal.rs @@ -1211,7 +1211,9 @@ mod tests { #[test] fn request_metrics_never_open_a_session() { let stats = moq_net::stats::Registry::new(Default::default()); - let request = stats.tier(moq_net::stats::Tier::new(Path::new("http").unwrap())).request(Path::new("root").unwrap()); + let request = stats + .tier(moq_net::stats::Tier::new(Path::new("http").unwrap())) + .request(Path::new("root").unwrap()); drop(request); let body = render_metrics(&stats.snapshot(), &[], &[]); assert!(body.contains("# TYPE moq_relay_requests_total counter"), "{body}"); @@ -1230,7 +1232,9 @@ mod tests { fn wire_metrics_include_internal_sessions_and_keep_final_totals() { let registry = moq_net::stats::Registry::new(Default::default()); for tier in ["internal", "edge"] { - let session = registry.tier(moq_net::stats::Tier::new(Path::new(tier).unwrap())).session(moq_net::Path::empty()); + let session = registry + .tier(moq_net::stats::Tier::new(Path::new(tier).unwrap())) + .session(moq_net::Path::empty()); let source = moq_net::transport::Wire::new(); let guard = session.wire(source.clone()); source.set_sent_bytes(123); @@ -1255,8 +1259,11 @@ mod tests { #[tokio::test] async fn announce_metrics_keep_retired_totals() { let stats = moq_net::stats::Registry::new(Default::default()); - let producer = - moq_tokio::origin::spawn().with_stats(stats.tier(moq_net::stats::Tier::new(Path::new("edge").unwrap())).session(Path::new("root").unwrap())); + let producer = moq_tokio::origin::spawn().with_stats( + stats + .tier(moq_net::stats::Tier::new(Path::new("edge").unwrap())) + .session(Path::new("root").unwrap()), + ); let broadcast = producer.create_broadcast(Path::new("demo/retired").unwrap()).unwrap(); broadcast.announce(Default::default()).unwrap(); @@ -1309,7 +1316,9 @@ mod tests { // Named-tier ingress: a tagged ingress producer writes, so subscriber // `bytes` advance on the regional tier. - let regional_ctx = stats.tier(Tier::new(Path::new("region/sjc").unwrap())).session(Path::new("peer").unwrap()); + let regional_ctx = stats + .tier(Tier::new(Path::new("region/sjc").unwrap())) + .session(Path::new("peer").unwrap()); let sub_origin = moq_tokio::origin::spawn().with_stats(regional_ctx.clone()); let sub_source = sub_origin.create_broadcast(Path::new("demo/x").unwrap()).unwrap(); sub_source.announce(Default::default()).unwrap(); diff --git a/rs/moq-relay/src/refusals.rs b/rs/moq-relay/src/refusals.rs index 642da660bc0..c0ff149e609 100644 --- a/rs/moq-relay/src/refusals.rs +++ b/rs/moq-relay/src/refusals.rs @@ -45,7 +45,10 @@ impl Refusals { if let auth::Error::Refused(refusal) = err { // The refusal is recorded either way, under the default tier or root if the // server named one with an empty segment. - let tier = refusal.tier.clone().and_then(|tier| moq_net::PathOwned::try_from(tier).ok()); + let tier = refusal + .tier + .clone() + .and_then(|tier| moq_net::PathOwned::try_from(tier).ok()); let root = refusal.root.as_deref().and_then(|root| moq_net::Path::new(root).ok()); self.0 .tier(tier.map(Tier::new).unwrap_or_default()) diff --git a/rs/moq-relay/src/stats.rs b/rs/moq-relay/src/stats.rs index 7597270a85a..1bd3cbfd568 100644 --- a/rs/moq-relay/src/stats.rs +++ b/rs/moq-relay/src/stats.rs @@ -122,7 +122,8 @@ impl Config { if !self.enabled { return Ok(moq_stats::Producer::new(moq_stats::produce::Config::new())); } - let prefix = PathOwned::try_from(self.prefix.clone()).map_err(|err| anyhow::anyhow!("invalid stats.prefix: {err}"))?; + let prefix = + PathOwned::try_from(self.prefix.clone()).map_err(|err| anyhow::anyhow!("invalid stats.prefix: {err}"))?; let interval = self.interval(); anyhow::ensure!(interval != Some(Duration::ZERO), "stats.interval must be non-zero"); let node = self diff --git a/rs/moq-relay/src/web.rs b/rs/moq-relay/src/web.rs index 92bf0b261d6..e1bd588868d 100644 --- a/rs/moq-relay/src/web.rs +++ b/rs/moq-relay/src/web.rs @@ -1101,7 +1101,10 @@ async fn serve_fetch( // NOTE: The auth token is already scoped to the broadcast. // Block until a route covers the broadcast (within the fetch deadline) so // freshly-connected subscribers don't get a spurious 404 before the announce arrives. - let broadcast = origin.routed_broadcast(moq_net::Path::empty()).await.map_err(|_| StatusCode::NOT_FOUND)?; + let broadcast = origin + .routed_broadcast(moq_net::Path::empty()) + .await + .map_err(|_| StatusCode::NOT_FOUND)?; let sequence = match params.group { FetchGroup::Num(sequence) => Some(sequence), FetchGroup::Latest => None, @@ -1373,7 +1376,10 @@ mod tests { }); let mut cluster = cluster::Cluster::new(crate::cluster::Options::default()).unwrap(); cluster.stats = Registry::new(Default::default()); - let broadcast = cluster.origin.create_broadcast(moq_net::Path::new("room").unwrap()).unwrap(); + let broadcast = cluster + .origin + .create_broadcast(moq_net::Path::new("room").unwrap()) + .unwrap(); broadcast.announce(Default::default()).unwrap(); let track = broadcast .create_track( @@ -1475,7 +1481,10 @@ mod tests { .init("test", &moq_tokio::tls::Connect::default(), false) .unwrap(); let cluster = cluster::Cluster::new(crate::cluster::Options::default()).unwrap(); - let broadcast = cluster.origin.create_broadcast(moq_net::Path::new("room").unwrap()).unwrap(); + let broadcast = cluster + .origin + .create_broadcast(moq_net::Path::new("room").unwrap()) + .unwrap(); broadcast.announce(Default::default()).unwrap(); let track = broadcast .create_track( diff --git a/rs/moq-relay/tests/drills.rs b/rs/moq-relay/tests/drills.rs index 6f2690fed27..d58e9964c8f 100644 --- a/rs/moq-relay/tests/drills.rs +++ b/rs/moq-relay/tests/drills.rs @@ -453,7 +453,9 @@ async fn cancel_under_backpressure_releases_the_reader(lane: Lane) { let url = path.url.clone(); let publisher = moq_tokio::origin::spawn(); - let broadcast = publisher.create_broadcast(moq_net::Path::new("live").unwrap()).expect("create broadcast"); + let broadcast = publisher + .create_broadcast(moq_net::Path::new("live").unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("announce broadcast"); let mut track = broadcast.create_track(TRACK, timed()).expect("create track"); let publish_session = tokio::time::timeout( @@ -585,7 +587,9 @@ async fn relay_killed_mid_group_aborts_then_resumes(lane: Lane) { let url = path.url.clone(); let publisher = moq_tokio::origin::spawn(); - let broadcast = publisher.create_broadcast(moq_net::Path::new("live").unwrap()).expect("create broadcast"); + let broadcast = publisher + .create_broadcast(moq_net::Path::new("live").unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("announce broadcast"); let mut track = broadcast.create_track(TRACK, timed()).expect("create track"); let mut publish_loop = client(&url).publish(publisher.consume()).expect("no connect url"); @@ -708,7 +712,9 @@ async fn interrupted_publisher_republishes_new_content(lane: Lane) { let mut announced = subscribed.announced(); let first = moq_tokio::origin::spawn(); - let broadcast = first.create_broadcast(moq_net::Path::new("live").unwrap()).expect("create broadcast"); + let broadcast = first + .create_broadcast(moq_net::Path::new("live").unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("announce broadcast"); let mut track = broadcast.create_track(TRACK, timed()).expect("create track"); let first_session = tokio::time::timeout( @@ -746,7 +752,9 @@ async fn interrupted_publisher_republishes_new_content(lane: Lane) { // Restore: the same name, a new publisher, different content. let second = moq_tokio::origin::spawn(); - let broadcast = second.create_broadcast(moq_net::Path::new("live").unwrap()).expect("re-create broadcast"); + let broadcast = second + .create_broadcast(moq_net::Path::new("live").unwrap()) + .expect("re-create broadcast"); broadcast.announce(Default::default()).expect("announce broadcast"); let mut track = broadcast.create_track(TRACK, timed()).expect("re-create track"); let second_session = tokio::time::timeout( @@ -1026,7 +1034,9 @@ async fn cross_cluster(lane: Lane, link: PeerLink) { let subscribe_path = Path::shaped(lane, &edge, bursty(), seed.wrapping_add(2)).await; let publisher = moq_tokio::origin::spawn(); - let broadcast = publisher.create_broadcast(moq_net::Path::new("live").unwrap()).expect("create broadcast"); + let broadcast = publisher + .create_broadcast(moq_net::Path::new("live").unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("announce broadcast"); let mut track = broadcast.create_track(TRACK, timed()).expect("create track"); let url = publish_path.url.clone(); diff --git a/rs/moq-relay/tests/integration/auth_lifetime.rs b/rs/moq-relay/tests/integration/auth_lifetime.rs index 3b638127809..daafc96ec08 100644 --- a/rs/moq-relay/tests/integration/auth_lifetime.rs +++ b/rs/moq-relay/tests/integration/auth_lifetime.rs @@ -250,7 +250,9 @@ fn room_url(scheme: &str, port: u16) -> url::Url { /// round-trips. Returns both sessions so the caller can watch them close. async fn connect_and_round_trip(url: &url::Url) -> (moq_tokio::Connection, moq_tokio::Connection) { let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); + let broadcast = pub_origin + .create_broadcast(Path::new("test").unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let track = broadcast.create_track("video", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); @@ -547,7 +549,9 @@ async fn a_moved_tier_retags_the_live_session() { // A publisher whose track stays open across the move, and a subscriber to it. let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); + let broadcast = pub_origin + .create_broadcast(Path::new("test").unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("announce broadcast"); let track = broadcast.create_track("video", timed()).expect("create track"); let pub_session = tokio::time::timeout( @@ -692,7 +696,9 @@ async fn a_rechecked_grant_resizes_live_sessions() { let pub_origin = moq_tokio::origin::spawn(); let mut tracks = Vec::new(); for path in ["alice/audio", "alice/video"] { - let broadcast = pub_origin.create_broadcast(Path::new(path).unwrap()).expect("create broadcast"); + let broadcast = pub_origin + .create_broadcast(Path::new(path).unwrap()) + .expect("create broadcast"); let track = broadcast.create_track("media", timed()).expect("create track"); broadcast.announce(Default::default()).expect("announce broadcast"); tracks.push((broadcast, track)); @@ -788,10 +794,13 @@ async fn a_rechecked_grant_resizes_live_sessions() { // Undeafen: the path is announced again and a new subscription flows. script.on_revalidate(Answer::Grant(grant(Duration::from_secs(3600)))); - let broadcast = tokio::time::timeout(TIMEOUT, sub_consumer.routed_broadcast(Path::new("alice/audio").unwrap())) - .await - .expect("the undeafened path was never announced again") - .expect("announced broadcast resolves"); + let broadcast = tokio::time::timeout( + TIMEOUT, + sub_consumer.routed_broadcast(Path::new("alice/audio").unwrap()), + ) + .await + .expect("the undeafened path was never announced again") + .expect("announced broadcast resolves"); let mut audio = broadcast .track("media") .unwrap() @@ -882,7 +891,9 @@ async fn http_routes_hold_a_lease() { // A publisher whose group stays open, so a fetch of it keeps streaming. let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); + let broadcast = pub_origin + .create_broadcast(Path::new("test").unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("announce"); let track = broadcast.create_track("video", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); diff --git a/rs/moq-relay/tests/integration/cluster_drain.rs b/rs/moq-relay/tests/integration/cluster_drain.rs index abb8cede5c0..cf7d5471257 100644 --- a/rs/moq-relay/tests/integration/cluster_drain.rs +++ b/rs/moq-relay/tests/integration/cluster_drain.rs @@ -113,7 +113,11 @@ async fn relay(name: &str) -> (Relay, SocketAddr, moq_net::broadcast::Producer) config.drain_timeout = Some(DRAIN.into()); let relay = Relay::load(config).await.expect("load relay").with_signals(false); let addr = relay.tcp_addr().expect("tcp listener"); - let broadcast = relay.cluster().origin.create_broadcast(Path::new(name).unwrap()).expect("create broadcast"); + let broadcast = relay + .cluster() + .origin + .create_broadcast(Path::new(name).unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("announce"); (relay, addr, broadcast) } @@ -125,7 +129,10 @@ async fn peer(name: &str, forwarder: &Forwarder) -> (cluster::Cluster, moq_net:: let cluster = cluster::Cluster::new(cluster::Options::new(config)) .expect("cluster init") .with_connect(Default::default(), Default::default()); - let broadcast = cluster.origin.create_broadcast(Path::new(name).unwrap()).expect("create broadcast"); + let broadcast = cluster + .origin + .create_broadcast(Path::new(name).unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("announce"); let started = cluster.clone().start().await.expect("cluster start"); tokio::spawn(started.run()); diff --git a/rs/moq-relay/tests/integration/cluster_idle.rs b/rs/moq-relay/tests/integration/cluster_idle.rs index 2bda16b8c39..1cf97bfee2c 100644 --- a/rs/moq-relay/tests/integration/cluster_idle.rs +++ b/rs/moq-relay/tests/integration/cluster_idle.rs @@ -52,7 +52,9 @@ async fn spawn_peer() -> (u16, tokio::runtime::Runtime) { let (bound, port) = tokio::sync::oneshot::channel(); runtime.spawn(async move { let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast(Path::new("peer").unwrap()).expect("create broadcast"); + let broadcast = origin + .create_broadcast(Path::new("peer").unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("announce"); let mut config = moq_tokio::listen::Config::default(); diff --git a/rs/moq-relay/tests/integration/cluster_unknown.rs b/rs/moq-relay/tests/integration/cluster_unknown.rs index 1bbfd778edd..9a9fe5e6293 100644 --- a/rs/moq-relay/tests/integration/cluster_unknown.rs +++ b/rs/moq-relay/tests/integration/cluster_unknown.rs @@ -148,7 +148,9 @@ impl Drop for Publisher { async fn publish_version(port: u16, version: &str) -> Publisher { let url: Url = format!("tcp://127.0.0.1:{port}").parse().expect("parse url"); let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast(Path::new(PATH).unwrap()).expect("create broadcast"); + let broadcast = origin + .create_broadcast(Path::new(PATH).unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let track = broadcast.create_track("video", timed()).expect("create track"); diff --git a/rs/moq-relay/tests/integration/connection.rs b/rs/moq-relay/tests/integration/connection.rs index 6e204dccd7f..d7412772102 100644 --- a/rs/moq-relay/tests/integration/connection.rs +++ b/rs/moq-relay/tests/integration/connection.rs @@ -45,7 +45,11 @@ async fn largest_quic_sequence_reaches_the_subscriber() { .await .unwrap() .unwrap(); - let remote = subscriber.consume().request_broadcast(Path::new("ladder").unwrap(), None).await.unwrap(); + let remote = subscriber + .consume() + .request_broadcast(Path::new("ladder").unwrap(), None) + .await + .unwrap(); let mut sub = remote.track("data").unwrap().subscribe(None).await.unwrap(); for sequence in [5, 1 << 32, (1 << 53) - 1, (1 << 53) + 1, (1 << 62) - 1] { // Timestamps stop at 2^61 - 1, the most lite-05/06 can zigzag as a first frame. @@ -77,7 +81,9 @@ fn publish( moq_net::track::Producer, ) { let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast(Path::new(name).unwrap()).expect("create broadcast"); + let broadcast = origin + .create_broadcast(Path::new(name).unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("announce"); let info = moq_net::track::Info::default().with_timescale(moq_net::Timescale::MILLI); let track = broadcast.create_track("video", info).expect("create track"); diff --git a/rs/moq-relay/tests/integration/embed.rs b/rs/moq-relay/tests/integration/embed.rs index 3ca5880f48b..67eb9c2b09b 100644 --- a/rs/moq-relay/tests/integration/embed.rs +++ b/rs/moq-relay/tests/integration/embed.rs @@ -263,7 +263,9 @@ async fn embed_and_stop(mut config: Config) { "authorization" ); - let broadcast = origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); + let broadcast = origin + .create_broadcast(Path::new("test").unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("announce"); let track = broadcast.create_track("video", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); diff --git a/rs/moq-relay/tests/integration/goaway_cluster.rs b/rs/moq-relay/tests/integration/goaway_cluster.rs index 75045d705e2..25620c2fc0e 100644 --- a/rs/moq-relay/tests/integration/goaway_cluster.rs +++ b/rs/moq-relay/tests/integration/goaway_cluster.rs @@ -150,7 +150,9 @@ async fn cluster_continues_a_group_split_by_goaway_inner() { let _ = rustls::crypto::aws_lc_rs::default_provider().install_default(); let upstream_origin = moq_tokio::origin::spawn(); - let broadcast = upstream_origin.create_broadcast(Path::new("cam").unwrap()).expect("create broadcast"); + let broadcast = upstream_origin + .create_broadcast(Path::new("cam").unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("announce"); let track = broadcast.create_track("video", timed()).expect("create track"); @@ -172,7 +174,9 @@ async fn cluster_continues_a_group_split_by_goaway_inner() { let session_a = within("A accepts", accepted_a.recv()).await.expect("A accepts"); let consumer = cluster.origin.consume(); - within("routed via A", consumer.routed(Path::new("cam").unwrap())).await.expect("routed"); + within("routed via A", consumer.routed(Path::new("cam").unwrap())) + .await + .expect("routed"); let bc = consumer .request_broadcast(Path::new("cam").unwrap(), None) .await @@ -288,7 +292,9 @@ async fn cluster_migrates_on_upstream_goaway_inner() { tokio::time::timeout(TEST_TIMEOUT, async { // ── the shared "live" broadcast both siblings can serve ───────── let upstream_origin = moq_tokio::origin::spawn(); - let broadcast = upstream_origin.create_broadcast(Path::new("cam").unwrap()).expect("create broadcast"); + let broadcast = upstream_origin + .create_broadcast(Path::new("cam").unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let track = broadcast.create_track("video", timed()).expect("create track"); @@ -484,7 +490,9 @@ async fn cluster_diamond_goaway_seamless_failover_inner() { // ── TOP: origin server serving the same broadcast to both mids ────── let top_origin = moq_tokio::origin::spawn(); - let broadcast = top_origin.create_broadcast(Path::new("diamond").unwrap()).expect("create broadcast"); + let broadcast = top_origin + .create_broadcast(Path::new("diamond").unwrap()) + .expect("create broadcast"); broadcast .announce(moq_net::origin::Route::default().with_epoch(moq_net::Epoch::mint())) .expect("create broadcast"); @@ -565,7 +573,10 @@ async fn cluster_diamond_goaway_seamless_failover_inner() { let bc = within("broadcast resolves on the subscriber origin", async { let consumer = sub_origin.consume(); consumer.routed(Path::new("diamond").unwrap()).await?; - consumer.request_broadcast(Path::new("diamond").unwrap(), None).await.ok() + consumer + .request_broadcast(Path::new("diamond").unwrap(), None) + .await + .ok() }) .await .expect("broadcast announced"); diff --git a/rs/moq-relay/tests/integration/hidden_cluster.rs b/rs/moq-relay/tests/integration/hidden_cluster.rs index d525b12a67f..6fac566e56a 100644 --- a/rs/moq-relay/tests/integration/hidden_cluster.rs +++ b/rs/moq-relay/tests/integration/hidden_cluster.rs @@ -69,7 +69,10 @@ async fn old_peer_keeps_hidden_paths(version: moq_net::Version) { let cluster = cluster::Cluster::new(cluster::Options::new(cluster_config)) .expect("cluster init") .with_connect(client_config, Default::default()); - let node = cluster.origin.create_broadcast(Path::new(".hidden/test").unwrap()).expect("create hidden"); + let node = cluster + .origin + .create_broadcast(Path::new(".hidden/test").unwrap()) + .expect("create hidden"); node.announce(Default::default()).expect("announce hidden"); let cluster_run = tokio::spawn(cluster.clone().start().await.expect("cluster start").run()); diff --git a/rs/moq-relay/tests/integration/public_rules.rs b/rs/moq-relay/tests/integration/public_rules.rs index 58abf10ef19..d6ecf3212d8 100644 --- a/rs/moq-relay/tests/integration/public_rules.rs +++ b/rs/moq-relay/tests/integration/public_rules.rs @@ -68,7 +68,9 @@ fn url(port: u16, path: &str) -> url::Url { /// handles alive for as long as the broadcast should stay announced. async fn publish(url: url::Url, name: &str) -> Box { let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast(Path::new(name).unwrap()).expect("create broadcast"); + let broadcast = origin + .create_broadcast(Path::new(name).unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("announce"); let track = broadcast.create_track("video", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); diff --git a/rs/moq-relay/tests/integration/refusals.rs b/rs/moq-relay/tests/integration/refusals.rs index 77aadf9fc29..668de56db9d 100644 --- a/rs/moq-relay/tests/integration/refusals.rs +++ b/rs/moq-relay/tests/integration/refusals.rs @@ -249,10 +249,15 @@ async fn refused_only_stats_depth_one_has_root_totals_and_shared_embedder_metric .await .unwrap() .unwrap(); - let broadcast = tokio::time::timeout(TIMEOUT, relay.origin.request_broadcast(Path::new(".stats/node/test").unwrap(), None)) - .await - .unwrap() - .unwrap(); + let broadcast = tokio::time::timeout( + TIMEOUT, + relay + .origin + .request_broadcast(Path::new(".stats/node/test").unwrap(), None), + ) + .await + .unwrap() + .unwrap(); let consumer = moq_stats::Consumer::new(broadcast, Default::default()); let mut totals = consumer.totals().await.unwrap(); tokio::time::timeout(TIMEOUT, async { @@ -277,14 +282,22 @@ async fn refused_only_stats_depth_one_has_root_totals_and_shared_embedder_metric 1, "embedder stats and metrics share the counter" ); - tokio::time::timeout(TIMEOUT, relay.origin.routed(Path::new(".stats/tenant/node/test").unwrap())) - .await - .unwrap() - .unwrap(); - let broadcast = tokio::time::timeout(TIMEOUT, relay.origin.request_broadcast(Path::new(".stats/tenant/node/test").unwrap(), None)) - .await - .unwrap() - .unwrap(); + tokio::time::timeout( + TIMEOUT, + relay.origin.routed(Path::new(".stats/tenant/node/test").unwrap()), + ) + .await + .unwrap() + .unwrap(); + let broadcast = tokio::time::timeout( + TIMEOUT, + relay + .origin + .request_broadcast(Path::new(".stats/tenant/node/test").unwrap(), None), + ) + .await + .unwrap() + .unwrap(); let consumer = moq_stats::Consumer::new(broadcast, Default::default()); let mut totals = consumer.totals().await.unwrap(); tokio::time::timeout(TIMEOUT, async { @@ -316,7 +329,11 @@ async fn peer_zero_close_is_clean_and_application_close_counts_once() { .await .unwrap() .unwrap(); - let broadcast = relay.origin.request_broadcast(Path::new(".stats/node/test").unwrap(), None).await.unwrap(); + let broadcast = relay + .origin + .request_broadcast(Path::new(".stats/node/test").unwrap(), None) + .await + .unwrap(); let consumer = moq_stats::Consumer::new(broadcast, Default::default()); let mut totals = consumer.totals().await.unwrap(); for (index, error) in [moq_net::Error::Cancel, moq_net::Error::App(42)] diff --git a/rs/moq-relay/tests/integration/runtime_uring.rs b/rs/moq-relay/tests/integration/runtime_uring.rs index e0fd2684e5e..a16b9f1a16e 100644 --- a/rs/moq-relay/tests/integration/runtime_uring.rs +++ b/rs/moq-relay/tests/integration/runtime_uring.rs @@ -134,7 +134,9 @@ async fn uring_workers_serve_webtransport_and_raw_quic() { let raw_url: url::Url = format!("moql://127.0.0.1:{port}/uring").parse().expect("parse url"); let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); + let broadcast = origin + .create_broadcast(Path::new("test").unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let track = broadcast.create_track("video", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); @@ -234,7 +236,9 @@ async fn uring_workers_serve_every_configured_version() { let running = tokio::spawn(relay.run()); let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); + let broadcast = origin + .create_broadcast(Path::new("test").unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("announce broadcast"); let track = broadcast.create_track("video", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); @@ -604,7 +608,9 @@ async fn an_mtls_client_authenticates_without_a_token() { // connecting proves nothing. let url: url::Url = format!("moql://127.0.0.1:{port}/mtls").parse().expect("parse url"); let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); + let broadcast = origin + .create_broadcast(Path::new("test").unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let track = broadcast.create_track("video", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); @@ -683,7 +689,9 @@ async fn uring_workers_write_qlog_traces() { // rather than a connection that only ever exchanged Initials. let url: url::Url = format!("moql://127.0.0.1:{port}/qlog").parse().expect("parse url"); let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); + let broadcast = origin + .create_broadcast(Path::new("test").unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let track = broadcast.create_track("video", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); diff --git a/rs/moq-relay/tests/integration/runtime_workers.rs b/rs/moq-relay/tests/integration/runtime_workers.rs index 0899f9778e9..6ccc10f889d 100644 --- a/rs/moq-relay/tests/integration/runtime_workers.rs +++ b/rs/moq-relay/tests/integration/runtime_workers.rs @@ -90,7 +90,9 @@ async fn workers_serve_quic_and_share_one_origin() { // ── publisher ─────────────────────────────────────────────────── let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); + let broadcast = origin + .create_broadcast(Path::new("test").unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let track = broadcast.create_track("video", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); diff --git a/rs/moq-relay/tests/integration/shutdown_signal.rs b/rs/moq-relay/tests/integration/shutdown_signal.rs index c195e349c7a..6d75653518c 100644 --- a/rs/moq-relay/tests/integration/shutdown_signal.rs +++ b/rs/moq-relay/tests/integration/shutdown_signal.rs @@ -420,7 +420,9 @@ async fn a_reconnecting_client_rides_out_a_restart_inner() { let url: url::Url = format!("tcp://{addr}/").parse().expect("parse url"); let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast(Path::new("cam").unwrap()).expect("create broadcast"); + let broadcast = origin + .create_broadcast(Path::new("cam").unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("announce"); let mut publisher = moq_tokio::connect::Config::default(); // Redials paced well inside the drain, under a window that ends long before it. diff --git a/rs/moq-relay/tests/integration/smoke.rs b/rs/moq-relay/tests/integration/smoke.rs index 561825659f2..b4c5758a0e9 100644 --- a/rs/moq-relay/tests/integration/smoke.rs +++ b/rs/moq-relay/tests/integration/smoke.rs @@ -146,7 +146,9 @@ async fn relay_websocket_round_trip_uses_newest_version() { // ── publisher ─────────────────────────────────────────────────── let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); + let broadcast = pub_origin + .create_broadcast(Path::new("test").unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let track = broadcast.create_track("video", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); @@ -285,7 +287,9 @@ async fn hidden_broadcasts_need_a_lite07_opt_in() { let url: url::Url = format!("ws://127.0.0.1:{port}/hidden").parse().expect("parse url"); let pub_origin = moq_tokio::origin::spawn(); - let hidden = pub_origin.create_broadcast(Path::new(".x/y").unwrap()).expect("create hidden"); + let hidden = pub_origin + .create_broadcast(Path::new(".x/y").unwrap()) + .expect("create hidden"); hidden.announce(Default::default()).expect("announce hidden"); let track = hidden.create_track("video", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); @@ -317,7 +321,9 @@ async fn hidden_broadcasts_need_a_lite07_opt_in() { // Announced after the hidden one, so any client that could see both lists the // hidden one first (the relay drains its table in path order). - let visible = pub_origin.create_broadcast(Path::new("visible").unwrap()).expect("create visible"); + let visible = pub_origin + .create_broadcast(Path::new("visible").unwrap()) + .expect("create visible"); visible.announce(Default::default()).expect("announce visible"); assert_eq!(announced_until(&mut opted, "visible").await, ["visible"]); @@ -486,7 +492,9 @@ async fn relay_websocket_root_path_upgrades() { // ── publisher ─────────────────────────────────────────────────── let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); + let broadcast = pub_origin + .create_broadcast(Path::new("test").unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let track = broadcast.create_track("video", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); @@ -619,7 +627,9 @@ async fn internal_tcp_round_trip() { // ── publisher ─────────────────────────────────────────────────── let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); + let broadcast = pub_origin + .create_broadcast(Path::new("test").unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let track = broadcast.create_track("video", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); @@ -722,7 +732,9 @@ async fn internal_unix_round_trip() { // ── publisher ─────────────────────────────────────────────────── let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); + let broadcast = pub_origin + .create_broadcast(Path::new("test").unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let track = broadcast.create_track("video", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); @@ -761,10 +773,13 @@ async fn internal_unix_round_trip() { .expect("origin closed"); assert_eq!(update.prefix.as_str(), "test"); assert!(active, "expected announce, got retraction"); - let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast(Path::new("test").unwrap(), None)) - .await - .expect("request timeout") - .expect("announced broadcast resolves"); + let bc = tokio::time::timeout( + TIMEOUT, + sub_consumer.request_broadcast(Path::new("test").unwrap(), None), + ) + .await + .expect("request timeout") + .expect("announced broadcast resolves"); let mut track_sub = tokio::time::timeout(TIMEOUT, async { bc.track("video").unwrap().subscribe(None).await }) .await @@ -814,7 +829,9 @@ fn path_versions() -> Vec { /// to that root). async fn path_round_trip(version: moq_net::Version, pub_url: url::Url, sub_url: url::Url, broadcast: &str) -> String { let pub_origin = moq_tokio::origin::spawn(); - let bc = pub_origin.create_broadcast(Path::new(broadcast).unwrap()).expect("create broadcast"); + let bc = pub_origin + .create_broadcast(Path::new(broadcast).unwrap()) + .expect("create broadcast"); bc.announce(Default::default()).expect("create broadcast"); let track = bc.create_track("video", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); diff --git a/rs/moq-relay/tests/integration/upstream_links.rs b/rs/moq-relay/tests/integration/upstream_links.rs index 708ffee9c61..fc6a3ad8340 100644 --- a/rs/moq-relay/tests/integration/upstream_links.rs +++ b/rs/moq-relay/tests/integration/upstream_links.rs @@ -152,7 +152,9 @@ impl Drop for Publisher { } fn publish(origin: &origin::Producer, path: &str) -> Publisher { - let broadcast = origin.publish(Path::new(path).unwrap(), Default::default()).expect("publish"); + let broadcast = origin + .publish(Path::new(path).unwrap(), Default::default()) + .expect("publish"); let track = broadcast.create_track("video", timed()).expect("create track"); let writer = tokio::spawn(async move { loop { @@ -173,9 +175,12 @@ fn publish(origin: &origin::Producer, path: &str) -> Publisher { /// Subscribe to `path` through `origin`'s routes and read one frame. async fn read_frame(origin: &origin::Producer, path: &str) { let consumer = origin.consume(); - let broadcast = within(&format!("route to {path}"), consumer.routed_broadcast(Path::new(path).unwrap())) - .await - .unwrap_or_else(|err| panic!("{path} unroutable: {err}")); + let broadcast = within( + &format!("route to {path}"), + consumer.routed_broadcast(Path::new(path).unwrap()), + ) + .await + .unwrap_or_else(|err| panic!("{path} unroutable: {err}")); let subscription = moq_net::track::Subscription::default().with_max_delay(Duration::from_secs(1)); let mut track = within( &format!("subscribe to {path}"), diff --git a/rs/moq-room/src/chat.rs b/rs/moq-room/src/chat.rs index 3189803790d..24ba131d7ee 100644 --- a/rs/moq-room/src/chat.rs +++ b/rs/moq-room/src/chat.rs @@ -296,7 +296,10 @@ mod tests { let _link = link(&publisher, &relay).await; let consumer = relay.consume(); consumer.routed(Path::new("room").unwrap()).await.unwrap(); - let remote = consumer.request_broadcast(Path::new("room").unwrap(), None).await.unwrap(); + let remote = consumer + .request_broadcast(Path::new("room").unwrap(), None) + .await + .unwrap(); // A first reader warms the relay's copy with the first window. { diff --git a/rs/moq-rtc/src/client/mod.rs b/rs/moq-rtc/src/client/mod.rs index f448f69f06d..793c849b122 100644 --- a/rs/moq-rtc/src/client/mod.rs +++ b/rs/moq-rtc/src/client/mod.rs @@ -103,7 +103,9 @@ mod tests { drop(listener); let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); + let broadcast = origin + .create_broadcast(Path::new("test").unwrap()) + .expect("create broadcast"); let url = format!("http://user:pass@{address}/whep/test?jwt=secret") .parse() .expect("WHEP URL"); diff --git a/rs/moq-rtc/src/egress.rs b/rs/moq-rtc/src/egress.rs index 05694e23f29..a5d1c00ed79 100644 --- a/rs/moq-rtc/src/egress.rs +++ b/rs/moq-rtc/src/egress.rs @@ -623,7 +623,10 @@ mod tests { #[test] fn catalog_codecs_ignores_codecs_available_only_via_escaping_references() { let origin = produce_origin(); - let source = moq_mux::Source::new(origin.consume(), origin.create_broadcast(Path::new("a/pub").unwrap()).unwrap().consume()); + let source = moq_mux::Source::new( + origin.consume(), + origin.create_broadcast(Path::new("a/pub").unwrap()).unwrap().consume(), + ); let mut catalog = Catalog::default(); let mut escaped_audio = AudioConfig::new(AudioCodec::Opus, 48_000, 2); @@ -658,7 +661,10 @@ mod tests { #[test] fn picks_the_best_video_rendition_whatever_its_name() { let origin = produce_origin(); - let source = moq_mux::Source::new(origin.consume(), origin.create_broadcast(Path::new("a/pub").unwrap()).unwrap().consume()); + let source = moq_mux::Source::new( + origin.consume(), + origin.create_broadcast(Path::new("a/pub").unwrap()).unwrap().consume(), + ); let mut catalog = Catalog::default(); let rendition = |height: u32| { @@ -698,7 +704,10 @@ mod tests { #[test] fn picks_the_preferred_codec_whatever_the_peer_offers_first() { let origin = produce_origin(); - let source = moq_mux::Source::new(origin.consume(), origin.create_broadcast(Path::new("a/pub").unwrap()).unwrap().consume()); + let source = moq_mux::Source::new( + origin.consume(), + origin.create_broadcast(Path::new("a/pub").unwrap()).unwrap().consume(), + ); let mut catalog = Catalog::default(); // An H.265 source beside its own H.264 compatibility transcode, which has the higher bitrate. @@ -748,7 +757,10 @@ mod tests { #[test] fn picks_the_best_opus_rendition_whatever_its_name() { let origin = produce_origin(); - let source = moq_mux::Source::new(origin.consume(), origin.create_broadcast(Path::new("a/pub").unwrap()).unwrap().consume()); + let source = moq_mux::Source::new( + origin.consume(), + origin.create_broadcast(Path::new("a/pub").unwrap()).unwrap().consume(), + ); let mut catalog = Catalog::default(); let opus = |bitrate: Option| { @@ -928,7 +940,11 @@ mod tests { }; point(&mut catalog, "a", None); - let broadcast = origin.consume().request_broadcast(Path::new("live").unwrap(), None).await.unwrap(); + let broadcast = origin + .consume() + .request_broadcast(Path::new("live").unwrap(), None) + .await + .unwrap(); let mut egress = EgressSource::new(moq_mux::Source::new(origin.consume(), broadcast)) .await .unwrap(); diff --git a/rs/moq-rtc/src/lib.rs b/rs/moq-rtc/src/lib.rs index 0bee36778b7..0b3666891d5 100644 --- a/rs/moq-rtc/src/lib.rs +++ b/rs/moq-rtc/src/lib.rs @@ -154,7 +154,9 @@ mod tests { origin: &moq_net::origin::Producer, epoch: moq_net::Epoch, ) -> (Box, moq_mux::catalog::Producer) { - let mut broadcast = origin.create_broadcast(Path::new("source").unwrap()).expect("create source broadcast"); + let mut broadcast = origin + .create_broadcast(Path::new("source").unwrap()) + .expect("create source broadcast"); broadcast .announce(moq_net::origin::Route::default().with_epoch(epoch)) .expect("announce source broadcast"); @@ -168,7 +170,8 @@ mod tests { /// Publish a replacement instance of `source`, returning once the origin serves it. async fn take_over(origin: &moq_net::origin::Producer) -> (Box, moq_mux::catalog::Producer) { let epoch = moq_net::Epoch::mint(); - let mut instances = moq_mux::follow::Instances::new(&origin.consume(), Path::new("source").unwrap(), Some(&epoch)).unwrap(); + let mut instances = + moq_mux::follow::Instances::new(&origin.consume(), Path::new("source").unwrap(), Some(&epoch)).unwrap(); let (mut new, catalog) = publish_opus(origin, epoch); push(&mut *new, 20_000, NEW_PACKET); let started = tokio::time::timeout(TIMEOUT, instances.next()) @@ -205,7 +208,9 @@ mod tests { let origin = whep_origin.clone(); let sessions = sessions_tx.clone(); async move { - let response = server::whep::accept(&server, &origin, Path::new("source").unwrap(), &offer).await.unwrap(); + let response = server::whep::accept(&server, &origin, Path::new("source").unwrap(), &offer) + .await + .unwrap(); let answer = response.answer.clone(); sessions.send(tokio::spawn(response.run())).await.unwrap(); answer @@ -284,7 +289,10 @@ mod tests { .await .expect("WHIP negotiation timed out") .expect("the ingest origin closed"); - let ingested = ingested.request_broadcast(Path::new("ingested").unwrap(), None).await.unwrap(); + let ingested = ingested + .request_broadcast(Path::new("ingested").unwrap(), None) + .await + .unwrap(); let mut played = opus_output(&ingested).await; assert_eq!(next_payload(&mut played).await, OPUS_PACKET); @@ -391,7 +399,11 @@ mod tests { // Each client call resolves once its session ends, so the test drives them aside. let whip_client = tokio::spawn({ let client = client.clone(); - async move { client.publish(whip, source_consumer, Path::new("source").unwrap()).await } + async move { + client + .publish(whip, source_consumer, Path::new("source").unwrap()) + .await + } }); let (whip_id, whip_task) = tokio::time::timeout(TIMEOUT, sources_rx.recv()) .await diff --git a/rs/moq-rtc/src/server/whep.rs b/rs/moq-rtc/src/server/whep.rs index c1d4097df64..a371f7bbf8b 100644 --- a/rs/moq-rtc/src/server/whep.rs +++ b/rs/moq-rtc/src/server/whep.rs @@ -284,7 +284,9 @@ mod tests { async fn a_broadcast_resolves_through_a_lazy_client_session() { let pub_origin = moq_tokio::origin::spawn(); - let mut source = pub_origin.create_broadcast(Path::new("cam").unwrap()).expect("create broadcast"); + let mut source = pub_origin + .create_broadcast(Path::new("cam").unwrap()) + .expect("create broadcast"); source .announce(moq_net::origin::Route::default()) .expect("announce broadcast"); @@ -313,14 +315,19 @@ mod tests { #[tokio::test] async fn offers_ride_the_routers_scope_watch() { let pub_origin = moq_tokio::origin::spawn(); - let other = pub_origin.create_broadcast(Path::new("other").unwrap()).expect("create broadcast"); + let other = pub_origin + .create_broadcast(Path::new("other").unwrap()) + .expect("create broadcast"); other .announce(moq_net::origin::Route::default()) .expect("announce broadcast"); let (sub_origin, _connection, accept) = lazy_client(pub_origin).await; let _router = super::router(crate::server::Server::new(Default::default()), sub_origin.consume()); - let missing = sub_origin.consume().follow(Path::new("missing").unwrap()).expect("follow"); + let missing = sub_origin + .consume() + .follow(Path::new("missing").unwrap()) + .expect("follow"); moq_clock::timeout(TIMEOUT, missing.synced()) .await .expect("sync timed out"); diff --git a/rs/moq-rtc/src/server/whip.rs b/rs/moq-rtc/src/server/whip.rs index 20a7fc1a365..42271e16eeb 100644 --- a/rs/moq-rtc/src/server/whip.rs +++ b/rs/moq-rtc/src/server/whip.rs @@ -222,8 +222,13 @@ mod tests { let server = Server::new(crate::server::Config::default()); let origin = moq_tokio::origin::spawn(); let consumer = origin.consume(); - let session = accept(&server, &origin, moq_net::Path::new("live/cam0").unwrap(), &offer()).await.unwrap(); - let broadcast = consumer.request_broadcast(moq_net::Path::new("live/cam0").unwrap(), None).await.unwrap(); + let session = accept(&server, &origin, moq_net::Path::new("live/cam0").unwrap(), &offer()) + .await + .unwrap(); + let broadcast = consumer + .request_broadcast(moq_net::Path::new("live/cam0").unwrap(), None) + .await + .unwrap(); let mut catalog = broadcast .track(hang::Catalog::DEFAULT_NAME) .unwrap() @@ -251,8 +256,13 @@ mod tests { let server = Server::new(crate::server::Config::default()); let origin = moq_tokio::origin::spawn(); let consumer = origin.consume(); - let _stale_session = accept(&server, &origin, moq_net::Path::new("live/cam0").unwrap(), &offer()).await.unwrap(); - let stale = consumer.request_broadcast(moq_net::Path::new("live/cam0").unwrap(), None).await.unwrap(); + let _stale_session = accept(&server, &origin, moq_net::Path::new("live/cam0").unwrap(), &offer()) + .await + .unwrap(); + let stale = consumer + .request_broadcast(moq_net::Path::new("live/cam0").unwrap(), None) + .await + .unwrap(); let mut catalog = stale .track(hang::Catalog::DEFAULT_NAME) .unwrap() @@ -260,7 +270,9 @@ mod tests { .await .unwrap(); - let _fresh_session = accept(&server, &origin, moq_net::Path::new("live/cam0").unwrap(), &offer()).await.unwrap(); + let _fresh_session = accept(&server, &origin, moq_net::Path::new("live/cam0").unwrap(), &offer()) + .await + .unwrap(); // The session binds a real UDP socket, so this runs on the wall clock. let stale_viewer = tokio::time::timeout(std::time::Duration::from_millis(200), async { loop { @@ -272,7 +284,10 @@ mod tests { }) .await; assert!(stale_viewer.is_err(), "the stale viewer ended: {stale_viewer:?}"); - let fresh = consumer.request_broadcast(moq_net::Path::new("live/cam0").unwrap(), None).await.unwrap(); + let fresh = consumer + .request_broadcast(moq_net::Path::new("live/cam0").unwrap(), None) + .await + .unwrap(); assert!(!fresh.is_clone(&stale), "viewers reach the reconnected session"); } } diff --git a/rs/moq-rtmp/src/dial.rs b/rs/moq-rtmp/src/dial.rs index 66ae0d84202..4eaaaccb84e 100644 --- a/rs/moq-rtmp/src/dial.rs +++ b/rs/moq-rtmp/src/dial.rs @@ -569,7 +569,10 @@ impl Publisher { fn new(origin: &origin::Producer, path: &str, config: moq_mux::catalog::Config) -> anyhow::Result { let epoch = moq_net::Epoch::mint(); let mut broadcast = origin - .publish(&moq_net::Path::new(path)?, moq_net::origin::Route::default().with_epoch(epoch.clone())) + .publish( + &moq_net::Path::new(path)?, + moq_net::origin::Route::default().with_epoch(epoch.clone()), + ) .map_err(|err| anyhow::anyhow!("broadcast '{path}' could not be published: {err}"))?; let catalog = moq_mux::catalog::Producer::new(&mut broadcast, config)?; let handle = broadcast.clone(); @@ -726,9 +729,11 @@ mod tests { let ingest = downstream.clone(); let server = tokio::spawn(async move { match accept_stream(server_io, peer).await.unwrap().unwrap() { - Request::Publish(publish) => { - publish.with_linger(linger).accept(&ingest, Path::new("live/cam0").unwrap()).await.unwrap() - } + Request::Publish(publish) => publish + .with_linger(linger) + .accept(&ingest, Path::new("live/cam0").unwrap()) + .await + .unwrap(), Request::Play(play) => play.accept(&served, Path::new("live/cam0").unwrap()).await.unwrap(), } }); @@ -736,7 +741,10 @@ mod tests { let client = tokio::spawn(async move { let client = Client::with_stream(client_io, "live").await.unwrap(); match push { - true => client.publish("cam0", exported, Path::new("live/cam0").unwrap()).await.unwrap(), + true => client + .publish("cam0", exported, Path::new("live/cam0").unwrap()) + .await + .unwrap(), false => client .with_linger(linger) .pull("cam0", &pulled, Path::new("live/cam0").unwrap()) @@ -747,7 +755,10 @@ mod tests { let consumer = downstream.consume(); consumer.routed(Path::new("live/cam0").unwrap()).await.unwrap(); - let copy = consumer.request_broadcast(Path::new("live/cam0").unwrap(), None).await.unwrap(); + let copy = consumer + .request_broadcast(Path::new("live/cam0").unwrap(), None) + .await + .unwrap(); // The catalog goes out once the keyframe landed, so the copy holds media to linger with. let mut listed = copy.track("catalog.json").unwrap().subscribe(None).await.unwrap(); assert!(listed.recv_group().await.unwrap().is_some()); @@ -822,7 +833,10 @@ mod tests { // Read what reaches the remote back out as FLV. let consumer = downstream.consume(); consumer.routed(Path::new("live/cam0").unwrap()).await.unwrap(); - let copy = consumer.request_broadcast(Path::new("live/cam0").unwrap(), None).await.unwrap(); + let copy = consumer + .request_broadcast(Path::new("live/cam0").unwrap(), None) + .await + .unwrap(); let source = moq_mux::Source::new(consumer, copy); let catalog = source .catalog::<()>(moq_mux::catalog::CatalogFormat::default()) @@ -839,7 +853,9 @@ mod tests { until(OLD_IDR).await; let epoch = moq_net::Epoch::mint(); - let mut instances = moq_mux::follow::Instances::new(&upstream.consume(), Path::new("live/cam0").unwrap(), Some(&epoch)).unwrap(); + let mut instances = + moq_mux::follow::Instances::new(&upstream.consume(), Path::new("live/cam0").unwrap(), Some(&epoch)) + .unwrap(); let (_new, _new_catalog) = publish(&upstream, &epoch, NEW_IDR); tokio::time::timeout(Duration::from_secs(5), instances.next()) .await @@ -905,15 +921,24 @@ mod tests { let pull_origin = client_origin.clone(); let pull = tokio::spawn(async move { let client = Client::connect(addr, "live").await.unwrap(); - client.pull("cam0", &pull_origin, Path::new("pulled/cam0").unwrap()).await.unwrap(); + client + .pull("cam0", &pull_origin, Path::new("pulled/cam0").unwrap()) + .await + .unwrap(); }); // The republished broadcast should show up in the client's origin. - tokio::time::timeout(Duration::from_secs(5), announced.routed(Path::new("pulled/cam0").unwrap())) + tokio::time::timeout( + Duration::from_secs(5), + announced.routed(Path::new("pulled/cam0").unwrap()), + ) + .await + .expect("client republish timed out") + .expect("broadcast announced in client origin"); + let broadcast = announced + .request_broadcast(Path::new("pulled/cam0").unwrap(), None) .await - .expect("client republish timed out") - .expect("broadcast announced in client origin"); - let broadcast = announced.request_broadcast(Path::new("pulled/cam0").unwrap(), None).await.unwrap(); + .unwrap(); // It should carry a hang catalog track (proof the FLV demux produced real // media on the far side): subscribe to it and read one catalog frame. diff --git a/rs/moq-rtmp/src/server.rs b/rs/moq-rtmp/src/server.rs index 5823783c5ae..12cd816d4a9 100644 --- a/rs/moq-rtmp/src/server.rs +++ b/rs/moq-rtmp/src/server.rs @@ -1745,7 +1745,11 @@ mod tests { let Some(Request::Publish(publish)) = accept_stream(stream, peer).await.unwrap() else { panic!("expected a publish request"); }; - publish.with_linger(linger).accept(&origin, Path::new("live/cam0").unwrap()).await.unwrap(); + publish + .with_linger(linger) + .accept(&origin, Path::new("live/cam0").unwrap()) + .await + .unwrap(); } /// An unpublish is a clean end: the finished broadcast stays up for the linger, then @@ -1763,7 +1767,10 @@ mod tests { let accept = tokio::spawn(accept_publish(server, origin.clone(), Duration::from_secs(10))); let broadcast = async { consumer.routed(Path::new("live/cam0").unwrap()).await.unwrap(); - consumer.request_broadcast(Path::new("live/cam0").unwrap(), None).await.unwrap() + consumer + .request_broadcast(Path::new("live/cam0").unwrap(), None) + .await + .unwrap() }; let (broadcast, ()) = tokio::join!(broadcast, publish_one_keyframe(client, leave)); @@ -1783,7 +1790,10 @@ mod tests { let accept = tokio::spawn(accept_publish(server, origin.clone(), Duration::ZERO)); let catalog = async { consumer.routed(Path::new("live/cam0").unwrap()).await.unwrap(); - let broadcast = consumer.request_broadcast(Path::new("live/cam0").unwrap(), None).await.unwrap(); + let broadcast = consumer + .request_broadcast(Path::new("live/cam0").unwrap(), None) + .await + .unwrap(); let track = broadcast.track(hang::Catalog::DEFAULT_NAME).unwrap(); track.subscribe(None).await.unwrap() }; @@ -1812,7 +1822,10 @@ mod tests { publish_one_keyframe(client, Leave::Unpublish).await; tokio::time::sleep(Duration::from_secs(5)).await; - let finished = consumer.request_broadcast(Path::new("live/cam0").unwrap(), None).await.unwrap(); + let finished = consumer + .request_broadcast(Path::new("live/cam0").unwrap(), None) + .await + .unwrap(); let mut video = finished.track("0.flv-v").unwrap().subscribe(None).await.unwrap(); assert!( video.recv_group().await.unwrap().is_some(), @@ -2094,7 +2107,10 @@ mod tests { let consumer = origin.consume(); consumer.routed(Path::new("live/cam0").unwrap()).await.unwrap(); - let broadcast = consumer.request_broadcast(Path::new("live/cam0").unwrap(), None).await.unwrap(); + let broadcast = consumer + .request_broadcast(Path::new("live/cam0").unwrap(), None) + .await + .unwrap(); let info = broadcast.track("0.flv-v").unwrap().query().await.unwrap(); assert_eq!(info.max_age, Some(Duration::from_secs(3))); } @@ -2219,7 +2235,8 @@ mod tests { assert_eq!(next().await.1[..2], [0x17, 0x01]); let epoch = moq_net::Epoch::mint(); - let mut instances = moq_mux::follow::Instances::new(&consumer, Path::new("live/cam0").unwrap(), Some(&epoch)).unwrap(); + let mut instances = + moq_mux::follow::Instances::new(&consumer, Path::new("live/cam0").unwrap(), Some(&epoch)).unwrap(); let (_new, _new_catalog) = publish_avc(&origin, epoch, &[0x65, 0x99, 0x99, 0x99, 0x99]); tokio::time::timeout(Duration::from_secs(5), instances.next()) .await @@ -2599,7 +2616,9 @@ mod tests { tokio::time::pause(); let server_task = tokio::spawn(async move { - play.accept(&consumer, Path::new("live/missing").unwrap()).await.unwrap(); + play.accept(&consumer, Path::new("live/missing").unwrap()) + .await + .unwrap(); }); tokio::task::yield_now().await; @@ -2672,7 +2691,10 @@ mod tests { .await .expect("stale publish timed out") .unwrap(); - let stale = consumer.request_broadcast(Path::new("live/cam0").unwrap(), None).await.unwrap(); + let stale = consumer + .request_broadcast(Path::new("live/cam0").unwrap(), None) + .await + .unwrap(); let mut catalog = stale .track(hang::Catalog::DEFAULT_NAME) .unwrap() @@ -2702,7 +2724,10 @@ mod tests { assert!(stale_viewer.is_err(), "the stale viewer ended: {stale_viewer:?}"); assert!(!stale_client.is_finished(), "the stale connection is still open"); - let fresh = consumer.request_broadcast(Path::new("live/cam0").unwrap(), None).await.unwrap(); + let fresh = consumer + .request_broadcast(Path::new("live/cam0").unwrap(), None) + .await + .unwrap(); assert!(!fresh.is_clone(&stale), "viewers reach the reconnected publish"); stale_client.abort(); diff --git a/rs/moq-srt/src/ts.rs b/rs/moq-srt/src/ts.rs index ff07f95c518..2b350f37c98 100644 --- a/rs/moq-srt/src/ts.rs +++ b/rs/moq-srt/src/ts.rs @@ -257,9 +257,9 @@ impl Subscriber { reason = "tests read the host clock directly" )] mod tests { - use moq_net::Path; use moq_mux::catalog::hang::Container; use moq_mux::catalog::{CatalogFormat, Stream}; + use moq_net::Path; use tokio::time::timeout; /// Build an origin producer, spawning its driver on the ambient runtime. @@ -482,7 +482,10 @@ mod tests { .await .expect("announce timed out") .expect("the broadcast is announced"); - let broadcast = consumer.request_broadcast(Path::new(path).unwrap(), None).await.unwrap(); + let broadcast = consumer + .request_broadcast(Path::new(path).unwrap(), None) + .await + .unwrap(); let mut catalog = moq_mux::catalog::Consumer::::new(&broadcast, CatalogFormat::Hang) .await .unwrap(); @@ -518,7 +521,10 @@ mod tests { let origin = produce_origin(); let consumer = origin.consume(); let _stale = Publisher::new(&origin, "ingest", Default::default(), None).unwrap(); - let stale = consumer.request_broadcast(Path::new("ingest").unwrap(), None).await.unwrap(); + let stale = consumer + .request_broadcast(Path::new("ingest").unwrap(), None) + .await + .unwrap(); let mut catalog = stale .track(hang::Catalog::DEFAULT_NAME) .unwrap() @@ -537,7 +543,10 @@ mod tests { }) .await; assert!(stale_viewer.is_err(), "the stale viewer ended: {stale_viewer:?}"); - let fresh = consumer.request_broadcast(Path::new("ingest").unwrap(), None).await.unwrap(); + let fresh = consumer + .request_broadcast(Path::new("ingest").unwrap(), None) + .await + .unwrap(); assert!(!fresh.is_clone(&stale), "viewers reach the reconnected caller"); } @@ -559,9 +568,12 @@ mod tests { assert_eq!(program(&origin, "ingest/1").await, (1, vec![0x0101])); assert_eq!(program(&origin, "ingest/2").await, (2, vec![0x0201])); assert!( - timeout(Duration::from_secs(1), origin.consume().routed(Path::new("ingest").unwrap())) - .await - .is_err(), + timeout( + Duration::from_secs(1), + origin.consume().routed(Path::new("ingest").unwrap()) + ) + .await + .is_err(), "nothing is published on the bare path" ); drop(publisher.finish(Duration::ZERO).unwrap()); @@ -578,7 +590,10 @@ mod tests { let consumer = origin.consume(); consumer.routed(Path::new("live/cam0").unwrap()).await.unwrap(); - let broadcast = consumer.request_broadcast(Path::new("live/cam0").unwrap(), None).await.unwrap(); + let broadcast = consumer + .request_broadcast(Path::new("live/cam0").unwrap(), None) + .await + .unwrap(); let start = tokio::time::Instant::now(); let wait = tokio::spawn(publisher.finish(linger).unwrap().wait()); tokio::time::sleep(linger / 2).await; @@ -612,7 +627,10 @@ mod tests { let consumer = origin.consume(); consumer.routed(Path::new("live/cam0").unwrap()).await.unwrap(); - let broadcast = consumer.request_broadcast(Path::new("live/cam0").unwrap(), None).await.unwrap(); + let broadcast = consumer + .request_broadcast(Path::new("live/cam0").unwrap(), None) + .await + .unwrap(); let info = broadcast.track("0.avc3").unwrap().query().await.unwrap(); assert_eq!(info.max_age, Some(Duration::from_secs(3))); } @@ -662,7 +680,10 @@ mod tests { .await .expect("announce timed out") .expect("the ingest broadcast is announced"); - let broadcast = consumer.request_broadcast(Path::new("ingest").unwrap(), None).await.unwrap(); + let broadcast = consumer + .request_broadcast(Path::new("ingest").unwrap(), None) + .await + .unwrap(); publisher.feed(bytes::Bytes::from_static(BBB5S)).unwrap(); diff --git a/rs/moq-stats/benches/producer_tick.rs b/rs/moq-stats/benches/producer_tick.rs index 813171803a6..6e0d5596c7d 100644 --- a/rs/moq-stats/benches/producer_tick.rs +++ b/rs/moq-stats/benches/producer_tick.rs @@ -289,7 +289,11 @@ impl Presence { let names: Vec = (0..labels).map(|index| format!("room/{index:05}")).collect(); let sessions: Vec<_> = names .iter() - .map(|label| registry.tier(stats::Tier::default()).session(Path::new(label.as_str()).unwrap())) + .map(|label| { + registry + .tier(stats::Tier::default()) + .session(Path::new(label.as_str()).unwrap()) + }) .collect(); // One set of wire counters per connection, independently of held presence tracks. let wire = sessions diff --git a/rs/moq-stats/src/aggregate.rs b/rs/moq-stats/src/aggregate.rs index d8c67c74474..3f047a9db2a 100644 --- a/rs/moq-stats/src/aggregate.rs +++ b/rs/moq-stats/src/aggregate.rs @@ -1036,13 +1036,18 @@ mod tests { let egress = feed_origin.consume().with_stats(ctx.clone()); let mut announced = egress.announced(); - let source = feed_origin.create_broadcast(Path::new(path).unwrap()).expect("create_broadcast"); + let source = feed_origin + .create_broadcast(Path::new(path).unwrap()) + .expect("create_broadcast"); source.announce(origin::Route::default()).expect("announce"); let track = source.create_track("video", timed()).expect("create_track"); let (_, active) = next_update(&mut announced).await.expect("announce"); assert!(active); - let consumer = egress.request_broadcast(Path::new(path).unwrap(), None).await.expect("resolve"); + let consumer = egress + .request_broadcast(Path::new(path).unwrap(), None) + .await + .expect("resolve"); let mut sub = consumer.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = track.append_group().unwrap(); @@ -1109,7 +1114,9 @@ mod tests { impl NodeBroadcast { fn new(origin: &origin::Producer, group: &str, node: &str) -> Self { let path = format!(".stats/{group}/node/{node}"); - let source = origin.create_broadcast(Path::new(path.as_str()).unwrap()).expect("create broadcast"); + let source = origin + .create_broadcast(Path::new(path.as_str()).unwrap()) + .expect("create broadcast"); source.announce(origin::Route::default()).expect("announce"); let name = traffic_track(&Tier::default(), Role::Publisher, Encoding::Plain); let track = source.create_track(name, timed()).expect("create track"); @@ -1442,7 +1449,9 @@ mod tests { .announce(origin::Route::default().with_epoch(epoch_b.clone())) .unwrap(); new.publish("acme/room", 30); - let pending = origin.consume().request_broadcast(Path::new(".stats/acme/node/a").unwrap(), None); + let pending = origin + .consume() + .request_broadcast(Path::new(".stats/acme/node/a").unwrap(), None); let front = futures::executor::block_on(kio::wait(|waiter| { driver.poll(now, waiter).unwrap(); pending.poll_ok(waiter) @@ -1467,7 +1476,10 @@ mod tests { (new, front, warm, driver) }); ready.wait(); - let key = (Path::new(".stats/acme/node/a").unwrap(), (!drop_epoch).then_some(epoch_a)); + let key = ( + Path::new(".stats/acme/node/a").unwrap(), + (!drop_epoch).then_some(epoch_a), + ); let node = merged.nodes.get_mut(&key).unwrap(); advance(node, &merged.origin, &merged.config, &name, &Waiter::noop()); let old_bytes = node.last.as_ref().unwrap()["acme/room"].bytes; @@ -1762,8 +1774,14 @@ mod tests { // group. let _fa = feed(&node_a, Tier::default(), "acme", "acme/room", 8).await; let _fb = feed(&node_b, Tier::default(), "acme", "acme/room", 8).await; - let _sa = node_a.registry().tier(Tier::default()).session(Path::new("acme").unwrap()); - let _sb = node_b.registry().tier(Tier::default()).session(Path::new("acme").unwrap()); + let _sa = node_a + .registry() + .tier(Tier::default()) + .session(Path::new("acme").unwrap()); + let _sb = node_b + .registry() + .tier(Tier::default()) + .session(Path::new("acme").unwrap()); drive_tick().await; let agg = Consumer::new(origin.consume(), Config::new().with_depth(1)); @@ -1789,8 +1807,14 @@ mod tests { let _fa = feed(&node_a, Tier::default(), "acme", "acme/room", 8).await; let fb = feed(&node_b, Tier::default(), "acme", "acme/room", 8).await; - let _sa = node_a.registry().tier(Tier::default()).session(Path::new("acme").unwrap()); - let sb = node_b.registry().tier(Tier::default()).session(Path::new("acme").unwrap()); + let _sa = node_a + .registry() + .tier(Tier::default()) + .session(Path::new("acme").unwrap()); + let sb = node_b + .registry() + .tier(Tier::default()) + .session(Path::new("acme").unwrap()); drive_tick().await; let agg = Consumer::new(origin.consume(), Config::new().with_depth(1)); diff --git a/rs/moq-stats/src/consume.rs b/rs/moq-stats/src/consume.rs index 6cb67dde293..00c683a0d57 100644 --- a/rs/moq-stats/src/consume.rs +++ b/rs/moq-stats/src/consume.rs @@ -255,7 +255,10 @@ mod tests { let (_, active) = next_update(&mut announced).await.expect("announce"); assert!(active); - let consumer = egress.request_broadcast(Path::new(path).unwrap(), None).await.expect("resolve"); + let consumer = egress + .request_broadcast(Path::new(path).unwrap(), None) + .await + .expect("resolve"); let sub = consumer.track("video").unwrap().subscribe(None).await.unwrap(); Feed { diff --git a/rs/moq-stats/src/lib.rs b/rs/moq-stats/src/lib.rs index 92ac50d8658..c9f20faca15 100644 --- a/rs/moq-stats/src/lib.rs +++ b/rs/moq-stats/src/lib.rs @@ -381,10 +381,22 @@ mod tests { ); assert_eq!(totals_track(Encoding::Plain), "totals.json"); assert_eq!(totals_track(Encoding::Compressed), "totals.json.z"); - assert_eq!(presence_track(Path::new("acme/live").unwrap(), Encoding::Plain), "acme/live/presence.json"); - assert_eq!(presence_track(Path::new("").unwrap(), Encoding::Compressed), "presence.json.z"); - assert_eq!(prefix_track(Path::new("acme/live").unwrap(), Encoding::Plain), "acme/live/prefix.json"); - assert_eq!(prefix_track(Path::new("").unwrap(), Encoding::Compressed), "prefix.json.z"); + assert_eq!( + presence_track(Path::new("acme/live").unwrap(), Encoding::Plain), + "acme/live/presence.json" + ); + assert_eq!( + presence_track(Path::new("").unwrap(), Encoding::Compressed), + "presence.json.z" + ); + assert_eq!( + prefix_track(Path::new("acme/live").unwrap(), Encoding::Plain), + "acme/live/prefix.json" + ); + assert_eq!( + prefix_track(Path::new("").unwrap(), Encoding::Compressed), + "prefix.json.z" + ); } #[test] diff --git a/rs/moq-stats/src/produce.rs b/rs/moq-stats/src/produce.rs index 6fb90378c6e..0c9a751310b 100644 --- a/rs/moq-stats/src/produce.rs +++ b/rs/moq-stats/src/produce.rs @@ -350,7 +350,10 @@ impl Drain { if refused.iter().any(|name| name == key) { return None; } - match GroupPublisher::create(task, &Path::new(key).expect("a group key is a run of a path's segments")) { + match GroupPublisher::create( + task, + &Path::new(key).expect("a group key is a run of a path's segments"), + ) { Some(group) => { groups.insert(key.to_string(), group); } @@ -1762,7 +1765,10 @@ mod tests { let (route, active) = next_update(&mut events).await.unwrap(); assert!(active); assert_eq!(route.prefix.as_str(), ".stats/node"); - let broadcast = consumer.request_broadcast(Path::new(".stats/node").unwrap(), None).await.unwrap(); + let broadcast = consumer + .request_broadcast(Path::new(".stats/node").unwrap(), None) + .await + .unwrap(); let name = presence_track(Path::new("room").unwrap(), encoding); let mut config = moq_json::snapshot::consumer::Config::default(); config.compression = encoding.compression(); @@ -1863,7 +1869,9 @@ mod tests { let consumer = broadcast.consume(); let mut pair = TrackPair::::create(&broadcast, "t.json", Arc::new(AtomicU64::new(0))).unwrap(); let mut publish = |key: &str, value: u64| { - pair.frame.entries.push((Path::try_from(key.to_string()).unwrap(), value)); + pair.frame + .entries + .push((Path::try_from(key.to_string()).unwrap(), value)); pair.publish("t.json"); }; publish("small", 1); @@ -1974,13 +1982,18 @@ mod tests { let egress = origin.consume().with_stats(ctx); let mut announced = egress.announced(); - let source = origin.create_broadcast(Path::new(path).unwrap()).expect("create_broadcast"); + let source = origin + .create_broadcast(Path::new(path).unwrap()) + .expect("create_broadcast"); source.announce(origin::Route::default()).expect("announce"); let producer = source.create_track("video", timed()).expect("create_track"); let (_, active) = next_update(&mut announced).await.expect("announce"); assert!(active); - let consumer = egress.request_broadcast(Path::new(path).unwrap(), None).await.expect("resolve"); + let consumer = egress + .request_broadcast(Path::new(path).unwrap(), None) + .await + .expect("resolve"); let sub = if subscribe { let mut sub = consumer @@ -2315,7 +2328,10 @@ mod tests { .with_stats(registry.tier(Tier::default()).session(Path::new("viewer").unwrap())); async fn view(egress: &origin::Consumer, video: &mut track::Producer, size: usize) { - let broadcast = egress.request_broadcast(Path::new("foo/bar").unwrap(), None).await.expect("resolve"); + let broadcast = egress + .request_broadcast(Path::new("foo/bar").unwrap(), None) + .await + .expect("resolve"); let mut sub = broadcast .track("video") .expect("track") @@ -2417,7 +2433,11 @@ mod tests { let [(path, true, old_epoch)] = &take_epochs(&mut events)[..] else { panic!("expected the wire root's group"); }; - let broadcast = origin.consume().request_broadcast(Path::new(path).unwrap(), None).await.expect("resolve"); + let broadcast = origin + .consume() + .request_broadcast(Path::new(path).unwrap(), None) + .await + .expect("resolve"); let totals = default_totals(&broadcast).await.sessions; assert_eq!((totals.wire_tx, totals.wire_rx), (71, 29)); drop(wire); @@ -2459,8 +2479,16 @@ mod tests { panic!("expected both groups to announce, got {started:?}"); }; assert_eq!((acme_path.as_str(), feed_path.as_str()), (ACME, FEED)); - let acme = origin.consume().request_broadcast(Path::new(ACME).unwrap(), None).await.expect("resolve"); - let sessions = origin.consume().request_broadcast(Path::new(FEED).unwrap(), None).await.expect("resolve"); + let acme = origin + .consume() + .request_broadcast(Path::new(ACME).unwrap(), None) + .await + .expect("resolve"); + let sessions = origin + .consume() + .request_broadcast(Path::new(FEED).unwrap(), None) + .await + .expect("resolve"); assert_eq!(read_last_frame(&acme, "publisher.json").await["acme/live"].bytes, 100); // The viewer leaves: both groups empty but stay announced. The path map @@ -2530,7 +2558,11 @@ mod tests { new_acme > acme_epoch && new_feed > feed_epoch, "a returning group mints a new epoch" ); - let acme = origin.consume().request_broadcast(Path::new(ACME).unwrap(), None).await.expect("resolve"); + let acme = origin + .consume() + .request_broadcast(Path::new(ACME).unwrap(), None) + .await + .expect("resolve"); assert_eq!(read_last_frame(&acme, "publisher.json").await["acme/live"].bytes, 25); assert_eq!( default_totals(&acme).await.publisher.bytes, @@ -2597,7 +2629,11 @@ mod tests { panic!("expected the session's group to announce"); }; assert_eq!(path, ACME); - let acme = origin.consume().request_broadcast(Path::new(ACME).unwrap(), None).await.expect("resolve"); + let acme = origin + .consume() + .request_broadcast(Path::new(ACME).unwrap(), None) + .await + .expect("resolve"); let mut held = hold(&acme).await; // The session leaves: the group lingers with every hold still live. @@ -2623,7 +2659,11 @@ mod tests { }; assert_eq!(path, ACME); assert!(newer > epoch, "a returning group mints a new epoch"); - let acme = origin.consume().request_broadcast(Path::new(ACME).unwrap(), None).await.expect("resolve"); + let acme = origin + .consume() + .request_broadcast(Path::new(ACME).unwrap(), None) + .await + .expect("resolve"); let [_tier, mut presence, _prefix] = hold(&acme).await; let frame = try_presence(&mut presence).expect("answered at once"); assert_eq!(frame[""].active(), 1, "served from the new epoch"); @@ -2632,9 +2672,18 @@ mod tests { #[tokio::test(start_paused = true)] async fn session_track_surfaces_by_root() { let (producer, origin) = test_producer(Some("sjc")); - let _a = producer.registry().tier(Tier::default()).session(Path::new("acme").unwrap()); - let _b = producer.registry().tier(Tier::default()).session(Path::new("acme").unwrap()); - let _c = producer.registry().tier(Tier::new(Path::new("region/sjc").unwrap())).session(Path::new("peer").unwrap()); + let _a = producer + .registry() + .tier(Tier::default()) + .session(Path::new("acme").unwrap()); + let _b = producer + .registry() + .tier(Tier::default()) + .session(Path::new("acme").unwrap()); + let _c = producer + .registry() + .tier(Tier::new(Path::new("region/sjc").unwrap())) + .session(Path::new("peer").unwrap()); drive_tick().await; @@ -2661,7 +2710,10 @@ mod tests { #[tokio::test(start_paused = true)] async fn request_root_stays_in_the_frame_while_held() { let (producer, origin) = test_producer(Some("sjc")); - let first = producer.registry().tier(Tier::default()).request(Path::new("acme").unwrap()); + let first = producer + .registry() + .tier(Tier::default()) + .request(Path::new("acme").unwrap()); drive_tick().await; let (_, broadcast) = announced(&origin).await; let mut track = subscribe(&broadcast, "sessions.json").await; @@ -2679,7 +2731,10 @@ mod tests { drive_tick().await; assert!(!drain(&mut track).contains(&None), "an idle request stays"); - let second = producer.registry().tier(Tier::default()).request(Path::new("acme").unwrap()); + let second = producer + .registry() + .tier(Tier::default()) + .request(Path::new("acme").unwrap()); drive_tick().await; assert_eq!(drain(&mut track), [Some(2)]); @@ -2693,9 +2748,18 @@ mod tests { #[tokio::test(start_paused = true)] async fn totals_split_sessions_by_tier() { let (producer, origin) = test_producer(Some("sjc")); - let _a = producer.registry().tier(Tier::default()).session(Path::new("acme").unwrap()); - let b = producer.registry().tier(Tier::default()).session(Path::new("beta").unwrap()); - let _c = producer.registry().tier(Tier::new(Path::new("region/sjc").unwrap())).session(Path::new("peer").unwrap()); + let _a = producer + .registry() + .tier(Tier::default()) + .session(Path::new("acme").unwrap()); + let b = producer + .registry() + .tier(Tier::default()) + .session(Path::new("beta").unwrap()); + let _c = producer + .registry() + .tier(Tier::new(Path::new("region/sjc").unwrap())) + .session(Path::new("peer").unwrap()); drive_tick().await; let (_, broadcast) = announced(&origin).await; @@ -2724,7 +2788,11 @@ mod tests { let _beta = feed(registry, Tier::default(), "beta/live", true, 1, 7).await; drive_tick().await; - let acme = origin.consume().request_broadcast(Path::new(ACME).unwrap(), None).await.expect("resolve"); + let acme = origin + .consume() + .request_broadcast(Path::new(ACME).unwrap(), None) + .await + .expect("resolve"); let beta = origin .consume() .request_broadcast(Path::new(".stats/beta/node/sjc").unwrap(), None) @@ -2753,7 +2821,9 @@ mod tests { let (producer, origin) = test_producer(Some("sjc")); let registry = producer.registry(); let first = registry.tier(Tier::default()).session(Path::new("acme/live").unwrap()); - let _other = registry.tier(Tier::new(Path::new("rtmp").unwrap())).session(Path::new("acme/live").unwrap()); + let _other = registry + .tier(Tier::new(Path::new("rtmp").unwrap())) + .session(Path::new("acme/live").unwrap()); let _unrelated = registry.tier(Tier::default()).session(Path::new("beta").unwrap()); drive_tick().await; let (_, broadcast) = announced(&origin).await; @@ -2852,7 +2922,11 @@ mod tests { let (producer, origin, _events) = grouped_producer(DEFAULT_LINGER); let _f = feed(producer.registry(), Tier::default(), "acme/live", true, 1, 42).await; drive_tick().await; - let acme = origin.consume().request_broadcast(Path::new(ACME).unwrap(), None).await.expect("resolve"); + let acme = origin + .consume() + .request_broadcast(Path::new(ACME).unwrap(), None) + .await + .expect("resolve"); let subscribing = acme .track(&presence_track(Path::new("beta").unwrap(), Encoding::Plain)) @@ -2866,9 +2940,12 @@ mod tests { let pending: Vec<_> = (0..3) .map(|i| { - acme.track(&presence_track(Path::new(format!("acme/{i}").as_str()).unwrap(), Encoding::Plain)) - .expect("track") - .subscribe(None) + acme.track(&presence_track( + Path::new(format!("acme/{i}").as_str()).unwrap(), + Encoding::Plain, + )) + .expect("track") + .subscribe(None) }) .collect(); drive_tick().await; @@ -2931,10 +3008,22 @@ mod tests { let _own = feed(registry, Tier::default(), "acme", true, 1, 1).await; let _live = feed(registry, Tier::default(), "acme/live", true, 1, 10).await; let _cam = feed(registry, Tier::default(), "acme/live/cam", true, 1, 100).await; - let _rtmp = feed(registry, Tier::new(Path::new("rtmp").unwrap()), "acme/vod", true, 1, 1000).await; + let _rtmp = feed( + registry, + Tier::new(Path::new("rtmp").unwrap()), + "acme/vod", + true, + 1, + 1000, + ) + .await; let _other = feed(registry, Tier::default(), "beta/live", true, 1, 5).await; drive_tick().await; - let acme = origin.consume().request_broadcast(Path::new(ACME).unwrap(), None).await.expect("resolve"); + let acme = origin + .consume() + .request_broadcast(Path::new(ACME).unwrap(), None) + .await + .expect("resolve"); let mut track = hold_prefix(&acme, "acme").await; let frame = last_prefix(&mut track).expect("answered at once"); @@ -2991,7 +3080,10 @@ mod tests { let egress = data .consume() .with_stats(registry.tier(Tier::default()).session(Path::new("viewer").unwrap())); - let broadcast = egress.request_broadcast(Path::new("acme/live").unwrap(), None).await.expect("resolve"); + let broadcast = egress + .request_broadcast(Path::new("acme/live").unwrap(), None) + .await + .expect("resolve"); let mut subs = Vec::new(); for _ in 0..300 { let track = broadcast.track("video").expect("track"); @@ -3186,7 +3278,12 @@ mod tests { let prefix = Path::new("metrics").unwrap(); assert_eq!( - advertised_path(&prefix, &Path::new("demo/room").unwrap(), Some(&Path::new("lon").unwrap())).as_str(), + advertised_path( + &prefix, + &Path::new("demo/room").unwrap(), + Some(&Path::new("lon").unwrap()) + ) + .as_str(), "metrics/demo/room/node/lon" ); } @@ -3244,7 +3341,15 @@ mod tests { assert!(parsed.is_empty(), "an idle tier serves zeros"); // The tier records: the same subscription carries the data. - let _rtmp = feed(producer.registry(), Tier::new(Path::new("rtmp").unwrap()), "foo/live", true, 1, 7).await; + let _rtmp = feed( + producer.registry(), + Tier::new(Path::new("rtmp").unwrap()), + "foo/live", + true, + 1, + 7, + ) + .await; drive_tick().await; let frame = next_frame(&mut sub).await; let parsed: BTreeMap = serde_json::from_slice(&frame.payload).expect("json"); @@ -3317,7 +3422,15 @@ mod tests { } // ...then the tier records its first traffic before the next tick. - let _rtmp = feed(producer.registry(), Tier::new(Path::new("rtmp").unwrap()), "foo/live", true, 1, 7).await; + let _rtmp = feed( + producer.registry(), + Tier::new(Path::new("rtmp").unwrap()), + "foo/live", + true, + 1, + 7, + ) + .await; drive_tick().await; // The queued subscription resolves and carries the tier's first data. @@ -3405,7 +3518,15 @@ mod tests { ); // The tier records while the request is parked: the flush adopts it. - let _rt = feed(producer.registry(), Tier::new(Path::new("rt").unwrap()), "foo/live", true, 1, 9).await; + let _rt = feed( + producer.registry(), + Tier::new(Path::new("rt").unwrap()), + "foo/live", + true, + 1, + 9, + ) + .await; drive_tick().await; let mut sub = subscribing.await.expect("adopted by the flush").ordered(); let frame = next_frame(&mut sub).await; diff --git a/rs/moq-tokio/examples/chat.rs b/rs/moq-tokio/examples/chat.rs index 1376db44eda..fc4ae0327d6 100644 --- a/rs/moq-tokio/examples/chat.rs +++ b/rs/moq-tokio/examples/chat.rs @@ -43,7 +43,9 @@ async fn run_broadcast(origin: moq_net::origin::Producer) -> anyhow::Result<()> // but in this example we'll only create one. The live route announces it. // NOTE: The path is empty because we're using the URL to scope the broadcast. // If you put "alice" here, it would be published as "anon/chat-example/alice". - let broadcast = origin.create_broadcast(moq_net::Path::empty()).context("failed to create broadcast")?; + let broadcast = origin + .create_broadcast(moq_net::Path::empty()) + .context("failed to create broadcast")?; broadcast .announce(Default::default()) .context("failed to announce broadcast")?; diff --git a/rs/moq-tokio/src/client.rs b/rs/moq-tokio/src/client.rs index 20fb9adf560..607629424f7 100644 --- a/rs/moq-tokio/src/client.rs +++ b/rs/moq-tokio/src/client.rs @@ -1321,7 +1321,9 @@ mod tests { #[tokio::test] async fn broadcast_race_quic_wins() { let pub_origin = crate::origin::spawn(); - let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("failed to create broadcast"); + let broadcast = pub_origin + .create_broadcast(Path::new("test").unwrap()) + .expect("failed to create broadcast"); broadcast .announce(Default::default()) .expect("failed to create broadcast"); diff --git a/rs/moq-tokio/src/origin.rs b/rs/moq-tokio/src/origin.rs index 254af7069ec..c473c5986db 100644 --- a/rs/moq-tokio/src/origin.rs +++ b/rs/moq-tokio/src/origin.rs @@ -57,7 +57,9 @@ mod tests { let origin = spawn(); let mut announced = origin.consume().announced(); - let broadcast = origin.create_broadcast(Path::new("cam").unwrap()).expect("create broadcast"); + let broadcast = origin + .create_broadcast(Path::new("cam").unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let (update, active) = next_update(&mut announced).await.expect("announce"); diff --git a/rs/moq-tokio/src/server.rs b/rs/moq-tokio/src/server.rs index 23fcaf5c2cd..c8a778e8197 100644 --- a/rs/moq-tokio/src/server.rs +++ b/rs/moq-tokio/src/server.rs @@ -2665,7 +2665,9 @@ mod tests { let _ = std::fs::remove_file(&path); let origin = crate::origin::spawn(); - let broadcast = origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); + let broadcast = origin + .create_broadcast(Path::new("test").unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("announce broadcast"); let track = broadcast.create_track("video", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); @@ -2721,7 +2723,10 @@ mod tests { .expect("origin closed"); assert_eq!(update.prefix.as_str(), "test"); assert!(active); - let broadcast = consumer.request_broadcast(Path::new("test").unwrap(), None).await.expect("resolve"); + let broadcast = consumer + .request_broadcast(Path::new("test").unwrap(), None) + .await + .expect("resolve"); let mut track = broadcast .track("video") diff --git a/rs/moq-tokio/src/webrtc/tests.rs b/rs/moq-tokio/src/webrtc/tests.rs index 35e328266d4..3cfc6ffdc08 100644 --- a/rs/moq-tokio/src/webrtc/tests.rs +++ b/rs/moq-tokio/src/webrtc/tests.rs @@ -64,7 +64,10 @@ async fn transfer(offerer: &Offerer, answerer: &Answerer, payload: &[u8]) { panic!("expected the broadcast to be announced"); }; assert_eq!(route.prefix.as_str(), "test"); - let broadcast = consumer.request_broadcast(moq_net::Path::new("test").unwrap(), None).await.unwrap(); + let broadcast = consumer + .request_broadcast(moq_net::Path::new("test").unwrap(), None) + .await + .unwrap(); let mut track = broadcast.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = track.recv_group().await.unwrap().unwrap(); group.read_frame().await.unwrap().unwrap() diff --git a/rs/moq-tokio/tests/integration/backend.rs b/rs/moq-tokio/tests/integration/backend.rs index 338c5557491..02638c39a35 100644 --- a/rs/moq-tokio/tests/integration/backend.rs +++ b/rs/moq-tokio/tests/integration/backend.rs @@ -115,7 +115,9 @@ async fn connect_test(config: ConnectTest<'_>) { // ── publisher (server) ────────────────────────────────────────── let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("failed to create broadcast"); + let broadcast = pub_origin + .create_broadcast(Path::new("test").unwrap()) + .expect("failed to create broadcast"); broadcast .announce(Default::default()) .expect("failed to create broadcast"); @@ -190,10 +192,13 @@ async fn connect_test(config: ConnectTest<'_>) { .expect("origin closed"); assert_eq!(update.prefix.as_str(), "test"); assert!(active, "expected announce, got retraction"); - let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast(Path::new("test").unwrap(), None)) - .await - .expect("request timed out") - .expect("announced broadcast resolves"); + let bc = tokio::time::timeout( + TIMEOUT, + sub_consumer.request_broadcast(Path::new("test").unwrap(), None), + ) + .await + .expect("request timed out") + .expect("announced broadcast resolves"); let mut track_sub = bc .track("video") @@ -600,7 +605,9 @@ async fn iroh_connect_test(version: Option<&str>) { // ── publisher (server) ────────────────────────────────────────── let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("failed to create broadcast"); + let broadcast = pub_origin + .create_broadcast(Path::new("test").unwrap()) + .expect("failed to create broadcast"); broadcast .announce(Default::default()) .expect("failed to create broadcast"); @@ -704,10 +711,13 @@ async fn iroh_connect_test(version: Option<&str>) { .expect("origin closed"); assert_eq!(update.prefix.as_str(), "test"); assert!(active, "expected announce, got retraction"); - let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast(Path::new("test").unwrap(), None)) - .await - .expect("request timed out") - .expect("announced broadcast resolves"); + let bc = tokio::time::timeout( + TIMEOUT, + sub_consumer.request_broadcast(Path::new("test").unwrap(), None), + ) + .await + .expect("request timed out") + .expect("announced broadcast resolves"); let mut track_sub = bc .track("video") @@ -831,7 +841,9 @@ async fn quic_client_close_drains_finished_track() { .expect("client runtime"); runtime.block_on(async move { let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast(Path::new("test").unwrap()).expect("failed to create broadcast"); + let broadcast = origin + .create_broadcast(Path::new("test").unwrap()) + .expect("failed to create broadcast"); broadcast.announce(Default::default()).expect("failed to announce"); let mut track = broadcast .create_track("video", timed()) @@ -945,7 +957,9 @@ async fn quic_client_close_drains_migrated_predecessor() { .expect("client runtime"); runtime.block_on(async move { let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast(Path::new("test").unwrap()).expect("failed to create broadcast"); + let broadcast = origin + .create_broadcast(Path::new("test").unwrap()) + .expect("failed to create broadcast"); broadcast.announce(Default::default()).expect("failed to announce"); let mut track = broadcast .create_track("video", timed()) @@ -1087,7 +1101,9 @@ async fn quic_client_close_keeps_predecessor_handover() { .expect("client runtime"); runtime.block_on(async move { let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast(Path::new("test").unwrap()).expect("failed to create broadcast"); + let broadcast = origin + .create_broadcast(Path::new("test").unwrap()) + .expect("failed to create broadcast"); broadcast.announce(Default::default()).expect("failed to announce"); // Never finished, so the predecessor serving it cannot drain. let mut track = broadcast diff --git a/rs/moq-tokio/tests/integration/broadcast.rs b/rs/moq-tokio/tests/integration/broadcast.rs index b90bdb18c6b..5e49f3b4efc 100644 --- a/rs/moq-tokio/tests/integration/broadcast.rs +++ b/rs/moq-tokio/tests/integration/broadcast.rs @@ -30,7 +30,9 @@ async fn broadcast_test(scheme: &str, client_version: Option<&str>, server_versi // ── publisher (server) ────────────────────────────────────────── let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("failed to create broadcast"); + let broadcast = pub_origin + .create_broadcast(Path::new("test").unwrap()) + .expect("failed to create broadcast"); broadcast .announce(Default::default()) .expect("failed to create broadcast"); @@ -98,10 +100,13 @@ async fn broadcast_test(scheme: &str, client_version: Option<&str>, server_versi assert_eq!(update.prefix.as_str(), "test"); assert!(active, "expected announce, got retraction"); - let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast(Path::new("test").unwrap(), None)) - .await - .expect("request timed out") - .expect("announced broadcast resolves"); + let bc = tokio::time::timeout( + TIMEOUT, + sub_consumer.request_broadcast(Path::new("test").unwrap(), None), + ) + .await + .expect("request timed out") + .expect("announced broadcast resolves"); // Subscribe to the track. let mut track_sub = bc @@ -143,7 +148,9 @@ async fn lite05_timestamp_roundtrip(scheme: &str) { use moq_tokio::moq_net::{Timescale, Timestamp}; let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("failed to create broadcast"); + let broadcast = pub_origin + .create_broadcast(Path::new("test").unwrap()) + .expect("failed to create broadcast"); broadcast .announce(Default::default()) .expect("failed to create broadcast"); @@ -207,10 +214,13 @@ async fn lite05_timestamp_roundtrip(scheme: &str) { .expect("origin closed"); assert_eq!(update.prefix.as_str(), "test"); assert!(active, "expected announce, got retraction"); - let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast(Path::new("test").unwrap(), None)) - .await - .expect("request timed out") - .expect("announced broadcast resolves"); + let bc = tokio::time::timeout( + TIMEOUT, + sub_consumer.request_broadcast(Path::new("test").unwrap(), None), + ) + .await + .expect("request timed out") + .expect("announced broadcast resolves"); let mut track_sub = bc .track("video") @@ -259,7 +269,9 @@ async fn lite05_fetch_roundtrip(scheme: &str) { use moq_tokio::moq_net::{Timescale, Timestamp}; let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("failed to create broadcast"); + let broadcast = pub_origin + .create_broadcast(Path::new("test").unwrap()) + .expect("failed to create broadcast"); broadcast .announce(Default::default()) .expect("failed to create broadcast"); @@ -321,10 +333,13 @@ async fn lite05_fetch_roundtrip(scheme: &str) { .expect("origin closed"); assert_eq!(update.prefix.as_str(), "test"); assert!(active, "expected announce, got retraction"); - let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast(Path::new("test").unwrap(), None)) - .await - .expect("request timed out") - .expect("announced broadcast resolves"); + let bc = tokio::time::timeout( + TIMEOUT, + sub_consumer.request_broadcast(Path::new("test").unwrap(), None), + ) + .await + .expect("request timed out") + .expect("announced broadcast resolves"); // Fetch group 0 directly, without subscribing. No live producer holds the group // on the client, so this issues a wire FETCH upstream. @@ -374,7 +389,9 @@ async fn broadcast_moq_lite_05_fetch_webtransport() { /// refusal. async fn transport_fetch_roundtrip(version: &str) { let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("failed to create broadcast"); + let broadcast = pub_origin + .create_broadcast(Path::new("test").unwrap()) + .expect("failed to create broadcast"); broadcast .announce(Default::default()) .expect("failed to announce broadcast"); @@ -431,10 +448,13 @@ async fn transport_fetch_roundtrip(version: &str) { .await .expect("announce timed out") .expect("origin closed"); - let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast(Path::new("test").unwrap(), None)) - .await - .expect("request timed out") - .expect("announced broadcast resolves"); + let bc = tokio::time::timeout( + TIMEOUT, + sub_consumer.request_broadcast(Path::new("test").unwrap(), None), + ) + .await + .expect("request timed out") + .expect("announced broadcast resolves"); let fetched = tokio::time::timeout(TIMEOUT, async { bc.track("video").unwrap().fetch_group(1, None).await }) .await @@ -504,7 +524,9 @@ async fn lite05_fetch_during_subscribe(scheme: &str) { use moq_tokio::moq_net::{Timescale, Timestamp}; let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("failed to create broadcast"); + let broadcast = pub_origin + .create_broadcast(Path::new("test").unwrap()) + .expect("failed to create broadcast"); broadcast .announce(Default::default()) .expect("failed to create broadcast"); @@ -568,10 +590,13 @@ async fn lite05_fetch_during_subscribe(scheme: &str) { .expect("origin closed"); assert_eq!(update.prefix.as_str(), "test"); assert!(active, "expected announce, got retraction"); - let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast(Path::new("test").unwrap(), None)) - .await - .expect("request timed out") - .expect("announced broadcast resolves"); + let bc = tokio::time::timeout( + TIMEOUT, + sub_consumer.request_broadcast(Path::new("test").unwrap(), None), + ) + .await + .expect("request timed out") + .expect("announced broadcast resolves"); // Subscribe (starts at the latest group) and read the live group, which // establishes the upstream subscription and leaves it active. @@ -628,7 +653,9 @@ async fn broadcast_moq_lite_05_fetch_during_subscribe_webtransport() { #[tokio::test] async fn broadcast_moq_lite_05_untimed_track() { let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); + let broadcast = pub_origin + .create_broadcast(Path::new("test").unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let track = broadcast.create_track("video", None).expect("create track"); @@ -723,7 +750,9 @@ async fn broadcast_moq_lite_05_untimed_track() { #[tokio::test] async fn broadcast_moq_transport_20_current_group_join() { let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); + let broadcast = pub_origin + .create_broadcast(Path::new("test").unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("announce"); let track = broadcast.create_track("video", timed()).expect("create track"); @@ -848,7 +877,9 @@ async fn announce_lifecycle_test(version: &str) { let pub_origin = moq_tokio::origin::spawn(); // Announced before the client connects, so it rides the initial set. - let first = pub_origin.create_broadcast(Path::new("room/first").unwrap()).expect("create broadcast"); + let first = pub_origin + .create_broadcast(Path::new("room/first").unwrap()) + .expect("create broadcast"); first.announce(Default::default()).expect("create broadcast"); let mut server_config = moq_tokio::listen::Config::default(); @@ -889,7 +920,9 @@ async fn announce_lifecycle_test(version: &str) { assert!(active, "expected initial announce"); // A live announce after the initial set. - let second = pub_origin.create_broadcast(Path::new("room/second").unwrap()).expect("create broadcast"); + let second = pub_origin + .create_broadcast(Path::new("room/second").unwrap()) + .expect("create broadcast"); second.announce(Default::default()).expect("create broadcast"); let (update, active) = next_announce(&mut announcements).await; assert_eq!(update.prefix.as_str(), "room/second"); @@ -903,7 +936,9 @@ async fn announce_lifecycle_test(version: &str) { assert!(!active, "expected retraction"); // Re-announce the same path: a fresh announce assigning a fresh id. - let _second = pub_origin.create_broadcast(Path::new("room/second").unwrap()).expect("create broadcast"); + let _second = pub_origin + .create_broadcast(Path::new("room/second").unwrap()) + .expect("create broadcast"); _second.announce(Default::default()).expect("create broadcast"); let (update, active) = next_announce(&mut announcements).await; assert_eq!(update.prefix.as_str(), "room/second"); @@ -916,14 +951,18 @@ async fn announce_lifecycle_test(version: &str) { let (update, active) = next_announce(&mut announcements).await; assert_eq!(update.prefix.as_str(), "room/first"); assert!(!active, "expected the replaced retraction"); - let _replacement = pub_origin.create_broadcast(Path::new("room/first").unwrap()).expect("create replacement"); + let _replacement = pub_origin + .create_broadcast(Path::new("room/first").unwrap()) + .expect("create replacement"); _replacement.announce(Default::default()).expect("create replacement"); let (update, active) = next_announce(&mut announcements).await; assert_eq!(update.prefix.as_str(), "room/first"); assert!(active, "expected the replacement announce"); // A sentinel proves no stray event for "first" snuck in behind the replacement. - let _sentinel = pub_origin.create_broadcast(Path::new("room/sentinel").unwrap()).expect("create broadcast"); + let _sentinel = pub_origin + .create_broadcast(Path::new("room/sentinel").unwrap()) + .expect("create broadcast"); _sentinel.announce(Default::default()).expect("create broadcast"); let (update, active) = next_announce(&mut announcements).await; assert_eq!(update.prefix.as_str(), "room/sentinel"); @@ -978,7 +1017,9 @@ async fn broadcast_route_migration() { let origin_a = moq_tokio::origin::spawn(); let mut hops_a = moq_net::Hops::new(); hops_a.push(publisher).unwrap(); - let broadcast_a = origin_a.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); + let broadcast_a = origin_a + .create_broadcast(Path::new("test").unwrap()) + .expect("create broadcast"); broadcast_a .announce( moq_net::origin::Route::default() @@ -1003,7 +1044,9 @@ async fn broadcast_route_migration() { let mut hops_b = moq_net::Hops::new(); hops_b.push(publisher).unwrap(); hops_b.push(Hop::new(0x1234).unwrap()).unwrap(); - let broadcast_b = origin_b.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); + let broadcast_b = origin_b + .create_broadcast(Path::new("test").unwrap()) + .expect("create broadcast"); broadcast_b .announce( moq_net::origin::Route::default() @@ -1092,10 +1135,13 @@ async fn broadcast_route_migration() { let subscription = moq_net::track::Subscription::default() .with_range(1..) .with_max_delay(Duration::from_secs(10)); - let broadcast = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast(Path::new("test").unwrap(), None)) - .await - .expect("request timeout") - .expect("routed broadcast resolves"); + let broadcast = tokio::time::timeout( + TIMEOUT, + sub_consumer.request_broadcast(Path::new("test").unwrap(), None), + ) + .await + .expect("request timeout") + .expect("routed broadcast resolves"); let mut sub = broadcast .track("video") .unwrap() @@ -1172,7 +1218,9 @@ async fn rejoin_skips_a_stale_warm_cache(version: &str) { }; let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); + let broadcast = pub_origin + .create_broadcast(Path::new("test").unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("announce"); let track = broadcast.create_track("audio", timed()).expect("create track"); let live = track.clone(); @@ -1214,10 +1262,13 @@ async fn rejoin_skips_a_stale_warm_cache(version: &str) { .expect("connect failed"); assert!(next_announce(&mut announcements).await.1); - let remote = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast(Path::new("test").unwrap(), None)) - .await - .expect("request timeout") - .expect("broadcast resolves"); + let remote = tokio::time::timeout( + TIMEOUT, + sub_consumer.request_broadcast(Path::new("test").unwrap(), None), + ) + .await + .expect("request timeout") + .expect("broadcast resolves"); let budget = moq_net::track::Subscription::default().with_max_delay(Duration::from_millis(100)); async fn recv(sub: &mut moq_net::track::Subscriber, version: &str) -> u64 { tokio::time::timeout(TIMEOUT, sub.recv_group()) @@ -1288,7 +1339,9 @@ async fn broadcast_rejoin_replays_a_current_warm_cache() { async fn rejoin_replays_a_current_warm_cache(version: &str, open: bool) { let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); + let broadcast = pub_origin + .create_broadcast(Path::new("test").unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("announce"); let track = broadcast.create_track("catalog.json", timed()).expect("create track"); let live = track.clone(); @@ -1334,10 +1387,13 @@ async fn rejoin_replays_a_current_warm_cache(version: &str, open: bool) { .expect("connect failed"); assert!(next_announce(&mut announcements).await.1); - let remote = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast(Path::new("test").unwrap(), None)) - .await - .expect("request timeout") - .expect("broadcast resolves"); + let remote = tokio::time::timeout( + TIMEOUT, + sub_consumer.request_broadcast(Path::new("test").unwrap(), None), + ) + .await + .expect("request timeout") + .expect("broadcast resolves"); async fn recv(sub: &mut moq_net::track::Subscriber, ctx: &str) -> moq_net::group::Consumer { tokio::time::timeout(TIMEOUT, sub.recv_group()) @@ -1413,7 +1469,9 @@ async fn route_reannounce_test(version: Option<&str>) { let publisher_hop = Hop::new(0x4444).unwrap(); let mut initial_hops = moq_net::Hops::new(); initial_hops.push(publisher_hop).unwrap(); - let producer = origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); + let producer = origin + .create_broadcast(Path::new("test").unwrap()) + .expect("create broadcast"); producer .announce(moq_net::origin::Route::default().with_hops(initial_hops)) .expect("announce"); @@ -1468,10 +1526,13 @@ async fn route_reannounce_test(version: Option<&str>) { assert!(active, "expected announce"); let initial = update.route; - let broadcast = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast(Path::new("test").unwrap(), None)) - .await - .expect("request timeout") - .expect("routed broadcast resolves"); + let broadcast = tokio::time::timeout( + TIMEOUT, + sub_consumer.request_broadcast(Path::new("test").unwrap(), None), + ) + .await + .expect("request timeout") + .expect("routed broadcast resolves"); let mut sub = broadcast .track("video") .unwrap() @@ -1730,7 +1791,9 @@ async fn max_age_test(version: &str, published: Option) -> Option) -> Option u64 { #[tokio::test] async fn idle_subscription_releases_the_viewer_count() { let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); + let broadcast = pub_origin + .create_broadcast(Path::new("test").unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let track = broadcast.create_track("video", timed()).expect("create track"); @@ -2648,7 +2735,9 @@ async fn idle_subscription_releases_the_viewer_count() { // The publisher counts viewers through a stats context, exactly like the relay. let registry = moq_net::stats::Registry::new(moq_net::stats::Config::new()); - let stats = registry.tier(moq_net::stats::Tier::default()).session(moq_net::Path::empty()); + let stats = registry + .tier(moq_net::stats::Tier::default()) + .session(moq_net::Path::empty()); let sub_origin = moq_tokio::origin::spawn(); let sub_consumer = sub_origin.consume(); @@ -2914,7 +3003,9 @@ async fn a_dead_session_unannounces_while_the_reconnect_retries() { let url: url::Url = format!("https://localhost:{}", addr.port()).parse().unwrap(); let pub_origin = moq_tokio::origin::spawn(); - let _broadcast = pub_origin.create_broadcast(Path::new("live").unwrap()).expect("create broadcast"); + let _broadcast = pub_origin + .create_broadcast(Path::new("live").unwrap()) + .expect("create broadcast"); _broadcast.announce(Default::default()).expect("create broadcast"); // Accept the first session and hand it back so the test can kill it. Later @@ -3071,7 +3162,9 @@ async fn wildcard_scope_test(version: &str, server_scope: &str) { "room/bob/chat", "lobby/alice/chat", ] { - let broadcast = pub_origin.create_broadcast(Path::new(path).unwrap()).expect("create broadcast"); + let broadcast = pub_origin + .create_broadcast(Path::new(path).unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("announce"); let track = broadcast.create_track("data", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); @@ -3140,10 +3233,13 @@ async fn wildcard_scope_test(version: &str, server_scope: &str) { ); // The granted path serves; the excluded ones are refused before the wire. - let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast(Path::new("room/alice/chat").unwrap(), None)) - .await - .expect("request timed out") - .expect("announced broadcast resolves"); + let bc = tokio::time::timeout( + TIMEOUT, + sub_consumer.request_broadcast(Path::new("room/alice/chat").unwrap(), None), + ) + .await + .expect("request timed out") + .expect("announced broadcast resolves"); let mut sub = bc.track("data").unwrap().subscribe(None).await.expect("subscribe"); let mut group = tokio::time::timeout(TIMEOUT, sub.recv_group()) .await @@ -3158,10 +3254,16 @@ async fn wildcard_scope_test(version: &str, server_scope: &str) { assert_eq!(frame.payload.as_ref(), b"room/alice/chat"); // The server grant excludes bob's chat, so that otherwise-authorized request is // unroutable. Audio and lobby never pass the client's own scope and are unauthorized. - let refused = sub_consumer.request_broadcast(Path::new("room/bob/chat").unwrap(), None).await.err(); + let refused = sub_consumer + .request_broadcast(Path::new("room/bob/chat").unwrap(), None) + .await + .err(); assert!(matches!(refused, Some(moq_net::Error::Unroutable)), "{refused:?}"); for path in ["room/alice/audio", "lobby/alice/chat"] { - let refused = sub_consumer.request_broadcast(Path::new(path).unwrap(), None).await.err(); + let refused = sub_consumer + .request_broadcast(Path::new(path).unwrap(), None) + .await + .err(); assert!( matches!(refused, Some(moq_net::Error::Unauthorized)), "{path}: {refused:?}" @@ -3242,10 +3344,13 @@ async fn publish_only_client_to_subscribe_only_server() { .expect("origin closed"); assert_eq!(update.prefix.as_str(), "allowed/test"); assert!(active, "expected announce, got retraction"); - let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast(Path::new("allowed/test").unwrap(), None)) - .await - .expect("request timed out") - .expect("announced broadcast resolves"); + let bc = tokio::time::timeout( + TIMEOUT, + sub_consumer.request_broadcast(Path::new("allowed/test").unwrap(), None), + ) + .await + .expect("request timed out") + .expect("announced broadcast resolves"); let mut track_sub = bc .track("video") @@ -3359,7 +3464,9 @@ async fn goaway_test(scheme: &str, version: &str, expect_wire_timeout: bool) { // ── publisher (server) ────────────────────────────────────────── let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("failed to create broadcast"); + let broadcast = pub_origin + .create_broadcast(Path::new("test").unwrap()) + .expect("failed to create broadcast"); broadcast .announce(Default::default()) .expect("failed to create broadcast"); @@ -3427,10 +3534,13 @@ async fn goaway_test(scheme: &str, version: &str, expect_wire_timeout: bool) { .expect("origin closed"); assert_eq!(update.prefix.as_str(), "test"); assert!(active, "expected announce, got retraction"); - let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast(Path::new("test").unwrap(), None)) - .await - .expect("request timed out") - .expect("announced broadcast resolves"); + let bc = tokio::time::timeout( + TIMEOUT, + sub_consumer.request_broadcast(Path::new("test").unwrap(), None), + ) + .await + .expect("request timed out") + .expect("announced broadcast resolves"); let mut sub = tokio::time::timeout(TIMEOUT, async { bc.track("video").expect("track handle").subscribe(None).await diff --git a/rs/moq-tokio/tests/integration/receive_credit.rs b/rs/moq-tokio/tests/integration/receive_credit.rs index 10caa376b0e..ddf943f34b2 100644 --- a/rs/moq-tokio/tests/integration/receive_credit.rs +++ b/rs/moq-tokio/tests/integration/receive_credit.rs @@ -79,7 +79,9 @@ async fn setup_through( let version: moq_net::Version = version.parse().expect("version"); let publisher = moq_tokio::origin::spawn(); - let broadcast = publisher.create_broadcast(Path::new("room").unwrap()).expect("broadcast"); + let broadcast = publisher + .create_broadcast(Path::new("room").unwrap()) + .expect("broadcast"); broadcast.announce(Default::default()).expect("announce"); let mut config = moq_tokio::listen::Config::default(); @@ -429,7 +431,9 @@ async fn reversed(version: &str) -> Reversed { ); let publisher = moq_tokio::origin::spawn(); - let broadcast = publisher.create_broadcast(Path::new("room").unwrap()).expect("broadcast"); + let broadcast = publisher + .create_broadcast(Path::new("room").unwrap()) + .expect("broadcast"); broadcast.announce(Default::default()).expect("announce"); let subscriber = moq_tokio::origin::spawn(); let session = |conn: driver::Connection| { diff --git a/rs/moq-tokio/tests/integration/subscription_end_integrity.rs b/rs/moq-tokio/tests/integration/subscription_end_integrity.rs index 3f2f9441528..50682829e44 100644 --- a/rs/moq-tokio/tests/integration/subscription_end_integrity.rs +++ b/rs/moq-tokio/tests/integration/subscription_end_integrity.rs @@ -50,7 +50,9 @@ const STALL: Duration = Duration::from_millis(300); /// the subscriber read and the error its subscription ended with, if any. async fn round(drop_session: bool) -> (usize, Option) { let pub_origin = moq_tokio::origin::spawn(); - let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); + let broadcast = pub_origin + .create_broadcast(Path::new("test").unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("announce"); let track = broadcast.create_track("video", timed()).expect("create track"); diff --git a/rs/moq-tokio/tests/integration/unannounce.rs b/rs/moq-tokio/tests/integration/unannounce.rs index 67315127fbe..83b9fb30454 100644 --- a/rs/moq-tokio/tests/integration/unannounce.rs +++ b/rs/moq-tokio/tests/integration/unannounce.rs @@ -11,9 +11,15 @@ use moq_tokio::moq_net; /// publisher's demand to go unused. async fn release(unannounce: bool, settle: bool) { let origin = moq_tokio::origin::spawn(); - let broadcast = origin.publish(Path::new("a/b").unwrap(), moq_net::origin::Route::default()).unwrap(); + let broadcast = origin + .publish(Path::new("a/b").unwrap(), moq_net::origin::Route::default()) + .unwrap(); let track = broadcast.create_track("t", None).unwrap(); - let consumer = origin.consume().request_broadcast(Path::new("a/b").unwrap(), None).await.unwrap(); + let consumer = origin + .consume() + .request_broadcast(Path::new("a/b").unwrap(), None) + .await + .unwrap(); let sub = consumer.track("t").unwrap().subscribe(None).await.unwrap(); crate::wanted(track.demand()).await.unwrap(); diff --git a/rs/moq-uring/benches/session_lite.rs b/rs/moq-uring/benches/session_lite.rs index 9d7b8b7ba4a..12b91b7ba7c 100644 --- a/rs/moq-uring/benches/session_lite.rs +++ b/rs/moq-uring/benches/session_lite.rs @@ -112,7 +112,9 @@ mod linux { }); }); - let broadcast = pub_origin.create_broadcast(Path::new("bench").unwrap()).expect("create broadcast"); + let broadcast = pub_origin + .create_broadcast(Path::new("bench").unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let track = broadcast.create_track("data", timed()).expect("create track"); @@ -176,7 +178,10 @@ mod linux { }); let bc = { let consumer = sub_origin.consume(); - consumer.routed(Path::new("bench").unwrap()).await.expect("broadcast announced"); + consumer + .routed(Path::new("bench").unwrap()) + .await + .expect("broadcast announced"); consumer .request_broadcast(Path::new("bench").unwrap(), None) .await diff --git a/rs/moq-uring/tests/integration/receive_credit.rs b/rs/moq-uring/tests/integration/receive_credit.rs index b30f49e1f91..2f0d744c71c 100644 --- a/rs/moq-uring/tests/integration/receive_credit.rs +++ b/rs/moq-uring/tests/integration/receive_credit.rs @@ -12,8 +12,8 @@ #![cfg(all(target_os = "linux", feature = "quic"))] -use moq_net::Path; use crate::support; +use moq_net::Path; use std::net::UdpSocket; use std::task::Poll; @@ -90,7 +90,9 @@ fn partial_frame_gives_way() { }); }); - let broadcast = pub_origin.create_broadcast(Path::new("room").unwrap()).expect("create broadcast"); + let broadcast = pub_origin + .create_broadcast(Path::new("room").unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("announce"); let low = broadcast.create_track("low", timed()).expect("low track"); let high = broadcast.create_track("high", timed()).expect("high track"); @@ -158,9 +160,13 @@ fn partial_frame_gives_way() { within(&handle, "the route", consumer.routed(Path::new("room").unwrap())) .await .expect("routed"); - let remote = within(&handle, "the broadcast", consumer.request_broadcast(Path::new("room").unwrap(), None)) - .await - .expect("broadcast resolves"); + let remote = within( + &handle, + "the broadcast", + consumer.request_broadcast(Path::new("room").unwrap(), None), + ) + .await + .expect("broadcast resolves"); let subscribe = |name: &str, priority: i8| { let track = remote.track(name).expect("track"); async move { @@ -314,9 +320,13 @@ fn javascript_partial_frame_gives_way() { within(&handle, "the route", consumer.routed(Path::new("room").unwrap())) .await .expect("routed"); - let remote = within(&handle, "the broadcast", consumer.request_broadcast(Path::new("room").unwrap(), None)) - .await - .expect("broadcast resolves"); + let remote = within( + &handle, + "the broadcast", + consumer.request_broadcast(Path::new("room").unwrap(), None), + ) + .await + .expect("broadcast resolves"); let subscribe = |name: &str, priority: i8| { let track = remote.track(name).expect("track"); async move { diff --git a/rs/moq-uring/tests/integration/session.rs b/rs/moq-uring/tests/integration/session.rs index 496ecc23bec..7ef18905df4 100644 --- a/rs/moq-uring/tests/integration/session.rs +++ b/rs/moq-uring/tests/integration/session.rs @@ -10,8 +10,8 @@ #![cfg(all(target_os = "linux", feature = "quic"))] -use moq_net::Path; use crate::support; +use moq_net::Path; use std::net::UdpSocket; @@ -57,7 +57,9 @@ fn lite_session_over_the_worker() { // Content ready before anyone connects: one broadcast, one track, one // finished group. - let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); + let broadcast = pub_origin + .create_broadcast(Path::new("test").unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let track = broadcast.create_track("data", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); @@ -136,7 +138,10 @@ fn lite_session_over_the_worker() { let bc = { let consumer = sub.consume(); - consumer.routed(Path::new("test").unwrap()).await.expect("broadcast announced"); + consumer + .routed(Path::new("test").unwrap()) + .await + .expect("broadcast announced"); consumer .request_broadcast(Path::new("test").unwrap(), None) .await @@ -196,7 +201,9 @@ fn two_lite_sessions_share_the_server_socket() { }); }); - let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); + let broadcast = pub_origin + .create_broadcast(Path::new("test").unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let track = broadcast.create_track("data", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); @@ -277,7 +284,10 @@ fn two_lite_sessions_share_the_server_socket() { let bc = { let consumer = sub.consume(); - consumer.routed(Path::new("test").unwrap()).await.expect("broadcast announced"); + consumer + .routed(Path::new("test").unwrap()) + .await + .expect("broadcast announced"); consumer .request_broadcast(Path::new("test").unwrap(), None) .await diff --git a/rs/moq-uring/tests/integration/web.rs b/rs/moq-uring/tests/integration/web.rs index 74c7c11cc53..8dcb454bd92 100644 --- a/rs/moq-uring/tests/integration/web.rs +++ b/rs/moq-uring/tests/integration/web.rs @@ -7,8 +7,8 @@ #![cfg(all(target_os = "linux", feature = "quic"))] -use moq_net::Path; use crate::support; +use moq_net::Path; use std::net::UdpSocket; @@ -265,7 +265,9 @@ fn lite_session_over_webtransport() { rt.block_on(moq_net::time::run(pub_driver)); }); - let broadcast = pub_origin.create_broadcast(Path::new("test").unwrap()).expect("create broadcast"); + let broadcast = pub_origin + .create_broadcast(Path::new("test").unwrap()) + .expect("create broadcast"); broadcast.announce(Default::default()).expect("create broadcast"); let track = broadcast.create_track("data", timed()).expect("create track"); let mut group = track.append_group().expect("append group"); @@ -295,7 +297,10 @@ fn lite_session_over_webtransport() { let bc = { let consumer = sub_origin.consume(); - consumer.routed(Path::new("test").unwrap()).await.expect("broadcast announced"); + consumer + .routed(Path::new("test").unwrap()) + .await + .expect("broadcast announced"); consumer .request_broadcast(Path::new("test").unwrap(), None) .await diff --git a/rs/moq-video/src/decode/decoder.rs b/rs/moq-video/src/decode/decoder.rs index ee4f90fd92f..105b8334e04 100644 --- a/rs/moq-video/src/decode/decoder.rs +++ b/rs/moq-video/src/decode/decoder.rs @@ -653,7 +653,11 @@ mod tests { .unwrap(); producer.finish().unwrap(); - let broadcast = origin.consume().request_broadcast(Path::new("test").unwrap(), None).await.unwrap(); + let broadcast = origin + .consume() + .request_broadcast(Path::new("test").unwrap(), None) + .await + .unwrap(); let catalog = moq_mux::catalog::Consumer::<()>::new(&broadcast, moq_mux::catalog::CatalogFormat::Hang) .await .unwrap(); diff --git a/rs/moq-wasm/src/lib.rs b/rs/moq-wasm/src/lib.rs index f21c58317d1..3f7f277522c 100644 --- a/rs/moq-wasm/src/lib.rs +++ b/rs/moq-wasm/src/lib.rs @@ -158,9 +158,10 @@ impl Session { let session = self.inner.clone(); let consumer = self.consumer.clone(); future_to_promise(async move { + let path = moq_net::PathOwned::try_from(path).map_err(js_err)?; let request = pin!(async { - consumer.routed(path.as_str()).await?; - consumer.request_broadcast(path.as_str(), None).await.ok() + consumer.routed(&path).await?; + consumer.request_broadcast(&path, None).await.ok() }); // The origin outlives the session, so its wait alone never ends on a close. let closed = pin!(session.closed()); diff --git a/test/interop/clients/rust/audio.rs b/test/interop/clients/rust/audio.rs index c499ca13d64..06883237639 100644 --- a/test/interop/clients/rust/audio.rs +++ b/test/interop/clients/rust/audio.rs @@ -41,7 +41,9 @@ async fn main() -> anyhow::Result<()> { .established() .await?; - let broadcast = consumer.routed_broadcast(moq_tokio::moq_net::Path::new(&args[2])?).await?; + let broadcast = consumer + .routed_broadcast(moq_tokio::moq_net::Path::new(&args[2])?) + .await?; let source = moq_mux::Source::new(consumer, broadcast.clone()); let mut catalogs = moq_mux::catalog::Consumer::<()>::new(&broadcast, CatalogFormat::Hang).await?; // A lazy publisher (the browser) may add audio in a later catalog update. diff --git a/test/interop/clients/rust/finish.rs b/test/interop/clients/rust/finish.rs index d22f93a4a3f..999105d1e70 100644 --- a/test/interop/clients/rust/finish.rs +++ b/test/interop/clients/rust/finish.rs @@ -161,7 +161,9 @@ async fn main() -> anyhow::Result<()> { break; } } - let health = consumer.routed_broadcast(moq_net::PathOwned::try_from(format!("{}.health", args.broadcast))?).await?; + let health = consumer + .routed_broadcast(moq_net::PathOwned::try_from(format!("{}.health", args.broadcast))?) + .await?; let mut track = health.track("live")?.subscribe(None).await?; let mut group = track.recv_group().await?.context("no health group")?; let frame = group.read_frame().await?.context("no health frame")?; diff --git a/test/interop/clients/rust/goaway-client.rs b/test/interop/clients/rust/goaway-client.rs index 869a543cb60..84486ad9b3c 100644 --- a/test/interop/clients/rust/goaway-client.rs +++ b/test/interop/clients/rust/goaway-client.rs @@ -43,7 +43,9 @@ async fn main() -> anyhow::Result<()> { // Drafts 14 and 16 carry no epoch, so nothing proves the replacement serves the same // publisher: the held reader ends with the old route and the application requests again. let legacy = ["moq-transport-14", "moq-transport-16"].contains(&version.as_str()); - let broadcast = consumer.routed_broadcast(moq_tokio::moq_net::Path::new("handover")?).await?; + let broadcast = consumer + .routed_broadcast(moq_tokio::moq_net::Path::new("handover")?) + .await?; let mut track = broadcast.track("video")?.subscribe(None).await?; let input = child.stdin.as_mut().context("stdin")?; for sequence in 0..2 { @@ -54,7 +56,9 @@ async fn main() -> anyhow::Result<()> { ); // The server wrote this group just after cutting the original, so only the // replacement, already its largest, can serve it. - let broadcast = consumer.routed_broadcast(moq_tokio::moq_net::Path::new("handover")?).await?; + let broadcast = consumer + .routed_broadcast(moq_tokio::moq_net::Path::new("handover")?) + .await?; track = broadcast.track("video")?.subscribe(None).await?; } let mut group = track.recv_group().await?.context("reader ended during GOAWAY")?; @@ -68,7 +72,9 @@ async fn main() -> anyhow::Result<()> { input.write_all(b"first group\n").await?; // The first endpoint's publisher scope excludes this broadcast, so its bytes // prove that the replacement session is serving beyond its SETUP handshake. - let ready = consumer.routed_broadcast(moq_tokio::moq_net::Path::new("replacement")?).await?; + let ready = consumer + .routed_broadcast(moq_tokio::moq_net::Path::new("replacement")?) + .await?; let mut marker = ready.track("ready")?.subscribe(None).await?; let mut marker = marker.recv_group().await?.context("replacement marker")?; ensure!( From 3c1b809011fb1baf1233e8941e3ba866be97f1e5 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sun, 25 Oct 2026 00:00:48 -0700 Subject: [PATCH 09/67] chore(quest): claim quest/m1/ietf-drop/d14-17.md Quest-Claim: 1835d705d02d19b4 From 47ffd180fd070f3daa2ee9031d954cb79021b27c Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sun, 25 Oct 2026 02:23:59 -0700 Subject: [PATCH 10/67] wip(net): drop moq-transport drafts 14-17 from the moq-net library Tests, the relay, JS, CI, and docs still to follow. Co-Authored-By: Claude Opus 5.5 --- rs/moq-net/benches/request-ids.rs | 34 +- rs/moq-net/src/client.rs | 201 +- rs/moq-net/src/coding/codes.rs | 16 +- rs/moq-net/src/coding/encode.rs | 2 +- rs/moq-net/src/coding/reader.rs | 6 - rs/moq-net/src/coding/varint.rs | 78 +- rs/moq-net/src/fuzz.rs | 48 +- rs/moq-net/src/ietf/active_count.rs | 30 +- rs/moq-net/src/ietf/adapter.rs | 2701 -------------------- rs/moq-net/src/ietf/auth.rs | 52 +- rs/moq-net/src/ietf/cluster.rs | 40 +- rs/moq-net/src/ietf/control.rs | 449 +--- rs/moq-net/src/ietf/datagram.rs | 55 +- rs/moq-net/src/ietf/epoch.rs | 27 +- rs/moq-net/src/ietf/error.rs | 601 +---- rs/moq-net/src/ietf/fetch.rs | 382 +-- rs/moq-net/src/ietf/filter.rs | 20 +- rs/moq-net/src/ietf/flate.rs | 39 +- rs/moq-net/src/ietf/goaway.rs | 41 +- rs/moq-net/src/ietf/group.rs | 159 +- rs/moq-net/src/ietf/hidden.rs | 2 +- rs/moq-net/src/ietf/max_age.rs | 2 +- rs/moq-net/src/ietf/message.rs | 53 +- rs/moq-net/src/ietf/mod.rs | 16 +- rs/moq-net/src/ietf/namespace.rs | 9 +- rs/moq-net/src/ietf/object.rs | 88 +- rs/moq-net/src/ietf/parameters.rs | 543 +--- rs/moq-net/src/ietf/properties.rs | 65 +- rs/moq-net/src/ietf/publish.rs | 397 +-- rs/moq-net/src/ietf/publish_namespace.rs | 199 +- rs/moq-net/src/ietf/publisher.rs | 1236 +++------ rs/moq-net/src/ietf/publisher/tracks.rs | 53 +- rs/moq-net/src/ietf/request.rs | 238 +- rs/moq-net/src/ietf/request_stream.rs | 406 +-- rs/moq-net/src/ietf/request_update.rs | 28 +- rs/moq-net/src/ietf/session.rs | 722 ++---- rs/moq-net/src/ietf/solicit.rs | 2 +- rs/moq-net/src/ietf/subscribe.rs | 713 ++---- rs/moq-net/src/ietf/subscribe_namespace.rs | 387 +-- rs/moq-net/src/ietf/subscribe_tracks.rs | 34 +- rs/moq-net/src/ietf/subscriber.rs | 1322 +++------- rs/moq-net/src/ietf/subscriber/tracks.rs | 50 +- rs/moq-net/src/ietf/token.rs | 25 +- rs/moq-net/src/ietf/track.rs | 165 +- rs/moq-net/src/ietf/version.rs | 8 - rs/moq-net/src/lite/ietf.rs | 25 +- rs/moq-net/src/model/origin.rs | 52 +- rs/moq-net/src/server.rs | 253 +- rs/moq-net/src/session.rs | 27 +- rs/moq-net/src/setup.rs | 176 +- rs/moq-net/src/test_interop.rs | 52 +- rs/moq-net/src/transport/boxed.rs | 2 + rs/moq-net/src/version.rs | 40 +- 53 files changed, 1937 insertions(+), 10434 deletions(-) delete mode 100644 rs/moq-net/src/ietf/adapter.rs diff --git a/rs/moq-net/benches/request-ids.rs b/rs/moq-net/benches/request-ids.rs index e540905c7ed..d17be0208d9 100644 --- a/rs/moq-net/benches/request-ids.rs +++ b/rs/moq-net/benches/request-ids.rs @@ -1,36 +1,8 @@ -//! Request-ID admission cost across independent sessions and reordered windows. +//! Request-ID admission cost across independent sessions and reordered arrivals. use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main}; use std::{hint::black_box, time::Duration}; -fn request_ids(c: &mut Criterion) { - let mut group = c.benchmark_group("request-ids"); - group.sample_size(20); - group.warm_up_time(Duration::from_millis(200)); - group.measurement_time(Duration::from_secs(1)); - // Up to the production window, which the session sizes to twice its 120,000 caps. - for mode in ["ordered", "reordered", "scattered"] { - for sessions in [1, 8, 32] { - for window in [8, 128, 240_000] { - let ids = ids(mode, window); - println!( - "admitted,{mode},{sessions},{window},{}", - moq_net::fuzz::request_ids(window, &ids) * sessions - ); - group.bench_function(BenchmarkId::new(mode, format!("{sessions}x{window}")), |b| { - b.iter(|| { - let accepted: usize = (0..sessions) - .map(|_| moq_net::fuzz::request_ids(window, black_box(&ids))) - .sum(); - black_box(accepted) - }); - }); - } - } - } - group.finish(); -} - -/// Draft-17+ admission, which spends IDs without a window but remembers skipped runs. +/// Admission spends IDs without a window but remembers skipped runs. fn request_history(c: &mut Criterion) { let mut group = c.benchmark_group("modern-request-ids"); group.sample_size(20); @@ -77,5 +49,5 @@ fn ids(mode: &str, window: u64) -> Vec { } } -criterion_group!(benches, request_ids, request_history); +criterion_group!(benches, request_history); criterion_main!(benches); diff --git a/rs/moq-net/src/client.rs b/rs/moq-net/src/client.rs index be90008de04..9beb9325fa5 100644 --- a/rs/moq-net/src/client.rs +++ b/rs/moq-net/src/client.rs @@ -3,8 +3,7 @@ use crate::origin; use crate::time::{Deadlines, Instant}; use crate::transport::poll::Session as _; use crate::{ - ALPN_14, ALPN_15, ALPN_16, ALPN_17, ALPN_18, ALPN_19, ALPN_20, ALPN_21, ALPN_22, ALPN_LITE, ALPN_LITE_03, - ALPN_LITE_04, ALPN_LITE_05, ALPN_LITE_06, ALPN_LITE_07_WIP, Consume, Error, NEGOTIATED, Session, Version, Versions, + ALPN_18, ALPN_19, ALPN_20, ALPN_21, ALPN_22, ALPN_LITE, ALPN_LITE_03, ALPN_LITE_04, ALPN_LITE_05, ALPN_LITE_06, ALPN_LITE_07_WIP, Consume, Error, NEGOTIATED, Session, Version, Versions, coding::{self, Decode, Encode, Stream}, ietf, lite, setup, stats, }; @@ -312,22 +311,19 @@ impl Client { let peer_hop = self.assigned_hop(); let (publish, subscribe) = self.origins(peer_hop); - // If ALPN was used to negotiate the version, use the appropriate encoding. - // Default to IETF 14 if no ALPN was used and we'll negotiate the version later. - let (encoding, supported) = match session.protocol() { - Some(alpn @ (ALPN_22 | ALPN_21 | ALPN_20 | ALPN_19 | ALPN_18 | ALPN_17)) => { + let supported = match session.protocol() { + Some(alpn @ (ALPN_22 | ALPN_21 | ALPN_20 | ALPN_19 | ALPN_18)) => { let draft = match alpn { ALPN_22 => ietf::Version::Draft22, ALPN_21 => ietf::Version::Draft21, ALPN_20 => ietf::Version::Draft20, ALPN_19 => ietf::Version::Draft19, - ALPN_18 => ietf::Version::Draft18, - _ => ietf::Version::Draft17, + _ => ietf::Version::Draft18, }; let v = self.versions.select(Version::Ietf(draft)).ok_or(Error::Version)?; - // Draft-17+: SETUP is exchanged by the connection driver. + // SETUP is exchanged by the connection driver. // We advertise the request path in our SETUP for URL-less transports. // The peer's SETUP decides whether AUTH is negotiated. A handle that does not // offer it keeps the option out of our SETUP and presents no credential. @@ -338,8 +334,6 @@ impl Client { stats: self.stats.clone(), limits: self.limits, session: session.clone(), - setup: None, - request_id_max: None, client: true, publish: publish.clone(), subscribe: subscribe.clone(), @@ -374,27 +368,6 @@ impl Client { }, )); } - Some(ALPN_16) => { - let v = self - .versions - .select(Version::Ietf(ietf::Version::Draft16)) - .ok_or(Error::Version)?; - (v, v.into()) - } - Some(ALPN_15) => { - let v = self - .versions - .select(Version::Ietf(ietf::Version::Draft15)) - .ok_or(Error::Version)?; - (v, v.into()) - } - Some(ALPN_14) => { - let v = self - .versions - .select(Version::Ietf(ietf::Version::Draft14)) - .ok_or(Error::Version)?; - (v, v.into()) - } Some(alpn @ (ALPN_LITE_05 | ALPN_LITE_06 | ALPN_LITE_07_WIP)) => { let version = match alpn { ALPN_LITE_07_WIP => lite::Version::Lite07, @@ -416,46 +389,18 @@ impl Client { .ok_or(Error::Version)?; return self.start_lite(runtime, session, lite::Version::Lite03, peer_hop); } - Some(ALPN_LITE) | None => { - let supported = self.versions.filter(&NEGOTIATED.into()).ok_or(Error::Version)?; - (Version::Ietf(ietf::Version::Draft14), supported) - } + // No ALPN, or `moql`: negotiate moq-lite 01/02 in a bidi SETUP. + Some(ALPN_LITE) | None => self.versions.filter(&NEGOTIATED.into()).ok_or(Error::Version)?, Some(p) => return Err(Error::UnknownAlpn(p.to_string())), }; + // Lite 01 and 02 frame the SETUP identically, so either encodes it. + let encoding = *supported.iter().next().ok_or(Error::Version)?; let mut stream = Stream::open(&mut session, encoding).await?.with_stats(&self.stats); - // The encoding is always an IETF version for SETUP negotiation. - let ietf_encoding = ietf::Version::try_from(encoding).map_err(|_| Error::Version)?; - - let mut parameters = ietf::Parameters::default(); - // The server's requests, admitted up to our limits and granted back as they close. - parameters.set_varint( - ietf::ParameterVarInt::MaxRequestId, - ietf::initial_max_request_id(self.limits.window(), false), - ); - if let Some(implementation) = self.implementation() { - parameters.set_bytes(ietf::ParameterBytes::Implementation, implementation.into_bytes()); - } - // Advertise the request path in-band (draft 14-16), same as the lite-05 SETUP. - if let Some(path) = &self.setup_path { - parameters.set_bytes(ietf::ParameterBytes::Path, path.clone().into_bytes()); - } - if let Some(authority) = &self.setup_authority { - parameters.set_bytes(ietf::ParameterBytes::Authority, authority.clone().into_bytes()); - } - if self.extensions.solicit { - ietf::solicit::into_setup(&mut parameters, ietf_encoding); - } - ietf::hidden::into_setup(&mut parameters, ietf_encoding); - ietf::max_age::into_setup(&mut parameters, ietf_encoding); - ietf::active_count::into_setup(&mut parameters, ietf_encoding); - ietf::flate::into_setup(&mut parameters, ietf_encoding); - let parameters = parameters.encode_bytes(ietf_encoding)?; - let client = setup::Client { versions: supported.clone().into(), - parameters, + parameters: lite::Parameters::default().encode_bytes(lite::Version::Lite01)?, }; stream.writer.encode(&client).await?; @@ -467,109 +412,42 @@ impl Client { .find(|v| coding::Version::from(**v) == server.version) .copied() .ok_or(Error::Version)?; - - let (recv_bw, protocol, goaway, auth, estimate, peer_implementation) = match version { - Version::Lite(v) => { - let stream = stream.with_version(v); - let start = lite::start(lite::Config { - runtime: runtime.clone(), - stats: self.stats.clone(), - client: true, - limits: self.limits, - session: session.clone(), - setup_stream: Some(stream), - publish: publish.clone(), - subscribe: subscribe.clone(), - peer_hop: Some(peer_hop), - version: v, - // This path only handles versions negotiated via the bidi SETUP exchange - // (pre-lite-05), which have no Setup Stream. - our_setup: lite::Setup::default(), - peer_setup: None, - // Negotiated over the bidi SETUP: lite 01/02, which carry no AUTH. - auth: self.link(v.has_auth(), false)?, - })?; - - ( - start.recv_bandwidth, - crate::driver::Protocol::Lite(Box::new(start.driver)), - start.goaway, - start.auth, - Some(start.estimate), - start.peer_implementation, - ) - } - Version::Ietf(v) => { - // Decode the parameters to get the initial request ID and what the server - // requires of us. - let (parameters, _) = ietf::Parameters::decode_slice(&server.parameters, v)?; - let request_id_max = parameters - .get_varint(ietf::ParameterVarInt::MaxRequestId) - .map(ietf::RequestId); - let peer_declared = ietf::peer::Peer { - solicit: ietf::solicit::from_setup(¶meters, v)?, - hidden: ietf::hidden::from_setup(¶meters, v), - max_age: ietf::max_age::from_setup(¶meters, v), - active_count: ietf::active_count::from_setup(¶meters, v), - flate: ietf::flate::from_setup(¶meters, v)?, - ..Default::default() - }; - let peer_implementation = setup::PeerImplementation::known(setup::decode_implementation( - parameters.get_bytes(ietf::ParameterBytes::Implementation), - )?); - - let stream = stream.with_version(v); - // Draft 14-16 carry no AUTH, but the session is still limited through this handle. - let auth = self.link(false, true)?; - // Draft 14-16: the path rode in the bidi SETUP above, not the uni one. - let (protocol, goaway) = ietf::start(ietf::Config { - runtime: runtime.clone(), - stats: self.stats.clone(), - limits: self.limits, - session: session.clone(), - setup: Some(stream), - request_id_max, - client: true, - publish: publish.clone(), - subscribe: subscribe.clone(), - peer_hop: Some(peer_hop), - cost: self.cost, - version: v, - path: None, - authority: None, - peer_setup_stream: None, - peer_declared: Some(peer_declared), - auth: auth.clone(), - early_unis: Vec::new(), - extensions: self.extensions, - // Already sent on the bidi SETUP above. - implementation: None, - peer_implementation: peer_implementation.clone(), - })?; - ( - None, - crate::driver::Protocol::Ietf(protocol), - goaway, - auth, - None, - peer_implementation, - ) - } + let Version::Lite(v) = version else { + return Err(Error::Version); }; + let stream = stream.with_version(v); + let start = lite::start(lite::Config { + runtime: runtime.clone(), + stats: self.stats.clone(), + client: true, + limits: self.limits, + session: session.clone(), + setup_stream: Some(stream), + publish: publish.clone(), + subscribe: subscribe.clone(), + peer_hop: Some(peer_hop), + version: v, + // The bidi SETUP exchange predates lite-05, so there is no Setup Stream. + our_setup: lite::Setup::default(), + peer_setup: None, + // Lite 01/02 carry no AUTH. + auth: self.link(v.has_auth(), false)?, + })?; + Ok(Session::new( runtime, session, version, - recv_bw, - protocol, + start.recv_bandwidth, + crate::driver::Protocol::Lite(Box::new(start.driver)), crate::session::Handles { stats: self.stats.clone(), - goaway, - auth, - estimate, + goaway: start.goaway, + auth: start.auth, + estimate: Some(start.estimate), bandwidth: self.bandwidth(), - peer_implementation, + peer_implementation: start.peer_implementation, }, )) } @@ -864,7 +742,6 @@ mod tests { server .encode( &mut crate::coding::Encoder::new(&mut encoded, (Version::Ietf(ietf::Version::Draft14)).into()), - Version::Ietf(ietf::Version::Draft14), ) .unwrap(); @@ -884,7 +761,6 @@ mod tests { Version::Lite(lite::Version::Lite03), Version::Lite(lite::Version::Lite02), Version::Lite(lite::Version::Lite01), - Version::Ietf(ietf::Version::Draft14), ] .into(), ); @@ -897,7 +773,6 @@ mod tests { let mut setup_bytes = Bytes::from(fake.control_writes()); let setup = crate::coding::decode_buf( &mut setup_bytes, - Version::Ietf(ietf::Version::Draft14), setup::Client::decode, ) .unwrap(); @@ -907,7 +782,6 @@ mod tests { vec![ Version::Lite(lite::Version::Lite02), Version::Lite(lite::Version::Lite01), - Version::Ietf(ietf::Version::Draft14), ] ); @@ -960,7 +834,6 @@ mod tests { .with_versions( [ Version::Lite(lite::Version::Lite01), - Version::Ietf(ietf::Version::Draft14), ] .into(), ) diff --git a/rs/moq-net/src/coding/codes.rs b/rs/moq-net/src/coding/codes.rs index 2bd51bc3ce4..75512807ca9 100644 --- a/rs/moq-net/src/coding/codes.rs +++ b/rs/moq-net/src/coding/codes.rs @@ -65,14 +65,14 @@ impl StreamCodes for lite::Version { } } -/// moq-transport's registry, which is per draft. +/// moq-transport's registry. impl StreamCodes for ietf::Version { fn encode_stream_code(&self, err: &StreamError) -> u32 { - ietf::error::to_stream_code(err, *self) + ietf::error::to_stream_code(err) } fn decode_stream_code(&self, code: u32) -> StreamError { - ietf::error::from_stream_code(code, *self) + ietf::error::from_stream_code(code) } } @@ -120,16 +120,8 @@ mod tests { assert_eq!(lite.encode_stream_code(&StreamError::Cancel), ietf::error::CANCELLED); assert_eq!(ietf.encode_stream_code(&StreamError::Cancel), ietf::error::CANCELLED); - // GOING_AWAY is moq-lite's 0x4 and draft-20's, but draft-17 gives 0x4 to - // UNKNOWN_OBJECT_STATUS, so it is not sent there and not read back there. - let draft17 = crate::Version::Ietf(ietf::Version::Draft17); assert_eq!(lite.decode_stream_code(0x4), StreamError::GoingAway); assert_eq!(ietf.decode_stream_code(0x4), StreamError::GoingAway); - assert_eq!(draft17.decode_stream_code(0x4), StreamError::Unknown(0x4)); - assert_eq!( - draft17.encode_stream_code(&StreamError::GoingAway), - ietf::error::INTERNAL_ERROR - ); } /// NOT_FETCHABLE is lite-07's: an earlier peer is told NOT_FOUND, the miss it would @@ -178,7 +170,7 @@ mod tests { /// connection closed. Native transport adapters supply that metadata themselves. #[test] fn a_virtual_stream_close_does_not_claim_the_connection_closed() { - let version = ietf::Version::Draft16; + let version = ietf::Version::Draft18; assert!(matches!(version.transport_error(Error::Closed), Error::Transport(_))); assert!(matches!( version.transport_error(Error::IdleTimeout), diff --git a/rs/moq-net/src/coding/encode.rs b/rs/moq-net/src/coding/encode.rs index b84d437e2ba..a6ccd7034f1 100644 --- a/rs/moq-net/src/coding/encode.rs +++ b/rs/moq-net/src/coding/encode.rs @@ -90,7 +90,7 @@ impl<'a> Encoder<'a> { } /// Write a big-endian `u16`. - #[cfg_attr(not(feature = "async"), allow(dead_code, reason = "async-only"))] + #[cfg(test)] pub fn u16(&mut self, v: u16) { self.buf.extend_from_slice(&v.to_be_bytes()); } diff --git a/rs/moq-net/src/coding/reader.rs b/rs/moq-net/src/coding/reader.rs index 77f60c36862..8544ac7f0ff 100644 --- a/rs/moq-net/src/coding/reader.rs +++ b/rs/moq-net/src/coding/reader.rs @@ -413,11 +413,6 @@ impl Reader { Poll::Ready(Ok(bytes)) } - /// Read exactly the given number of bytes from the stream. - pub async fn read_exact(&mut self, size: usize) -> Result { - std::future::poll_fn(|cx| self.poll_read_exact(cx, size)).await - } - /// Poll until the stream is closed, erroring if there are any additional bytes. pub fn poll_closed(&mut self, cx: &mut Context<'_>) -> Poll> { if ready!(self.poll_has_more(cx))? { @@ -777,7 +772,6 @@ mod tests { for version in [ Version::Lite(lite::Version::Lite01), Version::Lite(lite::Version::Lite02), - Version::Ietf(ietf::Version::Draft14), ] { let prefix: &'static [u8] = if version.is_lite() { &[0x20, 0] } else { &[0x20, 0, 0] }; refuses_frame::(prefix, version, false); diff --git a/rs/moq-net/src/coding/varint.rs b/rs/moq-net/src/coding/varint.rs index 33e4ec6945d..0228cef32a3 100644 --- a/rs/moq-net/src/coding/varint.rs +++ b/rs/moq-net/src/coding/varint.rs @@ -23,10 +23,7 @@ pub(crate) enum Form { /// QUIC's two-bit length tag, up to [`MAX_QUIC`]. Quic, /// Leading one bits count the length, up to `u64::MAX`. - LeadingOnes { - /// Whether the 7-byte form (`1111110x`) is accepted on decode, which draft-17 forbids. - seven: bool, - }, + LeadingOnes, } impl From for Form { @@ -40,18 +37,14 @@ impl From for Form { | lite::Version::Lite06 => Self::Quic, // Lite-07 is only reached through its ALPN, so the form is known before the // first byte of any stream. - _ => Self::LeadingOnes { seven: true }, + _ => Self::LeadingOnes, } } } impl From for Form { - fn from(version: ietf::Version) -> Self { - match version { - ietf::Version::Draft14 | ietf::Version::Draft15 | ietf::Version::Draft16 => Self::Quic, - ietf::Version::Draft17 => Self::LeadingOnes { seven: false }, - _ => Self::LeadingOnes { seven: true }, - } + fn from(_: ietf::Version) -> Self { + Self::LeadingOnes } } @@ -83,15 +76,15 @@ pub(crate) fn size(value: u64, form: Form) -> Result { Form::Quic if hi == 0 && lo < 1 << 30 => 4, Form::Quic if hi < 1 << 30 => 8, Form::Quic => return Err(BoundsExceeded), - Form::LeadingOnes { .. } if hi == 0 && lo < 1 << 7 => 1, - Form::LeadingOnes { .. } if hi == 0 && lo < 1 << 14 => 2, - Form::LeadingOnes { .. } if hi == 0 && lo < 1 << 21 => 3, - Form::LeadingOnes { .. } if hi == 0 && lo < 1 << 28 => 4, - Form::LeadingOnes { .. } if hi < 1 << 3 => 5, - Form::LeadingOnes { .. } if hi < 1 << 10 => 6, + Form::LeadingOnes if hi == 0 && lo < 1 << 7 => 1, + Form::LeadingOnes if hi == 0 && lo < 1 << 14 => 2, + Form::LeadingOnes if hi == 0 && lo < 1 << 21 => 3, + Form::LeadingOnes if hi == 0 && lo < 1 << 28 => 4, + Form::LeadingOnes if hi < 1 << 3 => 5, + Form::LeadingOnes if hi < 1 << 10 => 6, // The 7-byte form is skipped: one byte longer, but legal on every draft. - Form::LeadingOnes { .. } if hi < 1 << 24 => 8, - Form::LeadingOnes { .. } => 9, + Form::LeadingOnes if hi < 1 << 24 => 8, + Form::LeadingOnes => 9, }) } @@ -103,7 +96,7 @@ pub(crate) fn size(value: u64, form: Form) -> Result { pub(super) fn write(value: u64, form: Form, out: &mut Vec) -> Result<(), BoundsExceeded> { match form { Form::Quic => write_quic(value, out), - Form::LeadingOnes { .. } => { + Form::LeadingOnes => { write_leading_ones(value, out); Ok(()) } @@ -172,7 +165,7 @@ fn write_leading_ones(value: u64, out: &mut Vec) { pub(super) fn read(buf: &[u8], form: Form) -> Result<(u64, &[u8]), DecodeError> { match form { Form::Quic => read_quic(buf), - Form::LeadingOnes { seven } => read_leading_ones(buf, seven), + Form::LeadingOnes => read_leading_ones(buf), } } @@ -201,7 +194,7 @@ fn read_quic(buf: &[u8]) -> Result<(u64, &[u8]), DecodeError> { #[cfg_attr(target_arch = "wasm32", inline)] #[cfg_attr(not(target_arch = "wasm32"), inline(always))] #[cfg_attr(not(feature = "async"), allow(dead_code, reason = "async-only"))] -fn read_leading_ones(buf: &[u8], seven: bool) -> Result<(u64, &[u8]), DecodeError> { +fn read_leading_ones(buf: &[u8]) -> Result<(u64, &[u8]), DecodeError> { let Some((&first, rest)) = buf.split_first() else { return Err(DecodeError::Short); }; @@ -229,8 +222,6 @@ fn read_leading_ones(buf: &[u8], seven: bool) -> Result<(u64, &[u8]), DecodeErro let ([a, b, lo @ ..], rest) = buf.split_first_chunk::<6>().ok_or(DecodeError::Short)?; (from_halves(be([0, 0, a & 0x03, *b]), be(*lo)), rest) } - // 1111110x: the 7-byte form, which draft-17 forbids. - 6 if !seven => return Err(DecodeError::InvalidValue), 6 => { let ([a, b, c, lo @ ..], rest) = buf.split_first_chunk::<7>().ok_or(DecodeError::Short)?; (from_halves(be([0, a & 0x01, *b, *c]), be(*lo)), rest) @@ -303,8 +294,7 @@ pub(crate) const fn unzigzag(value: u64) -> i64 { mod tests { use super::*; - const DRAFT17: Form = Form::LeadingOnes { seven: false }; - const DRAFT18: Form = Form::LeadingOnes { seven: true }; + const LEADING_ONES: Form = Form::LeadingOnes; fn encode(value: u64, form: Form) -> Result, BoundsExceeded> { let mut buf = Vec::new(); @@ -313,7 +303,7 @@ mod tests { Ok(buf) } - /// Test vectors from the draft-17 spec (Table 2: Example Integer Encodings), + /// Test vectors from the spec (Table 2: Example Integer Encodings), /// excluding the known-buggy example 4 (0xdd7f3e7d). #[test] fn leading_ones_spec_examples() { @@ -335,27 +325,18 @@ mod tests { ]; for (bytes, expected) in cases { - let (decoded, rest) = read(bytes, DRAFT17).expect("decode should succeed"); + let (decoded, rest) = read(bytes, LEADING_ONES).expect("decode should succeed"); assert_eq!(decoded, *expected, "decode mismatch for bytes {bytes:02x?}"); assert!(rest.is_empty(), "all bytes should be consumed for {bytes:02x?}"); // Skip the non-minimal encoding (0x8025 for 37); we only emit the minimal one. if bytes.len() == 1 || *expected != 37 { - let encoded = encode(*expected, DRAFT17).unwrap(); + let encoded = encode(*expected, LEADING_ONES).unwrap(); assert_eq!(&encoded, bytes, "encode mismatch for value {expected}"); } } } - /// 11111100 (0xFC) is an invalid code point on draft-17 (allowed as 7-byte form on draft-18+). - #[test] - fn leading_ones_invalid_0xfc() { - assert!( - matches!(read(&[0xFC], DRAFT17), Err(DecodeError::InvalidValue)), - "0xFC should be rejected as invalid on draft-17" - ); - } - #[test] fn leading_ones_boundaries_round_trip() { let cases = [ @@ -368,14 +349,14 @@ mod tests { ]; for (value, expected_len) in cases { - let encoded = encode(value, DRAFT17).unwrap(); + let encoded = encode(value, LEADING_ONES).unwrap(); assert_eq!( encoded.len(), expected_len, "unexpected encoded length for value {value}" ); - let (decoded, _) = read(&encoded, DRAFT17).expect("leading-ones decode should succeed"); + let (decoded, _) = read(&encoded, LEADING_ONES).expect("leading-ones decode should succeed"); assert_eq!(decoded, value, "round-trip mismatch for value {value}"); } } @@ -386,7 +367,7 @@ mod tests { fn every_length_round_trips() { for bits in 0..64 { for value in [1u64 << bits, (1u64 << bits) - 1, (1u64 << bits) + 1] { - for form in [Form::Quic, DRAFT17, DRAFT18] { + for form in [Form::Quic, LEADING_ONES] { let Ok(encoded) = encode(value, form) else { assert_eq!(form, Form::Quic); assert!(value > MAX_QUIC); @@ -414,19 +395,12 @@ mod tests { } for value in [MAX_QUIC, 1u64 << 62, u64::MAX] { - let encoded = encode(value, DRAFT18).unwrap(); + let encoded = encode(value, LEADING_ONES).unwrap(); assert_eq!(encoded.len(), 9); - assert_eq!(read(&encoded, DRAFT18).unwrap().0, value); + assert_eq!(read(&encoded, LEADING_ONES).unwrap().0, value); } } - #[test] - fn draft17_rejects_7_byte_varint() { - // 1111110x prefix: invalid on draft-17. - let err = read(&[0xFC, 0, 0, 0, 0, 0, 0], DRAFT17).unwrap_err(); - assert!(matches!(err, DecodeError::InvalidValue)); - } - #[test] fn zigzag_roundtrip_small() { for n in [-3i64, -2, -1, 0, 1, 2, 3, 100, -100] { @@ -465,7 +439,7 @@ mod tests { } #[test] - fn draft18_accepts_7_byte_varint() { + fn accepts_7_byte_varint() { // Value 0x1234_5678_9ABC encoded as 7-byte leading-ones (1111110x | hi, +6 bytes). let value: u64 = 0x1234_5678_9ABC; let mut bytes = Vec::new(); @@ -476,7 +450,7 @@ mod tests { for shift in (0..48).step_by(8).rev() { bytes.push(((value >> shift) & 0xFF) as u8); } - let (decoded, _) = read(&bytes, DRAFT18).unwrap(); + let (decoded, _) = read(&bytes, LEADING_ONES).unwrap(); assert_eq!(decoded, value); } diff --git a/rs/moq-net/src/fuzz.rs b/rs/moq-net/src/fuzz.rs index e9633ecfed1..8d97be22fe1 100644 --- a/rs/moq-net/src/fuzz.rs +++ b/rs/moq-net/src/fuzz.rs @@ -96,10 +96,6 @@ const LITE_VERSIONS: &[lite::Version] = &[ /// The moq-transport drafts a target decodes at, selected by the input's first byte. const IETF_VERSIONS: &[ietf::Version] = &[ - ietf::Version::Draft14, - ietf::Version::Draft15, - ietf::Version::Draft16, - ietf::Version::Draft17, ietf::Version::Draft18, ietf::Version::Draft19, ietf::Version::Draft20, @@ -630,15 +626,6 @@ pub fn ietf_wire(data: &[u8]) -> bool { 38 => roundtrip::(rest, version), 39 => roundtrip::(rest, version), 40 => roundtrip::, _>(rest, version), - // The unified SETUP replaced the client/server pair at draft-17. The pair refuses a - // later draft itself, but the unified one treats an earlier draft as unreachable. - 41 if matches!( - version, - ietf::Version::Draft14 | ietf::Version::Draft15 | ietf::Version::Draft16 - ) => - { - false - } 41 => setup::(rest, version, |setup| &setup.parameters), 42 => setup::(rest, version, |setup| &setup.parameters), 43 => setup::(rest, version, |setup| &setup.parameters), @@ -785,7 +772,6 @@ impl Default for Messages { }, // Draft-17+ carries the request id in the control message framing instead. ietf_ok: ietf::SubscribeOk { - request_id: None, track_alias: 5, largest: Some(ietf::Location { group: 1_000, @@ -1086,29 +1072,7 @@ pub fn seeds() -> Vec { for (index, version) in IETF_VERSIONS.iter().enumerate() { let outer = crate::Version::Ietf(*version); let parameters = ietf::Parameters::default().encode_bytes(*version).unwrap(); - let messages = match version { - ietf::Version::Draft14 | ietf::Version::Draft15 | ietf::Version::Draft16 => vec![ - ( - 42, - crate::setup::Client { - versions: coding::Versions::from([outer.into()]), - parameters: parameters.clone(), - } - .encode_bytes(outer) - .unwrap(), - ), - ( - 43, - crate::setup::Server { - version: outer.into(), - parameters, - } - .encode_bytes(outer) - .unwrap(), - ), - ], - _ => vec![(41, crate::setup::Setup { parameters }.encode_bytes(outer).unwrap())], - }; + let messages = vec![(41, crate::setup::Setup { parameters }.encode_bytes(outer).unwrap())]; for (kind, message) in messages { let mut data = vec![index as u8, kind]; data.extend(message); @@ -1166,11 +1130,6 @@ pub fn seeds() -> Vec { // valid parameter count followed by a Location, so build it from the encoder. for (index, version) in IETF_VERSIONS.iter().enumerate() { let subscribe_ok = ietf::SubscribeOk { - request_id: matches!( - version, - ietf::Version::Draft14 | ietf::Version::Draft15 | ietf::Version::Draft16 - ) - .then_some(ietf::RequestId(0)), track_alias: 0, largest: Some(ietf::Location { group: 427, object: 0 }), properties: Default::default(), @@ -1416,11 +1375,6 @@ pub fn request_history(ids: &[u64]) -> usize { ietf::request_history(ids) } -/// Admit a draft-16 window for the request-ID benchmark, returning the accepted count. -pub fn request_ids(window: u64, ids: &[u64]) -> usize { - ietf::request_ids(window, ids) -} - /// A source-selection watch for the private request-lifetime benchmark. pub struct RequestValidity(crate::model::broadcast::RequestValidity); diff --git a/rs/moq-net/src/ietf/active_count.rs b/rs/moq-net/src/ietf/active_count.rs index 24b55d1a096..2b37334c255 100644 --- a/rs/moq-net/src/ietf/active_count.rs +++ b/rs/moq-net/src/ietf/active_count.rs @@ -6,8 +6,6 @@ //! quiet. When both endpoints declare the ACTIVE_COUNT option, the publisher puts on its //! REQUEST_OK how many NAMESPACE messages come before the subscription is synced. -use super::Version; - /// ACTIVE_COUNT Setup Option: the sender counts the NAMESPACE messages before a /// subscription is synced, and reads the peer's count. Even, so the value is a bare varint. pub const ACTIVE_COUNT: u64 = 0x40B64; @@ -17,23 +15,15 @@ pub const ACTIVE_COUNT: u64 = 0x40B64; /// Even, so the value is a bare varint. pub const ACTIVE_COUNT_PARAM: u64 = 0x40B66; -/// Whether this version answers SUBSCRIBE_NAMESPACE with NAMESPACE messages. Draft-14/15 -/// answer with PUBLISH_NAMESPACE requests instead, which the stream cannot count. -fn supported(version: Version) -> bool { - !matches!(version, Version::Draft14 | Version::Draft15) -} - /// Whether the peer declared the option. We always declare it, so this alone decides /// whether the extension is negotiated. -pub fn from_setup(params: &super::Parameters, version: Version) -> bool { - supported(version) && params.get_varint(super::ParameterVarInt::ActiveCount).is_some() +pub fn from_setup(params: &super::Parameters) -> bool { + params.get_varint(super::ParameterVarInt::ActiveCount).is_some() } /// Declare that we count and read the peer's count. -pub fn into_setup(params: &mut super::Parameters, version: Version) { - if supported(version) { - params.set_varint(super::ParameterVarInt::ActiveCount, 1); - } +pub fn into_setup(params: &mut super::Parameters) { + params.set_varint(super::ParameterVarInt::ActiveCount, 1); } #[cfg(test)] @@ -41,12 +31,10 @@ mod tests { use super::*; #[test] - fn only_versions_with_namespace_negotiate() { - for version in [Version::Draft14, Version::Draft15, Version::Draft16, Version::Draft22] { - let mut params = super::super::Parameters::default(); - assert!(!from_setup(¶ms, version)); - into_setup(&mut params, version); - assert_eq!(from_setup(¶ms, version), supported(version), "{version:?}"); - } + fn declared_option_negotiates() { + let mut params = super::super::Parameters::default(); + assert!(!from_setup(¶ms)); + into_setup(&mut params); + assert!(from_setup(¶ms)); } } diff --git a/rs/moq-net/src/ietf/adapter.rs b/rs/moq-net/src/ietf/adapter.rs deleted file mode 100644 index fe84ae1fdee..00000000000 --- a/rs/moq-net/src/ietf/adapter.rs +++ /dev/null @@ -1,2701 +0,0 @@ -use crate::driver::Transport; -use crate::transport::poll::Session as _; -use std::{ - collections::{HashMap, HashSet, VecDeque}, - sync::{Arc, Mutex, Weak}, - task::{Context, Poll}, -}; - -use bytes::{Buf, Bytes, BytesMut}; - -use crate::{ - Error, PathOwned, - coding::{Decode, Decoder, Encoder, Reader, Writer}, - ietf::{self, RequestId}, -}; - -use super::{Control, Message, Version, control::RequestPermit}; - -// === Message Queues === - -struct QueueState { - messages: VecDeque, - closed: bool, -} - -/// An unbounded FIFO over [`kio::Shared`]: any clone can push or pop. -/// -/// Closure is a plain flag rather than handle liveness: [`close`](Self::close) -/// (or dropping a [`QueueWriter`]) stops future pushes, and the reader drains -/// what's buffered before seeing `None`. -struct Queue(kio::Shared>); - -impl Queue { - fn new() -> Self { - Self(kio::Shared::new(QueueState { - messages: VecDeque::new(), - closed: false, - })) - } - - /// Enqueue a message. Returns false once the queue is closed (the message is - /// dropped), matching a write to a stream whose reader is gone. - fn push(&self, item: T) -> bool { - self.offer(item).is_none() - } - - /// Enqueue a message, handing it back once the queue is closed, for a caller that - /// must not drop it where it is. - fn offer(&self, item: T) -> Option { - let mut state = self.0.lock(); - if state.closed { - return Some(item); - } - state.messages.push_back(item); - None - } - - /// Dequeue the next message, waiting while the queue is open and empty. - /// Returns `None` once the queue is closed and drained. - #[cfg(test)] - async fn pop(&self) -> Option { - kio::wait(|waiter| self.poll_pop(waiter)).await - } - - /// Poll for the next message; ready with `None` once closed and drained. - fn poll_pop(&self, waiter: &kio::Waiter) -> Poll> { - self.0 - .poll(waiter, |state| { - if state.messages.is_empty() && !state.closed { - Poll::Pending - } else { - Poll::Ready(()) - } - }) - .map(|mut state| state.messages.pop_front()) - } - - /// Stop future pushes; buffered messages still drain, then `poll_pop` returns `None`. - fn close(&self) { - self.0.lock().closed = true; - } - - /// Mint the single owning push handle whose `Drop` closes the queue. - fn writer(&self) -> QueueWriter { - QueueWriter(Self(self.0.clone())) - } -} - -// Manual impls: derives would demand `T: Clone`/`T: Default`, which the queued -// stream pairs don't satisfy. -impl Clone for Queue { - fn clone(&self) -> Self { - Self(self.0.clone()) - } -} - -impl Default for Queue { - fn default() -> Self { - Self::new() - } -} - -/// Single-owner push handle: dropping it closes the queue, which the reading -/// [`VirtualRecvStream`] observes as a FIN after draining. -struct QueueWriter(Queue); - -impl QueueWriter { - /// Enqueue a message, returning false if the reader already closed its side. - fn push(&self, item: T) -> bool { - self.0.push(item) - } -} - -impl Drop for QueueWriter { - fn drop(&mut self) { - self.0.close(); - } -} - -// === Virtual Streams === - -/// A virtual receive stream backed by an initial message buffer and a queue of follow-up messages. -pub struct VirtualRecvStream { - buffer: Bytes, - rx: Queue, - closed: bool, - park: kio::Park, - shared: Weak, - /// The request this stream serves, known up front when the peer opened it and - /// filled in by the first write when we did. - request_id: Arc>>, - /// Holds the peer's request open against our MAX_REQUEST_ID window until the - /// handler drops this stream. Only on a stream the peer opened. - _permit: Option, -} - -impl VirtualRecvStream { - fn new(initial: Bytes, rx: Queue, shared: Arc, request_id: Arc>>) -> Self { - Self { - buffer: initial, - rx, - closed: false, - park: kio::Park::default(), - shared: Arc::downgrade(&shared), - request_id, - _permit: None, - } - } - - /// Fill the buffer from the queue if empty; `self.closed` marks the FIN. - fn poll_fill(&mut self, cx: &mut Context<'_>) -> Poll<()> { - if !self.buffer.is_empty() || self.closed { - return Poll::Ready(()); - } - - let waiter = self.park.hold(cx); - match self.rx.poll_pop(waiter) { - Poll::Ready(Some(data)) => { - self.buffer = data; - Poll::Ready(()) - } - Poll::Ready(None) => { - self.closed = true; - Poll::Ready(()) - } - Poll::Pending => Poll::Pending, - } - } -} - -impl crate::transport::poll::Chunks for VirtualRecvStream { - type Error = crate::Error; - - fn poll_read_chunk(&mut self, cx: &mut Context<'_>, max: usize) -> Poll, Self::Error>> { - if max == 0 { - return Poll::Ready(Ok(Some(Bytes::new()))); - } - - std::task::ready!(self.poll_fill(cx)); - if self.buffer.is_empty() { - return Poll::Ready(Ok(None)); - } - - let n = max.min(self.buffer.len()); - Poll::Ready(Ok(Some(self.buffer.split_to(n)))) - } - - fn stop(&mut self, _code: u32) { - self.rx.close(); - } -} - -impl Drop for VirtualRecvStream { - fn drop(&mut self) { - // The reader is gone: close the queue so routed follow-ups are discarded - // instead of buffering forever while the map entry lingers. - self.rx.close(); - - // Release the routing entries too, so a request torn down locally gives its - // namespace back and the same one can be advertised again. - if let Some(request_id) = *self.request_id.lock().unwrap() - && let Some(shared) = self.shared.upgrade() - { - shared.forget(request_id); - } - } -} - -/// A virtual send stream that forwards writes to the shared control stream writer. -/// -/// For streams created by `open_bi` (outgoing requests), this also parses -/// the first outgoing message to extract the request_id and register the -/// stream for response routing. -pub struct VirtualSendStream { - control_tx: Queue, - /// Present only for outgoing requests (from open_bi). - /// Accumulates bytes until the request_id can be parsed, - /// then registers the stream and flushes. - pending: Option, - /// Draft-16 only, once registered: what follows the request, held until whole so - /// each REQUEST_UPDATE is routed back to its request before it leaves. - updates: Option, -} - -struct OutgoingRegistration { - follow_tx: QueueWriter, - shared: Arc, - version: Version, - buf: BytesMut, - /// Shared with the matching [`VirtualRecvStream`] so it can release this request's - /// routing entries once the reader is dropped. - request_id: Arc>>, -} - -impl OutgoingRegistration { - /// Try to parse the request_id (and optionally namespace) from the accumulated bytes, - /// with the length of the message that carried it. - /// Returns Ok(None) if not enough data yet, Err if the message is malformed. - fn try_parse(&self) -> Result, crate::Error> { - let Some((type_id, len, mut body)) = whole_message(&self.buf, self.version) else { - return Ok(None); - }; - - // We have enough bytes for the full message; decoding must succeed. - let request_id = RequestId::decode(&mut body, self.version)?; - - // For PublishNamespace, also extract the namespace for reverse lookup. - if type_id == ietf::PublishNamespace::ID { - if self.version == Version::Draft17 { - // v17 has required_request_id_delta after request_id - let _ = body.varint(); - } - if let Ok(ns) = crate::ietf::namespace::decode_namespace(&mut body) { - self.shared.namespaces.register(Direction::Outgoing, ns, request_id); - } - } - - Ok(Some((request_id, len))) - } - - fn register(self, request_id: RequestId) { - // Serialize publication with receive-half cleanup, including a drop before - // the first write supplied the request id. - let mut registered = self.request_id.lock().unwrap(); - *registered = Some(request_id); - let closed = self.follow_tx.0.0.lock().closed; - if closed { - self.shared.forget(request_id); - } else { - self.shared.streams.lock().unwrap().insert(request_id, self.follow_tx); - } - } -} - -impl VirtualSendStream { - fn new(control_tx: Queue) -> Self { - Self { - control_tx, - pending: None, - updates: None, - } - } - - fn with_registration(control_tx: Queue, pending: OutgoingRegistration) -> Self { - Self { - control_tx, - pending: Some(pending), - updates: None, - } - } -} - -impl VirtualSendStream { - /// Route a chunk: accumulate while the request_id is still unknown, then - /// register and flush; forward directly afterwards. Never blocks, since the - /// control queue is unbounded. - fn push(&mut self, chunk: Bytes) -> Result<(), crate::Error> { - if let Some(pending) = &mut self.pending { - pending.buf.extend_from_slice(&chunk); - - if let Some((request_id, len)) = pending.try_parse()? { - let mut pending = self.pending.take().unwrap(); - let mut buf = std::mem::take(&mut pending.buf); - let rest = buf.split_off(len); - if pending.version == Version::Draft16 { - self.updates = Some(UpdateRouting { - shared: Arc::clone(&pending.shared), - version: pending.version, - request_id, - buf: BytesMut::new(), - }); - } - pending.register(request_id); - if !self.control_tx.push(buf.freeze()) { - return Err(crate::Error::Closed); - } - if !rest.is_empty() { - return self.push(rest.freeze()); - } - } - } else if let Some(updates) = &mut self.updates { - updates.buf.extend_from_slice(&chunk); - while let Some(message) = updates.next()? { - if !self.control_tx.push(message) { - return Err(crate::Error::Closed); - } - } - } else if !self.control_tx.push(chunk) { - return Err(crate::Error::Closed); - } - - Ok(()) - } -} - -/// Draft-16 answers a REQUEST_UPDATE on the control stream by the update's own Request -/// ID, which names no stream, so each update we send is recorded against the request it -/// rides, in [`Shared::updates`], before it leaves. Drafts 14 and 15 answer no update of -/// ours that anything reads. -struct UpdateRouting { - shared: Arc, - version: Version, - /// The request whose stream carries the updates. - request_id: RequestId, - buf: BytesMut, -} - -impl UpdateRouting { - /// The next whole message, recorded first when it is an update. - fn next(&mut self) -> Result, crate::Error> { - let Some((type_id, len, mut body)) = whole_message(&self.buf, self.version) else { - return Ok(None); - }; - if type_id == ietf::SubscribeUpdate::ID { - let own = RequestId::decode(&mut body, self.version)?; - self.shared.route_update(own, self.request_id); - } - Ok(Some(self.buf.split_to(len).freeze())) - } -} - -/// The type, whole length, and body of the first message in `buf`, once all of it is there. -fn whole_message(buf: &[u8], version: Version) -> Option<(u64, usize, Decoder<'_>)> { - let mut r = Decoder::new(buf, version.into()); - let type_id = r.varint().ok()?; - let size = r.u16().ok()? as usize; - let len = buf.len() - r.remaining() + size; - let body = r.sub(size).ok()?; - Some((type_id, len, body)) -} - -impl crate::transport::poll::SendStream for VirtualSendStream { - type Error = crate::Error; - type Group = crate::transport::poll::Ungrouped; - - fn poll_write(&mut self, _cx: &mut Context<'_>, buf: &[u8]) -> Poll> { - let len = buf.len(); - Poll::Ready(self.push(Bytes::copy_from_slice(buf)).map(|()| len)) - } - - fn poll_write_buf(&mut self, _cx: &mut Context<'_>, buf: &mut B) -> Poll> { - // Taking the whole buffer is safe because this never returns Pending; a - // `Bytes` source hands its chunk over without a copy. - let len = buf.remaining(); - let chunk = buf.copy_to_bytes(len); - Poll::Ready(self.push(chunk).map(|()| len)) - } - - fn set_priority(&mut self, _order: i64) {} - - fn set_group(&mut self, group: &Self::Group) { - match *group {} - } - - fn finish(&mut self) -> Result<(), Self::Error> { - // Flush any remaining buffered data (e.g. if registration never completed). - if let Some(pending) = self.pending.take() - && !pending.buf.is_empty() - { - let _ = self.control_tx.push(pending.buf.freeze()); - } - if let Some(updates) = self.updates.take() - && !updates.buf.is_empty() - { - let _ = self.control_tx.push(updates.buf.freeze()); - } - Ok(()) - } - - fn reset(&mut self, _code: u32) {} - - fn poll_closed(&mut self, _cx: &mut Context<'_>) -> Poll> { - Poll::Ready(Ok(())) - } -} - -// === Adapter Send/Recv Enums === - -/// A failure on an adapter stream. A real stream keeps its transport's error, so the negotiated -/// registry decodes a peer's reset rather than mistaking it for a lost connection. -/// Virtual streams have only local errors. -#[derive(Debug, thiserror::Error)] -#[non_exhaustive] -pub enum AdapterError { - #[error(transparent)] - Real(E), - #[error(transparent)] - Virtual(crate::Error), -} - -impl crate::transport::Error for AdapterError { - fn close_kind(&self) -> crate::transport::CloseKind { - match self { - Self::Real(err) => err.close_kind(), - Self::Virtual(err) => err.close_kind(), - } - } - - fn session_error(&self) -> Option<(u32, String)> { - match self { - Self::Real(err) => err.session_error(), - Self::Virtual(err) => err.session_error(), - } - } - - fn stream_error(&self) -> Option { - match self { - Self::Real(err) => err.stream_error(), - Self::Virtual(err) => err.stream_error(), - } - } -} - -pub(crate) enum AdapterSend { - Real(crate::transport::boxed::SendStream), - Virtual(VirtualSendStream), -} - -impl crate::transport::poll::SendStream for AdapterSend { - type Error = AdapterError<::Error>; - type Group = ::Group; - - fn poll_write(&mut self, cx: &mut Context<'_>, buf: &[u8]) -> Poll> { - match self { - Self::Real(s) => s.poll_write(cx, buf).map_err(AdapterError::Real), - Self::Virtual(s) => s.poll_write(cx, buf).map_err(AdapterError::Virtual), - } - } - - fn poll_write_buf(&mut self, cx: &mut Context<'_>, buf: &mut B) -> Poll> { - match self { - Self::Real(s) => s.poll_write_buf(cx, buf).map_err(AdapterError::Real), - Self::Virtual(s) => s.poll_write_buf(cx, buf).map_err(AdapterError::Virtual), - } - } - - fn set_priority(&mut self, order: i64) { - match self { - Self::Real(s) => s.set_priority(order), - Self::Virtual(s) => s.set_priority(order), - } - } - - fn set_group(&mut self, group: &Self::Group) { - match self { - Self::Real(s) => s.set_group(group), - // Rides the control stream, which no group schedules. - Self::Virtual(_) => {} - } - } - - fn finish(&mut self) -> Result<(), Self::Error> { - match self { - Self::Real(s) => s.finish().map_err(AdapterError::Real), - Self::Virtual(s) => s.finish().map_err(AdapterError::Virtual), - } - } - - fn reset(&mut self, code: u32) { - match self { - Self::Real(s) => s.reset(code), - Self::Virtual(s) => s.reset(code), - } - } - - fn poll_closed(&mut self, cx: &mut Context<'_>) -> Poll> { - match self { - Self::Real(s) => s.poll_closed(cx).map_err(AdapterError::Real), - Self::Virtual(s) => s.poll_closed(cx).map_err(AdapterError::Virtual), - } - } -} - -#[cfg_attr( - target_pointer_width = "64", - expect( - clippy::large_enum_variant, - reason = "one per stream, so boxing a variant would add an allocation per stream to save bytes nothing holds in bulk" - ) -)] -pub(crate) enum AdapterRecv { - Real(crate::transport::boxed::RecvStream), - Virtual(crate::transport::poll::Buffered), -} - -impl crate::transport::poll::RecvStream for AdapterRecv { - type Error = AdapterError<::Error>; - type Lease<'a> = AdapterLease<'a>; - - fn poll_lease(&mut self, cx: &mut Context<'_>, want: usize) -> Poll, Self::Error>> { - match self { - Self::Real(s) => s - .poll_lease(cx, want) - .map(|r| r.map(AdapterLease::Real).map_err(AdapterError::Real)), - Self::Virtual(s) => s - .poll_lease(cx, want) - .map(|r| r.map(AdapterLease::Virtual).map_err(AdapterError::Virtual)), - } - } - - fn set_priority(&mut self, priority: i64) { - match self { - Self::Real(s) => s.set_priority(priority), - // Rides the control stream, which carries its credit. - Self::Virtual(_) => {} - } - } - - fn stop(&mut self, code: u32) { - match self { - Self::Real(s) => s.stop(code), - Self::Virtual(s) => s.stop(code), - } - } -} - -/// A [`Lease`](crate::transport::poll::Lease) of an [`AdapterRecv`]. -pub(crate) enum AdapterLease<'a> { - Real(::Lease<'a>), - Virtual(crate::transport::poll::BufferedLease<'a>), -} - -impl Buf for AdapterLease<'_> { - fn remaining(&self) -> usize { - match self { - Self::Real(l) => l.remaining(), - Self::Virtual(l) => l.remaining(), - } - } - - fn chunk(&self) -> &[u8] { - match self { - Self::Real(l) => l.chunk(), - Self::Virtual(l) => l.chunk(), - } - } - - fn advance(&mut self, n: usize) { - match self { - Self::Real(l) => l.advance(n), - Self::Virtual(l) => l.advance(n), - } - } - - fn copy_to_bytes(&mut self, n: usize) -> Bytes { - match self { - Self::Real(l) => l.copy_to_bytes(n), - Self::Virtual(l) => l.copy_to_bytes(n), - } - } -} - -impl crate::transport::poll::Lease for AdapterLease<'_> { - fn is_fin(&self) -> bool { - match self { - Self::Real(l) => l.is_fin(), - Self::Virtual(l) => l.is_fin(), - } - } - - fn chunks(&self) -> impl Iterator { - let (real, virt) = match self { - Self::Real(l) => (Some(l.chunks()), None), - Self::Virtual(l) => (None, Some(l.chunks())), - }; - real.into_iter().flatten().chain(virt.into_iter().flatten()) - } - - fn release(self) { - match self { - Self::Real(l) => l.release(), - Self::Virtual(l) => l.release(), - } - } -} - -// === Control Stream Adapter === - -/// Which request a namespace names: an advertisement, by the side that made it, or the -/// peer's namespace subscription. -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -enum Direction { - /// We advertised it to the peer, on a stream from `open_bi`. - Outgoing, - /// The peer advertised it to us, on a stream handed to `accept_bi`. - Incoming, - /// The peer subscribed to it with SUBSCRIBE_NAMESPACE, on a stream handed to - /// `accept_bi`. Only draft-14's UNSUBSCRIBE_NAMESPACE names one. - Subscribed, -} - -/// Namespace → request_id reverse lookup for the v14/v15 messages that name a -/// namespace instead of a request id. -/// -/// Direction is part of the key because a cluster mesh has both endpoints -/// advertising the same namespace to each other. One map would let the second -/// advertisement overwrite the first, and a terminal message would then tear -/// down the stream travelling the other way while its real target stayed open. -/// A subscription keeps a map of its own for the same reason: a peer may both -/// advertise a namespace and subscribe to it. -#[derive(Default)] -struct Namespaces { - state: Mutex, -} - -#[derive(Default)] -struct NamespacesState { - outgoing: HashMap, - incoming: HashMap, - subscribed: HashMap, - - /// request_id → the namespace that request advertised, one entry per request - /// including queued duplicates, so [`Namespaces::forget`] removes only that - /// request from its namespace. The two directions share this map because - /// moq-transport gives each peer its own request id space. - by_request: HashMap, -} - -struct NamespaceRequests { - first: RequestId, - last: RequestId, -} - -struct NamespaceRegistration { - direction: Direction, - namespace: PathOwned, - previous: Option, - next: Option, -} - -impl NamespacesState { - fn map(&mut self, direction: Direction) -> &mut HashMap { - match direction { - Direction::Outgoing => &mut self.outgoing, - Direction::Incoming => &mut self.incoming, - Direction::Subscribed => &mut self.subscribed, - } - } -} - -impl Namespaces { - /// Record a request's namespace, leaving a live advertisement of the same name alone. - /// - /// The first request in a direction owns the name until it ends. A peer that - /// advertises the same namespace twice would otherwise move the name onto the second - /// request, and the withdrawal it eventually names would close that one while the - /// first stayed open, advertised for the life of the session. - fn register(&self, direction: Direction, namespace: PathOwned, request_id: RequestId) { - let mut state = self.state.lock().unwrap(); - if state.by_request.contains_key(&request_id) { - return; - } - let previous = match state.map(direction).entry(namespace.clone()) { - std::collections::hash_map::Entry::Occupied(mut entry) => { - Some(std::mem::replace(&mut entry.get_mut().last, request_id)) - } - std::collections::hash_map::Entry::Vacant(entry) => { - entry.insert(NamespaceRequests { - first: request_id, - last: request_id, - }); - None - } - }; - if let Some(previous) = previous { - state.by_request.get_mut(&previous).unwrap().next = Some(request_id); - } - state.by_request.insert( - request_id, - NamespaceRegistration { - direction, - namespace, - previous, - next: None, - }, - ); - } - - /// The namespace the peer's request `request_id` advertises, if it is a PUBLISH_NAMESPACE. - fn incoming(&self, request_id: RequestId) -> Option { - let state = self.state.lock().unwrap(); - let registration = state.by_request.get(&request_id)?; - (registration.direction == Direction::Incoming).then(|| registration.namespace.clone()) - } - - fn get(&self, direction: Direction, namespace: &PathOwned) -> Option { - self.state - .lock() - .unwrap() - .map(direction) - .get(namespace) - .map(|requests| requests.first) - } - - /// Release whatever a finished request holds, so its namespace can be advertised again. - fn forget(&self, request_id: RequestId) { - let mut state = self.state.lock().unwrap(); - let Some(registration) = state.by_request.remove(&request_id) else { - return; - }; - - // Link around the removed request without scanning a burst of duplicates. - if let Some(previous) = registration.previous { - state.by_request.get_mut(&previous).unwrap().next = registration.next; - } - if let Some(next) = registration.next { - state.by_request.get_mut(&next).unwrap().previous = registration.previous; - } - let map = state.map(registration.direction); - if registration.previous.is_none() && registration.next.is_none() { - map.remove(®istration.namespace); - } else { - let requests = map.get_mut(®istration.namespace).unwrap(); - if requests.first == request_id { - requests.first = registration.next.unwrap(); - } - if requests.last == request_id { - requests.last = registration.previous.unwrap(); - } - } - } -} - -#[derive(Default)] -struct Shared { - /// New virtual streams for accept_bi; any caller can pop directly. - incoming: Queue<(VirtualSendStream, VirtualRecvStream)>, - - /// Messages every VirtualSendStream writes; the run_write task drains this - /// onto the real control stream. - control: Queue, - - /// Active virtual streams keyed by request_id. Removing an entry drops its - /// writer, which FINs the matching VirtualRecvStream. - streams: Mutex>>, - - /// Draft-16: our REQUEST_UPDATEs' own Request IDs → the open request each updates, so - /// the one answer each is owed reaches that request's stream. Bounded by what we sent, - /// and an entry goes with its answer or its request. Locked after `streams`. - updates: Mutex>, - - /// Namespace → request_id reverse lookup (for v14/v15 namespace-keyed messages). - namespaces: Namespaces, - - /// The peer's advertisements held back behind a withdrawal still being handled. - readvertised: Mutex, -} - -/// Keeps the peer's withdrawal and re-advertisement of a namespace in wire order. -/// -/// Each request is served by its own handler, so a PUBLISH_NAMESPACE that follows a -/// PUBLISH_NAMESPACE_DONE for the same namespace could otherwise be handled first. It -/// would then read as a second advertisement of a namespace still advertised, and the -/// withdrawal as the end of the first, so the route never ends and starts again. The -/// re-advertisement reaches `accept_bi` only once the withdrawn request's handler drops -/// its stream, which it does after releasing the route. Bounded by the peer's requests. -#[derive(Default)] -struct Readvertised { - namespaces: HashMap, - /// Each withdrawn request a handler still holds, to the namespace it advertised. - withdrawn: HashMap, -} - -#[derive(Default)] -struct Withdrawing { - /// Withdrawn requests whose handlers still hold their streams. - handling: HashSet, - /// The advertisements behind them, in wire order. - held: VecDeque, -} - -struct HeldRequest { - request_id: RequestId, - stream: (VirtualSendStream, VirtualRecvStream), - /// Withdrawn while held, so the advertisements behind it wait for its handler too. - withdrawn: bool, -} - -impl Shared { - /// Mint the local half of a request we're about to send. Registration waits - /// until the first write reveals the request_id. - fn open_outgoing(self: &Arc, version: Version) -> (VirtualSendStream, VirtualRecvStream) { - let follow = Queue::new(); - let request_id = Arc::new(Mutex::new(None)); - let recv = VirtualRecvStream::new(Bytes::new(), follow.clone(), Arc::clone(self), Arc::clone(&request_id)); - let send = VirtualSendStream::with_registration( - self.control.clone(), - OutgoingRegistration { - follow_tx: follow.writer(), - shared: Arc::clone(self), - version, - buf: BytesMut::new(), - request_id, - }, - ); - (send, recv) - } - - /// Register the peer's new request and queue its stream for accept_bi. - fn open_incoming( - self: &Arc, - request_id: RequestId, - raw: Bytes, - permit: Option, - ) -> Result<(), Error> { - let follow = Queue::new(); - let mut recv = VirtualRecvStream::new( - raw, - follow.clone(), - Arc::clone(self), - Arc::new(Mutex::new(Some(request_id))), - ); - recv._permit = permit; - let send = VirtualSendStream::new(self.control.clone()); - self.streams.lock().unwrap().insert(request_id, follow.writer()); - if let Some(namespace) = self.namespaces.incoming(request_id) { - let mut readvertised = self.readvertised.lock().unwrap(); - if let Some(withdrawing) = readvertised.namespaces.get_mut(&namespace) { - withdrawing.held.push_back(HeldRequest { - request_id, - stream: (send, recv), - withdrawn: false, - }); - return Ok(()); - } - } - if !self.incoming.push((send, recv)) { - return Err(Error::Closed); - } - Ok(()) - } - - /// Deliver a message to an open virtual stream, dropping it if the stream is gone. - /// An answer to one of our updates goes to the request it updated. - /// Returns whether a stream took it. - fn push(&self, request_id: RequestId, raw: Bytes) -> bool { - let streams = self.streams.lock().unwrap(); - let request_id = self.updates.lock().unwrap().remove(&request_id).unwrap_or(request_id); - match streams.get(&request_id) { - Some(tx) => tx.push(raw), - None => false, - } - } - - /// Deliver a final message and FIN the stream: the removed writer drops after it. - /// A refusal of one of our updates is only its answer, which leaves the request open. - fn close(&self, request_id: RequestId, raw: Bytes) { - if self.updates.lock().unwrap().contains_key(&request_id) { - self.push(request_id, raw); - return; - } - let tx = self.streams.lock().unwrap().remove(&request_id); - let namespace = self.namespaces.incoming(request_id); - self.namespaces.forget(request_id); - let Some(tx) = tx else { return }; - let Some(namespace) = namespace else { - tx.push(raw); - return; - }; - - // Under the lock, so a handler dropping its stream either refuses the push or - // finds the withdrawal recorded. - let mut readvertised = self.readvertised.lock().unwrap(); - if !tx.push(raw) { - return; - } - let withdrawing = readvertised.namespaces.entry(namespace.clone()).or_default(); - match withdrawing.held.iter_mut().find(|held| held.request_id == request_id) { - Some(held) => held.withdrawn = true, - None => { - withdrawing.handling.insert(request_id); - readvertised.withdrawn.insert(request_id, namespace); - } - } - } - - /// Expect the answer to our update `own` on `request_id`'s stream, while it is open. - fn route_update(&self, own: RequestId, request_id: RequestId) { - let streams = self.streams.lock().unwrap(); - if streams.contains_key(&request_id) { - self.updates.lock().unwrap().insert(own, request_id); - } - } - - /// Drop every routing entry a request owns, whether or not its stream is still around. - fn forget(&self, request_id: RequestId) { - let mut streams = self.streams.lock().unwrap(); - streams.remove(&request_id); - let mut updates = self.updates.lock().unwrap(); - if !updates.is_empty() { - updates.retain(|_, updated| *updated != request_id); - } - drop((updates, streams)); - self.namespaces.forget(request_id); - self.handled(request_id); - } - - /// A withdrawn request's handler is done with it: once none of the namespace's - /// withdrawals is still being handled, hand over what was held behind them, up to and - /// including the next one withdrawn. - fn handled(&self, request_id: RequestId) { - // What a closed session refused, dropped only once the lock is released, since - // dropping a stream lands back here. - let mut refused = Vec::new(); - let mut readvertised = self.readvertised.lock().unwrap(); - let Some(namespace) = readvertised.withdrawn.remove(&request_id) else { - return; - }; - let Readvertised { namespaces, withdrawn } = &mut *readvertised; - let Some(withdrawing) = namespaces.get_mut(&namespace) else { - return; - }; - withdrawing.handling.remove(&request_id); - while withdrawing.handling.is_empty() { - let Some(held) = withdrawing.held.pop_front() else { - namespaces.remove(&namespace); - break; - }; - if let Some(stream) = self.incoming.offer(held.stream) { - // The session is gone, so nothing held behind this one is accepted either. - refused.push(stream); - refused.extend(withdrawing.held.drain(..).map(|held| held.stream)); - namespaces.remove(&namespace); - break; - } - if held.withdrawn { - withdrawing.handling.insert(held.request_id); - withdrawn.insert(held.request_id, namespace.clone()); - } - } - drop(readvertised); - drop(refused); - } -} - -#[derive(Clone)] -pub(crate) struct ControlStreamAdapter { - stats: crate::stats::Session, - inner: Transport, - shared: Arc, - control: Control, - version: Version, - // Bridges Context-based polls onto the kio queues; empty on clone. - park: kio::Park, -} - -impl ControlStreamAdapter { - pub fn new(inner: Transport, control: Control, version: Version) -> Self { - Self { - stats: Default::default(), - inner, - shared: Arc::new(Shared::default()), - control, - version, - park: kio::Park::default(), - } - } - - pub(super) fn with_stats(mut self, stats: &crate::stats::Session) -> Self { - self.stats = stats.clone(); - self - } - - /// Open a real (non-virtual) bidi stream, bypassing control stream multiplexing. - /// Used for v16 SubscribeNamespace which moved to its own bidi stream. - pub async fn open_native_bi(&mut self) -> Result<(AdapterSend, AdapterRecv), crate::Error> { - let (send, recv) = kio::wait(|waiter| self.inner.poll_open_request(&mut waiter.context(), Default::default())) - .await - .map_err(crate::Error::from_transport)? - .ok_or(crate::Error::NoStreamCredit)?; - Ok((AdapterSend::Real(send), AdapterRecv::Real(recv))) - } - - /// Run the control stream read + write tasks. - /// This reads from the control stream and routes messages to virtual streams, - /// and also drains the write queue to the control stream writer. A decoded - /// GOAWAY is surfaced through `goaway` so [`crate::Session::recv_goaway`] resolves - /// instead of the session tearing down. - pub async fn run( - &self, - reader: Reader, - writer: Writer, - goaway: crate::goaway::Protocol, - ) -> Result<(), Error> { - let res = { - let mut read = std::pin::pin!(self.run_read(reader, goaway)); - let mut write = std::pin::pin!(self.run_write(writer)); - kio::wait(|waiter| { - if let Poll::Ready(res) = waiter.poll_future(read.as_mut()) { - return Poll::Ready(res); - } - // Queued before the write drains, so a grant goes out in the same turn. - while let Poll::Ready(max) = self.control.poll_grant(waiter) { - self.send_max_request_id(max); - } - if let Poll::Ready(res) = waiter.poll_future(write.as_mut()) { - return Poll::Ready(res); - } - Poll::Pending - }) - .await - }; - - // The control stream is dead, so the mux is too: fail future virtual - // writes fast and end accept_bi instead of buffering into a queue nobody - // will ever drain. - self.shared.control.close(); - self.shared.incoming.close(); - - res - } - - /// Queue a GOAWAY message onto the shared control stream (draft-14-16). - /// - /// Framed as `[type_id varint][size u16][body]` like every other control - /// message. Best-effort: an encode failure or a closed control stream is - /// logged and dropped, since the session is tearing down anyway. - pub(super) fn send_goaway(&self, uri: &str, timeout_ms: u64, version: Version) { - let msg = crate::ietf::GoAway { - new_session_uri: std::borrow::Cow::Borrowed(uri), - timeout: timeout_ms, - request_id: None, - }; - - if let Err(err) = self.queue_message(&msg, version) { - tracing::warn!(%err, "failed to encode goaway"); - } - } - - /// Refuse an update no request here can apply, naming its own Request ID. - fn refuse_update(&self, request_id: RequestId) { - if self.version == Version::Draft14 { - return; - } - let msg = ietf::RequestError { - request_id: Some(request_id), - error_code: super::error::request::to_code( - &crate::Error::Unsupported, - super::error::request::Kind::Subscribe, - self.version, - ), - reason_phrase: "update not supported".into(), - retry_interval: 0, - }; - if let Err(err) = self.queue_message(&msg, self.version) { - tracing::warn!(%err, "failed to encode REQUEST_ERROR"); - } - } - - /// Queue a MAX_REQUEST_ID granting the peer room up to `max`. - fn send_max_request_id(&self, max: RequestId) { - if let Err(err) = self.queue_message(&ietf::MaxRequestId { request_id: max }, self.version) { - tracing::warn!(%err, "failed to encode MAX_REQUEST_ID"); - } - } - - fn queue_message(&self, msg: &T, version: Version) -> Result<(), Error> { - use crate::coding::Encode; - let mut raw = Vec::new(); - let mut encoder = Encoder::new(&mut raw, version.into()); - encoder.varint(T::ID)?; - msg.encode(&mut encoder, version)?; - let selector = crate::coding::varint::size(T::ID, version.into()).map_err(crate::coding::EncodeError::from)?; - self.stats - .control(super::message::control(T::ID, version), raw.len() - selector, false); - if !self.shared.control.push(raw.into()) { - tracing::debug!("control stream closed; message not sent"); - } - Ok(()) - } - - /// Writer task: drains the queue and writes to the control stream. The peer's - /// STOP_SENDING, seen while idle or as a failed write, is a protocol violation. - async fn run_write(&self, mut writer: Writer) -> Result<(), Error> { - loop { - let msg = kio::wait(|waiter| { - // Never finished, so any end is the peer's or the session's. - if let Poll::Ready(res) = writer.poll_closed(&mut waiter.context()) { - let err = res - .err() - .map_or(Error::ProtocolViolation, super::session::control_stream_error); - return Poll::Ready(Err(err)); - } - self.shared.control.poll_pop(waiter).map(Ok) - }) - .await?; - let Some(msg) = msg else { break }; - let mut buf = std::io::Cursor::new(msg); - writer - .write_all(&mut buf) - .await - .map_err(super::session::control_stream_error)?; - } - Ok(()) - } - - /// Dispatcher loop that reads control stream messages and routes them. - async fn run_read( - &self, - mut reader: Reader, - goaway: crate::goaway::Protocol, - ) -> Result<(), Error> { - loop { - let type_id = match reader - .varint_maybe() - .await - .map_err(super::session::control_stream_error)? - { - Some(id) => id, - None => return Err(Error::ProtocolViolation), - }; - - let body = reader - .decode::() - .await - .map_err(super::session::control_stream_error)? - .0; - - self.stats - .control(super::message::control(type_id, self.version), body.len() + 2, true); - - // Reconstruct raw message bytes: [type_id][size][body] - let raw = encode_raw(type_id, &body, self.version); - - // Classify and route - match classify(type_id, &body, self.version, &self.shared.namespaces)? { - Route::NewRequest(request_id) => { - let permit = self.control.accept(request_id)?; - self.shared.open_incoming(request_id, raw, permit)? - } - Route::Response(request_id) => { - self.shared.push(request_id, raw); - } - Route::FollowUp { own, target } => { - // SUBSCRIBE_UPDATE takes a request ID of its own (draft-14 section 9.1), - // done as soon as it is delivered, so it is granted straight back. - drop(self.control.accept(own)?); - // An update whose request is gone, or rides a stream of its own like draft 16's - // SUBSCRIBE_NAMESPACE, is still owed its one answer. - if !self.shared.push(target, raw) { - self.refuse_update(own); - } - } - Route::CloseStream(request_id) => self.shared.close(request_id, raw), - Route::MaxRequestId(max) => self.control.max_request_id(max), - Route::Ignore => {} - Route::GoAway => { - let mut data = Decoder::new(&body, self.version.into()); - let msg = crate::ietf::GoAway::decode_msg(&mut data, self.version)?; - tracing::info!(message = ?msg, "received GOAWAY"); - - // Draft-14-16 have no timeout field. - // A second GOAWAY is a protocol violation the draft requires we - // close over, so let it propagate and end the session. - goaway.record(crate::goaway::Goaway { - uri: msg.new_session_uri.into_owned(), - timeout: None, - })?; - // Keep processing control messages: existing subscriptions - // flow until the session actually closes. - } - } - } - } -} - -/// Classify a control message and extract its request_id for routing. -/// -/// Takes the namespace map rather than reading it off the adapter so the routing -/// rules can be tested without a session behind them. -fn classify(type_id: u64, body: &Bytes, version: Version, namespaces: &Namespaces) -> Result { - match type_id { - // New requests: these create new virtual streams - ietf::Subscribe::ID => { - let id = decode_request_id(body, version)?; - Ok(Route::NewRequest(id)) - } - ietf::Fetch::ID => { - let id = decode_request_id(body, version)?; - Ok(Route::NewRequest(id)) - } - ietf::Publish::ID => { - let id = decode_request_id(body, version)?; - Ok(Route::NewRequest(id)) - } - ietf::PublishNamespace::ID => { - let id = decode_request_id(body, version)?; - // Decode the namespace and store the mapping for v14/v15 reverse lookup - if let Ok(ns) = decode_publish_namespace_body(body, version) { - namespaces.register(Direction::Incoming, ns, id); - } - Ok(Route::NewRequest(id)) - } - ietf::TrackStatus::ID => { - let id = decode_request_id(body, version)?; - Ok(Route::NewRequest(id)) - } - // SubscribeNamespace on control stream (v14/v15 only) - ietf::SubscribeNamespaceLegacy::ID => match version { - // Draft-14's UNSUBSCRIBE_NAMESPACE names the prefix rather than the request. - Version::Draft14 => { - let mut r = Decoder::new(body, version.into()); - let id = RequestId::decode(&mut r, version)?; - if let Ok(prefix) = crate::ietf::namespace::decode_namespace(&mut r) { - namespaces.register(Direction::Subscribed, prefix.into_owned(), id); - } - Ok(Route::NewRequest(id)) - } - Version::Draft15 => { - let id = decode_request_id(body, version)?; - Ok(Route::NewRequest(id)) - } - _ => Err(Error::UnexpectedMessage), - }, - - // SUBSCRIBE_TRACKS (draft-18+, #1542): the half of the SUBSCRIBE_NAMESPACE split - // that subscribes to all tracks under a prefix. We don't implement PUBLISH - // replication, so this is impossible to honor. Reject loudly. - ietf::SubscribeTracks::ID => { - tracing::error!( - version = ?version, - "received SUBSCRIBE_TRACKS (0x51); not supported in moq-lite (no PUBLISH replication)" - ); - Err(Error::Unsupported) - } - - // Responses: route to the virtual stream waiting for a reply - ietf::SubscribeOk::ID => { - let id = decode_response_request_id(body, version)?; - Ok(Route::Response(id)) - } - // 0x05: SubscribeError in v14, RequestError in v15+ - ietf::SubscribeError::ID => { - let id = decode_response_request_id(body, version)?; - Ok(Route::CloseStream(id)) - } - ietf::FetchOk::ID => { - let id = decode_response_request_id(body, version)?; - Ok(Route::Response(id)) - } - // 0x19: FetchError in v14 only - ietf::FetchError::ID => match version { - Version::Draft14 => { - let id = decode_request_id(body, version)?; - Ok(Route::CloseStream(id)) - } - _ => Err(Error::UnexpectedMessage), - }, - // TRACK_STATUS_OK and TRACK_STATUS_ERROR (v14 only): the one answer the request gets. - ietf::TrackStatusOk::ID_14 | ietf::TRACK_STATUS_ERROR_14 => match version { - Version::Draft14 => { - let id = decode_request_id(body, version)?; - Ok(Route::CloseStream(id)) - } - _ => Err(Error::UnexpectedMessage), - }, - // PublishOk (0x1E) - ietf::PublishOk::ID => { - let id = decode_response_request_id(body, version)?; - Ok(Route::Response(id)) - } - // PublishError (0x1F) - v14 only - ietf::PublishError::ID => { - let id = decode_request_id(body, version)?; - Ok(Route::CloseStream(id)) - } - // 0x07: PublishNamespaceOk in v14, RequestOk in v15+ - ietf::PublishNamespaceOk::ID => match version { - Version::Draft14 => { - let id = decode_request_id(body, version)?; - Ok(Route::Response(id)) - } - Version::Draft15 | Version::Draft16 => { - // RequestOk - route to stream - let id = decode_response_request_id(body, version)?; - Ok(Route::Response(id)) - } - _ => Err(Error::UnexpectedMessage), - }, - // 0x08: PublishNamespaceError in v14 only - ietf::PublishNamespaceError::ID => match version { - Version::Draft14 => { - let id = decode_request_id(body, version)?; - Ok(Route::CloseStream(id)) - } - _ => Err(Error::UnexpectedMessage), - }, - // SubscribeNamespaceOk (v14 only) - ietf::SubscribeNamespaceOk::ID => match version { - Version::Draft14 => { - let id = decode_request_id(body, version)?; - Ok(Route::Response(id)) - } - _ => Err(Error::UnexpectedMessage), - }, - // SubscribeNamespaceError (v14 only) - ietf::SubscribeNamespaceError::ID => match version { - Version::Draft14 => { - let id = decode_request_id(body, version)?; - Ok(Route::CloseStream(id)) - } - _ => Err(Error::UnexpectedMessage), - }, - - // Follow-up messages: route to the request being updated, not the update's own id. - ietf::SubscribeUpdate::ID => { - let own = decode_request_id(body, version)?; - let target = decode_update_target(body, version)?; - Ok(Route::FollowUp { own, target }) - } - - // Close stream messages - ietf::Unsubscribe::ID => { - let id = decode_request_id(body, version)?; - Ok(Route::CloseStream(id)) - } - ietf::PublishDone::ID => { - let id = decode_response_request_id(body, version)?; - Ok(Route::CloseStream(id)) - } - ietf::FetchCancel::ID => { - let id = decode_request_id(body, version)?; - Ok(Route::CloseStream(id)) - } - ietf::PublishNamespaceDone::ID => match version { - Version::Draft16 => { - let id = decode_request_id(body, version)?; - Ok(Route::CloseStream(id)) - } - // v14/v15: namespace-keyed, so decode namespace and look up request_id. - // DONE withdraws the advertisement its sender made, so it names an - // inbound one. - Version::Draft14 | Version::Draft15 => { - match lookup_namespace_request_id(body, version, namespaces, Direction::Incoming)? { - Some(id) => Ok(Route::CloseStream(id)), - None => Ok(Route::Ignore), - } - } - _ => Err(Error::UnexpectedMessage), - }, - ietf::PublishNamespaceCancel::ID => match version { - Version::Draft16 => { - let id = decode_request_id(body, version)?; - Ok(Route::CloseStream(id)) - } - // v14/v15: namespace-keyed. CANCEL rejects an advertisement its sender - // received, so it names an outbound one. - Version::Draft14 | Version::Draft15 => { - match lookup_namespace_request_id(body, version, namespaces, Direction::Outgoing)? { - Some(id) => Ok(Route::CloseStream(id)), - None => Ok(Route::Ignore), - } - } - _ => Err(Error::UnexpectedMessage), - }, - ietf::UnsubscribeNamespace::ID => match version { - Version::Draft14 => match lookup_namespace_request_id(body, version, namespaces, Direction::Subscribed)? { - Some(id) => Ok(Route::CloseStream(id)), - None => Ok(Route::Ignore), - }, - Version::Draft15 => { - let id = decode_request_id(body, version)?; - Ok(Route::CloseStream(id)) - } - _ => Err(Error::UnexpectedMessage), - }, - - // Utility - ietf::MaxRequestId::ID => { - let id = decode_request_id(body, version)?; - Ok(Route::MaxRequestId(id)) - } - // The peer reached the MAX_REQUEST_ID we advertised and waits for a grant, which - // follows on its own as its requests close. - ietf::RequestsBlocked::ID => Ok(Route::Ignore), - - // Terminal - ietf::GoAway::ID => Ok(Route::GoAway), - - _ => Err(Error::UnexpectedMessage), - } -} - -/// Decode the namespace from a v14/v15 namespace-keyed message body and look up the -/// request_id of the advertisement it terminates, travelling in the given direction. -/// -/// `None` when nothing holds that name: the request it named is already gone. There is -/// nothing left to close, so the message is dropped rather than ending the session. -fn lookup_namespace_request_id( - body: &Bytes, - version: Version, - namespaces: &Namespaces, - direction: Direction, -) -> Result, Error> { - let mut r = Decoder::new(body, version.into()); - let ns = crate::ietf::namespace::decode_namespace(&mut r)?; - Ok(namespaces.get(direction, &ns)) -} - -impl crate::transport::poll::Session for ControlStreamAdapter { - type SendStream = AdapterSend; - type RecvStream = AdapterRecv; - type Error = crate::Error; - - fn poll_accept_bi( - &mut self, - cx: &mut Context<'_>, - ) -> Poll> { - // v16: SubscribeNamespace uses real bidi streams, so poll both sources. - // Native first: real bidi streams are rare and transport-paced, so they - // can't starve the queue, while a control-message flood could starve a - // native SubscribeNamespace under queue-first order. - if self.version == Version::Draft16 { - match self.inner.poll_accept_bi(cx) { - Poll::Ready(Ok((send, recv))) => { - return Poll::Ready(Ok((AdapterSend::Real(send), AdapterRecv::Real(recv)))); - } - Poll::Ready(Err(_)) => return Poll::Ready(Err(crate::Error::Closed)), - Poll::Pending => {} - } - } - - let waiter = self.park.hold(cx); - match std::task::ready!(self.shared.incoming.poll_pop(waiter)) { - Some((send, recv)) => Poll::Ready(Ok(( - AdapterSend::Virtual(send), - AdapterRecv::Virtual(crate::transport::poll::Buffered::new(recv)), - ))), - None => Poll::Ready(Err(crate::Error::Closed)), - } - } - - fn poll_open_bi( - &mut self, - _cx: &mut Context<'_>, - // Rides the control stream, which no group schedules. - _: crate::transport::poll::SendOptions<'_, ::Group>, - ) -> Poll> { - let (send, recv) = self.shared.open_outgoing(self.version); - Poll::Ready(Ok(( - AdapterSend::Virtual(send), - AdapterRecv::Virtual(crate::transport::poll::Buffered::new(recv)), - ))) - } - - fn poll_open_request( - &mut self, - cx: &mut std::task::Context<'_>, - options: crate::transport::poll::SendOptions< - '_, - ::Group, - >, - ) -> std::task::Poll>, Self::Error>> { - self.poll_open_bi(cx, options).map_ok(Some) - } - - fn poll_open_uni( - &mut self, - cx: &mut Context<'_>, - options: crate::transport::poll::SendOptions< - '_, - ::Group, - >, - ) -> Poll> { - self.inner - .poll_open_uni(cx, options) - .map(|r| r.map(AdapterSend::Real).map_err(|_| crate::Error::Closed)) - } - - fn poll_accept_uni(&mut self, cx: &mut Context<'_>) -> Poll> { - self.inner - .poll_accept_uni(cx) - .map(|r| r.map(AdapterRecv::Real).map_err(|_| crate::Error::Closed)) - } - - fn send_group(&mut self, priority: i64) -> Option<::Group> { - self.inner.send_group(priority) - } - - fn send_datagram( - &mut self, - payload: Bytes, - options: crate::transport::poll::SendOptions< - '_, - ::Group, - >, - ) -> Result<(), Self::Error> { - self.inner - .send_datagram(payload, options) - .map_err(|_| crate::Error::Closed) - } - - fn poll_recv_datagram(&mut self, cx: &mut Context<'_>) -> Poll> { - self.inner - .poll_recv_datagram(cx) - .map(|r| r.map_err(|_| crate::Error::Closed)) - } - - fn max_datagram_size(&self) -> usize { - self.inner.max_datagram_size() - } - - fn binding(&self) -> crate::transport::Binding { - self.inner.binding() - } - fn protocol(&self) -> Option<&str> { - self.inner.protocol() - } - - fn close(&mut self, code: u32, reason: &str) { - self.inner.close(code, reason) - } - - fn poll_closed(&mut self, cx: &mut Context<'_>) -> Poll { - self.inner.poll_closed(cx).map(|_| crate::Error::Closed) - } - - fn stats(&self) -> impl crate::transport::Stats { - self.inner.stats() - } -} - -// === Message Classification === - -#[derive(Debug)] -enum Route { - NewRequest(RequestId), - Response(RequestId), - /// An update: its own request ID counts against the window, and it goes to `target`. - FollowUp { - own: RequestId, - target: RequestId, - }, - CloseStream(RequestId), - MaxRequestId(RequestId), - /// Nothing to route: the message named a request that is already gone. - Ignore, - GoAway, -} - -/// Encode raw message bytes as [type_id varint][size u16][body]. -fn encode_raw(type_id: u64, body: &Bytes, version: Version) -> Bytes { - let mut buf = Vec::new(); - let mut w = Encoder::new(&mut buf, version.into()); - w.varint(type_id).expect("type_id was read from the same wire"); - w.u16(u16::try_from(body.len()).expect("body was read with a u16 size")); - w.slice(body); - buf.into() -} - -/// Decode just the request_id from the beginning of a message body. -fn decode_request_id(body: &Bytes, version: Version) -> Result { - let (request_id, _) = RequestId::decode_slice(body, version)?; - Ok(request_id) -} - -/// The request a SUBSCRIBE_UPDATE or REQUEST_UPDATE applies to. -/// -/// Drafts 14 and 15 name it in Subscription Request ID, and draft 16 in Existing -/// Request ID. Both are the second field; the first is the update's own new -/// Request ID. Later drafts send updates on the request's own stream, not here. -fn decode_update_target(body: &Bytes, version: Version) -> Result { - match version { - Version::Draft14 | Version::Draft15 | Version::Draft16 => { - let mut r = Decoder::new(body, version.into()); - let _own = RequestId::decode(&mut r, version)?; - Ok(RequestId::decode(&mut r, version)?) - } - _ => Err(Error::UnexpectedMessage), - } -} - -/// Decode request_id for response messages that have Option in v14-16. -fn decode_response_request_id(body: &Bytes, version: Version) -> Result { - // In v14-16, response messages always have request_id present - decode_request_id(body, version) -} - -/// Decode the namespace from a PublishNamespace message body (after the request_id). -fn decode_publish_namespace_body(body: &Bytes, version: Version) -> Result { - let mut r = Decoder::new(body, version.into()); - // Skip request_id - let _request_id = RequestId::decode(&mut r, version)?; - // v17 has required_request_id_delta - if version == Version::Draft17 { - r.varint()?; - } - let ns = crate::ietf::namespace::decode_namespace(&mut r)?; - Ok(ns.into_owned()) -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::coding::Encode; - use crate::transport::poll::{RecvStream as _, SendStream as _}; - use futures::FutureExt as _; - - fn make_body_with_request_id(id: u64, version: Version) -> Bytes { - RequestId(id).encode_bytes(version).unwrap() - } - - /// Classify against an empty namespace map, for the messages that don't use it. - fn classify_msg(version: Version, type_id: u64, body: &Bytes) -> Result { - classify(type_id, body, version, &Namespaces::default()) - } - - /// A receive stream with no request behind it, for exercising the reader alone. - fn detached_recv(initial: Bytes, rx: Queue) -> crate::transport::poll::Buffered { - crate::transport::poll::Buffered::new(VirtualRecvStream::new( - initial, - rx, - Arc::new(Shared::default()), - Arc::new(Mutex::new(None)), - )) - } - - #[test] - fn test_classify_subscribe_new_request() { - let body = make_body_with_request_id(42, Version::Draft15); - let route = classify_msg(Version::Draft15, ietf::Subscribe::ID, &body).unwrap(); - assert!(matches!(route, Route::NewRequest(RequestId(42)))); - } - - #[test] - fn test_classify_fetch_new_request() { - let body = make_body_with_request_id(10, Version::Draft14); - let route = classify_msg(Version::Draft14, ietf::Fetch::ID, &body).unwrap(); - assert!(matches!(route, Route::NewRequest(RequestId(10)))); - } - - #[test] - fn test_classify_publish_new_request() { - let body = make_body_with_request_id(5, Version::Draft16); - let route = classify_msg(Version::Draft16, ietf::Publish::ID, &body).unwrap(); - assert!(matches!(route, Route::NewRequest(RequestId(5)))); - } - - #[test] - fn test_classify_subscribe_ok_response() { - let body = make_body_with_request_id(42, Version::Draft15); - let route = classify_msg(Version::Draft15, ietf::SubscribeOk::ID, &body).unwrap(); - assert!(matches!(route, Route::Response(RequestId(42)))); - } - - #[test] - fn test_classify_request_error_v15_closes_stream() { - let body = make_body_with_request_id(7, Version::Draft15); - let route = classify_msg(Version::Draft15, ietf::SubscribeError::ID, &body).unwrap(); - assert!(matches!(route, Route::CloseStream(RequestId(7)))); - } - - #[test] - fn test_classify_request_ok_v15_response() { - let body = make_body_with_request_id(3, Version::Draft15); - let route = classify_msg(Version::Draft15, ietf::PublishNamespaceOk::ID, &body).unwrap(); - assert!(matches!(route, Route::Response(RequestId(3)))); - } - - #[test] - fn test_classify_unsubscribe_closes_stream() { - let body = make_body_with_request_id(99, Version::Draft14); - let route = classify_msg(Version::Draft14, ietf::Unsubscribe::ID, &body).unwrap(); - assert!(matches!(route, Route::CloseStream(RequestId(99)))); - } - - /// Drafts 14 and 15 name the subscription in the second field; draft 16 names - /// the existing request there. The first field is the update's own Request ID, - /// so a body that carries only that ID cannot tell the two apart. - #[moq_clock::test] - async fn test_subscribe_update_reaches_its_target() { - let update_id = RequestId(10); - let target_id = RequestId(4); - - for version in [Version::Draft14, Version::Draft15, Version::Draft16] { - let update = ietf::SubscribeUpdate { - max_age: None, - new_group: None, - request_id: update_id, - subscription_request_id: Some(target_id), - start_location: ietf::Location { group: 1, object: 2 }, - end_group: 100, - subscriber_priority: Some(200), - forward: Some(false), - filter: Some(ietf::Filter::NextObject), - authorization_token: None, - fill: None, - }; - let body = encode_body(&update, version); - let raw = encode_raw(ietf::SubscribeUpdate::ID, &body, version); - let Route::FollowUp { own, target: routed } = - classify_msg(version, ietf::SubscribeUpdate::ID, &body).unwrap() - else { - panic!("{version} did not route the update as a follow-up"); - }; - assert_eq!(own, update_id, "{version}"); - - let shared = Arc::new(Shared::default()); - shared - .open_incoming(target_id, Bytes::from_static(b"request"), None) - .unwrap(); - let (_, mut recv) = shared.incoming.pop().await.unwrap(); - assert_eq!( - read_virtual(&mut recv).await.unwrap(), - Some(Bytes::from_static(b"request")) - ); - - assert_eq!(routed, target_id, "{version}: update {update_id} routed to {routed}"); - shared.push(routed, raw.clone()); - assert_eq!( - read_virtual(&mut recv).await.unwrap(), - Some(raw), - "{version}: update {update_id} did not reach {target_id}" - ); - } - } - - /// Draft-16 answers our REQUEST_UPDATE by the update's own Request ID. The answer - /// reaches the request it updated, a refusal leaves that request open, and an update - /// written in pieces is recorded all the same. - #[moq_clock::test] - async fn our_update_answers_reach_their_request() { - const VERSION: Version = Version::Draft16; - let shared = Arc::new(Shared::default()); - let (mut send, mut recv) = shared.open_outgoing(VERSION); - let update = |request_id| { - encode_msg( - &ietf::PublishNamespaceUpdate { - request_id: RequestId(request_id), - namespace_request_id: Some(RequestId(4)), - hops: None, - cost: None, - authorization_token: None, - }, - VERSION, - ) - }; - - // The request and the first byte of its update in one write, the rest in another. - let first = update(6); - let request = encode_msg(&publish_namespace(RequestId(4), "ns"), VERSION); - send.write_chunk([request.clone(), first.slice(..1)].concat().into()) - .await - .unwrap(); - send.write_chunk(first.slice(1..)).await.unwrap(); - assert_eq!(shared.control.pop().await.unwrap(), request); - assert_eq!(shared.control.pop().await.unwrap(), first); - - let ok = ietf::RequestOk { - largest: None, - request_id: Some(RequestId(6)), - active: None, - }; - assert!(matches!( - classify_msg(VERSION, ietf::RequestOk::ID, &encode_body(&ok, VERSION)).unwrap(), - Route::Response(RequestId(6)) - )); - let ok = encode_msg(&ok, VERSION); - assert!(shared.push(RequestId(6), ok.clone()), "the answer found no stream"); - assert_eq!(read_virtual(&mut recv).await.unwrap(), Some(ok.clone())); - assert!(!shared.push(RequestId(6), ok), "a second answer was routed"); - - send.write_chunk(update(8)).await.unwrap(); - assert_eq!(shared.control.pop().await.unwrap(), update(8)); - let error = encode_msg( - &ietf::RequestError { - request_id: Some(RequestId(8)), - error_code: 0, - reason_phrase: "refused".into(), - retry_interval: 0, - }, - VERSION, - ); - shared.close(RequestId(8), error.clone()); - assert_eq!(read_virtual(&mut recv).await.unwrap(), Some(error)); - assert!( - shared.push(RequestId(4), Bytes::from_static(b"later")), - "the refusal closed the request" - ); - - // An update outstanding when its request goes leaves nothing behind. - send.write_chunk(update(10)).await.unwrap(); - assert_eq!(shared.updates.lock().unwrap().len(), 1); - drop(recv); - assert!(shared.updates.lock().unwrap().is_empty()); - } - - /// Before draft-16 an answer to our update names nothing we route. - #[moq_clock::test] - async fn draft_15_update_answers_are_not_routed() { - const VERSION: Version = Version::Draft15; - let shared = Arc::new(Shared::default()); - let (mut send, _recv) = shared.open_outgoing(VERSION); - send.write_chunk(encode_msg(&publish_namespace(RequestId(4), "ns"), VERSION)) - .await - .unwrap(); - // A SUBSCRIBE_UPDATE's header and its own Request ID 6, all that routing reads. - send.write_chunk(Bytes::from_static(&[0x02, 0x00, 0x01, 0x06])) - .await - .unwrap(); - assert!(!shared.push(RequestId(6), Bytes::from_static(b"ok"))); - assert!(shared.updates.lock().unwrap().is_empty()); - } - - #[test] - fn test_classify_goaway() { - let body = Bytes::new(); - let route = classify_msg(Version::Draft14, ietf::GoAway::ID, &body).unwrap(); - assert!(matches!(route, Route::GoAway)); - } - - #[test] - fn test_classify_max_request_id() { - let body = make_body_with_request_id(100, Version::Draft14); - let route = classify_msg(Version::Draft14, ietf::MaxRequestId::ID, &body).unwrap(); - assert!(matches!(route, Route::MaxRequestId(RequestId(100)))); - } - - #[test] - fn test_classify_subscribe_namespace_v14_new_request() { - let body = make_body_with_request_id(20, Version::Draft14); - let route = classify_msg(Version::Draft14, ietf::SubscribeNamespaceLegacy::ID, &body).unwrap(); - assert!(matches!(route, Route::NewRequest(RequestId(20)))); - } - - #[test] - fn test_classify_subscribe_namespace_v16_errors() { - let body = make_body_with_request_id(20, Version::Draft16); - let result = classify_msg(Version::Draft16, ietf::SubscribeNamespaceLegacy::ID, &body); - assert!(result.is_err()); - } - - #[test] - fn test_classify_unknown_message() { - let body = Bytes::new(); - let result = classify_msg(Version::Draft14, 0xFF, &body); - assert!(result.is_err()); - } - - #[test] - fn test_encode_raw_roundtrip() { - let version = Version::Draft15; - let body = Bytes::from_static(b"hello"); - let raw = encode_raw(0x03, &body, version); - - // Decode the raw bytes - let mut r = Decoder::new(&raw, version.into()); - assert_eq!(r.varint().unwrap(), 0x03); - assert_eq!(r.u16().unwrap(), 5); - assert_eq!(r.rest(), b"hello"); - } - - #[moq_clock::test] - async fn test_virtual_recv_stream_reads_initial_then_followup() { - let initial = Bytes::from_static(b"initial"); - let follow = Queue::new(); - let tx = follow.writer(); - let mut stream = detached_recv(initial, follow); - - // Read initial data - let chunk = stream.read_chunk(32).await.unwrap().unwrap(); - assert_eq!(&chunk[..], b"initial"); - - // Send follow-up - tx.push(Bytes::from_static(b"followup")); - let chunk = stream.read_chunk(32).await.unwrap().unwrap(); - assert_eq!(&chunk[..], b"followup"); - - // Drop the writer → FIN - drop(tx); - let result = stream.read_chunk(32).await.unwrap(); - assert_eq!(result, None); - } - - #[moq_clock::test] - async fn test_virtual_recv_stream_partial_reads() { - let initial = Bytes::from_static(b"hello world"); - let mut stream = detached_recv(initial, Queue::new()); - - // Read small chunks - let chunk = stream.read_chunk(5).await.unwrap().unwrap(); - assert_eq!(&chunk[..], b"hello"); - - let chunk = stream.read_chunk(5).await.unwrap().unwrap(); - assert_eq!(&chunk[..], b" worl"); - - let chunk = stream.read_chunk(1).await.unwrap().unwrap(); - assert_eq!(&chunk[..], b"d"); - } - - #[moq_clock::test] - async fn test_virtual_send_stream_errors_once_control_closes() { - // The adapter closes the control queue when its run() exits; writes must - // fail fast instead of buffering into a queue nobody drains. - let control = Queue::new(); - let mut stream = VirtualSendStream::new(control.clone()); - control.close(); - assert!(matches!(stream.write(b"hello").await, Err(Error::Closed))); - } - - #[test] - fn test_recv_stream_drop_discards_followups() { - // Dropping the reader closes the queue, so late routed messages are - // discarded instead of accumulating while the map entry lingers. - let follow = Queue::new(); - let stream = detached_recv(Bytes::new(), follow.clone()); - drop(stream); - assert!(!follow.push(Bytes::from_static(b"late"))); - } - - #[moq_clock::test] - async fn test_virtual_send_stream_writes_to_channel() { - let control = Queue::new(); - let mut stream = VirtualSendStream::new(control.clone()); - - let n = stream.write(b"hello").await.unwrap(); - assert_eq!(n, 5); - - let data = control.pop().await.unwrap(); - assert_eq!(data, &b"hello"[..]); - } - - /// Encode a message body (no type_id/size header). - fn encode_body(msg: &M, version: Version) -> Bytes { - let mut buf = Vec::new(); - msg.encode_msg(&mut Encoder::new(&mut buf, version.into()), version) - .unwrap(); - bytes::Bytes::from(buf) - } - - /// Encode a full control message: [type_id][size][body]. - fn encode_msg(msg: &M, version: Version) -> Bytes { - let body = encode_body(msg, version); - encode_raw(M::ID, &body, version) - } - - fn publish_namespace(request_id: RequestId, namespace: &str) -> ietf::PublishNamespace<'_> { - ietf::PublishNamespace { - request_id, - track_namespace: crate::Path::new(namespace), - params: Default::default(), - authorization_token: None, - } - } - - /// Advertise `namespace` to the peer on `request_id`, as `open_bi` + a write would. - async fn advertise( - shared: &Arc, - namespace: &str, - version: Version, - request_id: RequestId, - ) -> VirtualRecvStream { - let (mut send, recv) = shared.open_outgoing(version); - send.write_chunk(encode_msg(&publish_namespace(request_id, namespace), version)) - .await - .unwrap(); - recv - } - - /// Receive the peer's advertisement of `namespace` on `request_id`, as the read loop would. - async fn receive( - shared: &Arc, - namespace: &str, - version: Version, - request_id: RequestId, - ) -> VirtualRecvStream { - let msg = publish_namespace(request_id, namespace); - let route = classify( - ietf::PublishNamespace::ID, - &encode_body(&msg, version), - version, - &shared.namespaces, - ) - .unwrap(); - assert!(matches!(route, Route::NewRequest(id) if id == request_id)); - shared - .open_incoming(request_id, encode_msg(&msg, version), None) - .unwrap(); - - let (_, mut recv) = shared.incoming.pop().await.unwrap(); - - // Drain the advertisement the stream opened with, so both halves are quiescent - // and a later read only sees what the terminal message routes. - assert_eq!(read_virtual(&mut recv).await.unwrap(), Some(encode_msg(&msg, version))); - recv - } - - /// Two relays meshed together, each advertising `namespace` to the other: ours on - /// request 4, theirs on request 7. Returns their receive halves. - /// - /// `last` is the advertisement registered second, which is the one a single map - /// would leave as the sole entry. Each test passes the direction it must *not* - /// match, so a direction-blind lookup lands on the wrong stream. - async fn mesh( - namespace: &str, - version: Version, - last: Direction, - ) -> (Arc, VirtualRecvStream, VirtualRecvStream) { - let shared = Arc::new(Shared::default()); - - let (ours, theirs) = match last { - Direction::Outgoing => { - let theirs = receive(&shared, namespace, version, RequestId(7)).await; - (advertise(&shared, namespace, version, RequestId(4)).await, theirs) - } - Direction::Incoming => { - let ours = advertise(&shared, namespace, version, RequestId(4)).await; - (ours, receive(&shared, namespace, version, RequestId(7)).await) - } - Direction::Subscribed => unreachable!("a mesh only advertises"), - }; - - (shared, ours, theirs) - } - - /// The next chunk of a virtual stream, read without a lease. - fn read_virtual(stream: &mut VirtualRecvStream) -> impl Future, crate::Error>> + '_ { - std::future::poll_fn(|cx| crate::transport::poll::Chunks::poll_read_chunk(stream, cx, usize::MAX)) - } - - /// Read until the stream FINs, returning whether it did so within `limit` reads. - async fn drained(stream: &mut VirtualRecvStream, limit: usize) -> bool { - for _ in 0..limit { - if read_virtual(stream).await.unwrap().is_none() { - return true; - } - } - false - } - - #[test] - fn test_namespace_reverse_lookup_v14() { - let namespaces = Namespaces::default(); - namespaces.register(Direction::Incoming, crate::Path::new("test/ns"), RequestId(42)); - - let body = encode_body( - &ietf::PublishNamespaceDone { - track_namespace: crate::Path::new("test/ns"), - request_id: RequestId(0), - }, - Version::Draft14, - ); - - let route = classify(ietf::PublishNamespaceDone::ID, &body, Version::Draft14, &namespaces).unwrap(); - assert!(matches!(route, Route::CloseStream(RequestId(42)))); - } - - #[moq_clock::test] - async fn test_publish_namespace_done_closes_only_inbound() { - // The peer withdraws the advertisement it made, so its own stream closes and - // ours keeps running. - let version = Version::Draft14; - let (shared, mut ours, mut theirs) = mesh("cluster/ns", version, Direction::Outgoing).await; - - let done = ietf::PublishNamespaceDone { - track_namespace: crate::Path::new("cluster/ns"), - request_id: RequestId(0), - }; - let route = classify( - ietf::PublishNamespaceDone::ID, - &encode_body(&done, version), - version, - &shared.namespaces, - ) - .unwrap(); - assert!(matches!(route, Route::CloseStream(RequestId(7)))); - - shared.close(RequestId(7), encode_msg(&done, version)); - assert!(drained(&mut theirs, 4).await); - assert!(shared.streams.lock().unwrap().contains_key(&RequestId(4))); - assert!(read_virtual(&mut ours).now_or_never().is_none()); - } - - #[moq_clock::test] - async fn test_publish_namespace_cancel_closes_only_outbound() { - // The peer rejects the advertisement we made, so ours closes and the one it - // sent us keeps running. - let version = Version::Draft14; - let (shared, mut ours, mut theirs) = mesh("cluster/ns", version, Direction::Incoming).await; - - let cancel = ietf::PublishNamespaceCancel { - track_namespace: crate::Path::new("cluster/ns"), - request_id: RequestId(0), - error_code: 0, - reason_phrase: "".into(), - }; - let route = classify( - ietf::PublishNamespaceCancel::ID, - &encode_body(&cancel, version), - version, - &shared.namespaces, - ) - .unwrap(); - assert!(matches!(route, Route::CloseStream(RequestId(4)))); - - shared.close(RequestId(4), encode_msg(&cancel, version)); - assert!(drained(&mut ours, 4).await); - assert!(shared.streams.lock().unwrap().contains_key(&RequestId(7))); - assert!(read_virtual(&mut theirs).now_or_never().is_none()); - } - - /// Classify the peer withdrawing its own advertisement of `namespace`. - fn done(shared: &Arc, namespace: &str, version: Version) -> Route { - let msg = ietf::PublishNamespaceDone { - track_namespace: crate::Path::new(namespace), - request_id: RequestId(0), - }; - classify( - ietf::PublishNamespaceDone::ID, - &encode_body(&msg, version), - version, - &shared.namespaces, - ) - .unwrap() - } - - /// Classify the peer rejecting our advertisement of `namespace`. - fn cancel(shared: &Arc, namespace: &str, version: Version) -> Route { - let msg = ietf::PublishNamespaceCancel { - track_namespace: crate::Path::new(namespace), - request_id: RequestId(0), - error_code: 0, - reason_phrase: "".into(), - }; - classify( - ietf::PublishNamespaceCancel::ID, - &encode_body(&msg, version), - version, - &shared.namespaces, - ) - .unwrap() - } - - #[moq_clock::test] - async fn test_duplicate_publish_namespace_keeps_the_first() { - // The peer advertises the same namespace twice. The session refuses the second, so - // the first still owns the name and its withdrawal must reach the first's stream. - let version = Version::Draft14; - let shared = Arc::new(Shared::default()); - let first = receive(&shared, "cluster/ns", version, RequestId(7)).await; - let duplicate = receive(&shared, "cluster/ns", version, RequestId(11)).await; - - assert!(matches!( - done(&shared, "cluster/ns", version), - Route::CloseStream(RequestId(7)) - )); - - // Tearing down the refused duplicate releases only what it owns, which is nothing. - drop(duplicate); - assert!(matches!( - done(&shared, "cluster/ns", version), - Route::CloseStream(RequestId(7)) - )); - - // The winner going away is what frees the name. - drop(first); - assert!(matches!(done(&shared, "cluster/ns", version), Route::Ignore)); - } - - #[moq_clock::test] - async fn test_withdrawal_releases_the_namespace() { - // A namespace the peer withdraws must be advertisable again on a new request. - let version = Version::Draft14; - let shared = Arc::new(Shared::default()); - let mut theirs = receive(&shared, "cluster/ns", version, RequestId(7)).await; - - let msg = ietf::PublishNamespaceDone { - track_namespace: crate::Path::new("cluster/ns"), - request_id: RequestId(0), - }; - shared.close(RequestId(7), encode_msg(&msg, version)); - assert!(drained(&mut theirs, 4).await); - assert!(!shared.streams.lock().unwrap().contains_key(&RequestId(7))); - drop(theirs); - - let _again = receive(&shared, "cluster/ns", version, RequestId(11)).await; - assert!(matches!( - done(&shared, "cluster/ns", version), - Route::CloseStream(RequestId(11)) - )); - } - - /// The peer's next request on `namespace`, advertising it, as the read loop routes it. - fn readvertise(shared: &Arc, namespace: &str, version: Version, request_id: RequestId) { - let msg = publish_namespace(request_id, namespace); - let route = classify( - ietf::PublishNamespace::ID, - &encode_body(&msg, version), - version, - &shared.namespaces, - ) - .unwrap(); - assert!(matches!(route, Route::NewRequest(id) if id == request_id)); - shared - .open_incoming(request_id, encode_msg(&msg, version), None) - .unwrap(); - } - - /// The peer withdrawing `namespace` on `request_id`, as the read loop routes it. - fn withdraw(shared: &Arc, namespace: &str, version: Version, request_id: RequestId) { - let msg = ietf::PublishNamespaceDone { - track_namespace: crate::Path::new(namespace), - request_id, - }; - let route = classify( - ietf::PublishNamespaceDone::ID, - &encode_body(&msg, version), - version, - &shared.namespaces, - ) - .unwrap(); - assert!(matches!(route, Route::CloseStream(id) if id == request_id)); - shared.close(request_id, encode_msg(&msg, version)); - } - - /// The request of the next stream `accept_bi` would hand out, if one is ready. - fn accepted(shared: &Arc) -> Option<(RequestId, VirtualRecvStream)> { - let (_, recv) = shared.incoming.pop().now_or_never()??; - let request_id = recv.request_id.lock().unwrap().unwrap(); - Some((request_id, recv)) - } - - #[moq_clock::test] - async fn a_readvertisement_waits_for_the_withdrawal_to_be_handled() { - // Each request has its own handler, so a re-advertisement handed out beside the - // withdrawal before it could be handled first and read as a second advertisement. - for version in [Version::Draft14, Version::Draft15, Version::Draft16] { - let shared = Arc::new(Shared::default()); - let first = receive(&shared, "live/media", version, RequestId(3)).await; - let other = receive(&shared, "live/other", version, RequestId(5)).await; - - withdraw(&shared, "live/media", version, RequestId(3)); - readvertise(&shared, "live/media", version, RequestId(7)); - withdraw(&shared, "live/media", version, RequestId(7)); - readvertise(&shared, "live/media", version, RequestId(9)); - // Another namespace is not held up. - withdraw(&shared, "live/other", version, RequestId(5)); - drop(other); - readvertise(&shared, "live/other", version, RequestId(11)); - assert!(matches!(accepted(&shared), Some((RequestId(11), _))), "{version:?}"); - assert!(accepted(&shared).is_none(), "{version:?}"); - - // Handling the first withdrawal hands over the next advertisement, which was - // withdrawn too, so the one after it waits for that withdrawal in turn. - drop(first); - let (id, mut second) = accepted(&shared).expect("released"); - assert_eq!(id, RequestId(7), "{version:?}"); - assert!(accepted(&shared).is_none(), "{version:?}"); - assert!(drained(&mut second, 4).await, "{version:?}"); - drop(second); - assert!(matches!(accepted(&shared), Some((RequestId(9), _))), "{version:?}"); - assert!(shared.readvertised.lock().unwrap().namespaces.is_empty(), "{version:?}"); - } - } - - #[moq_clock::test] - async fn a_session_closed_behind_a_withdrawal_drops_what_it_held() { - // Dropping a refused stream re-enters the release, which must not still hold its lock. - let version = Version::Draft14; - let shared = Arc::new(Shared::default()); - let first = receive(&shared, "live/media", version, RequestId(3)).await; - withdraw(&shared, "live/media", version, RequestId(3)); - readvertise(&shared, "live/media", version, RequestId(7)); - withdraw(&shared, "live/media", version, RequestId(7)); - readvertise(&shared, "live/media", version, RequestId(9)); - shared.incoming.close(); - - drop(first); - let readvertised = shared.readvertised.lock().unwrap(); - assert!(readvertised.namespaces.is_empty() && readvertised.withdrawn.is_empty()); - drop(readvertised); - assert!(shared.streams.lock().unwrap().is_empty()); - } - - #[moq_clock::test] - async fn test_local_withdrawal_releases_the_namespace() { - // We withdraw our own advertisement by dropping the request that carried it, so a - // later CANCEL must name the re-advertisement rather than the request that is gone. - let version = Version::Draft14; - let shared = Arc::new(Shared::default()); - - let ours = advertise(&shared, "cluster/ns", version, RequestId(4)).await; - drop(ours); - assert!(matches!(cancel(&shared, "cluster/ns", version), Route::Ignore)); - - let _again = advertise(&shared, "cluster/ns", version, RequestId(6)).await; - assert!(matches!( - cancel(&shared, "cluster/ns", version), - Route::CloseStream(RequestId(6)) - )); - } - - #[moq_clock::test] - async fn surviving_duplicate_remains_reachable_after_owner_closes() { - for version in [Version::Draft14, Version::Draft15] { - let shared = Arc::new(Shared::default()); - let first = receive(&shared, "cluster/ns", version, RequestId(7)).await; - let second = receive(&shared, "cluster/ns", version, RequestId(11)).await; - let third = receive(&shared, "cluster/ns", version, RequestId(15)).await; - drop(first); - assert!(matches!( - done(&shared, "cluster/ns", version), - Route::CloseStream(RequestId(11)) - )); - drop(second); - assert!(matches!( - done(&shared, "cluster/ns", version), - Route::CloseStream(RequestId(15)) - )); - drop(third); - assert!(matches!(done(&shared, "cluster/ns", version), Route::Ignore)); - } - } - - #[test] - fn namespace_removal_preserves_links_in_every_order() { - for direction in [Direction::Incoming, Direction::Outgoing, Direction::Subscribed] { - for first in 0..4 { - for second in 0..4 { - for third in 0..4 { - if first == second || first == third || second == third { - continue; - } - let fourth = (0..4).find(|id| *id != first && *id != second && *id != third).unwrap(); - let namespaces = Namespaces::default(); - let name = crate::Path::new("ns"); - for id in 0..4 { - namespaces.register(direction, name.clone(), RequestId(id)); - } - let mut live = [true; 4]; - for id in [first, second, third, fourth] { - namespaces.forget(RequestId(id)); - live[id as usize] = false; - let expected = live.iter().position(|live| *live).map(|id| RequestId(id as u64)); - assert_eq!(namespaces.get(direction, &name), expected); - } - let state = namespaces.state.lock().unwrap(); - assert!(state.by_request.is_empty()); - assert!(state.incoming.is_empty() && state.outgoing.is_empty() && state.subscribed.is_empty()); - } - } - } - } - } - - /// A peer's control stream carrying a bare SUBSCRIBE for each request ID: the - /// adapter routes on the ID alone, so the rest of the body is never read. - async fn windowed( - window: u64, - ids: &[u64], - then: &[u8], - ) -> ( - ControlStreamAdapter, - Reader, - Writer, - crate::lite::test_transport::Log, - ) { - use crate::lite::test_transport::{Log, ScriptedSession, SinkSend}; - use crate::transport::poll::Session as _; - - const VERSION: Version = Version::Draft14; - let mut script = Vec::new(); - for id in ids { - let body = make_body_with_request_id(*id, VERSION); - script.extend_from_slice(&encode_raw(ietf::Subscribe::ID, &body, VERSION)); - } - script.extend_from_slice(then); - let mut session = ScriptedSession::new(script); - let (_, recv) = session.open_bi(Default::default()).await.unwrap(); - // We are the server, so the client's request IDs are even. - let control = Control::new(None, false).with_window(window, false, VERSION); - let adapter = ControlStreamAdapter::new(Transport::new(session.clone()), control, VERSION); - let log = Log::default(); - let writer = Writer::new( - crate::transport::boxed::SendStream::new(SinkSend::new(log.clone())), - VERSION, - ); - ( - adapter, - Reader::new(crate::transport::boxed::RecvStream::new(recv), VERSION), - writer, - log, - ) - } - - #[moq_clock::test] - async fn legacy_multiplexing_counts_a_control_body_once() { - use crate::{ - coding::{Encode, Stream}, - lite::test_transport::{Log, ScriptedSession, SinkSend}, - stats::{Bytes, Control as Class, Registry, Tier}, - }; - for version in [Version::Draft14, Version::Draft15, Version::Draft16] { - let registry = Registry::new(Default::default()); - let stats = registry.tier(Tier::default()).session(""); - let msg = ietf::FetchCancel { - request_id: RequestId(0), - }; - let body = msg.encode_bytes(version).unwrap(); - let raw_response = encode_raw(ietf::FetchCancel::ID, &body.slice(2..), version); - let mut session = ScriptedSession::new(raw_response.to_vec()); - let (_, recv) = crate::transport::poll::Session::open_bi(&mut session, Default::default()) - .await - .unwrap(); - let adapter = ControlStreamAdapter::new(Transport::new(session.clone()), Control::new(None, true), version) - .with_stats(&stats); - let mut virtual_stream = super::super::request_stream::with_stats( - Stream::open(&mut crate::driver::Transport::new(adapter.clone()), version) - .await - .unwrap(), - &stats, - version, - ); - let msg = ietf::FetchCancel { - request_id: RequestId(0), - }; - let size = msg.encode_bytes(version).unwrap().len() as u64; - virtual_stream.writer.encode_message(&msg).await.unwrap(); - let raw = adapter.shared.control.pop().await.unwrap(); - let log = Log::default(); - let mut physical = Writer::new( - crate::transport::boxed::SendStream::new(SinkSend::new(log.clone())), - version, - ); - physical.write_all(&mut raw.clone()).await.unwrap(); - assert_eq!( - registry.snapshot().control(), - vec![(Tier::default(), Class::Fetch, Bytes { tx: size, rx: 0 })], - "{version:?}" - ); - assert_eq!(*log.writes.lock().unwrap(), raw); - let (_, goaway) = crate::goaway::Handle::new(false); - let mut reading = std::pin::pin!(adapter.run_read( - Reader::new(crate::transport::boxed::RecvStream::new(recv), version), - goaway - )); - assert!(futures::poll!(reading.as_mut()).is_pending()); - assert_eq!(virtual_stream.reader.varint().await.unwrap(), ietf::FetchCancel::ID); - virtual_stream.reader.decode::().await.unwrap(); - assert_eq!( - registry.snapshot().control(), - vec![(Tier::default(), Class::Fetch, Bytes { tx: size, rx: size })], - "virtual decode counted a physical frame twice: {version:?}" - ); - adapter.send_max_request_id(RequestId(123)); - assert!( - registry - .snapshot() - .control() - .iter() - .any(|(_, class, bytes)| *class == Class::Other && bytes.tx > 0), - "adapter-generated messages bypassed the typed writer" - ); - } - } - - #[moq_clock::test] - async fn a_legacy_control_stream_fin_or_reset_is_a_protocol_violation() { - use crate::lite::test_transport::{DeadStreamSession, ScriptedSession}; - for version in [Version::Draft14, Version::Draft15, Version::Draft16] { - let session = ScriptedSession::eof(Vec::new()); - let stream = crate::coding::Stream::open(&mut Transport::new(session.clone()), version) - .await - .unwrap(); - let adapter = ControlStreamAdapter::new(Transport::new(session.clone()), Control::new(None, true), version); - let (_handle, protocol) = crate::goaway::Handle::new(false); - let err = adapter.run(stream.reader, stream.writer, protocol).await.unwrap_err(); - assert!(matches!(err, Error::ProtocolViolation), "{version:?}: {err:?}"); - - let session = DeadStreamSession::bis(0); - let stream = crate::coding::Stream::open(&mut Transport::new(session.clone()), version) - .await - .unwrap(); - let adapter = ControlStreamAdapter::new(Transport::new(session.clone()), Control::new(None, true), version); - let (_handle, protocol) = crate::goaway::Handle::new(false); - let err = adapter.run(stream.reader, stream.writer, protocol).await.unwrap_err(); - assert!(matches!(err, Error::ProtocolViolation), "{version:?}: {err:?}"); - } - } - - /// A STOP_SENDING on a legacy control stream ends the session even with nothing queued - /// to write, while the peer keeps its own half open. - #[moq_clock::test] - async fn a_legacy_control_stream_stopped_while_idle_is_a_protocol_violation() { - use crate::transport::memory; - for version in [Version::Draft14, Version::Draft15, Version::Draft16] { - let (session, mut peer) = memory::pair(memory::Config::default()); - let stream = crate::coding::Stream::open(&mut Transport::new(session.clone()), version) - .await - .unwrap(); - let mut remote = crate::coding::Stream::accept(&mut peer, version).await.unwrap(); - remote.reader.abort(&Error::Cancel); - let adapter = ControlStreamAdapter::new(Transport::new(session.clone()), Control::new(None, true), version); - let (_handle, protocol) = crate::goaway::Handle::new(false); - let res = moq_clock::timeout( - std::time::Duration::from_secs(10), - adapter.run(stream.reader, stream.writer, protocol), - ) - .await - .expect("an idle writer missed the STOP_SENDING"); - assert!(matches!(res, Err(Error::ProtocolViolation)), "{version:?}: {res:?}"); - } - } - - /// A request ID at the MAX_REQUEST_ID we advertised closes the session with the - /// draft's TOO_MANY_REQUESTS, before the request is queued. - #[moq_clock::test] - async fn a_request_past_the_window_closes_the_session() { - let (adapter, reader, writer, _) = windowed(1, &[0, 2], &[]).await; - let (_, goaway) = crate::goaway::Handle::new(true); - let err = adapter.run(reader, writer, goaway).await.unwrap_err(); - assert!( - matches!(err, Error::Session(crate::SessionError::TooManyRequests)), - "{err:?}" - ); - } - - /// An update's own request ID counts against the window, not the subscription it targets. - #[moq_clock::test] - async fn an_update_past_the_window_closes_the_session() { - const VERSION: Version = Version::Draft14; - let update = ietf::SubscribeUpdate { - max_age: None, - new_group: None, - request_id: RequestId(4), - subscription_request_id: Some(RequestId(0)), - start_location: ietf::Location { group: 0, object: 0 }, - end_group: 0, - subscriber_priority: Some(1), - forward: Some(true), - filter: Some(ietf::Filter::NextObject), - authorization_token: None, - fill: None, - }; - let update = encode_raw(ietf::SubscribeUpdate::ID, &encode_body(&update, VERSION), VERSION); - // The target is in the window and the update's own ID is past it. - let (adapter, reader, writer, _) = windowed(2, &[0], &update).await; - let (_, goaway) = crate::goaway::Handle::new(true); - let err = adapter.run(reader, writer, goaway).await.unwrap_err(); - assert!( - matches!(err, Error::Session(crate::SessionError::TooManyRequests)), - "{err:?}" - ); - } - - /// An update aimed at no open request, such as draft 16's SUBSCRIBE_NAMESPACE riding a - /// stream of its own, still gets its one answer on drafts 15 and 16: a REQUEST_ERROR - /// naming the update. Draft 14 answers no update. - #[moq_clock::test] - async fn an_unroutable_update_is_refused() { - use crate::lite::test_transport::{Log, ScriptedSession, SinkSend}; - use crate::transport::poll::Session as _; - - for version in [Version::Draft14, Version::Draft15, Version::Draft16] { - // Own Request ID 2, aimed at request 0, which nothing here holds. Draft 14 carries - // its fixed start, end group, priority and forward before the parameters. - let body: &[u8] = match version { - Version::Draft14 => &[2, 0, 0, 0, 0, 128, 1, 0], - _ => &[2, 0, 0], - }; - let script = encode_raw(ietf::SubscribeUpdate::ID, &Bytes::copy_from_slice(body), version); - let mut session = ScriptedSession::new(script.to_vec()); - let (_, recv) = session.open_bi(Default::default()).await.unwrap(); - let adapter = - ControlStreamAdapter::new(Transport::new(session.clone()), Control::new(None, false), version); - let log = Log::default(); - let writer = Writer::new( - crate::transport::boxed::SendStream::new(SinkSend::new(log.clone())), - version, - ); - let (_, goaway) = crate::goaway::Handle::new(true); - let mut run = std::pin::pin!(adapter.run( - Reader::new(crate::transport::boxed::RecvStream::new(recv), version), - writer, - goaway - )); - assert!(futures::poll!(run.as_mut()).is_pending(), "{version}"); - - let written = log.writes.lock().unwrap().clone(); - match version { - Version::Draft14 => assert!(written.is_empty(), "{version}: {written:?}"), - // [type, length (2), Request ID, NOT_SUPPORTED, ...] - _ => assert_eq!( - (written[0], written[3], written[4]), - (ietf::RequestError::ID as u8, 2, 0x3), - "{version}: {written:?}" - ), - } - } - } - - /// Requests that end are granted back with MAX_REQUEST_ID, once half the window has. - #[moq_clock::test] - async fn retired_requests_are_granted_back() { - use crate::transport::poll::Session as _; - - const VERSION: Version = Version::Draft14; - let (mut adapter, reader, writer, log) = windowed(2, &[0, 2], &[]).await; - let (_, goaway) = crate::goaway::Handle::new(true); - let runner = adapter.clone(); - let mut run = std::pin::pin!(runner.run(reader, writer, goaway)); - assert!(futures::poll!(run.as_mut()).is_pending()); - - let first = adapter.accept_bi().await.unwrap(); - let _second = adapter.accept_bi().await.unwrap(); - assert!(log.writes.lock().unwrap().is_empty(), "nothing has ended yet"); - - drop(first); - assert!(futures::poll!(run.as_mut()).is_pending()); - - let mut expected = Vec::new(); - crate::coding::Encoder::new(&mut expected, VERSION.into()) - .varint(ietf::MaxRequestId::ID) - .unwrap(); - ietf::MaxRequestId { - request_id: RequestId(6), - } - .encode(&mut crate::coding::Encoder::new(&mut expected, VERSION.into()), VERSION) - .unwrap(); - assert_eq!(*log.writes.lock().unwrap(), expected.to_vec()); - } - - #[test] - fn queued_incoming_stream_does_not_keep_shared_alive() { - let shared = Arc::new(Shared::default()); - let weak = Arc::downgrade(&shared); - shared.open_incoming(RequestId(7), Bytes::new(), None).unwrap(); - drop(shared); - assert!(weak.upgrade().is_none()); - } - - #[moq_clock::test] - async fn receive_drop_before_registration_releases_namespace() { - for version in [Version::Draft14, Version::Draft15] { - let shared = Arc::new(Shared::default()); - let (mut send, recv) = shared.open_outgoing(version); - drop(recv); - send.write_chunk(encode_msg(&publish_namespace(RequestId(4), "cluster/ns"), version)) - .await - .unwrap(); - assert!(shared.streams.lock().unwrap().is_empty()); - assert!(matches!(cancel(&shared, "cluster/ns", version), Route::Ignore)); - let _again = advertise(&shared, "cluster/ns", version, RequestId(6)).await; - assert!(matches!( - cancel(&shared, "cluster/ns", version), - Route::CloseStream(RequestId(6)) - )); - } - } - - #[test] - fn test_unresolvable_withdrawal_is_dropped() { - // v14/v15 name their withdrawals, and a name we hold no advertisement for belongs - // to a request that is already gone. Dropping it beats ending the session. - for version in [Version::Draft14, Version::Draft15] { - let shared = Arc::new(Shared::default()); - assert!(matches!(done(&shared, "cluster/ns", version), Route::Ignore)); - assert!(matches!(cancel(&shared, "cluster/ns", version), Route::Ignore)); - } - } -} diff --git a/rs/moq-net/src/ietf/auth.rs b/rs/moq-net/src/ietf/auth.rs index 995d51e1fe5..ac0090e1093 100644 --- a/rs/moq-net/src/ietf/auth.rs +++ b/rs/moq-net/src/ietf/auth.rs @@ -18,7 +18,7 @@ use crate::{Error, Patterns, SessionError}; #[cfg(feature = "async")] use super::Control; -use super::{Message, RequestId, Version, cluster, peer}; +use super::{Message, RequestId, Version, peer}; #[cfg(feature = "async")] use crate::coding::Stream; @@ -27,33 +27,15 @@ use crate::coding::Stream; /// negotiates it. pub const AUTH: u64 = 0x40B70; -/// Whether a version negotiates this extension: draft-17+, like MoQ Cluster. -pub fn supported(version: Version) -> bool { - cluster::supported(version) -} - /// What the peer declared: `None` for no option, otherwise whether it offered the /// extension. Only an explicit 1 negotiates it. -pub fn from_setup(params: &super::Parameters, version: Version) -> Option { - if !supported(version) { - return None; - } +pub fn from_setup(params: &super::Parameters) -> Option { params.get_varint(super::ParameterVarInt::Auth).map(|value| value == 1) } -/// Offer the extension, on the versions that negotiate it. -pub fn into_setup(params: &mut super::Parameters, version: Version) { - if supported(version) { - params.set_varint(super::ParameterVarInt::Auth, 1); - } -} - -/// Refuse a message on a version that cannot negotiate the extension. -fn check_version(version: Version) -> Result<(), DecodeError> { - match supported(version) { - true => Ok(()), - false => Err(DecodeError::Version), - } +/// Offer the extension. +pub fn into_setup(params: &mut super::Parameters) { + params.set_varint(super::ParameterVarInt::Auth, 1); } /// AUTH: the first message on an Auth request stream, presenting a token. @@ -68,13 +50,11 @@ impl Message for Auth { const ID: u64 = 0x40B61; fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { - check_version(version).map_err(|_| EncodeError::Version)?; self.request_id.encode(w, version)?; w.bytes(&self.token) } fn decode_msg(r: &mut Decoder<'_>, version: Version) -> Result { - check_version(version)?; Ok(Self { request_id: RequestId::decode(r, version)?, token: Bytes::copy_from_slice(r.bytes()?), @@ -100,7 +80,6 @@ impl Message for AuthOk { const ID: u64 = 0x40B62; fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { - check_version(version).map_err(|_| EncodeError::Version)?; self.publish.encode(w, version)?; self.subscribe.encode(w, version)?; // 0 means never, so a grant that has already lapsed rounds up to the smallest @@ -113,7 +92,6 @@ impl Message for AuthOk { } fn decode_msg(r: &mut Decoder<'_>, version: Version) -> Result { - check_version(version)?; let publish = Patterns::decode(r, version)?; let subscribe = Patterns::decode(r, version)?; let expires = match r.varint()? { @@ -144,8 +122,7 @@ const MAX_REASON: usize = 8192; impl Message for AuthError { const ID: u64 = 0x40B63; - fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { - check_version(version).map_err(|_| EncodeError::Version)?; + fn encode_msg(&self, w: &mut Encoder<'_>, _: Version) -> Result<(), EncodeError> { if self.reason.len() > MAX_REASON { return Err(EncodeError::TooLarge); } @@ -153,8 +130,7 @@ impl Message for AuthError { w.string(&self.reason) } - fn decode_msg(r: &mut Decoder<'_>, version: Version) -> Result { - check_version(version)?; + fn decode_msg(r: &mut Decoder<'_>, _: Version) -> Result { let code = r.varint()?; if code > u32::MAX as u64 { return Err(DecodeError::InvalidValue); @@ -312,11 +288,8 @@ impl Present { Ok(stream) => stream, Err(err) => return err, }; - stream = super::request_stream::with_stats(stream, &self.stats, self.version); - let request_id = match self.control.next_request_id(&self.runtime).await { - Ok(id) => id, - Err(err) => return err, - }; + stream = stream.with_stats(&self.stats); + let request_id = self.control.next_request_id(); if let Err(err) = stream.writer.encode_message(&Auth { request_id, token }).await { return err; } @@ -589,7 +562,7 @@ mod tests { #[cfg(feature = "async")] #[moq_clock::test] async fn auth_refused_without_credit_spends_no_request_id() { - for version in [Version::Draft17, Version::Draft19] { + for version in [Version::Draft19] { for client in [false, true] { let first = if client { 0 } else { 1 }; let control = Control::new(Some(RequestId(first + 1)), client); @@ -638,7 +611,6 @@ mod tests { #[test] fn setup_option_round_trips_on_supported_drafts() { for version in [ - Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft20, @@ -650,7 +622,7 @@ mod tests { into_setup(&mut params, version); assert_eq!(from_setup(¶ms, version), Some(true), "{version:?}"); } - for version in [Version::Draft14, Version::Draft15, Version::Draft16] { + for version in [Version::Draft15] { let mut params = super::super::Parameters::default(); into_setup(&mut params, version); assert_eq!(params.get_varint(super::super::ParameterVarInt::Auth), None); @@ -735,7 +707,7 @@ mod tests { #[test] fn older_drafts_have_no_auth() { - for version in [Version::Draft14, Version::Draft15, Version::Draft16] { + for version in [Version::Draft15] { let msg = Auth { request_id: RequestId(0), token: Bytes::new(), diff --git a/rs/moq-net/src/ietf/cluster.rs b/rs/moq-net/src/ietf/cluster.rs index f1321350ede..2bb89d1f388 100644 --- a/rs/moq-net/src/ietf/cluster.rs +++ b/rs/moq-net/src/ietf/cluster.rs @@ -44,15 +44,6 @@ pub const ROUTE_COST: u64 = 0x40B58; /// same datacenter. pub const DEFAULT_COST: u64 = 1; -/// Whether a version negotiates this extension. -/// -/// Draft-17 is the first with the unified SETUP: a bare Key-Value-Pair block that a -/// new option slots into without touching the message shape. Earlier drafts exchange -/// SETUP over the legacy control stream, which this extension does not cover. -pub fn supported(version: Version) -> bool { - !matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) -} - /// The ordered list of Hop IDs an advertisement has traversed, from the original /// publisher to the relay immediately upstream of the receiver. /// @@ -221,11 +212,7 @@ pub fn link_cost(local: Option, peer: &Peer) -> u64 { } /// Read the cluster Setup Options out of a decoded SETUP parameter block. -pub fn peer_from_setup(params: &super::Parameters, version: Version) -> Result { - if !supported(version) { - return Ok(Peer::default()); - } - +pub fn peer_from_setup(params: &super::Parameters) -> Result { // 0 is legal here: the peer speaks the extension but withholds its identity. let hop = params.get_varint(super::ParameterVarInt::HopId).map(Hop::from_wire); @@ -238,11 +225,7 @@ pub fn peer_from_setup(params: &super::Parameters, version: Version) -> Result

, version: Version) { - if !supported(version) { - return; - } - +pub fn peer_into_setup(params: &mut super::Parameters, self_hop: Hop, cost: Option) { params.set_varint(super::ParameterVarInt::HopId, self_hop.id()); if let Some(cost) = cost { @@ -495,7 +478,7 @@ mod tests { (Hop::UNKNOWN, None), ] { let mut params = super::super::Parameters::default(); - peer_into_setup(&mut params, self_hop, cost, VERSION); + peer_into_setup(&mut params, self_hop, cost); let mut buf = Vec::new(); params @@ -504,7 +487,7 @@ mod tests { let mut bytes = bytes::Bytes::from(buf); let decoded = crate::coding::decode_buf(&mut bytes, VERSION, super::super::Parameters::decode).unwrap(); - let peer = peer_from_setup(&decoded, VERSION).unwrap(); + let peer = peer_from_setup(&decoded).unwrap(); assert_eq!(peer.hop, Some(self_hop)); assert_eq!(peer.cost, cost); } @@ -515,7 +498,7 @@ mod tests { // The key sits at delta 0x40B54 from the start of the block and the value follows // it directly: a length byte here would make us unreadable to every -01 peer. let mut params = super::super::Parameters::default(); - peer_into_setup(&mut params, hop(42), None, VERSION); + peer_into_setup(&mut params, hop(42), None); let mut buf = Vec::new(); params @@ -527,7 +510,7 @@ mod tests { #[test] fn setup_without_hop_id_is_not_negotiated() { let params = super::super::Parameters::default(); - let peer = peer_from_setup(¶ms, VERSION).unwrap(); + let peer = peer_from_setup(¶ms).unwrap(); assert!(!peer.negotiated()); } @@ -546,17 +529,8 @@ mod tests { let mut bytes = bytes::Bytes::from(buf); let decoded = crate::coding::decode_buf(&mut bytes, VERSION, super::super::Parameters::decode).unwrap(); - let peer = peer_from_setup(&decoded, VERSION).unwrap(); + let peer = peer_from_setup(&decoded).unwrap(); assert!(!peer.negotiated()); } - #[test] - fn setup_options_skipped_before_draft17() { - // Draft-14..16 exchange SETUP over the legacy control stream, which this - // extension does not cover; we neither send nor read the options there. - let mut params = super::super::Parameters::default(); - peer_into_setup(&mut params, hop(42), Some(3), Version::Draft16); - assert!(params.get_varint(super::super::ParameterVarInt::HopId).is_none()); - assert!(!peer_from_setup(¶ms, Version::Draft16).unwrap().negotiated()); - } } diff --git a/rs/moq-net/src/ietf/control.rs b/rs/moq-net/src/ietf/control.rs index e83e0591efc..08ec9bdc839 100644 --- a/rs/moq-net/src/ietf/control.rs +++ b/rs/moq-net/src/ietf/control.rs @@ -1,9 +1,6 @@ -use std::{collections::BTreeMap, task::Poll}; +use std::collections::BTreeMap; -use crate::{ - Error, SessionError, - ietf::{RequestId, Version}, -}; +use crate::{Error, SessionError, ietf::RequestId}; /// The peer's spent request IDs: every ID of its parity below `next`, except the skipped /// `start..end` runs in `missing`. @@ -33,7 +30,7 @@ impl Spent { /// Whether `id` has the peer's parity and was never spent. /// /// No peer reaches 2^62 requests, and refusing the IDs past it keeps `next` from - /// overflowing on a draft-17+ varint, which can carry a full 64 bits. + /// overflowing on a varint that can carry a full 64 bits. fn unused(&self, id: u64) -> bool { id < 1 << 62 && id % 2 == self.next % 2 && (id >= self.next || self.run(id).is_some()) } @@ -63,80 +60,39 @@ impl Spent { } } -/// The MAX_REQUEST_ID that first admits `window` requests from a peer. +/// The most runs of skipped IDs a peer may leave before the session closes. /// -/// A client's request IDs are even from 0 and a server's odd from 1, each stepping by 2. -pub(crate) fn initial_max_request_id(window: u64, peer_client: bool) -> u64 { - let parity = if peer_client { 0 } else { 1 }; - window.saturating_mul(2).saturating_add(parity).min((1 << 62) - 1) -} +/// Each request holds a stream, so stream credit bounds the live ones, but a skipped ID +/// stays remembered after the requests around it end. Forgetting one would make it usable +/// again, so a peer that keeps skipping loses the session instead. Matches `@moq/net`. +const HISTORY: u64 = 240_000; struct ControlState { /// Our own role. client: bool, request_id_next: RequestId, - /// Legacy request headers that must finish before a later ID can be allocated. - /// A count, since two tasks can allocate before either takes its hold. - request_id_sending: usize, - /// None means no flow control (draft17 removed MaxRequestId). - request_id_max: Option, - /// The peer's requests, flow controlled on drafts 14 to 16 only. - incoming: Option, - /// The peer's spent IDs on draft 17 and later, which has no window to bound the runs. - modern: Spent, - /// The most runs `modern` may hold. Forgetting one would make its IDs usable again. + /// The peer's spent IDs, which no window bounds. + spent: Spent, + /// The most runs `spent` may hold. Forgetting one would make its IDs usable again. history: u64, - /// A draft-18 GOAWAY has frozen admission of new peer requests. + /// A GOAWAY has frozen admission of new peer requests. going_away: bool, } -/// The MAX_REQUEST_ID window we grant the peer. -struct Incoming { - /// How many requests the peer may hold open at once. - window: u64, - /// The MAX_REQUEST_ID in force: every request ID the peer uses must be below it. - max: u64, - /// The last MAX_REQUEST_ID the peer was told, so each grant goes out once. - sent: u64, - /// Requests accepted and not yet retired. - live: u64, - /// Requests retired since the last grant. - retired: u64, - /// Every accepted ID, preserving IDs whose requests retired. - spent: Spent, - /// Draft 16 can reorder across streams; drafts 14 and 15 require the next ID. - reorder: bool, -} - #[derive(Clone)] pub(super) struct Control { state: kio::Shared, } -/// The session must keep a committed legacy header alive until this hold ends. -pub(super) struct RequestSend(Control); - -impl Drop for RequestSend { - fn drop(&mut self) { - self.0.state.lock().request_id_sending -= 1; - } -} - impl Control { - /// How long a request waits for MAX_REQUEST_ID credit before giving up. - pub const REQUEST_ID_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(10); - - pub fn new(request_id_max: Option, client: bool) -> Self { + pub fn new(client: bool) -> Self { Self { state: kio::Shared::new(ControlState { client, request_id_next: if client { RequestId(0) } else { RequestId(1) }, - request_id_sending: 0, - request_id_max, - incoming: None, // The peer takes the other parity: a client's IDs are even, a server's odd. - modern: Spent::new(u64::from(client)), - history: crate::session::Limits::default().window(), + spent: Spent::new(u64::from(client)), + history: HISTORY, going_away: false, }), } @@ -147,37 +103,20 @@ impl Control { self.state.lock().client } - /// Flow control the peer's requests (drafts 14 to 16), admitting `window` at once. - /// - /// `client` is our own role, as passed to [`Self::new`]; the window starts at what - /// [`initial_max_request_id`] advertised in our SETUP. - pub fn with_window(self, window: u64, client: bool, version: Version) -> Self { - let max = initial_max_request_id(window, !client); - self.state.lock().incoming = Some(Incoming { - window, - max, - sent: max, - live: 0, - retired: 0, - spent: Spent::new(u64::from(client)), - reorder: version == Version::Draft16, - }); - self - } - - /// Bound the runs of skipped IDs a draft-17+ peer may leave, closing the session with + /// Bound the runs of skipped IDs the peer may leave, closing the session with /// INTERNAL_ERROR past `limit` rather than forgetting any. + #[cfg(test)] pub fn with_history(self, limit: u64) -> Self { self.state.lock().history = limit; self } - /// Freeze draft-18 admission and name the smallest peer ID not admitted: the first one - /// a reordered stream skipped, or else the next. + /// Freeze admission and name the smallest peer ID not admitted: the first one a + /// reordered stream skipped, or else the next. pub fn goaway(&self) -> Result { let mut state = self.state.lock(); - let modern = &state.modern; - let cutoff = modern.missing.keys().next().copied().unwrap_or(modern.next); + let spent = &state.spent; + let cutoff = spent.missing.keys().next().copied().unwrap_or(spent.next); if cutoff >= 1 << 62 { return Err(SessionError::Internal.into()); } @@ -185,145 +124,31 @@ impl Control { Ok(RequestId(cutoff)) } - pub fn max_request_id(&self, max: RequestId) { - // Mutating through the guard wakes any `next_request_id` waiting on the limit. - self.state.lock().request_id_max = Some(max); - } - - /// Admit a request the peer opened, held open until the returned permit drops. + /// Admit a request the peer opened. /// - /// Closes the session with TOO_MANY_REQUESTS when the ID is at or past the - /// MAX_REQUEST_ID we advertised, or its live requests exceed the window. - /// Drafts 14/15 require the next ID; draft 16 permits cross-stream reordering. - /// Used IDs close with INVALID_REQUEST_ID even after retirement, on every draft. - /// `None` when the peer's requests are not flow controlled (draft 17 and later). - pub fn accept(&self, id: RequestId) -> Result, Error> { + /// Used IDs close with INVALID_REQUEST_ID even after retirement, and every ID once + /// GOAWAY froze admission is refused with [`Error::GoingAway`]. + pub fn accept(&self, id: RequestId) -> Result<(), Error> { let mut state = self.state.lock(); let state = &mut *state; - let Some(incoming) = &mut state.incoming else { - let modern = &mut state.modern; - if !modern.unused(id.0) { - return Err(SessionError::InvalidRequestId.into()); - } - if modern.splits(id.0) && modern.missing.len() as u64 >= state.history { - tracing::warn!(limit = state.history, "request ID history exhausted"); - return Err(SessionError::Internal.into()); - } - modern.spend(id.0); - return if state.going_away { - Err(Error::GoingAway) - } else { - Ok(None) - }; - }; - if id.0 >= incoming.max { - tracing::warn!(id = %id, max = incoming.max, live = incoming.live, "peer exceeded MAX_REQUEST_ID"); - return Err(SessionError::TooManyRequests.into()); - } - let unused = match incoming.reorder { - true => incoming.spent.unused(id.0), - false => id.0 == incoming.spent.next, - }; - if !unused { + let spent = &mut state.spent; + if !spent.unused(id.0) { return Err(SessionError::InvalidRequestId.into()); } - if incoming.live >= incoming.window { - return Err(SessionError::TooManyRequests.into()); - } - incoming.spent.spend(id.0); - incoming.live += 1; - Ok(Some(RequestPermit(self.clone()))) - } - - /// Retire one accepted request, growing the window once half of it has retired. - /// - /// Batching keeps the MAX_REQUEST_ID traffic a fraction of the requests it grants. - fn retire(&self) { - let mut state = self.state.lock(); - let Some(incoming) = &mut state.incoming else { - return; - }; - incoming.live -= 1; - incoming.retired += 1; - if incoming.retired.saturating_mul(2) >= incoming.window { - let grant = incoming.retired.saturating_mul(2); - incoming.max = incoming.max.saturating_add(grant).min((1 << 62) - 1); - incoming.retired = 0; - } - } - - /// Poll for a MAX_REQUEST_ID the peer has not been told yet. - /// - /// Pending forever when the peer's requests are not flow controlled. - pub fn poll_grant(&self, waiter: &kio::Waiter) -> Poll { - let ready = self.state.poll(waiter, |state| match &state.incoming { - Some(incoming) if incoming.max > incoming.sent => Poll::Ready(()), - _ => Poll::Pending, - }); - let mut state = std::task::ready!(ready); - let incoming = state.incoming.as_mut().expect("checked above"); - incoming.sent = incoming.max; - Poll::Ready(RequestId(incoming.max)) - } - - /// Hold later allocations until an already allocated legacy header is sent. - pub fn sending(&self) -> RequestSend { - self.state.lock().request_id_sending += 1; - RequestSend(self.clone()) - } - - /// Allocate the next request_id once credit and the committed header allow it, without - /// giving up: for a caller that waits on credit beside its other work. - pub fn poll_next_request_id(&self, waiter: &kio::Waiter) -> Poll { - let allowed = self.state.poll(waiter, |state| { - let allowed = match state.request_id_max { - None => true, - Some(max) => state.request_id_next < max, - }; - match allowed && state.request_id_sending == 0 { - true => Poll::Ready(()), - false => Poll::Pending, - } - }); - let mut state = std::task::ready!(allowed); - Poll::Ready(state.request_id_next.increment()) - } - - /// Allocate the next request_id once credit and the committed header allow it, or give - /// up with [`Error::Cancel`] once `timeout` passes. - /// - /// Arm `timeout` with [`Self::REQUEST_ID_TIMEOUT`] on the caller's clock. - pub fn poll_credit( - &self, - waiter: &kio::Waiter, - timeout: &mut crate::time::Deadline, - ) -> Poll> { - if let Poll::Ready(id) = self.poll_next_request_id(waiter) { - return Poll::Ready(Ok(id)); + if spent.splits(id.0) && spent.missing.len() as u64 >= state.history { + tracing::warn!(limit = state.history, "request ID history exhausted"); + return Err(SessionError::Internal.into()); } - if timeout.poll(waiter).is_ready() { - tracing::warn!("timed out waiting for MAX_REQUEST_ID"); - return Poll::Ready(Err(Error::Cancel)); + spent.spend(id.0); + match state.going_away { + true => Err(Error::GoingAway), + false => Ok(()), } - Poll::Pending } - /// Allocate the next request_id once credit and the committed header allow it. - /// - /// `runtime` arms the give-up timer, so the wait cannot outlive the caller's - /// clock. - pub async fn next_request_id(&self, runtime: &crate::time::Deadlines) -> Result { - let mut timeout = crate::time::Deadline::after(runtime, Self::REQUEST_ID_TIMEOUT); - kio::wait(|waiter| self.poll_credit(waiter, &mut timeout)).await - } -} - -/// One request the peer holds open, retired (and eventually granted back) on drop. -pub(super) struct RequestPermit(Control); - -impl Drop for RequestPermit { - fn drop(&mut self) { - self.0.retire(); + /// Allocate the next request ID. + pub fn next_request_id(&self) -> RequestId { + self.state.lock().request_id_next.increment() } } @@ -334,18 +159,18 @@ mod tests { #[test] fn goaway_freezes_request_admission_at_current_progress() { for client in [false, true] { - let control = Control::new(None, client); + let control = Control::new(client); let first = u64::from(client); assert_eq!(control.goaway().unwrap(), RequestId(first)); assert!(matches!(control.accept(RequestId(first)), Err(Error::GoingAway))); - let control = Control::new(None, client); + let control = Control::new(client); control.accept(RequestId(first)).unwrap(); control.accept(RequestId(first + 2)).unwrap(); assert_eq!(control.goaway().unwrap(), RequestId(first + 4)); // A reordered stream skipped first + 2, which is the smallest ID not processed. - let control = Control::new(None, client); + let control = Control::new(client); control.accept(RequestId(first)).unwrap(); control.accept(RequestId(first + 4)).unwrap(); assert_eq!(control.goaway().unwrap(), RequestId(first + 2)); @@ -360,162 +185,13 @@ mod tests { } } - fn granted(control: &Control) -> Option { - match control.poll_grant(&kio::Waiter::noop()) { - Poll::Ready(max) => Some(max.0), - Poll::Pending => None, - } - } - - /// The window admits exactly its size, refuses the next ID with TOO_MANY_REQUESTS, - /// and grants room back in batches as requests retire. - #[test] - fn window_refills_as_requests_retire() { - // We are the server, so the client's IDs are even: 0, 2, 4, 6. - let control = Control::new(None, false).with_window(4, false, Version::Draft15); - assert_eq!(initial_max_request_id(4, true), 8); - - let mut open: Vec<_> = (0..4) - .map(|i| control.accept(RequestId(i * 2)).unwrap().unwrap()) - .collect(); - assert!(matches!( - control.accept(RequestId(8)), - Err(Error::Session(SessionError::TooManyRequests)) - )); - assert_eq!(granted(&control), None, "nothing retired yet"); - - // One retired is below half the window, so nothing is granted yet. - open.pop(); - assert_eq!(granted(&control), None); - - // Half the window retired: two more IDs. - open.pop(); - assert_eq!(granted(&control), Some(12)); - assert_eq!(granted(&control), None, "each grant goes out once"); - - let _a = control.accept(RequestId(8)).unwrap(); - let _b = control.accept(RequestId(10)).unwrap(); - assert!(control.accept(RequestId(12)).is_err()); - } - - /// An ID remains spent after its request ends, across every request type. - #[test] - fn retired_or_lower_request_ids_are_refused() { - for later in [0, 2] { - let control = Control::new(None, false).with_window(8, false, Version::Draft15); - for id in [0, 2, 4] { - drop(control.accept(RequestId(id)).unwrap()); - } - let err = control.accept(RequestId(later)).err().expect("spent ID refused"); - assert_eq!(SessionError::from(&err).to_code(), 0x4); - } - } - - #[test] - fn a_duplicate_is_invalid_even_when_the_window_is_full() { - for client in [false, true] { - let control = Control::new(None, client).with_window(1, client, Version::Draft15); - let id = RequestId(u64::from(client)); - let _held = control.accept(id).unwrap(); - assert!(matches!( - control.accept(id), - Err(Error::Session(SessionError::InvalidRequestId)) - )); - } - } - - /// The first ID and every subsequent request must be exactly the next in sequence. - #[test] - fn skipped_and_wrong_parity_request_ids_are_refused() { - for client in [false, true] { - let first = u64::from(client); - for prefix in [0, 1, 2] { - for gap in [2, 4, 1] { - let control = Control::new(None, client).with_window(8, client, Version::Draft15); - for index in 0..prefix { - drop(control.accept(RequestId(first + 2 * index)).unwrap()); - } - let err = control - .accept(RequestId(first + 2 * prefix + gap)) - .err() - .expect("non-sequential ID refused"); - assert_eq!(SessionError::from(&err), SessionError::InvalidRequestId); - } - } - } - } - - #[test] - fn draft16_independent_streams_can_arrive_out_of_order() { - for client in [false, true] { - let control = Control::new(None, client).with_window(8, client, Version::Draft16); - let first = u64::from(client); - for id in [first + 2, first, first + 6, first + 4] { - drop(control.accept(RequestId(id)).expect("independent stream arrival order")); - } - for id in [first, first + 2, first + 4, first + 6] { - assert!(matches!( - control.accept(RequestId(id)), - Err(Error::Session(SessionError::InvalidRequestId)) - )); - } - } - } - - #[test] - fn draft16_remembers_only_missing_ids_while_other_requests_retire() { - let control = Control::new(None, false).with_window(4, false, Version::Draft16); - for id in 1..1024 { - drop(control.accept(RequestId(id * 2)).unwrap()); - let state = control.state.lock(); - let missing = &state.incoming.as_ref().unwrap().spent.missing; - assert_eq!(missing.iter().collect::>(), [(&0, &2)]); - } - drop(control.accept(RequestId(0)).unwrap()); - assert!(control.state.lock().incoming.as_ref().unwrap().spent.missing.is_empty()); - for id in [0, 2, 2046] { - assert!(matches!( - control.accept(RequestId(id)), - Err(Error::Session(SessionError::InvalidRequestId)) - )); - } - } - - /// Skipping to the top of a production-sized window records one run, not every ID. - #[test] - fn draft16_a_jump_is_one_run_split_only_by_requests_inside_it() { - let window = crate::session::Limits::default().window(); - let control = Control::new(None, false).with_window(window, false, Version::Draft16); - let top = 2 * (window - 1); - let runs = |control: &Control| { - let state = control.state.lock(); - let missing = &state.incoming.as_ref().unwrap().spent.missing; - missing.iter().map(|(&start, &end)| (start, end)).collect::>() - }; - - drop(control.accept(RequestId(top)).unwrap()); - assert_eq!(runs(&control), [(0, top)]); - - for id in [100, 0, top - 2] { - drop(control.accept(RequestId(id)).unwrap()); - } - assert_eq!(runs(&control), [(2, 100), (102, top - 2)]); - - for id in [0, 100, top - 2, top] { - assert!(matches!( - control.accept(RequestId(id)), - Err(Error::Session(SessionError::InvalidRequestId)) - )); - } - } - #[test] - fn modern_requests_reject_reuse_and_wrong_parity() { + fn requests_reject_reuse_and_wrong_parity() { for client in [false, true] { - let control = Control::new(None, client); + let control = Control::new(client); let first = u64::from(client); for id in [first + 4, first, first + 2] { - assert!(control.accept(RequestId(id)).unwrap().is_none()); + control.accept(RequestId(id)).unwrap(); } for id in [first, first + 2, first + 4, first ^ 1] { assert!( @@ -532,20 +208,20 @@ mod tests { /// Contiguous arrival in either order leaves no runs, and a full history refuses a new /// gap rather than forgetting an old one. #[test] - fn modern_history_coalesces_and_never_forgets() { + fn history_coalesces_and_never_forgets() { for reversed in [false, true] { - let control = Control::new(None, false).with_history(1); + let control = Control::new(false).with_history(1); for n in 0..4096 { let id = if reversed { 4095 - n } else { n } * 2; control.accept(RequestId(id)).unwrap(); } - assert!(control.state.lock().modern.missing.is_empty()); + assert!(control.state.lock().spent.missing.is_empty()); assert!(matches!( control.accept(RequestId(0)), Err(Error::Session(SessionError::InvalidRequestId)) )); } - let control = Control::new(None, false).with_history(1); + let control = Control::new(false).with_history(1); control.accept(RequestId(0)).unwrap(); control.accept(RequestId(4)).unwrap(); assert!(matches!( @@ -563,12 +239,12 @@ mod tests { } #[test] - fn modern_sparse_ids_do_not_allocate_the_gap() { - let control = Control::new(None, false).with_history(1); + fn sparse_ids_do_not_allocate_the_gap() { + let control = Control::new(false).with_history(1); let top = (1 << 62) - 2; control.accept(RequestId(top)).unwrap(); control.accept(RequestId(0)).unwrap(); - let runs: Vec<_> = control.state.lock().modern.missing.clone().into_iter().collect(); + let runs: Vec<_> = control.state.lock().spent.missing.clone().into_iter().collect(); assert_eq!(runs, [(2, top)]); for id in [top, 1 << 62, u64::MAX - 1] { assert!(matches!( @@ -577,29 +253,4 @@ mod tests { )); } } - - /// Draft-17+ has no MAX_REQUEST_ID: nothing is granted. - #[test] - fn unlimited_without_a_window() { - let control = Control::new(None, true); - assert!(control.accept(RequestId(1)).unwrap().is_none()); - assert_eq!(granted(&control), None); - } - - /// Allocation waits until every overlapping legacy header hold has ended. - #[moq_clock::test] - async fn overlapping_send_holds_block_allocation_until_all_end() { - let control = Control::new(None, false); - let clock = crate::time::sim(); - let a = control.sending(); - let b = control.sending(); - drop(a); - let mut next = std::pin::pin!(control.next_request_id(&clock)); - assert!(kio::Waiter::noop().poll_future(next.as_mut()).is_pending()); - drop(b); - assert!(matches!( - kio::Waiter::noop().poll_future(next.as_mut()), - Poll::Ready(Ok(RequestId(1))) - )); - } } diff --git a/rs/moq-net/src/ietf/datagram.rs b/rs/moq-net/src/ietf/datagram.rs index 6d7f18bbae9..595322665dd 100644 --- a/rs/moq-net/src/ietf/datagram.rs +++ b/rs/moq-net/src/ietf/datagram.rs @@ -1,9 +1,7 @@ -//! OBJECT_DATAGRAM: one Object carried in a QUIC datagram (draft-14 section 10.3.1 through -//! draft-20 section 11.3.1). +//! OBJECT_DATAGRAM: one Object carried in a QUIC datagram (draft-20 section 11.3.1). //! //! Public [`crate::Datagram`] writers emit Object ID 0; private relay metadata preserves -//! other IDs, properties, and status. The Type is a set of flags; draft-14 lacks the -//! DEFAULT_PRIORITY bit and a status with an omitted Object ID. +//! other IDs, properties, and status. The Type is a set of flags. use bytes::Bytes; @@ -38,7 +36,7 @@ pub struct ObjectDatagram { pub group_id: u64, /// The Object ID, or `None` when the ZERO_OBJECT_ID bit omits it (Object 0). pub object_id: Option, - /// The Publisher Priority, or `None` to inherit the subscription's (draft-15+). + /// The Publisher Priority, or `None` to inherit the subscription's. pub publisher_priority: Option, /// No Object past this one exists in the group. pub end_of_group: bool, @@ -48,13 +46,9 @@ pub struct ObjectDatagram { } impl ObjectDatagram { - /// Whether `kind` is a Type this draft defines. - fn valid(kind: u64, version: Version) -> bool { - match version { - Version::Draft14 => kind <= 0x07 || kind == 0x20 || kind == 0x21, - // A status cannot also end the group. - _ => kind & !flag::ALL == 0 && !(kind & flag::STATUS != 0 && kind & flag::END_OF_GROUP != 0), - } + /// Whether `kind` is a defined Type. A status cannot also end the group. + fn valid(kind: u64) -> bool { + kind & !flag::ALL == 0 && !(kind & flag::STATUS != 0 && kind & flag::END_OF_GROUP != 0) } /// The Type bits this datagram's fields set. @@ -80,10 +74,9 @@ impl ObjectDatagram { } impl crate::model::datagram::Wire { - /// Whether `version`, the draft its track's publisher spoke, defines a datagram of this - /// shape, as its ingress checks one. Egress resolves the Object ID and priority each - /// draft needs. - pub(crate) fn defined(&self, version: Version) -> bool { + /// Whether a datagram of this shape is defined, as ingress checks one. Egress resolves + /// the Object ID and priority each draft needs. + pub(crate) fn defined(&self) -> bool { let shape = ObjectDatagram { track_alias: 0, group_id: 0, @@ -96,24 +89,19 @@ impl crate::model::datagram::Wire { None => DatagramBody::Payload(Bytes::new()), }, }; - ObjectDatagram::valid(shape.kind(), version) + ObjectDatagram::valid(shape.kind()) && self.status.is_none_or(|status| { - super::object::status_defined(status, version) - && (self.properties.block.is_none() || carries_properties(status, version)) + super::object::status_defined(status) && (self.properties.block.is_none() || status == 0) }) } } -/// Whether `version` lets a datagram of Object Status `status` carry properties: from -/// draft-17 on, only a Normal Object may. -pub(super) fn carries_properties(status: u64, version: Version) -> bool { - status == 0 || matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) -} + impl Encode for ObjectDatagram { - fn encode(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { + fn encode(&self, w: &mut Encoder<'_>, _: Version) -> Result<(), EncodeError> { let kind = self.kind(); - if !Self::valid(kind, version) { + if !Self::valid(kind) { return Err(EncodeError::InvalidState); } @@ -136,7 +124,8 @@ impl Encode for ObjectDatagram { match &self.body { DatagramBody::Status(status) => { - if self.properties.is_some() && !carries_properties(*status, version) { + // Only a Normal Object may carry properties. + if self.properties.is_some() && *status != 0 { return Err(EncodeError::InvalidState); } w.varint(*status)? @@ -151,9 +140,9 @@ impl Encode for ObjectDatagram { } impl Decode for ObjectDatagram { - fn decode(r: &mut Decoder<'_>, version: Version) -> Result { + fn decode(r: &mut Decoder<'_>, _: Version) -> Result { let kind = r.varint()?; - if !Self::valid(kind, version) { + if !Self::valid(kind) { return Err(DecodeError::InvalidValue); } @@ -181,7 +170,7 @@ impl Decode for ObjectDatagram { let body = match kind & flag::STATUS != 0 { true => { let status = r.varint()?; - if properties.is_some() && !carries_properties(status, version) { + if properties.is_some() && status != 0 { return Err(DecodeError::InvalidValue); } if !r.is_empty() { @@ -215,10 +204,6 @@ mod tests { } const ALL: [Version; 9] = [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft20, @@ -308,7 +293,7 @@ mod tests { body: DatagramBody::Status(3), }; for version in ALL { - let legacy = matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16); + let legacy = false; match datagram.encode_bytes(version) { Ok(buf) => { assert!(legacy, "{version}"); diff --git a/rs/moq-net/src/ietf/epoch.rs b/rs/moq-net/src/ietf/epoch.rs index 34f99e994c2..013920c52fa 100644 --- a/rs/moq-net/src/ietf/epoch.rs +++ b/rs/moq-net/src/ietf/epoch.rs @@ -24,21 +24,14 @@ pub const EPOCH: u64 = 0x40B68; /// value is length-prefixed. pub const EPOCH_PARAM: u64 = 0x40B69; -/// Whether a version negotiates this extension: draft-17+, like MoQ Cluster. -pub fn supported(version: Version) -> bool { - !matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) -} - /// Whether the peer declared the option. -pub fn from_setup(params: &super::Parameters, version: Version) -> bool { - supported(version) && params.get_varint(super::ParameterVarInt::Epoch).is_some() +pub fn from_setup(params: &super::Parameters) -> bool { + params.get_varint(super::ParameterVarInt::Epoch).is_some() } /// Declare that we understand the EPOCH parameter. -pub fn into_setup(params: &mut super::Parameters, version: Version) { - if supported(version) { - params.set_varint(super::ParameterVarInt::Epoch, 1); - } +pub fn into_setup(params: &mut super::Parameters) { + params.set_varint(super::ParameterVarInt::Epoch, 1); } impl Param for Epoch { @@ -66,13 +59,11 @@ mod tests { } #[test] - fn only_draft17_and_later_negotiate() { - for version in [Version::Draft14, Version::Draft16, Version::Draft17, Version::Draft22] { - let mut params = super::super::Parameters::default(); - assert!(!from_setup(¶ms, version)); - into_setup(&mut params, version); - assert_eq!(from_setup(¶ms, version), supported(version), "{version:?}"); - } + fn declared_option_negotiates() { + let mut params = super::super::Parameters::default(); + assert!(!from_setup(¶ms)); + into_setup(&mut params); + assert!(from_setup(¶ms)); } #[test] diff --git a/rs/moq-net/src/ietf/error.rs b/rs/moq-net/src/ietf/error.rs index de60a3a2142..ee711790324 100644 --- a/rs/moq-net/src/ietf/error.rs +++ b/rs/moq-net/src/ietf/error.rs @@ -8,33 +8,16 @@ //! //! Sent on RESET_STREAM and STOP_SENDING, and read back off both. The values are the //! draft's, not [`StreamError::to_code`]'s: the two registries agree on most of what they -//! both assign, but not all of it, and this one grew (and moved a value) across the drafts -//! we negotiate, so a code only means something once you know which draft carried it. -//! -//! | Code | draft-14/15 | draft-16 | draft-17 | draft-18+ | -//! |------|-------------|----------|----------|-----------| -//! | 0x0 | INTERNAL_ERROR | INTERNAL_ERROR | INTERNAL_ERROR | INTERNAL_ERROR | -//! | 0x1 | CANCELLED | CANCELLED | CANCELLED | CANCELLED | -//! | 0x2 | DELIVERY_TIMEOUT | DELIVERY_TIMEOUT | DELIVERY_TIMEOUT | DELIVERY_TIMEOUT | -//! | 0x3 | SESSION_CLOSED | SESSION_CLOSED | SESSION_CLOSED | SESSION_CLOSED | -//! | 0x4 | - | UNKNOWN_OBJECT_STATUS | UNKNOWN_OBJECT_STATUS | GOING_AWAY | -//! | 0x5 | - | - | TOO_FAR_BEHIND | TOO_FAR_BEHIND | -//! | 0x12 | - | MALFORMED_TRACK | MALFORMED_TRACK | MALFORMED_TRACK | -//! -//! Encoding and decoding therefore move together and both take the negotiated version: -//! GOING_AWAY sent to a draft-17 peer reads as UNKNOWN_OBJECT_STATUS, and a draft-17 -//! peer's UNKNOWN_OBJECT_STATUS read as GOING_AWAY would retire a session that is not -//! going anywhere. +//! both assign, but not all of it. use super::Version; use crate::{SessionError, StreamError}; /// An implementation-specific error: the stream died on our side, with no registry entry -/// for why. Assigned by every draft we negotiate. +/// for why. pub const INTERNAL_ERROR: u32 = 0x0; /// The stream was cancelled by either endpoint. A routine unsubscribe, not a failure. -/// Assigned by every draft we negotiate. pub const CANCELLED: u32 = 0x1; /// The content missed its delivery deadline. @@ -43,43 +26,21 @@ const DELIVERY_TIMEOUT: u32 = 0x2; /// The session is closing, taking this stream with it. const SESSION_CLOSED: u32 = 0x3; -/// A GOAWAY was sent or received. Draft-18 and later; draft-16 and 17 gave 0x4 to -/// UNKNOWN_OBJECT_STATUS instead. +/// A GOAWAY was sent or received. const GOING_AWAY: u32 = 0x4; -/// The subscription outran the publisher's resource limits. Draft-17 and later. +/// The subscription outran the publisher's resource limits. const TOO_FAR_BEHIND: u32 = 0x5; -/// The track's content could not be parsed. Draft-16 and later. +/// The track's content could not be parsed. const MALFORMED_TRACK: u32 = 0x12; -/// Whether the draft assigns 0x4 to GOING_AWAY. -/// -/// Draft-16 and 17 assign it to UNKNOWN_OBJECT_STATUS, which draft-18 moved to 0x6 when it -/// took 0x4 for this. Draft-14 and 15 assign it nothing. -fn has_going_away(version: Version) -> bool { - matches!( - version, - Version::Draft18 | Version::Draft19 | Version::Draft20 | Version::Draft21 | Version::Draft22 - ) -} - -/// Whether the draft assigns TOO_FAR_BEHIND. Added in draft-17. -fn has_too_far_behind(version: Version) -> bool { - !matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) -} - -/// Whether the draft assigns MALFORMED_TRACK. Added in draft-16. -fn has_malformed_track(version: Version) -> bool { - !matches!(version, Version::Draft14 | Version::Draft15) -} - -/// The code to reset a stream, or send STOP_SENDING, with on the negotiated draft. +/// The code to reset a stream, or send STOP_SENDING, with. /// /// Conditions without a matching reset code use INTERNAL_ERROR. Request rejection has /// its own registry: a missing track belongs in a request error response, not a reset. /// moq-lite's own 48-63 range and its application offset have no corresponding ranges here. -pub fn to_stream_code(err: &StreamError, version: Version) -> u32 { +pub fn to_stream_code(err: &StreamError) -> u32 { match err { StreamError::Internal => INTERNAL_ERROR, StreamError::Cancel => CANCELLED, @@ -90,30 +51,30 @@ pub fn to_stream_code(err: &StreamError, version: Version) -> u32 { // Flattened, as on the moq-lite wire: the session registry is disjoint, so the // specific reason travels on the session close instead. StreamError::Session(_) => SESSION_CLOSED, - StreamError::GoingAway if has_going_away(version) => GOING_AWAY, - StreamError::TooFarBehind if has_too_far_behind(version) => TOO_FAR_BEHIND, - StreamError::MalformedTrack if has_malformed_track(version) => MALFORMED_TRACK, + StreamError::GoingAway => GOING_AWAY, + StreamError::TooFarBehind => TOO_FAR_BEHIND, + StreamError::MalformedTrack => MALFORMED_TRACK, _ => INTERNAL_ERROR, } } -/// Read a stream reset (or STOP_SENDING) code received on the negotiated draft. +/// Read a stream reset (or STOP_SENDING) code. /// -/// A code the draft does not assign stays [`StreamError::Unknown`], which surfaces as +/// A code the drafts do not assign stays [`StreamError::Unknown`], which surfaces as /// [`Error::Stream`](crate::Error::Stream): an error, but never one given a meaning it did /// not carry. That includes the codes this crate has no local counterpart for /// (UNKNOWN_OBJECT_STATUS, EXCESSIVE_LOAD) and every value a later /// draft may add. -pub fn from_stream_code(code: u32, version: Version) -> StreamError { +pub fn from_stream_code(code: u32) -> StreamError { match code { INTERNAL_ERROR => StreamError::Internal, CANCELLED => StreamError::Cancel, DELIVERY_TIMEOUT => StreamError::DeliveryTimeout, // The peer's session code is not on this stream, so the reason is unknown here. SESSION_CLOSED => StreamError::Session(SessionError::Internal), - GOING_AWAY if has_going_away(version) => StreamError::GoingAway, - TOO_FAR_BEHIND if has_too_far_behind(version) => StreamError::TooFarBehind, - MALFORMED_TRACK if has_malformed_track(version) => StreamError::MalformedTrack, + GOING_AWAY => StreamError::GoingAway, + TOO_FAR_BEHIND => StreamError::TooFarBehind, + MALFORMED_TRACK => StreamError::MalformedTrack, code => StreamError::Unknown(code), } } @@ -131,55 +92,34 @@ pub(crate) fn to_session_code(error: &SessionError) -> u32 { /// The moq-transport request error registry, per negotiated draft. /// -/// Sent in a rejection response to a request, and read back off one. Draft-14 gives each -/// error message its own registry and they disagree about 0x4; draft-15 folded them all -/// into REQUEST_ERROR with a single registry that renumbered almost everything. So a -/// request code only means something once you know both the draft and, on draft-14, which -/// request it answers. -/// -/// | Condition | 14 SUBSCRIBE | 14 FETCH | 14 PUBLISH | 14 ANNOUNCE | 14 SUB_NS | 15+ | -/// |-----------|--------------|----------|------------|-------------|-----------|-----| -/// | INTERNAL_ERROR | 0x0 | 0x0 | 0x0 | 0x0 | 0x0 | 0x0 | -/// | UNAUTHORIZED | 0x1 | 0x1 | 0x1 | 0x1 | 0x1 | 0x1 | -/// | TIMEOUT | 0x2 | 0x2 | 0x2 | 0x2 | 0x2 | 0x2 | -/// | NOT_SUPPORTED | 0x3 | 0x3 | 0x3 | 0x3 | 0x3 | 0x3 | -/// | DOES_NOT_EXIST | 0x4 | 0x4 | - | - | - | 0x10 | -/// | UNINTERESTED | - | - | 0x4 | 0x4 | - | 0x20 | -/// | MALFORMED_TRACK | - | 0x9 | - | - | - | 0x12 | -/// | EXPIRED_AUTH_TOKEN | 0x12 | 0x12 | - | 0x12 | 0x12 | 0x5 | -/// | GOING_AWAY | - | - | - | - | - | 0x6 (17+) | -/// | UNSUPPORTED_EXTENSION | - | - | - | - | - | 0x33 (18+) | -/// -/// The renumbering is the trap: draft-14 SUBSCRIBE_ERROR gives 0x4 to TRACK_DOES_NOT_EXIST -/// and 0x10 to MALFORMED_AUTH_TOKEN, and draft-15 swaps the two. Sending either number -/// without the draft in hand tells the peer the opposite of what happened. +/// Sent in a rejection response to a request, and read back off one. The registry is +/// disjoint from the stream reset one, so the same integer means something else there. pub(crate) mod request { use super::Version; use crate::{DecodeError, Error, SessionError, StreamError}; - /// Which request the error answers, so draft-14 picks the right registry. + /// Which request the error answers. /// - /// Draft-15 and later carry one REQUEST_ERROR registry for every request, so from there - /// on the kind only decides what a refused route says: not here to a request for - /// content, uninterested to an offer of it. + /// Every request shares one REQUEST_ERROR registry, so the kind only decides what a + /// refused route says (not here to a request for content, uninterested to an offer of + /// it) and which codes only FETCH carries. #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub(crate) enum Kind { - /// SUBSCRIBE_ERROR, draft-14 section 13.1.2. + /// SUBSCRIBE. Subscribe, - /// FETCH_ERROR, draft-14 section 13.1.5. + /// FETCH. Fetch, - /// PUBLISH_ERROR, draft-14 section 13.1.4. + /// PUBLISH. Publish, - /// ANNOUNCE_ERROR, draft-14 section 13.1.6. + /// PUBLISH_NAMESPACE. PublishNamespace, - /// SUBSCRIBE_NAMESPACE_ERROR, draft-14 section 13.1.7. + /// SUBSCRIBE_NAMESPACE. SubscribeNamespace, - /// TRACK_STATUS_ERROR on draft-14, REQUEST_ERROR later. + /// TRACK_STATUS. TrackStatus, } - /// An implementation-specific error, with no registry entry for why. Assigned by every - /// draft, for every request. + /// An implementation-specific error, with no registry entry for why. const INTERNAL_ERROR: u64 = 0x0; /// The peer's credentials do not cover the request. @@ -191,86 +131,47 @@ pub(crate) mod request { /// The endpoint does not implement this request at all, as opposed to refusing this one. pub(crate) const NOT_SUPPORTED: u64 = 0x3; - /// A second subscription to a track the peer already subscribes to. Draft-16 and later. + /// A second subscription to a track the peer already subscribes to. pub(crate) const DUPLICATE_SUBSCRIPTION: u64 = 0x19; - /// The endpoint is overloaded and cannot process the request. Draft-18 and later. + /// The endpoint is overloaded and cannot process the request. pub(crate) const EXCESSIVE_LOAD: u64 = 0x9; /// A SUBSCRIBE_NAMESPACE or SUBSCRIBE_TRACKS prefix overlapping an established one. - /// Draft-15 and later. pub(crate) const PREFIX_OVERLAP: u64 = 0x30; - /// A GOAWAY is draining the session, so no new request is accepted. Draft-17 and later. + /// A GOAWAY is draining the session, so no new request is accepted. const GOING_AWAY: u64 = 0x6; - /// The requested broadcast or track is not here, as draft-14 numbers it under the name - /// TRACK_DOES_NOT_EXIST. - const DOES_NOT_EXIST_14: u64 = 0x4; - - /// An invalid FETCH range: draft-14 FETCH_ERROR and draft-15+ REQUEST_ERROR. - const INVALID_RANGE_14: u64 = 0x5; + /// An invalid FETCH range. const INVALID_RANGE: u64 = 0x11; - /// The track holds a Mandatory Track Property the endpoint does not understand. Draft-18 - /// and later; draft-15 gave 0x33 another meaning. + /// The track holds a Mandatory Track Property the endpoint does not understand. const UNSUPPORTED_EXTENSION: u64 = 0x33; /// A Range Filter exceeds MAX_FILTER_RANGES (draft-19 and later). pub(crate) const INVALID_FILTER: u64 = 0x36; /// A joining FETCH named no active subscription. Removed from the registry in draft-20. - const INVALID_JOINING_REQUEST_ID_14: u64 = 0x7; const INVALID_JOINING_REQUEST_ID: u64 = 0x32; - /// The same condition from draft-15 on, renamed DOES_NOT_EXIST and moved off 0x4. + /// The requested broadcast or track is not here. const DOES_NOT_EXIST: u64 = 0x10; - /// The offered content is not wanted here, as draft-14 numbers it. - const UNINTERESTED_14: u64 = 0x4; - - /// The same condition from draft-15 on. + /// The offered content is not wanted here. const UNINTERESTED: u64 = 0x20; - /// The track's content could not be parsed, as draft-14 numbers it on FETCH_ERROR. - const MALFORMED_TRACK_14: u64 = 0x9; - - /// The same condition from draft-15 on. + /// The track's content could not be parsed. const MALFORMED_TRACK: u64 = 0x12; - /// A well-formed AUTHORIZATION TOKEN this endpoint cannot use, as draft-14 numbers it. - const MALFORMED_AUTH_TOKEN_14: u64 = 0x10; - - /// The same condition from draft-15 on, where 0x10 became DOES_NOT_EXIST. + /// A well-formed AUTHORIZATION TOKEN this endpoint cannot use. const MALFORMED_AUTH_TOKEN: u64 = 0x4; - /// An expired AUTHORIZATION TOKEN, as draft-14 numbers it. - const EXPIRED_AUTH_TOKEN_14: u64 = 0x12; - - /// The same condition from draft-15 on, where 0x12 became MALFORMED_TRACK. + /// An expired AUTHORIZATION TOKEN. const EXPIRED_AUTH_TOKEN: u64 = 0x5; - /// The value for "the thing you asked for is not here", or `None` where the draft and - /// request assign none. - fn does_not_exist(kind: Kind, version: Version) -> Option { - match version { - Version::Draft14 => match kind { - Kind::Subscribe | Kind::Fetch | Kind::TrackStatus => Some(DOES_NOT_EXIST_14), - _ => None, - }, - _ => Some(DOES_NOT_EXIST), - } - } - - fn invalid_range(kind: Kind, version: Version) -> Option { - if kind != Kind::Fetch { - return None; - } - Some(if version == Version::Draft14 { - INVALID_RANGE_14 - } else { - INVALID_RANGE - }) + fn invalid_range(kind: Kind) -> Option { + (kind == Kind::Fetch).then_some(INVALID_RANGE) } fn invalid_joining_request_id(kind: Kind, version: Version) -> Option { @@ -278,75 +179,13 @@ pub(crate) mod request { return None; } match version { - Version::Draft14 => Some(INVALID_JOINING_REQUEST_ID_14), - Version::Draft15 | Version::Draft16 | Version::Draft17 | Version::Draft18 | Version::Draft19 => { + Version::Draft18 | Version::Draft19 => { Some(INVALID_JOINING_REQUEST_ID) } _ => None, } } - /// The value for "we do not want this", or `None` where the draft and request assign - /// none. Draft-14 registers it only on the two requests that offer content. - fn uninterested(kind: Kind, version: Version) -> Option { - match version { - Version::Draft14 => match kind { - Kind::Publish | Kind::PublishNamespace => Some(UNINTERESTED_14), - _ => None, - }, - _ => Some(UNINTERESTED), - } - } - - /// The value for a track we could not parse, or `None` where the draft and request - /// assign none. - fn malformed_track(kind: Kind, version: Version) -> Option { - match version { - Version::Draft14 => match kind { - Kind::Fetch => Some(MALFORMED_TRACK_14), - _ => None, - }, - _ => Some(MALFORMED_TRACK), - } - } - - /// The value for an unusable token, or `None` where the draft and request assign none. - /// Draft-14 registers none on PUBLISH_ERROR. - fn malformed_auth_token(kind: Kind, version: Version) -> Option { - match (version, kind) { - (Version::Draft14, Kind::Publish) => None, - (Version::Draft14, _) => Some(MALFORMED_AUTH_TOKEN_14), - _ => Some(MALFORMED_AUTH_TOKEN), - } - } - - /// The value for an expired token, or `None` where the draft and request assign none. - /// Draft-14 registers none on PUBLISH_ERROR. - fn expired_auth_token(kind: Kind, version: Version) -> Option { - match (version, kind) { - (Version::Draft14, Kind::Publish) => None, - (Version::Draft14, _) => Some(EXPIRED_AUTH_TOKEN_14), - _ => Some(EXPIRED_AUTH_TOKEN), - } - } - - /// The value for a track needing a property we do not understand, or `None` before - /// draft-18 registered one. - fn unsupported_extension(version: Version) -> Option { - match version { - Version::Draft14 | Version::Draft15 | Version::Draft16 | Version::Draft17 => None, - _ => Some(UNSUPPORTED_EXTENSION), - } - } - - /// The value for a draining session, or `None` before draft-17 registered one. - fn going_away(version: Version) -> Option { - match version { - Version::Draft14 | Version::Draft15 | Version::Draft16 => None, - _ => Some(GOING_AWAY), - } - } - /// The code to reject a request with, on the negotiated draft. /// /// Lossy on purpose, like [`to_stream_code`](super::to_stream_code): an error says what went @@ -359,7 +198,7 @@ pub(crate) mod request { Error::Unauthorized | Error::Session(SessionError::Unauthorized) | Error::Stream(StreamError::Unauthorized) => return UNAUTHORIZED, - Error::Expired | Error::Session(SessionError::Expired) => expired_auth_token(kind, version), + Error::Expired | Error::Session(SessionError::Expired) => return EXPIRED_AUTH_TOKEN, Error::Timeout | Error::Stream(StreamError::DeliveryTimeout) | Error::Session(SessionError::Timeout) => { return TIMEOUT; } @@ -374,26 +213,27 @@ pub(crate) mod request { // does not implement FETCH at all. Error::NotFound | Error::NotFetchable - | Error::Stream(StreamError::NotFound | StreamError::NotFetchable) => does_not_exist(kind, version), - Error::InvalidRange => invalid_range(kind, version), + | Error::Stream(StreamError::NotFound | StreamError::NotFetchable) => return DOES_NOT_EXIST, + Error::InvalidRange => invalid_range(kind), Error::InvalidJoiningRequestId => invalid_joining_request_id(kind, version), // A path with no route is one we will not carry. A subscriber that asked for it // cannot act on "we do not want it": what it needs to know is that we do not have // it, which is the same refusal from its side. Only the requests that offer content // say UNINTERESTED. - Error::Unroutable | Error::Stream(StreamError::Unroutable) => match kind { - Kind::Subscribe | Kind::Fetch | Kind::TrackStatus => does_not_exist(kind, version), - Kind::Publish | Kind::PublishNamespace | Kind::SubscribeNamespace => uninterested(kind, version), - }, - Error::Decode(DecodeError::MalformedAuthToken) => malformed_auth_token(kind, version), + Error::Unroutable | Error::Stream(StreamError::Unroutable) => { + return match kind { + Kind::Subscribe | Kind::Fetch | Kind::TrackStatus => DOES_NOT_EXIST, + Kind::Publish | Kind::PublishNamespace | Kind::SubscribeNamespace => UNINTERESTED, + }; + } + Error::Decode(DecodeError::MalformedAuthToken) => return MALFORMED_AUTH_TOKEN, // Our own parse failure is, from the peer's side, a malformed track. Error::Decode(_) | Error::BoundsExceeded(_) | Error::MalformedTrack - | Error::Stream(StreamError::MalformedTrack) => malformed_track(kind, version), - Error::GoingAway | Error::Stream(StreamError::GoingAway) => going_away(version), - // Before its code, the closest is that we do not implement what the track needs. - Error::UnsupportedExtension => unsupported_extension(version).or(Some(NOT_SUPPORTED)), + | Error::Stream(StreamError::MalformedTrack) => return MALFORMED_TRACK, + Error::GoingAway | Error::Stream(StreamError::GoingAway) => return GOING_AWAY, + Error::UnsupportedExtension => return UNSUPPORTED_EXTENSION, // Everything else, a duplicate included: no draft assigns it a value, and // INTERNAL_ERROR is how a peer reads an unregistered code anyway. _ => return INTERNAL_ERROR, @@ -411,14 +251,14 @@ pub(crate) mod request { UNAUTHORIZED => Error::Unauthorized, TIMEOUT => Error::Timeout, NOT_SUPPORTED => Error::Unsupported, - code if Some(code) == expired_auth_token(kind, version) => Error::Expired, - code if Some(code) == does_not_exist(kind, version) => Error::NotFound, - code if Some(code) == invalid_range(kind, version) => Error::InvalidRange, + EXPIRED_AUTH_TOKEN => Error::Expired, + DOES_NOT_EXIST => Error::NotFound, + code if Some(code) == invalid_range(kind) => Error::InvalidRange, code if Some(code) == invalid_joining_request_id(kind, version) => Error::InvalidJoiningRequestId, - code if Some(code) == uninterested(kind, version) => Error::Unroutable, - code if Some(code) == malformed_track(kind, version) => Error::MalformedTrack, - code if Some(code) == going_away(version) => Error::GoingAway, - code if Some(code) == unsupported_extension(version) => Error::UnsupportedExtension, + UNINTERESTED => Error::Unroutable, + MALFORMED_TRACK => Error::MalformedTrack, + GOING_AWAY => Error::GoingAway, + UNSUPPORTED_EXTENSION => Error::UnsupportedExtension, code => Error::Remote(u32::try_from(code).unwrap_or(u32::MAX)), } } @@ -427,11 +267,7 @@ pub(crate) mod request { mod tests { use super::*; - const ALL: [Version; 9] = [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, + const ALL: [Version; 5] = [ Version::Draft18, Version::Draft19, Version::Draft20, @@ -483,20 +319,15 @@ pub(crate) mod request { } } - /// Draft-14 numbers a missing track 0x4 and draft-15 moved it to 0x10, which is - /// draft-14's MALFORMED_AUTH_TOKEN. Getting this backwards tells a peer its token is - /// broken when the broadcast simply is not here, so it re-authenticates instead of - /// waiting for the announcement. + /// A missing broadcast is DOES_NOT_EXIST, never 0x4, which is MALFORMED_AUTH_TOKEN: + /// getting this backwards tells a peer its token is broken when the broadcast simply + /// is not here, so it re-authenticates instead of waiting for the announcement. #[test] - fn a_missing_broadcast_uses_the_draft_s_own_number() { + fn a_missing_broadcast_is_not_here() { for kind in [Kind::Subscribe, Kind::Fetch] { - assert_eq!(to_code(&Error::NotFound, kind, Version::Draft14), 0x4); - assert!(matches!(from_code(0x4, kind, Version::Draft14), Error::NotFound)); - - for version in ALL.into_iter().skip(1) { + for version in ALL { assert_eq!(to_code(&Error::NotFound, kind, version), 0x10); assert!(matches!(from_code(0x10, kind, version), Error::NotFound)); - // 0x4 is MALFORMED_AUTH_TOKEN from draft-15 on, which is not ours to claim. assert!(matches!(from_code(0x4, kind, version), Error::Remote(0x4))); } } @@ -506,7 +337,6 @@ pub(crate) mod request { // So is a datagram group: never cached, so a FETCH reaching one finds nothing, and // NOT_SUPPORTED would say the endpoint has no FETCH at all. - assert_eq!(to_code(&Error::NotFetchable, Kind::Fetch, Version::Draft14), 0x4); assert_eq!(to_code(&Error::NotFetchable, Kind::Fetch, Version::Draft20), 0x10); // Including a lite-07 upstream's NOT_FETCHABLE, bridged by a relay. assert_eq!( @@ -515,99 +345,35 @@ pub(crate) mod request { ); } - /// Draft-14 gives 0x4 to UNINTERESTED on the requests that offer content and to - /// TRACK_DOES_NOT_EXIST on the ones that ask for it, so the same integer on the same - /// draft says two different things. + /// A refused route says UNINTERESTED to the requests that offer content. #[test] - fn draft_14_reads_0x4_per_request() { - for kind in [Kind::Publish, Kind::PublishNamespace] { - assert_eq!(to_code(&Error::Unroutable, kind, Version::Draft14), 0x4); - assert!(matches!(from_code(0x4, kind, Version::Draft14), Error::Unroutable)); - // Those requests offer content, so "it is not here" is not a rejection they - // can carry. - assert_eq!(to_code(&Error::NotFound, kind, Version::Draft14), INTERNAL_ERROR); + fn an_unroutable_offer_is_uninterested() { + for kind in [Kind::Publish, Kind::PublishNamespace, Kind::SubscribeNamespace] { + assert_eq!(to_code(&Error::Unroutable, kind, Version::Draft20), 0x20); + assert!(matches!(from_code(0x20, kind, Version::Draft20), Error::Unroutable)); } - - // And neither meaning reaches a request draft-14 gives neither to. - assert!(matches!( - from_code(0x4, Kind::SubscribeNamespace, Version::Draft14), - Error::Remote(0x4) - )); } - /// Draft-15 swapped MALFORMED_AUTH_TOKEN and the missing-track code, and draft-14 - /// gives PUBLISH_ERROR no value for it. #[test] - fn a_malformed_token_uses_the_draft_s_own_number() { + fn token_refusals_use_their_codes() { let err = Error::Decode(DecodeError::MalformedAuthToken); - for kind in KINDS { - let draft14 = if kind == Kind::Publish { INTERNAL_ERROR } else { 0x10 }; - assert_eq!(to_code(&err, kind, Version::Draft14), draft14); - for version in ALL.into_iter().skip(1) { + for version in ALL { + for kind in KINDS { assert_eq!(to_code(&err, kind, version), 0x4); - } - } - } - - /// Draft-15 moved EXPIRED_AUTH_TOKEN from 0x12 to 0x5, and draft-14 gives PUBLISH_ERROR - /// no value for it. - #[test] - fn an_expired_token_uses_the_draft_s_own_number() { - for kind in KINDS { - if kind == Kind::Publish { - assert_eq!(to_code(&Error::Expired, kind, Version::Draft14), INTERNAL_ERROR); - } else { - assert_eq!(to_code(&Error::Expired, kind, Version::Draft14), 0x12); - assert!(matches!(from_code(0x12, kind, Version::Draft14), Error::Expired)); - } - for version in ALL.into_iter().skip(1) { assert_eq!(to_code(&Error::Expired, kind, version), 0x5); assert!(matches!(from_code(0x5, kind, version), Error::Expired)); } } } - /// GOING_AWAY arrived in draft-17. Sent to an earlier peer, 0x6 is unassigned there, - /// so say INTERNAL_ERROR outright rather than a number that means nothing. #[test] - fn going_away_only_exists_from_draft_17() { - for kind in KINDS { - for version in [Version::Draft14, Version::Draft15, Version::Draft16] { - assert_eq!(to_code(&Error::GoingAway, kind, version), INTERNAL_ERROR); - assert!(matches!(from_code(GOING_AWAY, kind, version), Error::Remote(0x6))); - } - - for version in [ - Version::Draft17, - Version::Draft18, - Version::Draft19, - Version::Draft20, - Version::Draft21, - Version::Draft22, - ] { + fn going_away_and_unsupported_extension_round_trip() { + for version in ALL { + for kind in KINDS { assert_eq!(to_code(&Error::GoingAway, kind, version), GOING_AWAY); assert!(matches!(from_code(GOING_AWAY, kind, version), Error::GoingAway)); - } - } - } - - /// UNSUPPORTED_EXTENSION arrived in draft-18. Draft-15 gave its 0x33 to - /// UNKNOWN_STATUS_IN_RANGE, so earlier drafts say NOT_SUPPORTED instead. - #[test] - fn unsupported_extension_only_exists_from_draft_18() { - for kind in KINDS { - for version in ALL { - let code = to_code(&Error::UnsupportedExtension, kind, version); - match version { - Version::Draft14 | Version::Draft15 | Version::Draft16 | Version::Draft17 => { - assert_eq!(code, NOT_SUPPORTED, "{version}"); - assert!(!matches!(from_code(0x33, kind, version), Error::UnsupportedExtension)); - } - _ => { - assert_eq!(code, 0x33, "{version}"); - assert!(matches!(from_code(code, kind, version), Error::UnsupportedExtension)); - } - } + assert_eq!(to_code(&Error::UnsupportedExtension, kind, version), 0x33); + assert!(matches!(from_code(0x33, kind, version), Error::UnsupportedExtension)); } } } @@ -615,14 +381,10 @@ pub(crate) mod request { #[test] fn fetch_refusals_follow_each_drafts_registry() { for version in ALL { - let range = if version == Version::Draft14 { 0x5 } else { 0x11 }; - assert_eq!(to_code(&Error::InvalidRange, Kind::Fetch, version), range); - assert!(matches!(from_code(range, Kind::Fetch, version), Error::InvalidRange)); + assert_eq!(to_code(&Error::InvalidRange, Kind::Fetch, version), 0x11); + assert!(matches!(from_code(0x11, Kind::Fetch, version), Error::InvalidRange)); let joining = match version { - Version::Draft14 => Some(0x7), - Version::Draft15 | Version::Draft16 | Version::Draft17 | Version::Draft18 | Version::Draft19 => { - Some(0x32) - } + Version::Draft18 | Version::Draft19 => Some(0x32), _ => None, }; assert_eq!( @@ -660,31 +422,19 @@ pub(crate) mod request { } /// Every code we put in a rejection has to be one the negotiated draft registers for - /// that request. The table is transcribed from the drafts (draft-14 section 13.1 - /// through draft-20 section 15.11.2), not derived from the mapping, so a mistake in - /// the mapping cannot talk the assertion into agreeing with it. + /// that request. The table is transcribed from the drafts (draft-18 section 15.11.2 + /// on), not derived from the mapping, so a mistake in the mapping cannot talk the + /// assertion into agreeing with it. #[test] fn only_registered_codes_reach_the_wire() { - fn registered(kind: Kind, version: Version) -> &'static [u64] { - match (version, kind) { - (Version::Draft14, Kind::Subscribe) => &[0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x10, 0x12], - (Version::Draft14, Kind::Fetch) => &[0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x10, 0x12], - (Version::Draft14, Kind::Publish) => &[0x0, 0x1, 0x2, 0x3, 0x4], - (Version::Draft14, Kind::PublishNamespace) => &[0x0, 0x1, 0x2, 0x3, 0x4, 0x10, 0x12], - (Version::Draft14, Kind::TrackStatus) => &[0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x10, 0x12], - (Version::Draft14, Kind::SubscribeNamespace) => &[0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x10, 0x12], - (Version::Draft15, _) => &[0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x10, 0x11, 0x12, 0x20, 0x30, 0x32, 0x33], - (Version::Draft16, _) => &[0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x10, 0x11, 0x12, 0x19, 0x20, 0x30, 0x32], - (Version::Draft17, _) => &[ - 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x9, 0x10, 0x11, 0x12, 0x19, 0x20, 0x30, 0x31, 0x32, - ], - _ => &[ - 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x9, 0x10, 0x11, 0x12, 0x19, 0x20, 0x30, 0x31, 0x32, 0x33, - 0x34, 0x35, 0x36, - ], - } + fn registered() -> &'static [u64] { + &[ + 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x9, 0x10, 0x11, 0x12, 0x19, 0x20, 0x30, 0x31, 0x32, 0x33, 0x34, + 0x35, 0x36, + ] } + // Sent but never read back as itself: a peer's MALFORMED_AUTH_TOKEN stays remote. let malformed = Error::Decode(DecodeError::MalformedAuthToken); for version in ALL { @@ -692,7 +442,7 @@ pub(crate) mod request { for err in EVERY_ERROR.iter().chain([&malformed]) { let code = to_code(err, kind, version); assert!( - registered(kind, version).contains(&code), + registered().contains(&code), "{err:?} sends {code:#x}, which {version} does not register for {kind:?}" ); } @@ -727,31 +477,17 @@ mod tests { use super::*; use crate::Error; - const ALL: [Version; 9] = [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, - Version::Draft18, - Version::Draft19, - Version::Draft20, - Version::Draft21, - Version::Draft22, - ]; - /// A routine unsubscribe must not read as a fault on our side. moq-lite's own error /// enum encodes a cancellation as 0, which is this wire's INTERNAL_ERROR, so the codes /// come from here instead. #[test] fn a_cancellation_is_not_an_internal_error() { - for version in ALL { - assert_eq!(to_stream_code(&StreamError::Cancel, version), CANCELLED); - assert_eq!(from_stream_code(CANCELLED, version), StreamError::Cancel); - assert!(matches!( - Error::from(from_stream_code(CANCELLED, version)), - Error::Stream(StreamError::Cancel) - )); - } + assert_eq!(to_stream_code(&StreamError::Cancel), CANCELLED); + assert_eq!(from_stream_code(CANCELLED), StreamError::Cancel); + assert!(matches!( + Error::from(from_stream_code(CANCELLED)), + Error::Stream(StreamError::Cancel) + )); assert_ne!( CANCELLED, @@ -781,8 +517,8 @@ mod tests { assert_eq!(to_session_code(&SessionError::App(7)), 64 + 7); } - /// Every code we send must decode back to what we meant on the same draft, or two - /// moq-net peers disagree about what a stream reset said. + /// Every code we send must decode back to what we meant, or two moq-net peers disagree + /// about what a stream reset said. #[test] fn every_emitted_code_round_trips() { let errors = [ @@ -799,85 +535,17 @@ mod tests { StreamError::App(7), ]; - for version in ALL { - for err in &errors { - let code = to_stream_code(err, version); - let decoded = from_stream_code(code, version); - assert_eq!( - to_stream_code(&decoded, version), - code, - "{err:?} on {version:?} did not survive a round trip" - ); - } - - // A session teardown flattens to SESSION_CLOSED and comes back as one, rather - // than as the session's own reason, which the stream never carried. - let code = to_stream_code(&StreamError::Session(SessionError::Unauthorized), version); - assert_eq!(code, SESSION_CLOSED); - assert_eq!( - from_stream_code(code, version), - StreamError::Session(SessionError::Internal) - ); - } - } - - /// Draft-18 took 0x4 for GOING_AWAY from UNKNOWN_OBJECT_STATUS, so the same integer - /// means different things on two drafts we both negotiate. Sending it to draft-17 would - /// claim the next object's status is unknowable; reading theirs as GOING_AWAY would - /// start draining a session that is not going anywhere. - #[test] - fn going_away_only_exists_from_draft_18() { - for version in [Version::Draft14, Version::Draft15, Version::Draft16, Version::Draft17] { - assert_eq!(to_stream_code(&StreamError::GoingAway, version), INTERNAL_ERROR); - assert_eq!(from_stream_code(GOING_AWAY, version), StreamError::Unknown(GOING_AWAY)); + for err in &errors { + let code = to_stream_code(err); + let decoded = from_stream_code(code); + assert_eq!(to_stream_code(&decoded), code, "{err:?} did not survive a round trip"); } - for version in [ - Version::Draft18, - Version::Draft19, - Version::Draft20, - Version::Draft21, - Version::Draft22, - ] { - assert_eq!(to_stream_code(&StreamError::GoingAway, version), GOING_AWAY); - assert_eq!(from_stream_code(GOING_AWAY, version), StreamError::GoingAway); - } - } - - /// The rest of the per-draft registry: TOO_FAR_BEHIND arrived in draft-17 and - /// MALFORMED_TRACK in draft-16, so an older peer must be told neither. - #[test] - fn later_codes_are_not_sent_to_earlier_drafts() { - for version in ALL { - let too_far_behind = to_stream_code(&StreamError::TooFarBehind, version); - let malformed = to_stream_code(&StreamError::MalformedTrack, version); - - assert_eq!( - too_far_behind, - match has_too_far_behind(version) { - true => TOO_FAR_BEHIND, - false => INTERNAL_ERROR, - }, - "{version:?} disagrees about TOO_FAR_BEHIND" - ); - assert_eq!( - malformed, - match has_malformed_track(version) { - true => MALFORMED_TRACK, - false => INTERNAL_ERROR, - }, - "{version:?} disagrees about MALFORMED_TRACK" - ); - } - - assert_eq!( - from_stream_code(TOO_FAR_BEHIND, Version::Draft16), - StreamError::Unknown(TOO_FAR_BEHIND) - ); - assert_eq!( - from_stream_code(MALFORMED_TRACK, Version::Draft15), - StreamError::Unknown(MALFORMED_TRACK) - ); + // A session teardown flattens to SESSION_CLOSED and comes back as one, rather + // than as the session's own reason, which the stream never carried. + let code = to_stream_code(&StreamError::Session(SessionError::Unauthorized)); + assert_eq!(code, SESSION_CLOSED); + assert_eq!(from_stream_code(code), StreamError::Session(SessionError::Internal)); } /// Conditions this registry has no value for say INTERNAL_ERROR rather than borrowing @@ -902,7 +570,7 @@ mod tests { StreamError::Unknown(0x1234), ] { assert_eq!( - to_stream_code(&err, Version::Draft20), + to_stream_code(&err), INTERNAL_ERROR, "{err:?} has no value in this registry" ); @@ -927,9 +595,9 @@ mod tests { 0x3b, 64 + 7, ] { - assert_eq!(from_stream_code(code, Version::Draft20), StreamError::Unknown(code)); + assert_eq!(from_stream_code(code), StreamError::Unknown(code)); assert!(matches!( - Error::from(from_stream_code(code, Version::Draft20)), + Error::from(from_stream_code(code)), Error::Stream(StreamError::Unknown(remote)) if remote == code )); } @@ -965,44 +633,25 @@ mod tests { /// application codes past 64, neither of which this registry has a range for, /// and it assigns 0x4 and 0x5 meanings the earlier drafts give to something else. /// - /// The table is transcribed from the drafts (draft-14 section 13.1.8 through draft-20 - /// section 15.11.4), not derived from the mapping, so a mistake in the mapping cannot - /// talk the assertion into agreeing with it. + /// The table is transcribed from the drafts (draft-18 section 15.11.4 on), not derived + /// from the mapping, so a mistake in the mapping cannot talk the assertion into + /// agreeing with it. #[test] fn only_registered_codes_reach_the_wire() { - fn registered(version: Version) -> &'static [u32] { - match version { - Version::Draft14 | Version::Draft15 => &[0x0, 0x1, 0x2, 0x3], - Version::Draft16 => &[0x0, 0x1, 0x2, 0x3, 0x4, 0x12], - Version::Draft17 => &[0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x9, 0x12], - _ => &[0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x9, 0x12], - } - } - - for version in ALL { - for err in EVERY_ERROR { - let code = to_stream_code(&err, version); - assert!( - registered(version).contains(&code), - "{err:?} sends {code:#x}, which {version} does not register" - ); - } + const REGISTERED: &[u32] = &[0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x9, 0x12]; + for err in EVERY_ERROR { + let code = to_stream_code(&err); + assert!(REGISTERED.contains(&code), "{err:?} sends {code:#x}, which is not registered"); } } /// A relay decodes a peer's code and re-encodes it onto the stream it tears down in - /// response. That hop must not change what the code says, on the same draft. + /// response. That hop must not change what the code says. #[test] fn relaying_a_code_does_not_change_its_meaning() { - for version in ALL { - for code in [INTERNAL_ERROR, CANCELLED, DELIVERY_TIMEOUT, SESSION_CLOSED] { - let relayed = StreamError::from(&Error::from(from_stream_code(code, version))); - assert_eq!( - to_stream_code(&relayed, version), - code, - "{code:#x} changed across a relay on {version:?}" - ); - } + for code in [INTERNAL_ERROR, CANCELLED, DELIVERY_TIMEOUT, SESSION_CLOSED] { + let relayed = StreamError::from(&Error::from(from_stream_code(code))); + assert_eq!(to_stream_code(&relayed), code, "{code:#x} changed across a relay"); } } } diff --git a/rs/moq-net/src/ietf/fetch.rs b/rs/moq-net/src/ietf/fetch.rs index 2cb61e3ebad..e267ac5484d 100644 --- a/rs/moq-net/src/ietf/fetch.rs +++ b/rs/moq-net/src/ietf/fetch.rs @@ -4,7 +4,7 @@ use crate::{ Path, coding::{Decode, DecodeError, Decoder, Encode, EncodeError, Encoder}, ietf::{ - Filter, GroupOrder, Location, Opaque, Parameters, RequestId, + Filter, GroupOrder, Location, Opaque, RequestId, namespace::{decode_track, encode_namespace}, subscribe::has_range_filters, }, @@ -151,20 +151,11 @@ impl Message for Fetch<'_> { let group_order = (self.group_order != GroupOrder::Any).then_some(self.group_order); self.request_id.encode(w, version)?; - if version == Version::Draft17 { - w.varint(0)?; // required_request_id_delta = 0 (draft-17 only, removed in draft-18 per #1615) - } match version { - Version::Draft14 => { - w.u8(self.subscriber_priority); - self.group_order.encode(w, version)?; - self.fetch_type.encode(w, version)?; - w.u8(0); // no parameters - } - Version::Draft15 | Version::Draft16 | Version::Draft17 | Version::Draft18 | Version::Draft19 => { + Version::Draft18 | Version::Draft19 => { self.fetch_type.encode(w, version)?; - let epoch = self.epoch.clone().filter(|_| epoch::supported(version)); + let epoch = self.epoch.clone(); encode_params!(w, version, 0x20 => self.subscriber_priority, 0x22 => group_order, @@ -199,40 +190,22 @@ impl Message for Fetch<'_> { fn decode_msg(buf: &mut Decoder<'_>, version: Version) -> Result { let request_id = RequestId::decode(buf, version)?; - if version == Version::Draft17 { - let _required_request_id_delta = buf.varint()?; - } // The token decodes but grants nothing: the session's grant is what authorizes the request. let (fetch_type, subscriber_priority, group_order, range_filters, fill_timeout, properties_wanted, epoch) = match version { - Version::Draft14 => { - let subscriber_priority = buf.u8()?; - let group_order = GroupOrder::decode(buf, version)?; - let fetch_type = FetchType::decode(buf, version)?; - super::token::single(Parameters::skip_request(buf)?)?; - ( - fetch_type, - Some(subscriber_priority), - Some(group_order), - false, - false, - true, - None, - ) - } - Version::Draft15 | Version::Draft16 | Version::Draft17 | Version::Draft18 | Version::Draft19 => { + Version::Draft18 | Version::Draft19 => { let fetch_type = FetchType::decode(buf, version)?; decode_params!(buf, version, 0x03 => authorization_token: Vec, - 0x0A => fill_timeout: Option where !matches!(version, Version::Draft15 | Version::Draft16 | Version::Draft17), + 0x0A => fill_timeout: Option, 0x20 => subscriber_priority: Option, 0x22 => group_order: Option, 0x25 => subgroup_filter: Vec where has_range_filters(version), 0x26 => object_id_filter: Vec where has_range_filters(version), 0x27 => priority_filter: Vec where has_range_filters(version), 0x28 => object_property_filter: Vec where has_range_filters(version), - epoch::EPOCH_PARAM => epoch: Option where epoch::supported(version), + epoch::EPOCH_PARAM => epoch: Option, ); super::token::single(authorization_token)?; let range_filters = [ @@ -325,150 +298,44 @@ impl Message for Fetch<'_> { #[derive(Debug, Clone, PartialEq, Eq)] pub struct FetchOk { - pub request_id: Option, - pub group_order: GroupOrder, pub end_of_track: bool, /// Drafts 14-19 use the last object plus one, or Object 0 for the whole End Group; /// draft 20 and later use an inclusive End Location. pub end_location: Location, - /// The track's properties, as SUBSCRIBE_OK carries them: MAX_CACHE_DURATION from the - /// draft-14/15 parameters, the Track Properties block from draft-16 on. + /// The track's properties, as SUBSCRIBE_OK carries them. pub properties: super::Properties, } impl Message for FetchOk { const ID: u64 = 0x18; fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { - if matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) { - self.request_id - .expect("request_id required for draft14-16") - .encode(w, version)?; - } else { - assert!(self.request_id.is_none(), "request_id must be None for draft17+"); - } - - match version { - Version::Draft14 => { - self.group_order.encode(w, version)?; - w.bool(self.end_of_track); - self.end_location.encode(w, version)?; - w.u8(0); // no parameters - } - _ => { - // GROUP_ORDER is not a legal FETCH_OK parameter in any draft after 14; the order - // of the response is whatever the FETCH asked for. - w.bool(self.end_of_track); - self.end_location.encode(w, version)?; - encode_params!(w, version,); - // Track Properties are the final field, so nothing may follow. - self.properties.encode(w, version)?; - } - } + // GROUP_ORDER is not a legal FETCH_OK parameter; the order of the response is + // whatever the FETCH asked for. + w.bool(self.end_of_track); + self.end_location.encode(w, version)?; + encode_params!(w, version,); + // Track Properties are the final field, so nothing may follow. + self.properties.encode(w, version)?; Ok(()) } fn decode_msg(buf: &mut Decoder<'_>, version: Version) -> Result { - let request_id = if matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) { - Some(RequestId::decode(buf, version)?) - } else { - None - }; - - match version { - Version::Draft14 => { - let group_order = GroupOrder::decode(buf, version)?; - let end_of_track = buf.bool()?; - let end_location = Location::decode(buf, version)?; - let properties = super::Properties { - max_cache_duration: Parameters::skip_response(buf)?.map(std::time::Duration::from_millis), - ..Default::default() - }; - Ok(Self { - request_id, - group_order, - end_of_track, - end_location, - properties, - }) - } - _ => { - let end_of_track = buf.bool()?; - let end_location = Location::decode(buf, version)?; - // MAX_CACHE_DURATION and GROUP_ORDER are legal on FETCH_OK only in draft-15. - // Draft-16 still knows GROUP_ORDER, so one here is ignored. From draft-17 - // it closes the session. - decode_params!(buf, version, - 0x04 => max_cache_duration: Option where version == Version::Draft15, - 0x22 => group_order: Option where version == Version::Draft15, - ); - // The timescale is read but not surfaced yet: a fetched object without its - // own units arrives untimed. - let mut properties = super::Properties::decode(buf, version)?; - if version == Version::Draft15 { - properties.max_cache_duration = max_cache_duration.map(std::time::Duration::from_millis); - } - - let group_order = group_order.unwrap_or(GroupOrder::Descending); - - Ok(Self { - request_id, - group_order, - end_of_track, - end_location, - properties, - }) - } - } - } -} - -#[derive(Debug, Clone, PartialEq, Eq)] -pub struct FetchError<'a> { - pub request_id: RequestId, - pub error_code: u64, - pub reason_phrase: Cow<'a, str>, -} - -impl Message for FetchError<'_> { - const ID: u64 = 0x19; + let end_of_track = buf.bool()?; + let end_location = Location::decode(buf, version)?; + // FETCH_OK lists no parameters, so any closes the session. + decode_params!(buf, version,); + // The timescale is read but not surfaced yet: a fetched object without its + // own units arrives untimed. + let properties = super::Properties::decode(buf, version)?; - fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { - self.request_id.encode(w, version)?; - w.varint(self.error_code)?; - w.string(&self.reason_phrase)?; - Ok(()) - } - - fn decode_msg(buf: &mut Decoder<'_>, version: Version) -> Result { - let request_id = RequestId::decode(buf, version)?; - let error_code = buf.varint()?; - let reason_phrase = Cow::Owned(buf.string()?); Ok(Self { - request_id, - error_code, - reason_phrase, + end_of_track, + end_location, + properties, }) } } -#[derive(Debug, Clone, PartialEq, Eq)] -pub struct FetchCancel { - pub request_id: RequestId, -} -impl Message for FetchCancel { - const ID: u64 = 0x17; - - fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { - self.request_id.encode(w, version)?; - Ok(()) - } - - fn decode_msg(buf: &mut Decoder<'_>, version: Version) -> Result { - let request_id = RequestId::decode(buf, version)?; - Ok(Self { request_id }) - } -} - #[derive(Debug, Clone, PartialEq, Eq)] pub struct FetchHeader { pub request_id: RequestId, @@ -708,178 +575,6 @@ mod tests { crate::coding::decode_buf(&mut buf, version, M::decode_msg) } - #[test] - fn test_fetch_v14_round_trip() { - let msg = Fetch { - request_id: RequestId(1), - subscriber_priority: 128, - group_order: GroupOrder::Descending, - fetch_type: FetchType::Standalone { - namespace: Path::new("test"), - track: "video".into(), - start: Location { group: 0, object: 0 }, - end: Location { group: 10, object: 5 }, - }, - range_filters: false, - fill_timeout: false, - properties_wanted: true, - epoch: None, - }; - - let encoded = encode_message(&msg, Version::Draft14); - let decoded: Fetch = decode_message(&encoded, Version::Draft14).unwrap(); - - assert_eq!(decoded.request_id, RequestId(1)); - assert_eq!(decoded.subscriber_priority, 128); - } - - #[test] - fn test_fetch_v15_round_trip() { - let msg = Fetch { - request_id: RequestId(1), - subscriber_priority: 128, - group_order: GroupOrder::Descending, - fetch_type: FetchType::Standalone { - namespace: Path::new("test"), - track: "video".into(), - start: Location { group: 0, object: 0 }, - end: Location { group: 10, object: 5 }, - }, - range_filters: false, - fill_timeout: false, - properties_wanted: true, - epoch: None, - }; - - let encoded = encode_message(&msg, Version::Draft15); - let decoded: Fetch = decode_message(&encoded, Version::Draft15).unwrap(); - - assert_eq!(decoded.request_id, RequestId(1)); - assert_eq!(decoded.subscriber_priority, 128); - } - - #[test] - fn test_fetch_ok_v14_round_trip() { - let msg = FetchOk { - request_id: Some(RequestId(2)), - group_order: GroupOrder::Descending, - end_of_track: false, - end_location: Location { group: 5, object: 3 }, - properties: Default::default(), - }; - - let encoded = encode_message(&msg, Version::Draft14); - let decoded: FetchOk = decode_message(&encoded, Version::Draft14).unwrap(); - - assert_eq!(decoded.request_id, Some(RequestId(2))); - assert!(!decoded.end_of_track); - assert_eq!(decoded.end_location, Location { group: 5, object: 3 }); - } - - #[test] - fn test_fetch_v16_round_trip() { - let msg = Fetch { - request_id: RequestId(1), - subscriber_priority: 128, - group_order: GroupOrder::Descending, - fetch_type: FetchType::Standalone { - namespace: Path::new("test"), - track: "video".into(), - start: Location { group: 0, object: 0 }, - end: Location { group: 10, object: 5 }, - }, - range_filters: false, - fill_timeout: false, - properties_wanted: true, - epoch: None, - }; - - let encoded = encode_message(&msg, Version::Draft16); - let decoded: Fetch = decode_message(&encoded, Version::Draft16).unwrap(); - - assert_eq!(decoded.request_id, RequestId(1)); - assert_eq!(decoded.subscriber_priority, 128); - } - - #[test] - fn test_fetch_v17_round_trip() { - let msg = Fetch { - request_id: RequestId(1), - subscriber_priority: 128, - group_order: GroupOrder::Descending, - fetch_type: FetchType::Standalone { - namespace: Path::new("test"), - track: "video".into(), - start: Location { group: 0, object: 0 }, - end: Location { group: 10, object: 5 }, - }, - range_filters: false, - fill_timeout: false, - properties_wanted: true, - epoch: None, - }; - - let encoded = encode_message(&msg, Version::Draft17); - let decoded: Fetch = decode_message(&encoded, Version::Draft17).unwrap(); - - assert_eq!(decoded.request_id, RequestId(1)); - assert_eq!(decoded.subscriber_priority, 128); - } - - #[test] - fn test_fetch_ok_v15_round_trip() { - let msg = FetchOk { - request_id: Some(RequestId(2)), - group_order: GroupOrder::Descending, - end_of_track: false, - end_location: Location { group: 5, object: 3 }, - properties: Default::default(), - }; - - let encoded = encode_message(&msg, Version::Draft15); - let decoded: FetchOk = decode_message(&encoded, Version::Draft15).unwrap(); - - assert_eq!(decoded.request_id, Some(RequestId(2))); - assert!(!decoded.end_of_track); - assert_eq!(decoded.end_location, Location { group: 5, object: 3 }); - } - - #[test] - fn test_fetch_ok_v16_round_trip() { - let msg = FetchOk { - request_id: Some(RequestId(2)), - group_order: GroupOrder::Descending, - end_of_track: false, - end_location: Location { group: 5, object: 3 }, - properties: Default::default(), - }; - - let encoded = encode_message(&msg, Version::Draft16); - let decoded: FetchOk = decode_message(&encoded, Version::Draft16).unwrap(); - - assert_eq!(decoded.request_id, Some(RequestId(2))); - assert!(!decoded.end_of_track); - assert_eq!(decoded.end_location, Location { group: 5, object: 3 }); - } - - #[test] - fn test_fetch_ok_v17_round_trip() { - let msg = FetchOk { - request_id: None, - group_order: GroupOrder::Descending, - end_of_track: false, - end_location: Location { group: 5, object: 3 }, - properties: Default::default(), - }; - - let encoded = encode_message(&msg, Version::Draft17); - let decoded: FetchOk = decode_message(&encoded, Version::Draft17).unwrap(); - - assert_eq!(decoded.request_id, None); - assert!(!decoded.end_of_track); - assert_eq!(decoded.end_location, Location { group: 5, object: 3 }); - } - #[test] fn test_fetch_v18_round_trip() { let msg = Fetch { @@ -908,8 +603,6 @@ mod tests { #[test] fn test_fetch_ok_v18_round_trip() { let msg = FetchOk { - request_id: None, - group_order: GroupOrder::Descending, end_of_track: false, end_location: Location { group: 5, object: 3 }, properties: Default::default(), @@ -918,19 +611,15 @@ mod tests { let encoded = encode_message(&msg, Version::Draft18); let decoded: FetchOk = decode_message(&encoded, Version::Draft18).unwrap(); - assert_eq!(decoded.request_id, None); assert!(!decoded.end_of_track); assert_eq!(decoded.end_location, Location { group: 5, object: 3 }); } - /// GROUP_ORDER (0x22) has never been a legal FETCH_OK parameter outside draft-14, where - /// it was a plain field. A draft-15+ peer closes the session with PROTOCOL_VIOLATION when - /// it sees one, so the response carries no parameters at all. + /// GROUP_ORDER (0x22) is not a legal FETCH_OK parameter; a peer closes the session with + /// PROTOCOL_VIOLATION when it sees one, so the response carries no parameters at all. #[test] fn test_fetch_ok_v18_omits_group_order() { let msg = FetchOk { - request_id: None, - group_order: GroupOrder::Descending, end_of_track: false, end_location: Location { group: 5, object: 3 }, properties: Default::default(), @@ -1056,8 +745,7 @@ mod tests { ); } - /// FILL_TIMEOUT arrived in draft-18 and the Range Filters in draft-19; each is still - /// an unknown parameter before then. + /// The Range Filters arrived in draft-19, so they are still unknown parameters before it. #[test] fn test_fetch_parameters_follow_their_draft() { #[rustfmt::skip] @@ -1071,8 +759,7 @@ mod tests { let range_filter = joining(&[0x01, 0x25, 0x00]); for (version, body, ok) in [ - (Version::Draft15, &token, true), - (Version::Draft16, &fill_timeout, false), + (Version::Draft18, &token, true), (Version::Draft18, &fill_timeout, true), (Version::Draft18, &range_filter, false), (Version::Draft19, &range_filter, true), @@ -1095,7 +782,7 @@ mod tests { 0x02, 0x03, 0x00, // Relative Joining: subscription 3, offset 0 0x00, // no parameters ]; - let fetch = decode_message::(&body, Version::Draft16).unwrap(); + let fetch = decode_message::(&body, Version::Draft18).unwrap(); assert_eq!(fetch.subscriber_priority, 128); } } @@ -1238,10 +925,6 @@ mod cache_duration_tests { #[test] fn max_cache_duration_is_read_in_each_drafts_field() { for version in [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft20, @@ -1249,12 +932,7 @@ mod cache_duration_tests { Version::Draft22, ] { for age in [0u64, 30_000] { - let mut payload = match version { - Version::Draft14 => vec![0, 1, 0, 0, 0, 1, 4], - Version::Draft15 => vec![0, 0, 0, 0, 1, 4], - Version::Draft16 => vec![0, 0, 0, 0, 0, 4], - _ => vec![0, 0, 0, 0, 4], - }; + let mut payload = vec![0, 0, 0, 0, 4]; Encoder::new(&mut payload, version.into()).varint(age).unwrap(); let got = FetchOk::decode_msg(&mut Decoder::new(&payload, version.into()), version).unwrap(); assert_eq!( diff --git a/rs/moq-net/src/ietf/filter.rs b/rs/moq-net/src/ietf/filter.rs index 4a4d09a47f6..9e67b79356f 100644 --- a/rs/moq-net/src/ietf/filter.rs +++ b/rs/moq-net/src/ietf/filter.rs @@ -77,11 +77,7 @@ impl Filter { pub(crate) fn is_draft20(version: Version) -> bool { !matches!( version, - Version::Draft14 - | Version::Draft15 - | Version::Draft16 - | Version::Draft17 - | Version::Draft18 + Version::Draft18 | Version::Draft19 ) } @@ -293,19 +289,12 @@ impl Param for Filter { fn param_encode(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { // Inner varints use the draft-15 leading-ones encoding on the drafts that predate // the switch, matching the other length-prefixed parameters. - let sv = match version { - Version::Draft14 | Version::Draft15 | Version::Draft16 => Version::Draft15, - _ => version, - }; + let sv = version; let mut buf = Vec::new(); let mut inner = Encoder::new(&mut buf, sv.into()); match version { - Version::Draft14 - | Version::Draft15 - | Version::Draft16 - | Version::Draft17 - | Version::Draft18 + Version::Draft18 | Version::Draft19 => self.encode_tag(&mut inner, sv)?, Version::Draft20 | Version::Draft21 => self.encode_fields(&mut inner)?, // Draft-22 drops the Length, since the Location Filter Type says which fields follow. @@ -317,8 +306,7 @@ impl Param for Filter { fn param_decode(r: &mut Decoder<'_>, version: Version) -> Result { let sv = match version { - Version::Draft14 | Version::Draft15 | Version::Draft16 => Version::Draft15, - Version::Draft17 | Version::Draft18 | Version::Draft19 => version, + Version::Draft18 | Version::Draft19 => version, // The field count is what carries the meaning, so the value is consumed whole. Version::Draft20 | Version::Draft21 => { return Self::decode_fields(&mut Decoder::new(r.bytes()?, version.into())); diff --git a/rs/moq-net/src/ietf/flate.rs b/rs/moq-net/src/ietf/flate.rs index 1c4ac1c833f..71aa7b38121 100644 --- a/rs/moq-net/src/ietf/flate.rs +++ b/rs/moq-net/src/ietf/flate.rs @@ -11,20 +11,11 @@ pub(super) const COMPRESSION: u64 = 0x40B6C; /// Inflated Size object property, in the MOQ Properties registry. pub(super) const INFLATED: u64 = 0x40B6E; -pub(crate) fn supported(version: Version) -> bool { - !matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) +pub(crate) fn into_setup(parameters: &mut Parameters) { + parameters.set_varint(ParameterVarInt::Flate, 1); } -pub(crate) fn into_setup(parameters: &mut Parameters, version: Version) { - if supported(version) { - parameters.set_varint(ParameterVarInt::Flate, 1); - } -} - -pub(crate) fn from_setup(parameters: &Parameters, version: Version) -> Result { - if !supported(version) { - return Ok(false); - } +pub(crate) fn from_setup(parameters: &Parameters) -> Result { match parameters.get_varint(ParameterVarInt::Flate) { None => Ok(false), Some(1) => Ok(true), @@ -63,36 +54,24 @@ mod tests { use super::*; #[test] - fn negotiation_requires_an_offer_on_draft17_or_later() { + fn negotiation_requires_an_offer() { for version in crate::Versions::all().iter().filter_map(|v| Version::try_from(*v).ok()) { let mut parameters = Parameters::default(); - assert!(!from_setup(¶meters, version).unwrap()); - into_setup(&mut parameters, version); - assert_eq!(from_setup(¶meters, version).unwrap(), supported(version)); + assert!(!from_setup(¶meters).unwrap()); + into_setup(&mut parameters); + assert!(from_setup(¶meters).unwrap()); use crate::coding::{Decode, Encode}; let encoded = parameters.encode_bytes(version).unwrap(); let (decoded, consumed) = Parameters::decode_slice(&encoded, version).unwrap(); assert_eq!(consumed, encoded.len()); - assert_eq!(from_setup(&decoded, version).unwrap(), supported(version)); + assert!(from_setup(&decoded).unwrap()); for invalid in [0, 2, u64::MAX >> 2] { parameters.set_varint(ParameterVarInt::Flate, invalid); - assert_eq!(from_setup(¶meters, version).is_err(), supported(version)); + assert!(from_setup(¶meters).is_err()); } } } - #[test] - fn legacy_setup_is_unchanged() { - for version in [Version::Draft14, Version::Draft15, Version::Draft16] { - let mut parameters = Parameters::default(); - into_setup(&mut parameters, version); - assert_eq!(parameters.get_varint(ParameterVarInt::Flate), None); - } - let mut parameters = Parameters::default(); - into_setup(&mut parameters, Version::Draft17); - assert_eq!(parameters.get_varint(ParameterVarInt::Flate), Some(1)); - } - #[test] fn setup_code_point_is_even_and_not_grease() { assert_eq!(OPTION % 2, 0); diff --git a/rs/moq-net/src/ietf/goaway.rs b/rs/moq-net/src/ietf/goaway.rs index 1c4c11c914c..7a278a10d6a 100644 --- a/rs/moq-net/src/ietf/goaway.rs +++ b/rs/moq-net/src/ietf/goaway.rs @@ -1,4 +1,4 @@ -//! IETF moq-transport-14 goaway message +//! The moq-transport GOAWAY message. use std::borrow::Cow; @@ -12,7 +12,7 @@ use super::Version; #[derive(Clone, Debug)] pub struct GoAway<'a> { pub new_session_uri: Cow<'a, str>, - /// Draft-17: timeout in milliseconds before closing the session + /// Timeout in milliseconds before closing the session. pub timeout: u64, /// Draft-18 only: the smallest of the receiver's Request IDs the sender has not /// processed. Required on the control stream and absent on a request stream. @@ -24,10 +24,7 @@ impl Message for GoAway<'_> { fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { w.string(&self.new_session_uri)?; - // Draft-17+ adds a timeout field. - if !matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) { - w.varint(self.timeout)?; - } + w.varint(self.timeout)?; // Draft-18 (#1559) added the Request ID; draft-19 removed it again (#1623). if version == Version::Draft18 && let Some(request_id) = self.request_id @@ -45,7 +42,6 @@ impl Message for GoAway<'_> { return Err(DecodeError::InvalidValue); } let (timeout, request_id) = match version { - Version::Draft14 | Version::Draft15 | Version::Draft16 => (0, None), // The Request ID is present only on the control stream; each caller checks it // against the stream it read from. Version::Draft18 => { @@ -72,14 +68,14 @@ mod tests { fn encode_message(msg: &M) -> Vec { let mut buf = Vec::new(); - msg.encode_msg(&mut Encoder::new(&mut buf, Version::Draft14.into()), Version::Draft14) + msg.encode_msg(&mut Encoder::new(&mut buf, Version::Draft20.into()), Version::Draft20) .unwrap(); buf.to_vec() } fn decode_message(bytes: &[u8]) -> Result { let mut buf = bytes::Bytes::from(bytes.to_vec()); - crate::coding::decode_buf(&mut buf, Version::Draft14, M::decode_msg) + crate::coding::decode_buf(&mut buf, Version::Draft20, M::decode_msg) } #[test] @@ -110,25 +106,6 @@ mod tests { assert_eq!(decoded.new_session_uri, ""); } - #[test] - fn test_goaway_v17_timeout() { - let msg = GoAway { - new_session_uri: "https://example.com/new".into(), - timeout: 5000, - request_id: None, - }; - - let mut buf = Vec::new(); - msg.encode_msg(&mut Encoder::new(&mut buf, Version::Draft17.into()), Version::Draft17) - .unwrap(); - - let mut bytes = bytes::Bytes::from(buf.to_vec()); - let decoded: GoAway = crate::coding::decode_buf(&mut bytes, Version::Draft17, GoAway::decode_msg).unwrap(); - - assert_eq!(decoded.new_session_uri, "https://example.com/new"); - assert_eq!(decoded.timeout, 5000); - } - #[test] fn test_goaway_v18_timeout() { let msg = GoAway { @@ -142,11 +119,11 @@ mod tests { .unwrap(); // Draft-18 requires a trailing Request ID on the control stream, so the - // v18 body must be exactly one varint longer than the v17 body. - let mut buf17 = Vec::new(); - msg.encode_msg(&mut Encoder::new(&mut buf17, Version::Draft17.into()), Version::Draft17) + // v18 body must be exactly one varint longer than the v19 body. + let mut buf19 = Vec::new(); + msg.encode_msg(&mut Encoder::new(&mut buf19, Version::Draft19.into()), Version::Draft19) .unwrap(); - assert_eq!(buf.len(), buf17.len() + 1, "v18 must append the Request ID varint"); + assert_eq!(buf.len(), buf19.len() + 1, "v18 must append the Request ID varint"); let mut bytes = bytes::Bytes::from(buf.to_vec()); let decoded: GoAway = crate::coding::decode_buf(&mut bytes, Version::Draft18, GoAway::decode_msg).unwrap(); diff --git a/rs/moq-net/src/ietf/group.rs b/rs/moq-net/src/ietf/group.rs index 5fc762771af..14231136233 100644 --- a/rs/moq-net/src/ietf/group.rs +++ b/rs/moq-net/src/ietf/group.rs @@ -37,8 +37,7 @@ impl Decode for ObjectExtensionsLength { /// Encode a frame's presentation timestamp as a moq-transport Object Property. /// /// Matches the LOC encoding of the same registry id so a relay or LOC-aware peer -/// reads the same bytes on drafts that delta-encode KVP type ids. The Timestamp -/// value is always absolute. Writes the raw KVP bytes +/// reads the same bytes. The Timestamp value is always absolute. Writes the raw KVP bytes /// (no outer length prefix); the caller frames the block with its byte length. /// /// The units come from the track's TIMESCALE property, not from here: repeating the @@ -49,22 +48,14 @@ pub fn encode_object_time( w: &mut Encoder<'_>, timestamp: Timestamp, timescale: Timescale, - version: Version, ) -> Result<(), EncodeError> { let timestamp = timestamp.convert(timescale).map_err(|_| EncodeError::BoundsExceeded)?; - encode_object_property_type(w, PROP_TIMESTAMP, 0, version)?; + // The first property's type is a delta from zero, so it is written as is. + w.varint(PROP_TIMESTAMP)?; w.varint(timestamp.value())?; Ok(()) } -fn encode_object_property_type(w: &mut Encoder<'_>, kind: u64, prev: u64, version: Version) -> Result<(), EncodeError> { - let encoded = match version { - Version::Draft14 | Version::Draft15 => kind, - _ => kind.checked_sub(prev).ok_or(EncodeError::BoundsExceeded)?, - }; - w.varint(encoded) -} - /// Decode the same property list as ingest when checking timestamps in wire tests. #[cfg(test)] pub fn decode_object_time( @@ -138,9 +129,6 @@ impl Param for GroupOrder { fn param_decode(r: &mut Decoder<'_>, version: Version) -> Result { let v = u8::param_decode(r, version)?; match version { - Version::Draft14 | Version::Draft15 | Version::Draft16 => Ok(GroupOrder::try_from(v) - .unwrap_or(GroupOrder::Descending) - .any_to_descending()), _ => match v { 1 => Ok(GroupOrder::Ascending), 2 => Ok(GroupOrder::Descending), @@ -189,7 +177,7 @@ impl GroupFlags { // moq-lite always sets this bit on emit because every subgroup starts at object 0. pub const FIRST_OBJECT_BIT: u64 = 0x40; - pub fn encode(&self, version: Version) -> Result { + pub fn encode(&self) -> Result { if self.has_subgroup && self.has_subgroup_object { return Err(EncodeError::InvalidState); } @@ -214,27 +202,18 @@ impl GroupFlags { } // Draft-18+: moq-lite always starts subgroups at object 0 and never has gaps, so // the publisher side sets this on everything it produces. - if self.first_object - && !matches!( - version, - Version::Draft14 | Version::Draft15 | Version::Draft16 | Version::Draft17 - ) { + if self.first_object { id |= Self::FIRST_OBJECT_BIT; } Ok(id) } - pub fn decode(id: u64, version: Version) -> Result { - // Draft-18+ allows bit 0x40 (FIRST_OBJECT), which says the stream carries the - // subgroup from its first published object. Strip it before the range check, but - // keep the value: it is the only signal that a subgroup starts partway through. - // The drafts that predate it carry no such signal, so they are taken at their word. - let legacy = matches!( - version, - Version::Draft14 | Version::Draft15 | Version::Draft16 | Version::Draft17 - ); - let first_object = legacy || (id & Self::FIRST_OBJECT_BIT) != 0; - let id = if legacy { id } else { id & !Self::FIRST_OBJECT_BIT }; + pub fn decode(id: u64) -> Result { + // Bit 0x40 (FIRST_OBJECT) says the stream carries the subgroup from its first + // published object. Strip it before the range check, but keep the value: it is the + // only signal that a subgroup starts partway through. + let first_object = (id & Self::FIRST_OBJECT_BIT) != 0; + let id = id & !Self::FIRST_OBJECT_BIT; let (has_priority, base_id) = if (Self::START..=Self::END).contains(&id) { (true, id) @@ -287,9 +266,9 @@ pub struct GroupHeader { } impl Encode for GroupHeader { - fn encode(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { + fn encode(&self, w: &mut Encoder<'_>, _: Version) -> Result<(), EncodeError> { tracing::trace!(?self, "encoding group header"); - w.varint(self.flags.encode(version)?)?; + w.varint(self.flags.encode()?)?; w.varint(self.track_alias)?; w.varint(self.group_id)?; @@ -310,8 +289,8 @@ impl Encode for GroupHeader { } impl Decode for GroupHeader { - fn decode(r: &mut Decoder<'_>, version: Version) -> Result { - let flags = GroupFlags::decode(r.varint()?, version)?; + fn decode(r: &mut Decoder<'_>, _: Version) -> Result { + let flags = GroupFlags::decode(r.varint()?)?; let track_alias = r.varint()?; let group_id = r.varint()?; @@ -346,7 +325,7 @@ mod tests { /// Encode an object's properties at `version`. fn encode_time(ts: Timestamp, timescale: Timescale, version: Version) -> Vec { let mut buf = Vec::new(); - encode_object_time(&mut Encoder::new(&mut buf, version.into()), ts, timescale, version).unwrap(); + encode_object_time(&mut Encoder::new(&mut buf, version.into()), ts, timescale).unwrap(); buf } @@ -451,150 +430,130 @@ mod tests { #[test] fn test_group_flags_spec_table() { // Type 0x10: No subgroup field, Subgroup ID = 0, No extensions, No end - let flags = GroupFlags::decode(0x10, Version::Draft14).unwrap(); + let flags = GroupFlags::decode(0x10).unwrap(); assert!(!flags.has_subgroup); assert!(!flags.has_subgroup_object); assert!(!flags.has_extensions); assert!(!flags.has_end); assert!(flags.has_priority); - assert_eq!(flags.encode(Version::Draft14).unwrap(), 0x10); + assert_eq!(flags.encode().unwrap(), 0x10); // Type 0x11: No subgroup field, Subgroup ID = 0, Extensions, No end - let flags = GroupFlags::decode(0x11, Version::Draft14).unwrap(); + let flags = GroupFlags::decode(0x11).unwrap(); assert!(!flags.has_subgroup); assert!(!flags.has_subgroup_object); assert!(flags.has_extensions); assert!(!flags.has_end); - assert_eq!(flags.encode(Version::Draft14).unwrap(), 0x11); + assert_eq!(flags.encode().unwrap(), 0x11); // Type 0x12: No subgroup field, Subgroup ID = First Object ID, No extensions, No end - let flags = GroupFlags::decode(0x12, Version::Draft14).unwrap(); + let flags = GroupFlags::decode(0x12).unwrap(); assert!(!flags.has_subgroup); assert!(flags.has_subgroup_object); assert!(!flags.has_extensions); assert!(!flags.has_end); - assert_eq!(flags.encode(Version::Draft14).unwrap(), 0x12); + assert_eq!(flags.encode().unwrap(), 0x12); // Type 0x13: No subgroup field, Subgroup ID = First Object ID, Extensions, No end - let flags = GroupFlags::decode(0x13, Version::Draft14).unwrap(); + let flags = GroupFlags::decode(0x13).unwrap(); assert!(!flags.has_subgroup); assert!(flags.has_subgroup_object); assert!(flags.has_extensions); assert!(!flags.has_end); - assert_eq!(flags.encode(Version::Draft14).unwrap(), 0x13); + assert_eq!(flags.encode().unwrap(), 0x13); // Type 0x14: Subgroup field present, No extensions, No end - let flags = GroupFlags::decode(0x14, Version::Draft14).unwrap(); + let flags = GroupFlags::decode(0x14).unwrap(); assert!(flags.has_subgroup); assert!(!flags.has_subgroup_object); assert!(!flags.has_extensions); assert!(!flags.has_end); - assert_eq!(flags.encode(Version::Draft14).unwrap(), 0x14); + assert_eq!(flags.encode().unwrap(), 0x14); // Type 0x15: Subgroup field present, Extensions, No end - let flags = GroupFlags::decode(0x15, Version::Draft14).unwrap(); + let flags = GroupFlags::decode(0x15).unwrap(); assert!(flags.has_subgroup); assert!(!flags.has_subgroup_object); assert!(flags.has_extensions); assert!(!flags.has_end); - assert_eq!(flags.encode(Version::Draft14).unwrap(), 0x15); + assert_eq!(flags.encode().unwrap(), 0x15); // Type 0x18: No subgroup field, Subgroup ID = 0, No extensions, End of group - let flags = GroupFlags::decode(0x18, Version::Draft14).unwrap(); + let flags = GroupFlags::decode(0x18).unwrap(); assert!(!flags.has_subgroup); assert!(!flags.has_subgroup_object); assert!(!flags.has_extensions); assert!(flags.has_end); - assert_eq!(flags.encode(Version::Draft14).unwrap(), 0x18); + assert_eq!(flags.encode().unwrap(), 0x18); // Type 0x19: No subgroup field, Subgroup ID = 0, Extensions, End of group - let flags = GroupFlags::decode(0x19, Version::Draft14).unwrap(); + let flags = GroupFlags::decode(0x19).unwrap(); assert!(!flags.has_subgroup); assert!(!flags.has_subgroup_object); assert!(flags.has_extensions); assert!(flags.has_end); - assert_eq!(flags.encode(Version::Draft14).unwrap(), 0x19); + assert_eq!(flags.encode().unwrap(), 0x19); // Type 0x1A: No subgroup field, Subgroup ID = First Object ID, No extensions, End of group - let flags = GroupFlags::decode(0x1A, Version::Draft14).unwrap(); + let flags = GroupFlags::decode(0x1A).unwrap(); assert!(!flags.has_subgroup); assert!(flags.has_subgroup_object); assert!(!flags.has_extensions); assert!(flags.has_end); - assert_eq!(flags.encode(Version::Draft14).unwrap(), 0x1A); + assert_eq!(flags.encode().unwrap(), 0x1A); // Type 0x1B: No subgroup field, Subgroup ID = First Object ID, Extensions, End of group - let flags = GroupFlags::decode(0x1B, Version::Draft14).unwrap(); + let flags = GroupFlags::decode(0x1B).unwrap(); assert!(!flags.has_subgroup); assert!(flags.has_subgroup_object); assert!(flags.has_extensions); assert!(flags.has_end); - assert_eq!(flags.encode(Version::Draft14).unwrap(), 0x1B); + assert_eq!(flags.encode().unwrap(), 0x1B); // Type 0x1C: Subgroup field present, No extensions, End of group - let flags = GroupFlags::decode(0x1C, Version::Draft14).unwrap(); + let flags = GroupFlags::decode(0x1C).unwrap(); assert!(flags.has_subgroup); assert!(!flags.has_subgroup_object); assert!(!flags.has_extensions); assert!(flags.has_end); - assert_eq!(flags.encode(Version::Draft14).unwrap(), 0x1C); + assert_eq!(flags.encode().unwrap(), 0x1C); // Type 0x1D: Subgroup field present, Extensions, End of group - let flags = GroupFlags::decode(0x1D, Version::Draft14).unwrap(); + let flags = GroupFlags::decode(0x1D).unwrap(); assert!(flags.has_subgroup); assert!(!flags.has_subgroup_object); assert!(flags.has_extensions); assert!(flags.has_end); - assert_eq!(flags.encode(Version::Draft14).unwrap(), 0x1D); + assert_eq!(flags.encode().unwrap(), 0x1D); // Invalid: Both has_subgroup and has_subgroup_object (would be 0x16) - assert!(GroupFlags::decode(0x16, Version::Draft14).is_err()); + assert!(GroupFlags::decode(0x16).is_err()); } #[test] fn test_group_flags_no_priority_range() { // v15: 0x30 range = same flags as 0x10 range but no priority - let flags = GroupFlags::decode(0x30, Version::Draft14).unwrap(); + let flags = GroupFlags::decode(0x30).unwrap(); assert!(!flags.has_priority); assert!(!flags.has_subgroup); assert!(!flags.has_extensions); assert!(!flags.has_end); - assert_eq!(flags.encode(Version::Draft14).unwrap(), 0x30); + assert_eq!(flags.encode().unwrap(), 0x30); - let flags = GroupFlags::decode(0x38, Version::Draft14).unwrap(); + let flags = GroupFlags::decode(0x38).unwrap(); assert!(!flags.has_priority); assert!(flags.has_end); - assert_eq!(flags.encode(Version::Draft14).unwrap(), 0x38); + assert_eq!(flags.encode().unwrap(), 0x38); - let flags = GroupFlags::decode(0x3D, Version::Draft14).unwrap(); + let flags = GroupFlags::decode(0x3D).unwrap(); assert!(!flags.has_priority); assert!(flags.has_subgroup); assert!(flags.has_extensions); assert!(flags.has_end); - assert_eq!(flags.encode(Version::Draft14).unwrap(), 0x3D); + assert_eq!(flags.encode().unwrap(), 0x3D); // Invalid: Both has_subgroup and has_subgroup_object in no-priority range - assert!(GroupFlags::decode(0x36, Version::Draft14).is_err()); - } - - /// Draft-18 introduces the FIRST_OBJECT bit (0x40) per spec §11.4.2. - /// Plain groups set it; relayed groups preserve the publisher's claim. - #[test] - fn test_first_object_bit_draft18() { - // Encoding sets bit 0x40 for default flags. - let flags = GroupFlags::default(); - let encoded = flags.encode(Version::Draft18).unwrap(); - assert_eq!(encoded & GroupFlags::FIRST_OBJECT_BIT, GroupFlags::FIRST_OBJECT_BIT); - // The base value is what draft-17 would have produced. - let v17 = flags.encode(Version::Draft17).unwrap(); - assert_eq!(encoded, v17 | GroupFlags::FIRST_OBJECT_BIT); - - // Decoding accepts and discards the bit. - let decoded = GroupFlags::decode(v17 | GroupFlags::FIRST_OBJECT_BIT, Version::Draft18).unwrap(); - assert_eq!(decoded, flags); - - // Draft-17 rejects the FIRST_OBJECT bit (it's outside the 0x10-0x1d / 0x30-0x3d ranges). - assert!(GroupFlags::decode(v17 | GroupFlags::FIRST_OBJECT_BIT, Version::Draft17).is_err()); + assert!(GroupFlags::decode(0x36).is_err()); } /// FIRST_OBJECT says the stream carries the subgroup from its first published object. @@ -608,13 +567,13 @@ mod tests { first_object, ..Default::default() }; - let encoded = flags.encode(version).unwrap(); + let encoded = flags.encode().unwrap(); assert_eq!( (encoded & GroupFlags::FIRST_OBJECT_BIT) != 0, first_object, "{version} {first_object}" ); - assert_eq!(GroupFlags::decode(encoded, version).unwrap().first_object, first_object); + assert_eq!(GroupFlags::decode(encoded).unwrap().first_object, first_object); } } } @@ -623,14 +582,14 @@ mod tests { /// is taken at its word rather than read as starting partway through. #[test] fn older_drafts_have_no_first_object_signal() { - for version in [Version::Draft14, Version::Draft15, Version::Draft16, Version::Draft17] { + for version in [Version::Draft15] { let flags = GroupFlags { first_object: false, ..Default::default() }; - let encoded = flags.encode(version).unwrap(); + let encoded = flags.encode().unwrap(); assert_eq!(encoded & GroupFlags::FIRST_OBJECT_BIT, 0, "{version}"); - assert!(GroupFlags::decode(encoded, version).unwrap().first_object, "{version}"); + assert!(GroupFlags::decode(encoded).unwrap().first_object, "{version}"); } } @@ -649,10 +608,10 @@ mod tests { first_object: true, }, ] { - let v18 = flags.encode(Version::Draft18).unwrap(); - let v19 = flags.encode(Version::Draft19).unwrap(); + let v18 = flags.encode().unwrap(); + let v19 = flags.encode().unwrap(); assert_eq!(v18, v19, "draft-19 must encode the subgroup header like draft-18"); - assert_eq!(GroupFlags::decode(v19, Version::Draft19).unwrap(), flags); + assert_eq!(GroupFlags::decode(v19).unwrap(), flags); } } @@ -660,14 +619,14 @@ mod tests { #[test] fn test_draft18_extended_range() { // 0x70 = 0x30 (no-priority, no flags) + 0x40 (FIRST_OBJECT) - let flags = GroupFlags::decode(0x70, Version::Draft18).unwrap(); + let flags = GroupFlags::decode(0x70).unwrap(); assert!(!flags.has_priority); assert!(!flags.has_subgroup); assert!(!flags.has_extensions); assert!(!flags.has_end); // 0x7D = 0x3D + 0x40 - let flags = GroupFlags::decode(0x7D, Version::Draft18).unwrap(); + let flags = GroupFlags::decode(0x7D).unwrap(); assert!(!flags.has_priority); assert!(flags.has_subgroup); assert!(flags.has_extensions); @@ -701,7 +660,7 @@ mod tests { ); // The check in session.rs::UniType::classify. assert!( - GroupFlags::decode(type_byte, Version::Draft18).is_ok(), + GroupFlags::decode(type_byte).is_ok(), "draft-18 SUBGROUP_HEADER type 0x{type_byte:02x} not recognized by uni-stream classifier", ); } diff --git a/rs/moq-net/src/ietf/hidden.rs b/rs/moq-net/src/ietf/hidden.rs index 388334a516d..7827926f989 100644 --- a/rs/moq-net/src/ietf/hidden.rs +++ b/rs/moq-net/src/ietf/hidden.rs @@ -34,7 +34,7 @@ mod tests { #[test] fn every_version_round_trips() { - for version in [Version::Draft14, Version::Draft16, Version::Draft17, Version::Draft22] { + for version in [Version::Draft22] { let mut params = super::super::Parameters::default(); assert!(!from_setup(¶ms, version)); into_setup(&mut params, version); diff --git a/rs/moq-net/src/ietf/max_age.rs b/rs/moq-net/src/ietf/max_age.rs index 672c0850bb9..a95331fc3fc 100644 --- a/rs/moq-net/src/ietf/max_age.rs +++ b/rs/moq-net/src/ietf/max_age.rs @@ -30,7 +30,7 @@ mod tests { use super::*; #[test] fn negotiated_separately_and_bounded() { - for version in [Version::Draft14, Version::Draft16, Version::Draft22] { + for version in [Version::Draft22] { let mut params = Parameters::default(); assert!(!from_setup(¶ms, version)); into_setup(&mut params, version); diff --git a/rs/moq-net/src/ietf/message.rs b/rs/moq-net/src/ietf/message.rs index 0ff229f5ceb..1c89c2eada1 100644 --- a/rs/moq-net/src/ietf/message.rs +++ b/rs/moq-net/src/ietf/message.rs @@ -2,37 +2,14 @@ use crate::coding::{Decode, DecodeError, Decoder, Encode, EncodeError, Encoder}; use super::Version; -pub(super) fn control(id: u64, version: Version) -> crate::stats::Control { +pub(super) fn control(id: u64) -> crate::stats::Control { use super::*; use crate::stats::Control; - // Draft 14 reuses later drafts' NAMESPACE_DONE type for TRACK_STATUS_OK. - if version == Version::Draft14 && (id == TrackStatusOk::ID_14 || id == TRACK_STATUS_ERROR_14) { - return Control::TrackInfo; - } - // Before draft 16, 0x02 updates only a subscription; later it is the shared REQUEST_UPDATE. - if matches!(version, Version::Draft14 | Version::Draft15) && id == SubscribeUpdate::ID { - return Control::Subscribe; - } match id { - PublishNamespace::ID - | PublishNamespaceError::ID - | PublishNamespaceDone::ID - | PublishNamespaceCancel::ID - | SubscribeNamespace::ID - | SubscribeNamespaceLegacy::ID - | SubscribeNamespaceOk::ID - | SubscribeNamespaceError::ID - | UnsubscribeNamespace::ID - | NamespaceDone::ID => Control::Announce, + PublishNamespace::ID | SubscribeNamespace::ID | Namespace::ID | NamespaceDone::ID => Control::Announce, TrackStatus::ID | SubscribeTracks::ID | PublishSkipped::ID => Control::TrackInfo, - Subscribe::ID - | SubscribeOk::ID - | Unsubscribe::ID - | Publish::ID - | PublishOk::ID - | PublishError::ID - | PublishDone::ID => Control::Subscribe, - Fetch::ID | FetchOk::ID | FetchError::ID | FetchCancel::ID => Control::Fetch, + Subscribe::ID | SubscribeOk::ID | Publish::ID | PublishOk::ID | PublishDone::ID => Control::Subscribe, + Fetch::ID | FetchOk::ID => Control::Fetch, auth::Auth::ID | auth::AuthOk::ID | auth::AuthError::ID => Control::Auth, GoAway::ID => Control::Goaway, _ => Control::Other, @@ -58,7 +35,7 @@ impl Encode for T { let prefix = w.prefix_u16(); self.encode_msg(w, version)?; w.fill(prefix)?; - w.control = Some(control(T::ID, version)); + w.control = Some(control(T::ID)); Ok(()) } } @@ -112,7 +89,7 @@ impl Decode for T { Err(err) => tracing::warn!(%err, "decode failed"), } if result.is_ok() { - r.control = Some(control(T::ID, version)); + r.control = Some(control(T::ID)); } result } @@ -123,23 +100,11 @@ mod tests { use super::*; use crate::stats::Control; - /// Draft 14's track-status replies reuse type IDs later drafts give other classes. #[test] - fn draft14_track_status_ids_are_track_info() { - for id in [super::super::TrackStatusOk::ID_14, super::super::TRACK_STATUS_ERROR_14] { - assert_eq!(control(id, Version::Draft14), Control::TrackInfo); - } - assert_eq!( - control(super::super::NamespaceDone::ID, Version::Draft16), - Control::Announce - ); - assert_eq!( - control(super::super::SubscribeUpdate::ID, Version::Draft15), - Control::Subscribe - ); - // Shared replies and updates identify no request class. + fn shared_replies_identify_no_request_class() { + assert_eq!(control(super::super::NamespaceDone::ID), Control::Announce); for id in [super::super::RequestOk::ID, super::super::SubscribeUpdate::ID] { - assert_eq!(control(id, Version::Draft16), Control::Other); + assert_eq!(control(id), Control::Other); } } } diff --git a/rs/moq-net/src/ietf/mod.rs b/rs/moq-net/src/ietf/mod.rs index 66635b40bf4..ee59598afee 100644 --- a/rs/moq-net/src/ietf/mod.rs +++ b/rs/moq-net/src/ietf/mod.rs @@ -16,8 +16,6 @@ #[macro_use] mod parameters; pub mod active_count; -#[cfg(feature = "async")] -mod adapter; pub(crate) mod auth; pub mod cluster; #[cfg(feature = "async")] @@ -61,8 +59,6 @@ mod version; #[cfg(feature = "async")] use control::Control; -#[cfg(feature = "async")] -pub(crate) use control::initial_max_request_id; pub use datagram::*; pub use fetch::*; pub use filter::*; @@ -87,19 +83,9 @@ use subscriber::*; pub use track::*; pub use version::Version; -#[cfg(all(feature = "async", any(test, feature = "fuzz")))] -pub(crate) fn request_ids(window: u64, ids: &[u64]) -> usize { - let control = Control::new(None, false).with_window(window, false, Version::Draft16); - let held: Vec<_> = ids - .iter() - .filter_map(|id| control.accept(RequestId(*id)).ok()) - .collect(); - held.len() -} - #[cfg(all(feature = "async", any(test, feature = "fuzz")))] pub(crate) fn request_history(ids: &[u64]) -> usize { - let control = Control::new(None, false); + let control = Control::new(false); ids.iter().filter(|id| control.accept(RequestId(**id)).is_ok()).count() } diff --git a/rs/moq-net/src/ietf/namespace.rs b/rs/moq-net/src/ietf/namespace.rs index 4d89af79d81..b5641842472 100644 --- a/rs/moq-net/src/ietf/namespace.rs +++ b/rs/moq-net/src/ietf/namespace.rs @@ -117,11 +117,7 @@ pub fn decode_track(r: &mut Decoder<'_>) -> Result<(Path<'static>, String), Deco pub(super) fn refusal(namespace: &Path, version: super::Version) -> Option> { if matches!( version, - super::Version::Draft14 - | super::Version::Draft15 - | super::Version::Draft16 - | super::Version::Draft17 - | super::Version::Draft18 + super::Version::Draft18 | super::Version::Draft19 | super::Version::Draft20 ) { @@ -133,7 +129,6 @@ pub(super) fn refusal(namespace: &Path, version: super::Version) -> Option Vec { encode_path(&Path::from(path.to_string())) diff --git a/rs/moq-net/src/ietf/object.rs b/rs/moq-net/src/ietf/object.rs index eb74e055509..78d23c5f063 100644 --- a/rs/moq-net/src/ietf/object.rs +++ b/rs/moq-net/src/ietf/object.rs @@ -3,43 +3,26 @@ use bytes::Bytes; use super::Version; use crate::{ Error, Timescale, Timestamp, - coding::{Decoder, Encoder, Form}, + coding::{Decoder, Encoder}, model::object::{Properties, Property, Value}, }; -/// Whether `version` serializes property IDs as they are, rather than as deltas. -fn absolute(version: Version) -> bool { - matches!(version, Version::Draft14 | Version::Draft15) -} - -/// Whether lists from drafts `a` and `b` are the same bytes: the same keys and varints. -pub(crate) fn same_bytes(a: Version, b: Version) -> bool { - let form = |version| (absolute(version), Form::from(version)); - form(a) == form(b) -} - /// Draft-19 assigns property 0x06 to SUBGROUP_DELIVERY_TIMEOUT. pub(crate) fn has_delivery_timeout(version: Version) -> bool { !matches!( version, - Version::Draft14 | Version::Draft15 | Version::Draft16 | Version::Draft17 | Version::Draft18 + Version::Draft18 ) } -/// Object status: the object does not exist, defined by drafts 14 and 15 only. -pub(crate) const DOES_NOT_EXIST: u64 = 0x1; /// Object status: no object at or past this location in the group exists. pub(crate) const END_OF_GROUP: u64 = 0x3; /// Object status: no object at or past this location exists (every implemented draft). pub(crate) const END_OF_TRACK: u64 = 0x4; -/// Whether `version` defines the Object Status `status`, 0 being Normal. -pub(crate) fn status_defined(status: u64, version: Version) -> bool { - match status { - 0 | END_OF_GROUP | END_OF_TRACK => true, - DOES_NOT_EXIST => matches!(version, Version::Draft14 | Version::Draft15), - _ => false, - } +/// Whether the Object Status `status` is defined, 0 being Normal. +pub(crate) fn status_defined(status: u64) -> bool { + matches!(status, 0 | END_OF_GROUP | END_OF_TRACK) } /// Refuse the properties of an object with a frame on a track in `timescale` if they @@ -52,16 +35,10 @@ pub(crate) fn check_frame(properties: &Properties, timescale: Option) } } -/// Only draft-14 lets a status object, such as END_OF_GROUP, carry properties. -#[cfg(feature = "async")] -pub(crate) fn status_has_properties(version: Version) -> bool { - version == Version::Draft14 -} - -/// Refuse properties on a status object where its draft forbids them. +/// Refuse properties on a status object, such as END_OF_GROUP, which may not carry any. #[cfg(feature = "async")] -pub(super) fn check_status(version: Version, properties: &Properties) -> Result<(), Error> { - match status_has_properties(version) || properties.is_empty() { +pub(super) fn check_status(properties: &Properties) -> Result<(), Error> { + match properties.is_empty() { true => Ok(()), false => Err(Error::Session(crate::SessionError::ProtocolViolation)), } @@ -88,7 +65,7 @@ pub(crate) fn max_block(timescale: Option) -> usize { } // A Timestamp's value is a QUIC varint at most, and its key, a delta of at most 0x10, // only shrinks the key of the property after it. - let largest = [Version::Draft14, Version::Draft16, Version::Draft17, Version::Draft18] + let largest = [Version::Draft18] .into_iter() .map(|version| { let form = version.into(); @@ -128,10 +105,7 @@ fn list(data: &Bytes, version: Version, immutable: bool, lift: bool) -> Result key, - false => previous.checked_add(key).ok_or(Error::MalformedTrack)?, - }; + let id = previous.checked_add(key).ok_or(Error::MalformedTrack)?; previous = id; let value = if id % 2 == 0 { let value = decoder.varint()?; @@ -191,10 +165,7 @@ fn serialize<'a>(values: impl IntoIterator, version: Versio let mut encoder = Encoder::new(&mut out, version.into()); let mut previous = 0; for property in sorted { - encoder.varint(match absolute(version) { - true => property.id, - false => property.id - previous, - })?; + encoder.varint(property.id - previous)?; previous = property.id; match &property.value { Value::Int(value) => encoder.varint(*value)?, @@ -408,14 +379,11 @@ pub(crate) fn write( return serialize(×tamp, version); }; let source = source.ok_or(Error::MalformedTrack)?; - if block.immutable && !same_bytes(source, version) { - return Err(Error::Unsupported); - } // Across draft-19, forwarding 0x06 would give it a different meaning. // A mutable one is dropped; a sealed one is refused. let flipped = has_delivery_timeout(source) != has_delivery_timeout(version); // The common case: the block is already what this draft would send. - if timestamp.is_none() && !flipped && same_bytes(source, version) { + if timestamp.is_none() && !flipped { return Ok(block.bytes.to_vec()); } let values = values(block, source)?; @@ -456,10 +424,6 @@ mod tests { #[test] fn key_six_is_opaque_on_every_draft() { for version in [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft20, @@ -551,7 +515,6 @@ mod tests { &decoded.properties, Some(Version::Draft22), decoded.timestamp, - Version::Draft17, milli ), Err(Error::Unsupported) @@ -722,18 +685,18 @@ mod tests { fn a_status_object_keeps_its_timestamp() { let milli = Some(Timescale::MILLI); let list = Bytes::from_static(&[0x10, 7, 0x3e, 1]); - let framed = read(&list, Version::Draft14, milli).unwrap(); + let framed = read(&list, milli).unwrap(); assert_eq!(framed.timestamp, Some(Timestamp::new(7, Timescale::MILLI).unwrap())); - let status = unframed(&list, Version::Draft14, milli).unwrap(); + let status = unframed(&list, milli).unwrap(); assert_eq!( - write(&status, Some(Version::Draft14), None, Version::Draft14, None).unwrap(), + write(&status, Some(Version::Draft14), None, None).unwrap(), list.to_vec() ); // Over the lite hop, only a status block may hold it. let block = status.block.unwrap().bytes; - assert!(check(&block, Version::Draft14, milli, false).is_ok()); - assert!(check(&block, Version::Draft14, milli, true).is_err()); + assert!(check(&block, milli, false).is_ok()); + assert!(check(&block, milli, true).is_err()); } /// A draft-14 block crosses the lite hop in ascending order, as ingress sorts it, so @@ -741,11 +704,11 @@ mod tests { #[test] fn a_draft14_block_ascends() { let milli = Some(Timescale::MILLI); - assert!(check(&Bytes::from_static(&[0x02, 1, 0x20, 1]), Version::Draft14, milli, true).is_ok()); - assert!(check(&Bytes::from_static(&[0x02, 1, 0x02, 2]), Version::Draft14, milli, true).is_ok()); - assert!(check(&Bytes::from_static(&[0x20, 1, 0x02, 1]), Version::Draft14, milli, true).is_err()); + assert!(check(&Bytes::from_static(&[0x02, 1, 0x20, 1]), milli, true).is_ok()); + assert!(check(&Bytes::from_static(&[0x02, 1, 0x02, 2]), milli, true).is_ok()); + assert!(check(&Bytes::from_static(&[0x20, 1, 0x02, 1]), milli, true).is_err()); let sealed = Bytes::from_static(&[0x02, 1, 0x0b, 4, 0x20, 1, 0x02, 1]); - assert!(check(&sealed, Version::Draft14, milli, true).is_ok()); + assert!(check(&sealed, milli, true).is_ok()); } /// Draft-19 assigns 0x06 to SUBGROUP_DELIVERY_TIMEOUT, so it cannot cross that boundary. @@ -852,13 +815,12 @@ mod tests { .unwrap(), bytes ); - assert!(read(&bytes, Version::Draft17, None).is_err()); + assert!(read(&bytes, None).is_err()); assert!(matches!( write( &decoded.properties, Some(Version::Draft18), decoded.timestamp, - Version::Draft17, None ), Err(Error::Unsupported) @@ -895,7 +857,7 @@ mod compression_tests { } #[test] fn sizes_are_known_and_unknown_properties_survive() { - for version in [Version::Draft17, Version::Draft18, Version::Draft22] { + for version in [Version::Draft18, Version::Draft22] { let unknown = property(0x8800, 7); let wire = compression(serialize([&unknown], version).unwrap(), version, Some(123)).unwrap(); let decoded = read(&wire.into(), version, None).unwrap(); @@ -908,7 +870,7 @@ mod compression_tests { } #[test] fn a_status_cannot_declare_an_inflated_size() { - for version in [Version::Draft17, Version::Draft18, Version::Draft22] { + for version in [Version::Draft18, Version::Draft22] { let size = property(super::super::flate::INFLATED, 0); for value in [ size.clone(), @@ -928,7 +890,7 @@ mod compression_tests { #[test] fn sealed_sizes_are_forwarded_or_refused_without_rewriting() { - for version in [Version::Draft17, Version::Draft18, Version::Draft22] { + for version in [Version::Draft18, Version::Draft22] { let sealed = Property { id: 0x0b, value: Value::Bytes( diff --git a/rs/moq-net/src/ietf/parameters.rs b/rs/moq-net/src/ietf/parameters.rs index 2f5cda2eff1..8e204185527 100644 --- a/rs/moq-net/src/ietf/parameters.rs +++ b/rs/moq-net/src/ietf/parameters.rs @@ -14,8 +14,6 @@ const MAX_KVP_VALUE_LEN: usize = (1 << 16) - 1; #[derive(Debug, Copy, Clone, FromPrimitive, IntoPrimitive, Eq, Hash, PartialEq)] #[repr(u64)] pub enum ParameterVarInt { - /// Removed in draft-17; only used in draft-14/15/16. - MaxRequestId = 2, MaxAuthTokenCacheSize = 4, /// MAX_REQUEST_UPDATES, added in draft-19. MaxRequestUpdates = super::request_update::OPTION, @@ -65,27 +63,18 @@ impl Decode for Parameters { fn decode(r: &mut Decoder<'_>, version: Version) -> Result { let mut params = Self::default(); - // Draft-14/15/16 count the pairs; draft-17+ reads them until the buffer is empty. - let count = match version { - Version::Draft14 | Version::Draft15 | Version::Draft16 => Some(r.varint()?), - _ => None, - }; - if count.is_some_and(|count| count > MAX_PARAMS) { - return Err(DecodeError::TooMany); - } - - // Draft-16+ delta-encodes the types; even is a varint value, odd is length-prefixed bytes. - let delta = !matches!(version, Version::Draft14 | Version::Draft15); + // No count: the pairs run to the end of the buffer. The types are delta-encoded; + // even is a varint value, odd is length-prefixed bytes. let mut prev = 0u64; let mut i = 0u64; - while count.map_or(!r.is_empty(), |count| i < count) { + while !r.is_empty() { if i >= MAX_PARAMS { return Err(DecodeError::TooMany); } let kind = r.varint()?; - let kind = match delta && i > 0 { + let kind = match i > 0 { true => prev.checked_add(kind).ok_or(DecodeError::BoundsExceeded)?, false => kind, }; @@ -100,7 +89,6 @@ impl Decode for Parameters { ParameterVarInt::MaxRequestUpdates if !super::request_update::supported(version) => { ParameterVarInt::Unknown(kind) } - ParameterVarInt::Flate if !super::flate::supported(version) => ParameterVarInt::Unknown(kind), kind => kind, }; if !matches!(kind, ParameterVarInt::Unknown(_)) && params.get_varint(kind).is_some() { @@ -125,7 +113,7 @@ impl Decode for Parameters { } impl Encode for Parameters { - fn encode(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { + fn encode(&self, w: &mut Encoder<'_>, _: Version) -> Result<(), EncodeError> { let count = self.vars.len() + self.bytes.len(); if count as u64 > MAX_PARAMS { return Err(EncodeError::TooMany); @@ -134,46 +122,24 @@ impl Encode for Parameters { return Err(EncodeError::BoundsExceeded); } - match version { - Version::Draft14 | Version::Draft15 => { - w.varint(count as u64)?; - - for (kind, value) in &self.vars { - w.varint(u64::from(*kind))?; - w.varint(*value)?; - } + // No count prefix; the types are delta-encoded in ascending order. + enum ParamRef<'a> { + Var(u64), + Bytes(&'a [u8]), + } + let mut all: Vec<(u64, ParamRef)> = Vec::with_capacity(count); + all.extend(self.vars.iter().map(|(k, v)| (u64::from(*k), ParamRef::Var(*v)))); + all.extend(self.bytes.iter().map(|(k, v)| (u64::from(*k), ParamRef::Bytes(v)))); + all.sort_by_key(|(k, _)| *k); - for (kind, value) in &self.bytes { - w.varint(u64::from(*kind))?; - w.bytes(value)?; - } - } - _ => { - // Draft16: count prefix + delta encoding - // Draft17+: NO count prefix + delta encoding - if matches!(version, Version::Draft16) { - w.varint(count as u64)?; - } + let mut prev = 0u64; + for (kind, value) in all { + w.varint(kind - prev)?; + prev = kind; - enum ParamRef<'a> { - Var(u64), - Bytes(&'a [u8]), - } - let mut all: Vec<(u64, ParamRef)> = Vec::with_capacity(count); - all.extend(self.vars.iter().map(|(k, v)| (u64::from(*k), ParamRef::Var(*v)))); - all.extend(self.bytes.iter().map(|(k, v)| (u64::from(*k), ParamRef::Bytes(v)))); - all.sort_by_key(|(k, _)| *k); - - let mut prev = 0u64; - for (kind, value) in all { - w.varint(kind - prev)?; - prev = kind; - - match value { - ParamRef::Var(v) => w.varint(v)?, - ParamRef::Bytes(v) => w.bytes(v)?, - } - } + match value { + ParamRef::Var(v) => w.varint(v)?, + ParamRef::Bytes(v) => w.bytes(v)?, } } @@ -182,63 +148,6 @@ impl Encode for Parameters { } impl Parameters { - /// Consume a draft-14 request's parameter block, returning every AUTHORIZATION TOKEN - /// (0x03), each decoded by [`super::token::RequestToken`]'s rules. - pub fn skip_request(r: &mut Decoder<'_>) -> Result, DecodeError> { - let mut tokens = Vec::new(); - Self::skip(r, Some(&mut tokens))?; - Ok(tokens) - } - - /// Consume a draft-14 response's parameter block, returning its first - /// MAX_CACHE_DURATION (0x04), the one parameter we act on. - pub fn skip_response(r: &mut Decoder<'_>) -> Result, DecodeError> { - Self::skip(r, None) - } - - /// Draft-14 section 9.2 has a receiver ignore unrecognized parameters and allow their - /// duplicates, and lets AUTHORIZATION TOKEN repeat, so unlike [`Parameters::decode`], - /// which SETUP uses, a repeat is not refused. A request collects its tokens into `tokens`; - /// on a message that does not list them, a response, they are ignored like any other - /// parameter. - fn skip( - r: &mut Decoder<'_>, - mut tokens: Option<&mut Vec>, - ) -> Result, DecodeError> { - let count = r.varint()?; - if count > MAX_PARAMS { - return Err(DecodeError::TooMany); - } - - let mut cache_duration = None; - for _ in 0..count { - // Parity frames a Key-Value-Pair: even is one varint, odd is length prefixed. - let kind = r.varint()?; - match kind % 2 { - 0 => { - let value = r.varint()?; - if kind == 0x04 { - cache_duration.get_or_insert(value); - } - } - _ if let Some(tokens) = tokens.as_deref_mut() - && kind == u64::from(ParameterBytes::AuthorizationToken) => - { - tokens.push(super::token::RequestToken::param_decode(r, Version::Draft14)?); - } - _ => { - let len = usize::try_from(r.varint()?).map_err(|_| DecodeError::BoundsExceeded)?; - if len > MAX_KVP_VALUE_LEN { - return Err(DecodeError::BoundsExceeded); - } - r.slice(len)?; - } - } - } - - Ok(cache_duration) - } - pub fn get_varint(&self, kind: ParameterVarInt) -> Option { self.vars.iter().find(|(k, _)| *k == kind).map(|(_, v)| *v) } @@ -264,13 +173,8 @@ impl Parameters { // ---- Message Parameter Value Encoding ---- -/// Trait for encoding/decoding parameter values with version-specific formats. -/// -/// Parameter encoding differs from field encoding: -/// - Draft-14/15/16: u8 and bool are encoded as varints (cast to u64) -/// - Draft-17: type-specific encoding (u8 as raw byte, bool as raw byte, etc.) -/// -/// Use `_ =>` for the newest draft behavior so future versions default forward. +/// Encodes and decodes a Message Parameter value, whose format is type-specific +/// (a u8 or bool is one raw byte, a Location two bare varints). pub trait Param: Sized { fn param_encode(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError>; fn param_decode(r: &mut Decoder<'_>, version: Version) -> Result; @@ -290,44 +194,24 @@ pub trait Param: Sized { } impl Param for u8 { - fn param_encode(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { - match version { - // Draft-14/15/16: u8 encoded as varint - Version::Draft14 | Version::Draft15 | Version::Draft16 => w.varint(u64::from(*self))?, - _ => w.u8(*self), - } + fn param_encode(&self, w: &mut Encoder<'_>, _: Version) -> Result<(), EncodeError> { + w.u8(*self); Ok(()) } - fn param_decode(r: &mut Decoder<'_>, version: Version) -> Result { - match version { - Version::Draft14 | Version::Draft15 | Version::Draft16 => { - u8::try_from(r.varint()?).map_err(|_| DecodeError::InvalidValue) - } - _ => r.u8(), - } + fn param_decode(r: &mut Decoder<'_>, _: Version) -> Result { + r.u8() } } impl Param for bool { - fn param_encode(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { - match version { - // Draft-14/15/16: bool encoded as varint - Version::Draft14 | Version::Draft15 | Version::Draft16 => w.varint(u8::from(*self).into())?, - _ => w.bool(*self), - } + fn param_encode(&self, w: &mut Encoder<'_>, _: Version) -> Result<(), EncodeError> { + w.bool(*self); Ok(()) } - fn param_decode(r: &mut Decoder<'_>, version: Version) -> Result { - match version { - Version::Draft14 | Version::Draft15 | Version::Draft16 => match r.varint()? { - 0 => Ok(false), - 1 => Ok(true), - _ => Err(DecodeError::InvalidValue), - }, - _ => r.bool(), - } + fn param_decode(r: &mut Decoder<'_>, _: Version) -> Result { + r.bool() } } @@ -342,51 +226,19 @@ impl Param for u64 { } } -/// A Location parameter value, such as LARGEST_OBJECT (0x09). -/// -/// Draft-16 section 9.2 serializes every Message Parameter as a Key-Value-Pair, and section -/// 9.2.2.7 calls LARGEST_OBJECT "a length-prefixed Location structure", so the two varints -/// sit inside a byte string there. Draft-17 section 9.3, and section 10.2 from draft-18 on, -/// redefines a Message Parameter as `{ Type Delta (vi64), Value (..) }` with no Length at -/// all, and lists "Location: Two consecutive varints (Group, Object)" as its own value -/// encoding beside Length-prefixed. So from draft-17 the two varints are written bare. +/// A Location parameter value, such as LARGEST_OBJECT (0x09): two bare varints, as a +/// Message Parameter has no Length (draft-18 section 10.2). impl Param for Location { - fn param_encode(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { - match version { - Version::Draft14 | Version::Draft15 | Version::Draft16 => { - // The drafts before 17 pin the inner varints to the draft-15 encoding, - // matching the other length-prefixed parameters. - let mut buf = Vec::new(); - let mut inner = Encoder::new(&mut buf, Version::Draft15.into()); - inner.varint(self.group)?; - inner.varint(self.object)?; - w.bytes(&buf) - } - _ => { - w.varint(self.group)?; - w.varint(self.object)?; - Ok(()) - } - } + fn param_encode(&self, w: &mut Encoder<'_>, _: Version) -> Result<(), EncodeError> { + w.varint(self.group)?; + w.varint(self.object)?; + Ok(()) } - fn param_decode(r: &mut Decoder<'_>, version: Version) -> Result { - match version { - Version::Draft14 | Version::Draft15 | Version::Draft16 => { - let mut inner = Decoder::new(r.bytes()?, Version::Draft15.into()); - let group = inner.varint()?; - let object = inner.varint()?; - if !inner.is_empty() { - return Err(DecodeError::TrailingBytes); - } - Ok(Location { group, object }) - } - _ => { - let group = r.varint()?; - let object = r.varint()?; - Ok(Location { group, object }) - } - } + fn param_decode(r: &mut Decoder<'_>, _: Version) -> Result { + let group = r.varint()?; + let object = r.varint()?; + Ok(Location { group, object }) } } @@ -453,43 +305,6 @@ impl Param for Opaque { } } -/// Message parameter ids defined in draft-16. Sorted for `binary_search`. -/// -/// A known id on a message that does not list it is ignored. An id outside this set -/// is unknown and closes the session. -const DRAFT16_MESSAGE_PARAMS: &[u64] = &[0x02, 0x03, 0x08, 0x09, 0x10, 0x20, 0x21, 0x22, 0x32]; - -fn skip_kvp(r: &mut Decoder<'_>, key: u64) -> Result<(), DecodeError> { - if key.is_multiple_of(2) { - r.varint()?; - } else { - let value = r.bytes()?; - if value.len() > MAX_KVP_VALUE_LEN { - return Err(DecodeError::BoundsExceeded); - } - } - Ok(()) -} - -/// Consumes a parameter the message does not list, when that draft says to ignore it. -/// -/// Draft-14 and draft-15 ignore an unrecognized parameter, including one defined for a -/// different message. Draft-16 ignores a known parameter on the wrong message and closes -/// on an unknown id. From draft-17 on both close the session, and a parameter value has -/// no length to skip by, so this returns false and the caller fails the message. -pub(crate) fn skip_unlisted(r: &mut Decoder<'_>, version: Version, key: u64) -> Result { - let ignore = match version { - Version::Draft14 | Version::Draft15 => true, - Version::Draft16 => DRAFT16_MESSAGE_PARAMS.binary_search(&key).is_ok(), - _ => false, - }; - if !ignore { - return Ok(false); - } - skip_kvp(r, key)?; - Ok(true) -} - /// Encode message parameters with compile-time sorted keys. /// /// Keys must be listed in ascending order (enforced at compile time). @@ -527,11 +342,7 @@ macro_rules! encode_params { $( if $crate::ietf::Param::param_present(&$val) { let _key: u64 = $key; - let _wire = match _version { - $crate::ietf::Version::Draft14 | $crate::ietf::Version::Draft15 => _key, - _ if _first => _key, - _ => _key - _prev_key, - }; + let _wire = if _first { _key } else { _key - _prev_key }; $w.varint(_wire)?; _prev_key = _key; _first = false; @@ -548,9 +359,7 @@ macro_rules! encode_params { /// for parameters where `T::default()` is an acceptable fallback. /// /// A `where` gate takes the key off the list on versions where the expression is false. -/// What remains unlisted is ignored on draft-14 and draft-15, ignored on draft-16 when -/// the id is a message parameter of that draft used on the wrong message, and a -/// `DecodeError::InvalidValue` otherwise (unknown id, or any unlisted id from draft-17 on). +/// An unlisted key is a `DecodeError::InvalidValue`: a value has no length to skip by. /// Duplicate parameters cause `DecodeError::Duplicate`, unless the type allows a repeat /// (see [`Param::param_repeat`]), such as `Vec`. /// @@ -588,17 +397,17 @@ macro_rules! decode_params { let mut _prev_key: u64 = 0; for _i in 0.._count { let _wire = $r.varint()?; - let _key: u64 = match _version { - $crate::ietf::Version::Draft14 | $crate::ietf::Version::Draft15 => _wire, - _ if _i == 0 => _wire, - _ => _prev_key.checked_add(_wire).ok_or($crate::coding::DecodeError::BoundsExceeded)?, + let _key: u64 = if _i == 0 { + _wire + } else { + _prev_key.checked_add(_wire).ok_or($crate::coding::DecodeError::BoundsExceeded)? }; _prev_key = _key; // An if-chain rather than a `match`, so a key can be a named constant: // the macro captures it as an expression, which is not a legal pattern. - // A false `where` gate falls through, so the draft's ignore-or-close rule applies - // instead of validating a value the message is not allowed to carry. + // A false `where` gate falls through to the refusal instead of validating a + // value the message is not allowed to carry. $( if _key == $key $( && ($gate) )? { let _value = <$ty as $crate::ietf::Param>::param_decode($r, _version)?; @@ -609,9 +418,6 @@ macro_rules! decode_params { continue; } )* - if $crate::ietf::parameters::skip_unlisted($r, _version, _key)? { - continue; - } return Err($crate::coding::DecodeError::InvalidValue); } } @@ -645,10 +451,6 @@ mod tests { #[test] fn setup_allows_repeated_unknown_options() { for version in [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft20, @@ -658,18 +460,10 @@ mod tests { for kind in [0x20, 0x21, 0x9d, 0x11c] { let mut buf = Vec::new(); let mut w = Encoder::new(&mut buf, version.into()); - if matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) { - w.varint(2).unwrap(); - } w.varint(kind).unwrap(); for delta in [None, Some(0)] { if let Some(delta) = delta { - w.varint(if matches!(version, Version::Draft14 | Version::Draft15) { - kind - } else { - delta - }) - .unwrap(); + w.varint(delta).unwrap(); } if kind % 2 == 0 { w.varint(1).unwrap(); @@ -704,7 +498,6 @@ mod tests { #[test] fn group_order_parameter_rejects_values_outside_one_and_two() { for version in [ - Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft20, @@ -734,61 +527,7 @@ mod tests { } #[test] - fn legacy_group_order_zero_keeps_the_publisher_preference() { - for version in [Version::Draft14, Version::Draft15, Version::Draft16] { - let mut r = Decoder::new(&[0], version.into()); - assert_eq!( - super::super::GroupOrder::param_decode(&mut r, version).unwrap(), - super::super::GroupOrder::Descending - ); - } - } - - // ---- Setup Parameters tests (unchanged) ---- - - #[test] - fn test_parameters_v16_delta_round_trip() { - let mut params = Parameters::default(); - params.set_bytes(ParameterBytes::Path, b"/test".to_vec()); - params.set_varint(ParameterVarInt::MaxRequestId, 100); - params.set_bytes(ParameterBytes::Implementation, b"test-impl".to_vec()); - - let mut buf = Vec::new(); - params - .encode(&mut Encoder::new(&mut buf, Version::Draft16.into()), Version::Draft16) - .unwrap(); - - let mut bytes = bytes::Bytes::from(buf); - let decoded = crate::coding::decode_buf(&mut bytes, Version::Draft16, Parameters::decode).unwrap(); - - assert_eq!(decoded.get_bytes(ParameterBytes::Path), Some(b"/test".as_ref())); - assert_eq!(decoded.get_varint(ParameterVarInt::MaxRequestId), Some(100)); - assert_eq!( - decoded.get_bytes(ParameterBytes::Implementation), - Some(b"test-impl".as_ref()) - ); - } - - #[test] - fn test_parameters_v15_round_trip() { - let mut params = Parameters::default(); - params.set_bytes(ParameterBytes::Path, b"/test".to_vec()); - params.set_varint(ParameterVarInt::MaxRequestId, 100); - - let mut buf = Vec::new(); - params - .encode(&mut Encoder::new(&mut buf, Version::Draft15.into()), Version::Draft15) - .unwrap(); - - let mut bytes = bytes::Bytes::from(buf); - let decoded = crate::coding::decode_buf(&mut bytes, Version::Draft15, Parameters::decode).unwrap(); - - assert_eq!(decoded.get_bytes(ParameterBytes::Path), Some(b"/test".as_ref())); - assert_eq!(decoded.get_varint(ParameterVarInt::MaxRequestId), Some(100)); - } - - #[test] - fn test_parameters_v17_round_trip() { + fn setup_parameters_round_trip() { let mut params = Parameters::default(); params.set_bytes(ParameterBytes::Path, b"/test".to_vec()); params.set_varint(ParameterVarInt::MaxAuthTokenCacheSize, 4096); @@ -796,37 +535,18 @@ mod tests { let mut buf = Vec::new(); params - .encode(&mut Encoder::new(&mut buf, Version::Draft17.into()), Version::Draft17) + .encode(&mut Encoder::new(&mut buf, Version::Draft18.into()), Version::Draft18) .unwrap(); + // No count prefix: the first byte is the first type, PATH (0x01). + assert_eq!(buf[0], 0x01); - let mut bytes = bytes::Bytes::from(buf); - let decoded = crate::coding::decode_buf(&mut bytes, Version::Draft17, Parameters::decode).unwrap(); - + let (decoded, _) = Parameters::decode_slice(&buf, Version::Draft18).unwrap(); assert_eq!(decoded.get_bytes(ParameterBytes::Path), Some(b"/test".as_ref())); assert_eq!(decoded.get_varint(ParameterVarInt::MaxAuthTokenCacheSize), Some(4096)); assert_eq!( decoded.get_bytes(ParameterBytes::Implementation), Some(b"test-impl".as_ref()) ); - assert!(bytes.is_empty()); - } - - #[test] - fn test_parameters_v17_no_count_prefix() { - let mut params = Parameters::default(); - params.set_bytes(ParameterBytes::Path, b"/x".to_vec()); - - let mut buf15 = Vec::new(); - params - .encode(&mut Encoder::new(&mut buf15, Version::Draft15.into()), Version::Draft15) - .unwrap(); - - let mut buf17 = Vec::new(); - params - .encode(&mut Encoder::new(&mut buf17, Version::Draft17.into()), Version::Draft17) - .unwrap(); - - assert!(buf17.len() < buf15.len()); } // ---- Message Parameter (encode_params!/decode_params!) tests ---- @@ -846,10 +566,6 @@ mod tests { #[test] fn test_param_u8_all_versions() { for version in [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, ] { round_trip_params( @@ -870,8 +586,6 @@ mod tests { #[test] fn test_param_u8_wire_vectors() -> Result<(), EncodeError> { for (version, expected) in [ - (Version::Draft16, &[0x01, 0x20, 0x40, 0xff][..]), - (Version::Draft17, &[0x01, 0x20, 0xff][..]), (Version::Draft18, &[0x01, 0x20, 0xff][..]), (Version::Draft19, &[0x01, 0x20, 0xff][..]), ] { @@ -894,10 +608,6 @@ mod tests { #[test] fn test_param_bool_all_versions() { for version in [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, ] { round_trip_params( @@ -919,10 +629,6 @@ mod tests { fn test_param_location_all_versions() { let loc = Location { group: 5, object: 3 }; for version in [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, ] { round_trip_params( @@ -946,12 +652,8 @@ mod tests { group: 255, object: 128, }; - // Draft-16 wraps the two varints in a Key-Value-Pair Length; from draft-17 a - // Message Parameter has no Length and a Location value is two bare varints. The - // inner format differs too: QUIC-style before draft-17, leading-ones after. + // A Message Parameter has no Length, so a Location value is two bare varints. for (version, expected) in [ - (Version::Draft16, &[0x01, 0x09, 0x04, 0x40, 0xff, 0x40, 0x80][..]), - (Version::Draft17, &[0x01, 0x09, 0x80, 0xff, 0x80, 0x80][..]), (Version::Draft18, &[0x01, 0x09, 0x80, 0xff, 0x80, 0x80][..]), (Version::Draft19, &[0x01, 0x09, 0x80, 0xff, 0x80, 0x80][..]), (Version::Draft20, &[0x01, 0x09, 0x80, 0xff, 0x80, 0x80][..]), @@ -975,10 +677,6 @@ mod tests { #[test] fn test_param_filter_all_versions() { for version in [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, ] { round_trip_params( @@ -999,10 +697,6 @@ mod tests { #[test] fn test_param_multiple_delta_encoding() { for version in [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, ] { round_trip_params( @@ -1036,10 +730,6 @@ mod tests { #[test] fn test_param_empty_set() { for version in [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, ] { round_trip_params( @@ -1059,10 +749,6 @@ mod tests { #[test] fn test_param_option_skip_none() { for version in [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, ] { round_trip_params( @@ -1091,10 +777,6 @@ mod tests { #[test] fn test_param_option_encode_some() { for version in [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, ] { round_trip_params( @@ -1124,10 +806,6 @@ mod tests { fn test_param_bare_type_defaults() { // Bare types use T::default() when the parameter is absent for version in [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, ] { round_trip_params( @@ -1152,13 +830,8 @@ mod tests { #[test] fn test_param_unknown_rejected() { - // 0x3E is not a message parameter in any of these drafts. Draft-14 and draft-15 - // ignore it. Draft-16 on closes the session. + // 0x3E is not a message parameter, which closes the session. for version in [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, ] { let mut buf = Vec::new(); @@ -1172,25 +845,18 @@ mod tests { decode_params!(&mut bytes, version, 0x20 => val: Option); Ok(val) })(); - match version { - Version::Draft14 | Version::Draft15 => { - assert_eq!(result.unwrap(), None, "{version} ignores an unrecognized parameter"); - assert!(bytes.is_empty(), "{version}"); - } - _ => assert!( - matches!(result, Err(DecodeError::InvalidValue)), - "expected InvalidValue for unknown param in {version}" - ), - } + assert!( + matches!(result, Err(DecodeError::InvalidValue)), + "expected InvalidValue for unknown param in {version}" + ); } } - /// EXPIRES (0x08) is a draft-16 message parameter, but not for a message whose list is - /// only SUBSCRIBER_PRIORITY. Draft-16 ignores it and still reads the parameter after it. - /// Draft-18 closes the session on the same bytes. + /// EXPIRES (0x08) is a message parameter, but not for a message whose list is only + /// SUBSCRIBER_PRIORITY, so it closes the session. #[test] fn known_param_on_the_wrong_message() { - for version in [Version::Draft16, Version::Draft18] { + for version in [Version::Draft18] { let mut buf = Vec::new(); let mut w = Encoder::new(&mut buf, version.into()); w.varint(2).unwrap(); @@ -1204,14 +870,7 @@ mod tests { decode_params!(&mut bytes, version, 0x20 => val: Option); Ok(val) })(); - match version { - Version::Draft16 => { - assert_eq!(result.unwrap(), Some(7)); - assert!(bytes.is_empty()); - } - Version::Draft18 => assert!(matches!(result, Err(DecodeError::InvalidValue))), - _ => unreachable!(), - } + assert!(matches!(result, Err(DecodeError::InvalidValue))); } } @@ -1219,32 +878,17 @@ mod tests { fn test_param_duplicate_rejected() { // Manually construct a buffer with duplicate key 0x20 for version in [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, ] { let mut buf = Vec::new(); let mut w = Encoder::new(&mut buf, version.into()); // Encode count = 2 w.varint(2).unwrap(); - match version { - Version::Draft14 | Version::Draft15 => { - // Plain (non-delta) keys: first key=0x20, second key=0x20 - w.varint(0x20u64).unwrap(); - 100u8.param_encode(&mut w, version).unwrap(); - w.varint(0x20u64).unwrap(); - 200u8.param_encode(&mut w, version).unwrap(); - } - _ => { - // Delta-encoded: first delta=0x20 (abs=0x20), second delta=0 (abs=0x20) - w.varint(0x20u64).unwrap(); - 100u8.param_encode(&mut w, version).unwrap(); - w.varint(0).unwrap(); - 200u8.param_encode(&mut w, version).unwrap(); - } - } + // Delta-encoded: first delta=0x20 (abs=0x20), second delta=0 (abs=0x20) + w.varint(0x20u64).unwrap(); + 100u8.param_encode(&mut w, version).unwrap(); + w.varint(0).unwrap(); + 200u8.param_encode(&mut w, version).unwrap(); let mut bytes = Decoder::new(&buf, version.into()); let result: Result<(), DecodeError> = (|| { @@ -1272,15 +916,13 @@ mod tests { value: vec![0xAA], }) }; - for version in [Version::Draft15, Version::Draft16, Version::Draft17, Version::Draft20] { + for version in [Version::Draft20] { let mut buf = Vec::new(); let mut w = Encoder::new(&mut buf, version.into()); w.varint(2).unwrap(); w.varint(0x03).unwrap(); token(0).param_encode(&mut w, version).unwrap(); - // The second key: absolute before draft-16, a zero delta after. - let second: u64 = if version == Version::Draft15 { 0x03 } else { 0 }; - w.varint(second).unwrap(); + w.varint(0).unwrap(); token(1).param_encode(&mut w, version).unwrap(); let mut r = Decoder::new(&buf, version.into()); @@ -1293,45 +935,4 @@ mod tests { assert!(r.is_empty(), "{version}"); } } - - /// Draft-14 lets AUTHORIZATION TOKEN repeat and has unknown parameters, duplicates - /// included, ignored. The block is consumed whole either way. - #[test] - fn test_skip_allows_draft14_repeats() { - #[rustfmt::skip] - let block = [ - 0x04, // Number of Parameters - 0x03, 0x03, 0x03, 0x00, 0xAA, // AUTHORIZATION TOKEN: USE_VALUE, type 0 - 0x03, 0x03, 0x03, 0x01, 0xBB, // and again, type 1 - 0x3E, 0x05, // an unknown varint parameter - 0x3E, 0x06, // and again - ]; - let mut r = Decoder::new(&block, Version::Draft14.into()); - let tokens = Parameters::skip_request(&mut r).unwrap(); - assert_eq!(tokens.len(), 2); - assert_eq!(tokens[1].0.kind, 1); - assert!(r.is_empty()); - } - - /// A draft-14 request decodes every token; a response ignores one, as section 9.2 has - /// for a parameter on a message that does not list it. - #[test] - fn test_skip_decodes_draft14_request_tokens() { - #[rustfmt::skip] - let block = [ - 0x02, // Number of Parameters - 0x03, 0x03, 0x03, 0x00, 0xAA, // AUTHORIZATION TOKEN: USE_VALUE, type 0 - 0x03, 0x02, 0x02, 0x07, // and a USE_ALIAS, never registered - ]; - let mut r = Decoder::new(&block, Version::Draft14.into()); - let err = Parameters::skip_request(&mut r).unwrap_err(); - assert!( - matches!(err, DecodeError::Session(crate::SessionError::UnknownAuthTokenAlias)), - "{err:?}" - ); - - let mut r = Decoder::new(&block, Version::Draft14.into()); - assert_eq!(Parameters::skip_response(&mut r).unwrap(), None); - assert!(r.is_empty()); - } } diff --git a/rs/moq-net/src/ietf/properties.rs b/rs/moq-net/src/ietf/properties.rs index 093a4bb17d3..1c9234a8337 100644 --- a/rs/moq-net/src/ietf/properties.rs +++ b/rs/moq-net/src/ietf/properties.rs @@ -82,16 +82,6 @@ pub struct Properties { } impl Properties { - /// Whether [`Self::encode`] writes a TIMESCALE on this version. - /// - /// Drafts 14-16 do not. 14 and 15 have no properties block, and 16's Track Extensions - /// predate the TIMESCALE registration; an older peer rejects trailing bytes it does not - /// parse. A Timestamp on those drafts would have no units. Draft-16 is still read, so a - /// peer that sends the block is understood. - pub(crate) fn sends_timescale(version: Version) -> bool { - !matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) - } - /// The properties a relay states for a track it serves, from the `info` it acts on. /// /// We serve the newest group first by default, matching moq-lite. @@ -119,9 +109,6 @@ impl Properties { /// A property the publisher sealed inside Immutable Properties travels there, so it is /// not restated in the mutable list. pub fn encode(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { - if matches!(version, Version::Draft14 | Version::Draft15) { - return Ok(()); - } let int = |id, value| Property { id, @@ -129,20 +116,18 @@ impl Properties { }; let mut known = Vec::new(); - if Self::sends_timescale(version) { - if let Some(age) = self.max_cache_duration { - let millis = u64::try_from(age.as_millis()).map_err(|_| EncodeError::BoundsExceeded)?; - known.push(int(MAX_CACHE_DURATION, millis)); - } - if let Some(timescale) = self.timescale { - known.push(int(TIMESCALE, u64::from(timescale))); - } - if let Some(priority) = self.priority { - known.push(int(DEFAULT_PUBLISHER_PRIORITY, u64::from(priority))); - } - if let Some(group_order) = self.group_order { - known.push(int(DEFAULT_PUBLISHER_GROUP_ORDER, u64::from(u8::from(group_order)))); - } + if let Some(age) = self.max_cache_duration { + let millis = u64::try_from(age.as_millis()).map_err(|_| EncodeError::BoundsExceeded)?; + known.push(int(MAX_CACHE_DURATION, millis)); + } + if let Some(timescale) = self.timescale { + known.push(int(TIMESCALE, u64::from(timescale))); + } + if let Some(priority) = self.priority { + known.push(int(DEFAULT_PUBLISHER_PRIORITY, u64::from(priority))); + } + if let Some(group_order) = self.group_order { + known.push(int(DEFAULT_PUBLISHER_GROUP_ORDER, u64::from(u8::from(group_order)))); } // Omitted means 0, so only support is worth bytes. @@ -150,7 +135,7 @@ impl Properties { known.push(int(DYNAMIC_GROUPS, 1)); } - if self.compress && super::flate::supported(version) { + if self.compress { known.push(int(super::flate::COMPRESSION, 1)); } @@ -190,10 +175,7 @@ impl Properties { // Draft-16 calls the block Track Extensions, draft-17+ Track Properties. Same encoding, // so read either rather than faulting the message for trailing bytes. - match version { - Version::Draft14 | Version::Draft15 => return Ok(properties), - _ => {} - } + {} let mut prev_type: u64 = 0; let mut i: u64 = 0; @@ -311,9 +293,6 @@ pub(crate) const MAX_FORWARDED: usize = MAX_PROPERTIES as usize - UNDERSTOOD.len /// [`Properties::decode`] does. pub(crate) fn check_immutable(block: &[u8], version: Version) -> Result<(), DecodeError> { // Track Properties start at draft-16. - if matches!(version, Version::Draft14 | Version::Draft15) { - return Err(DecodeError::InvalidValue); - } sealed( &mut Decoder::new(block, version.into()), &mut Properties::default(), @@ -449,7 +428,7 @@ mod tests { fn test_skip_empty_properties() { let mut buf = bytes::Bytes::new(); assert_eq!( - crate::coding::decode_buf(&mut buf, Version::Draft17, Properties::decode).unwrap(), + crate::coding::decode_buf(&mut buf, Properties::decode).unwrap(), Properties::default() ); } @@ -461,7 +440,7 @@ mod tests { Encoder::new(&mut buf, Version::Draft17.into()).varint(0x02u64).unwrap(); // delta type Encoder::new(&mut buf, Version::Draft17.into()).varint(5000u64).unwrap(); // value let mut bytes = bytes::Bytes::from(buf); - crate::coding::decode_buf(&mut bytes, Version::Draft17, Properties::decode).unwrap(); + crate::coding::decode_buf(&mut bytes, Properties::decode).unwrap(); assert!(bytes.is_empty()); } @@ -473,7 +452,7 @@ mod tests { Encoder::new(&mut buf, Version::Draft17.into()).varint(3u64).unwrap(); // length buf.extend_from_slice(&[0x03, 0x01, 0x2A]); // sealed type 0x03, one byte let mut bytes = bytes::Bytes::from(buf); - crate::coding::decode_buf(&mut bytes, Version::Draft17, Properties::decode).unwrap(); + crate::coding::decode_buf(&mut bytes, Properties::decode).unwrap(); assert!(bytes.is_empty()); } @@ -492,7 +471,7 @@ mod tests { buf.extend_from_slice(&[0x02, 0x2A]); // sealed type 0x02 = 42 let mut bytes = bytes::Bytes::from(buf); - crate::coding::decode_buf(&mut bytes, Version::Draft17, Properties::decode).unwrap(); + crate::coding::decode_buf(&mut bytes, Properties::decode).unwrap(); assert!(bytes.is_empty()); } @@ -524,8 +503,6 @@ mod tests { #[test] fn publisher_priority_is_bounded_to_a_byte() { for version in [ - Version::Draft16, - Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft20, @@ -563,7 +540,7 @@ mod tests { Encoder::new(&mut buf, Version::Draft16.into()).varint(2u64).unwrap(); let mut bytes = bytes::Bytes::from(buf); - let properties = crate::coding::decode_buf(&mut bytes, Version::Draft16, Properties::decode).unwrap(); + let properties = crate::coding::decode_buf(&mut bytes, Properties::decode).unwrap(); assert_eq!(properties.group_order, Some(GroupOrder::Descending)); assert!(bytes.is_empty()); } @@ -582,7 +559,7 @@ mod tests { group_order: None, }; - for version in [Version::Draft14, Version::Draft15, Version::Draft16, Version::Draft17] { + for version in [Version::Draft15] { let mut buf = Vec::new(); properties .encode(&mut Encoder::new(&mut buf, version.into()), version) @@ -703,7 +680,7 @@ mod tests { /// in order among the ones we write ourselves. #[test] fn unknown_properties_round_trip() { - for version in [Version::Draft16, Version::Draft22] { + for version in [Version::Draft22] { // 0x02 = 5000, 0x0b = { 0x02 = 42 }, 0x3801 = "hi" let mut block = Vec::new(); let mut w = Encoder::new(&mut block, version.into()); diff --git a/rs/moq-net/src/ietf/publish.rs b/rs/moq-net/src/ietf/publish.rs index a388cdec298..1a604d1d8a5 100644 --- a/rs/moq-net/src/ietf/publish.rs +++ b/rs/moq-net/src/ietf/publish.rs @@ -110,7 +110,7 @@ use crate::{ Path, coding::{Decode, DecodeError, Decoder, Encode, EncodeError, Encoder}, ietf::{ - Filter, GroupOrder, Location, Parameters, Properties, RequestId, + Filter, GroupOrder, Location, Properties, RequestId, namespace::{decode_track, encode_namespace}, }, }; @@ -133,27 +133,14 @@ pub(crate) enum PublishDoneStatus { } impl PublishDoneStatus { - /// Return the registered wire code for every supported draft. - pub(crate) const fn code(self, version: Version) -> u64 { - match version { - // Draft-14 registers no UPDATE_FAILED; its 0x8 is unassigned. - Version::Draft14 if matches!(self, Self::UpdateFailed) => 0x0, - Version::Draft14 - | Version::Draft15 - | Version::Draft16 - | Version::Draft17 - | Version::Draft18 - | Version::Draft19 - // Draft-20 removed SUBSCRIPTION_ENDED (0x3), which this implementation never - // emitted, and left the rest of the registry alone. - | Version::Draft20 - | Version::Draft21 - | Version::Draft22 => match self { - Self::InternalError => 0x0, - Self::Unauthorized => 0x1, - Self::TrackEnded => 0x2, - Self::UpdateFailed => 0x8, - }, + /// Return the registered wire code. Draft-20 removed SUBSCRIPTION_ENDED (0x3), which + /// this implementation never emitted, and left the rest of the registry alone. + pub(crate) const fn code(self) -> u64 { + match self { + Self::InternalError => 0x0, + Self::Unauthorized => 0x1, + Self::TrackEnded => 0x2, + Self::UpdateFailed => 0x8, } } } @@ -161,7 +148,6 @@ impl PublishDoneStatus { /// Used to be called SubscribeDone #[derive(Clone, Debug)] pub struct PublishDone<'a> { - pub request_id: Option, pub status_code: u64, pub stream_count: u64, pub reason_phrase: Cow<'a, str>, @@ -171,17 +157,13 @@ impl PublishDone<'_> { /// How the publisher ended the subscription: cleanly, or with the error its status names. pub(crate) fn end(&self, version: Version) -> Result<(), crate::Error> { match self.status_code { - code if code == PublishDoneStatus::TrackEnded.code(version) => Ok(()), - code if code == PublishDoneStatus::Unauthorized.code(version) => Err(crate::Error::Unauthorized), + code if code == PublishDoneStatus::TrackEnded.code() => Ok(()), + code if code == PublishDoneStatus::Unauthorized.code() => Err(crate::Error::Unauthorized), // SUBSCRIPTION_ENDED: the subscription reached the end its filter asked for. // Draft-20 removed it and left 0x3 unassigned. 0x3 if matches!( version, - Version::Draft14 - | Version::Draft15 - | Version::Draft16 - | Version::Draft17 - | Version::Draft18 + Version::Draft18 | Version::Draft19 ) => { @@ -195,32 +177,19 @@ impl PublishDone<'_> { impl Message for PublishDone<'_> { const ID: u64 = 0x0b; - fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { - if matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) { - self.request_id - .expect("request_id required for draft14-16") - .encode(w, version)?; - } else { - assert!(self.request_id.is_none(), "request_id must be None for draft17+"); - } + fn encode_msg(&self, w: &mut Encoder<'_>, _: Version) -> Result<(), EncodeError> { w.varint(self.status_code)?; w.varint(self.stream_count)?; w.string(&self.reason_phrase)?; Ok(()) } - fn decode_msg(r: &mut Decoder<'_>, version: Version) -> Result { - let request_id = if matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) { - Some(RequestId::decode(r, version)?) - } else { - None - }; + fn decode_msg(r: &mut Decoder<'_>, _: Version) -> Result { let status_code = r.varint()?; let stream_count = r.varint()?; let reason_phrase = Cow::Owned(r.string()?); Ok(Self { - request_id, status_code, stream_count, reason_phrase, @@ -252,150 +221,74 @@ impl Message for Publish<'_> { fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { self.request_id.encode(w, version)?; - if version == Version::Draft17 { - w.varint(0)?; // required_request_id_delta = 0 - } encode_namespace(w, &self.track_namespace)?; w.string(&self.track_name)?; w.varint(self.track_alias)?; - match version { - Version::Draft14 => { - self.properties - .group_order - .unwrap_or(GroupOrder::Ascending) - .encode(w, version)?; - if let Some(location) = &self.largest_location { - w.bool(true); - location.encode(w, version)?; - } else { - w.bool(false); - } - - w.bool(self.forward); - // parameters - w.u8(0); - } - _ => { - // GROUP_ORDER is the publisher's preference on a draft-15 PUBLISH, illegal from - // draft-16 to draft-19 (a peer closes the session with PROTOCOL_VIOLATION), and - // from draft-20 one of the subscription's parameters, which moved here. The - // publisher's preference is a DEFAULT_PUBLISHER_GROUP_ORDER track property - // instead, which we write from draft-17 on. Draft-16 gets neither form; see - // Properties::encode. - let draft20 = Filter::is_draft20(version); - let group_order = match version { - Version::Draft15 => self.properties.group_order, - _ if draft20 => self.group_order, - _ => None, - }; - - encode_params!(w, version, - 0x09 => self.largest_location, - 0x10 => self.forward, - 0x20 => self.subscriber_priority.filter(|_| draft20), - 0x21 => self.filter.filter(|_| draft20), - 0x22 => group_order, - ); + // GROUP_ORDER is illegal on PUBLISH through draft-19 (a peer closes the session with + // PROTOCOL_VIOLATION), and from draft-20 one of the subscription's parameters, which + // moved here. The publisher's preference is a DEFAULT_PUBLISHER_GROUP_ORDER track + // property instead. + let draft20 = Filter::is_draft20(version); + encode_params!(w, version, + 0x09 => self.largest_location, + 0x10 => self.forward, + 0x20 => self.subscriber_priority.filter(|_| draft20), + 0x21 => self.filter.filter(|_| draft20), + 0x22 => self.group_order.filter(|_| draft20), + ); - // Track Properties are the final field, so nothing may follow. - self.properties.encode(w, version)?; - } - } + // Track Properties are the final field, so nothing may follow. + self.properties.encode(w, version)?; Ok(()) } fn decode_msg(r: &mut Decoder<'_>, version: Version) -> Result { let request_id = RequestId::decode(r, version)?; - if version == Version::Draft17 { - let _required_request_id_delta = r.varint()?; - } let (track_namespace, track_name) = decode_track(r)?; let track_name = Cow::Owned(track_name); let track_alias = r.varint()?; - match version { - Version::Draft14 => { - let group_order = GroupOrder::decode(r, version)?.any_to_descending(); - let content_exists = r.bool()?; - let largest_location = match content_exists { - true => Some(Location::decode(r, version)?), - false => None, - }; - let forward = r.bool()?; - // parameters - super::token::single(Parameters::skip_request(r)?)?; - - Ok(Self { - request_id, - track_namespace, - track_name, - track_alias, - largest_location, - forward, - properties: Properties { - group_order: Some(group_order), - ..Default::default() - }, - subscriber_priority: None, - group_order: None, - filter: None, - }) - } - _ => { - // GROUP_ORDER is legal on PUBLISH in draft-15 and again from draft-20, when - // the subscription parameters moved here. Draft-16 still knows the id, so one - // on this message is ignored. Draft-17 through draft-19 close the session. - // - // The draft-20 parameters have to parse even though reverse publishing is - // unsupported: an unlisted parameter fails the whole message, which would - // kill the session instead of letting the request reach NOT_SUPPORTED. - // OBJECT_DELIVERY_TIMEOUT is also legal in draft-15. The timeouts are dropped. - decode_params!(r, version, - 0x02 => _object_delivery_timeout: Option where version == Version::Draft15 || Filter::is_draft20(version), - 0x03 => authorization_token: Vec, - 0x06 => _subgroup_delivery_timeout: Option where Filter::is_draft20(version), - 0x08 => _expires: Option, - 0x09 => largest_location: Option, - 0x10 => forward: Option, - 0x20 => subscriber_priority: Option where Filter::is_draft20(version), - 0x21 => filter: Option where Filter::is_draft20(version), - 0x22 => group_order: Option where version == Version::Draft15 || Filter::is_draft20(version), - ); - let mut properties = Properties::decode(r, version)?; - // Last, so a malformed field closes the session before a token refusal. - super::token::single(authorization_token)?; - // Draft-15's GROUP_ORDER is the publisher's preference; draft-20's is the - // subscription's. - let (publisher_order, group_order) = match version { - Version::Draft15 => (group_order, None), - _ => (None, group_order), - }; - properties.group_order = properties.group_order.or(publisher_order); - - let forward = forward.unwrap_or(true); - - Ok(Self { - request_id, - track_namespace, - track_name, - track_alias, - largest_location, - forward, - properties, - subscriber_priority, - group_order, - filter, - }) - } - } + // GROUP_ORDER is legal on PUBLISH from draft-20, when the subscription parameters + // moved here; before that it closes the session. + // + // The draft-20 parameters have to parse even though reverse publishing is + // unsupported: an unlisted parameter fails the whole message, which would kill the + // session instead of letting the request reach NOT_SUPPORTED. The timeouts are + // dropped. + decode_params!(r, version, + 0x02 => _object_delivery_timeout: Option where Filter::is_draft20(version), + 0x03 => authorization_token: Vec, + 0x06 => _subgroup_delivery_timeout: Option where Filter::is_draft20(version), + 0x08 => _expires: Option, + 0x09 => largest_location: Option, + 0x10 => forward: Option, + 0x20 => subscriber_priority: Option where Filter::is_draft20(version), + 0x21 => filter: Option where Filter::is_draft20(version), + 0x22 => group_order: Option where Filter::is_draft20(version), + ); + let properties = Properties::decode(r, version)?; + // Last, so a malformed field closes the session before a token refusal. + super::token::single(authorization_token)?; + + Ok(Self { + request_id, + track_namespace, + track_name, + track_alias, + largest_location, + forward: forward.unwrap_or(true), + properties, + subscriber_priority, + group_order, + filter, + }) } } #[derive(Debug)] pub struct PublishOk { - pub request_id: Option, pub forward: bool, /// SUBSCRIBER_PRIORITY, `None` when absent: the subscription keeps the one it had. pub subscriber_priority: Option, @@ -411,25 +304,7 @@ impl Message for PublishOk { const ID: u64 = 0x1E; fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { - if matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) { - self.request_id - .expect("request_id required for draft14-16") - .encode(w, version)?; - } else { - assert!(self.request_id.is_none(), "request_id must be None for draft17+"); - } - match version { - Version::Draft14 => { - w.bool(self.forward); - w.u8(self.subscriber_priority.unwrap_or(super::priority::DEFAULT_WIRE)); - self.group_order.unwrap_or(GroupOrder::Descending).encode(w, version)?; - // Same as SUBSCRIBE: the Location an absolute filter carries is dropped on - // decode, so encoding one would truncate the message. - self.filter.unwrap_or(Filter::Unfiltered).encode(w, version)?; - // no parameters - w.u8(0); - } // Draft-20 moved the subscription parameters out of PUBLISH_OK; they belong to // PUBLISH and REQUEST_UPDATE now, so a PUBLISH_OK carries none of them. _ if Filter::is_draft20(version) => encode_params!(w, version,), @@ -438,13 +313,13 @@ impl Message for PublishOk { // on the wrong message, which closes the session. let group_order = matches!( version, - Version::Draft15 | Version::Draft16 | Version::Draft17 | Version::Draft18 + Version::Draft18 ) .then_some(self.group_order) .flatten(); let new_group = matches!( version, - Version::Draft16 | Version::Draft17 | Version::Draft18 | Version::Draft19 + Version::Draft18 | Version::Draft19 ) .then_some(self.new_group) .flatten(); @@ -462,84 +337,27 @@ impl Message for PublishOk { } fn decode_msg(r: &mut Decoder<'_>, version: Version) -> Result { - let request_id = if matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) { - Some(RequestId::decode(r, version)?) - } else { - None - }; - - match version { - Version::Draft14 => { - let forward = r.bool()?; - let subscriber_priority = r.u8()?; - let group_order = GroupOrder::decode(r, version)?; - let filter = Filter::decode(r, version)?; - - // no parameters - Parameters::skip_response(r)?; - - Ok(Self { - request_id, - forward, - subscriber_priority: Some(subscriber_priority), - group_order: Some(group_order), - filter: Some(filter), - new_group: None, - }) - } - _ => { - // EXPIRES is ignored, as in SUBSCRIBE_OK. Delivery timeouts are legal on the - // drafts that list them and dropped: nothing here acts on a publisher's timeout. Draft-20 moved the - // subscription parameters off PUBLISH_OK, and draft-19 already dropped - // GROUP_ORDER. - decode_params!(r, version, - 0x02 => _delivery_timeout: Option where !Filter::is_draft20(version), - 0x06 => _subgroup_delivery_timeout: Option where matches!(version, Version::Draft18 | Version::Draft19), - 0x08 => _expires: Option, - 0x10 => forward: Option where !Filter::is_draft20(version), - 0x20 => subscriber_priority: Option where !Filter::is_draft20(version), - 0x21 => filter: Option where !Filter::is_draft20(version), - 0x22 => group_order: Option where matches!(version, Version::Draft15 | Version::Draft16 | Version::Draft17 | Version::Draft18), - 0x32 => new_group: Option where matches!(version, Version::Draft16 | Version::Draft17 | Version::Draft18 | Version::Draft19), - ); - - Ok(Self { - request_id, - forward: forward.unwrap_or(true), - subscriber_priority, - group_order, - filter, - new_group, - }) - } - } - } -} - -#[derive(Debug)] -pub struct PublishError<'a> { - pub request_id: RequestId, - pub error_code: u64, - pub reason_phrase: Cow<'a, str>, -} -impl Message for PublishError<'_> { - const ID: u64 = 0x1F; - - fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { - self.request_id.encode(w, version)?; - w.varint(self.error_code)?; - w.string(&self.reason_phrase)?; - Ok(()) - } + // EXPIRES is ignored, as in SUBSCRIBE_OK. Delivery timeouts are legal on the drafts + // that list them and dropped: nothing here acts on a publisher's timeout. Draft-20 + // moved the subscription parameters off PUBLISH_OK, and draft-19 already dropped + // GROUP_ORDER. + decode_params!(r, version, + 0x02 => _delivery_timeout: Option where !Filter::is_draft20(version), + 0x06 => _subgroup_delivery_timeout: Option where matches!(version, Version::Draft18 | Version::Draft19), + 0x08 => _expires: Option, + 0x10 => forward: Option where !Filter::is_draft20(version), + 0x20 => subscriber_priority: Option where !Filter::is_draft20(version), + 0x21 => filter: Option where !Filter::is_draft20(version), + 0x22 => group_order: Option where matches!(version, Version::Draft18), + 0x32 => new_group: Option where matches!(version, Version::Draft18 | Version::Draft19), + ); - fn decode_msg(r: &mut Decoder<'_>, version: Version) -> Result { - let request_id = RequestId::decode(r, version)?; - let error_code = r.varint()?; - let reason_phrase = Cow::Owned(r.string()?); Ok(Self { - request_id, - error_code, - reason_phrase, + forward: forward.unwrap_or(true), + subscriber_priority, + group_order, + filter, + new_group, }) } } @@ -663,7 +481,6 @@ mod tests { #[test] fn test_publish_ok_v14_round_trip() { let msg = PublishOk { - request_id: Some(RequestId(7)), forward: true, subscriber_priority: Some(128), group_order: Some(GroupOrder::Descending), @@ -682,7 +499,6 @@ mod tests { #[test] fn test_publish_ok_v15_round_trip() { let msg = PublishOk { - request_id: Some(RequestId(7)), forward: true, subscriber_priority: Some(128), group_order: Some(GroupOrder::Descending), @@ -730,7 +546,6 @@ mod tests { #[test] fn test_publish_ok_v17_round_trip() { let msg = PublishOk { - request_id: None, forward: true, subscriber_priority: Some(128), group_order: Some(GroupOrder::Descending), @@ -750,9 +565,6 @@ mod tests { let mut buf = Vec::new(); let w = &mut Encoder::new(&mut buf, version.into()); RequestId(1).encode(w, version).unwrap(); - if version == Version::Draft17 { - w.varint(0).unwrap(); - } encode_namespace(w, &Path::new("t")).unwrap(); w.string("v").unwrap(); w.varint(1).unwrap(); @@ -765,9 +577,6 @@ mod tests { fn publish_ok_with_param(version: Version, key: u64, value: u64) -> Vec { let mut buf = Vec::new(); let w = &mut Encoder::new(&mut buf, version.into()); - if matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) { - RequestId(1).encode(w, version).unwrap(); - } w.varint(1).unwrap(); w.varint(key).unwrap(); w.varint(value).unwrap(); @@ -801,10 +610,6 @@ mod tests { #[test] fn test_publish_done_registered_statuses_all_versions() { for version in [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, Version::Draft19, ] { @@ -812,12 +617,10 @@ mod tests { (PublishDoneStatus::InternalError, 0x0), (PublishDoneStatus::TrackEnded, 0x2), ] { - assert_eq!(status.code(version), expected); + assert_eq!(status.code(), expected); let msg = PublishDone { - request_id: matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) - .then_some(RequestId(7)), - status_code: status.code(version), + status_code: status.code(), stream_count: 5, reason_phrase: "done".into(), }; @@ -836,13 +639,12 @@ mod tests { #[test] fn publish_done_end_follows_the_status() { let done = |status_code| PublishDone { - request_id: None, status_code, stream_count: 0, reason_phrase: "".into(), }; - for version in [Version::Draft14, Version::Draft19, Version::Draft20, Version::Draft22] { + for version in [Version::Draft19, Version::Draft20, Version::Draft22] { assert!(done(0x2).end(version).is_ok(), "{version:?}"); assert!( matches!(done(0x1).end(version), Err(crate::Error::Unauthorized)), @@ -894,10 +696,6 @@ mod tests { #[test] fn publish_priority_property_bytes_on_every_draft() { for version in [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft20, @@ -919,18 +717,14 @@ mod tests { let baseline = encode_message(&msg, version); msg.properties.priority = Some(37); let encoded = encode_message(&msg, version); - if matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) { - assert_eq!(encoded, baseline, "{version}"); - } else { - assert_eq!(encoded, [baseline, vec![0x0e, 37]].concat(), "{version}"); - assert_eq!( - decode_message::(&encoded, version) - .unwrap() - .properties - .priority, - Some(37) - ); - } + assert_eq!(encoded, [baseline, vec![0x0e, 37]].concat(), "{version}"); + assert_eq!( + decode_message::(&encoded, version) + .unwrap() + .properties + .priority, + Some(37) + ); } } @@ -1048,7 +842,6 @@ mod tests { #[test] fn test_publish_ok_v18_round_trip() { let msg = PublishOk { - request_id: None, forward: true, subscriber_priority: Some(128), group_order: Some(GroupOrder::Descending), @@ -1092,7 +885,6 @@ mod tests { fn test_publish_ok_carries_new_group_request() { for version in [Version::Draft18, Version::Draft19] { let msg = PublishOk { - request_id: None, forward: true, subscriber_priority: None, group_order: None, @@ -1108,7 +900,6 @@ mod tests { fn test_publish_done_preserves_unknown_status() { const UNKNOWN: u64 = 0xface; let msg = PublishDone { - request_id: None, status_code: UNKNOWN, stream_count: 5, reason_phrase: "extension".into(), diff --git a/rs/moq-net/src/ietf/publish_namespace.rs b/rs/moq-net/src/ietf/publish_namespace.rs index d0e6ffa3996..8e2a352c76f 100644 --- a/rs/moq-net/src/ietf/publish_namespace.rs +++ b/rs/moq-net/src/ietf/publish_namespace.rs @@ -1,6 +1,5 @@ //! IETF moq-transport-14 publish namespace messages -use std::borrow::Cow; use crate::{Epoch, Path, coding::*, ietf::RequestId}; @@ -65,9 +64,6 @@ impl PublishNamespace<'_> { /// which surfaces here as [`DecodeError::InvalidValue`]. pub fn decode_body(r: &mut Decoder<'_>, version: Version, negotiated: Negotiated) -> Result { let request_id = RequestId::decode(r, version)?; - if version == Version::Draft17 { - let _required_request_id_delta = r.varint()?; - } let track_namespace = decode_namespace(r)?; decode_params!(r, version, @@ -97,9 +93,6 @@ impl Message for PublishNamespace<'_> { fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { self.request_id.encode(w, version)?; - if version == Version::Draft17 { - w.varint(0)?; // required_request_id_delta = 0 (draft-17 only, removed in draft-18 per #1615) - } encode_namespace(w, &self.track_namespace)?; // ROUTE_COST is optional and absent means 0, so a free path sends nothing. let hops = self.params.cluster.as_ref().map(|advert| advert.hops.clone()); @@ -146,14 +139,11 @@ fn cluster_params( /// /// An omitted parameter keeps its value (moq-transport Section 9.5), so a cost that /// dropped to 0 is sent as an explicit 0, unlike the advertisement itself where absent -/// means 0. Draft-16+: the cluster extension negotiates on draft-17+ only, so draft-16 -/// carries only the token. +/// means 0. #[derive(Clone, Debug, PartialEq, Eq)] pub struct PublishNamespaceUpdate { /// The update's own Request ID; every REQUEST_UPDATE consumes one. pub request_id: RequestId, - /// Draft-16 only: the PUBLISH_NAMESPACE this updates, which later drafts name by stream. - pub namespace_request_id: Option, /// HOP_PATH, when the route changed. pub hops: Option, /// ROUTE_COST, when the cost changed. @@ -168,7 +158,6 @@ impl PublishNamespaceUpdate { pub fn between(request_id: RequestId, held: &cluster::Advert, next: &cluster::Advert) -> Self { Self { request_id, - namespace_request_id: None, hops: (held.hops != next.hops).then(|| next.hops.clone()), cost: (held.cost != next.cost).then_some(next.cost), authorization_token: None, @@ -188,20 +177,7 @@ impl Message for PublishNamespaceUpdate { const ID: u64 = 0x02; fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { - match version { - Version::Draft14 | Version::Draft15 => return Err(EncodeError::Version), - Version::Draft16 => { - self.request_id.encode(w, version)?; - self.namespace_request_id - .ok_or(EncodeError::Version)? - .encode(w, version)?; - } - Version::Draft17 => { - self.request_id.encode(w, version)?; - w.varint(0)?; // required_request_id_delta = 0 (draft-17 only, removed in draft-18 per #1615) - } - _ => self.request_id.encode(w, version)?, - } + self.request_id.encode(w, version)?; encode_params!(w, version, 0x03 => self.authorization_token.clone(), cluster::HOP_PATH => self.hops, @@ -211,16 +187,7 @@ impl Message for PublishNamespaceUpdate { } fn decode_msg(r: &mut Decoder<'_>, version: Version) -> Result { - let (request_id, namespace_request_id) = match version { - Version::Draft14 | Version::Draft15 => return Err(DecodeError::Version), - Version::Draft16 => (RequestId::decode(r, version)?, Some(RequestId::decode(r, version)?)), - Version::Draft17 => { - let request_id = RequestId::decode(r, version)?; - let _required_request_id_delta = r.varint()?; - (request_id, None) - } - _ => (RequestId::decode(r, version)?, None), - }; + let request_id = RequestId::decode(r, version)?; decode_params!(r, version, 0x03 => authorization_token: Vec, cluster::HOP_PATH => hops: Option, @@ -229,7 +196,6 @@ impl Message for PublishNamespaceUpdate { let authorization_token = super::token::single(authorization_token)?; Ok(Self { request_id, - namespace_request_id, hops, cost, authorization_token, @@ -276,161 +242,6 @@ pub(super) fn decode_advert_params( }) } -/// PublishNamespaceOk message (0x07) -#[derive(Clone, Debug)] -pub struct PublishNamespaceOk { - pub request_id: RequestId, -} - -impl Message for PublishNamespaceOk { - const ID: u64 = 0x07; - - fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { - self.request_id.encode(w, version)?; - Ok(()) - } - - fn decode_msg(r: &mut Decoder<'_>, version: Version) -> Result { - let request_id = RequestId::decode(r, version)?; - Ok(Self { request_id }) - } -} - -/// PublishNamespaceError message (0x08) -#[derive(Clone, Debug)] -pub struct PublishNamespaceError<'a> { - pub request_id: RequestId, - pub error_code: u64, - pub reason_phrase: Cow<'a, str>, -} - -impl Message for PublishNamespaceError<'_> { - const ID: u64 = 0x08; - - fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { - self.request_id.encode(w, version)?; - w.varint(self.error_code)?; - w.string(&self.reason_phrase)?; - Ok(()) - } - - fn decode_msg(r: &mut Decoder<'_>, version: Version) -> Result { - let request_id = RequestId::decode(r, version)?; - let error_code = r.varint()?; - let reason_phrase = Cow::Owned(r.string()?); - - Ok(Self { - request_id, - error_code, - reason_phrase, - }) - } -} - -/// PublishNamespaceDone message (0x09) -/// v14/v15: uses track_namespace. v16: uses request_id. -#[derive(Clone, Debug)] -pub struct PublishNamespaceDone<'a> { - /// v14/v15: the namespace being unannounced - pub track_namespace: Path<'a>, - /// v16: the request ID of the original PublishNamespace - pub request_id: RequestId, -} - -impl Message for PublishNamespaceDone<'_> { - const ID: u64 = 0x09; - - fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { - match version { - Version::Draft14 | Version::Draft15 => { - encode_namespace(w, &self.track_namespace)?; - } - Version::Draft16 => { - self.request_id.encode(w, version)?; - } - _ => return Err(EncodeError::Version), - } - Ok(()) - } - - fn decode_msg(r: &mut Decoder<'_>, version: Version) -> Result { - match version { - Version::Draft14 | Version::Draft15 => { - let track_namespace = decode_namespace(r)?; - Ok(Self { - track_namespace, - request_id: RequestId(0), - }) - } - Version::Draft16 => { - let request_id = RequestId::decode(r, version)?; - Ok(Self { - track_namespace: Path::default(), - request_id, - }) - } - _ => Err(DecodeError::Version), - } - } -} - -/// PublishNamespaceCancel message (0x0c) -/// v14/v15: uses track_namespace. v16: uses request_id. -#[derive(Clone, Debug)] -pub struct PublishNamespaceCancel<'a> { - /// v14/v15: the namespace being cancelled - pub track_namespace: Path<'a>, - /// v16: the request ID of the original PublishNamespace - pub request_id: RequestId, - pub error_code: u64, - pub reason_phrase: Cow<'a, str>, -} - -impl Message for PublishNamespaceCancel<'_> { - const ID: u64 = 0x0c; - - fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { - match version { - Version::Draft14 | Version::Draft15 => { - encode_namespace(w, &self.track_namespace)?; - } - Version::Draft16 => { - self.request_id.encode(w, version)?; - } - _ => { - return Err(EncodeError::Version); - } - } - w.varint(self.error_code)?; - w.string(&self.reason_phrase)?; - Ok(()) - } - - fn decode_msg(r: &mut Decoder<'_>, version: Version) -> Result { - let (track_namespace, request_id) = match version { - Version::Draft14 | Version::Draft15 => { - let track_namespace = decode_namespace(r)?; - (track_namespace, RequestId(0)) - } - Version::Draft16 => { - let request_id = RequestId::decode(r, version)?; - (Path::default(), request_id) - } - _ => { - return Err(DecodeError::Version); - } - }; - let error_code = r.varint()?; - let reason_phrase = Cow::Owned(r.string()?); - Ok(Self { - track_namespace, - request_id, - error_code, - reason_phrase, - }) - } -} - #[cfg(test)] mod tests { use super::*; @@ -635,7 +446,7 @@ mod tests { assert_eq!(msg.hops, None, "an unchanged path is omitted"); assert_eq!(msg.cost, Some(0), "a cost of 0 is sent explicitly"); - for version in [Version::Draft17, Version::Draft18, Version::Draft22] { + for version in [Version::Draft18, Version::Draft22] { let encoded = encode_message(&msg, version); let decoded: PublishNamespaceUpdate = decode_message(&encoded, version).unwrap(); assert_eq!(decoded, msg, "{version}"); @@ -668,7 +479,7 @@ mod tests { value: b"jwt".to_vec(), })), }; - for version in [Version::Draft14, Version::Draft15, Version::Draft16] { + for version in [Version::Draft15] { let mut buf = Vec::new(); assert!( msg.encode_msg(&mut Encoder::new(&mut buf, version.into()), version) diff --git a/rs/moq-net/src/ietf/publisher.rs b/rs/moq-net/src/ietf/publisher.rs index 8eef9575a41..c20a1423022 100644 --- a/rs/moq-net/src/ietf/publisher.rs +++ b/rs/moq-net/src/ietf/publisher.rs @@ -55,7 +55,7 @@ fn track_properties( version: Version, negotiated: bool, ) -> Result { - let compressed = info.compress && negotiated && super::flate::supported(version); + let compressed = info.compress && negotiated; super::flate::egress(info, compressed)?; let mut plain = info.clone(); plain.compress = compressed; @@ -67,14 +67,10 @@ fn track_properties( return Ok(ietf::Properties::restated(info)); }; let mut unknown = track.values.clone(); - let block = !matches!(version, Version::Draft14 | Version::Draft15); - if block && track.immutable().is_some() && !super::object::same_bytes(track.version, version) { - return Err(Error::Unsupported); - } // Across draft-19, forwarding 0x06 would give it a different meaning, as for object // properties. A mutable one is dropped; a sealed one is refused. if super::object::has_delivery_timeout(track.version) != super::object::has_delivery_timeout(version) { - if block && track.sealed().any(|id| id == 0x06) { + if track.sealed().any(|id| id == 0x06) { return Err(Error::Unsupported); } unknown.retain(|property| property.id != 0x06); @@ -146,7 +142,7 @@ struct FetchObjectInfo<'a> { source: Option, } -fn fetch_prior(version: Version, prior: Option, object: u64) -> Result { +fn fetch_prior(prior: Option, object: u64) -> Result { let Some(prior) = prior else { return Ok(FetchPrior::None); }; @@ -154,10 +150,7 @@ fn fetch_prior(version: Version, prior: Option, object: u64) -> Result 0) .ok_or(Error::MalformedTrack)?; - Ok(FetchPrior::Same((step != 1).then_some(match version { - Version::Draft14 | Version::Draft15 | Version::Draft16 | Version::Draft17 => object, - _ => step, - }))) + Ok(FetchPrior::Same((step != 1).then_some(step))) } impl FetchedGroup { @@ -416,23 +409,6 @@ impl Target { } } - /// Ready when the peer ends this loop by closing the stream it asked on. - /// - /// An unsolicited loop has no stream of its own to watch and parks here: the - /// session driver polling it is what drops it when the session ends. - fn poll_closed( - &mut self, - finished: &mut bool, - goaways: &mut super::request_stream::Messages, - version: Version, - cx: &mut std::task::Context<'_>, - ) -> Poll> { - match self.stream() { - Some(stream) => super::request_stream::poll_cancel(stream, finished, goaways, version, cx), - None => Poll::Pending, - } - } - /// `goaways` checks each GOAWAY the requester sends on this stream. fn poll_event( &mut self, @@ -443,14 +419,6 @@ impl Target { ) -> Poll { use super::request_stream::{NamespaceUpdate, Next}; - if matches!( - version, - Version::Draft14 | Version::Draft15 | Version::Draft16 | Version::Draft17 - ) { - return self - .poll_closed(finished, goaways, version, cx) - .map(NamespaceEvent::Closed); - } let Some(stream) = self.stream() else { return Poll::Pending; }; @@ -544,12 +512,12 @@ enum Served { /// The track and any fill finished, or serving ended with this error. Track(Result<(), Error>), /// An update could not be applied, its parameters unsupported or its renewal refused - /// (drafts 16 section 9.11.1, 18 section 10.9.1). The update was already answered, and - /// PUBLISH_DONE says UPDATE_FAILED, or on draft 14 the refusal itself. + /// (draft-18 section 10.9.1). The update was already answered, and PUBLISH_DONE says + /// UPDATE_FAILED. UpdateFailed(Error), - /// FORWARD=0 paused the subscription, which stays established. The update setting it, if - /// any, is not answered yet; none when a SUBSCRIBE started paused. - Paused(Option), + /// FORWARD=0 paused the subscription, which stays established. True when an update set + /// it and is not answered yet, false when a SUBSCRIBE started paused. + Paused(bool), } /// What reading a subscriber's next message on its request stream found. @@ -576,11 +544,8 @@ enum Subscribed { impl Served { /// The PUBLISH_DONE status and reason this end reports. - fn status(&self, version: Version) -> (ietf::PublishDoneStatus, &'static str) { + fn status(&self) -> (ietf::PublishDoneStatus, &'static str) { match self { - // Draft 14 neither answers an update nor registers UPDATE_FAILED, so the - // PUBLISH_DONE is the only place the subscriber learns why its renewal failed. - Self::UpdateFailed(err) if version == Version::Draft14 => Self::Track(Err(err.clone())).status(version), Self::Track(Ok(())) => (ietf::PublishDoneStatus::TrackEnded, "track ended"), Self::Track(Err( Error::Unauthorized @@ -787,16 +752,12 @@ impl Publisher { self } - /// What the peer declared in its SETUP, or the default (extension off) on a version - /// that cannot negotiate it. + /// What the peer declared in its SETUP. /// /// Blocks until the peer's SETUP arrives, because the extension changes the NAMESPACE /// encoding: nothing can be advertised until we know whether the peer speaks it. fn poll_peer(&self, waiter: &kio::Waiter) -> Poll { - match cluster::supported(self.version) { - true => self.peer_setup.poll_get(waiter).map(|peer| peer.cluster), - false => Poll::Ready(cluster::Peer::default()), - } + self.peer_setup.poll_get(waiter).map(|peer| peer.cluster) } /// Await [`Self::poll_peer`]. @@ -911,7 +872,7 @@ impl Publisher { if !data.is_empty() { return Err(Error::WrongSize); } - return Ok(this.reject_token(stream, request::Kind::Subscribe, body.clone(), err, serve)); + return Ok(this.reject_token(stream, request::Kind::Subscribe, err, serve)); } msg => msg?, }; @@ -943,7 +904,7 @@ impl Publisher { if !data.is_empty() { return Err(Error::WrongSize); } - return Ok(this.reject_token(stream, request::Kind::Fetch, body.clone(), err, serve)); + return Ok(this.reject_token(stream, request::Kind::Fetch, err, serve)); } msg => msg?, }; @@ -963,47 +924,21 @@ impl Publisher { } .maybe_boxed() } - // Draft-18 SUBSCRIBE_NAMESPACE (0x50) and the legacy 0x11 message decode - // to the same request_id + namespace. We never send PUBLISH, so a legacy - // request for PUBLISH alone is refused, and one for both gets only NAMESPACE. - ietf::SubscribeNamespace::ID | ietf::SubscribeNamespaceLegacy::ID => { - let decoded = if id == ietf::SubscribeNamespace::ID { - ietf::SubscribeNamespace::decode_msg(&mut data, this.version) - .map(|msg| (msg, ietf::SubscribeOptions::Namespace)) - } else { - ietf::SubscribeNamespaceLegacy::decode_msg(&mut data, this.version).map(|legacy| { - let msg = ietf::SubscribeNamespace { - request_id: legacy.request_id, - namespace: legacy.namespace, - hidden: legacy.hidden, - }; - (msg, legacy.subscribe_options) - }) - }; - let (msg, options) = match decoded { + ietf::SubscribeNamespace::ID => { + let msg = match ietf::SubscribeNamespace::decode_msg(&mut data, this.version) { Err(err) if super::token::refuses_request(&err) => { // Junk after the fields is fatal, which a token refusal must not hide. if !data.is_empty() { return Err(Error::WrongSize); } let kind = request::Kind::SubscribeNamespace; - return Ok(this.reject_token(stream, kind, body.clone(), err, serve)); + return Ok(this.reject_token(stream, kind, err, serve)); } decoded => decoded?, }; if !data.is_empty() { return Err(Error::WrongSize); } - if options == ietf::SubscribeOptions::Publish { - let request_id = msg.request_id; - return Ok(async move { - let reason = "SUBSCRIBE_NAMESPACE for PUBLISH is not supported"; - if let Err(err) = this.reject_namespace_request(stream, request_id, reason).await { - tracing::debug!(%err, "subscribe_namespace refusal failed"); - } - } - .maybe_boxed()); - } tracing::debug!(message = ?msg, "received subscribe_namespace"); let gate = crate::auth::Gate::new( this.auth.clone(), @@ -1024,7 +959,7 @@ impl Publisher { } .maybe_boxed() } - ietf::SubscribeTracks::ID if super::subscribe_tracks::has_subscribe_tracks(this.version) => { + ietf::SubscribeTracks::ID => { let msg = match ietf::SubscribeTracks::decode_msg(&mut data, this.version) { Err(err) if super::token::refuses_request(&err) => { // Junk after the fields is fatal, which a token refusal must not hide. @@ -1032,7 +967,7 @@ impl Publisher { return Err(Error::WrongSize); } let kind = request::Kind::SubscribeNamespace; - return Ok(this.reject_token(stream, kind, body.clone(), err, serve)); + return Ok(this.reject_token(stream, kind, err, serve)); } msg => msg?, }; @@ -1054,7 +989,7 @@ impl Publisher { if !data.is_empty() { return Err(Error::WrongSize); } - return Ok(this.reject_token(stream, request::Kind::TrackStatus, body.clone(), err, serve)); + return Ok(this.reject_token(stream, request::Kind::TrackStatus, err, serve)); } msg => msg?, }; @@ -1091,14 +1026,13 @@ impl Publisher { &self, stream: Stream, kind: request::Kind, - body: ietf::Body, err: DecodeError, serve: Option, ) -> MaybeSendBox<'static, ()> { let version = self.version; async move { let _serve = serve; - if let Err(err) = super::token::reject(stream, kind, body, err, version).await { + if let Err(err) = super::token::reject(stream, kind, err, version).await { tracing::debug!(%err, "token refusal failed"); } } @@ -1142,7 +1076,6 @@ impl Publisher { Some(subscribed) => Some(subscribed), None => { let error = ietf::RequestError { - request_id: None, error_code: request::DUPLICATE_SUBSCRIPTION, reason_phrase: "the track is PUBLISHed to this session".into(), retry_interval: 0, @@ -1179,7 +1112,7 @@ impl Publisher { }; if token.is_none() && !gate.allows() { let err = Error::Unauthorized; - return self.reject_subscribe(stream, request_id, &err, "not granted").await; + return self.reject_subscribe(stream, &err, "not granted").await; } // Legal requests we can't honor are refused one at a time, never by closing the // session. Serving a Range Filter unfiltered would deliver objects the subscriber @@ -1188,7 +1121,6 @@ impl Publisher { return super::request_stream::reject( stream, ietf::RequestError { - request_id: None, error_code: request::INVALID_FILTER, reason_phrase: "Range Filters exceed MAX_FILTER_RANGES=0".into(), retry_interval: 0, @@ -1234,7 +1166,7 @@ impl Publisher { Ok(grant) => (gate.named(), Some(grant)), Err(refusal) => { return self - .reject_subscribe(stream, request_id, &refusal.error, &refusal.reason) + .reject_subscribe(stream, &refusal.error, &refusal.reason) .await; } } @@ -1301,7 +1233,7 @@ impl Publisher { // Timestamp's units from TRACK_STATUS, so the opt-out strips nothing from the // objects. let timescale = track_serve.timescale; - let mut properties = match track_properties( + let properties = match track_properties( track_serve.track.info(), msg.properties_wanted, self.version, @@ -1312,9 +1244,6 @@ impl Publisher { }; // Through draft-15 this restates the order the subscription is served in. // Later drafts carry the publisher's default instead. - if matches!(self.version, Version::Draft14 | Version::Draft15) { - properties.group_order = Some(msg.group_order.to_order().into()); - } // Draft-20 replaced joining FETCH with subscription fills. Older drafts save // the same boundary used by the subscription so the two streams never overlap, @@ -1358,10 +1287,6 @@ impl Publisher { stream .writer .encode_message(&ietf::SubscribeOk { - request_id: match self.version { - Version::Draft14 | Version::Draft15 | Version::Draft16 => Some(request_id), - _ => None, - }, track_alias: request_id.0, // The subscription floor and FETCH/FILL cap use this same snapshot. largest: edge.largest, @@ -1394,12 +1319,12 @@ impl Publisher { false => { // Unpolled, it would still hold the track it serves from. drop(fill); - Some(Served::Paused(None)) + Some(Served::Paused(false)) } }; // A pause drops the subscription, and its demand with it; a resume subscribes // again as a new SUBSCRIBE would, so nothing carries across but the request. - while let Some(Served::Paused(update)) = served { + while let Some(Served::Paused(answer)) = served { // What an update changed while forwarding outlives the pause. let applied = track_serve.track.subscription(); msg.subscriber_priority = super::priority::to_wire(applied.priority); @@ -1407,21 +1332,19 @@ impl Publisher { track_serve.close_groups(); self.pause_join(_join.as_ref()); drop(track_serve); - if let Some(update) = update - && self.version != Version::Draft14 - { - self.write_request_ok(&mut stream.writer, update, None).await?; + if answer { + self.write_request_ok(&mut stream.writer, None).await?; } - let resume = match self + match self .wait_resume(&mut stream, &mut request_finished, &mut goaways, &mut msg) .await { - Ok(resume) => resume, + Ok(()) => {} Err(served) => { let served = served.unwrap_or(Served::Track(Ok(()))); return Ok(Subscribed::Served(served, opened.load(Ordering::Relaxed))); } - }; + } let resumed = match broadcast.track(&msg.track_name) { Ok(track) => self .subscribe_track(&mut stream, &track, &msg) @@ -1441,10 +1364,8 @@ impl Publisher { Ok(resumed) => resumed, // The resuming update is owed an answer, so it fails. Err(err) => { - if self.version != Version::Draft14 { - self.write_subscribe_error(&mut stream.writer, resume, &err, "resume failed") - .await?; - } + self.write_subscribe_error(&mut stream.writer, &err, "resume failed") + .await?; return Ok(Subscribed::Served( Served::UpdateFailed(err), opened.load(Ordering::Relaxed), @@ -1453,9 +1374,7 @@ impl Publisher { }; track_serve.opened = opened.clone(); save_join(edge.largest, &track, &track_serve.ranking); - if self.version != Version::Draft14 { - self.write_request_ok(&mut stream.writer, resume, edge.largest).await?; - } + self.write_request_ok(&mut stream.writer, edge.largest).await?; served = self .run_subscription( &mut stream, @@ -1507,7 +1426,7 @@ impl Publisher { let (served, streams) = match subscribed { Ok(Ok(Subscribed::Served(served, streams))) => (served, streams), Ok(Ok(Subscribed::Refused(reason, err))) => { - return self.reject_subscribe(stream, request_id, &err, &reason).await; + return self.reject_subscribe(stream, &err, &reason).await; } // Nobody is left to answer. Ok(Ok(Subscribed::Withdrawn)) => { @@ -1519,12 +1438,12 @@ impl Publisher { Some(opened) => (Served::Track(Err(refusal.error)), opened.load(Ordering::Relaxed)), None => { return self - .reject_subscribe(stream, request_id, &refusal.error, &refusal.reason) + .reject_subscribe(stream, &refusal.error, &refusal.reason) .await; } }, }; - self.write_publish_done(stream, request_id, served, streams, Some(&credit)) + self.write_publish_done(stream, served, streams, Some(&credit)) .await } } @@ -1614,12 +1533,11 @@ impl Publisher { async fn write_publish_done( &self, mut stream: Stream, - request_id: RequestId, served: Served, streams: u64, credit: Option<&kio::Producer<()>>, ) -> Result<(), Error> { - let (status, reason) = served.status(self.version); + let (status, reason) = served.status(); let res = match served { Served::Track(res) => res, Served::UpdateFailed(err) => Err(err), @@ -1629,11 +1547,7 @@ impl Publisher { let _ = stream .writer .encode_message(&ietf::PublishDone { - request_id: match self.version { - Version::Draft14 | Version::Draft15 | Version::Draft16 => Some(request_id), - _ => None, - }, - status_code: status.code(self.version), + status_code: status.code(), stream_count: streams, reason_phrase: reason.into(), }) @@ -1705,15 +1619,14 @@ impl Publisher { if session.poll_closed(&mut cx).is_ready() { return Poll::Ready(Turn::Cancelled); } - if !matches!(self.version, Version::Draft14 | Version::Draft15 | Version::Draft16) - && stream.writer.poll_closed(&mut cx).is_ready() + if stream.writer.poll_closed(&mut cx).is_ready() { return Poll::Ready(Turn::Cancelled); } if let Poll::Ready(renewed) = renewal.poll(waiter) { return Poll::Ready(Turn::Renewal(renewed)); } - match self.poll_subscribe_update(stream, finished, goaways, &mut cx) { + match self.poll_update(stream, finished, goaways, &mut cx) { Poll::Ready(UpdateRead::Update(update)) => return Poll::Ready(Turn::Update(update)), Poll::Ready(UpdateRead::Cancelled) => return Poll::Ready(Turn::Cancelled), Poll::Ready(UpdateRead::Malformed(err)) => return Poll::Ready(Turn::Malformed(err)), @@ -1738,7 +1651,7 @@ impl Publisher { // Draft 14 answers no update. Drafts 15 and 16 answer on the control stream, // naming the update's own Request ID; later drafts name none. - let answer = self.version != Version::Draft14; + let answer = true; match turn { // A malformed update, such as one whose AUTHORIZATION TOKEN names an alias, @@ -1759,14 +1672,13 @@ impl Publisher { Turn::Renewal(request_update::Verdict { verdict, grant: res, - request_id: rid, }) => { // Only a token-authorized request starts a renewal. let rg = request_grant.as_ref().expect("a renewal without a request grant"); // On accept the old grant is dropped (ending the old token) and the deadline // re-armed at the new expiry. let Err(refusal) = rg.renew(verdict, res) else { - if answer && let Err(err) = self.write_request_ok(&mut stream.writer, rid, None).await { + if answer && let Err(err) = self.write_request_ok(&mut stream.writer, None).await { return Some(Served::Track(Err(err))); } continue; @@ -1776,7 +1688,7 @@ impl Publisher { // UPDATE_FAILED. The session stays up and the old grant does not survive. if answer && let Err(err) = self - .write_subscribe_error(&mut stream.writer, rid, &refusal.error, &refusal.reason) + .write_subscribe_error(&mut stream.writer, &refusal.error, &refusal.reason) .await { return Some(Served::Track(Err(err))); @@ -1892,8 +1804,8 @@ impl Publisher { Some(Ok((serve, edge))) } - /// Hold a paused SUBSCRIBE, answering its updates, until one resumes it: the Request ID of - /// that update, or how the request ended (`None` when cancelled). + /// Hold a paused SUBSCRIBE, answering its updates, until one resumes it, or return how the + /// request ended (`None` when cancelled). /// /// A paused subscription holds nothing upstream, so only its priority and max age change /// while it waits; anything else fails the update, ending the request. @@ -1903,7 +1815,7 @@ impl Publisher { finished: &mut bool, goaways: &mut super::request_stream::Messages, msg: &mut ietf::Subscribe<'_>, - ) -> Result> { + ) -> Result<(), Option> { let mut session = self.session.clone(); loop { let read = kio::wait(|waiter| { @@ -1911,12 +1823,11 @@ impl Publisher { if session.poll_closed(&mut cx).is_ready() { return Poll::Ready(UpdateRead::Cancelled); } - if !matches!(self.version, Version::Draft14 | Version::Draft15 | Version::Draft16) - && stream.writer.poll_closed(&mut cx).is_ready() + if stream.writer.poll_closed(&mut cx).is_ready() { return Poll::Ready(UpdateRead::Cancelled); } - self.poll_subscribe_update(stream, finished, goaways, &mut cx) + self.poll_update(stream, finished, goaways, &mut cx) }) .await; let update = match read { @@ -1945,16 +1856,13 @@ impl Publisher { None => None, }; if let Some(err) = refused { - if self.version != Version::Draft14 { - self.write_subscribe_error( - &mut stream.writer, - update.request_id, - &err, - "REQUEST_UPDATE parameters not supported while paused", - ) - .await - .map_err(|err| Some(Served::Track(Err(err))))?; - } + self.write_subscribe_error( + &mut stream.writer, + &err, + "REQUEST_UPDATE parameters not supported while paused", + ) + .await + .map_err(|err| Some(Served::Track(Err(err))))?; return Err(Some(Served::UpdateFailed(Error::Unsupported))); } if let Some(priority) = update.priority { @@ -1964,44 +1872,15 @@ impl Publisher { msg.max_age = Some(max_age); } if update.forward == Some(true) { - return Ok(update.request_id); + return Ok(()); } - if self.version != Version::Draft14 { - self.write_request_ok(&mut stream.writer, update.request_id, None) - .await - .map_err(|err| Some(Served::Track(Err(err))))?; - } - } - } - - /// Read a SUBSCRIBE's next REQUEST_UPDATE: from the control stream's follow-ups through - /// draft 16, where UNSUBSCRIBE cancels, or from its request stream after. - fn poll_subscribe_update( - &self, - stream: &mut Stream, - finished: &mut bool, - goaways: &mut super::request_stream::Messages, - cx: &mut std::task::Context<'_>, - ) -> Poll { - if *finished { - return Poll::Pending; - } - if !matches!(self.version, Version::Draft14 | Version::Draft15 | Version::Draft16) { - return self.poll_update(stream, finished, goaways, cx); - } - use super::request_stream::{FollowUp, Update}; - match ready!(stream.reader.poll_decode_maybe::(cx)) { - Ok(Some(FollowUp::Update(body))) => Poll::Ready(match Update::decode_legacy(&body, self.version) { - Ok(update) => UpdateRead::Update(update), - Err(err) => UpdateRead::Malformed(err), - }), - // UNSUBSCRIBE, or the control stream going away. - Ok(Some(FollowUp::End) | None) => Poll::Ready(UpdateRead::Cancelled), - Err(err) => Poll::Ready(UpdateRead::Malformed(err)), + self.write_request_ok(&mut stream.writer, None) + .await + .map_err(|err| Some(Served::Track(Err(err))))?; } } - /// Read the requester's next REQUEST_UPDATE on a draft-17+ request stream, admitting its + /// Read the requester's next REQUEST_UPDATE on its request stream, admitting its /// Request ID. Pending once the requester finished sending where a FIN does not cancel. fn poll_update( &self, @@ -2057,7 +1936,7 @@ impl Publisher { ) -> Result<(), Served> { // Draft 14 answers no update. Drafts 15 and 16 answer on the control stream, naming the // update's own Request ID; later drafts name none. - let answer = self.version != Version::Draft14; + let answer = true; let failed = |err| Served::Track(Err(err)); // A token renews a token-authorized request. Where tokens decide, one arriving on a // request admitted without one is refused rather than taken unread, so every token this @@ -2098,7 +1977,7 @@ impl Publisher { }; if let Some((reason, err)) = refused { if answer { - self.write_subscribe_error(&mut stream.writer, update.request_id, &err, reason) + self.write_subscribe_error(&mut stream.writer, &err, reason) .await .map_err(failed)?; } @@ -2120,14 +1999,14 @@ impl Publisher { } // The caller stops forwarding, then answers. if update.forward == Some(false) { - return Err(Served::Paused(Some(update.request_id))); + return Err(Served::Paused(true)); } if let (Some(token), Some(grant)) = (update.authorization_token, request_grant) { - renewal.verify(grant.verify_renewal(&self.auth, token.0), update.request_id); + renewal.verify(grant.verify_renewal(&self.auth, token.0)); return Ok(()); } if answer { - self.write_request_ok(&mut stream.writer, update.request_id, None) + self.write_request_ok(&mut stream.writer, None) .await .map_err(failed)?; } @@ -2142,13 +2021,11 @@ impl Publisher { async fn write_request_ok( &self, writer: &mut Writer, - request_id: RequestId, largest: Option, ) -> Result<(), Error> { writer .encode_message(&ietf::RequestOk { largest, - request_id: matches!(self.version, Version::Draft15 | Version::Draft16).then_some(request_id), active: None, }) .await @@ -2163,11 +2040,10 @@ impl Publisher { async fn reject_subscribe( &self, mut stream: Stream, - request_id: RequestId, err: &Error, reason: &str, ) -> Result<(), Error> { - self.write_subscribe_error(&mut stream.writer, request_id, err, reason) + self.write_subscribe_error(&mut stream.writer, err, reason) .await?; // The peer dropping the stream once it has the rejection is a normal end, not our failure. @@ -2179,11 +2055,10 @@ impl Publisher { async fn write_subscribe_error( &self, writer: &mut Writer, - request_id: RequestId, err: &Error, reason: &str, ) -> Result<(), Error> { - super::request_stream::write_error(writer, request::Kind::Subscribe, request_id, err, reason, self.version) + super::request_stream::write_error(writer, request::Kind::Subscribe, err, reason, self.version) .await } @@ -2341,7 +2216,7 @@ impl Publisher { FetchObjectInfo { sequence, object: index, - prior: fetch_prior(version, prior, index)?, + prior: fetch_prior(prior, index)?, timestamp: frame.timestamp, inflated: frame.inflated, timescale, @@ -2351,7 +2226,7 @@ impl Publisher { }, ) .await?; - Self::write_fetch_payload(stream, frame.frame.payload, version).await?; + Self::write_fetch_payload(stream, frame.frame.payload).await?; prior = Some(index); } index += 1; @@ -2389,7 +2264,7 @@ impl Publisher { FetchObjectInfo { sequence, object: index, - prior: fetch_prior(version, prior, index)?, + prior: fetch_prior(prior, index)?, timestamp: frame.timestamp, inflated: frame.inflated, timescale, @@ -2403,9 +2278,6 @@ impl Publisher { index += 1; stream.varint(frame.size).await?; - if frame.size == 0 && matches!(version, Version::Draft14 | Version::Draft15) { - stream.varint(0).await?; - } loop { let chunk = { let mut closed = std::pin::pin!(stream.closed()); @@ -2453,7 +2325,7 @@ impl Publisher { } = header; // Relayed properties survive without a timescale. Plain frames generate a // timestamp only on drafts that can declare its units. - let timescale = timescale.filter(|_| ietf::Properties::sends_timescale(version)); + let timescale = timescale; let properties = if let Some(fields) = fields { let properties = super::object::write(&fields.properties, source, timestamp, version, timescale)?; (!properties.is_empty()).then_some(properties) @@ -2467,7 +2339,6 @@ impl Publisher { &mut Encoder::new(&mut properties, version.into()), timestamp, timescale, - version, )?; Some(properties) } @@ -2477,18 +2348,6 @@ impl Publisher { let properties = super::object::compression(properties.unwrap_or_default(), version, inflated)?; let properties = (!properties.is_empty()).then_some(properties); - if version == Version::Draft14 { - let properties = properties.unwrap_or_default(); - stream.buffer_varint(sequence)?; - stream.buffer_varint(0)?; - stream.buffer_varint(object)?; - // Publisher priority, a raw byte. - stream.buffer_raw(&[0]); - stream.buffer_varint(properties.len() as u64)?; - stream.buffer_raw(&properties); - std::future::poll_fn(|cx| stream.poll_flush(cx)).await?; - return Ok(()); - } let header = match prior { // The first object must carry its absolute Group and Object IDs. Include the @@ -2519,13 +2378,9 @@ impl Publisher { async fn write_fetch_payload( stream: &mut Writer, Version>, payload: bytes::Bytes, - version: Version, ) -> Result<(), Error> { stream.varint(payload.len() as u64).await?; // Draft-14 and 15 still carry a Normal status after an empty object. - if payload.is_empty() && matches!(version, Version::Draft14 | Version::Draft15) { - stream.varint(0).await?; - } if !payload.is_empty() { let mut payload = payload; stream.write_all(&mut payload).await?; @@ -2591,7 +2446,6 @@ impl Publisher { return super::request_stream::reject( stream, ietf::RequestError { - request_id: None, error_code: request::INVALID_FILTER, reason_phrase: "Range Filters exceed MAX_FILTER_RANGES=0".into(), retry_interval: 0, @@ -2606,7 +2460,6 @@ impl Publisher { return self .reject_fetch( stream, - msg.request_id, &Error::Unsupported, "FILL_TIMEOUT not supported", ) @@ -2627,7 +2480,7 @@ impl Publisher { // object plus one. Without one, both include the whole End Group. let Some(object) = end.object.map_or(Some(0), |object| object.checked_add(1)) else { return self - .reject_fetch(stream, msg.request_id, &Error::InvalidRange, "End Object overflows") + .reject_fetch(stream, &Error::InvalidRange, "End Object overflows") .await; }; FetchType::Standalone { @@ -2646,7 +2499,6 @@ impl Publisher { return self .reject_fetch( stream, - msg.request_id, &Error::Unsupported, "FETCH relative to Largest Object not supported", ) @@ -2675,7 +2527,7 @@ impl Publisher { }; if !gate.allows() { return self - .reject_fetch(stream, msg.request_id, &Error::Unauthorized, "not granted") + .reject_fetch(stream, &Error::Unauthorized, "not granted") .await; } @@ -2684,7 +2536,7 @@ impl Publisher { || (start.group == end.group && end.object != 0 && start.object >= end.object) { return self - .reject_fetch(stream, msg.request_id, &Error::InvalidRange, "empty range") + .reject_fetch(stream, &Error::InvalidRange, "empty range") .await; } @@ -2695,11 +2547,11 @@ impl Publisher { .await { Ok(broadcast) => broadcast, - Err(err) => return self.reject_fetch(stream, msg.request_id, &err, &err.to_string()).await, + Err(err) => return self.reject_fetch(stream, &err, &err.to_string()).await, }; let track = match broadcast.track(&track) { Ok(track) => track, - Err(err) => return self.reject_fetch(stream, msg.request_id, &err, &err.to_string()).await, + Err(err) => return self.reject_fetch(stream, &err, &err.to_string()).await, }; // Its own entry in the queue, or its own send group, so it competes with group @@ -2729,7 +2581,7 @@ impl Publisher { let (end, cache, namespace, ranking, token) = match self.joined(&mut stream, subscriber_request_id).await? { Ok(joined) => joined, - Err((err, reason)) => return self.reject_fetch(stream, msg.request_id, &err, reason).await, + Err((err, reason)) => return self.reject_fetch(stream, &err, reason).await, }; // The cache outlives the subscription, so the fetch holds its own gate and ends // with the subscription rather than trusting the cache. One the subscription's @@ -2744,7 +2596,6 @@ impl Publisher { return self .reject_fetch( stream, - msg.request_id, &Error::InvalidRange, "joining group past the subscription", ) @@ -2766,7 +2617,7 @@ impl Publisher { // Rewritten as standalone or refused above. FetchType::Filtered { .. } => { return self - .reject_fetch(stream, msg.request_id, &Error::Unsupported, "not supported") + .reject_fetch(stream, &Error::Unsupported, "not supported") .await; } }; @@ -2777,7 +2628,6 @@ impl Publisher { return self .reject_fetch( stream, - msg.request_id, &Error::Unsupported, "FETCH spanning several groups not supported", ) @@ -2825,21 +2675,19 @@ impl Publisher { }; let mut group = match group { Some(Ok(group)) => group, - Some(Err(err)) => return self.reject_fetch(stream, msg.request_id, &err, &err.to_string()).await, + Some(Err(err)) => return self.reject_fetch(stream, &err, &err.to_string()).await, None => return Ok(()), }; // Only draft-14 and 15 FETCH objects carry a status. Later drafts end the response at // the last frame, which is all a receiver can account for. - if !matches!(self.version, Version::Draft14 | Version::Draft15) { - group.end_object = None; - } - group.end_object = group.end_object.map(|end| status_fields(end, self.version)); + group.end_object = None; + group.end_object = group.end_object.map(|end| status_fields(end)); // FETCH keeps each object's Timestamp, in the units FETCH_OK declares wherever the // draft can declare them. Opting out of the properties strips nothing from the objects. let timescale = group .info .timescale - .filter(|_| ietf::Properties::sends_timescale(self.version)); +; let frames = group .frames .iter() @@ -2848,7 +2696,7 @@ impl Publisher { if let Err(err) = super::object::write(&fields.properties, group.info.ietf(), frame, self.version, timescale) { - return self.reject_fetch(stream, msg.request_id, &err, &err.to_string()).await; + return self.reject_fetch(stream, &err, &err.to_string()).await; } } let properties = match track_properties( @@ -2858,7 +2706,7 @@ impl Publisher { self.peer_setup.get().await.flate, ) { Ok(properties) => properties, - Err(err) => return self.reject_fetch(stream, msg.request_id, &err, &err.to_string()).await, + Err(err) => return self.reject_fetch(stream, &err, &err.to_string()).await, }; let draft20 = Filter::is_draft20(self.version); let end_of_track = !joined && group.complete && track.final_sequence() == group.sequence.checked_add(1); @@ -2885,7 +2733,6 @@ impl Publisher { return self .reject_fetch( stream, - msg.request_id, &Error::InvalidRange, "start past Largest Object", ) @@ -2897,7 +2744,7 @@ impl Publisher { // group has to be here in full or the two leave a gap. if group.end() != end.object { return self - .reject_fetch(stream, msg.request_id, &Error::Evicted, "joining prefix unavailable") + .reject_fetch(stream, &Error::Evicted, "joining prefix unavailable") .await; } (end, false) @@ -2946,15 +2793,6 @@ impl Publisher { stream .writer .encode_message(&ietf::FetchOk { - request_id: match self.version { - Version::Draft14 | Version::Draft15 | Version::Draft16 => Some(msg.request_id), - _ => None, - }, - // Only draft-14 encodes it, and only as the publisher restating the order. - group_order: match msg.group_order { - GroupOrder::Descending => GroupOrder::Descending, - _ => GroupOrder::Ascending, - }, end_of_track, end_location, properties, @@ -2979,7 +2817,7 @@ impl Publisher { for (ordinal, frame) in (group.first..).zip(group.frames) { kio::wait(|waiter| budget.poll_yield(waiter)).await; let object = frame.fields.as_ref().map_or(ordinal, |fields| fields.id); - let position = fetch_prior(self.version, prior, object)?; + let position = fetch_prior(prior, object)?; prior = Some(object); Self::write_fetch_object( &mut writer, @@ -2996,7 +2834,7 @@ impl Publisher { }, ) .await?; - Self::write_fetch_payload(&mut writer, frame.frame.payload, self.version).await?; + Self::write_fetch_payload(&mut writer, frame.frame.payload).await?; } if let Some(end) = group.end_object.as_deref() { Self::write_fetch_object( @@ -3004,7 +2842,7 @@ impl Publisher { FetchObjectInfo { sequence: group.sequence, object: end.id, - prior: fetch_prior(self.version, prior, end.id)?, + prior: fetch_prior(prior, end.id)?, timestamp: None, inflated: None, timescale, @@ -3112,24 +2950,13 @@ impl Publisher { })) => return Ok(Ok((end, cache, namespace, ranking, token))), Ok(None) => ( match self.version { - Version::Draft14 - | Version::Draft15 - | Version::Draft16 - | Version::Draft17 - | Version::Draft18 + Version::Draft18 | Version::Draft19 => Error::InvalidJoiningRequestId, _ => Error::NotFound, }, "no such subscription", ), Ok(Some(Joined::Unsupported)) => { - if matches!(self.version, Version::Draft14 | Version::Draft15 | Version::Draft16) { - self.session.close( - super::error::to_session_code(&crate::SessionError::ProtocolViolation), - "joining FETCH requires Largest Object filter", - ); - return Err(Error::ProtocolViolation); - } (Error::Unsupported, "joining filter not supported") } Ok(Some(Joined::Empty)) => (Error::InvalidRange, "no objects at subscription start"), @@ -3166,10 +2993,8 @@ impl Publisher { if let Some(error) = super::namespace::refusal(&msg.track_namespace, self.version) { return super::request_stream::reject(stream, error).await; } - let request_id = msg.request_id; - if !gate.allows() { - return self.reject_track_status(stream, request_id, &Error::Unauthorized).await; + return self.reject_track_status(stream, &Error::Unauthorized).await; } let broadcast = match gate .guard(async { @@ -3182,12 +3007,12 @@ impl Publisher { .await { Ok(broadcast) => broadcast, - Err(err) => return self.reject_track_status(stream, request_id, &err).await, + Err(err) => return self.reject_track_status(stream, &err).await, }; let track = match broadcast.track(&msg.track_name) { Ok(track) => track, - Err(err) => return self.reject_track_status(stream, request_id, &err).await, + Err(err) => return self.reject_track_status(stream, &err).await, }; // The requester abandoning the request is owed nothing. @@ -3213,7 +3038,7 @@ impl Publisher { let properties = match info.map(|info| track_properties(&info?, msg.properties_wanted, self.version, negotiated)) { Some(Ok(properties)) => properties, - Some(Err(err)) => return self.reject_track_status(stream, request_id, &err).await, + Some(Err(err)) => return self.reject_track_status(stream, &err).await, None => return Ok(()), }; @@ -3221,16 +3046,12 @@ impl Publisher { // when the grant narrows is reset rather than delivered. let respond = async { let ok = ietf::TrackStatusOk { - request_id: match self.version { - Version::Draft14 | Version::Draft15 | Version::Draft16 => Some(request_id), - _ => None, - }, largest: live_edge(&track).largest, properties, }; stream .writer - .buffer_message(ietf::TrackStatusOk::id(self.version), &ok)?; + .buffer_message(ietf::TrackStatusOk::ID, &ok)?; std::future::poll_fn(|cx| stream.writer.poll_flush(cx)).await?; Ok::<(), Error>(()) }; @@ -3258,26 +3079,10 @@ impl Publisher { async fn reject_track_status( &self, mut stream: Stream, - request_id: RequestId, err: &Error, ) -> Result<(), Error> { let (kind, reason) = (request::Kind::TrackStatus, err.to_string()); - super::request_stream::write_error(&mut stream.writer, kind, request_id, err, &reason, self.version).await?; - let _ = stream.writer.close().await; - Ok(()) - } - - /// Refuse a SUBSCRIBE_NAMESPACE or SUBSCRIBE_TRACKS that asks for PUBLISH, which we - /// never send. Both exist only from draft-16, so the reply is always REQUEST_ERROR. - async fn reject_namespace_request( - &self, - mut stream: Stream, - request_id: RequestId, - reason: &str, - ) -> Result<(), Error> { - let kind = request::Kind::SubscribeNamespace; - let err = &Error::Unsupported; - super::request_stream::write_error(&mut stream.writer, kind, request_id, err, reason, self.version).await?; + super::request_stream::write_error(&mut stream.writer, kind, err, &reason, self.version).await?; let _ = stream.writer.close().await; Ok(()) } @@ -3287,12 +3092,11 @@ impl Publisher { async fn reject_fetch( &self, mut stream: Stream, - request_id: RequestId, err: &Error, reason: &str, ) -> Result<(), Error> { let kind = request::Kind::Fetch; - super::request_stream::write_error(&mut stream.writer, kind, request_id, err, reason, self.version).await?; + super::request_stream::write_error(&mut stream.writer, kind, err, reason, self.version).await?; let _ = stream.writer.close().await; Ok(()) } @@ -3347,8 +3151,7 @@ impl Publisher { let restart = renamed || held_auth != auth && (held_auth.is_none() - || auth.is_none() - || matches!(self.version, Version::Draft14 | Version::Draft15)); + || auth.is_none()); // An update already waiting or in flight carries whatever is current once it goes // out, and its answer brings the loop back here for anything after that. @@ -3403,7 +3206,7 @@ impl Publisher { .advertise_namespace(requests, watch, path, suffix.clone(), advert.params(), auth) .await?; if let Some(old) = old { - self.end_request(old.stream, &old.path, old.request_id).await; + end_request(old.stream); } } (true, Some(_)) => { @@ -3421,10 +3224,7 @@ impl Publisher { } } // Register an idle reader too: GOAWAY can arrive without an update in flight. - if !matches!( - self.version, - Version::Draft14 | Version::Draft15 | Version::Draft16 | Version::Draft17 - ) && requests.contains_key(suffix) + if requests.contains_key(suffix) { woken.suffixes.lock().unwrap().push(suffix.clone()); } @@ -3511,7 +3311,7 @@ impl Publisher { tracing::debug!(broadcast = %self.origin.absolute(path), "no stream for the advertisement"); return Ok(Refused::No); }; - let request_id = self.control.next_request_id(&self.runtime).await?; + let request_id = self.control.next_request_id(); let mut messages = super::request_stream::Messages::new(self.session.clone(), self.control.client()); let sent = request @@ -3525,15 +3325,6 @@ impl Publisher { .await; let answer = match sent { Ok(()) => self.read_response(&mut request, &mut messages).await, - // A sequential-ID peer cannot accept any later request when this header failed - // before it learned the allocated ID. - Err(err) if matches!(self.version, Version::Draft14 | Version::Draft15) => { - self.session.clone().close( - super::error::to_session_code(&crate::SessionError::Internal), - "failed to send PUBLISH_NAMESPACE", - ); - return Err(err); - } Err(err) => Err(err), }; @@ -3542,9 +3333,8 @@ impl Publisher { Ok(Answer::Message(framed)) => framed, Ok(Answer::Late) => { tracing::debug!(broadcast = %absolute, "no answer to the advertisement"); - // The peer may hold the request it never answered. Dropping one riding the - // draft-14-16 control stream tells it nothing, so it is withdrawn instead. - self.end_request(request, path, request_id).await; + // The peer may hold the request it never answered, so it is withdrawn. + end_request(request); return Ok(Refused::No); } Ok(Answer::Ended) => { @@ -3560,18 +3350,8 @@ impl Publisher { // `None` when the peer holds the namespace. let refused = (|| { - match (self.version, type_id) { - (Version::Draft14, ietf::PublishNamespaceOk::ID) => { - let msg: ietf::PublishNamespaceOk = body.message(self.version)?; - tracing::debug!(message = ?msg, "publish namespace ok"); - } - (Version::Draft14, ietf::PublishNamespaceError::ID) => { - let msg: ietf::PublishNamespaceError = body.message(self.version)?; - tracing::warn!(message = ?msg, "publish namespace error"); - // Draft-14's error carries no retry interval, so our own backoff stands. - return Ok(Some(Refused::No)); - } - (_, ietf::RequestOk::ID) => { + match type_id { + ietf::RequestOk::ID => { let msg: ietf::RequestOk = body.message(self.version)?; // ACTIVE_COUNT only answers SUBSCRIBE_NAMESPACE (MoQ Active Count). if msg.active.is_some() { @@ -3579,7 +3359,7 @@ impl Publisher { } tracing::debug!(message = ?msg, "publish namespace ok"); } - (_, ietf::RequestError::ID) => { + ietf::RequestError::ID => { let msg: ietf::RequestError = body.message(self.version)?; tracing::warn!(message = ?msg, "publish namespace error"); return Ok(Some(self.refusal(msg.retry_interval))); @@ -3598,7 +3378,6 @@ impl Publisher { NamespaceRequest { messages, path: path.clone(), - request_id, stream: request, auth, queued: false, @@ -3697,7 +3476,6 @@ impl Publisher { (Some(next), Some(held)) => ietf::PublishNamespaceUpdate::between(request_id, &held, &next), _ => ietf::PublishNamespaceUpdate { request_id, - namespace_request_id: (self.version == Version::Draft16).then_some(request.request_id), hops: None, cost: None, authorization_token: None, @@ -3740,7 +3518,6 @@ impl Publisher { inflight: &mut VecDeque<(crate::time::Instant, crate::PathOwned)>, woken: &Arc, now: crate::time::Instant, - version: Version, cx: &mut std::task::Context<'_>, ) -> Poll<(crate::PathOwned, Result)> { // Registered before the take, so a wake landing between them is not lost. @@ -3750,13 +3527,6 @@ impl Publisher { let Some(request) = requests.get_mut(&suffix) else { continue; }; - if request.pending.is_none() - && matches!( - version, - Version::Draft14 | Version::Draft15 | Version::Draft16 | Version::Draft17 - ) { - continue; - } let waker = request.waker.get_or_insert_with(|| woken.waker(suffix.clone())).clone(); if let Poll::Ready(answer) = request .messages @@ -3821,10 +3591,6 @@ impl Publisher { match self.version { // Dropping a request riding the control stream tells the peer nothing, so // it would hold the namespace beside the one advertised next. - Version::Draft16 => { - self.withdraw_namespace(&mut ns.target, &mut ns.requests, suffix.clone()) - .await? - } // Abrupt: a peer that never answers is not owed the FIN handshake. _ => { ns.requests.remove(&suffix); @@ -3868,29 +3634,11 @@ impl Publisher { ietf::RequestError::ID => { let msg: ietf::RequestError = body.message(self.version)?; tracing::warn!(message = ?msg, "publish_namespace update error"); - match self.version { - // The peer follows its refusal with PUBLISH_NAMESPACE_CANCEL, and draft - // 16 sends no PUBLISH_NAMESPACE_DONE after a cancel. - Version::Draft16 => { - ns.requests.remove(&suffix); - } - // The peer closed its side; closing ours completes the withdrawal. - _ => { - self.withdraw_namespace(&mut ns.target, &mut ns.requests, suffix.clone()) - .await? - } - } + // The peer closed its side; closing ours completes the withdrawal. + self.withdraw_namespace(&mut ns.target, &mut ns.requests, suffix.clone()) + .await?; self.refusal(msg.retry_interval) } - // Draft-16 carries its cancel as a message, which can beat the answer. - ietf::PublishNamespaceCancel::ID if self.version == Version::Draft16 => { - let msg: ietf::PublishNamespaceCancel = body.message(self.version)?; - tracing::debug!(broadcast = %absolute, message = ?msg, "update cancelled"); - // The peer already let it go, and draft 16 sends no - // PUBLISH_NAMESPACE_DONE after a cancel. - ns.requests.remove(&suffix); - Refused::No - } _ => return Err(Error::UnexpectedMessage), } } @@ -3906,15 +3654,13 @@ impl Publisher { /// How to read a refusal's retry interval, in milliseconds. /// - /// Draft-14/15 errors carry no interval, so a decoded 0 there says nothing and our own - /// backoff stands. Everywhere else 0 is the peer asking not to be offered this again, - /// which is what keeps a permanent refusal (unauthorized, uninterested) from becoming - /// a request every few seconds for the life of the session. + /// 0 is the peer asking not to be offered this again, which is what keeps a permanent + /// refusal (unauthorized, uninterested) from becoming a request every few seconds for + /// the life of the session. fn refusal(&self, retry_interval: u64) -> Refused { - match (self.version, retry_interval) { - (Version::Draft14 | Version::Draft15, _) => Refused::No, - (_, 0) => Refused::Never, - (_, ms) => Refused::Until(self.runtime.now() + Duration::from_millis(ms)), + match retry_interval { + 0 => Refused::Never, + ms => Refused::Until(self.runtime.now() + Duration::from_millis(ms)), } } @@ -3941,11 +3687,7 @@ impl Publisher { kio::wait(|waiter| { if let Poll::Ready(res) = waiter.poll_future(open.as_mut()) { return Poll::Ready(match res { - Ok(stream) => Ok(Some(super::request_stream::with_stats( - stream, - self.origin.stats(), - self.version, - ))), + Ok(stream) => Ok(Some(stream.with_stats(self.origin.stats()))), Err(Error::NoStreamCredit) => Ok(None), Err(err) => Err(err), }); @@ -3996,8 +3738,7 @@ impl Publisher { match target { Target::Requests(_) => { if let Some(request) = requests.remove(&suffix) { - self.end_request(request.stream, &request.path, request.request_id) - .await; + end_request(request.stream); } } Target::Inline(stream) => { @@ -4012,34 +3753,6 @@ impl Publisher { Ok(()) } - /// Withdraw one PUBLISH_NAMESPACE request, best effort: the peer may already be gone. - async fn end_request( - &self, - mut stream: Stream, - path: &crate::PathOwned, - request_id: RequestId, - ) { - // Draft-17+ withdraws by cancelling the request in both directions; a FIN is only - // allowed to end SUBSCRIBE_NAMESPACE and SUBSCRIBE_TRACKS. - if !matches!(self.version, Version::Draft14 | Version::Draft15 | Version::Draft16) { - stream.reader.abort(&Error::Cancel); - stream.writer.abort(&Error::Cancel); - return; - } - - let _ = stream - .writer - .encode_message(&ietf::PublishNamespaceDone { - track_namespace: path.as_path(), - request_id, - }) - .await; - - // The withdrawal rides this request's own stream, which drops with it, so it needs - // the acknowledgement before the drop-time reset can discard it. - let _ = stream.writer.close().await; - } - /// Close out every open PUBLISH_NAMESPACE request. A no-op for a loop whose entries /// ride the SUBSCRIBE_NAMESPACE stream itself, which retracts them by ending. async fn withdraw_requests(&self, target: &mut Target, requests: &mut HashMap) { @@ -4146,21 +3859,8 @@ impl Publisher { // origin that already opted in (the caller's choice for this peer) keeps them. let origin = origin.discovery(!declared.hidden || msg.hidden || self.origin.includes_hidden()); - // Draft-16 and later always fill this stream. A NAMESPACE is discovery, not a - // route, so a peer that also hears the unsolicited PUBLISH_NAMESPACE still gets - // the match here. Draft-14 and 15 answer with PUBLISH_NAMESPACE and only say - // what that loop does not already say: everything when the peer asked to be - // told on request, otherwise the hidden remainder. - let origin = if matches!(self.version, Version::Draft14 | Version::Draft15) { - match declared.solicit.unwrap_or(false) { - true => origin, - false if !declared.hidden || self.origin.includes_hidden() => origin.empty(), - false => origin.beyond(&self.origin.clone().discovery(false)), - } - } else { - origin - }; - + // A NAMESPACE is discovery, not a route, so a peer that also hears the unsolicited + // PUBLISH_NAMESPACE still gets the match here. let mut announced = origin.announced(); // MoQ Active Count: take what is advertised now, so the OK can say how many @@ -4184,43 +3884,17 @@ impl Publisher { }; // Send OK response - match self.version { - Version::Draft14 => { - stream - .writer - .encode_message(&ietf::SubscribeNamespaceOk { - request_id: msg.request_id, - }) - .await?; - } - Version::Draft15 | Version::Draft16 => { - stream - .writer - .encode_message(&ietf::RequestOk { - largest: None, - request_id: Some(msg.request_id), - active, - }) - .await?; - } - _ => { - stream - .writer - .encode_message(&ietf::RequestOk { - largest: None, - request_id: None, - active, - }) - .await?; - } - } + stream + .writer + .encode_message(&ietf::RequestOk { + largest: None, + active, + }) + .await?; // Draft-14/15 predate NAMESPACE, so they answer with their own PUBLISH_NAMESPACE // requests and keep this stream open for the subscription's lifetime. - let target = match self.version { - Version::Draft14 | Version::Draft15 => Target::Requests(Some(stream)), - _ => Target::Inline(stream), - }; + let target = Target::Inline(stream); let mut ns = Namespaces::new(peer, target); ns.gate = Some(gate); @@ -4350,18 +4024,15 @@ impl Publisher { // once and none holds up the announcements behind it. let now = self.runtime.now(); if let Poll::Ready((suffix, answer)) = - Self::poll_answer(requests, inflight, woken, now, self.version, &mut cx) + Self::poll_answer(requests, inflight, woken, now, &mut cx) { return Poll::Ready(NamespaceEvent::Answered(suffix, answer)); } // The front is now the earliest update still waiting. answer_by.set(inflight.front().map(|(deadline, _)| *deadline)); let _ = answer_by.poll(waiter); - // Credit goes to queued updates in order, as the drafts before 17 require. - if !updates.is_empty() - && let Poll::Ready(id) = self.control.poll_next_request_id(waiter) - { - return Poll::Ready(NamespaceEvent::Renew(id)); + if !updates.is_empty() { + return Poll::Ready(NamespaceEvent::Renew(self.control.next_request_id())); } if let Poll::Ready(next) = announced.poll_next(waiter) { return Poll::Ready(NamespaceEvent::Update(next.map(|event| match event { @@ -4399,7 +4070,6 @@ impl Publisher { let refusal = update .refused .map(|error| ietf::RequestError { - request_id: None, error_code: request::to_code(&error, request::Kind::SubscribeNamespace, self.version), reason_phrase: "namespace update refused".into(), retry_interval: 0, @@ -4448,7 +4118,6 @@ impl Publisher { .writer .encode_message(&ietf::RequestOk { largest: None, - request_id: None, active: None, }) .await?; @@ -4622,7 +4291,7 @@ impl TrackServe { // A Timestamp whose units were not declared is worse than none. Drafts 14-16 // never write TIMESCALE, whatever the caller passed in, so datagrams and group // objects on those drafts go out unstamped. - let timescale = timescale.filter(|_| ietf::Properties::sends_timescale(version)); + let timescale = timescale; let dynamic = track.info().refresh.is_some(); let priority = kio::Producer::new(track.subscription().priority); let publisher = track.info().priority; @@ -4659,7 +4328,7 @@ impl TrackServe { } fn compression(mut self, negotiated: bool) -> Self { - self.compression = negotiated && super::flate::supported(self.version) && self.track.info().compress; + self.compression = negotiated && self.track.info().compress; self } @@ -4898,7 +4567,7 @@ impl TrackServe { // is best-effort, and the track's groups do not depend on it. if wire .status - .is_some_and(|status| !super::object::status_defined(status, self.version)) + .is_some_and(|status| !super::object::status_defined(status)) { tracing::debug!(sequence, "dropping a datagram status this draft cannot carry"); continue; @@ -4908,7 +4577,7 @@ impl TrackServe { let stripped = Default::default(); let forwarded = match wire .status - .is_some_and(|status| !super::datagram::carries_properties(status, self.version)) + .is_some_and(|status| status != 0) { true => &stripped, false => &wire.properties, @@ -4926,11 +4595,7 @@ impl TrackServe { continue; } }; - let object = if self.version == Version::Draft14 && wire.status.is_some() { - Some(wire.object_id.unwrap_or(0)) - } else { - wire.object_id - }; + let object = wire.object_id; // An omitted priority inherited the source track's default, which this // response may not carry (or carry the same), so resolve it here. let priority = wire @@ -4952,7 +4617,6 @@ impl TrackServe { &mut Encoder::new(&mut properties, self.version.into()), timestamp, timescale, - self.version, )?; } ( @@ -5535,7 +5199,7 @@ impl GroupServe { Poll::Ready(Ok(None)) => { if !self.ended && let Some(end) = - self.group.end_object().map(|end| status_fields(end, self.version)) + self.group.end_object().map(|end| status_fields(end)) && end.id >= self.slice.skip && self .slice .until @@ -5668,12 +5332,17 @@ fn object_delta(prior: Option, id: u64) -> Result { } } -/// A status object's fields, without properties where its draft forbids them. -fn status_fields( - end: std::sync::Arc, - version: Version, -) -> std::sync::Arc { - match super::object::status_has_properties(version) || end.properties.is_empty() { +/// Withdraw one PUBLISH_NAMESPACE request by cancelling it in both directions, best effort: +/// the peer may already be gone. A FIN is only allowed to end SUBSCRIBE_NAMESPACE and +/// SUBSCRIBE_TRACKS. +fn end_request(mut stream: Stream) { + stream.reader.abort(&Error::Cancel); + stream.writer.abort(&Error::Cancel); +} + +/// A status object's fields, without properties, which it may not carry. +fn status_fields(end: std::sync::Arc) -> std::sync::Arc { + match end.properties.is_empty() { true => end, false => std::sync::Arc::new(crate::model::object::Fields { id: end.id, @@ -5705,7 +5374,6 @@ fn buffer_object( &mut Encoder::new(&mut ext, encoding.version.into()), timestamp, timescale, - encoding.version, )?; } ext @@ -5722,11 +5390,9 @@ fn buffer_object( Ok(()) } -/// One draft-14/15 advertisement: the PUBLISH_NAMESPACE request it rode on and -/// what closes it out with PUBLISH_NAMESPACE_DONE. +/// One advertisement: the PUBLISH_NAMESPACE request stream it rides on. struct NamespaceRequest { path: crate::PathOwned, - request_id: RequestId, stream: Stream, messages: super::request_stream::Messages, /// The auth the peer holds the request under: the one it opened with, or the one @@ -5839,10 +5505,6 @@ mod group_priority_test { async fn exact_end_of_track_survives_the_final_group_fin() { use crate::lite::test_transport::Sent; for version in [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft20, @@ -6026,7 +5688,6 @@ mod group_priority_test { rank_in(&queue, priority, subscribe), group.consume(), Some(Timescale::MILLI), - Version::Draft14, GroupSlice::default(), ) }); @@ -6072,7 +5733,7 @@ mod group_priority_test { /// carries no Timestamp. Draft-17 declares the units and stamps the object. #[moq_clock::test] async fn drafts_14_through_16_send_no_timestamp_without_timescale() { - for version in [Version::Draft14, Version::Draft15, Version::Draft16, Version::Draft17] { + for version in [Version::Draft15] { let stamped = ietf::Properties::sends_timescale(version); let (header, mut buf) = serve_group(version, Some(Timescale::MILLI)).await; assert_eq!(header.flags.has_extensions, stamped, "{version}"); @@ -6178,7 +5839,6 @@ mod group_priority_test { crate::driver::Transport::new(session.clone()), subscriber, RequestId(0), - Version::Draft14, ServeRange::default(), None, ); @@ -6228,7 +5888,6 @@ mod group_priority_test { crate::driver::Transport::new(session.clone()), subscriber, RequestId(0), - Version::Draft14, ServeRange::default(), None, ); @@ -6284,7 +5943,6 @@ mod group_priority_test { crate::driver::Transport::new(session.clone()), subscriber, RequestId(0), - Version::Draft14, ServeRange::default(), None, ); @@ -6332,7 +5990,6 @@ mod group_priority_test { crate::driver::Transport::new(session.clone()), subscriber, RequestId(0), - Version::Draft14, ServeRange::default(), None, ); @@ -6399,7 +6056,6 @@ mod group_priority_test { crate::driver::Transport::new(session.clone()), subscriber, RequestId(0), - Version::Draft14, ServeRange::default(), Some(Timescale::MILLI), ); @@ -6407,7 +6063,7 @@ mod group_priority_test { let written = log.writes.lock().unwrap().clone(); let mut buf = bytes::Bytes::from(written); - crate::coding::decode_buf(&mut buf, Version::Draft14, ietf::GroupHeader::decode).expect("a group header") + crate::coding::decode_buf(&mut buf, ietf::GroupHeader::decode).expect("a group header") } /// `hang::catalog::PRIORITY` isn't reachable from `moq-net` (hang depends on it, not the @@ -6827,7 +6483,6 @@ mod subscribe_cursor_test { crate::driver::Transport::new(session.clone()), subscriber, RequestId(1), - Version::Draft14, ServeRange::default(), Some(Timescale::MILLI), ); @@ -6858,7 +6513,6 @@ mod serve_tests { suffix.clone(), NamespaceRequest { path: suffix.clone(), - request_id: RequestId(0), stream, messages: super::super::request_stream::Messages::new( crate::driver::Transport::new(session.clone()), @@ -6876,13 +6530,13 @@ mod serve_tests { let runtime = crate::time::sim(); let mut cx = std::task::Context::from_waker(std::task::Waker::noop()); assert!( - Publisher::poll_answer(&mut requests, &mut inflight, &woken, runtime.now(), version, &mut cx).is_pending() + Publisher::poll_answer(&mut requests, &mut inflight, &woken, runtime.now(), &mut cx).is_pending() ); assert!(session.log.closes().is_empty()); session.push(&[0x10, 0, 2, 0, 0]); woken.suffixes.lock().unwrap().push(suffix); assert!(matches!( - Publisher::poll_answer(&mut requests, &mut inflight, &woken, runtime.now(), version, &mut cx), + Publisher::poll_answer(&mut requests, &mut inflight, &woken, runtime.now(), &mut cx), Poll::Ready((_, Err(Error::ProtocolViolation))) )); assert_eq!(session.log.closes()[0].0, 0x03); @@ -7050,7 +6704,6 @@ mod serve_tests { #[moq_clock::test] async fn requester_fin_is_version_gated_for_subscriptions() { for version in [ - Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft20, @@ -7102,10 +6755,6 @@ mod serve_tests { #[moq_clock::test] async fn requester_reset_cancels_subscriptions() { for version in [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft20, @@ -7141,7 +6790,7 @@ mod serve_tests { /// when a dispatched task is cancelled or its message is refused. #[moq_clock::test] async fn drain_counts_dispatched_subscribe_and_fetch() { - for version in [Version::Draft14, Version::Draft19, Version::Draft20] { + for version in [Version::Draft19, Version::Draft20] { let h = serve(version); let mut subscribe_body = Vec::new(); subscribe(Filter::NextObject, None) @@ -7462,7 +7111,7 @@ mod serve_tests { let wire = Wire::read(&h.log, version); let (status, _) = wire.publish_done.expect("PUBLISH_DONE was sent"); - assert_eq!(status, ietf::PublishDoneStatus::InternalError.code(version)); + assert_eq!(status, ietf::PublishDoneStatus::InternalError.code()); assert_eq!(wire.data.len(), 2, "a group stream and a fill stream"); wire.assert_streams_closed_before_publish_done(); drop(group); @@ -7497,7 +7146,7 @@ mod serve_tests { let wire = Wire::read(&h.log, version); let (status, count) = wire.publish_done.expect("PUBLISH_DONE was sent"); - assert_eq!(status, ietf::PublishDoneStatus::TrackEnded.code(version)); + assert_eq!(status, ietf::PublishDoneStatus::TrackEnded.code()); assert_eq!(wire.data.len(), 3, "a fill, a group and an END_OF_TRACK stream"); assert_eq!(count, 3); wire.assert_streams_closed_before_publish_done(); @@ -7577,7 +7226,7 @@ mod serve_tests { assert_eq!(h.log.resets(), vec![crate::StreamError::Cancel.to_code()]); let wire = Wire::read(&h.log, version); let (status, _) = wire.publish_done.expect("PUBLISH_DONE was sent"); - assert_eq!(status, ietf::PublishDoneStatus::TrackEnded.code(version)); + assert_eq!(status, ietf::PublishDoneStatus::TrackEnded.code()); wire.assert_streams_closed_before_publish_done(); } @@ -7687,7 +7336,7 @@ mod serve_tests { let done = wire.sent(ietf::PublishDone::ID).expect("PUBLISH_DONE was sent"); assert!(error.end() < done.start(), "REQUEST_ERROR precedes PUBLISH_DONE"); let (status, _) = wire.publish_done.unwrap(); - assert_eq!(status, ietf::PublishDoneStatus::UpdateFailed.code(version)); + assert_eq!(status, ietf::PublishDoneStatus::UpdateFailed.code()); assert_eq!(wire.data.len(), 2, "a group stream and a fill stream"); wire } @@ -7719,27 +7368,7 @@ mod serve_tests { fn legacy_update(version: Version, priority: u8, forward: bool) -> Vec { const UPDATE_ID: u8 = 10; let body = match version { - Version::Draft14 => { - let mut body = Vec::new(); - ietf::SubscribeUpdate { - max_age: None, - new_group: None, - request_id: RequestId(UPDATE_ID.into()), - subscription_request_id: Some(RequestId(0)), - start_location: Location { group: 0, object: 0 }, - end_group: 0, - subscriber_priority: Some(priority), - forward: Some(forward), - filter: None, - authorization_token: None, - fill: None, - } - .encode_msg(&mut Encoder::new(&mut body, version.into()), version) - .unwrap(); - body - } // Draft 16 delta-encodes keys: SUBSCRIBER_PRIORITY (0x20) follows FORWARD (0x10). - Version::Draft16 => vec![UPDATE_ID, 0, 2, 0x10, forward as u8, 0x10, priority], _ => vec![UPDATE_ID, 0, 2, 0x10, forward as u8, 0x20, priority], }; let mut frame = vec![ietf::SubscribeUpdate::ID as u8, 0, body.len() as u8]; @@ -7752,7 +7381,7 @@ mod serve_tests { /// UNSUBSCRIBE ends it. #[moq_clock::test] async fn legacy_subscription_update_keeps_the_subscription() { - for version in [Version::Draft14, Version::Draft15, Version::Draft16] { + for version in [Version::Draft15] { let h = serve(version); let session = ScriptedSession::new(legacy_update(version, 10, true)); let mut stream = Stream::open(&mut crate::driver::Transport::new(session.clone()), version) @@ -7784,7 +7413,7 @@ mod serve_tests { // Drafts 15 and 16 answer with REQUEST_OK naming the update; draft 14 answers nothing. let answered = occurrences(&session.log, &[ietf::RequestOk::ID as u8, 0, 2, 10, 0]); - assert_eq!(answered, usize::from(version != Version::Draft14), "{version}"); + assert_eq!(answered, usize::from(true), "{version}"); let mut unsubscribe = vec![ietf::Unsubscribe::ID as u8]; ietf::Unsubscribe { @@ -7804,7 +7433,7 @@ mod serve_tests { /// the update on drafts 15 and 16, to the caller once it stopped forwarding. #[moq_clock::test] async fn a_legacy_update_pauses_the_subscription() { - for version in [Version::Draft14, Version::Draft15, Version::Draft16] { + for version in [Version::Draft15] { let h = serve(version); let session = ScriptedSession::new(legacy_update(version, 10, false)); let mut stream = Stream::open(&mut crate::driver::Transport::new(session.clone()), version) @@ -7828,7 +7457,7 @@ mod serve_tests { .run_subscription(&mut stream, &mut serving, &mut finished, &mut goaways, async {}, None) .await; assert!( - matches!(served, Some(Served::Paused(Some(RequestId(10))))), + matches!(served, Some(Served::Paused(true))), "{version}: {served:?}" ); let written = session.log.writes.lock().unwrap().clone(); @@ -7844,10 +7473,6 @@ mod serve_tests { max_age: None, new_group: None, request_id: RequestId(id), - subscription_request_id: matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) - .then_some(RequestId(REQUEST_ID)), - start_location: Location { group: 0, object: 0 }, - end_group: 0, subscriber_priority: None, forward: Some(forward), filter: None, @@ -7865,7 +7490,7 @@ mod serve_tests { /// established; FORWARD=1 subscribes again as a new SUBSCRIBE would, at the live edge. #[moq_clock::test] async fn a_subscribe_pauses_and_resumes_as_a_new_subscriber() { - for version in [Version::Draft16, Version::Draft22] { + for version in [Version::Draft22] { for start_paused in [false, true] { let h = serve(version); let mut request = ScriptedSession::new(Vec::new()); @@ -7959,7 +7584,7 @@ mod serve_tests { /// PUBLISH_DONE says UPDATE_FAILED. #[moq_clock::test] async fn a_failed_resume_answers_its_update() { - for version in [Version::Draft16, Version::Draft22] { + for version in [Version::Draft22] { let h = serve(version); let mut request = ScriptedSession::new(Vec::new()); request.log = h.log.clone(); @@ -7986,7 +7611,7 @@ mod serve_tests { assert!(done.start() > error.end(), "{version}: {:?}", wire.messages); assert_eq!( wire.publish_done.map(|(status, _)| status), - Some(ietf::PublishDoneStatus::UpdateFailed.code(version)), + Some(ietf::PublishDoneStatus::UpdateFailed.code()), "{version}" ); } @@ -8000,9 +7625,6 @@ mod serve_tests { max_age: None, new_group: Some(value), request_id: RequestId(id), - subscription_request_id: matches!(version, Version::Draft15 | Version::Draft16).then_some(RequestId(0)), - start_location: Location { group: 0, object: 0 }, - end_group: 0, subscriber_priority: None, forward: None, filter: None, @@ -8046,7 +7668,7 @@ mod serve_tests { /// wants the group past one over its ratio, and SUBSCRIBE_OK advertises DYNAMIC_GROUPS. #[moq_clock::test] async fn a_subscribe_joins_under_the_refresh_ratio() { - for version in [Version::Draft15, Version::Draft16, Version::Draft22] { + for version in [Version::Draft22] { for refresh in [Some(1), None] { let h = serve_track(version, crate::track::Info::timed().with_refresh(refresh)); let _group = refresh_group(&h); @@ -8124,7 +7746,7 @@ mod serve_tests { /// REQUEST_OK. One naming a group the track holds asks nothing. #[moq_clock::test] async fn a_new_group_update_joins_a_refreshing_track() { - for version in [Version::Draft15, Version::Draft16, Version::Draft22] { + for version in [Version::Draft22] { for (value, wanted) in [(0, 5), (5, 5), (4, 0)] { let h = serve_track(version, crate::track::Info::timed().with_refresh(1)); let session = ScriptedSession::new(new_group_update(version, 10, value)); @@ -8160,9 +7782,6 @@ mod serve_tests { // Draft 16 names the update it answers; later drafts answer on its own stream. let written = session.log.writes.lock().unwrap().clone(); assert_eq!(written[0], ietf::RequestOk::ID as u8, "{version}: {written:?}"); - if version == Version::Draft16 { - assert_eq!(written[3], 10, "{version}: {written:?}"); - } } } } @@ -8171,7 +7790,7 @@ mod serve_tests { /// subscription like any update it cannot apply. #[moq_clock::test] async fn a_new_group_update_without_refresh_fails() { - for version in [Version::Draft15, Version::Draft16, Version::Draft22] { + for version in [Version::Draft22] { let h = serve(version); let session = ScriptedSession::new(new_group_update(version, 10, 9)); let mut stream = Stream::open(&mut crate::driver::Transport::new(session.clone()), version) @@ -8205,30 +7824,8 @@ mod serve_tests { /// the subscription's stream. fn update_with_tokens(version: Version, tokens: &[&[u8]]) -> Vec { let mut body = match version { - Version::Draft14 => { - let mut body = Vec::new(); - ietf::SubscribeUpdate { - max_age: None, - new_group: None, - request_id: RequestId(2), - subscription_request_id: Some(RequestId(0)), - start_location: Location { group: 0, object: 0 }, - end_group: 0, - subscriber_priority: Some(10), - forward: Some(true), - filter: None, - authorization_token: None, - fill: None, - } - .encode_msg(&mut Encoder::new(&mut body, version.into()), version) - .unwrap(); - // Replace the empty parameter block with the token. - assert_eq!(body.pop(), Some(0)); - body - } // Then the request it updates, through draft 16. Every parameter but the token is // left as it is. - Version::Draft15 | Version::Draft16 => vec![2, 0], _ => vec![2], }; body.extend(token_params(version, tokens)); @@ -8241,7 +7838,7 @@ mod serve_tests { /// the draft's code, as it would on the SUBSCRIBE, not only the subscription. #[moq_clock::test] async fn an_update_token_that_cannot_be_used_closes_the_session() { - for version in [Version::Draft14, Version::Draft22] { + for version in [Version::Draft22] { for (token, expected, why) in [ ( &[0x01, 0x07, 0x00][..], @@ -8297,7 +7894,7 @@ mod serve_tests { fn token_params(version: Version, tokens: &[&[u8]]) -> Vec { let mut params = vec![tokens.len() as u8]; for (i, token) in tokens.iter().enumerate() { - let delta = i > 0 && !matches!(version, Version::Draft14 | Version::Draft15); + let delta = i > 0; params.extend([if delta { 0 } else { 0x03 }, token.len() as u8]); params.extend(*token); } @@ -8455,7 +8052,7 @@ mod serve_tests { /// A source track failing to decode ends only the subscriptions it feeds, not the requester's session. #[moq_clock::test] async fn source_decode_failure_keeps_the_session() { - for version in [Version::Draft16, Version::Draft19, Version::Draft22] { + for version in [Version::Draft19, Version::Draft22] { let h = serve(version); let session = ScriptedSession::new(Vec::new()); let mut stream = Stream::open(&mut crate::driver::Transport::new(session.clone()), version) @@ -8631,7 +8228,7 @@ mod serve_tests { #[moq_clock::test] async fn namespace_requester_fin_is_version_gated() { - for version in [Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft22] { + for version in [Version::Draft18, Version::Draft19, Version::Draft22] { let h = serve(version); moq_clock::sim::yield_now().await; let session = ScriptedSession::per_stream_eof(vec![vec![]]); @@ -8715,18 +8312,11 @@ mod serve_tests { #[moq_clock::test] async fn a_missing_broadcast_is_refused_with_the_draft_s_code() { for version in [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft20, ] { - let error_code = match version { - Version::Draft14 => 0x4, - _ => 0x10, - }; + let error_code = 0x10; let h = serve(version); let session = h.session.clone(); @@ -8746,34 +8336,15 @@ mod serve_tests { version, ); - match version { - Version::Draft14 => { - writer.varint(ietf::SubscribeError::ID).await.unwrap(); - writer - .encode(&ietf::SubscribeError { - request_id: RequestId(REQUEST_ID), - error_code, - reason_phrase: Error::Unroutable.to_string().into(), - }) - .await - .unwrap(); - } - _ => { - writer.varint(ietf::RequestError::ID).await.unwrap(); - writer - .encode(&ietf::RequestError { - request_id: match version { - Version::Draft15 | Version::Draft16 => Some(RequestId(REQUEST_ID)), - _ => None, - }, - error_code, - reason_phrase: Error::Unroutable.to_string().into(), - retry_interval: 0, - }) - .await - .unwrap(); - } - } + writer.varint(ietf::RequestError::ID).await.unwrap(); + writer + .encode(&ietf::RequestError { + error_code, + reason_phrase: Error::Unroutable.to_string().into(), + retry_interval: 0, + }) + .await + .unwrap(); log.writes.lock().unwrap().clone() }; @@ -8796,7 +8367,6 @@ mod serve_tests { writer.varint(ietf::RequestError::ID).await.unwrap(); writer .encode(&ietf::RequestError { - request_id: None, error_code: 0x10, reason_phrase: Error::Unroutable.to_string().into(), retry_interval: 0, @@ -8855,7 +8425,7 @@ mod serve_tests { /// refuses them as gone instead of serving another instance's content. #[moq_clock::test] async fn a_request_for_another_instance_is_refused() { - for version in [Version::Draft17, Version::Draft20, Version::Draft22] { + for version in [Version::Draft20, Version::Draft22] { let served = crate::Epoch::mint(); let stale = crate::Epoch::mint(); let pinned = crate::origin::Route::default().with_epoch(served.clone()); @@ -8897,7 +8467,7 @@ mod serve_tests { /// wait: an instance never comes back, so there is nothing to rendezvous with. #[moq_clock::test] async fn a_pinned_request_never_waits_for_its_instance() { - for version in [Version::Draft17, Version::Draft20, Version::Draft22] { + for version in [Version::Draft20, Version::Draft22] { let stale = crate::Epoch::mint(); let pinned = crate::origin::Route::default().with_epoch(crate::Epoch::mint()); for (name, route) in [("another epoch", pinned), ("no epoch", crate::origin::Route::default())] { @@ -8910,9 +8480,6 @@ mod serve_tests { let encode = |body: &mut Vec| -> Result<(), crate::coding::EncodeError> { let w = &mut Encoder::new(body, version.into()); RequestId(REQUEST_ID).encode(w, version)?; - if version == Version::Draft17 { - w.varint(0)?; // required_request_id_delta - } super::super::namespace::encode_namespace(w, &crate::Path::new("room"))?; w.string("video")?; encode_params!(w, version, @@ -8946,7 +8513,7 @@ mod serve_tests { /// cannot have learned an instance it was never told about. #[moq_clock::test] async fn an_epoch_without_the_extension_is_a_violation() { - for version in [Version::Draft17, Version::Draft22] { + for version in [Version::Draft22] { let h = serve(version); for (id, body) in pinned_requests(version, &crate::Epoch::mint()) { let stream = Stream::open(&mut crate::driver::Transport::new(h.session.clone()), version) @@ -8965,10 +8532,6 @@ mod serve_tests { } const ALL_VERSIONS: [Version; 9] = [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft20, @@ -9022,17 +8585,12 @@ mod serve_tests { let wire = h.log.writes.lock().unwrap()[mark..].to_vec(); let mut buf = Decoder::new(&wire, version.into()); - assert_eq!(buf.varint().unwrap(), ietf::TrackStatusOk::id(version), "{version}"); + assert_eq!(buf.varint().unwrap(), ietf::TrackStatusOk::ID, "{version}"); let ok = ietf::TrackStatusOk::decode(&mut buf, version).unwrap(); assert!(buf.is_empty(), "{version}: trailing bytes"); let expected = match version { // GROUP_ORDER is a field on draft-14 and a parameter on draft-15. - Version::Draft14 | Version::Draft15 => ietf::Properties { - group_order: Some(GroupOrder::Descending), - ..Default::default() - }, - Version::Draft16 | Version::Draft17 => ietf::Properties::default(), // Only draft-20 can carry the opt-out. _ if !wanted && Filter::is_draft20(version) => ietf::Properties::default(), _ => track_properties(&track::Info::timed(), true, version, true).unwrap(), @@ -9040,8 +8598,6 @@ mod serve_tests { assert_eq!( ok, ietf::TrackStatusOk { - request_id: matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) - .then_some(RequestId(REQUEST_ID)), largest: Some(Location { group: 4, object: 1 }), properties: expected, }, @@ -9134,7 +8690,7 @@ mod serve_tests { subscribe: Default::default(), expires: None, }; - for version in [Version::Draft14, Version::Draft22] { + for version in [Version::Draft22] { let mut h = serve(version); let auth = crate::auth::Link::new(false); auth.handle().authorize(¬hing); @@ -9249,10 +8805,7 @@ mod serve_tests { let mut buf = Decoder::new(wire, version.into()); let id = buf.varint().unwrap(); match version { - Version::Draft14 if id == ietf::TRACK_STATUS_ERROR_14 => { - Some(ietf::SubscribeError::decode(&mut buf, version).unwrap().error_code) - } - _ if version != Version::Draft14 && id == ietf::RequestError::ID => { + _ if id == ietf::RequestError::ID => { Some(ietf::RequestError::decode(&mut buf, version).unwrap().error_code) } _ => None, @@ -9264,10 +8817,7 @@ mod serve_tests { async fn track_status_for_a_missing_broadcast_is_refused() { for version in ALL_VERSIONS { let code = refusal(version, ietf::TrackStatus::ID, track_status("absent", true, version)).await; - let expected = match version { - Version::Draft14 => 0x4, - _ => 0x10, - }; + let expected = 0x10; assert_eq!(code, expected, "{version}"); } } @@ -9283,7 +8833,6 @@ mod serve_tests { &mut Encoder::new(&mut properties, version.into()), stamp, track::Info::timed().timescale.expect("a timed track"), - version, ) .unwrap(); @@ -9321,17 +8870,8 @@ mod serve_tests { let wire = h.log.writes.lock().unwrap()[mark..].to_vec(); let mut buf = Decoder::new(&wire, version.into()); - match version { - Version::Draft14 => { - // SUBSCRIBE_ERROR and FETCH_ERROR share their layout. - let _id = buf.varint().unwrap(); - ietf::SubscribeError::decode(&mut buf, version).unwrap().error_code - } - _ => { - assert_eq!(buf.varint().unwrap(), ietf::RequestError::ID); - ietf::RequestError::decode(&mut buf, version).unwrap().error_code - } - } + assert_eq!(buf.varint().unwrap(), ietf::RequestError::ID); + ietf::RequestError::decode(&mut buf, version).unwrap().error_code } #[moq_clock::test] @@ -9591,7 +9131,7 @@ mod serve_tests { assert_eq!(err.error_code, 0x3, "{label}: NOT_SUPPORTED"); assert_eq!( err.request_id, - (version == Version::Draft16).then_some(RequestId(REQUEST_ID)), + (false).then_some(RequestId(REQUEST_ID)), "{label}" ); } @@ -9842,7 +9382,7 @@ mod serve_tests { /// request id breaking ties, whatever group and GROUP_ORDER it asks for. #[moq_clock::test] async fn a_standalone_fetch_ranks_by_its_priority() { - for version in [Version::Draft16, Version::Draft20] { + for version in [Version::Draft20] { for (group, group_order) in [(1, GroupOrder::Ascending), (3, GroupOrder::Descending)] { let mut h = serve(version); publish_groups(&mut h, 3); @@ -9908,29 +9448,22 @@ mod serve_tests { /// Every draft that still carries a joining FETCH. const JOINING_DRAFTS: [Version; 6] = [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, Version::Draft19, ]; fn invalid_joining_request_id(version: Version) -> u64 { - if version == Version::Draft14 { 0x7 } else { 0x32 } + 0x32 } fn invalid_range(version: Version) -> u64 { - if version == Version::Draft14 { 0x5 } else { 0x11 } + 0x11 } /// The registry's "does not exist" value: draft-14 numbers it 0x4 on FETCH_ERROR and /// draft-15 moved it to 0x10. fn does_not_exist(version: Version) -> u64 { - match version { - Version::Draft14 => 0x4, - _ => 0x10, - } + 0x10 } /// Yield so the broadcast registered by `serve` is visible to the lookup. @@ -10041,16 +9574,10 @@ mod serve_tests { let ok = crate::coding::decode_buf(&mut buf, version, ietf::FetchOk::decode).unwrap(); assert_eq!( ok.request_id, - match version { - Version::Draft14 | Version::Draft15 | Version::Draft16 => Some(FETCH_ID), - _ => None, - }, + None, "{version}: wrong request id" ); assert!(!ok.end_of_track, "{version}: the track has not ended"); - if version == Version::Draft14 { - assert_eq!(ok.group_order, GroupOrder::Ascending); - } let properties = match ietf::Properties::sends_timescale(version) { false => ietf::Properties::default(), true => track_properties(&track::Info::timed(), true, version, true).unwrap(), @@ -10078,30 +9605,23 @@ mod serve_tests { // Drafts 14-16 never declared TIMESCALE, so the prefix must not carry a Timestamp. let stamped = ietf::Properties::sends_timescale(version); for (index, payload) in payloads.iter().enumerate() { - if version == Version::Draft14 { + let flags = match (index == 0, stamped) { + (true, true) => 0x3c, + (true, false) => 0x1c, + (false, true) => 0x20, + (false, false) => 0, + }; + assert_eq!( + crate::coding::decode_varint(&mut buf, version).unwrap(), + flags, + "{version}" + ); + if index == 0 { assert_eq!(crate::coding::decode_varint(&mut buf, version).unwrap(), LATEST); assert_eq!(crate::coding::decode_varint(&mut buf, version).unwrap(), 0); - assert_eq!(crate::coding::decode_varint(&mut buf, version).unwrap(), index as u64); assert_eq!(bytes::Buf::try_get_u8(&mut buf).unwrap(), 0); - } else { - let flags = match (index == 0, stamped) { - (true, true) => 0x3c, - (true, false) => 0x1c, - (false, true) => 0x20, - (false, false) => 0, - }; - assert_eq!( - crate::coding::decode_varint(&mut buf, version).unwrap(), - flags, - "{version}" - ); - if index == 0 { - assert_eq!(crate::coding::decode_varint(&mut buf, version).unwrap(), LATEST); - assert_eq!(crate::coding::decode_varint(&mut buf, version).unwrap(), 0); - assert_eq!(bytes::Buf::try_get_u8(&mut buf).unwrap(), 0); - } } - let properties = if version == Version::Draft14 || stamped { + let properties = if stamped { crate::coding::decode_buf(&mut buf, version, |r, _| Ok(r.bytes()?.to_vec())).unwrap() } else { Vec::new() @@ -10113,9 +9633,6 @@ mod serve_tests { } let size = crate::coding::decode_varint(&mut buf, version).unwrap() as usize; assert_eq!(size, payload.len()); - if size == 0 && matches!(version, Version::Draft14 | Version::Draft15) { - assert_eq!(crate::coding::decode_varint(&mut buf, version).unwrap(), 0); - } assert_eq!(buf.split_to(size).as_ref(), *payload); } assert!(buf.is_empty(), "FETCH delivered objects beyond the saved prefix"); @@ -10216,23 +9733,13 @@ mod serve_tests { drop(serving); let mut response = bytes::Bytes::from(fetching.await.unwrap()); let id = crate::coding::decode_varint(&mut response, version).unwrap(); - if version == Version::Draft14 { - assert_eq!(id, ietf::FetchError::ID); - assert_eq!( - crate::coding::decode_buf(&mut response, version, ietf::FetchError::decode) - .unwrap() - .error_code, - invalid_joining_request_id(version) - ); - } else { - assert_eq!(id, ietf::RequestError::ID); - assert_eq!( - crate::coding::decode_buf(&mut response, version, ietf::RequestError::decode) - .unwrap() - .error_code, - invalid_joining_request_id(version) - ); - } + assert_eq!(id, ietf::RequestError::ID); + assert_eq!( + crate::coding::decode_buf(&mut response, version, ietf::RequestError::decode) + .unwrap() + .error_code, + invalid_joining_request_id(version) + ); assert!(response.is_empty()); assert!(h.publisher.joins.read().is_empty()); } @@ -10311,23 +9818,13 @@ mod serve_tests { let mark = h.log.writes.lock().unwrap().len(); let mut buf = bytes::Bytes::from(joining_fetch(&h, mark).await.unwrap()); let id = crate::coding::decode_varint(&mut buf, version).unwrap(); - if version == Version::Draft14 { - assert_eq!(id, ietf::FetchError::ID); - assert_eq!( - crate::coding::decode_buf(&mut buf, version, ietf::FetchError::decode) - .unwrap() - .error_code, - invalid_joining_request_id(version) - ); - } else { - assert_eq!(id, ietf::RequestError::ID); - assert_eq!( - crate::coding::decode_buf(&mut buf, version, ietf::RequestError::decode) - .unwrap() - .error_code, - invalid_joining_request_id(version) - ); - } + assert_eq!(id, ietf::RequestError::ID); + assert_eq!( + crate::coding::decode_buf(&mut buf, version, ietf::RequestError::decode) + .unwrap() + .error_code, + invalid_joining_request_id(version) + ); assert!(buf.is_empty()); assert!(h.log.resets().is_empty()); } @@ -10351,22 +9848,17 @@ mod serve_tests { registered(&h, serving.as_mut()).await; let mark = h.log.writes.lock().unwrap().len(); let result = joining_fetch(&h, mark).await; - if matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) { - assert!(matches!(result, Err(Error::ProtocolViolation))); - assert_eq!(h.log.closes()[0].0, 0x3); - } else { - let mut buf = bytes::Bytes::from(result.unwrap()); - assert_eq!( - crate::coding::decode_varint(&mut buf, version).unwrap(), - ietf::RequestError::ID - ); - assert_eq!( - crate::coding::decode_buf(&mut buf, version, ietf::RequestError::decode) - .unwrap() - .error_code, - 0x3 - ); - } + let mut buf = bytes::Bytes::from(result.unwrap()); + assert_eq!( + crate::coding::decode_varint(&mut buf, version).unwrap(), + ietf::RequestError::ID + ); + assert_eq!( + crate::coding::decode_buf(&mut buf, version, ietf::RequestError::decode) + .unwrap() + .error_code, + 0x3 + ); } } } @@ -10390,23 +9882,13 @@ mod serve_tests { let mark = h.log.writes.lock().unwrap().len(); let mut buf = bytes::Bytes::from(joining_fetch(&h, mark).await.unwrap()); let id = crate::coding::decode_varint(&mut buf, version).unwrap(); - if version == Version::Draft14 { - assert_eq!(id, ietf::FetchError::ID); - assert_eq!( - crate::coding::decode_buf(&mut buf, version, ietf::FetchError::decode) - .unwrap() - .error_code, - invalid_range(version) - ); - } else { - assert_eq!(id, ietf::RequestError::ID); - assert_eq!( - crate::coding::decode_buf(&mut buf, version, ietf::RequestError::decode) - .unwrap() - .error_code, - invalid_range(version) - ); - } + assert_eq!(id, ietf::RequestError::ID); + assert_eq!( + crate::coding::decode_buf(&mut buf, version, ietf::RequestError::decode) + .unwrap() + .error_code, + invalid_range(version) + ); assert!(buf.is_empty()); assert!(h.log.resets().is_empty()); } @@ -10414,10 +9896,6 @@ mod serve_tests { /// Every draft, each carrying a standalone FETCH or draft-20's filtered one. const FETCH_DRAFTS: [Version; 9] = [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft20, @@ -10568,15 +10046,8 @@ mod serve_tests { let mut objects = Vec::new(); let mut prior: Option<(u64, u64)> = None; while !buf.is_empty() { - let (group, object) = if version == Version::Draft14 { - let group = buf.varint().unwrap(); - assert_eq!(buf.varint().unwrap(), 0, "subgroup"); - let object = buf.varint().unwrap(); - let _priority = buf.u8().unwrap(); - let _properties = buf.bytes().unwrap(); - (group, object) - } else { - let ietf::FetchObject::Object { group, object, .. } = + let (group, object) = { +let ietf::FetchObject::Object { group, object, .. } = ietf::FetchObject::decode(&mut buf, version).unwrap() else { panic!("{version}: unexpected End of Range"); @@ -10586,14 +10057,11 @@ mod serve_tests { // No Group ID: the same group, and an absent Object ID Delta is one. (Some((group, prior)), None) => (group, prior + object.unwrap_or(1)), (Some((prior, _)), Some(group)) => { - let group = match version { - Version::Draft15 | Version::Draft16 | Version::Draft17 => group, - _ => prior + group + 1, - }; + let group = prior + group + 1; (group, object.unwrap()) } } - }; +}; let size = buf.varint().unwrap() as usize; let payload = String::from_utf8(buf.slice(size).unwrap().to_vec()).unwrap(); objects.push((group, object, payload)); @@ -10684,7 +10152,6 @@ mod serve_tests { &mut Encoder::new(&mut properties, version.into()), stamp, info.timescale.expect("a timed track"), - version, ) .unwrap(); assert_eq!( @@ -10717,7 +10184,7 @@ mod serve_tests { /// unchanged, beside the ones it does, on every draft with a Track Properties block. #[moq_clock::test] async fn unknown_track_properties_are_forwarded() { - for version in [Version::Draft16, Version::Draft17, Version::Draft22] { + for version in [Version::Draft22] { let upstream = unknown_properties(version); let info = track::Info { properties: Some(Arc::new(crate::model::object::TrackProperties { @@ -10767,7 +10234,7 @@ mod serve_tests { .await; let wire = h.log.writes.lock().unwrap().clone(); let mut buf = Decoder::new(&wire, version.into()); - assert_eq!(buf.varint().unwrap(), ietf::TrackStatusOk::id(version)); + assert_eq!(buf.varint().unwrap(), ietf::TrackStatusOk::ID); let ok = ietf::TrackStatusOk::decode(&mut buf, version).unwrap(); assert_eq!(ok.properties.unknown, upstream.unknown, "{version}: TRACK_STATUS_OK"); } @@ -10806,7 +10273,7 @@ mod serve_tests { assert_eq!(occurrences(&h.log, &block[1..]), 1); // Draft 17 forbids the 7-byte varints draft 18 allows, and draft 16 has QUIC varints. - for version in [Version::Draft16, Version::Draft17] { + for version in [Version::Draft17] { let h = serve_track(version, info.clone()); let stream = Stream::open(&mut crate::driver::Transport::new(h.session.clone()), version) .await @@ -11267,10 +10734,7 @@ mod serve_tests { #[moq_clock::test] async fn a_standalone_fetch_through_the_maximum_group_is_unsupported() { for version in FETCH_DRAFTS { - let maximum = match version { - Version::Draft14 | Version::Draft15 | Version::Draft16 => (1 << 62) - 1, - _ => u64::MAX, - }; + let maximum = u64::MAX; let mut h = serve(version); publish_pairs(&mut h, 1, None); h.track.finish().unwrap(); @@ -11299,10 +10763,6 @@ mod serve_tests { let mut buf = Decoder::new(&wire, version.into()); let id = buf.varint().unwrap(); let code = match version { - Version::Draft14 => { - assert_eq!(id, ietf::FetchError::ID); - ietf::FetchError::decode(&mut buf, version).unwrap().error_code - } _ => { assert_eq!(id, ietf::RequestError::ID); ietf::RequestError::decode(&mut buf, version).unwrap().error_code @@ -11891,16 +11351,7 @@ mod serve_tests { fn withdraw(request: &ScriptedSession, version: Version) { use crate::lite::test_transport::Close; match version { - Version::Draft14 | Version::Draft15 | Version::Draft16 => { - let mut unsubscribe = vec![ietf::Unsubscribe::ID as u8]; - ietf::Unsubscribe { - request_id: RequestId(REQUEST_ID), - } - .encode(&mut Encoder::new(&mut unsubscribe, version.into()), version) - .unwrap(); - request.push(&unsubscribe); - } - Version::Draft17 | Version::Draft18 => request.close(Close::Fin), + Version::Draft18 => request.close(Close::Fin), _ => request.close(Close::Reset), } } @@ -12238,10 +11689,6 @@ mod serve_tests { #[moq_clock::test] async fn subscribe_ok_announces_the_served_order() { for version in [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft20, ] { for (requested, announced) in [ @@ -12262,9 +11709,7 @@ mod serve_tests { ); let ok = crate::coding::decode_buf(&mut buf, version, ietf::SubscribeOk::decode).unwrap(); let expected = match version { - Version::Draft14 | Version::Draft15 => Some(announced), // Draft-16 has no room for it. - Version::Draft16 => None, _ => Some(GroupOrder::Descending), }; assert_eq!(ok.properties.group_order, expected, "{version:?} {requested:?}"); @@ -12275,10 +11720,6 @@ mod serve_tests { #[moq_clock::test] async fn largest_object_is_the_live_edge_before_draft20() { for version in [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, Version::Draft19, ] { @@ -12501,17 +11942,10 @@ mod serve_tests { crate::transport::boxed::SendStream::new(crate::lite::test_transport::SinkSend::new(log.clone())), version, ); - let subscription_request_id = match version { - Version::Draft14 | Version::Draft15 | Version::Draft16 => Some(RequestId(REQUEST_ID)), - _ => None, - }; let msg = ietf::SubscribeUpdate { max_age: None, new_group: None, request_id: RequestId(0x40), - subscription_request_id, - start_location: Location { group: 0, object: 0 }, - end_group: 0, subscriber_priority: Some(128), forward: Some(forward), filter: None, @@ -12535,7 +11969,6 @@ mod serve_tests { writer .encode(&ietf::RequestOk { largest: None, - request_id: matches!(version, Version::Draft15 | Version::Draft16).then_some(request_id), active: None, }) .await @@ -12552,7 +11985,7 @@ mod serve_tests { crate::transport::boxed::SendStream::new(crate::lite::test_transport::SinkSend::new(log.clone())), version, ); - let request_id = matches!(version, Version::Draft15 | Version::Draft16).then_some(request_id); + let request_id = false.then_some(request_id); writer.varint(ietf::RequestError::ID).await.unwrap(); writer .encode(&ietf::RequestError { @@ -12662,7 +12095,7 @@ mod serve_tests { /// `super::super::adapter::tests::test_classify_subscribe_update_followup`. #[moq_clock::test] async fn a_subscribe_update_renewal_is_answered_from_draft_15() { - for version in [Version::Draft14, Version::Draft15, Version::Draft16] { + for version in [Version::Draft15] { renews(version, true).await; } } @@ -12672,7 +12105,7 @@ mod serve_tests { /// draft-14, a keyed REQUEST_ERROR to the update's Request ID on draft-15/16. #[moq_clock::test] async fn a_refused_subscribe_update_renewal_ends_the_subscription_from_draft_14() { - for version in [Version::Draft14, Version::Draft15, Version::Draft16] { + for version in [Version::Draft15] { renews(version, false).await; } } @@ -12681,7 +12114,7 @@ mod serve_tests { /// both fails instead of acknowledging a token nobody checked. #[moq_clock::test] async fn a_pause_carrying_a_token_fails_the_update() { - for version in [Version::Draft15, Version::Draft16] { + for version in [Version::Draft16] { let (auth, mut requests, _cred) = auth_covering_other(); let h = serve_with_auth(version, auth, subscribe_update_with_token(version, false).await); let rt = h.publisher.runtime.clone(); @@ -12717,7 +12150,7 @@ mod serve_tests { let (status, _) = wire.publish_done.expect("PUBLISH_DONE was sent"); assert_eq!( status, - ietf::PublishDoneStatus::UpdateFailed.code(version), + ietf::PublishDoneStatus::UpdateFailed.code(), "{version:?}" ); } @@ -12798,7 +12231,6 @@ mod serve_tests { // update's own Request ID (0x40), the id the renewing peer waits on. let written = h.log.writes.lock().unwrap()[before..].to_vec(); match version { - Version::Draft14 => assert!(written.is_empty(), "{version:?}: a renewal writes no answer"), _ => assert_eq!( written, request_ok_bytes(version, RequestId(0x40)).await, @@ -12844,16 +12276,12 @@ mod serve_tests { // Draft 14 has no UPDATE_FAILED and answers no update, so its PUBLISH_DONE // carries the refusal itself. let (status, _) = Wire::read(&h.log, version).publish_done.expect("PUBLISH_DONE was sent"); - let expected = match version { - Version::Draft14 => ietf::PublishDoneStatus::Unauthorized, - _ => ietf::PublishDoneStatus::UpdateFailed, - }; + let expected = ietf::PublishDoneStatus::UpdateFailed; assert_eq!(status, expected.code(version), "{version:?}"); let written = h.log.writes.lock().unwrap()[before..].to_vec(); match version { // draft-14 has no renewal reply: the refusal is signalled only by the subscription // ending (SUBSCRIBE_DONE UNAUTHORIZED, written by the caller), with no REQUEST_ERROR. - Version::Draft14 => {} // draft-15/16 answer with one keyed REQUEST_ERROR before the subscription ends. _ => { let error = request_error_bytes(version, RequestId(0x40), "no").await; @@ -12875,17 +12303,10 @@ mod serve_tests { crate::transport::boxed::SendStream::new(crate::lite::test_transport::SinkSend::new(log.clone())), version, ); - let subscription_request_id = match version { - Version::Draft14 | Version::Draft15 | Version::Draft16 => Some(RequestId(REQUEST_ID)), - _ => None, - }; let msg = ietf::SubscribeUpdate { max_age: None, new_group: None, request_id: RequestId(rid), - subscription_request_id, - start_location: Location { group: 0, object: 0 }, - end_group: 0, subscriber_priority: Some(128), forward: Some(true), filter: None, @@ -12906,17 +12327,10 @@ mod serve_tests { crate::transport::boxed::SendStream::new(crate::lite::test_transport::SinkSend::new(log.clone())), version, ); - let subscription_request_id = match version { - Version::Draft14 | Version::Draft15 | Version::Draft16 => Some(RequestId(REQUEST_ID)), - _ => None, - }; let msg = ietf::SubscribeUpdate { max_age: None, new_group: None, request_id: RequestId(rid), - subscription_request_id, - start_location: Location { group: 0, object: 0 }, - end_group: 0, subscriber_priority: Some(128), forward: Some(true), filter: None, @@ -13204,7 +12618,6 @@ mod serve_tests { writer .encode(&ietf::RequestOk { largest: None, - request_id: None, active: None, }) .await @@ -13232,7 +12645,7 @@ mod serve_tests { /// answer either way, and the token-less update behind it is never answered ahead of it. #[moq_clock::test] async fn an_update_behind_a_pending_renewal_is_answered_in_order() { - for version in [Version::Draft16, Version::Draft18] { + for version in [Version::Draft18] { let (auth, mut requests, _cred) = auth_covering_other(); let mut script = subscribe_update_token_rid(version, 0x40).await; script.extend(subscribe_update_bare_rid(version, 0x42).await); @@ -13298,7 +12711,7 @@ mod serve_tests { /// silent branches of the acknowledgement so a wrong key cannot misroute the peer's answer. #[moq_clock::test] async fn token_less_updates_are_keyed_before_draft_17() { - for version in [Version::Draft14, Version::Draft15, Version::Draft16] { + for version in [Version::Draft15] { let (auth, mut requests, _cred) = auth_covering_other(); let rids = [0x42u64, 0x44, 0x46]; let mut script = Vec::new(); @@ -13335,12 +12748,10 @@ mod serve_tests { // Draft-14 answers nothing; draft-15/16 answer each update keyed to its own request id. let written = h.log.writes.lock().unwrap().clone(); - if !matches!(version, Version::Draft14) { - for rid in rids { - let one = request_ok_bytes(version, RequestId(rid)).await; - let n = written.windows(one.len()).filter(|w| *w == one.as_slice()).count(); - assert_eq!(n, 1, "{version}: update {rid:#x} gets exactly one keyed REQUEST_OK"); - } + for rid in rids { + let one = request_ok_bytes(version, RequestId(rid)).await; + let n = written.windows(one.len()).filter(|w| *w == one.as_slice()).count(); + assert_eq!(n, 1, "{version}: update {rid:#x} gets exactly one keyed REQUEST_OK"); } assert!( h.log.closes().is_empty(), @@ -13505,7 +12916,7 @@ mod serve_tests { /// acceptor sitting on the renewal, the UNSUBSCRIBE is the only thing that can. #[moq_clock::test] async fn a_pending_renewal_ends_on_an_unsubscribe_before_draft_17() { - for version in [Version::Draft14, Version::Draft15, Version::Draft16] { + for version in [Version::Draft15] { let (auth, requests, _cred) = auth_covering_other(); // The stream carries the renewal, then the UNSUBSCRIBE, and never FINs, so only the // message can end the request. @@ -13580,7 +12991,7 @@ mod serve_tests { let (status, _) = Wire::read(&h.log, VERSION).publish_done.expect("PUBLISH_DONE was sent"); assert_eq!( status, - ietf::PublishDoneStatus::UpdateFailed.code(VERSION), + ietf::PublishDoneStatus::UpdateFailed.code(), "UPDATE_FAILED" ); // Draft-17+ answers the refused update with exactly one unkeyed REQUEST_ERROR before the @@ -13917,7 +13328,7 @@ mod serve_tests { /// one is refused NOT_SUPPORTED rather than taken unread, failing only that subscription. #[moq_clock::test] async fn a_token_on_a_subscription_admitted_without_one_is_refused() { - for version in [Version::Draft16, Version::Draft22] { + for version in [Version::Draft22] { let auth = crate::auth::Link::new(false); auth.handle().authorize(&crate::auth::Grant::all()); let h = serve_with_auth(version, auth, Vec::new()); @@ -14023,7 +13434,6 @@ mod serve_tests { writer.varint(ietf::RequestError::ID).await.unwrap(); writer .encode(&ietf::RequestError { - request_id: None, error_code: request::to_code(&Error::Unsupported, request::Kind::Subscribe, version), reason_phrase: Error::Unsupported.to_string().into(), retry_interval: 0, @@ -14315,7 +13725,6 @@ mod tests { Control::new(None, false), Some(assigned), peer::PeerSetup::default(), - Version::Draft16, ); let mut echoed_hops = crate::Hops::new(); @@ -14444,7 +13853,6 @@ mod tests { Control::new(None, false), Some(assigned), peer::PeerSetup::default(), - Version::Draft16, ); // The chain as ingress stores it: the peer named itself 0, and `via` is the @@ -14492,7 +13900,6 @@ mod tests { Control::new(None, false), None, setup, - Version::Draft17, ); let mut clean = crate::Hops::new(); @@ -14525,13 +13932,11 @@ mod tests { let expected = crate::lite::test_transport::Log::default(); let mut writer = crate::coding::Writer::new( crate::transport::boxed::SendStream::new(crate::lite::test_transport::SinkSend::new(expected.clone())), - Version::Draft17, ); writer.varint(ietf::RequestOk::ID).await.unwrap(); writer .encode(&ietf::RequestOk { largest: None, - request_id: None, active: Some(1), }) .await @@ -14563,7 +13968,6 @@ mod tests { Control::new(None, false), Some(assigned), requires_solicitation(), - Version::Draft16, ); // The prefix starts with only a route from the assigned peer: hop 0 on the @@ -14636,7 +14040,6 @@ mod tests { writer.varint(ietf::RequestError::ID).await.unwrap(); writer .encode(&ietf::RequestError { - request_id: matches!(version, Version::Draft15 | Version::Draft16).then_some(RequestId(1)), // UNINTERESTED, draft-17 section 14.5.2. error_code: 0x20, reason_phrase: "no".into(), @@ -14790,33 +14193,12 @@ mod tests { ); match version { - Version::Draft14 => { - writer.varint(ietf::PublishNamespaceOk::ID).await.unwrap(); - writer - .encode(&ietf::PublishNamespaceOk { - request_id: RequestId(1), - }) - .await - .unwrap(); - } - Version::Draft15 | Version::Draft16 => { - writer.varint(ietf::RequestOk::ID).await.unwrap(); - writer - .encode(&ietf::RequestOk { - largest: None, - request_id: Some(RequestId(1)), - active: None, - }) - .await - .unwrap(); - } // Draft-17+ dropped the request id: the response rides the request's stream. _ => { writer.varint(ietf::RequestOk::ID).await.unwrap(); writer .encode(&ietf::RequestOk { largest: None, - request_id: None, active: None, }) .await @@ -14968,7 +14350,7 @@ mod tests { /// plus STOP_SENDING. A FIN there is a protocol violation some peers close on. #[moq_clock::test] async fn publish_namespace_withdraws_by_reset_from_draft_17() { - for version in [Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft22] { + for version in [Version::Draft18, Version::Draft19, Version::Draft22] { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let local = origin.announce("local-cam", crate::origin::Route::default()).unwrap(); settle().await; @@ -15046,7 +14428,6 @@ mod tests { writer .encode(&ietf::RequestOk { largest: None, - request_id: None, active: Some(0), }) .await @@ -15219,9 +14600,6 @@ mod tests { #[moq_clock::test] async fn hidden_discovery_obeys_peer_setup_and_requested_prefix() { for version in [ - Version::Draft14, - Version::Draft15, - Version::Draft16, Version::Draft19, Version::Draft22, ] { @@ -15244,7 +14622,7 @@ mod tests { // the two paths disjoint; draft-16 and later fill the stream too. let on_stream = !declared || hidden || prefix == ".stats"; let unsolicited = solicit != Some(true) && !declared; - let legacy = matches!(version, Version::Draft14 | Version::Draft15); + let legacy = false; let inline = if legacy { (solicit == Some(true) && on_stream) || (solicit != Some(true) && declared && (hidden || prefix == ".stats")) @@ -15279,7 +14657,7 @@ mod tests { assert_eq!(once, 1, "a peer that asked to be told on request is told once"); assert_eq!(streams, 1, "inline on the SUBSCRIBE_NAMESPACE stream it asked on"); - for version in [Version::Draft14, Version::Draft15] { + for version in [Version::Draft15] { let log = advertise_with_hidden(Discovery { version, solicit: Some(false), @@ -15299,7 +14677,7 @@ mod tests { /// after, then NAMESPACE_DONE when that announcement ends. #[moq_clock::test] async fn a_non_solicit_subscribe_namespace_carries_namespace() { - for version in [Version::Draft16, Version::Draft18] { + for version in [Version::Draft18] { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let early = origin.announce("early-cam", crate::origin::Route::default()).unwrap(); settle().await; @@ -15487,7 +14865,6 @@ mod tests { Control::new(None, false), Some(assigned), declared(Some(false)), - Version::Draft17, ); // The state a refused or failed offer leaves behind: the peer holds nothing, and @@ -15748,7 +15125,6 @@ mod tests { writer .encode(&ietf::RequestOk { largest: None, - request_id: None, active: Some(0), }) .await @@ -15966,10 +15342,7 @@ mod tests { // From draft 18 the update goes unanswered: an answer scripted ahead of it would // arrive while the request is idle. let ok = publish_namespace_ok(version).await; - let script = match version { - Version::Draft16 => [ok.clone(), ok].concat(), - _ => ok, - }; + let script = ok; let (publisher, log) = auth_publisher(&origin, &auth, vec![script], version); let mut run = std::pin::pin!(publisher.run_publish_namespaces()); poll_until(&mut run, &log, b"cam", 1).await; @@ -15989,7 +15362,7 @@ mod tests { version, &ietf::PublishNamespaceUpdate { request_id: RequestId(3), - namespace_request_id: (version == Version::Draft16).then_some(RequestId(1)), + namespace_request_id: (false).then_some(RequestId(1)), hops: None, cost: None, authorization_token: Some(auth_token(b"second-secret")), @@ -16307,7 +15680,7 @@ mod tests { /// and the failed one is offered again after a backoff rather than in a loop. #[moq_clock::test] async fn a_failed_advertisement_ends_only_its_namespace() { - for version in [Version::Draft14, Version::Draft19] { + for version in [Version::Draft19] { for fin in [true, false] { fails_one_advertisement(version, fin).await; } @@ -16385,7 +15758,6 @@ mod tests { cams.remove(second); match version { - Version::Draft14 => assert_eq!(held.reader.varint().await.unwrap(), ietf::PublishNamespaceDone::ID), _ => assert!( held.reader.varint().await.is_err(), "{version} fin={fin}: not withdrawn" @@ -16401,7 +15773,7 @@ mod tests { async fn a_failed_legacy_header_closes_the_session() { use crate::transport::{memory, poll::Session as _}; - for version in [Version::Draft14, Version::Draft15, Version::Draft19] { + for version in [Version::Draft19] { let origin = unheld_origin(); // A token too big for the header's u16 length, so the header fails after its stream // opened and its request ID was spent. A message goes out whole, so this is the one @@ -16434,33 +15806,15 @@ mod tests { .expect("no advertisement") .unwrap(); - match version { - Version::Draft14 | Version::Draft15 => { - let closed = moq_clock::timeout(Duration::from_secs(10), peer.closed()) - .await - .unwrap_or_else(|_| panic!("{version}: the session stayed open")); - let code = super::super::error::to_session_code(&crate::SessionError::Internal); - assert!( - matches!(closed, memory::Error::Session { code: c, .. } if c == code), - "{version}: {closed:?}" - ); - let res = moq_clock::timeout(Duration::from_secs(10), run) - .await - .unwrap_or_else(|_| panic!("{version}: the loop kept running")); - assert!(res.unwrap().is_err(), "{version}: the loop ended cleanly"); - } - _ => { - // Offered again after the backoff, on a session that stays open. - moq_clock::timeout( - Duration::from_secs(10), - Stream::accept(&mut crate::driver::Transport::new(peer.clone()), version), - ) - .await - .unwrap_or_else(|_| panic!("{version}: not offered again")) - .unwrap(); - assert!(!run.is_finished(), "{version}: the loop ended"); - } - } + // Offered again after the backoff, on a session that stays open. + moq_clock::timeout( + Duration::from_secs(10), + Stream::accept(&mut crate::driver::Transport::new(peer.clone()), version), + ) + .await + .unwrap_or_else(|_| panic!("{version}: not offered again")) + .unwrap(); + assert!(!run.is_finished(), "{version}: the loop ended"); } } @@ -16554,10 +15908,6 @@ mod tests { 2, "{version}: the unanswered renewal was never retried" ); - if version == Version::Draft16 { - let done = publish_namespace_done(version).await; - assert_eq!(occurrences(&log, &done), 1, "the peer was never told to let it go"); - } } /// moq-transport has no restart: another source winning a namespace without an epoch @@ -16785,7 +16135,7 @@ mod tests { /// withdrawn with PUBLISH_NAMESPACE_DONE; from draft 17 its own stream's reset ends it. #[moq_clock::test] async fn an_unanswered_advertisement_is_withdrawn() { - for version in [Version::Draft14, Version::Draft15, Version::Draft16, Version::Draft17] { + for version in [Version::Draft15] { let origin = unheld_origin(); let _cam = origin.announce("cam", crate::origin::Route::default()).unwrap(); settle().await; @@ -16805,10 +16155,7 @@ mod tests { let mut run = std::pin::pin!(publisher.run_publish_namespaces()); poll_until(&mut run, &log, b"cam", 1).await; - let done = match version { - Version::Draft17 => None, - _ => Some(publish_namespace_done(version).await), - }; + let done = Some(publish_namespace_done(version).await); let withdrawn = || match &done { Some(done) => occurrences(&log, done) > 0, None => !log.resets().is_empty(), @@ -16833,10 +16180,6 @@ mod tests { async fn an_advertisement_without_credit_is_retried_and_spends_no_id() { use std::sync::atomic::Ordering; for version in [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft19, ] { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); @@ -17053,7 +16396,7 @@ mod tests { /// on a request we already refused. Finishing first makes the drop-time reset a no-op. #[moq_clock::test] async fn missing_broadcast_is_refused_without_resetting_the_stream() { - for version in [Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft20] { + for version in [Version::Draft18, Version::Draft19, Version::Draft20] { let (writes, resets) = subscribe_missing(version).await; assert!(!writes.is_empty(), "{version}: nothing was sent"); @@ -17093,7 +16436,7 @@ mod tests { ] }; - for version in [Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft20] { + for version in [Version::Draft18, Version::Draft19, Version::Draft20] { for (label, fetch_type) in refused() { let (writes, resets) = fetch_refused(version, fetch_type).await; @@ -17877,7 +17220,7 @@ mod compression_tests { use super::*; #[test] fn sealed_compression_refuses_incompatible_egress() { - for version in [Version::Draft17, Version::Draft18, Version::Draft22] { + for version in [Version::Draft18, Version::Draft22] { let mut sealed = Vec::new(); let mut encoder = Encoder::new(&mut sealed, version.into()); encoder.varint(super::super::flate::COMPRESSION).unwrap(); @@ -17919,13 +17262,13 @@ mod compression_tests { Err(Error::Unsupported) )); assert!(matches!( - track_properties(&info, wanted, Version::Draft16, true), + track_properties(&info, wanted, true), Err(Error::Unsupported) )); } let plain = track::Info::default().with_compress(true); assert!(!track_properties(&plain, true, version, false).unwrap().compress); - assert!(!track_properties(&plain, true, Version::Draft15, true).unwrap().compress); + assert!(!track_properties(&plain, true, true).unwrap().compress); } } @@ -17957,7 +17300,6 @@ mod compression_tests { group.finish().unwrap(); track.finish().unwrap(); let response = ietf::SubscribeOk { - request_id: None, track_alias: 0, largest: None, properties: track_properties(track.info(), true, version, negotiated).unwrap(), diff --git a/rs/moq-net/src/ietf/publisher/tracks.rs b/rs/moq-net/src/ietf/publisher/tracks.rs index cd38ab88291..1756a70ed59 100644 --- a/rs/moq-net/src/ietf/publisher/tracks.rs +++ b/rs/moq-net/src/ietf/publisher/tracks.rs @@ -289,7 +289,6 @@ impl Publisher { return super::super::request_stream::reject(stream, error).await; } let refuse = |error_code, reason: &'static str| ietf::RequestError { - request_id: None, error_code, reason_phrase: reason.into(), retry_interval: 0, @@ -341,7 +340,6 @@ impl Publisher { stream .writer .encode_message(&ietf::RequestOk { - request_id: None, active: None, largest: None, }) @@ -539,7 +537,6 @@ impl Publisher { stream.writer.buffer_message( ietf::RequestError::ID, &ietf::RequestError { - request_id: None, error_code: code, reason_phrase: reason.into(), retry_interval: 0, @@ -870,22 +867,16 @@ impl Publisher { let dynamic = properties.dynamic_groups; let absolute = self.origin.absolute(&namespace).to_owned(); - // Every wait on the peer, for a Request ID or the PUBLISH's bytes, lasts only while - // the track is listed and the request stands. A Request ID abandoned unsent leaves a - // gap, which the drafts with SUBSCRIBE_TRACKS allow: none has MAX_REQUEST_ID. + // Every wait on the peer for the PUBLISH's bytes lasts only while the track is listed + // and the request stands. let mut session = self.session.clone(); - let mut stream = super::super::request_stream::with_stats(stream, self.stats(), self.version); - let allocated = kio::wait(|waiter| { - if listed.poll_closed(waiter).is_ready() || live.poll_closed(waiter).is_ready() { - return Poll::Ready(None); - } - self.control.poll_next_request_id(waiter).map(Some) - }) - .await; + let mut stream = stream.with_stats(self.stats()); // Dropped unwritten, the stream is reset before its header, which the peer ignores. - let Some(request_id) = allocated else { + let noop = kio::Waiter::noop(); + if listed.poll_closed(&noop).is_ready() || live.poll_closed(&noop).is_ready() { return Ok(()); - }; + } + let request_id = self.control.next_request_id(); // A joining FETCH needs the subscription forwarding. let join = (!Filter::is_draft20(self.version)).then(|| self.register_join(request_id)); @@ -989,7 +980,7 @@ impl Publisher { if let Some(done) = refused { drop(join); - return self.write_publish_done(stream, request_id, done, 0, None).await; + return self.write_publish_done(stream, done, 0, None).await; } // Group streams opened over every time the subscription forwarded, which @@ -1020,7 +1011,7 @@ impl Publisher { { Ok(Served::Paused(_)) => { self.pause_join(join.as_ref()); - self.write_request_ok(&mut stream.writer, request_id, None).await?; + self.write_request_ok(&mut stream.writer, None).await?; // Unlisted while it forwarded: it ends now that it is idle. if listed.is_closed() { break unlisted(&listed); @@ -1099,7 +1090,7 @@ impl Publisher { None => None, }; if let Some((reason, err)) = refusal { - self.write_subscribe_error(&mut stream.writer, update.request_id, &err, reason) + self.write_subscribe_error(&mut stream.writer, &err, reason) .await?; break Served::UpdateFailed(Error::Unsupported); } @@ -1120,12 +1111,12 @@ impl Publisher { answer: true, }) } - _ => self.write_request_ok(&mut stream.writer, request_id, None).await?, + _ => self.write_request_ok(&mut stream.writer, None).await?, } }; drop(join); - self.write_publish_done(stream, request_id, done, opened, None).await + self.write_publish_done(stream, done, opened, None).await } /// Mark a paused subscription for joining FETCHes: draft-18 section 5.1 refuses one @@ -1142,14 +1133,13 @@ impl Publisher { async fn resume_failed( &self, stream: &mut Stream, - request_id: RequestId, answer: bool, err: Error, ) -> Result { if !answer { return Ok(Served::Track(Err(err))); } - self.write_subscribe_error(&mut stream.writer, request_id, &err, "resume failed") + self.write_subscribe_error(&mut stream.writer, &err, "resume failed") .await .map_err(|_| ())?; Ok(Served::UpdateFailed(err)) @@ -1212,10 +1202,10 @@ impl Publisher { .await?; let mut subscriber = match subscribed { Some(Ok(subscriber)) => subscriber, - Some(Err(err)) => return self.resume_failed(stream, request_id, how.answer, err).await, + Some(Err(err)) => return self.resume_failed(stream, how.answer, err).await, None => { return self - .resume_failed(stream, request_id, how.answer, Error::NotFound) + .resume_failed(stream, how.answer, Error::NotFound) .await; } }; @@ -1231,7 +1221,7 @@ impl Publisher { .await?; if !live { return self - .resume_failed(stream, request_id, how.answer, Error::NotFound) + .resume_failed(stream, how.answer, Error::NotFound) .await; } @@ -1242,7 +1232,7 @@ impl Publisher { let timescale = subscriber .info() .timescale - .filter(|_| ietf::Properties::sends_timescale(self.version)); +; let mut serve = TrackServe::new( self.session.clone(), subscriber, @@ -1282,7 +1272,7 @@ impl Publisher { if how.answer && self - .write_request_ok(&mut stream.writer, request_id, edge.largest) + .write_request_ok(&mut stream.writer, edge.largest) .await .is_err() { @@ -1494,7 +1484,6 @@ mod tests { stream .writer .encode(&ietf::PublishOk { - request_id: None, forward: false, subscriber_priority: Some(128), group_order: Some(GroupOrder::Ascending), @@ -1590,7 +1579,7 @@ mod tests { let done: ietf::PublishDone = body.message(version).unwrap(); assert_eq!( done.status_code, - ietf::PublishDoneStatus::TrackEnded.code(version), + ietf::PublishDoneStatus::TrackEnded.code(), "{version}" ); } @@ -1626,7 +1615,7 @@ mod tests { let (id, body) = next(published.get_mut(name).unwrap()).await; assert_eq!(id, ietf::PublishDone::ID, "{case}: {name}"); let done: ietf::PublishDone = body.message(version).unwrap(); - assert_eq!(done.status_code, status.code(version), "{case}: {name}"); + assert_eq!(done.status_code, status.code(), "{case}: {name}"); } drop(video); } @@ -2033,7 +2022,6 @@ mod tests { stream .writer .encode(&ietf::PublishOk { - request_id: None, forward: true, subscriber_priority: None, group_order: None, @@ -2067,7 +2055,6 @@ mod tests { stream .writer .encode(&ietf::PublishOk { - request_id: None, forward: true, subscriber_priority: Some(128), group_order: Some(GroupOrder::Ascending), diff --git a/rs/moq-net/src/ietf/request.rs b/rs/moq-net/src/ietf/request.rs index c5df80a756a..cd8f2c0e9e9 100644 --- a/rs/moq-net/src/ietf/request.rs +++ b/rs/moq-net/src/ietf/request.rs @@ -42,50 +42,9 @@ impl Decode for RequestId { } } -#[derive(Clone, Debug)] -pub struct MaxRequestId { - pub request_id: RequestId, -} - -impl Message for MaxRequestId { - const ID: u64 = 0x15; - - fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { - self.request_id.encode(w, version)?; - Ok(()) - } - - fn decode_msg(r: &mut Decoder<'_>, version: Version) -> Result { - let request_id = RequestId::decode(r, version)?; - Ok(Self { request_id }) - } -} - -#[derive(Clone, Debug)] -pub struct RequestsBlocked { - pub request_id: RequestId, -} - -impl Message for RequestsBlocked { - const ID: u64 = 0x1a; - - fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { - self.request_id.encode(w, version)?; - Ok(()) - } - - fn decode_msg(r: &mut Decoder<'_>, version: Version) -> Result { - let request_id = RequestId::decode(r, version)?; - Ok(Self { request_id }) - } -} - -/// REQUEST_OK (0x07 in v15) - Generic success response for any request. -/// Replaces PublishNamespaceOk, SubscribeNamespaceOk in v15. -/// Also used as response to SubscribeUpdate and TrackStatus in v15. +/// REQUEST_OK (0x07): the generic success response for any request, on its own stream. #[derive(Clone, Debug)] pub struct RequestOk { - pub request_id: Option, /// MoQ Active Count: how many NAMESPACE messages follow before the subscription is /// synced. Only on the answer to a SUBSCRIBE_NAMESPACE, when negotiated. pub active: Option, @@ -98,13 +57,6 @@ impl Message for RequestOk { const ID: u64 = 0x07; fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { - if matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) { - self.request_id - .expect("request_id required for draft14-16") - .encode(w, version)?; - } else { - assert!(self.request_id.is_none(), "request_id must be None for draft17+"); - } encode_params!(w, version, 0x09 => self.largest, ACTIVE_COUNT_PARAM => self.active, @@ -113,11 +65,6 @@ impl Message for RequestOk { } fn decode_msg(r: &mut Decoder<'_>, version: Version) -> Result { - let request_id = if matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) { - Some(RequestId::decode(r, version)?) - } else { - None - }; // A REQUEST_UPDATE_OK may refresh EXPIRES, which is ignored like SUBSCRIBE_OK's. // LARGEST_OBJECT is a MUST on a REQUEST_UPDATE_OK or TRACK_STATUS_OK once the track // has objects. @@ -126,59 +73,34 @@ impl Message for RequestOk { 0x09 => largest: Option, ACTIVE_COUNT_PARAM => active: Option, ); - Ok(Self { - request_id, - active, - largest, - }) + Ok(Self { active, largest }) } } -/// REQUEST_ERROR (0x05 in v15) - Generic error response for any request. -/// Replaces SubscribeError, PublishError, PublishNamespaceError, -/// SubscribeNamespaceError, FetchError in v15. +/// REQUEST_ERROR (0x05): the generic error response for any request, on its own stream. #[derive(Clone, Debug)] pub struct RequestError<'a> { - pub request_id: Option, pub error_code: u64, pub reason_phrase: Cow<'a, str>, - /// v16+: retry interval in milliseconds + /// Retry interval in milliseconds. pub retry_interval: u64, } impl Message for RequestError<'_> { const ID: u64 = 0x05; - fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { - if matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) { - self.request_id - .expect("request_id required for draft14-16") - .encode(w, version)?; - } else { - assert!(self.request_id.is_none(), "request_id must be None for draft17+"); - } + fn encode_msg(&self, w: &mut Encoder<'_>, _: Version) -> Result<(), EncodeError> { w.varint(self.error_code)?; - if !matches!(version, Version::Draft14 | Version::Draft15) { - w.varint(self.retry_interval)?; - } + w.varint(self.retry_interval)?; w.string(&self.reason_phrase)?; Ok(()) } - fn decode_msg(r: &mut Decoder<'_>, version: Version) -> Result { - let request_id = if matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) { - Some(RequestId::decode(r, version)?) - } else { - None - }; + fn decode_msg(r: &mut Decoder<'_>, _: Version) -> Result { let error_code = r.varint()?; - let retry_interval = match version { - Version::Draft14 | Version::Draft15 => 0, - _ => r.varint()?, - }; + let retry_interval = r.varint()?; let reason_phrase = Cow::Owned(r.string()?); Ok(Self { - request_id, error_code, reason_phrase, retry_interval, @@ -202,61 +124,31 @@ mod tests { crate::coding::decode_buf(&mut buf, version, M::decode_msg) } - #[test] - fn test_request_ok_round_trip() { - let msg = RequestOk { - largest: None, - request_id: Some(RequestId(42)), - active: None, - }; - - let encoded = encode_message(&msg, Version::Draft15); - let decoded: RequestOk = decode_message(&encoded, Version::Draft15).unwrap(); - - assert_eq!(decoded.request_id, Some(RequestId(42))); - } - - /// A REQUEST_UPDATE_OK may refresh EXPIRES; it is ignored rather than rejected. - #[test] - fn test_request_ok_ignores_expires() { - let bytes = [0x07, 0x01, 0x08, 0x05]; - - let decoded: RequestOk = decode_message(&bytes, Version::Draft16).unwrap(); - assert_eq!(decoded.request_id, Some(RequestId(7))); - } - - /// A REQUEST_UPDATE_OK or TRACK_STATUS_OK carries LARGEST_OBJECT; it is ignored rather - /// than rejected. Draft-14 has no REQUEST_OK, and the Location is length-prefixed until - /// draft-17. + /// A REQUEST_UPDATE_OK may refresh EXPIRES, and a REQUEST_UPDATE_OK or TRACK_STATUS_OK + /// carries LARGEST_OBJECT; neither is rejected. #[test] fn test_request_ok_ignores_largest_object() { for version in [ - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft20, Version::Draft21, Version::Draft22, ] { - let bytes: &[u8] = match version { - Version::Draft15 | Version::Draft16 => &[0x07, 0x01, 0x09, 0x02, 0x05, 0x03], - _ => &[0x01, 0x09, 0x05, 0x03], - }; - let mut buf = Decoder::new(bytes, version.into()); - RequestOk::decode_msg(&mut buf, version).unwrap_or_else(|e| panic!("{version}: {e}")); - assert!(buf.is_empty(), "{version}: trailing bytes"); + for bytes in [&[0x01, 0x08, 0x05][..], &[0x01, 0x09, 0x05, 0x03]] { + let mut buf = Decoder::new(bytes, version.into()); + RequestOk::decode_msg(&mut buf, version).unwrap_or_else(|e| panic!("{version}: {e}")); + assert!(buf.is_empty(), "{version}: trailing bytes"); + } } } #[test] fn test_request_ok_active_round_trips() { - for (version, request_id) in [(Version::Draft16, Some(RequestId(3))), (Version::Draft22, None)] { + for version in [Version::Draft18, Version::Draft22] { for count in [None, Some(0), Some(7)] { let msg = RequestOk { largest: None, - request_id, active: count, }; let decoded: RequestOk = decode_message(&encode_message(&msg, version), version).unwrap(); @@ -268,103 +160,6 @@ mod tests { #[test] fn test_request_error_round_trip() { let msg = RequestError { - request_id: Some(RequestId(99)), - error_code: 500, - reason_phrase: "Internal error".into(), - retry_interval: 0, - }; - - let encoded = encode_message(&msg, Version::Draft15); - let decoded: RequestError = decode_message(&encoded, Version::Draft15).unwrap(); - - assert_eq!(decoded.request_id, Some(RequestId(99))); - assert_eq!(decoded.error_code, 500); - assert_eq!(decoded.reason_phrase, "Internal error"); - assert_eq!(decoded.retry_interval, 0); - } - - #[test] - fn test_request_error_v16_retry_interval() { - let msg = RequestError { - request_id: Some(RequestId(99)), - error_code: 500, - reason_phrase: "Internal error".into(), - retry_interval: 5000, - }; - - let encoded = encode_message(&msg, Version::Draft16); - let decoded: RequestError = decode_message(&encoded, Version::Draft16).unwrap(); - - assert_eq!(decoded.request_id, Some(RequestId(99))); - assert_eq!(decoded.error_code, 500); - assert_eq!(decoded.reason_phrase, "Internal error"); - assert_eq!(decoded.retry_interval, 5000); - } - - #[test] - fn test_request_ok_v17_round_trip() { - let msg = RequestOk { - largest: None, - request_id: None, - active: None, - }; - - let encoded = encode_message(&msg, Version::Draft17); - let decoded: RequestOk = decode_message(&encoded, Version::Draft17).unwrap(); - - assert_eq!(decoded.request_id, None); - } - - #[test] - fn test_request_error_v17_round_trip() { - let msg = RequestError { - request_id: None, - error_code: 500, - reason_phrase: "Internal error".into(), - retry_interval: 3000, - }; - - let encoded = encode_message(&msg, Version::Draft17); - let decoded: RequestError = decode_message(&encoded, Version::Draft17).unwrap(); - - assert_eq!(decoded.request_id, None); - assert_eq!(decoded.error_code, 500); - assert_eq!(decoded.reason_phrase, "Internal error"); - assert_eq!(decoded.retry_interval, 3000); - } - - #[test] - fn test_request_ok_v18_round_trip() { - let msg = RequestOk { - largest: None, - request_id: None, - active: None, - }; - - let encoded = encode_message(&msg, Version::Draft18); - let decoded: RequestOk = decode_message(&encoded, Version::Draft18).unwrap(); - - assert_eq!(decoded.request_id, None); - } - - /// Regression: pre-fix, the `version != Draft17` check caused Draft18 to be - /// treated as Draft14-16 and panic in the encoder. - #[test] - fn test_request_ok_v18_wire_matches_v17() { - let msg = RequestOk { - largest: None, - request_id: None, - active: None, - }; - let v17 = encode_message(&msg, Version::Draft17); - let v18 = encode_message(&msg, Version::Draft18); - assert_eq!(v17, v18); - } - - #[test] - fn test_request_error_v18_round_trip() { - let msg = RequestError { - request_id: None, error_code: 500, reason_phrase: "Internal error".into(), retry_interval: 3000, @@ -373,7 +168,6 @@ mod tests { let encoded = encode_message(&msg, Version::Draft18); let decoded: RequestError = decode_message(&encoded, Version::Draft18).unwrap(); - assert_eq!(decoded.request_id, None); assert_eq!(decoded.error_code, 500); assert_eq!(decoded.reason_phrase, "Internal error"); assert_eq!(decoded.retry_interval, 3000); diff --git a/rs/moq-net/src/ietf/request_stream.rs b/rs/moq-net/src/ietf/request_stream.rs index ae9ee8a0be1..7a6b24c3b9d 100644 --- a/rs/moq-net/src/ietf/request_stream.rs +++ b/rs/moq-net/src/ietf/request_stream.rs @@ -8,24 +8,10 @@ use crate::{ coding::{Decode, DecodeError, Decoder, Stream}, }; -/// Legacy receives are framed once by the physical multiplexer, not again by -/// the virtual request decoder. Encodes still count at their typed codec. -pub(super) fn with_stats( - stream: Stream, - stats: &crate::stats::Session, - version: Version, -) -> Stream { - let mut stream = stream.with_stats(stats); - if matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) { - stream.reader = stream.reader.with_stats(&Default::default()); - } - stream -} - pub(super) fn fin_cancels(version: Version) -> bool { matches!( version, - Version::Draft14 | Version::Draft15 | Version::Draft16 | Version::Draft17 | Version::Draft18 + Version::Draft18 ) } @@ -38,21 +24,13 @@ pub(super) fn poll_cancel( cx: &mut Context<'_>, ) -> Poll> { if !*finished { - let closed = match version { - Version::Draft14 | Version::Draft15 | Version::Draft16 => poll_legacy_end(stream, version, cx), - _ => messages.poll_end(&mut stream.reader, cx), - }; - match closed { + match messages.poll_end(&mut stream.reader, cx) { Poll::Ready(Ok(())) if !fin_cancels(version) => *finished = true, Poll::Ready(result) => return Poll::Ready(result), Poll::Pending => {} } } - // Virtual writers on drafts 14-16 are already closed while their control request lives. - if !matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) { - return stream.writer.poll_closed(cx); - } - Poll::Pending + stream.writer.poll_closed(cx) } /// Watch for the requester ending a request it has not been answered on yet, without consuming @@ -64,16 +42,6 @@ pub(super) fn poll_withdrawn( version: Version, cx: &mut Context<'_>, ) -> Poll<()> { - // Drafts 14-16 deliver the terminal message (UNSUBSCRIBE, PUBLISH_NAMESPACE_DONE) ahead of - // the FIN, so a waiting message that is not an update already withdraws the request. Their - // virtual writers are closed while the control request lives, so only the reader counts. - if matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) { - return match stream.reader.poll_varint_peek(cx) { - Poll::Ready(Ok(id)) if id == super::SubscribeUpdate::ID => Poll::Pending, - Poll::Ready(_) => Poll::Ready(()), - Poll::Pending => Poll::Pending, - }; - } if stream.writer.poll_closed(cx).is_ready() { return Poll::Ready(()); } @@ -84,83 +52,6 @@ pub(super) fn poll_withdrawn( } } -/// Poll a draft 14-16 virtual request stream until the requester ends the request. -/// -/// An update modifies the request rather than ending it, and the requests watched here -/// apply none, so each is refused with [`refuse_update`] and the request stays open. Any -/// other message is `Err(Cancel)`, and the stream finishing is `Ok(())`. -pub(super) fn poll_legacy_end( - stream: &mut Stream, - version: Version, - cx: &mut Context<'_>, -) -> Poll> { - loop { - // A refusal goes out before the next message is read. - ready!(stream.writer.poll_flush(cx))?; - match ready!(stream.reader.poll_decode_maybe::(cx))? { - Some(FollowUp::Update(body)) => refuse_update(&mut stream.writer, &body, version)?, - Some(FollowUp::End) => return Poll::Ready(Err(Error::Cancel)), - None => return Poll::Ready(Ok(())), - } - } -} - -/// Buffer the answer to a draft 14-16 update aimed at a request that takes none. -/// -/// Draft 14 answers no update. Drafts 15 and 16 answer each with exactly one REQUEST_OK or -/// REQUEST_ERROR naming the update's own Request ID, and a refusal leaves any request but a -/// subscription standing, so NOT_SUPPORTED is the whole answer. -pub(super) fn refuse_update( - writer: &mut crate::coding::Writer, - body: &super::Body, - version: Version, -) -> Result<(), Error> { - if version == Version::Draft14 { - return Ok(()); - } - let request_id = super::RequestId::decode(&mut body.decoder(version), version).map_err(DecodeError::complete)?; - writer.buffer_message( - super::RequestError::ID, - &super::RequestError { - request_id: Some(request_id), - error_code: super::error::request::to_code( - &Error::Unsupported, - super::error::request::Kind::Subscribe, - version, - ), - reason_phrase: "update not supported".into(), - retry_interval: 0, - }, - ) -} - -/// A message the adapter routed onto a draft 14-16 request after the request itself. -/// -/// Those drafts carry every request on the control stream, and the adapter delivers -/// each message to the request it names. -#[derive(Debug)] -pub(super) enum FollowUp { - /// SUBSCRIBE_UPDATE, or REQUEST_UPDATE on draft 16, still undecoded. - Update(super::Body), - /// UNSUBSCRIBE, FETCH_CANCEL, or any other message, which ends the request. - End, -} - -impl Decode for FollowUp { - fn decode(r: &mut Decoder<'_>, version: Version) -> Result { - let id = r.varint()?; - let update = id == super::SubscribeUpdate::ID; - let start = r.position(); - let body = super::Body::decode(r, version)?; - r.control = Some(super::message::control(id, version)); - r.uncounted = start; - Ok(match update { - true => Self::Update(body), - false => Self::End, - }) - } -} - /// One whole `[type][length][body]` message off a request stream, decoded at once so a read /// dropped part-way consumes nothing. #[derive(Debug)] @@ -171,14 +62,14 @@ impl Decode for Framed { let id = r.varint()?; let start = r.position(); let body = super::Body::decode(r, version)?; - r.control = Some(super::message::control(id, version)); + r.control = Some(super::message::control(id)); r.uncounted = start; Ok(Self(id, body)) } } -/// A message following the request on a request stream: `T`, or from draft 18 a GOAWAY -/// migrating this one request (draft-21 section 9.2). +/// A message following the request on a request stream: `T`, or a GOAWAY migrating this +/// one request (draft-21 section 9.2). #[derive(Debug)] pub(super) enum Next { Message(T), @@ -190,23 +81,18 @@ pub(super) enum Next { impl> Decode for Next { fn decode(r: &mut Decoder<'_>, version: Version) -> Result { - if !matches!( - version, - Version::Draft14 | Version::Draft15 | Version::Draft16 | Version::Draft17 - ) { - let mut peek = r.clone(); - if peek.varint()? == super::GoAway::ID { - *r = peek; - r.uncounted = r.position(); - let msg = super::GoAway::decode(r, version)?; - // Draft-18's Request ID belongs on the control stream only. - if msg.request_id.is_some() { - return Err(DecodeError::InvalidValue); - } - return Ok(Self::GoAway { - redirect: !msg.new_session_uri.is_empty(), - }); + let mut peek = r.clone(); + if peek.varint()? == super::GoAway::ID { + *r = peek; + r.uncounted = r.position(); + let msg = super::GoAway::decode(r, version)?; + // Draft-18's Request ID belongs on the control stream only. + if msg.request_id.is_some() { + return Err(DecodeError::InvalidValue); } + return Ok(Self::GoAway { + redirect: !msg.new_session_uri.is_empty(), + }); } T::decode(r, version).map(Self::Message) } @@ -325,33 +211,17 @@ pub(super) async fn reject( Ok(()) } -/// Write the error refusing a `kind` request with `err`, as the negotiated draft spells it. -/// -/// Each draft-14 error message has the REQUEST_ERROR body that draft-15 folded them into, so -/// only the message type changes; draft-17 then drops the Request ID. +/// Write the REQUEST_ERROR refusing a `kind` request with `err`. pub(super) async fn write_error( writer: &mut crate::coding::Writer, kind: super::error::request::Kind, - request_id: super::RequestId, err: &Error, reason: &str, version: Version, ) -> Result<(), Error> { - use super::error::request::Kind; - - let id = match (version, kind) { - (Version::Draft14, Kind::Subscribe) => super::SubscribeError::ID, - (Version::Draft14, Kind::Fetch) => super::FetchError::ID, - (Version::Draft14, Kind::Publish) => super::PublishError::ID, - (Version::Draft14, Kind::PublishNamespace) => super::PublishNamespaceError::ID, - (Version::Draft14, Kind::SubscribeNamespace) => super::SubscribeNamespaceError::ID, - (Version::Draft14, Kind::TrackStatus) => super::TRACK_STATUS_ERROR_14, - _ => super::RequestError::ID, - }; writer.buffer_message( - id, + super::RequestError::ID, &super::RequestError { - request_id: matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16).then_some(request_id), error_code: super::error::request::to_code(err, kind, version), reason_phrase: reason.into(), retry_interval: 0, @@ -363,7 +233,7 @@ pub(super) async fn write_error( /// A framed subscription update, preserving omitted preferences. #[derive(Debug)] pub(super) struct Update { - /// The first Request ID: the update's own on drafts 14-16, which their answer names. + /// The update's own Request ID. pub(super) request_id: super::RequestId, pub(super) priority: Option, pub(super) max_age: Option, @@ -374,7 +244,7 @@ pub(super) struct Update { pub(super) refused: Option, /// The AUTHORIZATION TOKEN renewing the request's credential. pub(super) authorization_token: Option, - /// NEW_GROUP_REQUEST (draft-15+), which only a track advertising DYNAMIC_GROUPS takes. + /// NEW_GROUP_REQUEST, which only a track advertising DYNAMIC_GROUPS takes. pub(super) new_group: Option, /// FORWARD, `None` when unchanged. pub(super) forward: Option, @@ -385,63 +255,14 @@ pub(super) struct Update { } impl Update { - /// Decode a draft 14-16 update the adapter routed onto its subscription. - pub(super) fn decode_legacy(body: &super::Body, version: Version) -> Result { - let mut data = body.decoder(version); - // The body is complete, so running short inside it is malformed. - Self::decode_body(&mut data, version) - .map_err(DecodeError::complete) - .map_err(Into::into) - } - /// Decode the message body, after its type and length. fn decode_body(data: &mut Decoder<'_>, version: Version) -> Result { - use super::{Fill, Filter, Location, Opaque, RequestId}; + use super::{Fill, Filter, Opaque, RequestId}; let request_id = RequestId::decode(data, version)?; - match version { - Version::Draft14 => { - // The subscription it updates, which the adapter already routed by. - RequestId::decode(data, version)?; - // The range is left as it is: every field is mandatory, so a narrowed range - // cannot be told from a repeated one, and draft 14 accepts extra objects as - // the worst outcome of an update. - Location::decode(data, version)?; - let _end_group = data.varint()?; - let priority = data.u8()?; - let forward = data.bool()?; - decode_params!(data, version, - 0x03 => tokens: Vec, - super::max_age::PARAMETER => max_age: Option, - ); - if !data.is_empty() { - return Err(DecodeError::InvalidValue); - } - let (refused, authorization_token) = Self::refused(tokens, false); - return Ok(Self { - request_id, - priority: Some(priority), - max_age: super::max_age::validate(max_age)?, - refused, - authorization_token, - new_group: None, - forward: Some(forward), - filter: None, - fill: None, - }); - } - // The request it updates, which the adapter already routed by. - Version::Draft15 | Version::Draft16 => { - RequestId::decode(data, version)?; - } - Version::Draft17 => { - data.varint()?; - } - _ => {} - } decode_params!(data, version, 0x02 => object_timeout: Option, 0x03 => token: Vec, - 0x06 => subgroup_timeout: Option where !matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16 | Version::Draft17), + 0x06 => subgroup_timeout: Option, 0x10 => forward: Option, 0x20 => priority: Option, 0x21 => filter: Option, @@ -451,7 +272,7 @@ impl Update { 0x27 => priority_filter: Vec where super::subscribe::has_range_filters(version), 0x28 => property_filter: Vec where super::subscribe::has_range_filters(version), 0x29 => track_filter: Vec where super::subscribe::has_range_filters(version), - 0x32 => new_group: Option where super::subscribe::has_new_group_request(version), + 0x32 => new_group: Option, super::max_age::PARAMETER => max_age: Option, ); if !data.is_empty() { @@ -503,7 +324,7 @@ impl Decode for Update { let mut data = r.sub(size)?; // The complete frame is present; a short field inside it is malformed. let update = Self::decode_body(&mut data, version).map_err(DecodeError::complete)?; - r.control = Some(super::message::control(super::SubscribeUpdate::ID, version)); + r.control = Some(super::message::control(super::SubscribeUpdate::ID)); r.uncounted = start; Ok(update) } @@ -557,7 +378,7 @@ impl Decode for NamespaceUpdate { }) }; let update = decode().map_err(DecodeError::complete)?; - r.control = Some(super::message::control(super::SubscribeUpdate::ID, version)); + r.control = Some(super::message::control(super::SubscribeUpdate::ID)); r.uncounted = start; Ok(update) } @@ -597,13 +418,10 @@ mod tests { let stats = registry.tier(Tier::default()).session(""); let version = Version::Draft22; let session = ScriptedSession::new(vec![0x10, 0, 2, 0, 0, 0x07, 0, 0]); - let mut stream = with_stats( - Stream::open(&mut crate::driver::Transport::new(session.clone()), version) - .await - .unwrap(), - &stats, - version, - ); + let mut stream = Stream::open(&mut crate::driver::Transport::new(session.clone()), version) + .await + .unwrap() + .with_stats(&stats); let mut messages = Messages::new(crate::driver::Transport::new(session.clone()), true); assert_eq!(messages.message(&mut stream.reader).await.unwrap().0, 0x07); let rx = |class| { @@ -652,65 +470,6 @@ mod tests { } } - /// On drafts 14-16 an update aimed at a request that applies none, such as a FETCH or - /// SUBSCRIBE_NAMESPACE, keeps the request open. Drafts 15 and 16 refuse it with a - /// REQUEST_ERROR naming the update, and a later cancellation still ends the request. - #[moq_clock::test] - async fn legacy_update_is_answered_without_ending_the_request() { - use crate::lite::test_transport::ScriptedSession; - - for version in [Version::Draft14, Version::Draft15, Version::Draft16] { - // Own Request ID 10, target 0, no parameters. Draft 14 carries its fixed start, - // end group, priority and forward first. - let body: &[u8] = match version { - Version::Draft14 => &[10, 0, 0, 0, 0, 128, 1, 0], - _ => &[10, 0, 0], - }; - let mut update = vec![super::super::SubscribeUpdate::ID as u8, 0, body.len() as u8]; - update.extend_from_slice(body); - let session = ScriptedSession::new(update); - let mut stream = Stream::open(&mut crate::driver::Transport::new(session.clone()), version) - .await - .unwrap(); - let mut finished = false; - let mut messages = Messages::new(crate::driver::Transport::new(session.clone()), false); - - let polled = futures::poll!(std::future::poll_fn(|cx| poll_cancel( - &mut stream, - &mut finished, - &mut messages, - version, - cx - ))); - assert!(polled.is_pending(), "{version}: the update ended the request"); - - let written = session.log.writes.lock().unwrap().clone(); - match version { - Version::Draft14 => assert!(written.is_empty(), "{version}: {written:?}"), - // [type, length (2), Request ID, NOT_SUPPORTED, ...] - _ => assert_eq!( - (written[0], written[3], written[4]), - (super::super::RequestError::ID as u8, 10, 0x3), - "{version}: {written:?}" - ), - } - - // UNSUBSCRIBE, or any message but an update, ends the request. - session.push(&[super::super::Unsubscribe::ID as u8, 0, 1, 0]); - let polled = futures::poll!(std::future::poll_fn(|cx| poll_cancel( - &mut stream, - &mut finished, - &mut messages, - version, - cx - ))); - assert!( - matches!(polled, Poll::Ready(Err(Error::Cancel))), - "{version}: {polled:?}" - ); - } - } - #[test] fn delivery_timeouts_on_subscription_updates_are_accepted() { for version in [Version::Draft18, Version::Draft21, Version::Draft22] { @@ -764,109 +523,4 @@ mod tests { assert_eq!(update.priority, Some(5)); assert!(update.refused.is_none()); } - - /// Draft-14's per-request error messages share REQUEST_ERROR's body, so the shared writer - /// must put the same bytes on the wire as each legacy message does. - #[moq_clock::test] - async fn draft14_errors_match_their_legacy_messages() { - use super::super::error::request::{Kind, to_code}; - use super::super::{ - FetchError, PublishError, PublishNamespaceError, RequestId, SubscribeError, SubscribeNamespaceError, - }; - use crate::lite::test_transport::{Log, SinkSend}; - - let version = Version::Draft14; - let (request_id, err, reason) = (RequestId(6), Error::NotFound, "gone"); - - for kind in [ - Kind::Subscribe, - Kind::Fetch, - Kind::Publish, - Kind::PublishNamespace, - Kind::SubscribeNamespace, - Kind::TrackStatus, - ] { - let shared = Log::default(); - let mut writer = crate::coding::Writer::new( - crate::transport::boxed::SendStream::new(SinkSend::new(shared.clone())), - version, - ); - write_error(&mut writer, kind, request_id, &err, reason, version) - .await - .unwrap(); - - let legacy = Log::default(); - let mut writer = crate::coding::Writer::new( - crate::transport::boxed::SendStream::new(SinkSend::new(legacy.clone())), - version, - ); - let error_code = to_code(&err, kind, version); - let reason_phrase = reason.into(); - match kind { - Kind::Subscribe => { - writer - .encode_message(&SubscribeError { - request_id, - error_code, - reason_phrase, - }) - .await - } - Kind::Fetch => { - writer - .encode_message(&FetchError { - request_id, - error_code, - reason_phrase, - }) - .await - } - Kind::Publish => { - writer - .encode_message(&PublishError { - request_id, - error_code, - reason_phrase, - }) - .await - } - Kind::PublishNamespace => { - writer - .encode_message(&PublishNamespaceError { - request_id, - error_code, - reason_phrase, - }) - .await - } - Kind::SubscribeNamespace => { - writer - .encode_message(&SubscribeNamespaceError { - request_id, - error_code, - reason_phrase, - }) - .await - } - // TRACK_STATUS_ERROR has the SUBSCRIBE_ERROR body under its own type. - Kind::TrackStatus => { - writer.buffer_varint(super::super::TRACK_STATUS_ERROR_14).unwrap(); - writer - .encode(&SubscribeError { - request_id, - error_code, - reason_phrase, - }) - .await - } - } - .unwrap(); - - assert_eq!( - *shared.writes.lock().unwrap(), - *legacy.writes.lock().unwrap(), - "{kind:?}" - ); - } - } } diff --git a/rs/moq-net/src/ietf/request_update.rs b/rs/moq-net/src/ietf/request_update.rs index cfba92c239e..e22740abd78 100644 --- a/rs/moq-net/src/ietf/request_update.rs +++ b/rs/moq-net/src/ietf/request_update.rs @@ -18,7 +18,7 @@ use std::{collections::VecDeque, task::Poll}; -use super::{RequestId, Version}; +use super::Version; use crate::{Error, SessionError, auth}; /// MAX_REQUEST_UPDATES Setup Option (Option Type 0x08). Even, so the value is a bare varint. @@ -42,7 +42,7 @@ pub const UNNEGOTIATED_GUARD: usize = 64; pub fn supported(version: Version) -> bool { !matches!( version, - Version::Draft14 | Version::Draft15 | Version::Draft16 | Version::Draft17 | Version::Draft18 + Version::Draft18 ) } @@ -53,7 +53,7 @@ pub fn supported(version: Version) -> bool { /// behind a pending verdict waits here until the verdict ahead of it resolves. The queue is /// bounded by MAX_REQUEST_UPDATES, counting the one being verified. pub(super) struct Renewal { - pending: Option<(auth::RequestVerdict, RequestId)>, + pending: Option, queued: VecDeque, } @@ -80,10 +80,10 @@ impl Renewal { self.pending.is_some() } - /// Wait on `verdict`, the renewal the update with `request_id` carried. - pub fn verify(&mut self, verdict: auth::RequestVerdict, request_id: RequestId) { + /// Wait on `verdict`, the renewal an update carried. + pub fn verify(&mut self, verdict: auth::RequestVerdict) { debug_assert!(self.pending.is_none(), "one renewal is verified at a time"); - self.pending = Some((verdict, request_id)); + self.pending = Some(verdict); } /// Queue `update` behind the pending verdict, counting it against the bound. @@ -111,16 +111,12 @@ impl Renewal { /// `Ready` with the pending verdict once it resolves. pub fn poll(&mut self, waiter: &kio::Waiter) -> Poll { - let Some((verdict, _)) = &self.pending else { + let Some(verdict) = &self.pending else { return Poll::Pending; }; let grant = std::task::ready!(verdict.poll_grant(waiter)); - let (verdict, request_id) = self.pending.take().expect("a pending renewal"); - Poll::Ready(Verdict { - verdict, - grant, - request_id, - }) + let verdict = self.pending.take().expect("a pending renewal"); + Poll::Ready(Verdict { verdict, grant }) } } @@ -130,8 +126,6 @@ pub(super) struct Verdict { pub verdict: auth::RequestVerdict, /// The acceptor's grant, or its refusal. pub grant: Result, - /// The update that carried the renewal, which the answer names before draft 17. - pub request_id: RequestId, } /// Close `session` for a peer past the MAX_REQUEST_UPDATES we advertised, returning the error @@ -170,10 +164,6 @@ mod tests { } for version in [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, ] { let mut params = super::super::Parameters::default(); diff --git a/rs/moq-net/src/ietf/session.rs b/rs/moq-net/src/ietf/session.rs index e1610b64efc..52ef8e767e3 100644 --- a/rs/moq-net/src/ietf/session.rs +++ b/rs/moq-net/src/ietf/session.rs @@ -10,7 +10,7 @@ use crate::{ }; use super::{ - Control, Message, Publisher, Subscriber, Version, active_count, adapter::ControlStreamAdapter, auth, cluster, + Control, Message, Publisher, Subscriber, Version, active_count, auth, cluster, epoch, hidden, max_age, peer, request_update, solicit, subscriber::is_protocol_violation, }; @@ -41,14 +41,7 @@ pub struct Config { pub session: Transport, - /// The bidi SETUP stream (draft-14 through draft-16 only). Draft-17+ passes `None` - /// and exchanges SETUP on uni streams instead. - pub setup: Option>, - - pub request_id_max: Option, - - /// What the peer may make this session hold. On drafts 14 to 16 it also sizes the - /// MAX_REQUEST_ID window advertised in our SETUP (see [`ietf::initial_max_request_id`]). + /// What the peer may make this session hold. pub limits: crate::session::Limits, /// Whether we dialed, which sets the request-id parity. @@ -102,12 +95,11 @@ pub struct Config { /// classified by the session before it accepts any more. pub early_unis: Vec>, - /// The extensions our SETUP offers. Drafts 14-16 already sent it, so there this only - /// records what it said. MoQ Auth is offered only while [`Self::auth`] supports it too. + /// The extensions our SETUP offers. MoQ Auth is offered only while [`Self::auth`] + /// supports it too. pub extensions: crate::setup::Extensions, - /// The Implementation our SETUP advertises (draft-17+), or `None` to omit it. Drafts - /// 14-16 already sent theirs on the bidi SETUP. + /// The Implementation our SETUP advertises, or `None` to omit it. pub implementation: Option, /// Where the implementation the peer's SETUP advertises is published, once the uni loop @@ -141,8 +133,6 @@ pub fn start(config: Config) -> Result<(Driver, crate::goaway::Handle), Error> { runtime, stats, mut session, - setup, - request_id_max, limits, client, publish, @@ -175,7 +165,7 @@ pub fn start(config: Config) -> Result<(Driver, crate::goaway::Handle), Error> { // sides learn their grant without waiting on the app. Draft-17+ only; the peer's // SETUP then decides whether it is ever sent. // A handle that already knows the peer declined (a gated server accept) skips it. - let setup_token = match auth::supported(version) && auth.supported() { + let setup_token = match auth.supported() { true => auth.present(bytes::Bytes::new(), true).ok(), false => None, }; @@ -199,13 +189,8 @@ pub fn start(config: Config) -> Result<(Driver, crate::goaway::Handle), Error> { // loop otherwise. let peer_setup = peer::PeerSetup::new(extensions).with_implementation(peer_implementation); let setup_read = peer_declared.is_some(); - match peer_declared { - Some(declared) => peer_setup.set(declared), - // A legacy caller that passed nothing (our own tests, and the lite paths): - // settle the slot rather than leave the announce loops waiting on a value - // that is never coming. - None if !cluster::supported(version) => peer_setup.set(peer::Peer::default()), - None => {} + if let Some(declared) = peer_declared { + peer_setup.set(declared); } let driver = async move { @@ -238,373 +223,202 @@ pub fn start(config: Config) -> Result<(Driver, crate::goaway::Handle), Error> { let announces = crate::session::Slots::new(limits.announces).with_stats(subscribe.stats(), crate::stats::Cap::Announces); - let res = match version { - Version::Draft14 | Version::Draft15 | Version::Draft16 => { - let Some(setup) = setup else { - let err = Error::ProtocolViolation; - session.close( - super::error::to_session_code(&SessionError::from(&err)), - "setup stream required", - ); - return Err(err); - }; - let control = Control::new(request_id_max, client).with_window(limits.window(), client, version); - let adapter = ControlStreamAdapter::new(session.clone(), control.clone(), version).with_stats(&stats); - // Boxed like a draft-17+ transport, so the publisher and subscriber below - // are the same instantiation as theirs. - let virtual_session = crate::driver::Transport::new(adapter.clone()); - - // No AUTH on these drafts, but a limit still reaches both halves. - let mut publisher = Publisher::new( - runtime.clone(), - virtual_session.clone(), - publish, - control.clone(), - peer_hop, - peer_setup.clone(), - version, - ) - .with_auth(auth.clone()); - let (tasks, mut task_set) = TaskSet::new(); - publisher.withdrawal = withdrawing.clone(); - publisher.owed = serving.clone(); - publisher.subscriptions = subscriptions; - - let mut subscriber = Subscriber::new( - runtime.clone(), - virtual_session.clone(), - subscribe, - control, - peer_hop, - peer_setup.clone(), - self_origin, - cost, - version, - tasks.clone(), - goaway.going_away.clone(), - ) - .with_auth(auth.clone()) - .with_solicit(extensions.solicit); - subscriber.announces = announces; - - // GOAWAY send task: draft-14-16 carry GOAWAY on the shared control - // stream. Parked on the drain trigger; races the transport close so - // a parked trigger never blocks the task set draining. - { - let mut session = session.clone(); - let adapter = adapter.clone(); - let goaway = goaway.clone(); - tasks.push(async move { - let payload = kio::wait(|waiter| { - let mut cx = waiter.context(); - if session.poll_closed(&mut cx).is_ready() { - return std::task::Poll::Ready(None); - } - goaway.poll_triggered(waiter) - }) - .await; - let Some(payload) = payload else { - return; - }; - let timeout_ms = payload.timeout.map(|d| d.as_millis() as u64).unwrap_or(0); - adapter.send_goaway(&payload.uri, timeout_ms, version); - }); - } - drop(tasks); - - let dispatch_session = virtual_session.clone(); - - // Every half only ends the session on error (err_only parks on clean - // completion); the task set draining is the one clean exit. - let mut adapter_run = std::pin::pin!(err_only(adapter.run(setup.reader, setup.writer, goaway.clone()))); - let mut unis = Unis::new( - virtual_session.clone(), - subscriber.clone(), - UniSetup { - peer: None, - read: false, - early: Vec::new(), - client, - version, - goaway, - }, - ); - let mut dispatch = std::pin::pin!(err_only(run_dispatch( - dispatch_session, - publisher.clone(), - subscriber.clone(), - peer_setup.clone(), - None, - version - ))); - let mut datagrams = - std::pin::pin!(err_only(run_datagrams(virtual_session.clone(), subscriber.clone()))); - // Unsolicited PUBLISH_NAMESPACE unless the peer requires solicitation; - // see `Publisher::run_publish_namespaces`. - let mut pub_ns_run = std::pin::pin!(err_only(publisher.clone().run_publish_namespaces())); - let sub_ns_run = run_namespaces(subscriber.clone(), discovery, { - let adapter = adapter.clone(); - move || { - let mut adapter = adapter.clone(); - async move { - match version { - Version::Draft16 => { - let (send, recv) = adapter.open_native_bi().await?; - let mut reader = crate::coding::Reader::new( - crate::transport::boxed::RecvStream::new(recv), - version, - ); - reader.set_priority(crate::priority::RECV_CONTROL); - Ok(Stream { - writer: crate::coding::Writer::new( - crate::transport::boxed::SendStream::new(send), - version, - ), - reader, - }) - } - _ => Stream::open_request(&mut crate::driver::Transport::new(adapter), version).await, - } - } - } - }); - let mut sub_ns_run = std::pin::pin!(err_only(sub_ns_run)); + let res = { + let control = Control::new(client); + // Send SETUP and retain its writer for the session's lifetime. Only a failure + // ends the session; the other branches report how it closed. + let setup = err_only(run_setup( + session.clone(), + version, + path, + authority, + implementation, + self_origin, + cost, + crate::setup::Extensions { + auth: extensions.auth && auth.supported(), + ..extensions + }, + goaway.clone(), + control.clone(), + stats.clone(), + )); - let res = kio::wait(|waiter| { - use std::task::Poll; - if let Poll::Ready(err) = waiter.poll_future(adapter_run.as_mut()) { - return Poll::Ready(Err::<(), Error>(err)); - } - if let Poll::Ready(res) = unis.poll(waiter) { - return Poll::Ready(res); - } - if let Poll::Ready(err) = waiter.poll_future(dispatch.as_mut()) { - return Poll::Ready(Err(err)); - } - if let Poll::Ready(err) = waiter.poll_future(datagrams.as_mut()) { - return Poll::Ready(Err(err)); - } - if task_set.poll(waiter).is_ready() { - return Poll::Ready(Ok(())); - } - if let Poll::Ready(err) = waiter.poll_future(sub_ns_run.as_mut()) { - return Poll::Ready(Err(err)); - } - if let Poll::Ready(err) = waiter.poll_future(pub_ns_run.as_mut()) { - return Poll::Ready(Err(err)); + let mut publisher = Publisher::new( + runtime.clone(), + session.clone(), + publish, + control.clone(), + peer_hop, + peer_setup.clone(), + version, + ) + .with_auth(auth.clone()); + let (tasks, mut task_set) = TaskSet::new(); + publisher.withdrawal = withdrawing.clone(); + publisher.owed = serving.clone(); + publisher.subscriptions = subscriptions; + + // Only the dialing side fails loud on a publication outside its grant: a + // server's publish origin is everything the peer may read, not what it + // intends to push. + let enforce = { + let auth = auth.clone(); + let publisher = publisher.clone(); + let session = session.clone(); + async move { + match client { + true => enforce_grant(auth, publisher, session).await, + false => std::future::pending().await, } - Poll::Pending - }) - .await; - close(&mut session, &res); - if !closing.is_local() { - kio::wait(|waiter| unis.poll_drain(waiter)).await; } - if closing.is_local() { - subscriber.close(); - } else if let Err(err) = &res { - // Every track this session was receiving ends with its error. - subscriber.abort(err); - } - res - } - _ => { - let control = Control::new(None, client).with_history(limits.window()); - // Send SETUP and retain its writer for the session's lifetime. Only a failure - // ends the session; the other branches report how it closed. - let setup = err_only(run_setup( - session.clone(), - version, - path, - authority, - implementation, - self_origin, - cost, - crate::setup::Extensions { - auth: extensions.auth && auth.supported(), - ..extensions - }, - goaway.clone(), - control.clone(), - stats.clone(), - )); - - let mut publisher = Publisher::new( - runtime.clone(), - session.clone(), - publish, - control.clone(), - peer_hop, - peer_setup.clone(), - version, - ) - .with_auth(auth.clone()); - let (tasks, mut task_set) = TaskSet::new(); - publisher.withdrawal = withdrawing.clone(); - publisher.owed = serving.clone(); - publisher.subscriptions = subscriptions; - - // Only the dialing side fails loud on a publication outside its grant: a - // server's publish origin is everything the peer may read, not what it - // intends to push. - let enforce = { - let auth = auth.clone(); - let publisher = publisher.clone(); - let session = session.clone(); - async move { - match client { - true => enforce_grant(auth, publisher, session).await, - false => std::future::pending().await, - } - } - }; + }; - let mut subscriber = Subscriber::new( - runtime.clone(), - session.clone(), - subscribe, - control.clone(), - peer_hop, - peer_setup.clone(), - self_origin, - cost, - version, - tasks, - goaway.going_away.clone(), - ) - .with_auth(auth.clone()) - .with_solicit(extensions.solicit); - - // Our tokens, one Auth request each, once the peer's SETUP negotiates it. - let present = auth::run_present( - runtime.clone(), - session.clone(), - control.clone(), - auth.clone(), - peer_setup.clone(), - version, - stats.clone(), - ); - // Only a side that offered MoQ Auth answers the peer's Auth requests: one that - // arrives otherwise falls through to the protocol violation in `run_dispatch`. - let serve = auth.supported().then(|| auth::Serve { - runtime: runtime.clone(), - handle: auth.clone(), - peer_grant, - }); - subscriber.announces = announces; - - // When the peer's SETUP was pre-read (a gated server accept), monitor - // GOAWAY on that stream here; otherwise `run_unis` does it when the SETUP - // arrives on the wire. - let goaway_recv = { - let goaway = goaway.clone(); - let stats = stats.clone(); - async move { - match peer_setup_stream { - Some(reader) => { - run_goaway(reader.with_stats(&stats).with_version(version), version, client, goaway) - .await - } - None => std::future::pending().await, + let mut subscriber = Subscriber::new( + runtime.clone(), + session.clone(), + subscribe, + control.clone(), + peer_hop, + peer_setup.clone(), + self_origin, + cost, + version, + tasks, + goaway.going_away.clone(), + ) + .with_auth(auth.clone()) + .with_solicit(extensions.solicit); + + // Our tokens, one Auth request each, once the peer's SETUP negotiates it. + let present = auth::run_present( + runtime.clone(), + session.clone(), + control.clone(), + auth.clone(), + peer_setup.clone(), + version, + stats.clone(), + ); + // Only a side that offered MoQ Auth answers the peer's Auth requests: one that + // arrives otherwise falls through to the protocol violation in `run_dispatch`. + let serve = auth.supported().then(|| auth::Serve { + runtime: runtime.clone(), + handle: auth.clone(), + peer_grant, + }); + subscriber.announces = announces; + + // When the peer's SETUP was pre-read (a gated server accept), monitor + // GOAWAY on that stream here; otherwise `run_unis` does it when the SETUP + // arrives on the wire. + let goaway_recv = { + let goaway = goaway.clone(); + let stats = stats.clone(); + async move { + match peer_setup_stream { + Some(reader) => { + run_goaway(reader.with_stats(&stats).with_version(version), version, client, goaway) + .await } + None => std::future::pending().await, } - }; + } + }; - // Every half only ends the session on error (err_only parks on clean - // completion); `setup` never resolves (it holds the stream open) and the - // task set draining is the one clean exit. - let mut unis = Unis::new( - session.clone(), - subscriber.clone(), - UniSetup { - peer: Some(peer_setup.clone()), - read: setup_read, - early: early_unis, - client, - version, - goaway, - }, - ); - let mut dispatch = std::pin::pin!(err_only(run_dispatch( - session.clone(), - publisher.clone(), - subscriber.clone(), - peer_setup.clone(), - serve, - version - ))); - let mut datagrams = std::pin::pin!(err_only(run_datagrams(session.clone(), subscriber.clone()))); - let mut goaway_recv = std::pin::pin!(err_only(goaway_recv)); - let mut present = std::pin::pin!(err_only(present)); - let mut enforce = std::pin::pin!(err_only(enforce)); - let mut setup = std::pin::pin!(setup); - // Unsolicited PUBLISH_NAMESPACE unless the peer requires solicitation; - // see `Publisher::run_publish_namespaces`. - let mut pub_ns_run = std::pin::pin!(err_only(publisher.clone().run_publish_namespaces())); - let sub_ns_run = run_namespaces(subscriber.clone(), discovery, { - let session = session.clone(); - move || { - let mut session = session.clone(); - async move { Stream::open_request(&mut session, version).await } - } - }); - let mut sub_ns_run = std::pin::pin!(err_only(sub_ns_run)); + // Every half only ends the session on error (err_only parks on clean + // completion); `setup` never resolves (it holds the stream open) and the + // task set draining is the one clean exit. + let mut unis = Unis::new( + session.clone(), + subscriber.clone(), + UniSetup { + peer: Some(peer_setup.clone()), + read: setup_read, + early: early_unis, + client, + version, + goaway, + }, + ); + let mut dispatch = std::pin::pin!(err_only(run_dispatch( + session.clone(), + publisher.clone(), + subscriber.clone(), + peer_setup.clone(), + serve, + version + ))); + let mut datagrams = std::pin::pin!(err_only(run_datagrams(session.clone(), subscriber.clone()))); + let mut goaway_recv = std::pin::pin!(err_only(goaway_recv)); + let mut present = std::pin::pin!(err_only(present)); + let mut enforce = std::pin::pin!(err_only(enforce)); + let mut setup = std::pin::pin!(setup); + // Unsolicited PUBLISH_NAMESPACE unless the peer requires solicitation; + // see `Publisher::run_publish_namespaces`. + let mut pub_ns_run = std::pin::pin!(err_only(publisher.clone().run_publish_namespaces())); + let sub_ns_run = run_namespaces(subscriber.clone(), discovery, { + let session = session.clone(); + move || { + let mut session = session.clone(); + async move { Stream::open_request(&mut session, version).await } + } + }); + let mut sub_ns_run = std::pin::pin!(err_only(sub_ns_run)); - let res = kio::wait(|waiter| { - use std::task::Poll; - if let Poll::Ready(res) = unis.poll(waiter) { - return Poll::Ready(res); - } - if let Poll::Ready(err) = waiter.poll_future(dispatch.as_mut()) { - return Poll::Ready(Err(err)); - } - if let Poll::Ready(err) = waiter.poll_future(datagrams.as_mut()) { - return Poll::Ready(Err(err)); - } - if let Poll::Ready(err) = waiter.poll_future(goaway_recv.as_mut()) { - return Poll::Ready(Err(err)); - } - // Malformed replies are session-fatal, unlike token refusals. - if let Poll::Ready(err) = waiter.poll_future(present.as_mut()) { - return Poll::Ready(Err(err)); - } - if let Poll::Ready(err) = waiter.poll_future(enforce.as_mut()) { - return Poll::Ready(Err(err)); - } - if let Poll::Ready(err) = waiter.poll_future(setup.as_mut()) { - return Poll::Ready(Err(err)); - } - if task_set.poll(waiter).is_ready() { - return Poll::Ready(Ok(())); - } - if let Poll::Ready(err) = waiter.poll_future(sub_ns_run.as_mut()) { - return Poll::Ready(Err(err)); - } - if let Poll::Ready(err) = waiter.poll_future(pub_ns_run.as_mut()) { - return Poll::Ready(Err(err)); - } - Poll::Pending - }) - .await; - close(&mut session, &res); - // Before this arm's Auth serve tasks drop, so each settles with the - // session's error rather than a bare cancel. - auth.close(match &res { - Ok(()) => Error::Cancel, - Err(err) => err.clone(), - }); - if !closing.is_local() { - kio::wait(|waiter| unis.poll_drain(waiter)).await; + let res = kio::wait(|waiter| { + use std::task::Poll; + if let Poll::Ready(res) = unis.poll(waiter) { + return Poll::Ready(res); } - if closing.is_local() { - subscriber.close(); - } else if let Err(err) = &res { - // Every track this session was receiving ends with its error. - subscriber.abort(err); + if let Poll::Ready(err) = waiter.poll_future(dispatch.as_mut()) { + return Poll::Ready(Err(err)); + } + if let Poll::Ready(err) = waiter.poll_future(datagrams.as_mut()) { + return Poll::Ready(Err(err)); + } + if let Poll::Ready(err) = waiter.poll_future(goaway_recv.as_mut()) { + return Poll::Ready(Err(err)); + } + // Malformed replies are session-fatal, unlike token refusals. + if let Poll::Ready(err) = waiter.poll_future(present.as_mut()) { + return Poll::Ready(Err(err)); } - res + if let Poll::Ready(err) = waiter.poll_future(enforce.as_mut()) { + return Poll::Ready(Err(err)); + } + if let Poll::Ready(err) = waiter.poll_future(setup.as_mut()) { + return Poll::Ready(Err(err)); + } + if task_set.poll(waiter).is_ready() { + return Poll::Ready(Ok(())); + } + if let Poll::Ready(err) = waiter.poll_future(sub_ns_run.as_mut()) { + return Poll::Ready(Err(err)); + } + if let Poll::Ready(err) = waiter.poll_future(pub_ns_run.as_mut()) { + return Poll::Ready(Err(err)); + } + Poll::Pending + }) + .await; + close(&mut session, &res); + // Before this arm's Auth serve tasks drop, so each settles with the + // session's error rather than a bare cancel. + auth.close(match &res { + Ok(()) => Error::Cancel, + Err(err) => err.clone(), + }); + if !closing.is_local() { + kio::wait(|waiter| unis.poll_drain(waiter)).await; } + if closing.is_local() { + subscriber.close(); + } else if let Err(err) = &res { + // Every track this session was receiving ends with its error. + subscriber.abort(err); + } + res }; auth.close(match &res { @@ -772,14 +586,14 @@ pub(crate) fn decode_peer_setup( /// a future option reaches both the pre-read accept path and the uni loop. fn peer_from_params(params: &ietf::Parameters, version: Version) -> Result { Ok(peer::Peer { - cluster: cluster::peer_from_setup(params, version)?, + cluster: cluster::peer_from_setup(params)?, solicit: solicit::from_setup(params, version)?, hidden: hidden::from_setup(params, version), max_age: max_age::from_setup(params, version), - auth: auth::from_setup(params, version) == Some(true), - active_count: active_count::from_setup(params, version), - epoch: epoch::from_setup(params, version), - flate: super::flate::from_setup(params, version)?, + auth: auth::from_setup(params) == Some(true), + active_count: active_count::from_setup(params), + epoch: epoch::from_setup(params), + flate: super::flate::from_setup(params)?, }) } @@ -826,21 +640,21 @@ async fn run_setup( if let Some(authority) = authority { parameters.set_bytes(ietf::ParameterBytes::Authority, authority.into_bytes()); } - cluster::peer_into_setup(&mut parameters, self_origin, cost, version); + cluster::peer_into_setup(&mut parameters, self_origin, cost); if extensions.solicit { solicit::into_setup(&mut parameters, version); } hidden::into_setup(&mut parameters, version); max_age::into_setup(&mut parameters, version); if extensions.auth { - auth::into_setup(&mut parameters, version); + auth::into_setup(&mut parameters); } - active_count::into_setup(&mut parameters, version); + active_count::into_setup(&mut parameters); if extensions.epoch { - epoch::into_setup(&mut parameters, version); + epoch::into_setup(&mut parameters); } request_update::into_setup(&mut parameters, version); - super::flate::into_setup(&mut parameters, version); + super::flate::into_setup(&mut parameters); let parameters = parameters.encode_bytes(version)?; writer @@ -927,7 +741,7 @@ impl UniType { // 0x40 (FIRST_OBJECT), also covering 0x50-0x5D and 0x70-0x7D. A reserved // SUBGROUP_ID_MODE (0b11) or a bit the draft lacks is invalid, which MUST close the // session too (draft-21 section 11.3.1). - if ietf::GroupFlags::decode(kind, version).is_ok() { + if ietf::GroupFlags::decode(kind).is_ok() { return Some(Self::Subgroup); } @@ -935,13 +749,9 @@ impl UniType { FetchHeader::TYPE => Some(Self::Fetch), setup::SETUP_V17 => match version { // SETUP rides the bidi control stream. - Version::Draft14 | Version::Draft15 | Version::Draft16 => None, _ => Some(Self::Setup), }, - PADDING => match version { - Version::Draft14 | Version::Draft15 | Version::Draft16 | Version::Draft17 => None, - _ => Some(Self::Padding), - }, + PADDING => Some(Self::Padding), _ => None, } } @@ -1307,7 +1117,7 @@ struct Bidi { impl Bidi { /// Read and serve a request, failing only when it breaks the session. async fn serve(self, mut stream: Stream) -> Result<(), Error> { - stream = super::request_stream::with_stats(stream, self.publisher.stats(), self.version); + stream = stream.with_stats(self.publisher.stats()); let Self { publisher, mut subscriber, @@ -1337,27 +1147,21 @@ impl Bidi { } Err(err) => return Err(err), }; - let native = !matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) - || (version == Version::Draft16 && id == ietf::SubscribeNamespaceLegacy::ID); - if native { - stream.reader = stream.reader.with_stats(publisher.stats()); - publisher - .stats() - .control(super::message::control(id, version), data.0.len() + 2, true); - } - if !matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) - && matches!( - id, - ietf::Subscribe::ID - | ietf::Fetch::ID - | ietf::SubscribeNamespace::ID - | ietf::SubscribeNamespaceLegacy::ID - | ietf::SubscribeTracks::ID - | ietf::TrackStatus::ID - | ietf::Publish::ID - | ietf::PublishNamespace::ID - | auth::Auth::ID - ) { + stream.reader = stream.reader.with_stats(publisher.stats()); + publisher + .stats() + .control(super::message::control(id), data.0.len() + 2, true); + if matches!( + id, + ietf::Subscribe::ID + | ietf::Fetch::ID + | ietf::SubscribeNamespace::ID + | ietf::SubscribeTracks::ID + | ietf::TrackStatus::ID + | ietf::Publish::ID + | ietf::PublishNamespace::ID + | auth::Auth::ID + ) { let request_id = RequestId::decode(&mut data.decoder(version), version)?; match publisher.control.accept(request_id) { Err(Error::GoingAway) => return refuse_going_away(stream, id, version).await, @@ -1367,22 +1171,10 @@ impl Bidi { } } match id { - // Draft-16 moved SUBSCRIBE_NAMESPACE to its own stream, past the control stream - // that admits every other request, but it still takes a request ID from the - // MAX_REQUEST_ID window. Held until the request ends, like the rest. - ietf::SubscribeNamespaceLegacy::ID if version == Version::Draft16 => { - let request_id = RequestId::decode(&mut crate::coding::Decoder::new(&data.0, version.into()), version)?; - let permit = publisher.control.accept(request_id)?; - let task = publisher.handle_stream(id, data, stream, epoch)?; - let _permit = permit; - task.await; - } - // Publisher handles: Subscribe, Fetch, SubscribeNamespace (0x50 modern / - // 0x11 legacy), SubscribeTracks, TrackStatus + // Publisher handles: Subscribe, Fetch, SubscribeNamespace, SubscribeTracks, TrackStatus ietf::Subscribe::ID | ietf::Fetch::ID | ietf::SubscribeNamespace::ID - | ietf::SubscribeNamespaceLegacy::ID | ietf::SubscribeTracks::ID | ietf::TrackStatus::ID => { publisher.handle_stream(id, data, stream, epoch)?.await; @@ -1417,7 +1209,6 @@ async fn refuse_going_away(stream: Stream, id: u64, version: super::request_stream::reject( stream, ietf::RequestError { - request_id: None, error_code: super::error::request::to_code( &Error::GoingAway, super::error::request::Kind::Subscribe, @@ -1550,7 +1341,7 @@ mod tests { /// is not UTF-8 refuses the SETUP. #[test] fn peer_setup_reads_the_implementation() { - for version in [Version::Draft17, Version::Draft22] { + for version in [Version::Draft22] { let encode = |value: Option<&[u8]>| { let mut params = ietf::Parameters::default(); if let Some(value) = value { @@ -1569,21 +1360,13 @@ mod tests { #[moq_clock::test] async fn announce_interest_without_credit_keeps_the_session_alive() { use std::sync::atomic::Ordering; - for version in [Version::Draft16, Version::Draft17, Version::Draft19] { + for version in [Version::Draft19] { let origin = origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let interest = origin.consume().announced(); let session = crate::lite::test_transport::ScriptedSession::new(Vec::new()).without_credit(); let log = session.log.clone(); let mut session = crate::driver::Transport::new(session); - let setup = if version == Version::Draft16 { - Some( - Stream::open(&mut session, version) - .await - .expect("setup waits for credit"), - ) - } else { - None - }; + let setup = None; let (driver, _goaway) = start(Config { runtime: crate::time::sim(), stats: Default::default(), @@ -1636,7 +1419,6 @@ mod tests { #[moq_clock::test] async fn auth_ids_share_the_modern_request_history() { for version in [ - Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft20, @@ -1730,7 +1512,7 @@ mod tests { #[moq_clock::test] async fn malformed_auth_replies_close_the_session() { - for version in [Version::Draft17, Version::Draft22] { + for version in [Version::Draft22] { for (id, body) in [ (99, vec![]), (auth::AuthError::ID, vec![0xc0, 0, 0, 1, 0, 0, 0, 0, 0]), @@ -1784,7 +1566,7 @@ mod tests { #[moq_clock::test] async fn malformed_presenter_auth_closes_the_session() { - for version in [Version::Draft17, Version::Draft22] { + for version in [Version::Draft22] { for body in [vec![0, 2], vec![0, 0, 0]] { let mut script = Vec::new(); let mut encoder = crate::coding::Encoder::new(&mut script, version.into()); @@ -1863,7 +1645,6 @@ mod tests { writer .encode(&ietf::RequestOk { largest: None, - request_id: None, active: None, }) .await @@ -2074,14 +1855,7 @@ mod tests { ) { let log = session.log.clone(); let mut session = crate::driver::Transport::new(session); - let setup = match version { - Version::Draft14 | Version::Draft15 | Version::Draft16 => Some( - Stream::open(&mut session, version) - .await - .expect("open the control stream"), - ), - _ => None, - }; + let setup = None; let (driver, _goaway) = start(Config { runtime: crate::time::sim(), @@ -2142,7 +1916,7 @@ mod tests { /// A client asks nothing until something is watched, then only about what is. #[moq_clock::test] async fn a_client_asks_only_about_what_is_watched() { - for version in [Version::Draft14, Version::Draft15, Version::Draft16, Version::Draft17] { + for version in [Version::Draft15] { let subscribe = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let (log, _driver) = client(version, subscribe.clone(), Some(true)).await; let first = subscribe_namespace_legacy(version, "cam", RequestId(0)).await; @@ -2166,7 +1940,7 @@ mod tests { /// names the prefix on draft-14 and the request on draft-15. #[moq_clock::test] async fn an_unwatched_prefix_is_unsubscribed_after_the_linger() { - for version in [Version::Draft14, Version::Draft15] { + for version in [Version::Draft15] { let subscribe = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let cam = watch(&subscribe, "cam"); let (log, _driver) = client(version, subscribe.clone(), None).await; @@ -2190,7 +1964,7 @@ mod tests { /// goes out on the ordered control stream ahead of the broader SUBSCRIBE_NAMESPACE. #[moq_clock::test] async fn a_broader_watch_replaces_the_narrower_at_a_foreign_peer() { - for version in [Version::Draft14, Version::Draft15] { + for version in [Version::Draft15] { let subscribe = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let _front = watch(&subscribe, "cam/front"); let (log, _driver) = client(version, subscribe.clone(), None).await; @@ -2216,8 +1990,6 @@ mod tests { #[moq_clock::test] async fn a_broader_watch_waits_for_the_narrower_to_leave_the_wire() { for version in [ - Version::Draft16, - Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft22, @@ -2246,7 +2018,7 @@ mod tests { /// broader request that replaced it goes out alone once the credit arrives. #[moq_clock::test] async fn a_request_ended_before_it_opened_does_not_block_the_broader_one() { - for version in [Version::Draft16, Version::Draft17, Version::Draft22] { + for version in [Version::Draft22] { let subscribe = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let gate = kio::Producer::new(true); let credit = kio::Producer::new(true); @@ -2277,7 +2049,7 @@ mod tests { /// routes over before it has synced. #[moq_clock::test] async fn a_broader_watch_keeps_the_narrower_open_at_our_peer() { - for version in [Version::Draft14, Version::Draft15, Version::Draft16, Version::Draft17] { + for version in [Version::Draft15] { let subscribe = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let _front = watch(&subscribe, "cam/front"); let (log, _driver) = client(version, subscribe.clone(), Some(true)).await; @@ -2288,9 +2060,6 @@ mod tests { let broader = subscribe_namespace_legacy(version, "cam", RequestId(2)).await; assert!(sent(&log, &broader).await, "{version:?} never asked the broader prefix"); let ended = match version { - Version::Draft14 | Version::Draft15 => { - occurrences(&log, &unsubscribe_namespace(version, "cam/front", RequestId(0)).await) > 0 - } _ => log .trail() .iter() @@ -2307,7 +2076,7 @@ mod tests { /// gets the empty prefix. Draft-16 made the empty prefix legal, so it stays. #[moq_clock::test] async fn an_empty_namespace_is_not_asked_of_a_foreign_peer_before_draft_16() { - for version in [Version::Draft14, Version::Draft15] { + for version in [Version::Draft15] { assert_eq!( asked_namespace(version, "", None).await, 0, @@ -2578,7 +2347,7 @@ mod tests { let (setup, _) = setup::Setup::decode_slice(&writes, crate::Version::Ietf(VERSION)).expect("our SETUP"); let (params, _) = ietf::Parameters::decode_slice(&setup.parameters, VERSION).expect("its options"); ( - auth::from_setup(¶ms, VERSION) == Some(true), + auth::from_setup(¶ms) == Some(true), solicit::from_setup(¶ms, VERSION).unwrap() == Some(true), ) } @@ -3186,7 +2955,6 @@ mod tests { #[moq_clock::test] async fn an_unknown_bidi_type_closes_the_session() { for version in [ - Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft20, @@ -3350,7 +3118,6 @@ mod tests { let log = crate::lite::test_transport::Log::default(); let mut writer = crate::coding::Writer::new( crate::transport::boxed::SendStream::new(crate::lite::test_transport::SinkSend::new(log.clone())), - Version::Draft14, ); writer.varint(ietf::PublishNamespaceOk::ID).await.unwrap(); @@ -3447,11 +3214,6 @@ mod tests { let mut body = Vec::new(); let mut w = crate::coding::Encoder::new(&mut body, version.into()); match version { - Version::Draft14 => { - msg.encode_msg(&mut w, version).unwrap(); - // Replace the empty parameter block with the token. - assert_eq!(body.pop(), Some(0)); - } // The request ID, namespace and name; every parameter but the token defaults. _ => w.slice(&[0, 1, 4, b'r', b'o', b'o', b'm', 5, b'v', b'i', b'd', b'e', b'o']), } @@ -3473,7 +3235,7 @@ mod tests { /// request on the control stream, a strict draft on its own stream. #[moq_clock::test] async fn a_request_token_that_cannot_be_used_closes_the_session() { - for version in [Version::Draft14, Version::Draft22] { + for version in [Version::Draft22] { for (token, expected, why) in [ ( &[0x01, 0x07, 0x00][..], @@ -3495,21 +3257,13 @@ mod tests { ] { let payload = subscribe_with_token(version, token); let session = match version { - Version::Draft14 => crate::lite::test_transport::ScriptedSession::new(payload), _ => { crate::lite::test_transport::ScriptedSession::new(Vec::new()).with_incoming_bidis(vec![payload]) } }; let log = session.log.clone(); let session = crate::driver::Transport::new(session.clone()); - let setup = match version { - Version::Draft14 => Some( - Stream::open(&mut crate::driver::Transport::new(session.clone()), version) - .await - .unwrap(), - ), - _ => None, - }; + let setup = None; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let (driver, _goaway) = start(Config { runtime: crate::time::sim(), @@ -3686,7 +3440,7 @@ mod tests { #[moq_clock::test] async fn a_control_stream_fin_or_reset_is_a_protocol_violation() { use crate::lite::test_transport::{Close, DeadStreamSession, ScriptedSession}; - for version in [Version::Draft17, Version::Draft18, Version::Draft21, Version::Draft22] { + for version in [Version::Draft18, Version::Draft21, Version::Draft22] { let session = ScriptedSession::new(Vec::new()).with_incoming_unis(vec![setup_stream( version, ietf::Parameters::default(), diff --git a/rs/moq-net/src/ietf/solicit.rs b/rs/moq-net/src/ietf/solicit.rs index b1c07d55817..d5df9c12976 100644 --- a/rs/moq-net/src/ietf/solicit.rs +++ b/rs/moq-net/src/ietf/solicit.rs @@ -57,7 +57,7 @@ mod tests { /// Options: an old peer can opt out too. #[test] fn every_version_round_trips() { - for version in [Version::Draft14, Version::Draft15, Version::Draft16, Version::Draft20] { + for version in [Version::Draft20] { let mut params = super::super::Parameters::default(); into_setup(&mut params, version); assert_eq!(from_setup(¶ms, version).unwrap(), Some(true)); diff --git a/rs/moq-net/src/ietf/subscribe.rs b/rs/moq-net/src/ietf/subscribe.rs index 1a6e1d60725..2f98c38b393 100644 --- a/rs/moq-net/src/ietf/subscribe.rs +++ b/rs/moq-net/src/ietf/subscribe.rs @@ -1,11 +1,11 @@ -//! IETF moq-transport subscribe messages (v14 + v15) +//! IETF moq-transport subscribe messages use std::borrow::Cow; use crate::{ Path, coding::*, - ietf::{Fill, Filter, GroupOrder, Location, Opaque, Parameters, Properties, RequestId}, + ietf::{Fill, Filter, GroupOrder, Location, Opaque, Properties, RequestId}, }; use super::token::RequestToken; @@ -42,26 +42,21 @@ pub struct Subscribe<'a> { /// The `AUTHORIZATION TOKEN` (0x03) this request presents. At most one is /// accepted: decoding refuses a repeated or second token. pub authorization_token: Option, - /// NEW_GROUP_REQUEST (0x32, draft-15+): the subscriber's largest known Group ID plus - /// one, or 0 when it knows none. Never encoded where the draft has no such parameter. + /// NEW_GROUP_REQUEST (0x32): the subscriber's largest known Group ID plus one, or 0 + /// when it knows none. pub new_group: Option, /// Subscriber max age in milliseconds (MoQ Timestamp), if negotiated. pub max_age: Option, - /// The publisher instance the subscriber expects (MoQ Epoch, draft-17+). Only on a + /// The publisher instance the subscriber expects (MoQ Epoch). Only on a /// session that negotiated it; the session refuses one that arrives otherwise. pub epoch: Option, } -/// NEW_GROUP_REQUEST (0x32) and DYNAMIC_GROUPS (0x30) arrived in draft-15. -pub(super) fn has_new_group_request(version: Version) -> bool { - version != Version::Draft14 -} - /// The Range Filters (0x25-0x29) arrived in draft-19. pub(super) fn has_range_filters(version: Version) -> bool { !matches!( version, - Version::Draft14 | Version::Draft15 | Version::Draft16 | Version::Draft17 | Version::Draft18 + Version::Draft18 ) } @@ -70,158 +65,99 @@ impl Message for Subscribe<'_> { fn decode_msg(r: &mut Decoder<'_>, version: Version) -> Result { let request_id = RequestId::decode(r, version)?; - if version == Version::Draft17 { - let _required_request_id_delta = r.varint()?; - } let (track_namespace, track_name) = decode_track(r)?; let track_name = Cow::Owned(track_name); - match version { - Version::Draft14 => { - let subscriber_priority = r.u8()?; - let group_order = GroupOrder::decode(r, version)?; - - let forward = r.bool()?; - let filter = Filter::decode(r, version)?; - - decode_params!(r, version, - 0x03 => tokens: Vec, - super::max_age::PARAMETER => max_age: Option, - ); - let authorization_token = super::token::single(tokens)?; - - Ok(Self { - request_id, - track_namespace, - track_name, - subscriber_priority, - group_order, - filter, - fill: None, - properties_wanted: true, - forward, - rendezvous: false, - range_filters: false, - authorization_token, - new_group: None, - max_age: super::max_age::validate(max_age)?, - epoch: None, - }) - } - _ => { - decode_params!(r, version, - 0x02 => _object_delivery_timeout: Option, - 0x03 => authorization_token: Vec, - // 0x04 is MAX_CACHE_DURATION in draft-15 (a publisher parameter) and not a - // message parameter at all in draft-16. RENDEZVOUS_TIMEOUT arrives in draft-17. - 0x04 => rendezvous_timeout: Option where !matches!(version, Version::Draft15 | Version::Draft16), - 0x06 => _subgroup_delivery_timeout: Option where !matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16 | Version::Draft17), - 0x10 => forward: Option, - 0x20 => subscriber_priority: Option, - 0x21 => filter: Option, - 0x22 => group_order: Option, - 0x23 => fill: Option where Filter::is_draft20(version), - 0x25 => subgroup_filter: Vec where has_range_filters(version), - 0x26 => object_id_filter: Vec where has_range_filters(version), - 0x27 => priority_filter: Vec where has_range_filters(version), - 0x28 => object_property_filter: Vec where has_range_filters(version), - 0x32 => new_group: Option where has_new_group_request(version), - 0x35 => include_properties: Option where Filter::is_draft20(version), - epoch::EPOCH_PARAM => epoch: Option where epoch::supported(version), - super::max_age::PARAMETER => max_age: Option, - ); - let authorization_token = super::token::single(authorization_token)?; - - let range_filters = [ - subgroup_filter, - object_id_filter, - priority_filter, - object_property_filter, - ] - .iter() - .any(|filter| !filter.is_empty()); - - // Defaults to 1, so an absent parameter means the subscriber wants them. - let properties_wanted = include_properties.unwrap_or(true); - - // A zero cap still distinguishes a requested wait from an immediate miss. - let rendezvous = rendezvous_timeout.is_some_and(|millis| millis > 0); - - let subscriber_priority = subscriber_priority.unwrap_or(super::priority::DEFAULT_WIRE); - let group_order = group_order.unwrap_or(GroupOrder::Descending); - // An absent LOCATION_FILTER means the subscription is unfiltered. - let filter = filter.unwrap_or(Filter::Unfiltered); - - Ok(Self { - request_id, - track_namespace, - track_name, - subscriber_priority, - group_order, - filter, - fill, - properties_wanted, - // Absent means 1. - forward: forward.unwrap_or(true), - rendezvous, - range_filters, - authorization_token, - new_group, - max_age: super::max_age::validate(max_age)?, - epoch, - }) - } - } + decode_params!(r, version, + 0x02 => _object_delivery_timeout: Option, + 0x03 => authorization_token: Vec, + 0x04 => rendezvous_timeout: Option, + 0x06 => _subgroup_delivery_timeout: Option, + 0x10 => forward: Option, + 0x20 => subscriber_priority: Option, + 0x21 => filter: Option, + 0x22 => group_order: Option, + 0x23 => fill: Option where Filter::is_draft20(version), + 0x25 => subgroup_filter: Vec where has_range_filters(version), + 0x26 => object_id_filter: Vec where has_range_filters(version), + 0x27 => priority_filter: Vec where has_range_filters(version), + 0x28 => object_property_filter: Vec where has_range_filters(version), + 0x32 => new_group: Option, + 0x35 => include_properties: Option where Filter::is_draft20(version), + epoch::EPOCH_PARAM => epoch: Option, + super::max_age::PARAMETER => max_age: Option, + ); + let authorization_token = super::token::single(authorization_token)?; + + let range_filters = [ + subgroup_filter, + object_id_filter, + priority_filter, + object_property_filter, + ] + .iter() + .any(|filter| !filter.is_empty()); + + // Defaults to 1, so an absent parameter means the subscriber wants them. + let properties_wanted = include_properties.unwrap_or(true); + + // A zero cap still distinguishes a requested wait from an immediate miss. + let rendezvous = rendezvous_timeout.is_some_and(|millis| millis > 0); + + let subscriber_priority = subscriber_priority.unwrap_or(super::priority::DEFAULT_WIRE); + let group_order = group_order.unwrap_or(GroupOrder::Descending); + // An absent LOCATION_FILTER means the subscription is unfiltered. + let filter = filter.unwrap_or(Filter::Unfiltered); + + Ok(Self { + request_id, + track_namespace, + track_name, + subscriber_priority, + group_order, + filter, + fill, + properties_wanted, + // Absent means 1. + forward: forward.unwrap_or(true), + rendezvous, + range_filters, + authorization_token, + new_group, + max_age: super::max_age::validate(max_age)?, + epoch, + }) } fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { self.request_id.encode(w, version)?; - if version == Version::Draft17 { - w.varint(0)?; // required_request_id_delta = 0 (draft-17 only, removed in draft-18 per #1615) - } encode_namespace(w, &self.track_namespace)?; w.string(&self.track_name)?; - match version { - Version::Draft14 => { - w.u8(self.subscriber_priority); - self.group_order.encode(w, version)?; - w.bool(self.forward); + // FILL_PARAMETERS arrived in draft-20. Sending it to an older peer would be an + // unknown parameter, which is a protocol violation, so it is dropped instead. + // A subscriber there simply joins mid-group, which is what it did all along. + let fill = self.fill.filter(|_| Filter::is_draft20(version)); - self.filter.encode(w, version)?; - encode_params!(w, version, - 0x03 => self.authorization_token.clone(), - super::max_age::PARAMETER => self.max_age, - ); - } - _ => { - // FILL_PARAMETERS arrived in draft-20. Sending it to an older peer would be an - // unknown parameter, which is a protocol violation, so it is dropped instead. - // A subscriber there simply joins mid-group, which is what it did all along. - let fill = self.fill.filter(|_| Filter::is_draft20(version)); - - // INCLUDE_PROPERTIES defaults to 1, so only the opt-out is worth bytes. It - // arrived in draft-20, and an older peer would read it as an unknown - // parameter, which is a protocol violation. - let include_properties = (!self.properties_wanted && Filter::is_draft20(version)).then_some(false); - let new_group = self.new_group.filter(|_| has_new_group_request(version)); - // Only a session that negotiated MoQ Epoch names one, and it exists from draft-17. - let epoch = self.epoch.clone().filter(|_| epoch::supported(version)); - - encode_params!(w, version, - 0x03 => self.authorization_token.clone(), - 0x10 => self.forward, - 0x20 => self.subscriber_priority, - 0x21 => self.filter, - 0x22 => self.group_order, - 0x23 => fill, - 0x32 => new_group, - 0x35 => include_properties, - epoch::EPOCH_PARAM => epoch, - super::max_age::PARAMETER => self.max_age, - ); - } - } + // INCLUDE_PROPERTIES defaults to 1, so only the opt-out is worth bytes. It + // arrived in draft-20, and an older peer would read it as an unknown + // parameter, which is a protocol violation. + let include_properties = (!self.properties_wanted && Filter::is_draft20(version)).then_some(false); + // Only a session that negotiated MoQ Epoch names one. + let epoch = self.epoch.clone(); + + encode_params!(w, version, + 0x03 => self.authorization_token.clone(), + 0x10 => self.forward, + 0x20 => self.subscriber_priority, + 0x21 => self.filter, + 0x22 => self.group_order, + 0x23 => fill, + 0x32 => self.new_group, + 0x35 => include_properties, + epoch::EPOCH_PARAM => epoch, + super::max_age::PARAMETER => self.max_age, + ); Ok(()) } @@ -230,14 +166,13 @@ impl Message for Subscribe<'_> { /// SubscribeOk message (0x04) #[derive(Clone, Debug)] pub struct SubscribeOk { - pub request_id: Option, pub track_alias: u64, /// The largest Location in the track (LARGEST_OBJECT, 0x09), which the spec requires /// once the track has content. It is what a subscriber sizes a fill against. pub largest: Option, - /// Metadata about the track, sent as Track Properties (draft-17+). + /// Metadata about the track, sent as Track Properties. pub properties: Properties, } @@ -245,113 +180,34 @@ impl Message for SubscribeOk { const ID: u64 = 0x04; fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { - if matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) { - self.request_id - .expect("request_id required for draft14-16") - .encode(w, version)?; - } else { - assert!(self.request_id.is_none(), "request_id must be None for draft17+"); - } w.varint(self.track_alias)?; - match version { - Version::Draft14 => { - w.varint(0)?; // expires = 0 - self.properties - .group_order - .unwrap_or(GroupOrder::Ascending) - .encode(w, version)?; - w.bool(self.largest.is_some()); - if let Some(largest) = self.largest { - largest.encode(w, version)?; - } - w.u8(0); // no parameters - } - _ => { - // GROUP_ORDER is a legal SUBSCRIBE_OK parameter only through draft-15; a later - // peer closes the session with PROTOCOL_VIOLATION when it sees one. The - // publisher's preference is a DEFAULT_PUBLISHER_GROUP_ORDER track property - // instead, which we write from draft-17 on. Draft-16 gets neither form; see - // Properties::encode. - let group_order = match version { - Version::Draft15 => self.properties.group_order, - _ => None, - }; - // Draft-15 has no properties block, so DYNAMIC_GROUPS is a parameter there. - let dynamic_groups = (version == Version::Draft15 && self.properties.dynamic_groups).then_some(1u64); + // GROUP_ORDER is not a legal SUBSCRIBE_OK parameter; a peer closes the session with + // PROTOCOL_VIOLATION when it sees one. The publisher's preference is a + // DEFAULT_PUBLISHER_GROUP_ORDER track property instead. + encode_params!(w, version, + 0x09 => self.largest, + ); - encode_params!(w, version, - 0x09 => self.largest, - 0x22 => group_order, - 0x30 => dynamic_groups, - ); - - // Track Properties are the final field, so nothing may follow. - self.properties.encode(w, version)?; - } - } + // Track Properties are the final field, so nothing may follow. + self.properties.encode(w, version)?; Ok(()) } fn decode_msg(r: &mut Decoder<'_>, version: Version) -> Result { - let request_id = if matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) { - Some(RequestId::decode(r, version)?) - } else { - None - }; let track_alias = r.varint()?; - let mut properties = Properties::default(); - let mut largest = None; - match version { - Version::Draft14 => { - // EXPIRES is when the publisher expects to end the subscription. That end - // arrives as PUBLISH_DONE regardless, so there is nothing to act on. - let _expires = r.varint()?; - - properties.group_order = Some(GroupOrder::decode(r, version)?.any_to_descending()); - - if r.bool()? { - largest = Some(Location::decode(r, version)?); - } - - properties.max_cache_duration = Parameters::skip_response(r)?.map(std::time::Duration::from_millis); - } - _ => { - // GROUP_ORDER and MAX_CACHE_DURATION are legal here only in draft-15. Draft-16 - // still knows GROUP_ORDER, so one on this message is ignored. From draft-17 - // it closes the session. LARGEST_OBJECT is required once the track has - // content, so rejecting it would tear down a session over a parameter - // compliant publishers must send. EXPIRES is ignored, as on draft-14. - decode_params!(r, version, - 0x04 => max_cache_duration: Option where version == Version::Draft15, - 0x08 => _expires: Option, - 0x09 => largest: Option, - 0x22 => group_order: Option where version == Version::Draft15, - 0x30 => dynamic_groups: Option where version == Version::Draft15, - ); - properties = Properties::decode(r, version)?; - properties.group_order = properties.group_order.or(group_order); - if version == Version::Draft15 { - properties.max_cache_duration = max_cache_duration.map(std::time::Duration::from_millis); - properties.dynamic_groups = dynamic_groups - .map(super::properties::dynamic_groups) - .transpose()? - .unwrap_or(false); - } - - return Ok(Self { - request_id, - track_alias, - largest, - properties, - }); - } - } + // GROUP_ORDER closes the session. LARGEST_OBJECT is required once the track has + // content, so rejecting it would tear down a session over a parameter compliant + // publishers must send. EXPIRES is ignored. + decode_params!(r, version, + 0x08 => _expires: Option, + 0x09 => largest: Option, + ); + let properties = Properties::decode(r, version)?; Ok(Self { - request_id, track_alias, largest, properties, @@ -359,77 +215,20 @@ impl Message for SubscribeOk { } } -/// SubscribeError message (0x05) -#[derive(Clone, Debug)] -pub struct SubscribeError<'a> { - pub request_id: RequestId, - pub error_code: u64, - pub reason_phrase: Cow<'a, str>, -} - -impl Message for SubscribeError<'_> { - const ID: u64 = 0x05; - - fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { - self.request_id.encode(w, version)?; - w.varint(self.error_code)?; - w.string(&self.reason_phrase)?; - Ok(()) - } - - fn decode_msg(r: &mut Decoder<'_>, version: Version) -> Result { - let request_id = RequestId::decode(r, version)?; - let error_code = r.varint()?; - let reason_phrase = Cow::Owned(r.string()?); - - Ok(Self { - request_id, - error_code, - reason_phrase, - }) - } -} - -/// Unsubscribe message (0x0a) -#[derive(Clone, Debug)] -pub struct Unsubscribe { - pub request_id: RequestId, -} - -impl Message for Unsubscribe { - const ID: u64 = 0x0a; - - fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { - self.request_id.encode(w, version)?; - Ok(()) - } - - fn decode_msg(r: &mut Decoder<'_>, version: Version) -> Result { - let request_id = RequestId::decode(r, version)?; - Ok(Self { request_id }) - } -} - /// SubscribeUpdate message (0x02) #[derive(Clone, Debug)] pub struct SubscribeUpdate { pub request_id: RequestId, - pub subscription_request_id: Option, - /// Draft-14's fixed start, which a peer must not see decrease; unused on later drafts. - pub start_location: Location, - /// Draft-14's fixed end group (0 for open-ended); unused on later drafts. - pub end_group: u64, - /// `None` leaves the priority as it is. Draft-14 cannot omit it, so `None` sends the - /// default there. + /// `None` leaves the priority as it is. pub subscriber_priority: Option, /// `None` leaves forwarding as it is, as for the priority. pub forward: Option, - /// The new LOCATION_FILTER (draft-15+); `None` keeps the subscription's own range. + /// The new LOCATION_FILTER; `None` keeps the subscription's own range. pub filter: Option, /// The `AUTHORIZATION TOKEN` (0x03) renewing the request's credential, if any. At /// most one is accepted: decoding refuses a repeated or second token. pub authorization_token: Option, - /// NEW_GROUP_REQUEST (0x32, draft-16+), as on [`Subscribe::new_group`]. + /// NEW_GROUP_REQUEST (0x32), as on [`Subscribe::new_group`]. pub new_group: Option, /// Subscriber max age in milliseconds (MoQ Timestamp), if negotiated. pub max_age: Option, @@ -442,156 +241,53 @@ impl Message for SubscribeUpdate { const ID: u64 = 0x02; fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { - match version { - Version::Draft14 => { - self.request_id.encode(w, version)?; - self.subscription_request_id - .expect("subscription_request_id required for draft14") - .encode(w, version)?; - self.start_location.encode(w, version)?; - w.varint(self.end_group)?; - w.u8(self.subscriber_priority.unwrap_or(super::priority::DEFAULT_WIRE)); - w.bool(self.forward.unwrap_or(true)); - encode_params!(w, version, - 0x03 => self.authorization_token.clone(), - super::max_age::PARAMETER => self.max_age, - ); - } - Version::Draft15 | Version::Draft16 => { - self.request_id.encode(w, version)?; - self.subscription_request_id - .expect("subscription_request_id required for draft15-16") - .encode(w, version)?; - encode_params!(w, version, - 0x03 => self.authorization_token.clone(), - 0x10 => self.forward, - 0x20 => self.subscriber_priority, - 0x21 => self.filter, - 0x32 => self.new_group.filter(|_| has_new_group_request(version)), - super::max_age::PARAMETER => self.max_age, - ); - } - _ => { - assert!( - self.subscription_request_id.is_none(), - "subscription_request_id must be None for draft17+" - ); - // REQUEST_UPDATE - self.request_id.encode(w, version)?; - if matches!(version, Version::Draft17) { - w.varint(0)?; // required_request_id_delta = 0 (draft-17 only, removed in draft-18 per #1615) - } - encode_params!(w, version, - 0x03 => self.authorization_token.clone(), - 0x10 => self.forward, - 0x20 => self.subscriber_priority, - 0x21 => self.filter, - 0x23 => self.fill.filter(|_| Filter::is_draft20(version)), - 0x32 => self.new_group, - super::max_age::PARAMETER => self.max_age, - ); - } - } + // REQUEST_UPDATE + self.request_id.encode(w, version)?; + encode_params!(w, version, + 0x03 => self.authorization_token.clone(), + 0x10 => self.forward, + 0x20 => self.subscriber_priority, + 0x21 => self.filter, + 0x23 => self.fill.filter(|_| Filter::is_draft20(version)), + 0x32 => self.new_group, + super::max_age::PARAMETER => self.max_age, + ); Ok(()) } fn decode_msg(r: &mut Decoder<'_>, version: Version) -> Result { - match version { - Version::Draft14 => { - let request_id = RequestId::decode(r, version)?; - let subscription_request_id = Some(RequestId::decode(r, version)?); - let start_location = Location::decode(r, version)?; - let end_group = r.varint()?; - let subscriber_priority = Some(r.u8()?); - let forward = Some(r.bool()?); - decode_params!(r, version, - 0x03 => tokens: Vec, - super::max_age::PARAMETER => max_age: Option, - ); - let authorization_token = super::token::single(tokens)?; - - Ok(Self { - request_id, - subscription_request_id, - start_location, - end_group, - subscriber_priority, - forward, - filter: None, - authorization_token, - new_group: None, - max_age: super::max_age::validate(max_age)?, - fill: None, - }) - } - Version::Draft15 | Version::Draft16 => { - let request_id = RequestId::decode(r, version)?; - let subscription_request_id = Some(RequestId::decode(r, version)?); - decode_params!(r, version, - 0x02 => _object_delivery_timeout: Option, - 0x03 => authorization_token: Vec, - 0x10 => forward: Option, - 0x20 => subscriber_priority: Option, - 0x21 => filter: Option, - 0x32 => new_group: Option where has_new_group_request(version), - super::max_age::PARAMETER => max_age: Option, - ); - - Ok(Self { - request_id, - subscription_request_id, - start_location: Location { group: 0, object: 0 }, - end_group: 0, - subscriber_priority, - forward, - filter, - authorization_token: super::token::single(authorization_token)?, - new_group, - max_age: super::max_age::validate(max_age)?, - fill: None, - }) - } - _ => { - // REQUEST_UPDATE - let request_id = RequestId::decode(r, version)?; - if matches!(version, Version::Draft17) { - let _required_request_id_delta = r.varint()?; - } - // Nothing reads an update's Range Filters yet; they are - // consumed so a legal update does not fail the session. - decode_params!(r, version, - 0x02 => _object_delivery_timeout: Option, - 0x03 => authorization_token: Vec, - 0x06 => _subgroup_delivery_timeout: Option where !matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16 | Version::Draft17), - 0x10 => forward: Option, - 0x20 => subscriber_priority: Option, - 0x21 => filter: Option, - 0x23 => fill: Option where Filter::is_draft20(version), - 0x25 => _subgroup_filter: Vec where has_range_filters(version), - 0x26 => _object_id_filter: Vec where has_range_filters(version), - 0x27 => _priority_filter: Vec where has_range_filters(version), - 0x28 => _object_property_filter: Vec where has_range_filters(version), - 0x29 => _track_property_filter: Vec where has_range_filters(version), - 0x32 => new_group: Option, - super::max_age::PARAMETER => max_age: Option, - ); + // REQUEST_UPDATE + let request_id = RequestId::decode(r, version)?; + // Nothing reads an update's Range Filters yet; they are + // consumed so a legal update does not fail the session. + decode_params!(r, version, + 0x02 => _object_delivery_timeout: Option, + 0x03 => authorization_token: Vec, + 0x06 => _subgroup_delivery_timeout: Option, + 0x10 => forward: Option, + 0x20 => subscriber_priority: Option, + 0x21 => filter: Option, + 0x23 => fill: Option where Filter::is_draft20(version), + 0x25 => _subgroup_filter: Vec where has_range_filters(version), + 0x26 => _object_id_filter: Vec where has_range_filters(version), + 0x27 => _priority_filter: Vec where has_range_filters(version), + 0x28 => _object_property_filter: Vec where has_range_filters(version), + 0x29 => _track_property_filter: Vec where has_range_filters(version), + 0x32 => new_group: Option, + super::max_age::PARAMETER => max_age: Option, + ); - Ok(Self { - request_id, - subscription_request_id: None, - start_location: Location { group: 0, object: 0 }, - end_group: 0, - subscriber_priority, - forward, - filter, - authorization_token: super::token::single(authorization_token)?, - new_group, - max_age: super::max_age::validate(max_age)?, - fill, - }) - } - } + Ok(Self { + request_id, + subscriber_priority, + forward, + filter, + authorization_token: super::token::single(authorization_token)?, + new_group, + max_age: super::max_age::validate(max_age)?, + fill, + }) } } @@ -614,10 +310,6 @@ mod tests { #[test] fn subscriber_max_age_round_trips() { for version in [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft20, @@ -647,10 +339,6 @@ mod tests { let update = SubscribeUpdate { max_age, request_id: RequestId(2), - subscription_request_id: matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) - .then_some(RequestId(0)), - start_location: Location { group: 0, object: 0 }, - end_group: 0, subscriber_priority: None, forward: None, filter: None, @@ -724,10 +412,6 @@ mod tests { /// Build a SUBSCRIBE body carrying a single RENDEZVOUS_TIMEOUT parameter. const VERSIONS: [Version; 9] = [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft20, @@ -765,10 +449,6 @@ mod tests { new_group: Some(7), max_age: None, request_id: RequestId(3), - subscription_request_id: matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) - .then_some(RequestId(1)), - start_location: Location { group: 0, object: 0 }, - end_group: 0, subscriber_priority: None, forward: None, filter: None, @@ -785,9 +465,6 @@ mod tests { let mut buf = Vec::new(); let w = &mut Encoder::new(&mut buf, version.into()); RequestId(1).encode(w, version)?; - if version == Version::Draft17 { - w.varint(0)?; // required_request_id_delta - } encode_namespace(w, &Path::new("test"))?; w.string("video")?; encode_params!(w, version, @@ -805,7 +482,7 @@ mod tests { /// SUBSCRIBE. #[test] fn rendezvous_timeout_retains_whether_a_wait_was_requested() { - for version in [Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft20] { + for version in [Version::Draft18, Version::Draft19, Version::Draft20] { for millis in [0, 5000] { let encoded = subscribe_with_rendezvous(millis, version); let msg: Subscribe = decode_message(&encoded, version) @@ -838,9 +515,6 @@ mod tests { fn first_param_key(encoded: &[u8], version: Version) -> Option { let r = &mut Decoder::new(encoded, version.into()); RequestId::decode(r, version).unwrap(); - if version == Version::Draft17 { - r.varint().unwrap(); - } decode_track(r).unwrap(); // draft-14/15 write absolute keys, draft-16+ deltas, but the first is absolute either way. @@ -869,7 +543,7 @@ mod tests { epoch: None, }; - for version in [Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft20] { + for version in [Version::Draft18, Version::Draft19, Version::Draft20] { // The reader has to be able to see a 0x04, or its absence below proves nothing. assert_eq!( first_param_key(&subscribe_with_rendezvous(5000, version), version), @@ -914,7 +588,6 @@ mod tests { #[test] fn test_subscribe_ok() { let msg = SubscribeOk { - request_id: Some(RequestId(42)), track_alias: 42, largest: None, properties: Properties::default(), @@ -930,7 +603,7 @@ mod tests { fn test_subscribe_ok_accepts_largest_object() { // request_id=4, track_alias=4, one LARGEST_OBJECT parameter at {5, 0}. let payload = [0x04, 0x04, 0x01, 0x09, 0x02, 0x05, 0x00]; - for version in [Version::Draft15, Version::Draft16] { + for version in [Version::Draft16] { let decoded: SubscribeOk = decode_message(&payload, version).unwrap(); assert_eq!(decoded.request_id, Some(RequestId(4))); @@ -945,7 +618,7 @@ mod tests { #[test] fn test_subscribe_ok_accepts_largest_object_draft17_on() { let payload = [0x04, 0x01, 0x09, 0x05, 0x00]; - for version in [Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft20] { + for version in [Version::Draft18, Version::Draft19, Version::Draft20] { let decoded: SubscribeOk = decode_message(&payload, version).unwrap(); assert_eq!(decoded.request_id, None, "{version}"); @@ -988,7 +661,6 @@ mod tests { (Version::Draft20, &[42, 1, 0x09, 0x09, 0x03][..]), ] { let msg = SubscribeOk { - request_id: matches!(version, Version::Draft14 | Version::Draft16).then_some(RequestId(7)), track_alias: 42, largest, properties: Properties::default(), @@ -1004,7 +676,6 @@ mod tests { #[test] fn test_subscribe_ok_v15() { let msg = SubscribeOk { - request_id: Some(RequestId(42)), track_alias: 42, largest: None, properties: Properties::default(), @@ -1144,9 +815,6 @@ mod tests { #[test] fn test_subscribe_omitted_priority_is_128() { for version in [ - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft20, @@ -1154,9 +822,6 @@ mod tests { Version::Draft22, ] { let mut bytes = vec![0x00]; // request_id - if version == Version::Draft17 { - bytes.push(0x00); // required_request_id_delta - } bytes.extend_from_slice(b"\x01\x0bnonexistent\x0dno-such-track"); // namespace, name bytes.push(0x00); // no parameters let msg = decode_message::(&bytes, version).unwrap(); @@ -1171,8 +836,6 @@ mod tests { max_age: None, request_id: RequestId(10), subscription_request_id: Some(RequestId(5)), - start_location: Location { group: 0, object: 0 }, - end_group: 0, subscriber_priority: Some(200), forward: Some(true), filter: Some(Filter::NextObject), @@ -1290,7 +953,6 @@ mod tests { #[test] fn test_subscribe_ok_v17_round_trip() { let msg = SubscribeOk { - request_id: None, track_alias: 42, largest: None, properties: Properties::default(), @@ -1309,9 +971,6 @@ mod tests { new_group: None, max_age: None, request_id: RequestId(10), - subscription_request_id: None, - start_location: Location { group: 0, object: 0 }, - end_group: 0, subscriber_priority: Some(200), forward: Some(true), filter: Some(Filter::NextObject), @@ -1360,7 +1019,6 @@ mod tests { #[test] fn test_subscribe_ok_v18_round_trip() { let msg = SubscribeOk { - request_id: None, track_alias: 42, largest: None, properties: Properties::default(), @@ -1378,10 +1036,6 @@ mod tests { #[test] fn subscribe_ok_priority_property_bytes_on_every_draft() { for version in [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft20, @@ -1389,8 +1043,6 @@ mod tests { Version::Draft22, ] { let mut msg = SubscribeOk { - request_id: matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) - .then_some(RequestId(7)), track_alias: 42, largest: None, properties: Properties::default(), @@ -1398,18 +1050,14 @@ mod tests { let baseline = encode_message(&msg, version); msg.properties.priority = Some(37); let encoded = encode_message(&msg, version); - if matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) { - assert_eq!(encoded, baseline, "{version}"); - } else { - assert_eq!(encoded, [baseline, vec![0x0e, 37]].concat(), "{version}"); - assert_eq!( - decode_message::(&encoded, version) - .unwrap() - .properties - .priority, - Some(37) - ); - } + assert_eq!(encoded, [baseline, vec![0x0e, 37]].concat(), "{version}"); + assert_eq!( + decode_message::(&encoded, version) + .unwrap() + .properties + .priority, + Some(37) + ); } } @@ -1420,7 +1068,6 @@ mod tests { #[test] fn test_subscribe_ok_v18_group_order_is_a_property() { let msg = SubscribeOk { - request_id: None, track_alias: 42, largest: None, properties: Properties { @@ -1452,7 +1099,6 @@ mod tests { #[test] fn test_subscribe_ok_v15_group_order_is_a_parameter() { let msg = SubscribeOk { - request_id: Some(RequestId(7)), track_alias: 42, largest: None, properties: Properties { @@ -1484,7 +1130,6 @@ mod tests { #[test] fn test_subscribe_ok_v15_dynamic_groups_is_a_parameter() { let msg = SubscribeOk { - request_id: Some(RequestId(7)), track_alias: 42, largest: None, properties: Properties { @@ -1534,7 +1179,7 @@ mod tests { buf.extend_from_slice(&body); let mut bytes = bytes::Bytes::from(buf); - let decoded = crate::coding::decode_buf(&mut bytes, Version::Draft16, SubscribeOk::decode).unwrap(); + let decoded = crate::coding::decode_buf(&mut bytes, SubscribeOk::decode).unwrap(); assert_eq!(decoded.track_alias, 42); assert_eq!(decoded.properties.group_order, Some(GroupOrder::Descending)); } @@ -1562,9 +1207,6 @@ mod tests { new_group: None, max_age: None, request_id: RequestId(10), - subscription_request_id: None, - start_location: Location { group: 0, object: 0 }, - end_group: 0, subscriber_priority: Some(200), forward: Some(true), filter: Some(Filter::NextObject), @@ -1590,9 +1232,6 @@ mod tests { new_group: None, max_age: None, request_id: RequestId(10), - subscription_request_id: None, - start_location: Location { group: 0, object: 0 }, - end_group: 0, subscriber_priority: Some(200), forward: Some(true), filter: Some(Filter::NextObject), @@ -1717,10 +1356,6 @@ mod tests { #[test] fn subscribe_decodes_forward_zero() { for version in [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft20, @@ -1757,18 +1392,11 @@ mod tests { 0x03, 0x03, 0x03, 0x00, 0xAA, // AUTHORIZATION TOKEN ]); for version in [ - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft20, ] { let mut body = body.clone(); - if version == Version::Draft17 { - // Required Request ID Delta, draft-17 only. - body.insert(1, 0x00); - } let wire = body; let mut buf = Decoder::new(&wire, version.into()); Subscribe::decode_msg(&mut buf, version).unwrap_or_else(|e| panic!("{version}: {e}")); @@ -1851,10 +1479,6 @@ mod cache_duration_tests { #[test] fn max_cache_duration_is_read_in_each_drafts_field() { for version in [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft20, @@ -1862,12 +1486,7 @@ mod cache_duration_tests { Version::Draft22, ] { for age in [0u64, 30_000] { - let mut payload = match version { - Version::Draft14 => vec![0, 0, 0, 1, 0, 1, 4], - Version::Draft15 => vec![0, 0, 1, 4], - Version::Draft16 => vec![0, 0, 0, 4], - _ => vec![0, 0, 4], - }; + let mut payload = vec![0, 0, 4]; Encoder::new(&mut payload, version.into()).varint(age).unwrap(); let got = crate::coding::decode_buf(&mut payload.as_slice(), version, SubscribeOk::decode_msg).unwrap(); assert_eq!( @@ -1882,17 +1501,13 @@ mod cache_duration_tests { #[test] fn legacy_never_sends_cache_duration_and_modern_preserves_optional_value() { for version in [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft20, Version::Draft21, Version::Draft22, ] { - let legacy = matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16); + let legacy = false; for age in [None, Some(Duration::ZERO), Some(Duration::from_secs(30))] { let ok = SubscribeOk { request_id: legacy.then_some(RequestId(0)), diff --git a/rs/moq-net/src/ietf/subscribe_namespace.rs b/rs/moq-net/src/ietf/subscribe_namespace.rs index 79cb3233061..658c0352152 100644 --- a/rs/moq-net/src/ietf/subscribe_namespace.rs +++ b/rs/moq-net/src/ietf/subscribe_namespace.rs @@ -1,6 +1,5 @@ //! IETF moq-transport subscribe namespace messages -use std::borrow::Cow; use crate::{Path, coding::*, ietf::RequestId}; @@ -11,20 +10,7 @@ use super::publish_namespace::{AdvertParams, Negotiated}; use super::Version; -/// True for the drafts that use the legacy 0x11 SUBSCRIBE_NAMESPACE message. -/// Draft-18+ uses the renumbered 0x50 message instead. -fn is_legacy_version(version: Version) -> bool { - matches!( - version, - Version::Draft14 | Version::Draft15 | Version::Draft16 | Version::Draft17 - ) -} - -/// SUBSCRIBE_NAMESPACE message (draft-18+, type 0x50). -/// -/// Draft-18 renumbered the message from 0x11 to 0x50 and dropped the Subscribe -/// Options field when it split SUBSCRIBE_TRACKS (0x51) off into its own message -/// type (#1542). Draft-14 through draft-17 use [`SubscribeNamespaceLegacy`]. +/// SUBSCRIBE_NAMESPACE message (type 0x50). #[derive(Clone, Debug)] pub struct SubscribeNamespace<'a> { pub request_id: RequestId, @@ -52,9 +38,6 @@ impl Message for SubscribeNamespace<'_> { const ID: u64 = 0x50; fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { - if is_legacy_version(version) { - return Err(EncodeError::Version); - } self.request_id.encode(w, version)?; encode_namespace(w, &self.namespace)?; encode_params!(w, version, HIDDEN_PARAM => hidden_param(self.hidden)); @@ -62,9 +45,6 @@ impl Message for SubscribeNamespace<'_> { } fn decode_msg(r: &mut Decoder<'_>, version: Version) -> Result { - if is_legacy_version(version) { - return Err(DecodeError::Version); - } let request_id = RequestId::decode(r, version)?; let namespace = decode_namespace(r)?; // The token decodes but grants nothing: the session's grant is what authorizes the request. @@ -84,200 +64,7 @@ impl Message for SubscribeNamespace<'_> { } } -/// What a draft-16/17 SUBSCRIBE_NAMESPACE asks for (d16 §9.25, d17 §9.20). -/// -/// Draft-14/15 have no field and only ever ask for namespaces. Draft-18 dropped it -/// when SUBSCRIBE_TRACKS took over the PUBLISH half. -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum SubscribeOptions { - /// PUBLISH for each matching track (0x00). - Publish, - /// NAMESPACE for each matching namespace (0x01). - Namespace, - /// Both PUBLISH and NAMESPACE (0x02). - Both, -} - -impl SubscribeOptions { - fn encode(self, w: &mut Encoder<'_>) -> Result<(), EncodeError> { - w.varint(match self { - Self::Publish => 0x00u64, - Self::Namespace => 0x01, - Self::Both => 0x02, - }) - } - - fn decode(r: &mut Decoder<'_>) -> Result { - match r.varint()? { - 0x00 => Ok(Self::Publish), - 0x01 => Ok(Self::Namespace), - 0x02 => Ok(Self::Both), - _ => Err(DecodeError::InvalidValue), - } - } -} - -/// SUBSCRIBE_NAMESPACE message for draft-14 through draft-17 (type 0x11). -/// -/// In v16 this moves from the control stream to its own bidirectional stream. -/// Draft-16/17 carry [`SubscribeOptions`]; draft-17 additionally prefixes a -/// Required Request ID delta (removed in draft-18 per #1615). Draft-18+ uses -/// [`SubscribeNamespace`]. -#[derive(Clone, Debug)] -pub struct SubscribeNamespaceLegacy<'a> { - pub request_id: RequestId, - pub namespace: Path<'a>, - /// Encoded on v16/v17 only; earlier drafts always mean [`SubscribeOptions::Namespace`]. - pub subscribe_options: SubscribeOptions, - /// MoQ Hidden: see [`SubscribeNamespace::hidden`]. - pub hidden: bool, -} - -impl Message for SubscribeNamespaceLegacy<'_> { - const ID: u64 = 0x11; - - fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { - if !is_legacy_version(version) { - return Err(EncodeError::Version); - } - self.request_id.encode(w, version)?; - if version == Version::Draft17 { - w.varint(0)?; // required_request_id_delta = 0 (draft-17 only, removed in draft-18 per #1615) - } - encode_namespace(w, &self.namespace)?; - if matches!(version, Version::Draft16 | Version::Draft17) { - self.subscribe_options.encode(w)?; - } - encode_params!(w, version, HIDDEN_PARAM => hidden_param(self.hidden)); - Ok(()) - } - - fn decode_msg(r: &mut Decoder<'_>, version: Version) -> Result { - if !is_legacy_version(version) { - return Err(DecodeError::Version); - } - let request_id = RequestId::decode(r, version)?; - if version == Version::Draft17 { - let _required_request_id_delta = r.varint()?; - } - let namespace = decode_namespace(r)?; - let subscribe_options = match version { - Version::Draft16 | Version::Draft17 => SubscribeOptions::decode(r)?, - _ => SubscribeOptions::Namespace, - }; - - // The token decodes but grants nothing: the session's grant is what authorizes the request. - // FORWARD is legal here in draft-15 through draft-17. The value is checked (only - // 0 or 1) and then dropped: a namespace subscription has no objects to forward. - // Draft-14 has no such parameter, so an unlisted id is ignored. Draft-18 moved - // FORWARD onto SUBSCRIBE_TRACKS and closes if it shows up on the new message. - decode_params!(r, version, - 0x03 => authorization_token: Vec, - 0x10 => _forward: Option where matches!(version, Version::Draft15 | Version::Draft16 | Version::Draft17), - HIDDEN_PARAM => hidden: Option, - ); - let hidden = hidden_from_param(hidden)?; - // Last, so a malformed field closes the session before a token refusal. - super::token::single(authorization_token)?; - - Ok(Self { - request_id, - namespace, - subscribe_options, - hidden, - }) - } -} - -/// SubscribeNamespaceOk message (0x12): v14 only -#[derive(Clone, Debug)] -pub struct SubscribeNamespaceOk { - pub request_id: RequestId, -} - -impl Message for SubscribeNamespaceOk { - const ID: u64 = 0x12; - - fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { - self.request_id.encode(w, version)?; - Ok(()) - } - - fn decode_msg(r: &mut Decoder<'_>, version: Version) -> Result { - let request_id = RequestId::decode(r, version)?; - Ok(Self { request_id }) - } -} - -/// SubscribeNamespaceError message (0x13): v14 only -#[derive(Clone, Debug)] -pub struct SubscribeNamespaceError<'a> { - pub request_id: RequestId, - pub error_code: u64, - pub reason_phrase: Cow<'a, str>, -} - -impl Message for SubscribeNamespaceError<'_> { - const ID: u64 = 0x13; - - fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { - self.request_id.encode(w, version)?; - w.varint(self.error_code)?; - w.string(&self.reason_phrase)?; - Ok(()) - } - - fn decode_msg(r: &mut Decoder<'_>, version: Version) -> Result { - let request_id = RequestId::decode(r, version)?; - let error_code = r.varint()?; - let reason_phrase = Cow::Owned(r.string()?); - - Ok(Self { - request_id, - error_code, - reason_phrase, - }) - } -} - -/// UnsubscribeNamespace message (0x14): v14/v15 only (v16 uses stream close). -/// v14 names the prefix it subscribed, v15 the request. -#[derive(Clone, Debug)] -pub struct UnsubscribeNamespace<'a> { - /// v14: the Track Namespace Prefix of the SUBSCRIBE_NAMESPACE it cancels. - pub prefix: Path<'a>, - /// v15: the Request ID of the SUBSCRIBE_NAMESPACE it cancels. - pub request_id: RequestId, -} - -impl Message for UnsubscribeNamespace<'_> { - const ID: u64 = 0x14; - - fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { - match version { - Version::Draft14 => encode_namespace(w, &self.prefix)?, - Version::Draft15 => self.request_id.encode(w, version)?, - _ => return Err(EncodeError::Version), - } - Ok(()) - } - - fn decode_msg(r: &mut Decoder<'_>, version: Version) -> Result { - match version { - Version::Draft14 => Ok(Self { - prefix: decode_namespace(r)?, - request_id: RequestId(0), - }), - Version::Draft15 => Ok(Self { - prefix: Path::default(), - request_id: RequestId::decode(r, version)?, - }), - _ => Err(DecodeError::Version), - } - } -} - -/// NAMESPACE message (0x08): v16+, sent on the SUBSCRIBE_NAMESPACE bidi stream. +/// NAMESPACE message (0x08), sent on the SUBSCRIBE_NAMESPACE bidi stream. /// Indicates a namespace suffix matching the subscribed prefix is active. /// /// The base message carries only the suffix. A session that negotiated the MoQ Cluster @@ -326,7 +113,7 @@ impl Message for Namespace<'_> { } } -/// NAMESPACE_DONE message (0x0E): v16 only, sent on SUBSCRIBE_NAMESPACE bidi stream +/// NAMESPACE_DONE message (0x0E), sent on the SUBSCRIBE_NAMESPACE bidi stream. /// Indicates a namespace suffix matching the subscribed prefix is no longer active. #[derive(Clone, Debug)] pub struct NamespaceDone<'a> { @@ -387,29 +174,6 @@ mod tests { Ok((decoded, buf.is_empty())) } - /// Draft-14 names the prefix it cancels and draft-15 the request; later drafts close the - /// stream instead. - #[test] - fn unsubscribe_namespace_names_the_prefix_then_the_request() { - let msg = UnsubscribeNamespace { - prefix: Path::new("cam/front"), - request_id: RequestId(6), - }; - let mut v14 = bytes::Bytes::from(body(&msg, Version::Draft14)); - let named = crate::coding::decode_buf(&mut v14, Version::Draft14, UnsubscribeNamespace::decode_msg).unwrap(); - assert_eq!(named.prefix.as_str(), "cam/front"); - - let mut v15 = bytes::Bytes::from(body(&msg, Version::Draft15)); - let numbered = crate::coding::decode_buf(&mut v15, Version::Draft15, UnsubscribeNamespace::decode_msg).unwrap(); - assert_eq!(numbered.request_id, RequestId(6)); - - let mut buf = Vec::new(); - assert!( - msg.encode_msg(&mut Encoder::new(&mut buf, Version::Draft16.into()), Version::Draft16) - .is_err() - ); - } - fn clustered(hops: &[u64], cost: u64) -> Option { Some(AdvertParams { cluster: Some(cluster::Advert { @@ -590,76 +354,36 @@ mod tests { ); } - /// FORWARD (0x10) is legal on SUBSCRIBE_NAMESPACE through draft-17. A value other - /// than 0 or 1 still closes the session. Draft-18 dropped it from this message. + /// Draft-18 moved FORWARD (0x10) onto SUBSCRIBE_TRACKS, so it closes the session here. #[test] - fn forward_follows_the_draft() { - fn with_forward(version: Version, value: u64) -> Vec { - let mut buf = Vec::new(); - let w = &mut Encoder::new(&mut buf, version.into()); - RequestId(1).encode(w, version).unwrap(); - if version == Version::Draft17 { - w.varint(0).unwrap(); - } - encode_namespace(w, &Path::default()).unwrap(); - if matches!(version, Version::Draft16 | Version::Draft17) { - w.varint(1).unwrap(); - } - // Count, absolute key, then the raw varint. encode_params! needs a Result. - w.varint(1).unwrap(); - w.varint(0x10).unwrap(); - w.varint(value).unwrap(); - buf - } - - for version in [Version::Draft15, Version::Draft16, Version::Draft17] { - let mut buf = bytes::Bytes::from(with_forward(version, 0)); - crate::coding::decode_buf(&mut buf, version, SubscribeNamespaceLegacy::decode_msg) - .unwrap_or_else(|err| panic!("{version} FORWARD=0: {err}")); - assert!(buf.is_empty(), "{version}"); - - let mut buf = bytes::Bytes::from(with_forward(version, 2)); - assert!( - crate::coding::decode_buf(&mut buf, version, SubscribeNamespaceLegacy::decode_msg).is_err(), - "{version} FORWARD=2" - ); - } - - let mut buf = bytes::Bytes::from(with_forward(Version::Draft18, 0)); - assert!(crate::coding::decode_buf(&mut buf, Version::Draft18, SubscribeNamespace::decode_msg).is_err()); + fn forward_is_refused() { + let version = Version::Draft18; + let mut buf = Vec::new(); + let w = &mut Encoder::new(&mut buf, version.into()); + RequestId(1).encode(w, version).unwrap(); + encode_namespace(w, &Path::default()).unwrap(); + // Count, key, then the raw varint. + w.varint(1).unwrap(); + w.varint(0x10).unwrap(); + w.varint(0).unwrap(); + let mut buf = bytes::Bytes::from(buf); + assert!(crate::coding::decode_buf(&mut buf, version, SubscribeNamespace::decode_msg).is_err()); } - /// SUBSCRIBE_NAMESPACE's message types, pinned to the drafts: 0x11 through draft-17, - /// renumbered to 0x50 in draft-18. #[test] - fn message_type_code_points() { - for (name, id, spec) in [ - ("SUBSCRIBE_NAMESPACE (draft-17)", SubscribeNamespaceLegacy::ID, 0x11), - ("SUBSCRIBE_NAMESPACE", SubscribeNamespace::ID, 0x50), - ] { - assert_eq!(id, spec, "{name}"); - } + fn message_type_code_point() { + assert_eq!(SubscribeNamespace::ID, 0x50); } #[test] - fn draft18_omits_subscribe_options() { - // Draft-18 modern body: Request ID (0x00), empty namespace field-count - // (0x00), Number of Parameters (0x00). No Subscribe Options field. - let modern = SubscribeNamespace { - request_id: RequestId(0), - namespace: Path::default(), - hidden: false, - }; - assert_eq!(body(&modern, Version::Draft18), vec![0x00, 0x00, 0x00]); - - // The legacy draft-17 body keeps the options field, so it is one byte longer. - let legacy = SubscribeNamespaceLegacy { + fn body_has_no_subscribe_options() { + // Request ID (0x00), empty namespace field-count (0x00), Number of Parameters (0x00). + let msg = SubscribeNamespace { request_id: RequestId(0), namespace: Path::default(), - subscribe_options: SubscribeOptions::Namespace, hidden: false, }; - assert!(body(&legacy, Version::Draft17).len() > body(&modern, Version::Draft18).len()); + assert_eq!(body(&msg, Version::Draft18), vec![0x00, 0x00, 0x00]); } #[test] @@ -693,73 +417,6 @@ mod tests { hidden ); - for version in [Version::Draft14, Version::Draft16, Version::Draft17] { - let msg = SubscribeNamespaceLegacy { - request_id: RequestId(4), - namespace: Path::new("example"), - subscribe_options: SubscribeOptions::Namespace, - hidden, - }; - let mut buf = bytes::Bytes::from(body(&msg, version)); - let decoded = - crate::coding::decode_buf(&mut buf, version, SubscribeNamespaceLegacy::decode_msg).unwrap(); - assert_eq!(decoded.hidden, hidden, "{version:?}"); - } - } - } - - #[test] - fn legacy_round_trips() { - for version in [Version::Draft16, Version::Draft17] { - for options in [ - SubscribeOptions::Publish, - SubscribeOptions::Namespace, - SubscribeOptions::Both, - ] { - let msg = SubscribeNamespaceLegacy { - request_id: RequestId(4), - namespace: Path::new("example/meeting"), - subscribe_options: options, - hidden: false, - }; - let mut buf = bytes::Bytes::from(body(&msg, version)); - let decoded = - crate::coding::decode_buf(&mut buf, version, SubscribeNamespaceLegacy::decode_msg).unwrap(); - assert!(buf.is_empty(), "trailing bytes for {version:?}"); - assert_eq!(decoded.request_id, RequestId(4)); - assert_eq!(decoded.namespace.as_str(), "example/meeting"); - assert_eq!(decoded.subscribe_options, options); - } - } - } - - /// The drafts define only 0x00 through 0x02, so we refuse any other value as a protocol violation. - #[test] - fn legacy_rejects_unknown_subscribe_options() { - // Request ID, empty namespace, Subscribe Options 0x03, no parameters. - let mut buf = bytes::Bytes::from(vec![0x00, 0x00, 0x03, 0x00]); - assert!(matches!( - crate::coding::decode_buf(&mut buf, Version::Draft16, SubscribeNamespaceLegacy::decode_msg), - Err(DecodeError::InvalidValue) - )); - } - - #[test] - fn rejects_wrong_version() { - // The modern 0x50 message only exists in draft-18+. - for version in [Version::Draft14, Version::Draft16, Version::Draft17] { - let mut buf = bytes::Bytes::from(vec![0x00, 0x00, 0x00]); - assert!(matches!( - crate::coding::decode_buf(&mut buf, version, SubscribeNamespace::decode_msg), - Err(DecodeError::Version) - )); } - - // The legacy 0x11 message only exists in draft-14..17. - let mut buf = bytes::Bytes::from(vec![0x00, 0x00, 0x00]); - assert!(matches!( - crate::coding::decode_buf(&mut buf, Version::Draft18, SubscribeNamespaceLegacy::decode_msg), - Err(DecodeError::Version) - )); } } diff --git a/rs/moq-net/src/ietf/subscribe_tracks.rs b/rs/moq-net/src/ietf/subscribe_tracks.rs index 5dba72a7103..bfbb7db5610 100644 --- a/rs/moq-net/src/ietf/subscribe_tracks.rs +++ b/rs/moq-net/src/ietf/subscribe_tracks.rs @@ -51,9 +51,6 @@ impl Message for SubscribeTracks<'_> { const ID: u64 = 0x51; fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { - if !has_subscribe_tracks(version) { - return Err(EncodeError::Version); - } self.request_id.encode(w, version)?; encode_namespace(w, &self.prefix)?; // Absent means 1, so only a paused listing writes it. @@ -77,9 +74,6 @@ impl Message for SubscribeTracks<'_> { } fn decode_msg(r: &mut Decoder<'_>, version: Version) -> Result { - if !has_subscribe_tracks(version) { - return Err(DecodeError::Version); - } let request_id = RequestId::decode(r, version)?; let prefix = decode_namespace(r)?; // From draft-19 any parameter a SUBSCRIBE takes is legal here (section 10.19.1); @@ -133,18 +127,10 @@ impl Message for SubscribeTracks<'_> { } } -/// Whether `version` defines SUBSCRIBE_TRACKS: draft-18 split it off SUBSCRIBE_NAMESPACE. -pub(crate) fn has_subscribe_tracks(version: Version) -> bool { - !matches!( - version, - Version::Draft14 | Version::Draft15 | Version::Draft16 | Version::Draft17 - ) -} - /// PUBLISH_SKIPPED (0x0F): a track under a SUBSCRIBE_TRACKS prefix the publisher will /// not PUBLISH, sent on that request's stream. The subscriber may SUBSCRIBE to it instead. /// -/// Drafts 17 and 18 name it PUBLISH_BLOCKED and send it only when the publisher has run +/// Draft-18 names it PUBLISH_BLOCKED and send it only when the publisher has run /// out of streams for PUBLISH; draft-19 renamed it and allows it for any reason. #[derive(Clone, Debug)] pub struct PublishSkipped<'a> { @@ -156,31 +142,19 @@ pub struct PublishSkipped<'a> { impl Message for PublishSkipped<'_> { const ID: u64 = 0x0F; - fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { - if !has_publish_skipped(version) { - return Err(EncodeError::Version); - } + fn encode_msg(&self, w: &mut Encoder<'_>, _: Version) -> Result<(), EncodeError> { encode_namespace(w, &self.suffix)?; w.string(&self.track_name)?; Ok(()) } - fn decode_msg(r: &mut Decoder<'_>, version: Version) -> Result { - if !has_publish_skipped(version) { - return Err(DecodeError::Version); - } + fn decode_msg(r: &mut Decoder<'_>, _: Version) -> Result { let suffix = decode_namespace(r)?; let track_name = Cow::Owned(r.string()?); Ok(Self { suffix, track_name }) } } -/// Whether `version` defines [`PublishSkipped`], under either name. Draft-16 and older -/// had no message 0x0F. -fn has_publish_skipped(version: Version) -> bool { - !matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) -} - #[cfg(test)] mod tests { use super::*; @@ -316,7 +290,7 @@ mod tests { #[test] fn publish_skipped_round_trips() { - for version in [Version::Draft17, Version::Draft18, Version::Draft22] { + for version in [Version::Draft18, Version::Draft22] { let msg = PublishSkipped { suffix: Path::new("cam"), track_name: "video".into(), diff --git a/rs/moq-net/src/ietf/subscriber.rs b/rs/moq-net/src/ietf/subscriber.rs index e58bd3dc828..b195f174785 100644 --- a/rs/moq-net/src/ietf/subscriber.rs +++ b/rs/moq-net/src/ietf/subscriber.rs @@ -529,7 +529,7 @@ fn accepted_info(properties: &ietf::Properties, version: Version) -> track::Info /// Why a track a `version` publisher answered with `properties` is neither processed nor /// forwarded, if it is not. fn refused(properties: &ietf::Properties, version: Version, negotiated: bool) -> Option { - if properties.compress && !(negotiated && super::flate::supported(version)) { + if properties.compress && !negotiated { return Some(Error::UnsupportedExtension); } let info = accepted_info(properties, version); @@ -663,10 +663,10 @@ enum Withdraw { Done, /// Close our side and wait for the peer to read everything. Close, - /// Refuse the request with this ID, then close. - Reject(RequestId, crate::auth::Refusal), - /// Refuse the update with this ID, then cancel the advertisement. - Cancel(RequestId, crate::auth::Refusal), + /// Refuse the request, then close. + Reject(crate::auth::Refusal), + /// Refuse an update, then cancel the advertisement. + Cancel(crate::auth::Refusal), } /// What one advertisement said, once its parameters are resolved against the session. @@ -1002,13 +1002,9 @@ impl Subscriber { retire_track_alias(&aliases, alias, REQUEST_ID); } - /// What the peer declared in its SETUP, or the default (extension off) on a version - /// that cannot negotiate it. See [`super::Publisher::peer`]. + /// What the peer declared in its SETUP. See [`super::Publisher::peer`]. pub(super) async fn peer(&self) -> cluster::Peer { - match cluster::supported(self.version) { - true => self.peer_setup.get().await.cluster, - false => cluster::Peer::default(), - } + self.peer_setup.get().await.cluster } /// The announcing session's declared or assigned identity, for split-horizon. @@ -1169,13 +1165,8 @@ impl Subscriber { snapshot: crate::model::Snapshot, live: kio::Consumer<()>, ) -> Result { - let stream = if self.version == Version::Draft16 { - stream.with_stats(self.origin.stats()) - } else { - super::request_stream::with_stats(stream, self.origin.stats(), self.version) - }; let mut request = NamespaceRequest { - stream, + stream: stream.with_stats(self.origin.stats()), messages: super::request_stream::Messages::new(self.session.clone(), self.control.client()), prefix, request_id: None, @@ -1214,55 +1205,16 @@ impl Subscriber { let hidden = declared.hidden; let prefix = request.prefix.clone(); - // Draft-16 is the first to allow a zero-field namespace, so the empty prefix is a - // protocol violation on draft-14/15. A peer that never declared MoQ Solicit is not - // ours: it may enforce that, and it tells us unasked anyway. One that declared it - // accepts the empty prefix and only tells when asked, so it still gets one. - if prefix.is_empty() - && declared.solicit.is_none() - && matches!(self.version, Version::Draft14 | Version::Draft15) - { - tracing::debug!(version = ?self.version, "not asking a foreign peer for the empty namespace"); - return Ok(namespaces::Ended::Peer); - } - - // No ID is spent on a request that ends while it waits for credit, so the peer - // never sees a gap in our sequential request IDs. - let mut timeout = crate::time::Deadline::after(&self.runtime, Control::REQUEST_ID_TIMEOUT); - let request_id = kio::wait(|waiter| { - if live.poll_closed(waiter).is_ready() { - return Poll::Ready(Ok(None)); - } - self.control.poll_credit(waiter, &mut timeout).map(|id| id.map(Some)) - }) - .await?; - let Some(request_id) = request_id else { - return Ok(namespaces::Ended::Local); - }; + let request_id = self.control.next_request_id(); request.request_id = Some(request_id); let stream = &mut request.stream; - // Draft-18+ uses SUBSCRIBE_NAMESPACE (0x50); earlier drafts use the legacy - // 0x11 message with a Subscribe Options field. - match self.version { - Version::Draft14 | Version::Draft15 | Version::Draft16 | Version::Draft17 => { - let msg = ietf::SubscribeNamespaceLegacy { - request_id, - namespace: prefix.clone(), - subscribe_options: ietf::SubscribeOptions::Namespace, - hidden, - }; - stream.writer.encode_message(&msg).await?; - } - _ => { - let msg = ietf::SubscribeNamespace { - request_id, - namespace: prefix.clone(), - hidden, - }; - stream.writer.encode_message(&msg).await?; - } - } + let msg = ietf::SubscribeNamespace { + request_id, + namespace: prefix.clone(), + hidden, + }; + stream.writer.encode_message(&msg).await?; tracing::debug!(%prefix, "subscribe_namespace sent"); @@ -1275,17 +1227,7 @@ impl Subscriber { let mut data = body.decoder(self.version); let count = match type_id { - ietf::SubscribeNamespaceOk::ID if self.version == Version::Draft14 => { - ietf::SubscribeNamespaceOk::decode_msg(&mut data, self.version)?; - None - } ietf::RequestOk::ID => ietf::RequestOk::decode_msg(&mut data, self.version)?.active, - ietf::SubscribeNamespaceError::ID if self.version == Version::Draft14 => { - let msg = ietf::SubscribeNamespaceError::decode_msg(&mut data, self.version)?; - let err = request::from_code(msg.error_code, request::Kind::SubscribeNamespace, self.version); - tracing::warn!(%err, reason = %msg.reason_phrase, "subscribe_namespace error"); - return Err(err); - } ietf::RequestError::ID => { let msg = ietf::RequestError::decode_msg(&mut data, self.version)?; let err = request::from_code(msg.error_code, request::Kind::SubscribeNamespace, self.version); @@ -1342,10 +1284,8 @@ impl Subscriber { /// overlapping one can go out: a peer may refuse a prefix that overlaps one it still /// holds. /// - /// Draft-14 and 15 ride the control stream, whose virtual streams have no close of - /// their own, so UNSUBSCRIBE_NAMESPACE is all the peer ever sees, and anything after - /// it on that ordered stream reaches the peer later. Later drafts close the stream - /// (a FIN until draft-19 makes it a reset) and read until the peer closes its half. + /// The stream closes (a FIN until draft-19 makes it a reset) and is read until the peer + /// closes its half. async fn unsubscribe_namespace(&self, request: NamespaceRequest) { let NamespaceRequest { stream: Stream { mut writer, mut reader }, @@ -1355,23 +1295,10 @@ impl Subscriber { .. } = request; // Nothing went out, so there is nothing to end. - let Some(request_id) = request_id else { - return; - }; - tracing::debug!(%prefix, "unsubscribe_namespace"); - - if matches!(self.version, Version::Draft14 | Version::Draft15) { - let msg = ietf::UnsubscribeNamespace { prefix, request_id }; - let written = async { - writer.varint(ietf::UnsubscribeNamespace::ID).await?; - writer.encode(&msg).await - }; - if let Err(err) = written.await { - tracing::debug!(%err, "failed to write unsubscribe_namespace"); - } - let _ = writer.close().await; + if request_id.is_none() { return; } + tracing::debug!(%prefix, "unsubscribe_namespace"); match super::request_stream::fin_cancels(self.version) { true => { @@ -1533,7 +1460,7 @@ impl Subscriber { if !data.is_empty() { return Err(Error::WrongSize); } - return Ok(this.reject_token(stream, request::Kind::Publish, body.clone(), err)); + return Ok(this.reject_token(stream, request::Kind::Publish, err)); } msg => msg?, }; @@ -1561,7 +1488,7 @@ impl Subscriber { if !data.is_empty() { return Err(Error::WrongSize); } - return Ok(this.reject_token(stream, request::Kind::PublishNamespace, body.clone(), err)); + return Ok(this.reject_token(stream, request::Kind::PublishNamespace, err)); } msg => msg?, }; @@ -1611,12 +1538,11 @@ impl Subscriber { &self, stream: Stream, kind: request::Kind, - body: ietf::Body, err: DecodeError, ) -> MaybeSendBox<'static, ()> { let version = self.version; async move { - if let Err(err) = super::token::reject(stream, kind, body, err, version).await { + if let Err(err) = super::token::reject(stream, kind, err, version).await { tracing::debug!(%err, "token refusal failed"); } } @@ -1640,18 +1566,11 @@ impl Subscriber { /// cannot have advertised before reading our SETUP, since our SETUP is what says whether /// advertising unasked is allowed. So this is a bug in the peer, and a silent one on /// both sides if we tolerate it. - /// - /// Draft-14/15 are exempt: they have no inline NAMESPACE, so a PUBLISH_NAMESPACE - /// request is also how a peer answers our SUBSCRIBE_NAMESPACE there, and the message - /// alone does not say which it is. fn unsolicited_is_a_violation(&self, declared: Option) -> bool { if !self.solicit { return false; } - match self.version { - Version::Draft14 | Version::Draft15 => false, - _ => declared.is_some(), - } + declared.is_some() } /// Handle an incoming PUBLISH_NAMESPACE on its bidi stream. @@ -1694,7 +1613,6 @@ impl Subscriber { if let Some(error) = super::namespace::refusal(&msg.track_namespace, self.version) { return super::request_stream::reject(stream, error).await; } - let request_id = msg.request_id; let path = msg.track_namespace.to_owned(); if self.unsolicited_is_a_violation(declared) { @@ -1709,7 +1627,6 @@ impl Subscriber { tracing::debug!(%path, "dropping reflected publish_namespace"); self.write_error( &mut stream, - request_id, &Error::Unroutable, "route loops through this relay", ) @@ -1765,7 +1682,7 @@ impl Subscriber { match admitted { Ok(grant) => (Admit::Token(slot), Some(grant)), Err(refusal) => { - self.write_error(&mut stream, request_id, &refusal.error, &refusal.reason) + self.write_error(&mut stream, &refusal.error, &refusal.reason) .await?; let _ = stream.writer.close().await; return Ok(()); @@ -1783,16 +1700,15 @@ impl Subscriber { let lived = crate::auth::RequestGrant::guard(token_grant.as_ref(), async { match self.start_announce(path.clone(), advert, admit) { Ok(id) => attached = Some(id), - Err(err) => return Ok(Withdraw::Reject(request_id, err.into())), + Err(err) => return Ok(Withdraw::Reject(err.into())), } // Buffered whole before its first await, so however this is dropped from here, the // advertisement can still end on the wire. acked = true; - self.write_ok(&mut stream, request_id).await?; + self.write_ok(&mut stream).await?; // An endpoint updates an advertisement with REQUEST_UPDATE on the stream that - // already carries it, so keep reading until the stream ends: a close on - // draft-17+, or v14-16's PublishNamespaceDone (see `terminal_publish_namespace`). + // already carries it, so keep reading until the stream closes. self.run_publish_namespace_updates( &mut stream, &path, @@ -1818,12 +1734,12 @@ impl Subscriber { Err(refusal) => { tracing::info!(%path, err = %refusal.error, reason = %refusal.reason, "request token grant ended"); if !acked { - self.write_error(&mut stream, request_id, &refusal.error, &refusal.reason) + self.write_error(&mut stream, &refusal.error, &refusal.reason) .await?; let _ = stream.writer.close().await; return Ok(()); } - self.cancel_announce(&mut stream, request_id, &path, &refusal.error, &refusal.reason) + self.cancel_announce(&mut stream) .await?; return Err(refusal.error); } @@ -1833,38 +1749,21 @@ impl Subscriber { Withdraw::Close => { let _ = stream.writer.close().await; } - Withdraw::Reject(id, refusal) => { - self.write_error(&mut stream, id, &refusal.error, &refusal.reason) + Withdraw::Reject(refusal) => { + self.write_error(&mut stream, &refusal.error, &refusal.reason) .await?; let _ = stream.writer.close().await; } - Withdraw::Cancel(id, refusal) => { - self.write_error(&mut stream, id, &refusal.error, &refusal.reason) + Withdraw::Cancel(refusal) => { + self.write_error(&mut stream, &refusal.error, &refusal.reason) .await?; - self.cancel_announce(&mut stream, request_id, &path, &refusal.error, &refusal.reason) + self.cancel_announce(&mut stream) .await?; } } Ok(()) } - /// Whether `type_id` retracts a PUBLISH_NAMESPACE rather than updating it. - /// - /// v14-16 carry the stream over the control stream, and the adapter delivers the - /// terminal message *before* it FINs (`Route::CloseStream`), so the withdrawal - /// arrives here as a message and only then as a close. Draft-17+ has a real stream, - /// where the close alone retracts and a terminal message on it is a violation. - /// - /// Only PUBLISH_NAMESPACE_DONE: the publisher sends that one. PUBLISH_NAMESPACE_CANCEL - /// travels the other way, so receiving it on an advertisement *we* were offered is a - /// violation, not a withdrawal. - fn terminal_publish_namespace(&self, type_id: u64) -> bool { - match self.version { - Version::Draft14 | Version::Draft15 | Version::Draft16 => type_id == ietf::PublishNamespaceDone::ID, - _ => false, - } - } - /// Read advertisement updates off a live PUBLISH_NAMESPACE stream until it closes, and /// return how it ends, which the caller writes once the route is released. /// @@ -1917,11 +1816,9 @@ impl Subscriber { let turn = if let Some((id, body)) = renewal.next() { Turn::Message(id, body) } else { - let version = self.version; kio::wait(|waiter| { let mut cx = waiter.context(); - if !matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) - && let Poll::Ready(result) = stream.writer.poll_closed(&mut cx) + if let Poll::Ready(result) = stream.writer.poll_closed(&mut cx) { return Poll::Ready(Turn::WriterClosed(result)); } @@ -1947,25 +1844,22 @@ impl Subscriber { let (type_id, body) = match turn { // A non-terminal message read while a verdict is pending waits for it. - Turn::Message(id, body) if renewal.pending() && !self.terminal_publish_namespace(id) => { + Turn::Message(id, body) if renewal.pending() => { if id == ietf::PublishNamespaceUpdate::ID { // Its request ID is spent on arrival, so one dropped with the queue stays spent. - if self.version != Version::Draft16 { - let update_id = ietf::RequestId::decode(&mut body.decoder(self.version), self.version)?; - if let Err(err) = self.spend(update_id) { - if matches!(err, Error::GoingAway) { - return Ok(Withdraw::Cancel( - update_id, - crate::auth::Refusal { - error: err, - reason: "going away".to_string(), - }, - )); - } - return Err(err); + let update_id = ietf::RequestId::decode(&mut body.decoder(self.version), self.version)?; + if let Err(err) = self.spend(update_id) { + if matches!(err, Error::GoingAway) { + return Ok(Withdraw::Cancel( + crate::auth::Refusal { + error: err, + reason: "going away".to_string(), + }, + )); } - spent.insert(update_id); + return Err(err); } + spent.insert(update_id); // Decoded on arrival too, so a session-fatal update still closes the session // when a withdrawal drops the queue. A token refusal only refuses this // announce, which waits for the update's turn. @@ -1992,8 +1886,6 @@ impl Subscriber { Err(request_update::Overflow::Request) => return Ok(Withdraw::Close), } } - // A terminal read while a verdict is pending is handled now, ahead of any queued - // update: nothing more is owed once the peer retracts. Turn::Message(id, body) => (id, body), Turn::Fin => { if super::request_stream::fin_cancels(self.version) { @@ -2017,31 +1909,22 @@ impl Subscriber { Turn::Renewal(request_update::Verdict { verdict, grant: res, - request_id: rid, }) => { // Only a token-authorized announce starts a renewal. let rg = token_grant.as_ref().expect("a renewal without a request grant"); // On accept the old grant is dropped and the deadline re-armed (REQUEST_OK). let Err(refusal) = rg.renew(verdict, res) else { - self.write_ok(stream, rid).await?; + self.write_ok(stream).await?; continue; }; - // Per drafts 16 section 9.11.1 / 18 section 10.9.1, a refused or uncovered + // Per draft-18 section 10.9.1, a refused or uncovered // renewal ends only this announce. Answer REQUEST_ERROR, then close the stream; // the session stays up and the old grant does not survive. - return Ok(Withdraw::Cancel(rid, refusal)); + return Ok(Withdraw::Cancel(refusal)); } }; - // Drafts 14-15 have no update for an advertisement, so a SUBSCRIBE_UPDATE the adapter - // routed here is refused and changes nothing. Draft-16's REQUEST_UPDATE renews its token. - if type_id == ietf::SubscribeUpdate::ID && matches!(self.version, Version::Draft14 | Version::Draft15) { - super::request_stream::refuse_update(&mut stream.writer, &body, self.version)?; - std::future::poll_fn(|cx| stream.writer.poll_flush(cx)).await?; - continue; - } - let terminal = self.terminal_publish_namespace(type_id); - if type_id != ietf::PublishNamespaceUpdate::ID && !terminal { + if type_id != ietf::PublishNamespaceUpdate::ID { // A repeated PUBLISH_NAMESPACE lands here too: a second request on the // stream is the base draft's duplicate request ID. tracing::warn!(type_id, "unexpected message on publish_namespace stream"); @@ -2050,26 +1933,14 @@ impl Subscriber { let mut data = body.decoder(self.version); - if terminal { - ietf::PublishNamespaceDone::decode_msg(&mut data, self.version)?; - if !data.is_empty() { - return Err(Error::WrongSize); - } - tracing::debug!(%path, "publish_namespace_done"); - return Ok(Withdraw::Done); - } - - // An update spends its own request ID, even one refused below. On draft-16 the - // adapter already spent it when it routed the update here, and a queued one was + // An update spends its own request ID, even one refused below. A queued one was // spent when it arrived. let update_id = ietf::RequestId::decode(&mut body.decoder(self.version), self.version)?; - if self.version != Version::Draft16 - && !spent.remove(&update_id) + if !spent.remove(&update_id) && let Err(err) = self.spend(update_id) { if matches!(err, Error::GoingAway) { return Ok(Withdraw::Cancel( - update_id, crate::auth::Refusal { error: err, reason: "going away".to_string(), @@ -2090,7 +1961,7 @@ impl Subscriber { reason: super::token::reason(&err).to_string(), error: Error::Decode(err), }; - return Ok(Withdraw::Cancel(update_id, refusal)); + return Ok(Withdraw::Cancel(refusal)); } msg => msg?, }; @@ -2156,7 +2027,7 @@ impl Subscriber { // The close is the withdrawal. if let Err(err) = applied { tracing::warn!(%path, %err, "publish_namespace update refused"); - return Ok(Withdraw::Reject(msg.request_id, err.into())); + return Ok(Withdraw::Reject(err.into())); } // A REQUEST_UPDATE carrying a fresh token refreshes the announce's request grant @@ -2167,7 +2038,7 @@ impl Subscriber { if let Some(token) = msg.authorization_token { match &token_grant { Some(grant) => { - renewal.verify(grant.verify_renewal(&self.auth, token.0), msg.request_id); + renewal.verify(grant.verify_renewal(&self.auth, token.0)); continue; } // Where tokens decide, a token on an announce admitted without one is refused @@ -2177,14 +2048,14 @@ impl Subscriber { error: Error::Unsupported, reason: "AUTHORIZATION TOKEN on an announce admitted without one".to_string(), }; - return Ok(Withdraw::Cancel(msg.request_id, refusal)); + return Ok(Withdraw::Cancel(refusal)); } None => {} } } // No token rides this update: acknowledge it now. - self.write_ok(stream, msg.request_id).await?; + self.write_ok(stream).await?; } } @@ -2197,27 +2068,11 @@ impl Subscriber { Ok(()) } - /// End an advertisement we accepted, leaving the session up: a closed stream from draft-17, - /// and PUBLISH_NAMESPACE_CANCEL before it, where the request outlives its stream. + /// End an advertisement we accepted, leaving the session up: a closed stream. async fn cancel_announce( &self, stream: &mut Stream, - request_id: RequestId, - path: &PathOwned, - err: &Error, - reason: &str, ) -> Result<(), Error> { - if matches!(self.version, Version::Draft14 | Version::Draft15 | Version::Draft16) { - stream - .writer - .encode_message(&ietf::PublishNamespaceCancel { - track_namespace: path.clone(), - request_id, - error_code: request::to_code(err, request::Kind::PublishNamespace, self.version), - reason_phrase: reason.into(), - }) - .await?; - } // An OK cut short by the grant ending is still buffered, and goes out ahead of the FIN. std::future::poll_fn(|cx| stream.writer.poll_flush(cx)).await?; if stream.writer.finish().is_ok() { @@ -2256,7 +2111,6 @@ impl Subscriber { // before reading this are dropped by the unknown-alias path instead. self.write_publish_error( &mut stream, - msg.request_id, &Error::Unsupported, "PUBLISH is not supported", ) @@ -2284,35 +2138,14 @@ impl Subscriber { Ok(()) } - async fn write_ok(&self, stream: &mut Stream, request_id: RequestId) -> Result<(), Error> { - match self.version { - Version::Draft14 => { - stream - .writer - .encode_message(&ietf::PublishNamespaceOk { request_id }) - .await?; - } - Version::Draft15 | Version::Draft16 => { - stream - .writer - .encode_message(&ietf::RequestOk { - largest: None, - request_id: Some(request_id), - active: None, - }) - .await?; - } - _ => { - stream - .writer - .encode_message(&ietf::RequestOk { - largest: None, - request_id: None, - active: None, - }) - .await?; - } - } + async fn write_ok(&self, stream: &mut Stream) -> Result<(), Error> { + stream + .writer + .encode_message(&ietf::RequestOk { + largest: None, + active: None, + }) + .await?; Ok(()) } @@ -2320,14 +2153,12 @@ impl Subscriber { async fn write_error( &self, stream: &mut Stream, - request_id: RequestId, err: &Error, reason: &str, ) -> Result<(), Error> { super::request_stream::write_error( &mut stream.writer, request::Kind::PublishNamespace, - request_id, err, reason, self.version, @@ -2339,14 +2170,12 @@ impl Subscriber { async fn write_publish_error( &self, stream: &mut Stream, - request_id: RequestId, err: &Error, reason: &str, ) -> Result<(), Error> { super::request_stream::write_error( &mut stream.writer, request::Kind::Publish, - request_id, err, reason, self.version, @@ -2804,11 +2633,6 @@ impl Subscriber { if !matches!(lister.poll_used(waiter), Poll::Ready(Ok(()))) { return; } - if !super::subscribe_tracks::has_subscribe_tracks(self.version) { - // An empty answer would claim the peer lists nothing. - lister.abort(Error::Unsupported); - continue; - } *listening = Some(self.listen(path.to_owned(), lister.clone())); } Some(_) if lister.poll_unused(waiter).is_ready() => { @@ -2877,10 +2701,9 @@ impl Subscriber { // Demand with nobody subscribing (fetches, or a TRACK_STATUS downstream) learns the // track from TRACK_STATUS rather than a SUBSCRIBE: a finished track refuses one, and - // one made only to learn the track races the fetches it was for. Draft-17 still - // SUBSCRIBEs: its TRACK_STATUS answer cannot say whether the track is timed. + // one made only to learn the track races the fetches it was for. let mut target = match request.subscription() { - None if ietf::TrackStatusOk::describes_track(self.version) => { + None => { let Some(idle) = self .track_status(&broadcast_path, &track_name, request, &mut gate) .await @@ -2998,31 +2821,14 @@ impl Subscriber { }) .await { - Ok(stream) => super::request_stream::with_stats(stream, self.origin.stats(), self.version), + Ok(stream) => stream.with_stats(self.origin.stats()), Err(err) => { target.fail(err); return None; } }; - // Opening spends no ID. Once allocated, drafts 14-16 must receive the request - // to return its MAX_REQUEST_ID credit; the response wait cancels it instead. - let mut timeout = crate::time::Deadline::after(&self.runtime, Control::REQUEST_ID_TIMEOUT); - let request_id = kio::wait(|waiter| { - if gate.poll_denied(waiter).is_ready() { - return Poll::Ready(Err(Error::Unauthorized)); - } - validity.check(waiter)?; - self.control.poll_credit(waiter, &mut timeout) - }) - .await; - let request_id = match request_id { - Ok(id) => id, - Err(err) => { - target.fail(err); - return None; - } - }; + let request_id = self.control.next_request_id(); let messages = super::request_stream::Messages::new(self.session.clone(), self.control.client()); (request_id, stream, messages) } @@ -3071,7 +2877,7 @@ impl Subscriber { // Without an Established subscription, a relay includes the request it holds. let new_group = target .new_group() - .filter(|_| super::subscribe::has_new_group_request(self.version)); +; let written = match &held { // Resume the held subscription: its group order is the one it was made with, // since no update can change it. Its groups wait on the answer from here. @@ -3255,7 +3061,7 @@ impl Subscriber { // The publisher may already be serving before it answers. A session abort // already rejected the parked request; dropping what remains is not a second one. let aborted = self.remove_subscribe(request_id).is_none(); - self.cancel_subscribe(stream, request_id).await; + self.cancel_subscribe(stream).await; // A resumed copy goes back to lingering, unless the session took it. return resumed.filter(|_| !aborted); }; @@ -3281,7 +3087,7 @@ impl Subscriber { if let Some(idle) = resumed { let _ = idle.track.abort(err); } - self.cancel_subscribe(stream, request_id).await; + self.cancel_subscribe(stream).await; return None; } Ok(Some(accepted)) => accepted, @@ -3319,7 +3125,7 @@ impl Subscriber { let _ = idle.track.abort(err); } if cancel { - self.cancel_subscribe(stream, request_id).await; + self.cancel_subscribe(stream).await; } return None; } @@ -3429,7 +3235,7 @@ impl Subscriber { ); } else { tracing::warn!(track_alias = %alias, %err, "could not bind track alias"); - self.cancel_subscribe(stream, request_id).await; + self.cancel_subscribe(stream).await; } self.remove_subscribe(request_id); let _ = track.abort(err); @@ -3453,7 +3259,7 @@ impl Subscriber { // The NEW_GROUP_REQUEST last sent, the SUBSCRIBE's included. It stays outstanding // until the Largest Group reaches it, and joins meanwhile ask for the same group. let mut requested = new_group; - let dynamic_groups = track.info().refresh.is_some() && super::subscribe::has_new_group_request(self.version); + let dynamic_groups = track.info().refresh.is_some(); // The group the track's consumers want, `None` once nobody does. let mut wanted = None; // The subscriber priority upstream holds, and the one the aggregate now asks for. @@ -3461,17 +3267,8 @@ impl Subscriber { let mut wanted_max_age = max_age; let mut sent_priority = priority; let mut priority = priority; - // Draft-14's SUBSCRIBE_UPDATE repeats the bounds it leaves alone, and must not move the - // start. A Largest Object subscription starts just past the answer's Largest. - let start_location = largest.map_or(ietf::Location { group: 0, object: 0 }, |largest| ietf::Location { - group: largest.group, - object: largest.object.saturating_add(1), - }); - // REQUEST_UPDATEs sent and not yet answered. Draft-14 answers none, and draft-15's - // answer names only the update's own Request ID, which reaches no subscription, so - // only draft-16 on count them; the adapter routes draft-16's back by that ID. + // REQUEST_UPDATEs sent and not yet answered. let unanswered = AtomicU64::new(0); - let answered_here = !matches!(self.version, Version::Draft14 | Version::Draft15); let mut fetch_done = fetching.is_none(); // Our grant stopped covering the track: it is aborted rather than kept lingering. @@ -3556,8 +3353,7 @@ impl Subscriber { && largest_group(&track, largest).is_some_and(|largest| value > largest) && requested.is_none_or(|requested| value > requested) }); - let mut update = Update { - start_location, + let update = Update { priority: (priority != sent_priority).then_some(priority), max_age: wanted_max_age.filter(|_| wanted_max_age != sent_max_age), new_group, @@ -3567,9 +3363,6 @@ impl Subscriber { } // Draft-14's SUBSCRIBE_UPDATE cannot omit the priority, so it restates the one // in force rather than resetting it to the omission default. - if self.version == Version::Draft14 { - update.priority = Some(priority); - } Poll::Ready(End::Update(update)) }) .await; @@ -3577,7 +3370,7 @@ impl Subscriber { match end { End::Update(update) => { let (asked, new_group, asked_age) = (update.priority, update.new_group, update.max_age); - if let Err(err) = self.write_update(&mut stream.writer, request_id, update).await { + if let Err(err) = self.write_update(&mut stream.writer, update).await { tracing::debug!(%err, "failed to update the subscription"); ended = Some(Err(err.clone())); let _ = track.clone().abort(err); @@ -3592,9 +3385,7 @@ impl Subscriber { if let Some(value) = new_group { requested = Some(value); } - if answered_here { - unanswered.fetch_add(1, Ordering::Relaxed); - } + unanswered.fetch_add(1, Ordering::Relaxed); } End::Revoked => { tracing::info!(broadcast = %self.origin.absolute(broadcast_path), track = %track_name, "subscription no longer authorized"); @@ -3730,7 +3521,7 @@ impl Subscriber { { // Refusing the copy wakes its FETCH jobs too. Keep driving their cancels // while this stream waits for its FIN, even if the peer never ACKs it. - let mut cancelling = std::pin::pin!(self.cancel_subscribe(stream, request_id)); + let mut cancelling = std::pin::pin!(self.cancel_subscribe(stream)); kio::wait(|waiter| { let _ = group_fetches.poll(waiter); waiter.poll_future(cancelling.as_mut()) @@ -3890,24 +3681,18 @@ impl Subscriber { } } - /// Update an Established subscription: REQUEST_UPDATE (SUBSCRIBE_UPDATE through draft-16) - /// carrying only what changed, under a Request ID of its own. + /// Update an Established subscription: REQUEST_UPDATE carrying only what changed, under a + /// Request ID of its own. async fn write_update( &self, writer: &mut Writer, - subscription: RequestId, update: Update, ) -> Result<(), Error> { - let request_id = self.control.next_request_id(&self.runtime).await?; + let request_id = self.control.next_request_id(); writer .encode_message(&ietf::SubscribeUpdate { max_age: update.max_age, request_id, - subscription_request_id: matches!(self.version, Version::Draft14 | Version::Draft15 | Version::Draft16) - .then_some(subscription), - start_location: update.start_location, - // Open ended, as every subscription we send. - end_group: 0, subscriber_priority: update.priority.map(super::priority::to_wire), forward: None, filter: None, @@ -3924,52 +3709,26 @@ impl Subscriber { /// staying silent is what leaves the publisher serving a track nobody is reading and /// feeding an alias we already retired. /// - /// Two mechanisms, by version. Draft-14 through 16 carry requests over the control - /// stream adapter, whose virtual streams have no reset or stop of their own, so - /// UNSUBSCRIBE (draft-16 section 9.12) is the only thing the peer ever sees, and - /// draft-16 section 5.1.1 makes receiving it what frees the subscription. Draft-17 - /// removed the message, leaving the stream itself: a FIN is explicitly not a + /// There is no UNSUBSCRIBE message, only the stream itself: a FIN is explicitly not a /// cancellation (draft-19 section 3.3.2), so section 3.3.3's pair applies, an endpoint /// that has already FINed its sending direction cancels with STOP_SENDING on the /// receiving one. - async fn cancel_subscribe(&self, stream: Stream, request_id: RequestId) { - let Stream { mut writer, mut reader } = stream; - - if self.unsubscribes() - && let Err(err) = self.write_unsubscribe(&mut writer, request_id).await - { - tracing::debug!(%err, "failed to write unsubscribe"); - } + async fn cancel_subscribe(&self, stream: Stream) { + let Stream { writer, mut reader } = stream; // STOP_SENDING needs no acknowledgement, so it goes first and the wait below covers // only what we still have to deliver. reader.abort(&Error::Cancel); // Finishing alone would leave the writer's Drop free to RESET_STREAM, and a stream - // that has sent its FIN is still retransmitting: the reset would discard the - // UNSUBSCRIBE before the peer ever read it, which is the whole message. Closing - // consumes the writer, removing that fallback, and waits for the acknowledgement. + // that has sent its FIN is still retransmitting: the reset would discard what we + // already wrote. Closing consumes the writer, removing that fallback, and waits for + // the acknowledgement. if let Err(err) = writer.close().await { tracing::debug!(%err, "failed to close the subscribe stream"); } } - /// Whether this version cancels a subscription with an UNSUBSCRIBE message. - /// - /// Draft-17 removed it, leaving the stream reset as the only signal. - fn unsubscribes(&self) -> bool { - matches!(self.version, Version::Draft14 | Version::Draft15 | Version::Draft16) - } - - async fn write_unsubscribe( - &self, - writer: &mut crate::coding::Writer, - request_id: RequestId, - ) -> Result<(), Error> { - writer.encode_message(&ietf::Unsubscribe { request_id }).await?; - Ok(()) - } - /// Send the joining FETCH that follows a pre-draft-20 SUBSCRIBE, and keep reading its /// answer until the subscription ends. /// @@ -4000,20 +3759,8 @@ impl Subscriber { Stream::poll_open_request(&mut opening, this.version, &mut waiter.context()) }) .await?; - stream = super::request_stream::with_stats(stream, this.origin.stats(), this.version); - let mut timeout = crate::time::Deadline::after(&this.runtime, Control::REQUEST_ID_TIMEOUT); - let fetch_id = kio::wait(|waiter| { - validity.check(waiter)?; - if let Poll::Ready(err) = track.poll_closed(waiter) { - return Poll::Ready(Err(err)); - } - this.control.poll_credit(waiter, &mut timeout) - }) - .await?; - // On the shared control streams of drafts 14-16, later IDs must - // not overtake this header even if its subscription cancels mid-write. - let sending = matches!(this.version, Version::Draft14 | Version::Draft15 | Version::Draft16) - .then(|| this.control.sending()); + stream = stream.with_stats(this.origin.stats()); + let fetch_id = this.control.next_request_id(); progress.lock().committed = true; { let mut state = this.state.lock(); @@ -4047,17 +3794,8 @@ impl Subscriber { .await { tracing::debug!(%err, "failed to write joining FETCH"); - if matches!(this.version, Version::Draft14 | Version::Draft15) { - // A sequential-ID peer cannot accept any later request when this - // header failed before it learned the allocated ID. - this.session.close( - super::error::to_session_code(&SessionError::Internal), - "failed to send joining FETCH", - ); - } return Err(err); } - drop(sending); this.finish_joining_fetch(stream, progress).await } .await; @@ -4119,10 +3857,7 @@ impl Subscriber { }; // The request stays open while the subscription still needs its fill. From draft 18 // it may carry a GOAWAY meanwhile; before that, nothing follows the answer here. - let mut finished = matches!( - self.version, - Version::Draft14 | Version::Draft15 | Version::Draft16 | Version::Draft17 - ); + let mut finished = false; kio::wait(|waiter| { if !finished { let mut cx = waiter.context(); @@ -4161,17 +3896,6 @@ impl Subscriber { largest: msg.largest, })) } - // The rejection reaches the track as the reason the publisher gave, so a - // subscriber can tell a broadcast that is not there from one it may not have. - ietf::SubscribeError::ID if self.version == Version::Draft14 => { - let msg = ietf::SubscribeError::decode_msg(&mut data, self.version)?; - tracing::warn!(message = ?msg, "subscribe error"); - Err(request::from_code( - msg.error_code, - request::Kind::Subscribe, - self.version, - )) - } ietf::RequestError::ID => { let msg = ietf::RequestError::decode_msg(&mut data, self.version)?; tracing::warn!(message = ?msg, "request error"); @@ -4212,23 +3936,8 @@ impl Subscriber { return None; } }; - stream = super::request_stream::with_stats(stream, self.origin.stats(), self.version); - let mut timeout = crate::time::Deadline::after(&self.runtime, Control::REQUEST_ID_TIMEOUT); - let request_id = match kio::wait(|waiter| { - if gate.poll_denied(waiter).is_ready() { - return Poll::Ready(Err(Error::Unauthorized)); - } - validity.check(waiter)?; - self.control.poll_credit(waiter, &mut timeout) - }) - .await - { - Ok(id) => id, - Err(err) => { - request.reject(err); - return None; - } - }; + stream = stream.with_stats(self.origin.stats()); + let request_id = self.control.next_request_id(); let written = async { stream @@ -4342,13 +4051,10 @@ impl Subscriber { let mut data = body.decoder(self.version); let code = match type_id { - id if id == ietf::TrackStatusOk::id(self.version) => { + id if id == ietf::TrackStatusOk::ID => { return Ok(ietf::TrackStatusOk::decode_msg(&mut data, self.version)?); } - ietf::TRACK_STATUS_ERROR_14 if self.version == Version::Draft14 => { - ietf::SubscribeError::decode_msg(&mut data, self.version)?.error_code - } - ietf::RequestError::ID if self.version != Version::Draft14 => { + ietf::RequestError::ID if true => { ietf::RequestError::decode_msg(&mut data, self.version)?.error_code } _ => return Err(Error::UnexpectedMessage), @@ -4550,7 +4256,7 @@ impl Subscriber { let (payload, status) = match datagram.body { ietf::DatagramBody::Payload(payload) => (payload, None), - ietf::DatagramBody::Status(status) if super::object::status_defined(status, self.version) => { + ietf::DatagramBody::Status(status) if super::object::status_defined(status) => { (bytes::Bytes::new(), Some(status)) } ietf::DatagramBody::Status(_) => return Err(Error::Session(SessionError::ProtocolViolation)), @@ -5078,14 +4784,14 @@ impl Subscriber { ) -> Result<(), Error> { let mut prior_group = None; let mut first = true; - while let Some(object) = decode_fetch_object(stream, self.version, std::mem::take(&mut first)).await? { + while let Some(object) = decode_fetch_object(stream, std::mem::take(&mut first)).await? { if !object.datagram && !object.subgroup_ok { tracing::warn!("subgroup ID is not supported, dropping fill"); return Err(Error::Unsupported); } // Object ID still keys off whether the wire Group ID field was present. - let group = resolve_fetch_group(self.version, prior_group, object.group)?; + let group = resolve_fetch_group(prior_group, object.group)?; if let Some(sequence) = group { prior_group = Some(sequence); } @@ -5103,14 +4809,6 @@ impl Subscriber { .filter(|(sequence, _, _)| group.is_none_or(|group| group == *sequence)) .map_or(0, |(_, next, _)| *next); let id = match (object.group.is_some(), object.object) { - (_, Some(id)) - if matches!( - self.version, - Version::Draft14 | Version::Draft15 | Version::Draft16 | Version::Draft17 - ) => - { - id - } (true, Some(id)) => id, (false, Some(delta)) => expected .checked_sub(1) @@ -5141,21 +4839,8 @@ impl Subscriber { wire.first_id = id; producer.set_wire(wire)?; } - if self - .recv_fetch_payload( - stream, - producer, - FetchPayload { - decoded, - raw, - timescale, - id, - }, - ) - .await? != Fetched::Frame - { - return Err(Error::Unsupported); - } + self.recv_fetch_payload(stream, producer, FetchPayload { decoded, timescale, id }) + .await?; *next = id.checked_add(1).ok_or(Error::ProtocolViolation)?; } @@ -5168,38 +4853,10 @@ impl Subscriber { stream: &mut Reader, producer: &mut crate::recv::Group, payload: FetchPayload, - ) -> Result { - let FetchPayload { - decoded, - raw, - timescale, - id, - } = payload; + ) -> Result<(), Error> { + let FetchPayload { decoded, timescale, id } = payload; producer.mark_gap(id, decoded.gap)?; let size = stream.varint().await?; - if size == 0 && matches!(self.version, Version::Draft14 | Version::Draft15) { - let status = stream.varint().await?; - // A status object has no frame to hold its time, so its block keeps it. - let unframed = match status { - 0 => None, - _ => { - let properties = super::object::unframed(&raw, self.version, timescale)?; - super::object::check_status(self.version, &properties)?; - Some(properties) - } - }; - match (status, unframed) { - (0, _) => {} - (END_OF_GROUP, Some(properties)) => { - producer.set_end_object(crate::model::object::Fields { id, properties })?; - return Ok(Fetched::EndOfGroup); - } - // END_OF_TRACK is track-level, so there is nowhere to keep its properties. - (END_OF_TRACK, Some(properties)) if !properties.is_empty() => return Err(Error::Unsupported), - (END_OF_TRACK, _) => return Ok(Fetched::EndOfTrack), - _ => return Err(Error::Unsupported), - } - } super::object::check_frame(&decoded.properties, timescale)?; let timestamp = object_time(timescale, decoded.timestamp)?; let plain = id == producer.frame_count() as u64 && decoded.properties.is_empty(); @@ -5220,7 +4877,7 @@ impl Subscriber { return Err(err); } producer.restore(frame.finish()?); - Ok(Fetched::Frame) + Ok(()) } /// Serve a fill a group at a time, newest first for a descending reader, until it is @@ -5277,20 +4934,8 @@ impl Subscriber { Ok(stream) => stream, Err(err) => return request.reject(err), }; - stream = super::request_stream::with_stats(stream, self.origin.stats(), self.version); - let mut timeout = crate::time::Deadline::after(&self.runtime, Control::REQUEST_ID_TIMEOUT); - let fetch_id = match kio::wait(|waiter| { - validity.check(waiter)?; - if let Poll::Ready(err) = request.poll_closed(waiter) { - return Poll::Ready(Err(err)); - } - self.control.poll_credit(waiter, &mut timeout) - }) - .await - { - Ok(id) => id, - Err(err) => return request.reject(err), - }; + stream = stream.with_stats(self.origin.stats()); + let fetch_id = self.control.next_request_id(); // Registered before the FETCH goes out, since its stream can overtake FETCH_OK. let slot = kio::Producer::new(GroupFetch::Pending); @@ -5377,7 +5022,7 @@ impl Subscriber { SetupResponse::Cancelled(err) => { request.reject(err); drop(registered); - self.cancel_group_fetch(stream, fetch_id).await; + self.cancel_group_fetch(stream).await; return; } SetupResponse::Response(Err(err)) => { @@ -5480,12 +5125,7 @@ impl Subscriber { let reset = kio::wait(|waiter| { if open { let mut cx = std::task::Context::from_waker(waiter.waker()); - let closed = match self.version { - Version::Draft14 | Version::Draft15 | Version::Draft16 => { - super::request_stream::poll_legacy_end(&mut stream, self.version, &mut cx) - } - _ => messages.poll_end(&mut stream.reader, &mut cx), - }; + let closed = messages.poll_end(&mut stream.reader, &mut cx); match closed { Poll::Ready(Err(err)) => return Poll::Ready(Some(err)), Poll::Ready(Ok(())) => open = false, @@ -5518,7 +5158,7 @@ impl Subscriber { .await; if abandoned { drop(registered); - self.cancel_group_fetch(stream, fetch_id).await; + self.cancel_group_fetch(stream).await; return; } // A group already written stays cached; only one still waiting for its stream is lost. @@ -5533,23 +5173,9 @@ impl Subscriber { } /// Cancel a FETCH using the negotiated draft's existing cancellation signal. - async fn cancel_group_fetch(&self, mut stream: Stream, request_id: RequestId) { + async fn cancel_group_fetch(&self, mut stream: Stream) { stream.reader.abort(&Error::Cancel); - match self.version { - Version::Draft14 | Version::Draft15 | Version::Draft16 => { - // The adapter has no transport reset, so deliver FETCH_CANCEL without a - // subsequent writer drop discarding unacknowledged control bytes. - let res = async { - stream.writer.encode_message(&ietf::FetchCancel { request_id }).await?; - stream.writer.close().await - } - .await; - if let Err(err) = res { - tracing::debug!(%err, "failed to cancel group fetch"); - } - } - _ => stream.writer.abort(&Error::Cancel), - } + stream.writer.abort(&Error::Cancel) } /// Read the answer to a FETCH: FETCH_OK, or the publisher's refusal as an error. @@ -5563,10 +5189,6 @@ impl Subscriber { match type_id { ietf::FetchOk::ID => Ok(ietf::FetchOk::decode_msg(&mut data, self.version)?), - ietf::FetchError::ID if self.version == Version::Draft14 => { - let msg = ietf::FetchError::decode_msg(&mut data, self.version)?; - Err(request::from_code(msg.error_code, request::Kind::Fetch, self.version)) - } ietf::RequestError::ID => { let msg = ietf::RequestError::decode_msg(&mut data, self.version)?; Err(request::from_code(msg.error_code, request::Kind::Fetch, self.version)) @@ -5671,13 +5293,8 @@ impl Subscriber { let sequence = producer.info().sequence; let mut next = start; let mut prior_group = None; - let mut ended = false; let mut first = true; - while let Some(object) = decode_fetch_object(stream, self.version, std::mem::take(&mut first)).await? { - if ended { - tracing::warn!(sequence, "a group fetch continued past its end marker"); - return Err(Error::ProtocolViolation); - } + while let Some(object) = decode_fetch_object(stream, std::mem::take(&mut first)).await? { if object.datagram { tracing::debug!(sequence, "a datagram group is not fetchable"); return Err(Error::NotFetchable); @@ -5687,19 +5304,11 @@ impl Subscriber { return Err(Error::Unsupported); } - let group = resolve_fetch_group(self.version, prior_group, object.group)?; + let group = resolve_fetch_group(prior_group, object.group)?; if let Some(group) = group { prior_group = Some(group); } let id = match (object.group.is_some(), object.object) { - (_, Some(id)) - if matches!( - self.version, - Version::Draft14 | Version::Draft15 | Version::Draft16 | Version::Draft17 - ) => - { - id - } (true, Some(id)) => id, (false, Some(delta)) => next .checked_sub(1) @@ -5716,27 +5325,9 @@ impl Subscriber { if id > next && decoded.gap.is_none_or(|gap| gap < id - next) { return Err(Error::Unsupported); } - match self - .recv_fetch_payload( - stream, - producer, - FetchPayload { - decoded, - raw, - timescale, - id, - }, - ) - .await? - { - Fetched::Frame => next = id.checked_add(1).ok_or(Error::ProtocolViolation)?, - // The status is an object of the group, so the End Location counts it. - Fetched::EndOfGroup => { - next = id.checked_add(1).ok_or(Error::ProtocolViolation)?; - ended = true; - } - Fetched::EndOfTrack => ended = true, - } + self.recv_fetch_payload(stream, producer, FetchPayload { decoded, timescale, id }) + .await?; + next = id.checked_add(1).ok_or(Error::ProtocolViolation)?; if end.is_some_and(|end| next > end) { tracing::warn!(sequence, ?end, "a group fetch continued past FETCH_OK's End Location"); return Err(Error::ProtocolViolation); @@ -5760,20 +5351,8 @@ impl Subscriber { } } -/// What a fetch object carried. -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -enum Fetched { - Frame, - /// A draft-14 or 15 END_OF_GROUP status object. - EndOfGroup, - /// A draft-14 or 15 END_OF_TRACK marker. - EndOfTrack, -} - struct FetchPayload { decoded: super::object::Decoded, - /// The property list `decoded` was read from, for a status object, which has no frame. - raw: bytes::Bytes, timescale: Option, id: u64, } @@ -5795,26 +5374,8 @@ struct FetchedObject { /// the prior object is a protocol violation. async fn decode_fetch_object( stream: &mut Reader, - version: Version, first: bool, ) -> Result, Error> { - if version == Version::Draft14 { - let Some(group) = stream.varint_maybe().await? else { - return Ok(None); - }; - let subgroup = stream.varint().await?; - let object = stream.varint().await?; - let _priority = stream.read_exact(1).await?; - let ObjectExtensionsLength(size) = stream.decode().await?; - let properties = stream.read_exact(size).await?.to_vec(); - return Ok(Some(FetchedObject { - group: Some(group), - object: Some(object), - datagram: false, - subgroup_ok: subgroup == 0, - properties: Some(properties), - })); - } Ok(match stream.decode_maybe::().await? { None => None, @@ -5856,20 +5417,15 @@ async fn decode_fetch_object( /// The first object is always absolute. Draft-14 through draft-17 keep sending the /// absolute ID when the field is present; draft-18 and later send a Group ID Delta, /// resolved here in the ascending order this FETCH requested. -fn resolve_fetch_group(version: Version, prior: Option, wire: Option) -> Result, Error> { +fn resolve_fetch_group(prior: Option, wire: Option) -> Result, Error> { let Some(wire) = wire else { return Ok(None); }; let Some(prior) = prior else { return Ok(Some(wire)); }; - match version { - Version::Draft14 | Version::Draft15 | Version::Draft16 | Version::Draft17 => Ok(Some(wire)), - _ => { - let step = wire.checked_add(1).ok_or(Error::Unsupported)?; - prior.checked_add(step).map(Some).ok_or(Error::Unsupported) - } - } + let step = wire.checked_add(1).ok_or(Error::Unsupported)?; + prior.checked_add(step).map(Some).ok_or(Error::Unsupported) } fn open_fill_group( @@ -6010,7 +5566,7 @@ impl GroupIngest { } // A status object has no frame to hold its time, so its block keeps it. self.properties = super::object::unframed(&self.raw, self.version, self.timescale)?; - super::object::check_status(self.version, &self.properties)?; + super::object::check_status(&self.properties)?; if status == END_OF_GROUP { group.mark_gap(self.prior_object.expect("properties follow Object ID"), self.gap)?; group.set_end_object(crate::model::object::Fields { @@ -6124,7 +5680,7 @@ mod tests { let mut session = ScriptedSession::new(wire); let (_, recv) = session.open_bi(Default::default()).await.unwrap(); let mut reader = Reader::new(crate::transport::boxed::RecvStream::new(recv), VERSION); - let result = decode_fetch_object(&mut reader, VERSION, true) + let result = decode_fetch_object(&mut reader, true) .now_or_never() .expect("refused at the prefix, not parked on the body"); assert!( @@ -6142,8 +5698,7 @@ mod tests { .varint(ietf::PublishDone::ID) .unwrap(); ietf::PublishDone { - request_id: None, - status_code: ietf::PublishDoneStatus::TrackEnded.code(Version::Draft19), + status_code: ietf::PublishDoneStatus::TrackEnded.code(), stream_count: 0, reason_phrase: "done".into(), } @@ -6319,7 +5874,7 @@ mod tests { /// nothing there is enforceable: our own publisher advertises exactly this way. #[moq_clock::test] async fn a_legacy_announce_is_never_a_violation() { - for version in [Version::Draft14, Version::Draft15] { + for version in [Version::Draft15] { assert!( !unsolicited_is_a_violation(Some(true), version), "{version:?} answers a subscription this way" @@ -6353,7 +5908,6 @@ mod tests { peer_setup, crate::Hop::new(1).unwrap(), None, - Version::Draft16, tasks, Default::default(), ); @@ -6393,7 +5947,6 @@ mod tests { writer .encode(&ietf::RequestOk { largest: None, - request_id: None, active: None, }) .await @@ -6496,7 +6049,6 @@ mod tests { writer .encode(&ietf::RequestOk { largest: None, - request_id: None, active: None, }) .await @@ -6587,7 +6139,6 @@ mod tests { writer .encode(&ietf::RequestOk { largest: None, - request_id: None, active: None, }) .await @@ -6683,7 +6234,6 @@ mod tests { writer .encode(&ietf::RequestOk { largest: None, - request_id: None, active: count, }) .await @@ -6743,7 +6293,6 @@ mod tests { writer .encode(&ietf::RequestOk { largest: None, - request_id: None, active, }) .await @@ -6927,7 +6476,7 @@ mod tests { .expect_err("a retired alias resolves to a cancellation"); assert_eq!( - crate::ietf::error::to_stream_code(&crate::StreamError::from(&err), Version::Draft20), + crate::ietf::error::to_stream_code(&crate::StreamError::from(&err)), crate::ietf::error::CANCELLED, "the code the dispatch loop maps this error onto", ); @@ -7045,7 +6594,6 @@ mod tests { &mut crate::coding::Encoder::new(&mut properties, Version::Draft19.into()), timestamp, Timescale::MILLI, - Version::Draft19, ) .unwrap(); ietf::ObjectDatagram { @@ -7113,7 +6661,6 @@ mod tests { &mut crate::coding::Encoder::new(&mut properties, Version::Draft19.into()), crate::Timestamp::new(96_000, Timescale::MILLI).unwrap(), Timescale::MILLI, - Version::Draft19, ) .unwrap(); ietf::ObjectDatagram { @@ -7175,7 +6722,7 @@ mod tests { /// turns a routine unsubscribe into an endless "unknown track alias" stream. #[moq_clock::test] async fn cancelling_a_subscription_stops_the_publisher() { - for version in [Version::Draft16, Version::Draft20] { + for version in [Version::Draft20] { let log = cancel_a_subscription(version).await; // CANCELLED, not the moq-lite cancel code: 0 on this wire is INTERNAL_ERROR, so a // routine unsubscribe would read to the publisher as a fault on our side. @@ -7230,7 +6777,6 @@ mod tests { writer.varint(ietf::RequestError::ID).await.unwrap(); writer .encode(&ietf::RequestError { - request_id: Some(RequestId(1)), // DOES_NOT_EXIST, draft-16 section 13.4.2. error_code: 0x10, reason_phrase: "not found".into(), @@ -7483,7 +7029,7 @@ mod tests { /// at once, not after the ten-second give-up. #[moq_clock::test] async fn a_revocation_never_waits_behind_subscribe_credit() { - for version in [Version::Draft14, Version::Draft15, Version::Draft16] { + for version in [Version::Draft15] { // MAX_REQUEST_ID admits nothing, so the SUBSCRIBE waits for credit. let session = crate::lite::test_transport::ScriptedSession::new(Vec::new()); let log = session.log.clone(); @@ -7547,7 +7093,7 @@ mod tests { /// cancels the subscribe at once, not once the peer answers or acknowledges the cancel. #[moq_clock::test] async fn a_revocation_never_waits_behind_subscribe_ok() { - for version in [Version::Draft14, Version::Draft16, Version::Draft18, Version::Draft22] { + for version in [Version::Draft18, Version::Draft22] { // A peer that accepts the stream and then says nothing at all, not even // acknowledging the cancellation's FIN. let session = crate::lite::test_transport::ScriptedSession::new(Vec::new()).with_unacked_fin(); @@ -7849,29 +7395,29 @@ mod tests { setup_wait_test!( invalid_subscribe_open_is_refused, SubscribeOpen, - [Draft14, Draft16, Draft17, Draft22] + [Draft22] ); setup_wait_test!( invalid_status_open_is_refused, StatusOpen, - [Draft14, Draft16, Draft17, Draft22] + [Draft22] ); - setup_wait_test!(invalid_status_credit_is_refused, StatusCredit, [Draft14, Draft16]); + setup_wait_test!(invalid_status_credit_is_refused, StatusCredit, [Draft16]); setup_wait_test!( invalid_status_response_is_refused, StatusResponse, - [Draft14, Draft16, Draft17, Draft22] + [Draft22] ); setup_wait_test!( invalid_fetch_open_is_refused, FetchOpen, - [Draft14, Draft16, Draft17, Draft22] + [Draft22] ); - setup_wait_test!(invalid_fetch_credit_is_refused, FetchCredit, [Draft14, Draft16]); + setup_wait_test!(invalid_fetch_credit_is_refused, FetchCredit, [Draft16]); setup_wait_test!( invalid_fetch_response_is_refused, FetchResponse, - [Draft14, Draft16, Draft17, Draft22] + [Draft22] ); #[derive(Clone, Copy, Debug)] @@ -7886,7 +7432,7 @@ mod tests { /// then cancel it if the draft can. Skipping it would leak the credit for good. #[moq_clock::test] async fn a_retirement_after_allocation_still_sends_the_request() { - for version in [Version::Draft14, Version::Draft15, Version::Draft16] { + for version in [Version::Draft15] { retirement_after_allocation(version).await; } } @@ -8103,7 +7649,6 @@ mod tests { let subscribe_ok = message( ietf::SubscribeOk::ID, &ietf::SubscribeOk { - request_id: Some(RequestId(0)), track_alias: 7, largest: Some(ietf::Location { group: 5, object: 2 }), properties: Default::default(), @@ -8179,7 +7724,6 @@ mod tests { let subscribe_ok = message( ietf::SubscribeOk::ID, &ietf::SubscribeOk { - request_id: Some(RequestId(0)), track_alias: 7, largest: None, properties: Default::default(), @@ -8269,7 +7813,7 @@ mod tests { /// fallback, so a reset here means the cancellation never landed. #[moq_clock::test] async fn cancelling_does_not_reset_away_the_unsubscribe() { - for version in [Version::Draft16, Version::Draft20] { + for version in [Version::Draft20] { let log = cancel_a_subscription(version).await; assert!( log.resets().is_empty(), @@ -8291,10 +7835,6 @@ mod tests { writer.varint(ietf::SubscribeOk::ID).await.unwrap(); writer .encode(&ietf::SubscribeOk { - request_id: match version { - Version::Draft14 | Version::Draft15 | Version::Draft16 => Some(RequestId(0)), - _ => None, - }, track_alias: 7, largest: None, properties: Default::default(), @@ -8402,7 +7942,6 @@ mod tests { writer.varint(ietf::SubscribeOk::ID).await.unwrap(); writer .encode(&ietf::SubscribeOk { - request_id: None, track_alias: 7, largest, properties: ietf::Properties { @@ -8527,7 +8066,6 @@ mod tests { message( ietf::RequestError::ID, &ietf::RequestError { - request_id: None, error_code: u32::MAX.into(), reason_phrase: "TRACK_STATUS is refused".into(), retry_interval: 0, @@ -8538,7 +8076,6 @@ mod tests { message( ietf::SubscribeOk::ID, &ietf::SubscribeOk { - request_id: None, track_alias: 7, largest: None, properties: Default::default(), @@ -8602,38 +8139,21 @@ mod tests { #[moq_clock::test] async fn a_refused_track_status_never_subscribes() { for version in [ - Version::Draft14, - Version::Draft15, - Version::Draft16, Version::Draft18, Version::Draft19, Version::Draft22, ] { for code in [3, u64::from(u32::MAX)] { for fetching in [false, true] { - let refused = if version == Version::Draft14 { - message( - ietf::TRACK_STATUS_ERROR_14, - &ietf::SubscribeError { - request_id: RequestId(0), - error_code: code, - reason_phrase: "TRACK_STATUS is refused".into(), - }, - version, - ) - } else { - message( + let refused = message( ietf::RequestError::ID, &ietf::RequestError { - request_id: matches!(version, Version::Draft15 | Version::Draft16) - .then_some(RequestId(0)), error_code: code, reason_phrase: "TRACK_STATUS is refused".into(), retry_interval: 0, }, version, - ) - }; + ); let session = crate::lite::test_transport::ScriptedSession::new(refused); let log = session.log.clone(); let (tasks, _task_set) = crate::util::TaskSet::new(); @@ -8700,7 +8220,6 @@ mod tests { let status_ok = message( ietf::TrackStatusOk::ID, &ietf::TrackStatusOk { - request_id: None, largest: None, properties: declares(true), }, @@ -8713,7 +8232,6 @@ mod tests { message( ietf::SubscribeOk::ID, &ietf::SubscribeOk { - request_id: None, track_alias: 7, largest: None, properties: declares(!opts_out), @@ -8850,7 +8368,6 @@ mod tests { peer::PeerSetup::default(), crate::Hop::new(1).unwrap(), None, - Version::Draft14, tasks, Default::default(), ); @@ -8908,7 +8425,6 @@ mod tests { peer::PeerSetup::default(), crate::Hop::new(1).unwrap(), None, - Version::Draft14, tasks, Default::default(), ); @@ -8969,7 +8485,6 @@ mod tests { peer::PeerSetup::default(), self_origin, None, - Version::Draft14, tasks, Default::default(), ); @@ -9009,7 +8524,6 @@ mod tests { peer::PeerSetup::default(), self_origin, None, - Version::Draft14, tasks, Default::default(), ); @@ -9242,7 +8756,6 @@ mod tests { writer .encode(&ietf::RequestOk { largest: None, - request_id: None, active: None, }) .await @@ -9340,7 +8853,7 @@ mod tests { #[moq_clock::test] async fn publish_namespace_requester_fin_keeps_the_route() { - for version in [Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft22] { + for version in [Version::Draft18, Version::Draft19, Version::Draft22] { for reset in [false, true] { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let consumer = origin.consume(); @@ -9457,14 +8970,11 @@ mod tests { /// Draft 15 still owes the update an answer: a REQUEST_ERROR naming it. #[moq_clock::test] async fn a_legacy_update_on_an_advertisement_is_answered() { - for version in [Version::Draft14, Version::Draft15] { + for version in [Version::Draft15] { let path = crate::Path::new("room/host").to_owned(); // Own Request ID 10, aimed at the advertisement (0). Draft 14 carries its fixed // start, end group, priority and forward before the parameters. - let body: &[u8] = match version { - Version::Draft14 => &[10, 0, 0, 0, 0, 128, 1, 0], - _ => &[10, 0, 0], - }; + let body: &[u8] = &[10, 0, 0]; let mut script = vec![ietf::SubscribeUpdate::ID as u8, 0, body.len() as u8]; script.extend_from_slice(body); let log = crate::lite::test_transport::Log::default(); @@ -9522,10 +9032,7 @@ mod tests { sent.push((id, rest.get(2).copied())); rest = &rest[2 + len..]; } - let expected = match version { - Version::Draft14 => vec![(ietf::PublishNamespaceOk::ID, Some(0))], - _ => vec![(ietf::RequestOk::ID, Some(0)), (ietf::RequestError::ID, Some(10))], - }; + let expected = vec![(ietf::RequestOk::ID, Some(0)), (ietf::RequestError::ID, Some(10))]; assert_eq!(sent, expected, "{version}"); assert!(session.log.closes().is_empty(), "{version}: the session stays up"); } @@ -10625,7 +10132,7 @@ mod tests { /// into REQUEST_ERROR, so both shapes have to carry NOT_SUPPORTED. #[moq_clock::test] async fn publish_is_rejected_without_announcing() { - for version in [Version::Draft14, Version::Draft19] { + for version in [Version::Draft19] { // An open gate, so the rejection actually reaches the wire. let gate = kio::Producer::new(true); let session = crate::lite::test_transport::SinkSession::gated_bi(gate.consume()); @@ -10684,31 +10191,15 @@ mod tests { version, ); - match version { - Version::Draft14 => { - writer.varint(ietf::PublishError::ID).await.unwrap(); - writer - .encode(&ietf::PublishError { - request_id: RequestId(1), - error_code: NOT_SUPPORTED, - reason_phrase: "PUBLISH is not supported".into(), - }) - .await - .unwrap(); - } - _ => { - writer.varint(ietf::RequestError::ID).await.unwrap(); - writer - .encode(&ietf::RequestError { - request_id: None, - error_code: NOT_SUPPORTED, - reason_phrase: "PUBLISH is not supported".into(), - retry_interval: 0, - }) - .await - .unwrap(); - } - } + writer.varint(ietf::RequestError::ID).await.unwrap(); + writer + .encode(&ietf::RequestError { + error_code: NOT_SUPPORTED, + reason_phrase: "PUBLISH is not supported".into(), + retry_interval: 0, + }) + .await + .unwrap(); log.writes.lock().unwrap().clone() }; @@ -10838,7 +10329,7 @@ mod tests { ); let msg = ietf::PublishNamespaceUpdate { request_id: RequestId(3), - namespace_request_id: (version == Version::Draft16).then_some(RequestId(1)), + namespace_request_id: (false).then_some(RequestId(1)), hops: None, cost: None, authorization_token: Some(announce_token()), @@ -10912,10 +10403,6 @@ mod tests { #[moq_clock::test] async fn a_revoked_token_retracts_an_announce_whose_ok_is_blocked() { for version in [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, Version::Draft22, ] { @@ -10988,11 +10475,7 @@ mod tests { let len = usize::from(u16::from_be_bytes([rest[0], rest[1]])); rest = &rest[2 + len..]; } - let expected = match version { - Version::Draft14 => vec![ietf::PublishNamespaceOk::ID, ietf::PublishNamespaceCancel::ID], - Version::Draft15 | Version::Draft16 => vec![ietf::RequestOk::ID, ietf::PublishNamespaceCancel::ID], - _ => vec![ietf::RequestOk::ID], - }; + let expected = vec![ietf::RequestOk::ID]; assert_eq!(sent, expected, "{version}"); assert!(session.log.closes().is_empty(), "{version}: the session stays up"); } @@ -11268,7 +10751,6 @@ mod tests { ); writer.varint(ietf::SubscribeOk::ID).await.unwrap(); let ok = ietf::SubscribeOk { - request_id: None, track_alias: 7, largest: None, properties: Default::default(), @@ -11355,7 +10837,7 @@ mod tests { /// re-arms the deadline. #[moq_clock::test] async fn a_publish_namespace_renewal_extends_past_the_old_expiry() { - for version in [Version::Draft16, Version::Draft18] { + for version in [Version::Draft18] { let (mut subscriber, mut requests, _cred, consumer, session) = auth_announce_harness(version, publish_namespace_update_with_token(version).await); let rt = subscriber.runtime.clone(); @@ -11536,12 +11018,12 @@ mod tests { assert!(session.log.closes().is_empty(), "the session stays up"); } - /// Per drafts 16 section 9.11.1 / 18 section 10.9.1, a refused PUBLISH_NAMESPACE + /// Per draft-18 section 10.9.1, a refused PUBLISH_NAMESPACE /// renewal ends only that announce at once, by closing its stream (and cancelling it on /// draft-16), not by waiting for the old 60s grant to lapse. The session stays up. #[moq_clock::test] async fn a_refused_publish_namespace_renewal_ends_the_announce() { - for version in [Version::Draft16, Version::Draft18] { + for version in [Version::Draft18] { let (mut subscriber, mut requests, _cred, _consumer, session) = auth_announce_harness(version, publish_namespace_update_with_token(version).await); let rt = subscriber.runtime.clone(); @@ -11597,36 +11079,6 @@ mod tests { session.log.closes() ); // Draft-16's request outlives its stream, so the refusal cancels it explicitly. - if version == Version::Draft16 { - let cancel = { - let log = crate::lite::test_transport::Log::default(); - let mut writer = crate::coding::Writer::new( - crate::transport::boxed::SendStream::new(crate::lite::test_transport::SinkSend::new( - log.clone(), - )), - version, - ); - writer - .encode_message(&ietf::PublishNamespaceCancel { - track_namespace: crate::Path::new("room/alice"), - request_id: RequestId(1), - error_code: request::to_code( - &Error::Unauthorized, - request::Kind::PublishNamespace, - version, - ), - reason_phrase: "no".into(), - }) - .await - .unwrap(); - log.writes.lock().unwrap().clone() - }; - let writes = session.log.writes.lock().unwrap().clone(); - assert!( - writes.windows(cancel.len()).any(|window| window == cancel.as_slice()), - "a refused draft-16 renewal sends PUBLISH_NAMESPACE_CANCEL" - ); - } } } @@ -11634,7 +11086,7 @@ mod tests { /// without one is refused rather than taken unread: it ends only that announce, unverified. #[moq_clock::test] async fn a_token_on_an_announce_admitted_without_one_is_refused() { - for version in [Version::Draft16, Version::Draft18] { + for version in [Version::Draft18] { let (mut subscriber, mut requests, _cred, consumer, session) = auth_announce_harness(version, publish_namespace_update_with_token(version).await); let stream = Stream::open(&mut crate::driver::Transport::new(session.clone()), version) @@ -12559,8 +12011,6 @@ mod tests { /// What an update to an Established subscription changes. struct Update { - /// Draft-14's mandatory Start Location, repeated as it stands; unused on later drafts. - start_location: ietf::Location, /// The aggregate subscriber priority, in the model's higher-first terms. priority: Option, /// Subscriber age budget, in milliseconds. @@ -12735,10 +12185,6 @@ mod filter_tests { } const JOINING_DRAFTS: [Version; 6] = [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, Version::Draft19, ]; @@ -12823,7 +12269,7 @@ mod stitch_tests { let payload = payload.as_ref(); let mut properties = Vec::new(); let w = &mut Encoder::new(&mut properties, VERSION.into()); - ietf::encode_object_time(w, timestamp(object_index), Timescale::MICRO, VERSION).unwrap(); + ietf::encode_object_time(w, timestamp(object_index), Timescale::MICRO).unwrap(); let properties = Some(properties); // The first object of the stream carries the absolute Group ID. From @@ -12892,7 +12338,6 @@ mod stitch_tests { &mut Encoder::new(&mut ext, VERSION.into()), timestamp(object), Timescale::MICRO, - VERSION, ) .unwrap(); let w = &mut crate::coding::Encoder::new(&mut buf, VERSION.into()); @@ -12944,7 +12389,6 @@ mod stitch_tests { &mut Encoder::new(&mut ext, version.into()), timestamp(object), Timescale::MICRO, - version, ) .unwrap(); crate::coding::Encoder::new(&mut buf, version.into()) @@ -13373,7 +12817,7 @@ mod stitch_tests { #[moq_clock::test] async fn passthrough_preserves_object_properties_through_dispatch() { - for version in [Version::Draft15, Version::Draft22] { + for version in [Version::Draft22] { let mut script = Vec::new(); ietf::GroupHeader { track_alias: ALIAS, @@ -13387,10 +12831,7 @@ mod stitch_tests { } .encode(&mut Encoder::new(&mut script, version.into()), version) .unwrap(); - let properties = match version { - Version::Draft15 => vec![2, 7, 5, 1, 42], - _ => vec![2, 7, 3, 1, 42], - }; + let properties = vec![2, 7, 3, 1, 42]; let mut encoder = Encoder::new(&mut script, version.into()); encoder.varint(0u64).unwrap(); encoder.bytes(&properties).unwrap(); @@ -13470,7 +12911,7 @@ mod stitch_tests { #[moq_clock::test] async fn passthrough_fetch_requires_marked_gaps_and_preserves_fields() { - for version in [Version::Draft15, Version::Draft17, Version::Draft22] { + for version in [Version::Draft22] { for marked in [false, true] { let properties = if marked { vec![0x3e, 6] } else { vec![] }; let second = if marked { vec![0x3e, 1] } else { vec![] }; @@ -13529,15 +12970,11 @@ mod stitch_tests { #[moq_clock::test] async fn passthrough_fetch_keeps_the_end_of_group_object() { for version in [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft22, ] { // Only draft-14 lets a status object carry properties, so later drafts cannot mark // a gap before it. - let legacy = version == Version::Draft14; + let legacy = false; let terminal = if legacy { (11, &[0x3e, 2][..]) } else { (9, &[][..]) }; let objects = [ (6, &[0x3e, 6][..], None), @@ -13550,7 +12987,7 @@ mod stitch_tests { let mut decoder = Decoder::new(&bytes, version.into()); assert_eq!(decoder.varint().unwrap(), ietf::FetchOk::ID, "{version}"); let ok = ietf::FetchOk::decode(&mut decoder, version).unwrap(); - let carried = matches!(version, Version::Draft14 | Version::Draft15); + let carried = false; let last = match () { _ if carried => terminal.0 + 1, _ if Filter::is_draft20(version) => 8, @@ -13601,7 +13038,7 @@ mod stitch_tests { /// refused on ingest, and one relayed from draft-14 leaves without them. #[moq_clock::test] async fn passthrough_keeps_properties_off_status_objects() { - for version in [Version::Draft15, Version::Draft22] { + for version in [Version::Draft22] { for status in [END_OF_GROUP, END_OF_TRACK] { let script = object_stream(version, true, &[(0, &[], None), (1, &[0x20, 7], Some(status))]); let mut h = Harness::with_timescale(Fill::Done, vec![script], None); @@ -13640,7 +13077,7 @@ mod stitch_tests { true, &[(0, &[], None), (1, &[0x20, 7], Some(END_OF_GROUP))], ); - let (bytes, log) = relay_passthrough_stream(script, Version::Draft14, Version::Draft15).await; + let (bytes, log) = relay_passthrough_stream(script, Version::Draft15).await; assert!(log.resets().is_empty()); let mut decoder = Decoder::new(&bytes, Version::Draft15.into()); ietf::GroupHeader::decode(&mut decoder, Version::Draft15).unwrap(); @@ -13808,7 +13245,7 @@ mod stitch_tests { #[moq_clock::test] async fn passthrough_fetch_ingest_keeps_marked_gaps_and_stitches_its_tail() { - for version in [Version::Draft15, Version::Draft17, Version::Draft22] { + for version in [Version::Draft22] { let mut objects = Vec::new(); for (index, id) in [6u64, 8].into_iter().enumerate() { let properties = vec![0x3e, if index == 0 { 6 } else { 1 }]; @@ -13882,7 +13319,7 @@ mod stitch_tests { #[moq_clock::test] async fn passthrough_preserves_ids_first_object_and_end_status() { - for version in [Version::Draft15, Version::Draft22] { + for version in [Version::Draft22] { for first in [false, true] { let objects = [ (6, &[][..], None), @@ -13894,7 +13331,7 @@ mod stitch_tests { assert!(log.resets().is_empty()); let mut decoder = Decoder::new(&bytes, version.into()); let header = ietf::GroupHeader::decode(&mut decoder, version).unwrap(); - assert_eq!(header.flags.first_object, version == Version::Draft15 || first); + assert_eq!(header.flags.first_object, first); for (delta, status) in [(6, None), (1, None), (2, Some(END_OF_GROUP))] { assert_eq!(decoder.varint().unwrap(), delta); assert!(decoder.bytes().unwrap().is_empty()); @@ -13913,9 +13350,6 @@ mod stitch_tests { #[moq_clock::test] async fn passthrough_preserves_immutable_bytes_and_refuses_incompatible_drafts() { for ingress in [ - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, Version::Draft22, ] { @@ -13933,9 +13367,6 @@ mod stitch_tests { encoder.varint(0x0bu64).unwrap(); encoder.bytes(&inner).unwrap(); for egress in [ - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, Version::Draft22, ] { @@ -13992,120 +13423,114 @@ mod stitch_tests { #[moq_clock::test] async fn passthrough_preserves_datagram_objects_through_dispatch() { // Also through a second relay behind a moq-lite hop with the `ietf` extension. - for (version, ranged, hop) in [Version::Draft15, Version::Draft22] + for (version, ranged, hop) in [Version::Draft22] .into_iter() .flat_map(|version| [(version, false), (version, true)]) .filter(|(version, ranged)| !*ranged || *version == Version::Draft22) .flat_map(|(version, ranged)| [(version, ranged, false), (version, ranged, true)]) { - { - let origin = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); - let broadcast = origin.publish("room", crate::origin::Route::default()).unwrap(); - let track = broadcast - .create_track("video", accepted_info(&Default::default(), version)) - .unwrap(); - let mut h = Harness::with_timescale(Fill::Done, vec![], None); - h.subscriber.version = version; - h.subscriber.state.lock().subscribes.get_mut(&REQUEST).unwrap().producer = Some(track.clone()); - let properties = if version == Version::Draft15 { - vec![2, 7, 5, 1, 42] + let origin = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); + let broadcast = origin.publish("room", crate::origin::Route::default()).unwrap(); + let track = broadcast + .create_track("video", accepted_info(&Default::default(), version)) + .unwrap(); + let mut h = Harness::with_timescale(Fill::Done, vec![], None); + h.subscriber.version = version; + h.subscriber.state.lock().subscribes.get_mut(&REQUEST).unwrap().producer = Some(track.clone()); + let properties = vec![2, 7, 3, 1, 42]; + let mut original = Vec::new(); + for id in [6, 7, 8] { + let datagram = ietf::ObjectDatagram { + track_alias: ALIAS, + group_id: SEQUENCE, + object_id: Some(id), + // An omitted priority inherits the track default, which the + // downstream response need not carry. + publisher_priority: (id != 6).then_some(200), + end_of_group: false, + properties: (id != 8).then(|| properties.clone()), + body: if id == 8 { + ietf::DatagramBody::Status(END_OF_GROUP) } else { - vec![2, 7, 3, 1, 42] - }; - let mut original = Vec::new(); - for id in [6, 7, 8] { - let datagram = ietf::ObjectDatagram { - track_alias: ALIAS, - group_id: SEQUENCE, - object_id: Some(id), - // An omitted priority inherits the track default, which the - // downstream response need not carry. - publisher_priority: (id != 6).then_some(200), - end_of_group: false, - properties: (id != 8).then(|| properties.clone()), - body: if id == 8 { - ietf::DatagramBody::Status(END_OF_GROUP) - } else { - ietf::DatagramBody::Payload(bytes::Bytes::from_static(b"object")) - }, - }; - h.subscriber - .recv_datagram(datagram.encode_bytes(version).unwrap()) - .unwrap(); - original.push(datagram); - } - track.finish().unwrap(); - let (served, _sessions) = match hop { - true => { - let (served, sessions) = crate::lite::ietf::test_hop(&origin, "room", [true, true]).await; - (served, Some(sessions)) - } - false => (origin, None), - }; - let downstream = ScriptedSession::per_stream(vec![vec![]]).with_datagrams(65535); - let peer = peer::PeerSetup::default(); - peer.set(peer::Peer::default()); - let publisher = crate::ietf::Publisher::new( - crate::time::sim(), - crate::driver::Transport::new(downstream.clone()), - served.consume(), - Control::new(None, false), - None, - peer, - version, - ); - let subscribe = ietf::Subscribe { - max_age: None, - new_group: None, - request_id: RequestId(3), - track_namespace: Path::new("room"), - track_name: "video".into(), - subscriber_priority: 128, - group_order: ietf::GroupOrder::Ascending, - filter: if ranged { - Filter::Absolute { - start: ietf::Location { - group: SEQUENCE, - object: 7, - }, - end: Some(ietf::EndLocation { - group: SEQUENCE, - object: Some(7), - }), - } - } else { - Filter::Unfiltered + ietf::DatagramBody::Payload(bytes::Bytes::from_static(b"object")) + }, + }; + h.subscriber + .recv_datagram(datagram.encode_bytes(version).unwrap()) + .unwrap(); + original.push(datagram); + } + track.finish().unwrap(); + let (served, _sessions) = match hop { + true => { + let (served, sessions) = crate::lite::ietf::test_hop(&origin, "room", [true, true]).await; + (served, Some(sessions)) + } + false => (origin, None), + }; + let downstream = ScriptedSession::per_stream(vec![vec![]]).with_datagrams(65535); + let peer = peer::PeerSetup::default(); + peer.set(peer::Peer::default()); + let publisher = crate::ietf::Publisher::new( + crate::time::sim(), + crate::driver::Transport::new(downstream.clone()), + served.consume(), + Control::new(None, false), + None, + peer, + version, + ); + let subscribe = ietf::Subscribe { + max_age: None, + new_group: None, + request_id: RequestId(3), + track_namespace: Path::new("room"), + track_name: "video".into(), + subscriber_priority: 128, + group_order: ietf::GroupOrder::Ascending, + filter: if ranged { + Filter::Absolute { + start: ietf::Location { + group: SEQUENCE, + object: 7, }, - fill: None, - properties_wanted: true, - forward: true, - rendezvous: false, - range_filters: false, - authorization_token: None, - epoch: None, - }; - let mut body = Vec::new(); - subscribe - .encode_msg(&mut Encoder::new(&mut body, version.into()), version) - .unwrap(); - let stream = Stream::open(&mut crate::driver::Transport::new(downstream.clone()), version) - .await - .unwrap(); - publisher - .handle_stream(ietf::Subscribe::ID, ietf::Body(body.into()), stream, false) - .unwrap() - .await; - let sent = downstream.log.datagrams.lock().unwrap(); - original.retain(|datagram| !ranged || datagram.object_id == Some(7)); - assert_eq!(sent.len(), original.len(), "{version} ranged={ranged} hop={hop}"); - let inherited = super::super::priority::to_wire(track.publisher_priority()); - for (bytes, mut expected) in sent.iter().zip(original) { - expected.track_alias = 3; - expected.publisher_priority = expected.publisher_priority.or(Some(inherited)); - let (actual, _) = ietf::ObjectDatagram::decode_slice(bytes, version).unwrap(); - assert_eq!(actual, expected); + end: Some(ietf::EndLocation { + group: SEQUENCE, + object: Some(7), + }), } - } + } else { + Filter::Unfiltered + }, + fill: None, + properties_wanted: true, + forward: true, + rendezvous: false, + range_filters: false, + authorization_token: None, + epoch: None, + }; + let mut body = Vec::new(); + subscribe + .encode_msg(&mut Encoder::new(&mut body, version.into()), version) + .unwrap(); + let stream = Stream::open(&mut crate::driver::Transport::new(downstream.clone()), version) + .await + .unwrap(); + publisher + .handle_stream(ietf::Subscribe::ID, ietf::Body(body.into()), stream, false) + .unwrap() + .await; + let sent = downstream.log.datagrams.lock().unwrap(); + original.retain(|datagram| !ranged || datagram.object_id == Some(7)); + assert_eq!(sent.len(), original.len(), "{version} ranged={ranged} hop={hop}"); + let inherited = super::super::priority::to_wire(track.publisher_priority()); + for (bytes, mut expected) in sent.iter().zip(original) { + expected.track_alias = 3; + expected.publisher_priority = expected.publisher_priority.or(Some(inherited)); + let (actual, _) = ietf::ObjectDatagram::decode_slice(bytes, version).unwrap(); + assert_eq!(actual, expected); + } } } @@ -14113,12 +13538,8 @@ mod stitch_tests { /// egress draft forbids them beside a non-Normal status. #[moq_clock::test] async fn passthrough_strips_status_datagram_properties_a_draft_forbids() { - for ingress in [Version::Draft14, Version::Draft15, Version::Draft16] { + for ingress in [Version::Draft15] { let egresses = [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft20, @@ -14200,7 +13621,7 @@ mod stitch_tests { panic!("{context}: sent {} datagrams", sent.len()); }; let (actual, _) = ietf::ObjectDatagram::decode_slice(bytes, egress).unwrap(); - let carried = matches!(egress, Version::Draft14 | Version::Draft15 | Version::Draft16); + let carried = false; assert_eq!( (actual.object_id, actual.body, actual.properties.is_some()), (Some(5), ietf::DatagramBody::Status(status), carried), @@ -14212,20 +13633,16 @@ mod stitch_tests { #[moq_clock::test] async fn passthrough_translates_mutable_property_encodings() { - for ingress in [Version::Draft14, Version::Draft15, Version::Draft17, Version::Draft22] { + for ingress in [Version::Draft22] { let mut properties = Vec::new(); let mut encoder = Encoder::new(&mut properties, ingress.into()); encoder.varint(0x80u64).unwrap(); encoder.varint(96_000u64).unwrap(); encoder - .varint(if matches!(ingress, Version::Draft14 | Version::Draft15) { - 0x81u64 - } else { - 1u64 - }) + .varint(1u64) .unwrap(); encoder.bytes(&[42; 130]).unwrap(); - for egress in [Version::Draft15, Version::Draft17, Version::Draft22] { + for egress in [Version::Draft22] { let script = object_stream(ingress, true, &[(0, &properties, None)]); let (bytes, log) = relay_passthrough_stream(script, ingress, egress).await; assert!(log.resets().is_empty()); @@ -14247,7 +13664,7 @@ mod stitch_tests { #[moq_clock::test] async fn passthrough_accepts_nonzero_first_objects_and_gaps() { - for version in [Version::Draft15, Version::Draft22] { + for version in [Version::Draft22] { let mut script = Vec::new(); ietf::GroupHeader { track_alias: ALIAS, @@ -14276,7 +13693,7 @@ mod stitch_tests { /// A datagram's object number does not change its public payload view. #[moq_clock::test] async fn passthrough_accepts_datagrams_past_object_zero() { - for version in [Version::Draft15, Version::Draft22] { + for version in [Version::Draft22] { let mut h = Harness::with_timescale(Fill::Done, vec![], None); h.subscriber.version = version; let mut consumer = h.track.subscribe(None); @@ -14318,7 +13735,7 @@ mod stitch_tests { /// Old drafts preserve a nonzero first Object ID without inventing missing frames. #[moq_clock::test] async fn old_drafts_accept_a_nonzero_first_object() { - for version in [Version::Draft14, Version::Draft16] { + for version in [Version::Draft16] { let scripts = [2u64, 0] .into_iter() .enumerate() @@ -14396,7 +13813,7 @@ mod stitch_tests { /// is subgroup 0. #[moq_clock::test] async fn a_compact_non_zero_subgroup_is_refused() { - for version in [Version::Draft14, Version::Draft22] { + for version in [Version::Draft22] { let compact = |sequence: u64, first: Option| { let mut bytes = Vec::new(); ietf::GroupHeader { @@ -14971,7 +14388,7 @@ mod stitch_tests { let payloads: [&[u8]; 5] = [b"o0", b"o1", b"o2", b"o3", b"o4"]; let bytes = end_marker(draft18_subgroup(SEQUENCE, true, 0, &payloads), END_OF_GROUP); - let flags = ietf::GroupFlags::decode(u64::from(bytes[0]), Version::Draft18).unwrap(); + let flags = ietf::GroupFlags::decode(u64::from(bytes[0])).unwrap(); assert!(flags.has_end, "the header marks the group's end"); let mut h = Harness::new(Fill::Done, vec![bytes]); @@ -15274,15 +14691,15 @@ mod stitch_tests { #[test] fn a_later_fetch_group_field_is_a_delta() { assert_eq!( - resolve_fetch_group(Version::Draft18, Some(7), Some(0)).unwrap(), + resolve_fetch_group(Some(7), Some(0)).unwrap(), Some(8) ); assert_eq!( - resolve_fetch_group(Version::Draft20, Some(7), Some(0)).unwrap(), + resolve_fetch_group(Some(7), Some(0)).unwrap(), Some(8) ); assert_eq!( - resolve_fetch_group(Version::Draft17, Some(7), Some(8)).unwrap(), + resolve_fetch_group(Some(7), Some(8)).unwrap(), Some(8) ); } @@ -15366,7 +14783,7 @@ mod stitch_tests { header(Some(SEQUENCE), Some(0), Zero, None), ]; - for version in [Version::Draft15, VERSION] { + for version in [VERSION] { for header in &headers { let mut buf = Vec::new(); header @@ -15445,7 +14862,7 @@ mod stitch_tests { fn datagram_object(sequence: u64) -> Vec { let mut properties = Vec::new(); let w = &mut Encoder::new(&mut properties, VERSION.into()); - ietf::encode_object_time(w, timestamp(0), Timescale::MICRO, VERSION).unwrap(); + ietf::encode_object_time(w, timestamp(0), Timescale::MICRO).unwrap(); let mut buf = Vec::new(); ietf::FetchObject::Object { subgroup: ietf::FetchSubgroup::Datagram, @@ -15644,10 +15061,6 @@ mod joining_fetch_tests { use futures::FutureExt; const JOINING_DRAFTS: [Version; 6] = [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, Version::Draft19, ]; @@ -15670,10 +15083,6 @@ mod joining_fetch_tests { message_bytes( ietf::SubscribeOk::ID, &ietf::SubscribeOk { - request_id: match version { - Version::Draft14 | Version::Draft15 | Version::Draft16 => Some(RequestId(1)), - _ => None, - }, track_alias: 7, largest, properties: Default::default(), @@ -15686,10 +15095,6 @@ mod joining_fetch_tests { message_bytes( ietf::FetchOk::ID, &ietf::FetchOk { - request_id: match version { - Version::Draft14 | Version::Draft15 | Version::Draft16 => Some(RequestId(3)), - _ => None, - }, group_order: GroupOrder::Ascending, end_of_track: false, end_location: ietf::Location { group: 4, object: 2 }, @@ -15701,29 +15106,9 @@ mod joining_fetch_tests { fn fetch_error(version: Version) -> Vec { match version { - Version::Draft14 => message_bytes( - ietf::FetchError::ID, - &ietf::FetchError { - request_id: RequestId(3), - error_code: request::NOT_SUPPORTED, - reason_phrase: "refused".into(), - }, - version, - ), - Version::Draft15 | Version::Draft16 => message_bytes( - ietf::RequestError::ID, - &ietf::RequestError { - request_id: Some(RequestId(3)), - error_code: request::NOT_SUPPORTED, - reason_phrase: "refused".into(), - retry_interval: 0, - }, - version, - ), _ => message_bytes( ietf::RequestError::ID, &ietf::RequestError { - request_id: None, error_code: request::NOT_SUPPORTED, reason_phrase: "refused".into(), retry_interval: 0, @@ -15900,7 +15285,7 @@ mod joining_fetch_tests { /// The parent keeps its child FETCH cancellation moving while its own FIN awaits ACK. async fn revoked_child_fetch(accepted: bool) { - for version in [Version::Draft14, Version::Draft16, Version::Draft17, Version::Draft22] { + for version in [Version::Draft22] { let session = ScriptedSession::per_stream(vec![ subscribe_ok(version, None), if accepted { fetch_ok(version) } else { Vec::new() }, @@ -15959,13 +15344,6 @@ mod joining_fetch_tests { let stops = log.stops().len(); // One stop belongs to SUBSCRIBE, another to the cache-miss FETCH. assert!(stops >= 2, "{version}: only {stops} streams cancelled before ACK"); - if matches!(version, Version::Draft14 | Version::Draft16) { - assert!( - decode_messages(&log, version) - .iter() - .any(|(id, _)| *id == ietf::FetchCancel::ID) - ); - } drop(received); } } @@ -16040,10 +15418,7 @@ mod joining_fetch_tests { let session = ScriptedSession::new(Vec::new()).without_credit(); let (mut subscriber, track, _tasks) = pending_join(crate::driver::Transport::new(session), version); subscriber.control = Control::new( - match version { - Version::Draft14 | Version::Draft15 | Version::Draft16 => Some(RequestId(2)), - _ => None, - }, + None, false, ); let mut joining = subscriber.start_joining_fetch(RequestId(99), &track).unwrap(); @@ -16083,7 +15458,7 @@ mod joining_fetch_tests { /// A cancelled partial legacy header still precedes the next unrelated request ID. #[moq_clock::test] async fn cancelling_a_partial_joining_fetch_preserves_request_id_order() { - for version in [Version::Draft14, Version::Draft15, Version::Draft16] { + for version in [Version::Draft15] { let gate = kio::Producer::new(false); let session = crate::lite::test_transport::SinkSession::gated_bi_prefix(2, gate.consume()); let log = session.log.clone(); @@ -16122,7 +15497,7 @@ mod joining_fetch_tests { /// A peer that never acknowledges cancellation cannot retain request-ID allocation. #[moq_clock::test] async fn joining_fetch_cleanup_does_not_hold_the_next_request_id() { - for version in [Version::Draft14, Version::Draft15, Version::Draft16] { + for version in [Version::Draft15] { let session = ScriptedSession::per_stream(Vec::new()).with_unacked_fin(); let log = session.log.clone(); let (subscriber, track, mut tasks) = pending_join(crate::driver::Transport::new(session.clone()), version); @@ -16257,9 +15632,7 @@ mod joining_fetch_tests { ok.extend(message_bytes( ietf::PublishDone::ID, &ietf::PublishDone { - request_id: matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) - .then_some(RequestId(1)), - status_code: ietf::PublishDoneStatus::TrackEnded.code(version), + status_code: ietf::PublishDoneStatus::TrackEnded.code(), stream_count: 0, reason_phrase: "done".into(), }, @@ -16280,23 +15653,15 @@ mod joining_fetch_tests { let w = &mut Encoder::new(&mut objects, version.into()); w.varint(ietf::FetchHeader::TYPE).unwrap(); ietf::FetchHeader { request_id: fetch_id }.encode(w, version).unwrap(); - if version == Version::Draft14 { - w.varint(4).unwrap(); // group - w.varint(0).unwrap(); // subgroup - w.varint(0).unwrap(); // object - w.u8(0); // priority - w.bytes(&[]).unwrap(); // properties - } else { - ietf::FetchObject::Object { - subgroup: ietf::FetchSubgroup::Zero, - group: Some(4), - object: Some(0), - priority: Some(0), - properties: None, - } - .encode(w, version) - .unwrap(); + ietf::FetchObject::Object { + subgroup: ietf::FetchSubgroup::Zero, + group: Some(4), + object: Some(0), + priority: Some(0), + properties: None, } + .encode(w, version) + .unwrap(); w.bytes(b"x").unwrap(); let data = ScriptedSession::new(objects); let (_, recv) = data.clone().open_bi(Default::default()).await.unwrap(); @@ -16336,8 +15701,6 @@ mod joining_fetch_tests { ok.extend(message_bytes( ietf::PublishDone::ID, &ietf::PublishDone { - request_id: matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) - .then_some(RequestId(1)), status_code: 0x3, stream_count: 0, reason_phrase: "done".into(), @@ -16425,8 +15788,6 @@ mod joining_fetch_tests { session.push(&message_bytes( ietf::FetchOk::ID, &ietf::FetchOk { - request_id: matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) - .then_some(RequestId(1)), group_order: GroupOrder::Ascending, end_of_track: false, end_location: ietf::Location { @@ -16454,31 +15815,15 @@ mod joining_fetch_tests { ); } else { let mut objects = Vec::new(); - if version == Version::Draft14 { - crate::coding::Encoder::new(&mut objects, version.into()) - .varint(GROUP) - .unwrap(); - crate::coding::Encoder::new(&mut objects, version.into()) - .varint(0u64) - .unwrap(); // subgroup - crate::coding::Encoder::new(&mut objects, version.into()) - .varint(0u64) - .unwrap(); // object - crate::coding::Encoder::new(&mut objects, version.into()).u8(0u8); // priority - crate::coding::Encoder::new(&mut objects, version.into()) - .bytes(&Vec::::new()) - .unwrap(); - } else { - ietf::FetchObject::Object { - subgroup: ietf::FetchSubgroup::Zero, - group: Some(GROUP), - object: Some(0), - priority: Some(0), - properties: None, - } - .encode(&mut crate::coding::Encoder::new(&mut objects, version.into()), version) - .unwrap(); + ietf::FetchObject::Object { + subgroup: ietf::FetchSubgroup::Zero, + group: Some(GROUP), + object: Some(0), + priority: Some(0), + properties: None, } + .encode(&mut crate::coding::Encoder::new(&mut objects, version.into()), version) + .unwrap(); crate::coding::Encoder::new(&mut objects, version.into()) .varint(1u64) .unwrap(); @@ -16533,18 +15878,8 @@ mod joining_fetch_tests { assert_eq!(session.log.stops(), [crate::ietf::error::CANCELLED]); let messages = decode_messages(&session.log, version); let cancels: Vec<_> = messages.iter().filter(|(id, _)| *id == ietf::FetchCancel::ID).collect(); - if matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) { - assert_eq!(cancels.len(), 1, "legacy FETCH_CANCEL"); - let mut body = Decoder::new(&cancels[0].1, version.into()); - assert_eq!( - ietf::FetchCancel::decode_msg(&mut body, version).unwrap().request_id, - RequestId(1) - ); - assert!(session.log.resets().is_empty(), "deliver FETCH_CANCEL before closing"); - } else { - assert!(cancels.is_empty(), "FETCH_CANCEL was removed"); - assert_eq!(session.log.resets(), [crate::ietf::error::CANCELLED]); - } + assert!(cancels.is_empty(), "FETCH_CANCEL was removed"); + assert_eq!(session.log.resets(), [crate::ietf::error::CANCELLED]); assert!(subscriber.state.lock().group_fetches.is_empty(), "request retired"); } @@ -16602,7 +15937,6 @@ mod joining_fetch_tests { let ok = message_bytes( ietf::FetchOk::ID, &ietf::FetchOk { - request_id: None, group_order: GroupOrder::Ascending, end_of_track: false, end_location: ietf::Location { @@ -16671,7 +16005,6 @@ mod joining_fetch_tests { let ok = message_bytes( ietf::FetchOk::ID, &ietf::FetchOk { - request_id: None, group_order: GroupOrder::Ascending, end_of_track, end_location, @@ -16780,8 +16113,6 @@ mod joining_fetch_tests { let ok = message_bytes( ietf::FetchOk::ID, &ietf::FetchOk { - request_id: matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) - .then_some(RequestId(1)), group_order: GroupOrder::Ascending, end_of_track: ended, end_location, @@ -16802,24 +16133,15 @@ mod joining_fetch_tests { .unwrap(); for (index, payload) in [b"c", b"d"].iter().enumerate() { let first = index == 0; - if version == Version::Draft14 { - let w = &mut crate::coding::Encoder::new(&mut objects, version.into()); - w.varint(GROUP).unwrap(); - w.varint(0u64).unwrap(); // Subgroup - w.varint(START + index as u64).unwrap(); - w.u8(0); // Priority - w.varint(0u64).unwrap(); // Properties - } else { - ietf::FetchObject::Object { - subgroup: ietf::FetchSubgroup::Zero, - group: first.then_some(GROUP), - object: first.then_some(START), - priority: first.then_some(0), - properties: None, - } - .encode(&mut crate::coding::Encoder::new(&mut objects, version.into()), version) - .unwrap(); + ietf::FetchObject::Object { + subgroup: ietf::FetchSubgroup::Zero, + group: first.then_some(GROUP), + object: first.then_some(START), + priority: first.then_some(0), + properties: None, } + .encode(&mut crate::coding::Encoder::new(&mut objects, version.into()), version) + .unwrap(); crate::coding::Encoder::new(&mut objects, version.into()) .varint(1u64) .unwrap(); @@ -17039,7 +16361,6 @@ mod new_group_tests { stream .writer .encode(&ietf::SubscribeOk { - request_id: None, track_alias: 7, largest: Some(ietf::Location { group: largest, @@ -17070,7 +16391,6 @@ mod new_group_tests { .writer .encode(&ietf::RequestOk { largest: None, - request_id: None, active: None, }) .await @@ -17171,7 +16491,6 @@ mod new_group_tests { stream .writer .encode(&ietf::RequestError { - request_id: None, error_code: 0, reason_phrase: "refused".into(), retry_interval: 0, @@ -17250,7 +16569,7 @@ mod track_property_tests { }; /// The newest draft and an older one, both with a request stream per subscription. - const VERSIONS: [Version; 2] = [Version::Draft17, Version::Draft22]; + const VERSIONS: [Version; 2] = [Version::Draft22]; /// Subscribe to one track through a relay on `version`, whose publisher answers with /// `block` as SUBSCRIBE_OK's Track Properties, returning what the subscriber got. @@ -17290,7 +16609,6 @@ mod track_property_tests { let mut body = Vec::new(); ietf::SubscribeOk { - request_id: None, track_alias: 7, largest: None, properties: Default::default(), @@ -17450,10 +16768,6 @@ mod compression_negotiation_tests { ..Default::default() }; for version in [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, Version::Draft22, ] { diff --git a/rs/moq-net/src/ietf/subscriber/tracks.rs b/rs/moq-net/src/ietf/subscriber/tracks.rs index 53881fc05a4..7984a903ab3 100644 --- a/rs/moq-net/src/ietf/subscriber/tracks.rs +++ b/rs/moq-net/src/ietf/subscriber/tracks.rs @@ -32,7 +32,7 @@ pub(super) type TrackKey = (PathOwned, Arc); /// status, INTERNAL_ERROR included, fails the listing, so it asks again rather than hide a /// track that may still be live. pub(super) fn listing_end(done: &ietf::PublishDone, version: Version) -> Result<(), Error> { - match done.status_code == ietf::PublishDoneStatus::TrackEnded.code(version) { + match done.status_code == ietf::PublishDoneStatus::TrackEnded.code() { true => Ok(()), false => Err(done .end(version) @@ -426,9 +426,9 @@ impl Subscriber { let Some(stream) = opened else { return Ok(()); }; - let mut stream = request_stream::with_stats(stream?, self.origin.stats(), self.version); + let mut stream = stream?.with_stats(self.origin.stats()); // No draft with SUBSCRIBE_TRACKS has MAX_REQUEST_ID, so this never waits on credit. - let request_id = kio::wait(|waiter| self.control.poll_next_request_id(waiter)).await; + let request_id = self.control.next_request_id(); stream.writer.buffer_message( ietf::SubscribeTracks::ID, &ietf::SubscribeTracks { @@ -622,8 +622,8 @@ impl Subscriber { let Some(stream) = opened else { return Ok(None); }; - let mut stream = request_stream::with_stats(stream?, self.origin.stats(), self.version); - let request_id = kio::wait(|waiter| self.control.poll_next_request_id(waiter)).await; + let mut stream = stream?.with_stats(self.origin.stats()); + let request_id = self.control.next_request_id(); self.state.lock().subscribes.insert( request_id, TrackState { @@ -674,7 +674,7 @@ impl Subscriber { Ok(Some(accepted)) => accepted, Ok(None) => { self.remove_subscribe(request_id); - self.cancel_subscribe(stream, request_id).await; + self.cancel_subscribe(stream).await; return Ok(None); } Err(err) => { @@ -684,12 +684,12 @@ impl Subscriber { }; if let Some(err) = refused(&accepted.properties, self.version, self.peer_setup.get().await.flate) { self.remove_subscribe(request_id); - self.cancel_subscribe(stream, request_id).await; + self.cancel_subscribe(stream).await; return Err(err); } if let Err(err) = self.bind_alias(request_id, accepted.alias) { self.remove_subscribe(request_id); - self.cancel_subscribe(stream, request_id).await; + self.cancel_subscribe(stream).await; return Err(err); } let info = accepted_info(&accepted.properties, self.version); @@ -709,7 +709,7 @@ impl Subscriber { }; if !listed { self.remove_subscribe(request_id); - self.cancel_subscribe(stream, request_id).await; + self.cancel_subscribe(stream).await; return Ok(None); } Ok(Some(Upstream { @@ -828,7 +828,6 @@ impl Subscriber { Offer::Refuse(code, reason) => { tracing::debug!(broadcast = %key.0, track = %key.1, reason, "refusing publish"); let error = ietf::RequestError { - request_id: None, error_code: code, reason_phrase: reason.into(), retry_interval: 0, @@ -857,7 +856,6 @@ impl Subscriber { stream.writer.buffer_message( id, &ietf::PublishOk { - request_id: None, forward: false, subscriber_priority: None, group_order: None, @@ -939,12 +937,12 @@ impl Subscriber { } }; self.remove_subscribe(upstream.request_id); - self.cancel_subscribe(upstream.stream, upstream.request_id).await; + self.cancel_subscribe(upstream.stream).await; return; } Step::Gone => { self.remove_subscribe(upstream.request_id); - self.cancel_subscribe(upstream.stream, upstream.request_id).await; + self.cancel_subscribe(upstream.stream).await; return; } Step::Message(Ok(Some(Framed(id, body)))) => match id { @@ -1074,7 +1072,7 @@ impl Subscriber { true => this.watch(key, upstream, handoff).await, false => { this.remove_subscribe(upstream.request_id); - this.cancel_subscribe(upstream.stream, upstream.request_id).await; + this.cancel_subscribe(upstream.stream).await; } } }); @@ -1136,14 +1134,11 @@ impl Subscriber { writer: &mut Writer, forward: &Forward, ) -> Result<(), Error> { - let request_id = self.control.next_request_id(&self.runtime).await?; + let request_id = self.control.next_request_id(); writer .encode_message(&ietf::SubscribeUpdate { max_age: forward.max_age, request_id, - subscription_request_id: None, - start_location: ietf::Location { group: 0, object: 0 }, - end_group: 0, subscriber_priority: forward.priority.map(super::super::priority::to_wire), forward: Some(forward.forward), filter: forward.filter, @@ -1337,7 +1332,6 @@ mod tests { assert_eq!(msg.prefix.as_str(), "bcast"); assert!(!msg.forward, "the listing asks for every track's objects"); let ok = ietf::RequestOk { - request_id: None, active: None, largest: None, }; @@ -1393,7 +1387,6 @@ mod tests { let resume: ietf::SubscribeUpdate = body.message(self.version).unwrap(); assert_eq!(resume.forward, Some(true)); let ok = ietf::RequestOk { - request_id: None, active: None, largest: None, }; @@ -1493,8 +1486,7 @@ mod tests { assert_eq!(event(&mut h.tracks).as_deref(), Some("+video")); let done = ietf::PublishDone { - request_id: None, - status_code: ietf::PublishDoneStatus::TrackEnded.code(version), + status_code: ietf::PublishDoneStatus::TrackEnded.code(), stream_count: 0, reason_phrase: "".into(), }; @@ -1518,8 +1510,7 @@ mod tests { assert_eq!(event(&mut h.tracks).as_deref(), Some("+video")); let done = ietf::PublishDone { - request_id: None, - status_code: status.code(version), + status_code: status.code(), stream_count: 0, reason_phrase: "".into(), }; @@ -1546,7 +1537,6 @@ mod tests { // SUBSCRIPTION_ENDED, which drafts 18 and 19 register. let done = ietf::PublishDone { - request_id: None, status_code: 0x3, stream_count: 0, reason_phrase: "".into(), @@ -1589,7 +1579,6 @@ mod tests { assert!(!msg.forward, "{version}: the SUBSCRIBE forwards"); let ok = ietf::SubscribeOk { - request_id: None, track_alias: 3, largest: None, properties: ietf::Properties { @@ -1622,7 +1611,6 @@ mod tests { .unwrap(); let _ = read(&mut stream).await; let refused = ietf::RequestError { - request_id: None, error_code: 0x3, reason_phrase: "".into(), retry_interval: 0, @@ -1705,8 +1693,7 @@ mod tests { Some(true) ); let done = ietf::PublishDone { - request_id: None, - status_code: ietf::PublishDoneStatus::TrackEnded.code(version), + status_code: ietf::PublishDoneStatus::TrackEnded.code(), stream_count: 0, reason_phrase: "".into(), }; @@ -1739,8 +1726,7 @@ mod tests { assert!(!serving.is_finished(), "the copy did not linger"); let done = ietf::PublishDone { - request_id: None, - status_code: ietf::PublishDoneStatus::InternalError.code(version), + status_code: ietf::PublishDoneStatus::InternalError.code(), stream_count: 0, reason_phrase: "".into(), }; @@ -1793,7 +1779,6 @@ mod tests { let _held = match case { "refused" => { let refused = ietf::RequestError { - request_id: None, error_code: 0x3, reason_phrase: "".into(), retry_interval: 0, @@ -1832,7 +1817,6 @@ mod tests { let msg: ietf::Subscribe = body.message(version).unwrap(); assert!(msg.forward, "{case}: a paused SUBSCRIBE"); let ok = ietf::SubscribeOk { - request_id: None, track_alias: 7, largest: None, properties: ietf::Properties::default(), diff --git a/rs/moq-net/src/ietf/token.rs b/rs/moq-net/src/ietf/token.rs index 59fc94c2430..bada6914429 100644 --- a/rs/moq-net/src/ietf/token.rs +++ b/rs/moq-net/src/ietf/token.rs @@ -12,11 +12,11 @@ use crate::driver::Transport; use crate::{ DecodeError, Error, SessionError, - coding::{Decode as _, Decoder, EncodeError, Encoder}, + coding::{Decoder, EncodeError, Encoder}, setup::Token, }; -use super::{Param, ParameterBytes, Parameters, RequestId, Version, error::request}; +use super::{Param, ParameterBytes, Parameters, Version, error::request}; /// Retire a registered alias. const DELETE: u64 = 0x0; @@ -107,27 +107,16 @@ pub(super) fn reason(err: &DecodeError) -> &'static str { /// Refuse a request whose tokens decoded to `err`, one [`refuses_request`] accepts, ending /// its stream. /// -/// Section 8.9 rejects the message rather than the session. Every request starts with its -/// Request ID, so it is read from the undecoded `body`. +/// Section 8.9 rejects the message rather than the session. #[cfg(feature = "async")] pub(super) async fn reject( mut stream: Stream, kind: request::Kind, - body: super::Body, err: DecodeError, version: Version, ) -> Result<(), Error> { - let request_id = RequestId::decode(&mut body.decoder(version), version)?; let reason = reason(&err); - super::request_stream::write_error( - &mut stream.writer, - kind, - request_id, - &Error::Decode(err), - reason, - version, - ) - .await?; + super::request_stream::write_error(&mut stream.writer, kind, &Error::Decode(err), reason, version).await?; // The peer dropping the stream once it has the rejection is a normal end. let _ = stream.writer.close().await; Ok(()) @@ -214,10 +203,6 @@ mod tests { } const VERSIONS: [Version; 9] = [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft20, @@ -339,9 +324,7 @@ mod tests { let key = u64::from(ParameterBytes::AuthorizationToken); let (count, keys): (Option, [u64; 2]) = match version { - Version::Draft14 | Version::Draft15 => (Some(2), [key, key]), // Delta-encoded from draft-16, so the repeat is a delta of zero. - Version::Draft16 => (Some(2), [key, 0]), _ => (None, [key, 0]), }; let mut raw = Vec::new(); diff --git a/rs/moq-net/src/ietf/track.rs b/rs/moq-net/src/ietf/track.rs index abc97b75ce6..52f415f4820 100644 --- a/rs/moq-net/src/ietf/track.rs +++ b/rs/moq-net/src/ietf/track.rs @@ -7,7 +7,7 @@ use num_enum::{IntoPrimitive, TryFromPrimitive}; use crate::{ Path, coding::*, - ietf::{Filter, GroupOrder, Location, Properties, RequestId, Subscribe, SubscribeOk}, + ietf::{Filter, Location, Properties, RequestId, Subscribe}, }; use super::Message; @@ -15,9 +15,8 @@ use super::namespace::encode_namespace; use super::Version; -/// TrackStatus message (0x0d) -/// v14: own format (TrackStatusRequest-like with subscribe fields) -/// v15: same wire format as SUBSCRIBE. Response is REQUEST_OK. +/// TrackStatus message (0x0d), with the same wire format as SUBSCRIBE. The response is +/// REQUEST_OK. #[derive(Clone, Debug)] pub struct TrackStatus<'a> { pub request_id: RequestId, @@ -26,7 +25,7 @@ pub struct TrackStatus<'a> { /// Whether the requester wants Track Properties on the answer (INCLUDE_PROPERTIES, /// draft-20). pub properties_wanted: bool, - /// The publisher instance the requester expects (MoQ Epoch, draft-17+). + /// The publisher instance the requester expects (MoQ Epoch). pub epoch: Option, } @@ -35,31 +34,17 @@ impl Message for TrackStatus<'_> { fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { self.request_id.encode(w, version)?; - if version == Version::Draft17 { - w.varint(0)?; // required_request_id_delta = 0 - } encode_namespace(w, &self.track_namespace)?; w.string(&self.track_name)?; - match version { - Version::Draft14 => { - w.u8(0); // subscriber priority - GroupOrder::Descending.encode(w, version)?; - w.bool(false); // forward - Filter::NextObject.encode(w, version)?; // filter - w.u8(0); // no parameters - } - _ => { - // Only the opt-out is worth bytes, and an older peer would read the - // parameter as unknown, which is a protocol violation. - let include_properties = (!self.properties_wanted && Filter::is_draft20(version)).then_some(false); - let epoch = self.epoch.clone().filter(|_| super::epoch::supported(version)); - encode_params!(w, version, - 0x35 => include_properties, - super::epoch::EPOCH_PARAM => epoch, - ); - } - } + // Only the opt-out is worth bytes, and an older peer would read the + // parameter as unknown, which is a protocol violation. + let include_properties = (!self.properties_wanted && Filter::is_draft20(version)).then_some(false); + let epoch = self.epoch.clone(); + encode_params!(w, version, + 0x35 => include_properties, + super::epoch::EPOCH_PARAM => epoch, + ); Ok(()) } @@ -78,132 +63,41 @@ impl Message for TrackStatus<'_> { } } -/// TRACK_STATUS_OK: what a SUBSCRIBE_OK would say about the track, with no subscription. -/// -/// Draft-14 gives it its own type ([`Self::ID_14`]) and the SUBSCRIBE_OK body, with a -/// Track Alias of 0. Later drafts answer with a REQUEST_OK, which gained Track Properties -/// in draft-18; before that only the message parameters carry anything. +/// TRACK_STATUS_OK: what a SUBSCRIBE_OK would say about the track, with no subscription, +/// sent as a REQUEST_OK with Track Properties. #[derive(Clone, Debug, PartialEq, Eq)] pub struct TrackStatusOk { - /// Present on drafts 14-16 only. - pub request_id: Option, - /// The largest Location in the track (LARGEST_OBJECT), absent while it has no content. pub largest: Option, - /// The Track Properties, on the drafts whose answer has room for them. + /// The Track Properties. pub properties: Properties, } -/// TRACK_STATUS_ERROR on draft-14, with the SUBSCRIBE_ERROR body. Later drafts refuse -/// with REQUEST_ERROR. -pub const TRACK_STATUS_ERROR_14: u64 = 0x0F; - -impl TrackStatusOk { - /// The draft-14 message type. - pub const ID_14: u64 = 0x0E; - - /// The message type on `version`. - pub fn id(version: Version) -> u64 { - match version { - Version::Draft14 => Self::ID_14, - _ => Self::ID, - } - } - - /// Whether this answer describes the track as fully as SUBSCRIBE_OK on `version`. - /// Draft-17 is the gap: SUBSCRIBE_OK declares TIMESCALE, but REQUEST_OK has no - /// properties block to say whether the track is timed. - pub(crate) fn describes_track(version: Version) -> bool { - Self::has_properties(version) || !super::Properties::sends_timescale(version) - } - - /// Whether the answer carries a Track Properties block on `version`. - fn has_properties(version: Version) -> bool { - !matches!( - version, - Version::Draft14 | Version::Draft15 | Version::Draft16 | Version::Draft17 - ) - } -} - impl Message for TrackStatusOk { - /// REQUEST_OK; see [`Self::id`]. + /// REQUEST_OK. const ID: u64 = 0x07; fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { - if version == Version::Draft14 { - return SubscribeOk { - request_id: self.request_id, - track_alias: 0, - largest: self.largest, - properties: self.properties.clone(), - } - .encode_msg(w, version); - } - - if matches!(version, Version::Draft15 | Version::Draft16) { - self.request_id - .expect("request_id required for draft14-16") - .encode(w, version)?; - } else { - assert!(self.request_id.is_none(), "request_id must be None for draft17+"); - } - - // The parameters SUBSCRIBE_OK carries: GROUP_ORDER is one only on draft-15, and a - // Track Property after. - let group_order = match version { - Version::Draft15 => self.properties.group_order, - _ => None, - }; + // The parameters SUBSCRIBE_OK carries. encode_params!(w, version, 0x09 => self.largest, - 0x22 => group_order, ); // Track Properties are the final field, so nothing may follow. - if Self::has_properties(version) { - self.properties.encode(w, version)?; - } + self.properties.encode(w, version)?; Ok(()) } fn decode_msg(r: &mut Decoder<'_>, version: Version) -> Result { - if version == Version::Draft14 { - let ok = SubscribeOk::decode_msg(r, version)?; - return Ok(Self { - request_id: ok.request_id, - largest: ok.largest, - properties: ok.properties, - }); - } - - let request_id = match version { - Version::Draft15 | Version::Draft16 => Some(RequestId::decode(r, version)?), - _ => None, - }; - // Read as SUBSCRIBE_OK's are: EXPIRES is ignored, and MAX_CACHE_DURATION is a - // parameter only on draft-15. + // Read as SUBSCRIBE_OK's are: EXPIRES is ignored. decode_params!(r, version, - 0x04 => max_cache_duration: Option where version == Version::Draft15, 0x08 => _expires: Option, 0x09 => largest: Option, - 0x22 => group_order: Option where version == Version::Draft15, ); - let mut properties = match Self::has_properties(version) { - true => Properties::decode(r, version)?, - false => Properties::default(), - }; - properties.group_order = properties.group_order.or(group_order); - if version == Version::Draft15 { - properties.max_cache_duration = max_cache_duration.map(std::time::Duration::from_millis); - } + let properties = Properties::decode(r, version)?; - Ok(Self { - request_id, - largest, - properties, - }) + Ok(Self { largest, properties }) } } @@ -352,10 +246,6 @@ mod tests { } const ALL: [Version; 9] = [ - Version::Draft14, - Version::Draft15, - Version::Draft16, - Version::Draft17, Version::Draft18, Version::Draft19, Version::Draft20, @@ -402,22 +292,13 @@ mod tests { for version in ALL { let msg = TrackStatusOk { - request_id: matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) - .then_some(RequestId(3)), largest, properties: properties.clone(), }; let decoded: TrackStatusOk = decode_message(&encode_message(&msg, version), version).unwrap_or_else(|e| panic!("{version}: {e}")); - let expected = match version { - Version::Draft14 | Version::Draft15 => Properties { - group_order: Some(GroupOrder::Descending), - ..Default::default() - }, - Version::Draft16 | Version::Draft17 => Properties::default(), - _ => properties.clone(), - }; + let expected = properties.clone(); assert_eq!(decoded.request_id, msg.request_id, "{version}"); assert_eq!(decoded.largest, largest, "{version}"); assert_eq!(decoded.properties, expected, "{version}"); @@ -428,14 +309,12 @@ mod tests { #[test] fn test_track_status_ok_draft_14_is_a_subscribe_ok() { let msg = TrackStatusOk { - request_id: Some(RequestId(3)), largest: None, properties: Properties::default(), }; assert_eq!(TrackStatusOk::id(Version::Draft14), 0x0E); assert_eq!(TrackStatusOk::id(Version::Draft15), 0x07); let subscribe_ok = SubscribeOk { - request_id: Some(RequestId(3)), track_alias: 0, largest: None, properties: Properties::default(), diff --git a/rs/moq-net/src/ietf/version.rs b/rs/moq-net/src/ietf/version.rs index faf024169dd..59f22f18ddb 100644 --- a/rs/moq-net/src/ietf/version.rs +++ b/rs/moq-net/src/ietf/version.rs @@ -4,10 +4,6 @@ use std::fmt; #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] #[non_exhaustive] pub enum Version { - Draft14, - Draft15, - Draft16, - Draft17, Draft18, Draft19, Draft20, @@ -18,10 +14,6 @@ pub enum Version { impl fmt::Display for Version { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { - Self::Draft14 => write!(f, "moq-transport-14"), - Self::Draft15 => write!(f, "moq-transport-15"), - Self::Draft16 => write!(f, "moq-transport-16"), - Self::Draft17 => write!(f, "moq-transport-17"), Self::Draft18 => write!(f, "moq-transport-18"), Self::Draft19 => write!(f, "moq-transport-19"), Self::Draft20 => write!(f, "moq-transport-20"), diff --git a/rs/moq-net/src/lite/ietf.rs b/rs/moq-net/src/lite/ietf.rs index fae719f149a..f39c8172bed 100644 --- a/rs/moq-net/src/lite/ietf.rs +++ b/rs/moq-net/src/lite/ietf.rs @@ -206,11 +206,11 @@ pub(crate) fn decode_properties(body: &[u8], framing: super::Framing, framed: bo } /// Decode the END_OF_GROUP record's body on a track `framing` describes. It is a status -/// object, so a block needs a draft that lets one carry properties. +/// object, so it may not carry properties. #[cfg(feature = "async")] pub(crate) fn decode_end(body: &[u8], framing: super::Framing) -> Result { let decoded = decode_properties(body, framing, false)?; - if decoded.properties.block.is_some() && !framing.ietf.is_some_and(crate::ietf::object::status_has_properties) { + if decoded.properties.block.is_some() { return Err(DecodeError::InvalidValue); } Ok(decoded) @@ -341,9 +341,6 @@ impl Message for TrackProperties { return Err(DecodeError::InvalidValue); }; // Track Properties start at draft-16. - if matches!(version, crate::ietf::Version::Draft14 | crate::ietf::Version::Draft15) && !r.is_empty() { - return Err(DecodeError::InvalidValue); - } let properties = crate::model::object::TrackProperties { version, values: decode_list(r, version)?, @@ -417,7 +414,7 @@ pub(crate) fn decode_datagram( return Err(DecodeError::InvalidValue); } // A track published over moq-lite has no moq-transport state. - let version = framing.ietf.ok_or(DecodeError::InvalidValue)?; + framing.ietf.ok_or(DecodeError::InvalidValue)?; let object_id = (state & OBJECT_ID != 0).then(|| r.varint()).transpose()?; let priority = (state & PRIORITY != 0).then(|| r.u8()).transpose()?; let status = (state & STATUS != 0).then(|| r.varint()).transpose()?; @@ -433,7 +430,7 @@ pub(crate) fn decode_datagram( properties, }; // A relay holds and forwards it, so it must be one its publisher's draft could send. - if !wire.defined(version) { + if !wire.defined() { return Err(DecodeError::InvalidValue); } Ok(Some(wire)) @@ -565,7 +562,7 @@ mod tests { /// after a large first ID, crosses the hop byte for byte and is held at its wire size. #[test] fn a_full_block_crosses_at_its_wire_size() { - for version in [Draft::Draft16, Draft::Draft22] { + for version in [Draft::Draft22] { let mut list = Vec::new(); let e = &mut Encoder::new(&mut list, version.into()); // A Timestamp, then IDs from 2^40 on, each repeated as a two-byte zero delta. @@ -626,7 +623,7 @@ mod tests { assert_eq!(decoded.0.as_deref(), Some(&properties)); // Drafts 14 and 15 have no Track Properties, but their objects may have properties. - for version in [Draft::Draft14, Draft::Draft22] { + for version in [Draft::Draft22] { let bare = crate::model::object::TrackProperties { version, values: Vec::new(), @@ -677,7 +674,7 @@ mod tests { decode(&wire(&[opaque(0x40)], 0)).is_err(), "properties on a moq-lite track" ); - for version in [Draft::Draft14, Draft::Draft15] { + for version in [Draft::Draft15] { assert!(decode(&wire(&[], code(version))).is_ok(), "{version}"); assert!( decode(&wire(&[opaque(0x40)], code(version))).is_err(), @@ -730,7 +727,7 @@ mod tests { /// message would no longer fit a lite one. #[test] fn track_properties_cross_at_their_wire_size() { - for version in [Draft::Draft16, Draft::Draft17, Draft::Draft22] { + for version in [Draft::Draft22] { // As many repeats of an ID from 2^60 as moq-transport forwards, then one value // that fills the rest of a lite message beside its Version. let id = (1 << 60) + 1; @@ -971,7 +968,7 @@ mod tests { #[cfg(feature = "async")] #[test] fn an_end_record_block_needs_a_draft_that_carries_one() { - for version in [Draft::Draft14, Draft::Draft15, Draft::Draft16, Draft::Draft22] { + for version in [Draft::Draft22] { let framing = from(version, None); assert_eq!( decode_end(&[0x20, 1], framing).is_ok(), @@ -987,10 +984,6 @@ mod tests { #[test] fn a_datagram_block_needs_a_draft_that_sends_its_shape() { let drafts = [ - Draft::Draft14, - Draft::Draft15, - Draft::Draft16, - Draft::Draft17, Draft::Draft22, ]; for (status, carried) in [ diff --git a/rs/moq-net/src/model/origin.rs b/rs/moq-net/src/model/origin.rs index 7bb068b1879..494dd650976 100644 --- a/rs/moq-net/src/model/origin.rs +++ b/rs/moq-net/src/model/origin.rs @@ -1690,7 +1690,7 @@ impl TableCursor { /// Whether the hidden rule lets this cursor discover a route at `prefix`. fn discovers(&self, prefix: &Path) -> bool { - self.hidden.discovers(&self.heads, prefix) + self.hidden.reaches(&self.heads, prefix) } } @@ -1860,35 +1860,20 @@ pub(super) struct Hidden { include: bool, /// Measure visibility from the request prefix instead of authorization heads. from: Option, - /// Report only what a feed scoped to these heads hides, for a stream that tops - /// up a feed already carrying everything visible from them. - beyond: Option>, } impl Hidden { - /// Whether a cursor hanging at `heads` reports a route at `prefix`. - fn discovers(&self, heads: &[PathOwned], prefix: &Path) -> bool { - self.reaches(heads, prefix) && self.beyond.as_ref().is_none_or(|outer| hides(outer, prefix)) - } - - /// Whether a cursor hanging at `heads` could report a route at or beneath `prefix`. - /// A hidden segment hides everything beneath it, while a top-up feed's rule turns - /// on the rest of the path, so only the first can rule a prefix out. + /// Whether a cursor hanging at `heads` reports a route at or beneath `prefix`. A hidden + /// segment hides everything beneath it. fn reaches(&self, heads: &[PathOwned], prefix: &Path) -> bool { self.include || !hides(self.from.as_ref().map(std::slice::from_ref).unwrap_or(heads), prefix) } - /// This rule for a cursor reading through `mount`, whose heads sit on the - /// target: a feed it tops up hid everything under the mount, or hid what it - /// hides under the target. + /// This rule for a cursor reading through `mount`, whose heads sit on the target. fn translate(&self, mount: &Mount) -> Self { - let beyond = self.beyond.as_ref().and_then(|outer| { - (!hides(outer, &mount.at)).then(|| outer.iter().filter_map(|head| mount.translate_head(head)).collect()) - }); Self { include: self.include, from: self.from.as_ref().and_then(|head| mount.translate_head(head)), - beyond, } } } @@ -6034,21 +6019,6 @@ impl Consumer { self } - /// A clone whose [`announced`](Self::announced) reports only the routes a feed - /// from `outer` hides, for a stream topping up that feed. - #[cfg_attr(not(feature = "async"), allow(dead_code, reason = "async-only"))] - pub(crate) fn beyond(mut self, outer: &Consumer) -> Self { - self.hidden.beyond = Some( - outer - .hidden - .from - .clone() - .map(|head| vec![head]) - .unwrap_or_else(|| interest_prefixes(&outer.scope.allowed)), - ); - self - } - /// Set wire discovery visibility relative to this consumer's requested root. #[cfg_attr(not(feature = "async"), allow(dead_code, reason = "async-only"))] pub(crate) fn discovery(mut self, hidden: bool) -> Self { @@ -7511,20 +7481,6 @@ mod tests { let mut announced = consumer.scope("", &scopes(&["room/.internal"])).unwrap().announced(); announced.expect_next_active("room/.internal").await; announced.assert_next_wait(); - - // A top-up feed reports only what a feed from the root hid, filtered by its own - // prefix and opt-in. - let mut announced = consumer.clone().with_hidden(true).beyond(&consumer).announced(); - announced.expect_next_active(".stats/node").await; - announced.expect_next_active("room/.internal").await; - announced.assert_next_wait(); - let room = consumer.scope("", &scopes(&["room"])).unwrap().beyond(&consumer); - let mut announced = room.announced(); - announced.assert_next_wait(); - let stats = consumer.scope("", &scopes(&[".stats"])).unwrap().beyond(&consumer); - let mut announced = stats.announced(); - announced.expect_next_active(".stats/node").await; - announced.assert_next_wait(); } /// Hiding narrows discovery only: an exact request resolves without an opt-in. diff --git a/rs/moq-net/src/server.rs b/rs/moq-net/src/server.rs index 458c8eaf516..ca6f9ad1431 100644 --- a/rs/moq-net/src/server.rs +++ b/rs/moq-net/src/server.rs @@ -6,8 +6,7 @@ use crate::origin; use crate::time::{Deadlines, Instant}; use crate::transport::poll::Session as _; use crate::{ - ALPN_14, ALPN_15, ALPN_16, ALPN_17, ALPN_18, ALPN_19, ALPN_20, ALPN_21, ALPN_22, ALPN_LITE, ALPN_LITE_03, - ALPN_LITE_04, ALPN_LITE_05, ALPN_LITE_06, ALPN_LITE_07_WIP, Consume, Error, NEGOTIATED, Session, SessionError, + ALPN_18, ALPN_19, ALPN_20, ALPN_21, ALPN_22, ALPN_LITE, ALPN_LITE_03, ALPN_LITE_04, ALPN_LITE_05, ALPN_LITE_06, ALPN_LITE_07_WIP, Consume, Error, NEGOTIATED, Session, SessionError, Version, Versions, coding::{Decode, Encode, Stream}, ietf, lite, @@ -285,7 +284,7 @@ impl Server { PausedHandshake::LiteBare { version, .. } | PausedHandshake::LiteSetup { version, .. } => { version.has_auth() } - PausedHandshake::IetfModern(_) | PausedHandshake::Legacy(_) => false, + PausedHandshake::IetfModern(_) | PausedHandshake::Negotiated(_) => false, }); Ok(Handshake { path, @@ -350,54 +349,31 @@ impl Server { } async fn handshake(&self, runtime: Deadlines, mut session: Transport) -> Result { - let (encoding, supported) = match session.protocol() { - Some(alpn @ (ALPN_22 | ALPN_21 | ALPN_20 | ALPN_19 | ALPN_18 | ALPN_17)) => { + let supported = match session.protocol() { + Some(alpn @ (ALPN_22 | ALPN_21 | ALPN_20 | ALPN_19 | ALPN_18)) => { let draft = match alpn { ALPN_22 => ietf::Version::Draft22, ALPN_21 => ietf::Version::Draft21, ALPN_20 => ietf::Version::Draft20, ALPN_19 => ietf::Version::Draft19, - ALPN_18 => ietf::Version::Draft18, - _ => ietf::Version::Draft17, + _ => ietf::Version::Draft18, }; self.versions.select(Version::Ietf(draft)).ok_or(Error::Version)?; return self.accept_ietf_modern(runtime, session, draft).await; } - Some(ALPN_16) => { - let v = self - .versions - .select(Version::Ietf(ietf::Version::Draft16)) - .ok_or(Error::Version)?; - (v, v.into()) - } - Some(ALPN_15) => { - let v = self - .versions - .select(Version::Ietf(ietf::Version::Draft15)) - .ok_or(Error::Version)?; - (v, v.into()) - } - Some(ALPN_14) => { - let v = self - .versions - .select(Version::Ietf(ietf::Version::Draft14)) - .ok_or(Error::Version)?; - (v, v.into()) - } Some(ALPN_LITE_07_WIP | ALPN_LITE_06 | ALPN_LITE_05 | ALPN_LITE_04 | ALPN_LITE_03) => { return self.handshake_lite(runtime, session).await; } - Some(ALPN_LITE) | None => { - let supported = self.versions.filter(&NEGOTIATED.into()).ok_or(Error::Version)?; - (Version::Ietf(ietf::Version::Draft14), supported) - } + // No ALPN, or `moql`: negotiate moq-lite 01/02 in a bidi SETUP. + Some(ALPN_LITE) | None => self.versions.filter(&NEGOTIATED.into()).ok_or(Error::Version)?, Some(p) => return Err(Error::UnknownAlpn(p.to_string())), }; - // Legacy bidi SETUP exchange (IETF 14-16, lite 01/02). Read the client's - // SETUP to choose the version; `ok()` sends the server SETUP and starts. + // Read the client's SETUP to choose the version; `ok()` sends the server SETUP and starts. // Stats attach in `ok()`: a caller may still replace them on the handshake. + // Lite 01 and 02 frame the SETUP identically, so either decodes it. + let encoding = *supported.iter().next().ok_or(Error::Version)?; let mut stream = Stream::accept(&mut session, encoding).await?; let (client, client_setup_size) = stream.reader.decode_sized::().await?; @@ -407,71 +383,34 @@ impl Server { .flat_map(|v| Version::try_from(*v).ok()) .find(|v| supported.contains(v)) .ok_or(Error::Version)?; - - // Pull the request path and max request ID out now (IETF only) so `ok()` - // doesn't re-decode the consumed parameters. moq-transport carries the path - // in its SETUP just like lite-05. - let (path, token, request_id_max, peer_declared, peer_implementation) = match version { - Version::Ietf(v) => { - let (params, _) = ietf::Parameters::decode_slice(&client.parameters, v)?; - let path = match params.get_bytes(ietf::ParameterBytes::Path) { - Some(bytes) => Some( - std::str::from_utf8(bytes) - .map_err(|_| Error::Decode(crate::DecodeError::InvalidValue))? - .to_owned(), - ), - None => None, - }; - let token = ietf::token::from_setup(¶ms, v)?; - let request_id_max = params - .get_varint(ietf::ParameterVarInt::MaxRequestId) - .map(ietf::RequestId); - let peer_declared = ietf::peer::Peer { - solicit: ietf::solicit::from_setup(¶ms, v)?, - hidden: ietf::hidden::from_setup(¶ms, v), - max_age: ietf::max_age::from_setup(¶ms, v), - active_count: ietf::active_count::from_setup(¶ms, v), - flate: ietf::flate::from_setup(¶ms, v)?, - ..Default::default() - }; - let implementation = - setup::decode_implementation(params.get_bytes(ietf::ParameterBytes::Implementation))?; - (path, token, request_id_max, peer_declared, implementation) - } - Version::Lite(_) => (None, None, None, ietf::peer::Peer::default(), None), + let Version::Lite(version) = version else { + return Err(Error::Version); }; Ok(Handshake { - path, + path: None, role: None, origin: None, - token, - peer_implementation: peer_implementation.clone(), + token: None, + peer_implementation: None, assigned_hop: crate::Hop::random(), - // Lite 01/02 and moq-transport 14-16 carry no AUTH, though a moq-transport request - // still carries a token. - auth: match version { - Version::Ietf(_) => crate::auth::Link::ietf(false), - Version::Lite(_) => crate::auth::Link::new(false), - }, + // Lite 01/02 carry no AUTH. + auth: crate::auth::Link::new(false), inner: Some(RequestInner { server: self.clone(), runtime, deadline: None, - handshake: PausedHandshake::Legacy(PausedLegacy { + handshake: PausedHandshake::Negotiated(PausedNegotiated { session, stream, version, - request_id_max, - peer_declared, - peer_implementation, client_setup_size, }), }), }) } - /// Read a draft-17/18 client's SETUP (with its request path) off its uni stream, + /// Read a moq-transport client's SETUP (with its request path) off its uni stream, /// then pause. `ok()` starts the session and hands the stream back for GOAWAY. async fn accept_ietf_modern( &self, @@ -556,7 +495,7 @@ enum PausedHandshake { client_setup: lite::AcceptedSetup, }, IetfModern(PausedIetfModern), - Legacy(PausedLegacy), + Negotiated(PausedNegotiated), } /// Modern IETF (17+): the client's SETUP (with its request path) has been @@ -593,8 +532,7 @@ impl PausedIetfModern { stats: server.stats.clone(), limits: server.limits, session: session.clone(), - setup: None, - request_id_max: None, + client: false, publish, subscribe, @@ -631,23 +569,17 @@ impl PausedIetfModern { } } -/// Legacy IETF (draft 14-16) and lite 01/02: the client SETUP has been read -/// off the bidi stream (including its request path) but the server SETUP -/// hasn't been sent; `ok` finishes it. -struct PausedLegacy { +/// moq-lite 01/02: the client SETUP has been read off the bidi stream but the server +/// SETUP hasn't been sent; `ok` finishes it. +struct PausedNegotiated { session: Transport, stream: Stream, - version: Version, - request_id_max: Option, - /// What the client's SETUP declared, for the options `ok` acts on. - peer_declared: ietf::peer::Peer, - /// The implementation the client's SETUP advertised. - peer_implementation: Option, + version: lite::Version, /// The client SETUP's encoded size, counted under the final stats. client_setup_size: usize, } -impl PausedLegacy { +impl PausedNegotiated { /// Send the server SETUP and start the session. async fn ok( self, @@ -660,125 +592,49 @@ impl PausedLegacy { session, stream, version, - request_id_max, - peer_declared, - peer_implementation, client_setup_size, } = self; let mut stream = stream.with_stats(&server.stats); server.stats.control(stats::Control::Session, client_setup_size, true); let (publish, subscribe) = server.stat_tagged_origins(); - // Encode parameters using the version-appropriate type. - let parameters = match version { - Version::Ietf(v) => { - let mut parameters = ietf::Parameters::default(); - // The client's requests, admitted up to our limits and granted back as they close. - parameters.set_varint( - ietf::ParameterVarInt::MaxRequestId, - ietf::initial_max_request_id(server.limits.window(), true), - ); - if let Some(implementation) = server.implementation() { - parameters.set_bytes(ietf::ParameterBytes::Implementation, implementation.into_bytes()); - } - if server.extensions.solicit { - ietf::solicit::into_setup(&mut parameters, v); - } - ietf::hidden::into_setup(&mut parameters, v); - ietf::max_age::into_setup(&mut parameters, v); - ietf::active_count::into_setup(&mut parameters, v); - ietf::flate::into_setup(&mut parameters, v); - parameters.encode_bytes(v)? - } - Version::Lite(v) => lite::Parameters::default().encode_bytes(v)?, - }; - let server_setup = setup::Server { - version: version.into(), - parameters, + version: Version::Lite(version).into(), + parameters: lite::Parameters::default().encode_bytes(version)?, }; stream.writer.encode(&server_setup).await?; - let (recv_bw, protocol, goaway, auth, estimate, peer_implementation) = match version { - Version::Lite(v) => { - let stream = stream.with_version(v); - // Pre-lite-05: no Setup Stream, so nothing to advertise or seed. - let start = lite::start(lite::Config { - runtime: runtime.clone(), - stats: server.stats.clone(), - client: false, - limits: server.limits, - session: session.clone(), - setup_stream: Some(stream), - publish, - subscribe, - peer_hop, - version: v, - our_setup: lite::Setup::default(), - peer_setup: None, - auth, - })?; - ( - start.recv_bandwidth, - crate::driver::Protocol::Lite(Box::new(start.driver)), - start.goaway, - start.auth, - Some(start.estimate), - start.peer_implementation, - ) - } - Version::Ietf(v) => { - let stream = stream.with_version(v); - let peer_implementation = setup::PeerImplementation::known(peer_implementation); - // Draft 14-16: path came in the bidi SETUP, no uni SETUP to hand back. - let (protocol, goaway) = ietf::start(ietf::Config { - runtime: runtime.clone(), - stats: server.stats.clone(), - limits: server.limits, - session: session.clone(), - setup: Some(stream), - request_id_max, - client: false, - publish, - subscribe, - peer_hop, - cost: None, - version: v, - path: None, - authority: None, - peer_setup_stream: None, - peer_declared: Some(peer_declared), - auth: auth.clone(), - early_unis: Vec::new(), - extensions: server.extensions, - // Already sent on the bidi SETUP above. - implementation: None, - peer_implementation: peer_implementation.clone(), - })?; - ( - None, - crate::driver::Protocol::Ietf(protocol), - goaway, - auth, - None, - peer_implementation, - ) - } - }; + let stream = stream.with_version(version); + // Pre-lite-05: no Setup Stream, so nothing to advertise or seed. + let start = lite::start(lite::Config { + runtime: runtime.clone(), + stats: server.stats.clone(), + client: false, + limits: server.limits, + session: session.clone(), + setup_stream: Some(stream), + publish, + subscribe, + peer_hop, + version, + our_setup: lite::Setup::default(), + peer_setup: None, + auth, + })?; Ok(Session::new( runtime, session, - version, - recv_bw, - protocol, + version.into(), + start.recv_bandwidth, + crate::driver::Protocol::Lite(Box::new(start.driver)), crate::session::Handles { stats: server.stats.clone(), - goaway, - auth, - estimate, + goaway: start.goaway, + auth: start.auth, + estimate: Some(start.estimate), bandwidth: crate::bandwidth::Allocator::default(), - peer_implementation, + peer_implementation: start.peer_implementation, }, )) } @@ -946,7 +802,7 @@ impl Handshake { } PausedHandshake::IetfModern(paused) => paused.ok(server, runtime, peer_hop, auth), // Boxed so the bidi SETUP write of these old versions doesn't size every caller's future. - PausedHandshake::Legacy(paused) => Box::pin(paused.ok(server, runtime, peer_hop, auth)).await, + PausedHandshake::Negotiated(paused) => Box::pin(paused.ok(server, runtime, peer_hop, auth)).await, } }; let res = match deadline { @@ -1004,7 +860,7 @@ impl PausedHandshake { (session.clone(), (*version).into()) } Self::IetfModern(paused) => (paused.session.clone(), paused.version.into()), - Self::Legacy(paused) => (paused.session.clone(), paused.version), + Self::Negotiated(paused) => (paused.session.clone(), paused.version.into()), } } } @@ -1338,7 +1194,6 @@ mod tests { ( FakeSession::new(ALPN_14, []) .with_bi(legacy_setup(ietf::Version::Draft14, ietf::Parameters::default())), - ietf::Version::Draft14, ), ( FakeSession::new(ALPN_18, [ietf_setup(ietf::Version::Draft18, Some("room/alice"))]), diff --git a/rs/moq-net/src/session.rs b/rs/moq-net/src/session.rs index 4a0bafec220..a222467415b 100644 --- a/rs/moq-net/src/session.rs +++ b/rs/moq-net/src/session.rs @@ -876,9 +876,8 @@ impl Drop for Withdrawing { /// Bounds on what one peer can make a session hold, where its transport does not already. /// -/// Each moq-lite request, and each moq-transport request from draft 17 on, holds a stream -/// of its own, so the transport's stream credit bounds those. A peer that announces past -/// `announces`, or overruns the drafts 14 to 16 request window, loses the session, closed with +/// Each request holds a stream of its own, so the transport's stream credit bounds those. +/// A peer that announces past `announces` loses the session, closed with /// `TOO_MANY_REQUESTS`. The stats sessions rows report announcement and subscription peaks. /// /// ``` @@ -891,32 +890,12 @@ impl Drop for Withdrawing { pub struct Limits { /// Broadcasts (moq-lite) or namespaces (moq-transport) the peer may have announced to us. pub announces: usize, - /// Other moq-transport requests the peer may hold at once, such as SUBSCRIBE and FETCH. - /// - /// On drafts 14 to 16 this and `announces` size the request window, which every request - /// counts against. Later drafts still refuse a reused request ID, so a peer may leave at - /// most twice the sum of both runs of skipped IDs; one more closes the session with - /// `INTERNAL_ERROR` rather than forgetting any. moq-lite ignores it. - pub requests: usize, } impl Default for Limits { /// Generous enough for a relay mesh carrying a large origin; lower them for untrusted peers. fn default() -> Self { - Self { - announces: 100_000, - requests: 20_000, - } - } -} - -impl Limits { - /// How many requests a moq-transport peer may hold open at once (drafts 14 to 16). - /// - /// Twice what the limits admit, so a peer within them is never blocked by request IDs - /// still waiting to be granted back. - pub(crate) fn window(&self) -> u64 { - (self.announces.saturating_add(self.requests) as u64).saturating_mul(2) + Self { announces: 100_000 } } } diff --git a/rs/moq-net/src/setup.rs b/rs/moq-net/src/setup.rs index c6358a4ff66..bbc37ad9c2c 100644 --- a/rs/moq-net/src/setup.rs +++ b/rs/moq-net/src/setup.rs @@ -8,8 +8,7 @@ use bytes::Bytes; use crate::{ Version, - coding::{self, Decode, DecodeError, Decoder, Encode, EncodeError, Encoder}, - ietf, lite, + coding::{self, Decode, DecodeError, Decoder, Encode, EncodeError, Encoder}, lite, }; /// The session direction a client advertises in its SETUP (moq-lite-05+). @@ -21,7 +20,7 @@ pub(crate) const MAX_SETUP_SIZE: usize = u16::MAX as usize; const CLIENT_SETUP: u8 = 0x20; const SERVER_SETUP: u8 = 0x21; -/// Draft-17 unified SETUP message type (varint 0x2F00) +/// The unified SETUP message type (varint 0x2F00). pub(crate) const SETUP_V17: u64 = 0x2F00; /// Decode a SETUP Implementation value, refusing one that is not UTF-8. @@ -121,26 +120,18 @@ impl Token { pub const CAT: u64 = 0x1; } -/// Draft-17+ unified SETUP message, with the same encoding for both client and server. +/// The unified SETUP message, with the same encoding for both client and server. #[derive(Debug, Clone)] pub(crate) struct Setup { pub parameters: Bytes, } -impl Setup { - fn check_version(v: Version) { - match v { - Version::Ietf(ietf::Version::Draft14 | ietf::Version::Draft15 | ietf::Version::Draft16) - | Version::Lite(_) => unreachable!("Setup is draft-17+ only"), - _ => {} - } - } -} - impl Encode for Setup { fn encode(&self, w: &mut Encoder<'_>, v: Version) -> Result<(), EncodeError> { w.control = Some(crate::stats::Control::Session); - Self::check_version(v); + if !v.is_ietf() { + return Err(EncodeError::Version); + } w.varint(SETUP_V17)?; let prefix = w.prefix_u16(); w.slice(&self.parameters); @@ -151,7 +142,9 @@ impl Encode for Setup { impl Decode for Setup { fn decode(r: &mut Decoder<'_>, v: Version) -> Result { r.control = Some(crate::stats::Control::Session); - Self::check_version(v); + if !v.is_ietf() { + return Err(DecodeError::Version); + } let kind = r.varint()?; if kind != SETUP_V17 { return Err(DecodeError::InvalidValue); @@ -162,78 +155,38 @@ impl Decode for Setup { } } -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -enum SetupVersion { - Draft14, - Draft15Plus, - /// Draft17+ uses ALPN-only negotiation with no legacy SETUP message. - Modern, - LiteLegacy, - Unsupported, +/// Whether `v` negotiates over the `moql` bidi SETUP exchange (moq-lite 01/02). +fn negotiated(v: Version) -> bool { + matches!(v, Version::Lite(lite::Version::Lite01 | lite::Version::Lite02)) } -impl SetupVersion { - fn from_version(v: Version) -> Self { - match v { - Version::Ietf(ietf::Version::Draft14) => Self::Draft14, - Version::Ietf(ietf::Version::Draft15) | Version::Ietf(ietf::Version::Draft16) => Self::Draft15Plus, - Version::Ietf(ietf::Version::Draft17) - | Version::Ietf(ietf::Version::Draft18) - | Version::Ietf(ietf::Version::Draft19) - | Version::Ietf(ietf::Version::Draft20) - | Version::Ietf(ietf::Version::Draft21) - | Version::Ietf(ietf::Version::Draft22) => Self::Modern, - Version::Lite(lite::Version::Lite01) | Version::Lite(lite::Version::Lite02) => Self::LiteLegacy, - Version::Lite(_) => Self::Unsupported, - } - } -} - -/// A version-agnostic setup message sent by the client. +/// The client half of the `moql` bidi SETUP exchange, offering moq-lite 01/02. +/// +/// The framing is moq-transport draft-14's CLIENT_SETUP, which moq-lite 01/02 borrowed: +/// a u16 size, the offered versions, then parameters. #[derive(Debug, Clone)] pub(crate) struct Client { /// The list of supported versions in preferred order. pub versions: coding::Versions, - /// Parameters, unparsed because the IETF draft changed the encoding. + /// Parameters, unparsed: moq-lite 01/02 define none, so neither side reads them. pub parameters: Bytes, } -impl Client { - fn encode_inner(&self, w: &mut Encoder<'_>, v: Version) -> Result<(), EncodeError> { - match SetupVersion::from_version(v) { - SetupVersion::Draft15Plus => { - // Draft15+: no versions list, parameters only. - } - SetupVersion::Draft14 | SetupVersion::LiteLegacy => self.versions.encode(w, v)?, - SetupVersion::Modern | SetupVersion::Unsupported => return Err(EncodeError::Version), - }; - w.slice(&self.parameters); - Ok(()) - } -} - impl Decode for Client { - /// Decode a client setup message (draft-14 through draft-16 only). fn decode(r: &mut Decoder<'_>, v: Version) -> Result { r.control = Some(crate::stats::Control::Session); + if !negotiated(v) { + return Err(DecodeError::Version); + } let kind = r.u8()?; if kind != CLIENT_SETUP { return Err(DecodeError::InvalidValue); } - let mut msg = decode_body(r, v)?; - - let versions = match SetupVersion::from_version(v) { - SetupVersion::Draft15Plus => { - // Draft15+: no versions list, parameters only. - coding::Versions::from([v.into()]) - } - SetupVersion::Draft14 | SetupVersion::LiteLegacy => { - coding::Versions::decode(&mut msg, v).map_err(DecodeError::complete)? - } - SetupVersion::Modern | SetupVersion::Unsupported => return Err(DecodeError::Version), - }; + let size = r.u16()? as usize; + let mut msg = r.sub(size)?; + let versions = coding::Versions::decode(&mut msg, v).map_err(DecodeError::complete)?; Ok(Self { versions, @@ -243,42 +196,20 @@ impl Decode for Client { } impl Encode for Client { - /// Encode a client setup message (draft-14 through draft-16 only). fn encode(&self, w: &mut Encoder<'_>, v: Version) -> Result<(), EncodeError> { w.control = Some(crate::stats::Control::Session); + if !negotiated(v) { + return Err(EncodeError::Version); + } w.u8(CLIENT_SETUP); - let prefix = prefix_body(w, v)?; - self.encode_inner(w, v)?; + let prefix = w.prefix_u16(); + self.versions.encode(w, v)?; + w.slice(&self.parameters); fill_body(w, prefix) } } -/// Read a pre-draft-17 SETUP body: its size, then that many bytes. -fn decode_body<'a>(r: &mut Decoder<'a>, v: Version) -> Result, DecodeError> { - let size = match SetupVersion::from_version(v) { - SetupVersion::Draft14 | SetupVersion::Draft15Plus => r.u16()? as usize, - SetupVersion::LiteLegacy => usize::try_from(r.varint()?).map_err(|_| DecodeError::BoundsExceeded)?, - SetupVersion::Modern | SetupVersion::Unsupported => return Err(DecodeError::Version), - }; - if size > MAX_SETUP_SIZE { - return Err(DecodeError::MessageTooLarge { - size, - max: MAX_SETUP_SIZE, - }); - } - r.sub(size) -} - -/// Reserve the size prefix of a pre-draft-17 SETUP body. -fn prefix_body(w: &mut Encoder<'_>, v: Version) -> Result { - match SetupVersion::from_version(v) { - SetupVersion::Draft14 | SetupVersion::Draft15Plus => Ok(w.prefix_u16()), - SetupVersion::LiteLegacy => Ok(w.prefix_varint()), - SetupVersion::Modern | SetupVersion::Unsupported => Err(EncodeError::Version), - } -} - -/// Size a pre-draft-17 SETUP body, refusing one our own receiver would refuse. +/// Size a SETUP body, refusing one our own receiver would refuse. fn fill_body(w: &mut Encoder<'_>, prefix: coding::Prefix) -> Result<(), EncodeError> { if w.since(&prefix) > MAX_SETUP_SIZE { w.discard(prefix); @@ -287,58 +218,47 @@ fn fill_body(w: &mut Encoder<'_>, prefix: coding::Prefix) -> Result<(), EncodeEr w.fill(prefix) } -/// Sent by the server in response to a client setup. +/// The server half of the `moql` bidi SETUP exchange, selecting moq-lite 01 or 02. +/// +/// The framing is moq-transport draft-14's SERVER_SETUP: a u16 size, the selected version, +/// then parameters. #[derive(Debug, Clone)] pub(crate) struct Server { - /// The list of supported versions in preferred order. + /// The selected version. pub version: coding::Version, - /// Supported extensions. + /// Parameters, unparsed: moq-lite 01/02 define none, so neither side reads them. pub parameters: Bytes, } -impl Server { - fn encode_inner(&self, w: &mut Encoder<'_>, v: Version) -> Result<(), EncodeError> { - match SetupVersion::from_version(v) { - SetupVersion::Draft15Plus => { - // Draft15+: No version field, parameters only. - } - SetupVersion::Draft14 | SetupVersion::LiteLegacy => self.version.encode(w, v)?, - SetupVersion::Modern | SetupVersion::Unsupported => return Err(EncodeError::Version), - }; - w.slice(&self.parameters); - Ok(()) - } -} - impl Encode for Server { - /// Encode a server setup message (draft-14 through draft-16 only). fn encode(&self, w: &mut Encoder<'_>, v: Version) -> Result<(), EncodeError> { w.control = Some(crate::stats::Control::Session); + if !negotiated(v) { + return Err(EncodeError::Version); + } w.u8(SERVER_SETUP); - let prefix = prefix_body(w, v)?; - self.encode_inner(w, v)?; + let prefix = w.prefix_u16(); + self.version.encode(w, v)?; + w.slice(&self.parameters); fill_body(w, prefix) } } impl Decode for Server { - /// Decode a server setup message (draft-14 through draft-16 only). fn decode(r: &mut Decoder<'_>, v: Version) -> Result { r.control = Some(crate::stats::Control::Session); + if !negotiated(v) { + return Err(DecodeError::Version); + } let kind = r.u8()?; if kind != SERVER_SETUP { return Err(DecodeError::InvalidValue); } - let mut msg = decode_body(r, v)?; - let version = match SetupVersion::from_version(v) { - SetupVersion::Draft15Plus => v.into(), - SetupVersion::Draft14 | SetupVersion::LiteLegacy => { - coding::Version::decode(&mut msg, v).map_err(DecodeError::complete)? - } - SetupVersion::Modern | SetupVersion::Unsupported => return Err(DecodeError::Version), - }; + let size = r.u16()? as usize; + let mut msg = r.sub(size)?; + let version = coding::Version::decode(&mut msg, v).map_err(DecodeError::complete)?; Ok(Self { version, diff --git a/rs/moq-net/src/test_interop.rs b/rs/moq-net/src/test_interop.rs index f99c3404ed1..4e746e4823d 100644 --- a/rs/moq-net/src/test_interop.rs +++ b/rs/moq-net/src/test_interop.rs @@ -253,10 +253,6 @@ fn ietf_datagram_interop() { use crate::{Timescale, Timestamp}; let all = [ - ietf::Version::Draft14, - ietf::Version::Draft15, - ietf::Version::Draft16, - ietf::Version::Draft17, ietf::Version::Draft18, ietf::Version::Draft19, ietf::Version::Draft20, @@ -264,13 +260,10 @@ fn ietf_datagram_interop() { ietf::Version::Draft22, ]; for (draft, version) in (14..).zip(all) { - let legacy = matches!( - version, - ietf::Version::Draft14 | ietf::Version::Draft15 | ietf::Version::Draft16 - ); + let legacy = false; let mut properties = Vec::new(); let mut w = Encoder::new(&mut properties, version.into()); - ietf::encode_object_time(&mut w, Timestamp::from_millis(1234).unwrap(), Timescale::MILLI, version).unwrap(); + ietf::encode_object_time(&mut w, Timestamp::from_millis(1234).unwrap(), Timescale::MILLI).unwrap(); // What a publisher sends: Object 0, explicit priority, ending its group, stamped. let mut datagrams = vec![ietf::ObjectDatagram { @@ -291,17 +284,15 @@ fn ietf_datagram_interop() { properties: None, body: ietf::DatagramBody::Status(0), }); - if version != ietf::Version::Draft14 { - datagrams.push(ietf::ObjectDatagram { - track_alias: (1 << 40) + 1, - group_id: (1 << 50) + 1, - object_id: Some(1 << 20), - publisher_priority: None, - end_of_group: true, - properties: None, - body: ietf::DatagramBody::Payload(bytes::Bytes::new()), - }); - } + datagrams.push(ietf::ObjectDatagram { + track_alias: (1 << 40) + 1, + group_id: (1 << 50) + 1, + object_id: Some(1 << 20), + publisher_priority: None, + end_of_group: true, + properties: None, + body: ietf::DatagramBody::Payload(bytes::Bytes::new()), + }); if legacy { datagrams.push(ietf::ObjectDatagram { track_alias: 1, @@ -445,10 +436,6 @@ fn ietf_track_status_interop() { use crate::ietf::error::request; let all = [ - ietf::Version::Draft14, - ietf::Version::Draft15, - ietf::Version::Draft16, - ietf::Version::Draft17, ietf::Version::Draft18, ietf::Version::Draft19, ietf::Version::Draft20, @@ -456,10 +443,7 @@ fn ietf_track_status_interop() { ietf::Version::Draft22, ]; for (draft, version) in (14..).zip(all) { - let legacy = matches!( - version, - ietf::Version::Draft14 | ietf::Version::Draft15 | ietf::Version::Draft16 - ); + let legacy = false; let request = |id: u64, namespace: &str, wanted: bool| { let mut buf = Vec::new(); let mut w = Encoder::new(&mut buf, version.into()); @@ -485,17 +469,12 @@ fn ietf_track_status_interop() { for (index, wanted) in [true, false].into_iter().enumerate() { let mut r = Decoder::new(&responses[index], version.into()); - assert_eq!(r.varint().unwrap(), ietf::TrackStatusOk::id(version), "{version}"); + assert_eq!(r.varint().unwrap(), ietf::TrackStatusOk::ID, "{version}"); let ok = ietf::TrackStatusOk::decode(&mut r, version).unwrap(); assert!(r.is_empty(), "{version}: trailing bytes"); let expected = match version { // GROUP_ORDER is a field on draft-14 and a parameter on draft-15. - ietf::Version::Draft14 | ietf::Version::Draft15 => ietf::Properties { - group_order: Some(ietf::GroupOrder::Descending), - ..Default::default() - }, - ietf::Version::Draft16 | ietf::Version::Draft17 => ietf::Properties::default(), // Only draft-20 can carry the opt-out. _ if !wanted && ietf::Filter::is_draft20(version) => ietf::Properties::default(), _ => ietf::Properties { @@ -522,10 +501,7 @@ fn ietf_track_status_interop() { let mut r = Decoder::new(&responses[2], version.into()); let code = match r.varint().unwrap() { - ietf::TRACK_STATUS_ERROR_14 if version == ietf::Version::Draft14 => { - ietf::SubscribeError::decode(&mut r, version).unwrap().error_code - } - id if id == ::ID && version != ietf::Version::Draft14 => { + id if id == ::ID => { ietf::RequestError::decode(&mut r, version).unwrap().error_code } id => panic!("{version}: unexpected refusal type {id}"), diff --git a/rs/moq-net/src/transport/boxed.rs b/rs/moq-net/src/transport/boxed.rs index ee4111bc8e5..a043f5e51f0 100644 --- a/rs/moq-net/src/transport/boxed.rs +++ b/rs/moq-net/src/transport/boxed.rs @@ -105,6 +105,7 @@ pub(crate) struct SendStream(Box); impl SendStream { /// Box a stream, keeping its own send-group type behind the boundary. + #[cfg(test)] pub(crate) fn new(stream: impl poll::SendStream + MaybeSend + MaybeSync) -> Self { Self(Box::new(stream)) } @@ -114,6 +115,7 @@ impl SendStream { pub(crate) struct RecvStream(Box); impl RecvStream { + #[cfg(test)] pub(crate) fn new(stream: impl poll::RecvStream + MaybeSend + MaybeSync) -> Self { Self(Box::new(stream)) } diff --git a/rs/moq-net/src/version.rs b/rs/moq-net/src/version.rs index c99754957fd..4d6f9e1267e 100644 --- a/rs/moq-net/src/version.rs +++ b/rs/moq-net/src/version.rs @@ -6,13 +6,11 @@ use crate::{coding, ietf, lite}; /// The versions of MoQ that are negotiated via SETUP. /// /// Ordered by preference, with the client's preference taking priority. -/// This intentionally includes only SETUP-negotiated versions (Lite02, Lite01, Draft14); -/// Lite03 and newer IETF drafts negotiate via dedicated ALPNs instead. +/// Only moq-lite 01/02 share an ALPN; every other version has its own. #[cfg_attr(not(feature = "async"), allow(dead_code, reason = "async-only"))] -pub(crate) const NEGOTIATED: [Version; 3] = [ +pub(crate) const NEGOTIATED: [Version; 2] = [ Version::Lite(lite::Version::Lite02), Version::Lite(lite::Version::Lite01), - Version::Ietf(ietf::Version::Draft14), ]; /// ALPN strings for supported versions, most-preferred first. `ALPNS[0]` is the @@ -32,10 +30,6 @@ pub const ALPNS: &[&str] = &[ ALPN_20, ALPN_19, ALPN_18, - ALPN_17, - ALPN_16, - ALPN_15, - ALPN_14, ]; // ALPN constants @@ -45,17 +39,13 @@ pub(crate) const ALPN_LITE_04: &str = "moq-lite-04"; pub(crate) const ALPN_LITE_05: &str = "moq-lite-05"; pub(crate) const ALPN_LITE_06: &str = "moq-lite-06"; pub(crate) const ALPN_LITE_07_WIP: &str = "moq-lite-07-wip"; -pub(crate) const ALPN_14: &str = "moq-00"; -pub(crate) const ALPN_15: &str = "moqt-15"; -pub(crate) const ALPN_16: &str = "moqt-16"; -pub(crate) const ALPN_17: &str = "moqt-17"; pub(crate) const ALPN_18: &str = "moqt-18"; pub(crate) const ALPN_19: &str = "moqt-19"; pub(crate) const ALPN_20: &str = "moqt-20"; pub(crate) const ALPN_21: &str = "moqt-21"; pub(crate) const ALPN_22: &str = "moqt-22"; -const ALL: [Version; 16] = [ +const ALL: [Version; 12] = [ Version::Lite(lite::Version::Lite07), Version::Lite(lite::Version::Lite06), Version::Lite(lite::Version::Lite05), @@ -68,10 +58,6 @@ const ALL: [Version; 16] = [ Version::Ietf(ietf::Version::Draft20), Version::Ietf(ietf::Version::Draft19), Version::Ietf(ietf::Version::Draft18), - Version::Ietf(ietf::Version::Draft17), - Version::Ietf(ietf::Version::Draft16), - Version::Ietf(ietf::Version::Draft15), - Version::Ietf(ietf::Version::Draft14), ]; /// A MoQ protocol version. @@ -108,10 +94,6 @@ impl Version { Self::Lite(lite::Version::Lite05) => "moq-lite-05", Self::Lite(lite::Version::Lite06) => "moq-lite-06", Self::Lite(lite::Version::Lite07) => "moq-lite-07-wip", - Self::Ietf(ietf::Version::Draft14) => "moq-transport-14", - Self::Ietf(ietf::Version::Draft15) => "moq-transport-15", - Self::Ietf(ietf::Version::Draft16) => "moq-transport-16", - Self::Ietf(ietf::Version::Draft17) => "moq-transport-17", Self::Ietf(ietf::Version::Draft18) => "moq-transport-18", Self::Ietf(ietf::Version::Draft19) => "moq-transport-19", Self::Ietf(ietf::Version::Draft20) => "moq-transport-20", @@ -130,10 +112,6 @@ impl Version { 0xff0dad05 => Some(Self::Lite(lite::Version::Lite05)), 0xff0dad06 => Some(Self::Lite(lite::Version::Lite06)), 0xff0dad07 => Some(Self::Lite(lite::Version::Lite07)), - 0xff00000e => Some(Self::Ietf(ietf::Version::Draft14)), - 0xff00000f => Some(Self::Ietf(ietf::Version::Draft15)), - 0xff000010 => Some(Self::Ietf(ietf::Version::Draft16)), - 0xff000011 => Some(Self::Ietf(ietf::Version::Draft17)), 0xff000012 => Some(Self::Ietf(ietf::Version::Draft18)), 0xff000013 => Some(Self::Ietf(ietf::Version::Draft19)), 0xff000014 => Some(Self::Ietf(ietf::Version::Draft20)), @@ -153,10 +131,6 @@ impl Version { Self::Lite(lite::Version::Lite05) => 0xff0dad05, Self::Lite(lite::Version::Lite06) => 0xff0dad06, Self::Lite(lite::Version::Lite07) => 0xff0dad07, - Self::Ietf(ietf::Version::Draft14) => 0xff00000e, - Self::Ietf(ietf::Version::Draft15) => 0xff00000f, - Self::Ietf(ietf::Version::Draft16) => 0xff000010, - Self::Ietf(ietf::Version::Draft17) => 0xff000011, Self::Ietf(ietf::Version::Draft18) => 0xff000012, Self::Ietf(ietf::Version::Draft19) => 0xff000013, Self::Ietf(ietf::Version::Draft20) => 0xff000014, @@ -177,10 +151,6 @@ impl Version { ALPN_LITE_05 => Some(Self::Lite(lite::Version::Lite05)), ALPN_LITE_06 => Some(Self::Lite(lite::Version::Lite06)), ALPN_LITE_07_WIP => Some(Self::Lite(lite::Version::Lite07)), - ALPN_14 => Some(Self::Ietf(ietf::Version::Draft14)), - ALPN_15 => Some(Self::Ietf(ietf::Version::Draft15)), - ALPN_16 => Some(Self::Ietf(ietf::Version::Draft16)), - ALPN_17 => Some(Self::Ietf(ietf::Version::Draft17)), ALPN_18 => Some(Self::Ietf(ietf::Version::Draft18)), ALPN_19 => Some(Self::Ietf(ietf::Version::Draft19)), ALPN_20 => Some(Self::Ietf(ietf::Version::Draft20)), @@ -199,10 +169,6 @@ impl Version { Self::Lite(lite::Version::Lite04) => ALPN_LITE_04, Self::Lite(lite::Version::Lite03) => ALPN_LITE_03, Self::Lite(lite::Version::Lite01 | lite::Version::Lite02) => ALPN_LITE, - Self::Ietf(ietf::Version::Draft14) => ALPN_14, - Self::Ietf(ietf::Version::Draft15) => ALPN_15, - Self::Ietf(ietf::Version::Draft16) => ALPN_16, - Self::Ietf(ietf::Version::Draft17) => ALPN_17, Self::Ietf(ietf::Version::Draft18) => ALPN_18, Self::Ietf(ietf::Version::Draft19) => ALPN_19, Self::Ietf(ietf::Version::Draft20) => ALPN_20, From 346955b71940a742525ba9ff7b06c5a96a092c9d Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sun, 25 Oct 2026 02:50:02 -0700 Subject: [PATCH 11/67] wip(net): compile moq-net tests without drafts 14-17 Co-Authored-By: Claude Opus 5.5 --- rs/moq-net/benches/session.rs | 7 +- .../ietf/draft18-goaway-request-id | Bin 7 -> 7 bytes .../ietf/draft18-invalid-group-order-0 | Bin 13 -> 13 bytes .../ietf/draft18-invalid-group-order-255 | Bin 13 -> 13 bytes .../ietf/draft18-invalid-group-order-3 | Bin 13 -> 13 bytes .../draft18-setup-envelope-truncated-unknown | Bin 12 -> 12 bytes .../ietf/draft18-setup-envelope-unknown-bytes | Bin 12 -> 12 bytes .../draft18-setup-envelope-unknown-varint | Bin 10 -> 10 bytes .../ietf/draft18-setup-truncated-unknown | Bin 8 -> 8 bytes .../ietf/draft18-setup-unknown-bytes | Bin 8 -> 8 bytes .../ietf/draft18-setup-unknown-varint | Bin 6 -> 6 bytes .../draft18-subscribe-empty-namespace-field | Bin 10 -> 10 bytes ...raft18-subscribe-oversized-full-track-name | Bin 4107 -> 4107 bytes .../draft18-subscribe-oversized-namespace | Bin 4108 -> 4108 bytes .../ietf/draft21-invalid-fill-group-order-0 | Bin 16 -> 16 bytes .../ietf/draft21-invalid-fill-group-order-255 | Bin 16 -> 16 bytes .../ietf/draft21-invalid-fill-group-order-3 | Bin 16 -> 16 bytes .../ietf/draft21-invalid-group-order-0 | Bin 13 -> 13 bytes .../ietf/draft21-invalid-group-order-255 | Bin 13 -> 13 bytes .../ietf/draft21-invalid-group-order-3 | Bin 13 -> 13 bytes .../draft21-setup-envelope-truncated-unknown | Bin 12 -> 12 bytes .../ietf/draft21-setup-envelope-unknown-bytes | Bin 12 -> 12 bytes .../draft21-setup-envelope-unknown-varint | Bin 10 -> 10 bytes .../ietf/draft21-setup-truncated-unknown | Bin 8 -> 8 bytes .../ietf/draft21-setup-unknown-bytes | Bin 8 -> 8 bytes .../ietf/draft21-setup-unknown-varint | Bin 6 -> 6 bytes .../draft21-subscribe-empty-namespace-field | Bin 10 -> 10 bytes ...raft21-subscribe-oversized-full-track-name | Bin 4107 -> 4107 bytes .../draft21-subscribe-oversized-namespace | Bin 4108 -> 4108 bytes .../ietf/draft22-invalid-fill-group-order-0 | Bin 16 -> 16 bytes .../ietf/draft22-invalid-fill-group-order-255 | Bin 16 -> 16 bytes .../ietf/draft22-invalid-fill-group-order-3 | Bin 16 -> 16 bytes .../ietf/draft22-invalid-group-order-0 | Bin 13 -> 13 bytes .../ietf/draft22-invalid-group-order-255 | Bin 13 -> 13 bytes .../ietf/draft22-invalid-group-order-3 | Bin 13 -> 13 bytes .../draft22-setup-envelope-truncated-unknown | Bin 12 -> 12 bytes .../ietf/draft22-setup-envelope-unknown-bytes | Bin 12 -> 12 bytes .../draft22-setup-envelope-unknown-varint | Bin 10 -> 10 bytes .../ietf/draft22-setup-truncated-unknown | Bin 8 -> 8 bytes .../ietf/draft22-setup-unknown-bytes | Bin 8 -> 8 bytes .../ietf/draft22-setup-unknown-varint | Bin 6 -> 6 bytes .../ietf/subscribe-absolute-filter | Bin 16 -> 0 bytes rs/moq-net/src/client.rs | 44 +- rs/moq-net/src/coding/writer.rs | 4 +- rs/moq-net/src/fuzz.rs | 91 +- rs/moq-net/src/ietf/auth.rs | 41 +- rs/moq-net/src/ietf/datagram.rs | 19 +- rs/moq-net/src/ietf/group.rs | 31 - rs/moq-net/src/ietf/object.rs | 43 +- rs/moq-net/src/ietf/properties.rs | 84 +- rs/moq-net/src/ietf/publish.rs | 229 +-- rs/moq-net/src/ietf/publish_namespace.rs | 172 +-- rs/moq-net/src/ietf/publisher.rs | 1253 +++------------- rs/moq-net/src/ietf/publisher/tracks.rs | 7 +- rs/moq-net/src/ietf/session.rs | 339 +---- rs/moq-net/src/ietf/subscribe.rs | 448 +----- rs/moq-net/src/ietf/subscribe_tracks.rs | 2 +- rs/moq-net/src/ietf/subscriber.rs | 1321 ++--------------- rs/moq-net/src/ietf/subscriber/tracks.rs | 2 +- rs/moq-net/src/ietf/token.rs | 5 +- rs/moq-net/src/ietf/track.rs | 126 +- rs/moq-net/src/ietf/version.rs | 2 - rs/moq-net/src/lite/compress.rs | 2 +- rs/moq-net/src/lite/ietf.rs | 56 +- rs/moq-net/src/lite/test_transport.rs | 8 - rs/moq-net/src/server.rs | 75 +- rs/moq-net/src/test_interop.rs | 11 +- .../integration/announce_covering_route.rs | 4 - .../tests/integration/announce_to_serve.rs | 4 - rs/moq-net/tests/integration/auth.rs | 52 +- .../tests/integration/broadcast_close.rs | 2 +- .../tests/integration/catalog_acquisition.rs | 2 +- rs/moq-net/tests/integration/compress.rs | 20 +- rs/moq-net/tests/integration/control_stats.rs | 5 +- rs/moq-net/tests/integration/datagram.rs | 11 +- .../tests/integration/dial_split_horizon.rs | 2 +- rs/moq-net/tests/integration/empty_group.rs | 4 +- rs/moq-net/tests/integration/extensions.rs | 13 +- rs/moq-net/tests/integration/fetch_only.rs | 3 - rs/moq-net/tests/integration/finite_relay.rs | 3 +- rs/moq-net/tests/integration/goaway.rs | 7 +- rs/moq-net/tests/integration/group_order.rs | 5 +- .../tests/integration/history_groups.rs | 3 +- rs/moq-net/tests/integration/idle_session.rs | 4 +- .../tests/integration/ietf_conformance.rs | 4 +- .../tests/integration/implementation.rs | 8 +- .../tests/integration/late_lower_group.rs | 2 +- .../tests/integration/lazy_discovery.rs | 4 - rs/moq-net/tests/integration/mesh_withdraw.rs | 2 - rs/moq-net/tests/integration/multi_cdn.rs | 55 +- rs/moq-net/tests/integration/partial_group.rs | 4 - rs/moq-net/tests/integration/quiet_catalog.rs | 2 +- rs/moq-net/tests/integration/range_anchors.rs | 6 +- .../tests/integration/relay_upstream_close.rs | 3 +- rs/moq-net/tests/integration/replacement.rs | 2 +- rs/moq-net/tests/integration/request_caps.rs | 38 +- rs/moq-net/tests/integration/restart.rs | 9 +- rs/moq-net/tests/integration/route_change.rs | 6 +- rs/moq-net/tests/integration/session_close.rs | 17 +- .../tests/integration/subscribe_priority.rs | 4 - .../tests/integration/subscribe_ranges.rs | 2 +- .../tests/integration/subscribe_tracks.rs | 2 +- .../integration/subscription_end_integrity.rs | 3 +- rs/moq-net/tests/integration/synced.rs | 4 +- rs/moq-net/tests/integration/track_tail.rs | 6 +- rs/moq-net/tests/integration/tracks_ietf.rs | 2 +- rs/moq-net/tests/integration/untimed.rs | 14 +- 107 files changed, 624 insertions(+), 4141 deletions(-) delete mode 100644 rs/moq-net/fuzz/regressions/ietf/subscribe-absolute-filter diff --git a/rs/moq-net/benches/session.rs b/rs/moq-net/benches/session.rs index 76f7ec95a94..70c734666c1 100644 --- a/rs/moq-net/benches/session.rs +++ b/rs/moq-net/benches/session.rs @@ -1000,9 +1000,8 @@ fn allocations() { } } -/// Versions for the churn sweep: the one draft with a MAX_REQUEST_ID window, the -/// newest draft without it, and lite. -const CHURN_VERSIONS: [&str; 3] = ["moq-transport-14", "moq-transport-22", "moq-lite-06"]; +/// Versions for the churn sweep: the newest moq-transport draft and lite. +const CHURN_VERSIONS: [&str; 2] = ["moq-transport-22", "moq-lite-06"]; /// Sessions on one relay, each holding `held` subscriptions open while it churns one more. #[derive(Clone, Copy)] @@ -1156,7 +1155,7 @@ impl IdleRoom { fn idle(c: &mut Criterion) { let mut group = c.benchmark_group("session_idle"); - for version in ["moq-lite-06", "moq-transport-16", "moq-transport-22"] { + for version in ["moq-lite-06", "moq-transport-22"] { for sessions in [1, 64, 1024] { for consumers in [0, 1, 8] { group.throughput(Throughput::Elements(sessions as u64)); diff --git a/rs/moq-net/fuzz/regressions/ietf/draft18-goaway-request-id b/rs/moq-net/fuzz/regressions/ietf/draft18-goaway-request-id index ca1272f1f39f7fd3aeece66d2ef1fed522127348..2abb874d90663394f44cd9b127bf7a4151e521a3 100644 GIT binary patch literal 7 OcmZQzU|?ooU<3dF6aWPP literal 7 OcmZQ!U|?ooU<3dFFaQYv diff --git a/rs/moq-net/fuzz/regressions/ietf/draft18-invalid-group-order-0 b/rs/moq-net/fuzz/regressions/ietf/draft18-invalid-group-order-0 index 59c326743c0815898a31079cd77f4e54a1e897cf..b87d0aa307b28bbdc0343bc248ebdbbc6173cf52 100644 GIT binary patch literal 13 UcmZSJX5eICWK3jCVpL)P00k5P{r~^~ literal 13 UcmZP(V&G(8WK3jCVpL)P00o=@2><{9 diff --git a/rs/moq-net/fuzz/regressions/ietf/draft18-invalid-group-order-255 b/rs/moq-net/fuzz/regressions/ietf/draft18-invalid-group-order-255 index ffe8e6b9d8169d2d13521e584865bb66eaa1f670..7e9a314a706e135ebd01d37e8fd0369c74e69558 100644 GIT binary patch literal 13 UcmZSJX5eICWK3jCVpRGM00t8Q{Qv*} literal 13 UcmZP(V&G(8WK3jCVpRGM00x@^2mk;8 diff --git a/rs/moq-net/fuzz/regressions/ietf/draft18-invalid-group-order-3 b/rs/moq-net/fuzz/regressions/ietf/draft18-invalid-group-order-3 index 12ed52ca6284a49a3e7bdf079c9f77f5f000c735..264b409f72123dfe84076a98810ea9fde82b7174 100644 GIT binary patch literal 13 UcmZSJX5eICWK3jCVpL)V00kET0RR91 literal 13 UcmZP(V&G(8WK3jCVpL)V00o}`3;+NC diff --git a/rs/moq-net/fuzz/regressions/ietf/draft18-setup-envelope-truncated-unknown b/rs/moq-net/fuzz/regressions/ietf/draft18-setup-envelope-truncated-unknown index 065e52340956a46f2bc8b2bd919b48f547d4785e..915c20d41c3fce6ea8075c269a54ceb63e3c24d8 100644 GIT binary patch literal 12 TcmZROTF=11rpTDcz?1|43f}>@ literal 12 TcmZS4T+hJ3rpTDcz?1|43$y{s diff --git a/rs/moq-net/fuzz/regressions/ietf/draft18-setup-envelope-unknown-bytes b/rs/moq-net/fuzz/regressions/ietf/draft18-setup-envelope-unknown-bytes index 7fc380d97df9890d0fb14ac373b27185190af08a..96f776f5eeeac506c78a7c6fe3fe20073f988a20 100644 GIT binary patch literal 12 TcmZROTF=11rpTDcz?cL83f%#= literal 12 TcmZS4T+hJ3rpTDcz?cL83$g*p diff --git a/rs/moq-net/fuzz/regressions/ietf/draft18-setup-envelope-unknown-varint b/rs/moq-net/fuzz/regressions/ietf/draft18-setup-envelope-unknown-varint index 9ff874dd9da88c88d71cd12ee5c0a668bc6b21dd..8e998087af50b9cac6ace45bf6af02bfea51622e 100644 GIT binary patch literal 10 RcmZROTF=11qQJ<&1ONvG0Pz3- literal 10 RcmZS4T+hJ3qQJ<&1ONxL0R#X5 diff --git a/rs/moq-net/fuzz/regressions/ietf/draft18-setup-truncated-unknown b/rs/moq-net/fuzz/regressions/ietf/draft18-setup-truncated-unknown index 489e5c30e6afe3924d67051538ee2d9d80c9170e..69f2fc116406a28ab695ef72f40d291fd2ac1bc1 100644 GIT binary patch literal 8 PcmZP&QDjVHU`hf214#h< literal 8 PcmZQkR%A?MU`hf21JVHx diff --git a/rs/moq-net/fuzz/regressions/ietf/draft18-setup-unknown-bytes b/rs/moq-net/fuzz/regressions/ietf/draft18-setup-unknown-bytes index d502a4b6bfee6201984212e672b15740a8eee1c2..faf6680ce75a5f899dfd5d6ba94a7a62447968c6 100644 GIT binary patch literal 8 PcmZP&QDjVHU`zr414jV+ literal 8 PcmZQkR%A?MU`zr41JD5u diff --git a/rs/moq-net/fuzz/regressions/ietf/draft18-setup-unknown-varint b/rs/moq-net/fuzz/regressions/ietf/draft18-setup-unknown-varint index 8fb114a73cc675a152cae71f4d0adbdd08b77169..8e228f345e273272097ab6860d00ec2ebfe4363e 100644 GIT binary patch literal 6 NcmZP&QD9_X0ssK-05|{u literal 6 NcmZQkR$ydc0ssM0080P> diff --git a/rs/moq-net/fuzz/regressions/ietf/draft18-subscribe-empty-namespace-field b/rs/moq-net/fuzz/regressions/ietf/draft18-subscribe-empty-namespace-field index 7f6cb67fee233ce0b72d68e62443a092b6272f83..639915ac8e4dbc41e5456eb8cfc3cdc56009a178 100644 GIT binary patch literal 10 RcmZSJW?*AvWMHgd0004%0F3|u literal 10 RcmZP(VqjxrWMHgd0005}0GI#( diff --git a/rs/moq-net/fuzz/regressions/ietf/draft18-subscribe-oversized-full-track-name b/rs/moq-net/fuzz/regressions/ietf/draft18-subscribe-oversized-full-track-name index 4eeee07dc8a6b5b22217b2ac917279b972876acc..85cc10f525ecc669943859fadf5d1fff82976308 100644 GIT binary patch delta 24 fcmeBH=vLrh;1*zKWSqdTQSdweLh_B diff --git a/rs/moq-net/fuzz/regressions/ietf/draft18-subscribe-oversized-namespace b/rs/moq-net/fuzz/regressions/ietf/draft18-subscribe-oversized-namespace index e3445ccec2438288a2f92d64aef0c81fc1aba9d2..d5e41124eaeacb63db4b1821054834943d538b4d 100644 GIT binary patch delta 24 fcmeBC=uzNc;1=LuWSqdbQSb-!WSqdbQSb- literal 10 Rcmd Option<(usize, u8, &[u8])> { @@ -161,7 +161,7 @@ fn datagram(data: &[u8], version: lite::Version) -> bool { let mut any = false; for &negotiated in negotiated { for timescale in [Some(crate::Timescale::MILLI), None] { - for ietf in [None, Some(ietf::Version::Draft14), Some(ietf::Version::Draft22)] { + for ietf in [None, Some(ietf::Version::Draft18), Some(ietf::Version::Draft22)] { for compressed in [false, true] { let framing = lite::Framing { timescale, @@ -223,6 +223,8 @@ pub fn lite_wire(data: &[u8]) -> bool { 19 => datagram(rest, version), 20 => roundtrip::(rest, version), 21 => roundtrip::(rest, version), + 22 => roundtrip::(rest, crate::Version::Lite(version)), + 23 => roundtrip::(rest, crate::Version::Lite(version)), _ => unreachable!("kind is taken modulo LITE_KINDS"), } } @@ -588,47 +590,30 @@ pub fn ietf_wire(data: &[u8]) -> bool { 0 => roundtrip::, _>(rest, version), 1 => roundtrip::, _>(rest, version), 2 => roundtrip::(rest, version), - 3 => roundtrip::, _>(rest, version), - 4 => roundtrip::(rest, version), - 5 => roundtrip::(rest, version), - 6 => roundtrip::, _>(rest, version), - 7 => roundtrip::, _>(rest, version), - 8 => roundtrip::(rest, version), - 9 => roundtrip::, _>(rest, version), - 10 => roundtrip::, _>(rest, version), - 11 => roundtrip::, _>(rest, version), - 12 => roundtrip::, _>(rest, version), - 13 => roundtrip::, _>(rest, version), - 14 => roundtrip::(rest, version), - 15 => roundtrip::, _>(rest, version), - 16 => roundtrip::, _>(rest, version), - 17 => roundtrip::, _>(rest, version), - 18 => roundtrip::, _>(rest, version), - 19 => roundtrip::(rest, version), - 20 => roundtrip::, _>(rest, version), - 21 => roundtrip::(rest, version), - 22 => roundtrip::(rest, version), - 23 => roundtrip::, _>(rest, version), - 24 => roundtrip::, _>(rest, version), - 25 => roundtrip::(rest, version), - 26 => roundtrip::, _>(rest, version), - 27 => roundtrip::, _>(rest, version), - 28 => roundtrip::, _>(rest, version), - 29 => roundtrip::, _>(rest, version), - 30 => roundtrip::(rest, version), - 31 => roundtrip::(rest, version), - 32 => roundtrip::(rest, version), - 33 => roundtrip::, _>(rest, version), - 34 => roundtrip::(rest, version), - 35 => roundtrip::(rest, version), - 36 => roundtrip::(rest, version), - 37 => roundtrip::(rest, version), - 38 => roundtrip::(rest, version), - 39 => roundtrip::(rest, version), - 40 => roundtrip::, _>(rest, version), - 41 => setup::(rest, version, |setup| &setup.parameters), - 42 => setup::(rest, version, |setup| &setup.parameters), - 43 => setup::(rest, version, |setup| &setup.parameters), + 3 => roundtrip::(rest, version), + 4 => roundtrip::, _>(rest, version), + 5 => roundtrip::, _>(rest, version), + 6 => roundtrip::, _>(rest, version), + 7 => roundtrip::, _>(rest, version), + 8 => roundtrip::(rest, version), + 9 => roundtrip::, _>(rest, version), + 10 => roundtrip::, _>(rest, version), + 11 => roundtrip::, _>(rest, version), + 12 => roundtrip::(rest, version), + 13 => roundtrip::(rest, version), + 14 => roundtrip::, _>(rest, version), + 15 => roundtrip::, _>(rest, version), + 16 => roundtrip::, _>(rest, version), + 17 => roundtrip::(rest, version), + 18 => roundtrip::, _>(rest, version), + 19 => roundtrip::(rest, version), + 20 => roundtrip::(rest, version), + 21 => roundtrip::(rest, version), + 22 => roundtrip::(rest, version), + 23 => roundtrip::(rest, version), + 24 => roundtrip::(rest, version), + 25 => roundtrip::, _>(rest, version), + 26 => setup::(rest, version, |setup| &setup.parameters), _ => unreachable!("kind is taken modulo IETF_KINDS"), } } @@ -657,9 +642,9 @@ where /// Decode a varint with whichever codec the selected version uses. /// -/// Byte 0 picks the version, which is the whole point: lite-01 to lite-06 and drafts -/// 14-16 use the QUIC two-bit length tag, while lite-07 and draft-17+ count leading -/// ones, and the two disagree about which byte sequences are even legal. +/// Byte 0 picks the version, which is the whole point: lite-01 to lite-06 use the QUIC +/// two-bit length tag, while lite-07 and the moq-transport drafts count leading ones, and +/// the two disagree about which byte sequences are even legal. /// /// The leading-ones form spans the full `u64`, while the QUIC form stops at /// [`crate::coding::varint::MAX_QUIC`]; a value always re-encodes in the form it was read in. @@ -1072,7 +1057,7 @@ pub fn seeds() -> Vec { for (index, version) in IETF_VERSIONS.iter().enumerate() { let outer = crate::Version::Ietf(*version); let parameters = ietf::Parameters::default().encode_bytes(*version).unwrap(); - let messages = vec![(41, crate::setup::Setup { parameters }.encode_bytes(outer).unwrap())]; + let messages = vec![(26, crate::setup::Setup { parameters }.encode_bytes(outer).unwrap())]; for (kind, message) in messages { let mut data = vec![index as u8, kind]; data.extend(message); @@ -1125,9 +1110,9 @@ pub fn seeds() -> Vec { }); } - // A SUBSCRIBE_OK carrying LARGEST_OBJECT, whose value encoding changed at draft-17 - // from a length-prefixed Location to two bare varints. A uniform fill never lands a - // valid parameter count followed by a Location, so build it from the encoder. + // A SUBSCRIBE_OK carrying LARGEST_OBJECT, whose value is two bare varints. A uniform + // fill never lands a valid parameter count followed by a Location, so build it from + // the encoder. for (index, version) in IETF_VERSIONS.iter().enumerate() { let subscribe_ok = ietf::SubscribeOk { track_alias: 0, @@ -1139,11 +1124,11 @@ pub fn seeds() -> Vec { continue; }; - let mut data = vec![index as u8, 19]; + let mut data = vec![index as u8, 12]; data.extend_from_slice(&encoded); seeds.push(Seed { target: "ietf", - kind: 19, + kind: 12, data, }); } diff --git a/rs/moq-net/src/ietf/auth.rs b/rs/moq-net/src/ietf/auth.rs index ac0090e1093..3f64e212904 100644 --- a/rs/moq-net/src/ietf/auth.rs +++ b/rs/moq-net/src/ietf/auth.rs @@ -565,7 +565,7 @@ mod tests { for version in [Version::Draft19] { for client in [false, true] { let first = if client { 0 } else { 1 }; - let control = Control::new(Some(RequestId(first + 1)), client); + let control = Control::new(client); let present = Present { runtime: crate::time::sim(), stats: Default::default(), @@ -578,15 +578,12 @@ mod tests { id: 0, }; assert!(matches!(present.run(Bytes::new()).await, Error::NoStreamCredit)); - assert_eq!( - control.poll_next_request_id(&kio::Waiter::noop()), - Poll::Ready(RequestId(first)) - ); + assert_eq!(control.next_request_id(), RequestId(first)); } } } - const VERSION: Version = Version::Draft17; + const VERSION: Version = Version::Draft18; fn patterns(texts: &[&str]) -> Patterns { texts.iter().map(|text| Pattern::try_from(*text).unwrap()).collect() @@ -606,8 +603,7 @@ mod tests { got } - /// Every draft that negotiates the extension round-trips the option; the drafts - /// before the unified SETUP carry none. + /// Every draft that negotiates the extension round-trips the option. #[test] fn setup_option_round_trips_on_supported_drafts() { for version in [ @@ -618,15 +614,9 @@ mod tests { Version::Draft22, ] { let mut params = super::super::Parameters::default(); - assert_eq!(from_setup(¶ms, version), None); - into_setup(&mut params, version); - assert_eq!(from_setup(¶ms, version), Some(true), "{version:?}"); - } - for version in [Version::Draft15] { - let mut params = super::super::Parameters::default(); - into_setup(&mut params, version); - assert_eq!(params.get_varint(super::super::ParameterVarInt::Auth), None); - assert_eq!(from_setup(¶ms, version), None, "{version:?}"); + assert_eq!(from_setup(¶ms), None); + into_setup(&mut params); + assert_eq!(from_setup(¶ms), Some(true), "{version:?}"); } } @@ -636,7 +626,7 @@ mod tests { fn only_one_negotiates() { let mut params = super::super::Parameters::default(); params.set_varint(super::super::ParameterVarInt::Auth, 0); - assert_eq!(from_setup(¶ms, VERSION), Some(false)); + assert_eq!(from_setup(¶ms), Some(false)); } #[test] @@ -705,21 +695,6 @@ mod tests { assert!(matches!(err, DecodeError::InvalidValue), "{err:?}"); } - #[test] - fn older_drafts_have_no_auth() { - for version in [Version::Draft15] { - let msg = Auth { - request_id: RequestId(0), - token: Bytes::new(), - }; - assert!(matches!(encode_msg(&msg, version), Err(EncodeError::Version))); - assert!(matches!( - Auth::decode_msg(&mut Decoder::new(&[0, 0], version.into()), version), - Err(DecodeError::Version) - )); - } - } - /// A reply with bytes past its message is refused, like any other framed message. #[test] fn replies_with_trailing_bytes_are_refused() { diff --git a/rs/moq-net/src/ietf/datagram.rs b/rs/moq-net/src/ietf/datagram.rs index 595322665dd..431ff8030ea 100644 --- a/rs/moq-net/src/ietf/datagram.rs +++ b/rs/moq-net/src/ietf/datagram.rs @@ -96,8 +96,6 @@ impl crate::model::datagram::Wire { } } - - impl Encode for ObjectDatagram { fn encode(&self, w: &mut Encoder<'_>, _: Version) -> Result<(), EncodeError> { let kind = self.kind(); @@ -203,7 +201,7 @@ mod tests { Ok(datagram) } - const ALL: [Version; 9] = [ + const ALL: [Version; 5] = [ Version::Draft18, Version::Draft19, Version::Draft20, @@ -233,19 +231,6 @@ mod tests { } } - #[test] - fn default_priority_needs_draft15() { - assert!(matches!( - single(None).encode_bytes(Version::Draft14), - Err(EncodeError::InvalidState) - )); - assert!(decode(&[0x0C, 0x01, 0x02], Version::Draft14).is_err()); - - let buf = single(None).encode_bytes(Version::Draft16).unwrap(); - assert_eq!(buf[0], 0x0F); - assert_eq!(decode(&buf, Version::Draft16).unwrap(), single(None)); - } - #[test] fn explicit_object_id_and_status() { let datagram = ObjectDatagram { @@ -312,7 +297,7 @@ mod tests { // PROPERTIES and ZERO_OBJECT_ID, alias 1, group 2, priority 0, empty block. let bytes = [0x05, 0x01, 0x02, 0x00, 0x00, b'x']; assert!(matches!( - ObjectDatagram::decode_slice(&bytes, Version::Draft16), + ObjectDatagram::decode_slice(&bytes, Version::Draft18), Err(DecodeError::InvalidValue) )); } diff --git a/rs/moq-net/src/ietf/group.rs b/rs/moq-net/src/ietf/group.rs index 14231136233..223c200c323 100644 --- a/rs/moq-net/src/ietf/group.rs +++ b/rs/moq-net/src/ietf/group.rs @@ -376,22 +376,6 @@ mod tests { assert_eq!(decoded.scale(), Timescale::MICRO); } - /// No Timescale rides along with the object; the track declared it once. - #[test] - fn test_object_time_omits_the_timescale() { - let ts = Timestamp::new(96_000, Timescale::MILLI).unwrap(); - let buf = encode_time(ts, Timescale::MILLI, Version::Draft16); - assert_eq!(varints(&buf, Version::Draft16), [PROP_TIMESTAMP, 96_000]); - } - - /// Draft-14/15 write absolute property types rather than deltas. - #[test] - fn test_object_time_legacy_uses_absolute_types() { - let ts = Timestamp::new(96_000, Timescale::MILLI).unwrap(); - let buf = encode_time(ts, Timescale::MILLI, Version::Draft15); - assert_eq!(varints(&buf, Version::Draft15), [PROP_TIMESTAMP, 96_000]); - } - /// An object-scope Timescale (which LOC permits) is ignored: the track's units apply. #[test] fn test_object_time_ignores_an_object_scope_timescale() { @@ -578,21 +562,6 @@ mod tests { } } - /// The bit arrived in draft-18. Earlier drafts carry no such signal, so a group there - /// is taken at its word rather than read as starting partway through. - #[test] - fn older_drafts_have_no_first_object_signal() { - for version in [Version::Draft15] { - let flags = GroupFlags { - first_object: false, - ..Default::default() - }; - let encoded = flags.encode().unwrap(); - assert_eq!(encoded & GroupFlags::FIRST_OBJECT_BIT, 0, "{version}"); - assert!(GroupFlags::decode(encoded).unwrap().first_object, "{version}"); - } - } - /// Draft-19 makes no changes to the subgroup header wire format, so the flags /// byte must be byte-identical to draft-18 on both encode and decode. #[test] diff --git a/rs/moq-net/src/ietf/object.rs b/rs/moq-net/src/ietf/object.rs index 78d23c5f063..1073d0430b3 100644 --- a/rs/moq-net/src/ietf/object.rs +++ b/rs/moq-net/src/ietf/object.rs @@ -510,15 +510,6 @@ mod tests { .unwrap(), bytes ); - assert!(matches!( - write( - &decoded.properties, - Some(Version::Draft22), - decoded.timestamp, - milli - ), - Err(Error::Unsupported) - )); // Its units cannot follow the egress's, or vanish with them, without rewriting the block. for timescale in [Some(Timescale::MICRO), None] { assert!(matches!( @@ -685,30 +676,18 @@ mod tests { fn a_status_object_keeps_its_timestamp() { let milli = Some(Timescale::MILLI); let list = Bytes::from_static(&[0x10, 7, 0x3e, 1]); - let framed = read(&list, milli).unwrap(); + let framed = read(&list, Version::Draft18, milli).unwrap(); assert_eq!(framed.timestamp, Some(Timestamp::new(7, Timescale::MILLI).unwrap())); - let status = unframed(&list, milli).unwrap(); + let status = unframed(&list, Version::Draft18, milli).unwrap(); assert_eq!( - write(&status, Some(Version::Draft14), None, None).unwrap(), + write(&status, Some(Version::Draft18), None, Version::Draft18, None).unwrap(), list.to_vec() ); // Over the lite hop, only a status block may hold it. let block = status.block.unwrap().bytes; - assert!(check(&block, milli, false).is_ok()); - assert!(check(&block, milli, true).is_err()); - } - - /// A draft-14 block crosses the lite hop in ascending order, as ingress sorts it, so - /// one whose absolute IDs descend is malformed. Its Immutable Properties may not ascend. - #[test] - fn a_draft14_block_ascends() { - let milli = Some(Timescale::MILLI); - assert!(check(&Bytes::from_static(&[0x02, 1, 0x20, 1]), milli, true).is_ok()); - assert!(check(&Bytes::from_static(&[0x02, 1, 0x02, 2]), milli, true).is_ok()); - assert!(check(&Bytes::from_static(&[0x20, 1, 0x02, 1]), milli, true).is_err()); - let sealed = Bytes::from_static(&[0x02, 1, 0x0b, 4, 0x20, 1, 0x02, 1]); - assert!(check(&sealed, milli, true).is_ok()); + assert!(check(&block, Version::Draft18, milli, false).is_ok()); + assert!(check(&block, Version::Draft18, milli, true).is_err()); } /// Draft-19 assigns 0x06 to SUBGROUP_DELIVERY_TIMEOUT, so it cannot cross that boundary. @@ -801,7 +780,7 @@ mod tests { for bytes in [&[0x0b, 2, 0x0b, 0][..], &[0x0b, 0, 0, 0][..], &[0x0b, 1, 2][..]] { assert!(read(&Bytes::copy_from_slice(bytes), Version::Draft22, None).is_err()); } - // Draft-18 permits this nonminimal seven-byte value; draft-17 cannot read it. + // Draft-18 permits this nonminimal seven-byte value. let bytes = Bytes::from_static(&[0x0b, 8, 2, 0xfc, 0, 0, 0, 0, 0, 1]); let decoded = read(&bytes, Version::Draft18, None).unwrap(); assert_eq!( @@ -815,16 +794,6 @@ mod tests { .unwrap(), bytes ); - assert!(read(&bytes, None).is_err()); - assert!(matches!( - write( - &decoded.properties, - Some(Version::Draft18), - decoded.timestamp, - None - ), - Err(Error::Unsupported) - )); } } diff --git a/rs/moq-net/src/ietf/properties.rs b/rs/moq-net/src/ietf/properties.rs index 1c9234a8337..a6880097180 100644 --- a/rs/moq-net/src/ietf/properties.rs +++ b/rs/moq-net/src/ietf/properties.rs @@ -428,7 +428,7 @@ mod tests { fn test_skip_empty_properties() { let mut buf = bytes::Bytes::new(); assert_eq!( - crate::coding::decode_buf(&mut buf, Properties::decode).unwrap(), + crate::coding::decode_buf(&mut buf, Version::Draft18, Properties::decode).unwrap(), Properties::default() ); } @@ -437,10 +437,10 @@ mod tests { fn test_skip_varint_property() { // Even type (0x02 = DELIVERY_TIMEOUT), varint value let mut buf = Vec::new(); - Encoder::new(&mut buf, Version::Draft17.into()).varint(0x02u64).unwrap(); // delta type - Encoder::new(&mut buf, Version::Draft17.into()).varint(5000u64).unwrap(); // value + Encoder::new(&mut buf, Version::Draft18.into()).varint(0x02u64).unwrap(); // delta type + Encoder::new(&mut buf, Version::Draft18.into()).varint(5000u64).unwrap(); // value let mut bytes = bytes::Bytes::from(buf); - crate::coding::decode_buf(&mut bytes, Properties::decode).unwrap(); + crate::coding::decode_buf(&mut bytes, Version::Draft18, Properties::decode).unwrap(); assert!(bytes.is_empty()); } @@ -448,11 +448,11 @@ mod tests { fn test_skip_bytes_property() { // Odd type (0x0B = IMMUTABLE_PROPERTIES), length-prefixed let mut buf = Vec::new(); - Encoder::new(&mut buf, Version::Draft17.into()).varint(0x0Bu64).unwrap(); // delta type - Encoder::new(&mut buf, Version::Draft17.into()).varint(3u64).unwrap(); // length + Encoder::new(&mut buf, Version::Draft18.into()).varint(0x0Bu64).unwrap(); // delta type + Encoder::new(&mut buf, Version::Draft18.into()).varint(3u64).unwrap(); // length buf.extend_from_slice(&[0x03, 0x01, 0x2A]); // sealed type 0x03, one byte let mut bytes = bytes::Bytes::from(buf); - crate::coding::decode_buf(&mut bytes, Properties::decode).unwrap(); + crate::coding::decode_buf(&mut bytes, Version::Draft18, Properties::decode).unwrap(); assert!(bytes.is_empty()); } @@ -460,18 +460,18 @@ mod tests { fn test_skip_multiple_properties() { let mut buf = Vec::new(); // First: type 0x02 (even), varint value - Encoder::new(&mut buf, Version::Draft17.into()).varint(0x02u64).unwrap(); - Encoder::new(&mut buf, Version::Draft17.into()).varint(1000u64).unwrap(); + Encoder::new(&mut buf, Version::Draft18.into()).varint(0x02u64).unwrap(); + Encoder::new(&mut buf, Version::Draft18.into()).varint(1000u64).unwrap(); // Second: delta = 0x02 → abs type 0x04 (even), varint value - Encoder::new(&mut buf, Version::Draft17.into()).varint(0x02u64).unwrap(); - Encoder::new(&mut buf, Version::Draft17.into()).varint(2000u64).unwrap(); + Encoder::new(&mut buf, Version::Draft18.into()).varint(0x02u64).unwrap(); + Encoder::new(&mut buf, Version::Draft18.into()).varint(2000u64).unwrap(); // Third: delta = 0x07 → abs type 0x0B (odd), length-prefixed - Encoder::new(&mut buf, Version::Draft17.into()).varint(0x07u64).unwrap(); - Encoder::new(&mut buf, Version::Draft17.into()).varint(2u64).unwrap(); + Encoder::new(&mut buf, Version::Draft18.into()).varint(0x07u64).unwrap(); + Encoder::new(&mut buf, Version::Draft18.into()).varint(2u64).unwrap(); buf.extend_from_slice(&[0x02, 0x2A]); // sealed type 0x02 = 42 let mut bytes = bytes::Bytes::from(buf); - crate::coding::decode_buf(&mut bytes, Properties::decode).unwrap(); + crate::coding::decode_buf(&mut bytes, Version::Draft18, Properties::decode).unwrap(); assert!(bytes.is_empty()); } @@ -531,43 +531,6 @@ mod tests { assert!(crate::coding::decode_buf(&mut bytes, Version::Draft18, Properties::decode).is_err()); } - /// Draft-16 carries the same block under the name Track Extensions. We don't write one - /// there, but a peer that does must be understood rather than faulted. - #[test] - fn test_decodes_draft16_track_extensions() { - let mut buf = Vec::new(); - Encoder::new(&mut buf, Version::Draft16.into()).varint(0x22u64).unwrap(); - Encoder::new(&mut buf, Version::Draft16.into()).varint(2u64).unwrap(); - - let mut bytes = bytes::Bytes::from(buf); - let properties = crate::coding::decode_buf(&mut bytes, Properties::decode).unwrap(); - assert_eq!(properties.group_order, Some(GroupOrder::Descending)); - assert!(bytes.is_empty()); - } - - /// Drafts 14-16 cannot carry TIMESCALE, so the block (and any Timestamp that would - /// depend on it) stays off the wire. Draft-17 is the first version that writes it. - #[test] - fn drafts_14_through_16_write_no_timescale() { - let properties = Properties { - unknown: Default::default(), - dynamic_groups: false, - compress: false, - max_cache_duration: None, - timescale: Some(Timescale::MILLI), - priority: None, - group_order: None, - }; - - for version in [Version::Draft15] { - let mut buf = Vec::new(); - properties - .encode(&mut Encoder::new(&mut buf, version.into()), version) - .unwrap(); - assert_eq!(!buf.is_empty(), Properties::sends_timescale(version), "{version}"); - } - } - /// The group order property is delta-encoded against the timescale that precedes it, /// so it has to survive the timescale being absent. #[test] @@ -640,25 +603,6 @@ mod tests { .unwrap(); assert_eq!(buf, [0x30, 0x01]); - // Draft 16 defines DYNAMIC_GROUPS but not TIMESCALE, and drafts 14 and 15 have no block - // (draft 15 carries DYNAMIC_GROUPS as a SUBSCRIBE_OK parameter instead). - let both = Properties { - dynamic_groups: true, - compress: false, - timescale: Some(Timescale::MILLI), - ..Default::default() - }; - for (version, expected) in [ - (Version::Draft14, &[][..]), - (Version::Draft15, &[][..]), - (Version::Draft16, &[0x30, 0x01][..]), - ] { - let mut buf = Vec::new(); - both.encode(&mut Encoder::new(&mut buf, version.into()), version) - .unwrap(); - assert_eq!(buf, expected, "{version}"); - } - let mut buf = Vec::new(); Properties::default() .encode(&mut Encoder::new(&mut buf, Version::Draft22.into()), Version::Draft22) diff --git a/rs/moq-net/src/ietf/publish.rs b/rs/moq-net/src/ietf/publish.rs index 1a604d1d8a5..c64a6fa60c3 100644 --- a/rs/moq-net/src/ietf/publish.rs +++ b/rs/moq-net/src/ietf/publish.rs @@ -101,7 +101,6 @@ The endpoint does not support the PUBLISH method. UNINTERESTED (0x4): The namespace or track is not of interest to the endpoint. - */ use std::borrow::Cow; @@ -420,147 +419,6 @@ mod tests { crate::coding::decode_buf(&mut buf, version, M::decode_msg) } - #[test] - fn test_publish_v14_round_trip() { - let msg = Publish { - request_id: RequestId(1), - track_namespace: Path::new("test/ns"), - track_name: "video".into(), - track_alias: 42, - largest_location: Some(Location { group: 10, object: 5 }), - forward: true, - properties: Properties { - group_order: Some(GroupOrder::Descending), - ..Default::default() - }, - subscriber_priority: None, - group_order: None, - filter: None, - }; - - let encoded = encode_message(&msg, Version::Draft14); - let decoded: Publish = decode_message(&encoded, Version::Draft14).unwrap(); - - assert_eq!(decoded.request_id, RequestId(1)); - assert_eq!(decoded.track_namespace.as_str(), "test/ns"); - assert_eq!(decoded.track_name, "video"); - assert_eq!(decoded.track_alias, 42); - assert_eq!(decoded.largest_location, Some(Location { group: 10, object: 5 })); - assert!(decoded.forward); - } - - #[test] - fn test_publish_v15_round_trip() { - let msg = Publish { - request_id: RequestId(1), - track_namespace: Path::new("test/ns"), - track_name: "video".into(), - track_alias: 42, - largest_location: Some(Location { group: 10, object: 5 }), - forward: true, - properties: Properties { - group_order: Some(GroupOrder::Descending), - ..Default::default() - }, - subscriber_priority: None, - group_order: None, - filter: None, - }; - - let encoded = encode_message(&msg, Version::Draft15); - let decoded: Publish = decode_message(&encoded, Version::Draft15).unwrap(); - - assert_eq!(decoded.request_id, RequestId(1)); - assert_eq!(decoded.track_namespace.as_str(), "test/ns"); - assert_eq!(decoded.track_name, "video"); - assert_eq!(decoded.track_alias, 42); - assert_eq!(decoded.largest_location, Some(Location { group: 10, object: 5 })); - assert!(decoded.forward); - } - - #[test] - fn test_publish_ok_v14_round_trip() { - let msg = PublishOk { - forward: true, - subscriber_priority: Some(128), - group_order: Some(GroupOrder::Descending), - filter: Some(Filter::NextObject), - new_group: None, - }; - - let encoded = encode_message(&msg, Version::Draft14); - let decoded: PublishOk = decode_message(&encoded, Version::Draft14).unwrap(); - - assert_eq!(decoded.request_id, Some(RequestId(7))); - assert!(decoded.forward); - assert_eq!(decoded.subscriber_priority, Some(128)); - } - - #[test] - fn test_publish_ok_v15_round_trip() { - let msg = PublishOk { - forward: true, - subscriber_priority: Some(128), - group_order: Some(GroupOrder::Descending), - filter: Some(Filter::NextObject), - new_group: None, - }; - - let encoded = encode_message(&msg, Version::Draft15); - let decoded: PublishOk = decode_message(&encoded, Version::Draft15).unwrap(); - - assert_eq!(decoded.request_id, Some(RequestId(7))); - assert!(decoded.forward); - assert_eq!(decoded.subscriber_priority, Some(128)); - } - - #[test] - fn test_publish_v17_round_trip() { - let msg = Publish { - request_id: RequestId(1), - track_namespace: Path::new("test/ns"), - track_name: "video".into(), - track_alias: 42, - largest_location: Some(Location { group: 10, object: 5 }), - forward: true, - properties: Properties { - group_order: Some(GroupOrder::Descending), - ..Default::default() - }, - subscriber_priority: None, - group_order: None, - filter: None, - }; - - let encoded = encode_message(&msg, Version::Draft17); - let decoded: Publish = decode_message(&encoded, Version::Draft17).unwrap(); - - assert_eq!(decoded.request_id, RequestId(1)); - assert_eq!(decoded.track_namespace.as_str(), "test/ns"); - assert_eq!(decoded.track_name, "video"); - assert_eq!(decoded.track_alias, 42); - assert_eq!(decoded.largest_location, Some(Location { group: 10, object: 5 })); - assert!(decoded.forward); - } - - #[test] - fn test_publish_ok_v17_round_trip() { - let msg = PublishOk { - forward: true, - subscriber_priority: Some(128), - group_order: Some(GroupOrder::Descending), - filter: Some(Filter::NextObject), - new_group: None, - }; - - let encoded = encode_message(&msg, Version::Draft17); - let decoded: PublishOk = decode_message(&encoded, Version::Draft17).unwrap(); - - assert_eq!(decoded.request_id, None); - assert!(decoded.forward); - assert_eq!(decoded.subscriber_priority, Some(128)); - } - fn publish_with_param(version: Version, key: u64, value: u64) -> Vec { let mut buf = Vec::new(); let w = &mut Encoder::new(&mut buf, version.into()); @@ -583,25 +441,23 @@ mod tests { buf } - /// SUBSCRIBER_PRIORITY is known in draft-16 but not defined for PUBLISH until draft-20. - /// OBJECT_DELIVERY_TIMEOUT is legal on PUBLISH again from draft-20. + /// SUBSCRIBER_PRIORITY is not defined for PUBLISH until draft-20. OBJECT_DELIVERY_TIMEOUT + /// is legal on PUBLISH again from draft-20. #[test] fn publish_parameters_follow_the_draft() { - decode_message::(&publish_with_param(Version::Draft16, 0x20, 1), Version::Draft16) - .expect("draft-16 ignores SUBSCRIBER_PRIORITY"); assert!(decode_message::(&publish_with_param(Version::Draft18, 0x20, 1), Version::Draft18).is_err()); decode_message::(&publish_with_param(Version::Draft20, 0x02, 1), Version::Draft20) .expect("draft-20 accepts OBJECT_DELIVERY_TIMEOUT"); } - /// PUBLISH_OK carries the delivery timeout through draft-19, and NEW_GROUP_REQUEST from - /// draft-16 through draft-19. Draft-20 no longer carries FORWARD. + /// PUBLISH_OK carries the delivery timeout and NEW_GROUP_REQUEST through draft-19. + /// Draft-20 no longer carries FORWARD. #[test] fn publish_ok_parameters_follow_the_draft() { decode_message::(&publish_ok_with_param(Version::Draft19, 0x02, 1), Version::Draft19) .expect("draft-19 accepts DELIVERY_TIMEOUT"); - decode_message::(&publish_ok_with_param(Version::Draft16, 0x32, 1), Version::Draft16) - .expect("draft-16 accepts NEW_GROUP_REQUEST"); + decode_message::(&publish_ok_with_param(Version::Draft19, 0x32, 1), Version::Draft19) + .expect("draft-19 accepts NEW_GROUP_REQUEST"); assert!( decode_message::(&publish_ok_with_param(Version::Draft20, 0x10, 0), Version::Draft20).is_err() ); @@ -772,73 +628,6 @@ mod tests { assert_eq!(decoded.properties.group_order, Some(GroupOrder::Descending)); } - /// Draft-15 is the last version that takes it as a message parameter, and has no track - /// properties to put it in. - #[test] - fn test_publish_v15_group_order_is_a_parameter() { - let msg = Publish { - request_id: RequestId(1), - track_namespace: Path::new("ns"), - track_name: "video".into(), - track_alias: 42, - largest_location: None, - forward: true, - properties: Properties { - unknown: Default::default(), - dynamic_groups: false, - compress: false, - max_cache_duration: None, - timescale: None, - priority: None, - group_order: Some(GroupOrder::Descending), - }, - subscriber_priority: None, - group_order: None, - filter: None, - }; - - #[rustfmt::skip] - let expected = vec![ - 1, // request id - 1, // namespace tuple count - 2, b'n', b's', // "ns" - 5, b'v', b'i', b'd', b'e', b'o', // "video" - 42, // track alias - 2, // two message parameters - 0x10, 0x01, // FORWARD = true - 0x22, 0x02, // GROUP_ORDER = descending - ]; - assert_eq!(encode_message(&msg, Version::Draft15), expected); - - let decoded: Publish = decode_message(&expected, Version::Draft15).unwrap(); - assert_eq!(decoded.properties.group_order, Some(GroupOrder::Descending)); - } - - /// Draft-18 drops the required_request_id_delta varint (#1615). - /// For Publish (#1D) the field is a single zero varint = 1 byte. - #[test] - fn test_publish_v18_is_one_byte_shorter_than_v17() { - let msg = Publish { - request_id: RequestId(1), - track_namespace: Path::new("test/ns"), - track_name: "video".into(), - track_alias: 42, - largest_location: None, - forward: true, - properties: Properties { - group_order: Some(GroupOrder::Descending), - ..Default::default() - }, - subscriber_priority: None, - group_order: None, - filter: None, - }; - - let v17 = encode_message(&msg, Version::Draft17); - let v18 = encode_message(&msg, Version::Draft18); - assert_eq!(v17.len(), v18.len() + 1); - } - #[test] fn test_publish_ok_v18_round_trip() { let msg = PublishOk { @@ -852,7 +641,6 @@ mod tests { let encoded = encode_message(&msg, Version::Draft18); let decoded: PublishOk = decode_message(&encoded, Version::Draft18).unwrap(); - assert_eq!(decoded.request_id, None); assert!(decoded.forward); assert_eq!(decoded.subscriber_priority, Some(128)); } @@ -860,10 +648,9 @@ mod tests { /// Draft-18 lets PUBLISH_OK carry EXPIRES; it is ignored rather than rejected. #[test] fn test_publish_ok_ignores_expires() { - let bytes = [0x04, 0x01, 0x08, 0x05]; + let bytes = [0x01, 0x08, 0x05]; - let decoded: PublishOk = decode_message(&bytes, Version::Draft16).unwrap(); - assert_eq!(decoded.request_id, Some(RequestId(4))); + let decoded: PublishOk = decode_message(&bytes, Version::Draft18).unwrap(); assert!(decoded.forward); } diff --git a/rs/moq-net/src/ietf/publish_namespace.rs b/rs/moq-net/src/ietf/publish_namespace.rs index 8e2a352c76f..ed6b60d0049 100644 --- a/rs/moq-net/src/ietf/publish_namespace.rs +++ b/rs/moq-net/src/ietf/publish_namespace.rs @@ -1,6 +1,5 @@ //! IETF moq-transport-14 publish namespace messages - use crate::{Epoch, Path, coding::*, ietf::RequestId}; use super::Message; @@ -267,103 +266,12 @@ mod tests { authorization_token: None, }; - let encoded = encode_message(&msg, Version::Draft14); - let decoded: PublishNamespace = decode_message(&encoded, Version::Draft14).unwrap(); + let encoded = encode_message(&msg, Version::Draft18); + let decoded: PublishNamespace = decode_message(&encoded, Version::Draft18).unwrap(); assert_eq!(decoded.track_namespace.as_str(), "test/broadcast"); } - #[test] - fn test_announce_error() { - let msg = PublishNamespaceError { - request_id: RequestId(1), - error_code: 404, - reason_phrase: "Unauthorized".into(), - }; - - let encoded = encode_message(&msg, Version::Draft14); - let decoded: PublishNamespaceError = decode_message(&encoded, Version::Draft14).unwrap(); - - assert_eq!(decoded.error_code, 404); - assert_eq!(decoded.reason_phrase, "Unauthorized"); - } - - #[test] - fn test_unannounce_v14() { - let msg = PublishNamespaceDone { - track_namespace: Path::new("old/stream"), - request_id: RequestId(0), - }; - - let encoded = encode_message(&msg, Version::Draft14); - let decoded: PublishNamespaceDone = decode_message(&encoded, Version::Draft14).unwrap(); - - assert_eq!(decoded.track_namespace.as_str(), "old/stream"); - } - - #[test] - fn test_unannounce_v16() { - let msg = PublishNamespaceDone { - track_namespace: Path::default(), - request_id: RequestId(42), - }; - - let encoded = encode_message(&msg, Version::Draft16); - let decoded: PublishNamespaceDone = decode_message(&encoded, Version::Draft16).unwrap(); - - assert_eq!(decoded.request_id, RequestId(42)); - } - - #[test] - fn test_announce_cancel_v14() { - let msg = PublishNamespaceCancel { - track_namespace: Path::new("canceled"), - request_id: RequestId(0), - error_code: 1, - reason_phrase: "Shutdown".into(), - }; - - let encoded = encode_message(&msg, Version::Draft14); - let decoded: PublishNamespaceCancel = decode_message(&encoded, Version::Draft14).unwrap(); - - assert_eq!(decoded.track_namespace.as_str(), "canceled"); - assert_eq!(decoded.error_code, 1); - assert_eq!(decoded.reason_phrase, "Shutdown"); - } - - #[test] - fn test_announce_cancel_v16() { - let msg = PublishNamespaceCancel { - track_namespace: Path::default(), - request_id: RequestId(7), - error_code: 1, - reason_phrase: "Shutdown".into(), - }; - - let encoded = encode_message(&msg, Version::Draft16); - let decoded: PublishNamespaceCancel = decode_message(&encoded, Version::Draft16).unwrap(); - - assert_eq!(decoded.request_id, RequestId(7)); - assert_eq!(decoded.error_code, 1); - assert_eq!(decoded.reason_phrase, "Shutdown"); - } - - #[test] - fn test_publish_namespace_v17_round_trip() { - let msg = PublishNamespace { - request_id: RequestId(5), - track_namespace: Path::new("v17/broadcast"), - params: Default::default(), - authorization_token: None, - }; - - let encoded = encode_message(&msg, Version::Draft17); - let decoded: PublishNamespace = decode_message(&encoded, Version::Draft17).unwrap(); - - assert_eq!(decoded.request_id, RequestId(5)); - assert_eq!(decoded.track_namespace.as_str(), "v17/broadcast"); - } - #[test] fn test_publish_namespace_v18_round_trip() { let msg = PublishNamespace { @@ -380,50 +288,6 @@ mod tests { assert_eq!(decoded.track_namespace.as_str(), "v18/broadcast"); } - #[test] - fn test_publish_namespace_done_v18_rejected() { - let msg = PublishNamespaceDone { - track_namespace: Path::default(), - request_id: RequestId(42), - }; - - let mut buf = Vec::new(); - assert!( - msg.encode_msg(&mut Encoder::new(&mut buf, Version::Draft18.into()), Version::Draft18) - .is_err() - ); - } - - #[test] - fn test_publish_namespace_done_v17_rejected() { - let msg = PublishNamespaceDone { - track_namespace: Path::default(), - request_id: RequestId(42), - }; - - let mut buf = Vec::new(); - assert!( - msg.encode_msg(&mut Encoder::new(&mut buf, Version::Draft17.into()), Version::Draft17) - .is_err() - ); - } - - #[test] - fn test_publish_namespace_cancel_v17_rejected() { - let msg = PublishNamespaceCancel { - track_namespace: Path::default(), - request_id: RequestId(7), - error_code: 1, - reason_phrase: "Shutdown".into(), - }; - - let mut buf = Vec::new(); - assert!( - msg.encode_msg(&mut Encoder::new(&mut buf, Version::Draft17.into()), Version::Draft17) - .is_err() - ); - } - fn hop_path(ids: &[u64]) -> cluster::HopPath { let hops: Vec = ids.iter().map(|&id| crate::Hop::new(id).unwrap()).collect(); cluster::HopPath::new(crate::Hops::try_from(hops).unwrap()) @@ -465,36 +329,6 @@ mod tests { assert_eq!(decoded.apply(&held), rerouted); } - /// Drafts 14-15 have no update for an advertisement, and draft-16's names the one it - /// updates. - #[test] - fn update_names_the_advertisement_on_draft_16() { - let mut msg = PublishNamespaceUpdate { - request_id: RequestId(2), - namespace_request_id: None, - hops: None, - cost: None, - authorization_token: Some(super::super::token::RequestToken(crate::setup::Token { - kind: 0, - value: b"jwt".to_vec(), - })), - }; - for version in [Version::Draft15] { - let mut buf = Vec::new(); - assert!( - msg.encode_msg(&mut Encoder::new(&mut buf, version.into()), version) - .is_err(), - "{version:?}" - ); - } - assert!(decode_message::(&[0x02, 0x00], Version::Draft15).is_err()); - - msg.namespace_request_id = Some(RequestId(1)); - let decoded: PublishNamespaceUpdate = - decode_message(&encode_message(&msg, Version::Draft16), Version::Draft16).unwrap(); - assert_eq!(decoded, msg); - } - #[test] fn test_announce_rejects_parameters() { #[rustfmt::skip] @@ -504,7 +338,7 @@ mod tests { 0x01, // INVALID: num_params = 1 ]; - let result: Result = decode_message(&invalid_bytes, Version::Draft14); + let result: Result = decode_message(&invalid_bytes, Version::Draft18); assert!(result.is_err()); } } diff --git a/rs/moq-net/src/ietf/publisher.rs b/rs/moq-net/src/ietf/publisher.rs index c20a1423022..f2742cafc25 100644 --- a/rs/moq-net/src/ietf/publisher.rs +++ b/rs/moq-net/src/ietf/publisher.rs @@ -4288,10 +4288,6 @@ impl TrackServe { let end = range.end.map_or(Bound::Unbounded, |end| Bound::Included(end.group)); let track = track.with_range((Bound::Included(floor), end)); let datagrams = session.max_datagram_size() > 0; - // A Timestamp whose units were not declared is worse than none. Drafts 14-16 - // never write TIMESCALE, whatever the caller passed in, so datagrams and group - // objects on those drafts go out unstamped. - let timescale = timescale; let dynamic = track.info().refresh.is_some(); let priority = kio::Producer::new(track.subscription().priority); let publisher = track.info().priority; @@ -5688,6 +5684,7 @@ mod group_priority_test { rank_in(&queue, priority, subscribe), group.consume(), Some(Timescale::MILLI), + Version::Draft18, GroupSlice::default(), ) }); @@ -5729,49 +5726,6 @@ mod group_priority_test { assert_eq!(header.publisher_priority, 127); } - /// Drafts 14-16 cannot send TIMESCALE, so a group served with a track timescale still - /// carries no Timestamp. Draft-17 declares the units and stamps the object. - #[moq_clock::test] - async fn drafts_14_through_16_send_no_timestamp_without_timescale() { - for version in [Version::Draft15] { - let stamped = ietf::Properties::sends_timescale(version); - let (header, mut buf) = serve_group(version, Some(Timescale::MILLI)).await; - assert_eq!(header.flags.has_extensions, stamped, "{version}"); - assert_eq!( - crate::coding::decode_varint(&mut buf, version).unwrap(), - 0, - "{version}: object id" - ); - if stamped { - let ext = crate::coding::decode_buf(&mut buf, version, |r, _| Ok(r.bytes()?.to_vec())).unwrap(); - let mut ext = bytes::Bytes::from(ext); - assert!( - crate::coding::decode_buf(&mut ext, version, |r, v| { - ietf::decode_object_time(r, Timescale::MILLI, v) - }) - .unwrap() - .is_some(), - "{version}: Timestamp missing" - ); - } - assert_eq!( - crate::coding::decode_varint(&mut buf, version).unwrap(), - b"hello".len() as u64, - "{version}" - ); - assert_eq!(&buf[..b"hello".len()], b"hello"); - } - - // Opting out of the timescale stays unstamped on a draft that could carry one. - let (header, mut buf) = serve_group(Version::Draft17, None).await; - assert!(!header.flags.has_extensions); - assert_eq!(crate::coding::decode_varint(&mut buf, Version::Draft17).unwrap(), 0); - assert_eq!( - crate::coding::decode_varint(&mut buf, Version::Draft17).unwrap(), - b"hello".len() as u64 - ); - } - /// Drive `serve` beside a sibling that only counts its turns, until `done`, checking every /// poll stays under `most` by `progress` and leaves the sibling its turn. /// Each task-set pass returns to the executor so its children's yields reach the task. @@ -5839,6 +5793,7 @@ mod group_priority_test { crate::driver::Transport::new(session.clone()), subscriber, RequestId(0), + Version::Draft18, ServeRange::default(), None, ); @@ -5888,6 +5843,7 @@ mod group_priority_test { crate::driver::Transport::new(session.clone()), subscriber, RequestId(0), + Version::Draft18, ServeRange::default(), None, ); @@ -5943,6 +5899,7 @@ mod group_priority_test { crate::driver::Transport::new(session.clone()), subscriber, RequestId(0), + Version::Draft18, ServeRange::default(), None, ); @@ -5990,6 +5947,7 @@ mod group_priority_test { crate::driver::Transport::new(session.clone()), subscriber, RequestId(0), + Version::Draft18, ServeRange::default(), None, ); @@ -6006,39 +5964,6 @@ mod group_priority_test { .await; } - /// Serve one group at `version` with `timescale` and return the header plus what follows it. - async fn serve_group(version: Version, timescale: Option) -> (ietf::GroupHeader, bytes::Bytes) { - let log = crate::lite::test_transport::Log::default(); - let session = SinkSession::new(log.clone()); - - let track = track::Producer::new( - std::sync::Arc::new(crate::broadcast::Info::default()), - "test", - crate::track::Info::timed(), - ); - let subscriber = track.subscribe(None); - - let mut group = track.append_group().unwrap(); - group.write_frame(crate::Timestamp::ZERO, b"hello".as_slice()).unwrap(); - group.finish().unwrap(); - track.finish().unwrap(); - - let mut serve = TrackServe::new( - crate::driver::Transport::new(session.clone()), - subscriber, - RequestId(0), - version, - ServeRange::default(), - timescale, - ); - kio::wait(|waiter| serve.poll(waiter)).await.unwrap(); - - let written = log.writes.lock().unwrap().clone(); - let mut buf = bytes::Bytes::from(written); - let header = crate::coding::decode_buf(&mut buf, version, ietf::GroupHeader::decode).expect("a group header"); - (header, buf) - } - /// Serve one group of a track with `info` and decode the subgroup header it opens with. async fn serve_group_header(info: track::Info) -> ietf::GroupHeader { let log = crate::lite::test_transport::Log::default(); @@ -6056,6 +5981,7 @@ mod group_priority_test { crate::driver::Transport::new(session.clone()), subscriber, RequestId(0), + Version::Draft18, ServeRange::default(), Some(Timescale::MILLI), ); @@ -6063,7 +5989,7 @@ mod group_priority_test { let written = log.writes.lock().unwrap().clone(); let mut buf = bytes::Bytes::from(written); - crate::coding::decode_buf(&mut buf, ietf::GroupHeader::decode).expect("a group header") + crate::coding::decode_buf(&mut buf, Version::Draft18, ietf::GroupHeader::decode).expect("a group header") } /// `hang::catalog::PRIORITY` isn't reachable from `moq-net` (hang depends on it, not the @@ -6483,6 +6409,7 @@ mod subscribe_cursor_test { crate::driver::Transport::new(session.clone()), subscriber, RequestId(1), + Version::Draft18, ServeRange::default(), Some(Timescale::MILLI), ); @@ -6685,7 +6612,7 @@ mod serve_tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.consume(), - Control::new(None, false), + Control::new(false), None, peer_setup, version, @@ -7262,18 +7189,13 @@ mod serve_tests { .expect("the track's error ends the subscription"); assert!(matches!(served, Served::Track(Err(Error::Unsupported))), "{served:?}"); assert_eq!( - served.status(Version::Draft16).0, + served.status().0, ietf::PublishDoneStatus::InternalError ); assert_eq!( - Served::UpdateFailed(Error::Unsupported).status(Version::Draft16).0, + Served::UpdateFailed(Error::Unsupported).status().0, ietf::PublishDoneStatus::UpdateFailed ); - // Draft 14 answers no update, so its PUBLISH_DONE carries the refusal itself. - assert_eq!( - Served::UpdateFailed(Error::Unauthorized).status(Version::Draft14).0, - ietf::PublishDoneStatus::Unauthorized - ); // A revocation bridged from upstream, however it was received, is still one. for err in [ Error::Unauthorized, @@ -7281,7 +7203,7 @@ mod serve_tests { Error::Stream(crate::StreamError::Unauthorized), ] { assert_eq!( - Served::Track(Err(err)).status(Version::Draft16).0, + Served::Track(Err(err)).status().0, ietf::PublishDoneStatus::Unauthorized ); } @@ -7361,110 +7283,6 @@ mod serve_tests { ); } - /// A draft 14-16 update framed as the adapter routes it onto its subscription. - /// - /// Drafts 15 and 16 carry only SUBSCRIBER_PRIORITY and FORWARD here, written by hand so - /// the bytes are pinned. - fn legacy_update(version: Version, priority: u8, forward: bool) -> Vec { - const UPDATE_ID: u8 = 10; - let body = match version { - // Draft 16 delta-encodes keys: SUBSCRIBER_PRIORITY (0x20) follows FORWARD (0x10). - _ => vec![UPDATE_ID, 0, 2, 0x10, forward as u8, 0x20, priority], - }; - let mut frame = vec![ietf::SubscribeUpdate::ID as u8, 0, body.len() as u8]; - frame.extend(body); - frame - } - - /// Drafts 14-16 deliver an update on the subscription's own virtual stream. It - /// reprices the subscription, which keeps serving and owes no PUBLISH_DONE, and only - /// UNSUBSCRIBE ends it. - #[moq_clock::test] - async fn legacy_subscription_update_keeps_the_subscription() { - for version in [Version::Draft15] { - let h = serve(version); - let session = ScriptedSession::new(legacy_update(version, 10, true)); - let mut stream = Stream::open(&mut crate::driver::Transport::new(session.clone()), version) - .await - .unwrap(); - let mut goaways = super::super::request_stream::Messages::new( - crate::driver::Transport::new(h.session.clone()), - h.publisher.control.client(), - ); - let mut serving = TrackServe::new( - crate::driver::Transport::new(h.session.clone()), - h.track.subscribe(None), - RequestId(0), - version, - ServeRange::default(), - None, - ); - let mut finished = false; - let mut run = std::pin::pin!(h.publisher.run_subscription( - &mut stream, - &mut serving, - &mut finished, - &mut goaways, - async {}, - None, - )); - assert!(futures::poll!(run.as_mut()).is_pending(), "{version}: update ended it"); - assert_eq!(h.track.subscription().unwrap().priority, 117, "{version}"); - - // Drafts 15 and 16 answer with REQUEST_OK naming the update; draft 14 answers nothing. - let answered = occurrences(&session.log, &[ietf::RequestOk::ID as u8, 0, 2, 10, 0]); - assert_eq!(answered, usize::from(true), "{version}"); - - let mut unsubscribe = vec![ietf::Unsubscribe::ID as u8]; - ietf::Unsubscribe { - request_id: RequestId(0), - } - .encode(&mut Encoder::new(&mut unsubscribe, version.into()), version) - .unwrap(); - session.push(&unsubscribe); - assert!( - matches!(futures::poll!(run.as_mut()), Poll::Ready(None)), - "{version}: UNSUBSCRIBE cancels" - ); - } - } - - /// A draft 14-16 FORWARD=0 update pauses the subscription, leaving the answer, which names - /// the update on drafts 15 and 16, to the caller once it stopped forwarding. - #[moq_clock::test] - async fn a_legacy_update_pauses_the_subscription() { - for version in [Version::Draft15] { - let h = serve(version); - let session = ScriptedSession::new(legacy_update(version, 10, false)); - let mut stream = Stream::open(&mut crate::driver::Transport::new(session.clone()), version) - .await - .unwrap(); - let mut goaways = super::super::request_stream::Messages::new( - crate::driver::Transport::new(h.session.clone()), - h.publisher.control.client(), - ); - let mut serving = TrackServe::new( - crate::driver::Transport::new(h.session.clone()), - h.track.subscribe(None), - RequestId(0), - version, - ServeRange::default(), - None, - ); - let mut finished = false; - let served = h - .publisher - .run_subscription(&mut stream, &mut serving, &mut finished, &mut goaways, async {}, None) - .await; - assert!( - matches!(served, Some(Served::Paused(true))), - "{version}: {served:?}" - ); - let written = session.log.writes.lock().unwrap().clone(); - assert!(written.is_empty(), "{version}: {written:?}"); - } - } - /// A REQUEST_UPDATE with Request ID `id` carrying only FORWARD, framed for the stream of /// the [`subscribe`] it updates. fn forward_update(version: Version, id: u64, forward: bool) -> Vec { @@ -7552,7 +7370,7 @@ mod serve_tests { /// the resume joined rather than refused as the pause left it. #[moq_clock::test] async fn a_joining_fetch_after_a_resume_is_served() { - let version = Version::Draft16; + let version = Version::Draft18; let h = serve(version); let mut group = h.track.create_group(group::Info { sequence: 0 }).unwrap(); group.write_frame(timestamp(), b"head".as_slice()).unwrap(); @@ -7828,7 +7646,7 @@ mod serve_tests { // left as it is. _ => vec![2], }; - body.extend(token_params(version, tokens)); + body.extend(token_params(tokens)); let mut frame = vec![ietf::SubscribeUpdate::ID as u8, 0, body.len() as u8]; frame.extend(body); frame @@ -7889,9 +7707,9 @@ mod serve_tests { } } - /// A parameter block of AUTHORIZATION TOKENs. Draft-16 on codes each key as a delta from - /// the one before, so a repeat is 0. - fn token_params(version: Version, tokens: &[&[u8]]) -> Vec { + /// A parameter block of AUTHORIZATION TOKENs. Each key is coded as a delta from the one + /// before, so a repeat is 0. + fn token_params(tokens: &[&[u8]]) -> Vec { let mut params = vec![tokens.len() as u8]; for (i, token) in tokens.iter().enumerate() { let delta = i > 0; @@ -7910,11 +7728,11 @@ mod serve_tests { /// a single token is answered as usual. #[moq_clock::test] async fn a_request_with_repeated_or_several_tokens_is_refused_alone() { - for (version, malformed) in [(Version::Draft14, 0x10), (Version::Draft22, 0x4)] { + for (version, malformed) in [ (Version::Draft22, 0x4)] { let request = |tokens: &[&[u8]]| { let mut body = track_status("room", true, version); assert_eq!(body.pop(), Some(0), "{version}"); - body.extend(token_params(version, tokens)); + body.extend(token_params(tokens)); body }; @@ -7959,9 +7777,7 @@ mod serve_tests { async fn a_repeated_or_several_update_tokens_are_refused() { let other: &[u8] = &[0x03, 0x00, 0xBB]; for (version, tokens, code) in [ - (Version::Draft16, [TOKEN, TOKEN], 0x4), (Version::Draft22, [TOKEN, TOKEN], 0x4), - (Version::Draft16, [TOKEN, other], 0x3), (Version::Draft22, [TOKEN, other], 0x3), ] { let h = serve(version); @@ -8531,7 +8347,7 @@ mod serve_tests { } } - const ALL_VERSIONS: [Version; 9] = [ + const ALL_VERSIONS: [Version; 5] = [ Version::Draft18, Version::Draft19, Version::Draft20, @@ -8725,7 +8541,7 @@ mod serve_tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.consume(), - Control::new(None, false), + Control::new(false), None, peer_setup, version, @@ -9047,119 +8863,58 @@ mod serve_tests { } } - /// A draft-16/17 SUBSCRIBE_NAMESPACE gets NAMESPACE whenever it asks for namespaces, - /// and one asking for PUBLISH alone is refused, since we never send PUBLISH. Draft-18 - /// has no Subscribe Options and always asks for namespaces. + /// A SUBSCRIBE_NAMESPACE always asks for namespaces, and gets NAMESPACE for each. #[moq_clock::test] - async fn subscribe_namespace_honors_subscribe_options() { - use ietf::SubscribeOptions::{Both, Namespace, Publish}; - - for (version, options, namespaces) in [ - (Version::Draft16, Some(Publish), false), - (Version::Draft16, Some(Namespace), true), - (Version::Draft16, Some(Both), true), - (Version::Draft17, Some(Publish), false), - (Version::Draft17, Some(Namespace), true), - (Version::Draft17, Some(Both), true), - (Version::Draft18, None, true), - ] { - let h = serve(version); - settle().await; - - let mut body = Vec::new(); - let mut w = Encoder::new(&mut body, version.into()); - let id = match options { - Some(subscribe_options) => { - ietf::SubscribeNamespaceLegacy { - request_id: RequestId(REQUEST_ID), - namespace: crate::Path::new(""), - subscribe_options, - hidden: false, - } - .encode_msg(&mut w, version) - .unwrap(); - ietf::SubscribeNamespaceLegacy::ID - } - None => { - ietf::SubscribeNamespace { - request_id: RequestId(REQUEST_ID), - namespace: crate::Path::new(""), - hidden: false, - } - .encode_msg(&mut w, version) - .unwrap(); - ietf::SubscribeNamespace::ID - } - }; + async fn subscribe_namespace_gets_namespaces() { + let version = Version::Draft18; + let h = serve(version); + settle().await; - let stream = Stream::open(&mut crate::driver::Transport::new(h.session.clone()), version) - .await - .unwrap(); - let mark = h.log.writes.lock().unwrap().len(); - let task = h - .publisher - .clone() - .handle_stream(id, ietf::Body(bytes::Bytes::from(body)), stream, false) - .unwrap_or_else(|e| panic!("{version}: the request closed the session: {e}")); - let mut task = std::pin::pin!(task); - let mut done = false; - for _ in 0..100 { - done = futures::poll!(task.as_mut()).is_ready(); - if done || occurrences(&h.log, b"room") > 0 { - break; - } - settle().await; - } + let mut body = Vec::new(); + let mut w = Encoder::new(&mut body, version.into()); + ietf::SubscribeNamespace { + request_id: RequestId(REQUEST_ID), + namespace: crate::Path::new(""), + hidden: false, + } + .encode_msg(&mut w, version) + .unwrap(); - let wire = h.log.writes.lock().unwrap()[mark..].to_vec(); - let mut buf = Decoder::new(&wire, version.into()); - let label = format!("{version} {options:?}"); - if namespaces { - assert!(!done, "{label}: the subscription ended"); - assert_eq!(buf.varint().unwrap(), ietf::RequestOk::ID, "{label}"); - ietf::RequestOk::decode(&mut buf, version).unwrap(); - assert_eq!(buf.varint().unwrap(), ietf::Namespace::ID, "{label}"); - assert_eq!( - ietf::Namespace::decode(&mut buf, version).unwrap().suffix.as_str(), - "room", - "{label}" - ); - } else { - assert!(done, "{label}: the refusal did not finish"); - assert_eq!(buf.varint().unwrap(), ietf::RequestError::ID, "{label}"); - let err = ietf::RequestError::decode(&mut buf, version).unwrap(); - assert_eq!(err.error_code, 0x3, "{label}: NOT_SUPPORTED"); - assert_eq!( - err.request_id, - (false).then_some(RequestId(REQUEST_ID)), - "{label}" - ); + let stream = Stream::open(&mut crate::driver::Transport::new(h.session.clone()), version) + .await + .unwrap(); + let mark = h.log.writes.lock().unwrap().len(); + let task = h + .publisher + .clone() + .handle_stream( + ietf::SubscribeNamespace::ID, + ietf::Body(bytes::Bytes::from(body)), + stream, + false, + ) + .unwrap_or_else(|e| panic!("{version}: the request closed the session: {e}")); + let mut task = std::pin::pin!(task); + let mut done = false; + for _ in 0..100 { + done = futures::poll!(task.as_mut()).is_ready(); + if done || occurrences(&h.log, b"room") > 0 { + break; } - assert!(buf.is_empty(), "{label}: trailing bytes"); + settle().await; } - // Undefined Subscribe Options close the session: dispatch returns an error. - #[rustfmt::skip] - let cases: [(Version, &[u8]); 2] = [ - // Request ID, empty namespace, Subscribe Options 0x03, no parameters. - (Version::Draft16, &[0x2B, 0x00, 0x03, 0x00]), - // Draft-17 adds the Required Request ID delta after the Request ID. - (Version::Draft17, &[0x2B, 0x00, 0x00, 0x03, 0x00]), - ]; - for (version, body) in cases { - let h = serve(version); - let stream = Stream::open(&mut crate::driver::Transport::new(h.session.clone()), version) - .await - .unwrap(); - let body = ietf::Body(bytes::Bytes::copy_from_slice(body)); - assert!( - h.publisher - .clone() - .handle_stream(ietf::SubscribeNamespaceLegacy::ID, body, stream, false) - .is_err(), - "{version}: Subscribe Options 0x03 kept the session open" - ); - } + let wire = h.log.writes.lock().unwrap()[mark..].to_vec(); + let mut buf = Decoder::new(&wire, version.into()); + assert!(!done, "the subscription ended"); + assert_eq!(buf.varint().unwrap(), ietf::RequestOk::ID); + ietf::RequestOk::decode(&mut buf, version).unwrap(); + assert_eq!(buf.varint().unwrap(), ietf::Namespace::ID); + assert_eq!( + ietf::Namespace::decode(&mut buf, version).unwrap().suffix.as_str(), + "room" + ); + assert!(buf.is_empty(), "trailing bytes"); } /// The draft's canonical current-group join: a Next Object subscription plus a @@ -9447,24 +9202,17 @@ mod serve_tests { const FETCH_ID: RequestId = RequestId(0x2C); /// Every draft that still carries a joining FETCH. - const JOINING_DRAFTS: [Version; 6] = [ + const JOINING_DRAFTS: [Version; 2] = [ Version::Draft18, Version::Draft19, ]; - fn invalid_joining_request_id(version: Version) -> u64 { - 0x32 - } + const INVALID_JOINING_REQUEST_ID: u64 = 0x32; - fn invalid_range(version: Version) -> u64 { - 0x11 - } + const INVALID_RANGE: u64 = 0x11; - /// The registry's "does not exist" value: draft-14 numbers it 0x4 on FETCH_ERROR and - /// draft-15 moved it to 0x10. - fn does_not_exist(version: Version) -> u64 { - 0x10 - } + /// The registry's "does not exist" value. + const DOES_NOT_EXIST: u64 = 0x10; /// Yield so the broadcast registered by `serve` is visible to the lookup. async fn settle() { @@ -9572,16 +9320,8 @@ mod serve_tests { assert_eq!(id, ietf::FetchOk::ID, "{version}: not a FETCH_OK"); let ok = crate::coding::decode_buf(&mut buf, version, ietf::FetchOk::decode).unwrap(); - assert_eq!( - ok.request_id, - None, - "{version}: wrong request id" - ); assert!(!ok.end_of_track, "{version}: the track has not ended"); - let properties = match ietf::Properties::sends_timescale(version) { - false => ietf::Properties::default(), - true => track_properties(&track::Info::timed(), true, version, true).unwrap(), - }; + let properties = track_properties(&track::Info::timed(), true, version, true).unwrap(); assert_eq!(ok.properties, properties, "{version}: wrong properties"); assert_eq!( ok.end_location, @@ -9602,15 +9342,8 @@ mod serve_tests { .request_id, FETCH_ID ); - // Drafts 14-16 never declared TIMESCALE, so the prefix must not carry a Timestamp. - let stamped = ietf::Properties::sends_timescale(version); for (index, payload) in payloads.iter().enumerate() { - let flags = match (index == 0, stamped) { - (true, true) => 0x3c, - (true, false) => 0x1c, - (false, true) => 0x20, - (false, false) => 0, - }; + let flags = if index == 0 { 0x3c } else { 0x20 }; assert_eq!( crate::coding::decode_varint(&mut buf, version).unwrap(), flags, @@ -9621,16 +9354,9 @@ mod serve_tests { assert_eq!(crate::coding::decode_varint(&mut buf, version).unwrap(), 0); assert_eq!(bytes::Buf::try_get_u8(&mut buf).unwrap(), 0); } - let properties = if stamped { - crate::coding::decode_buf(&mut buf, version, |r, _| Ok(r.bytes()?.to_vec())).unwrap() - } else { - Vec::new() - }; - if stamped { - assert!(!properties.is_empty(), "{version}: missing Timestamp"); - } else { - assert!(properties.is_empty(), "{version}: Timestamp without TIMESCALE"); - } + let properties = + crate::coding::decode_buf(&mut buf, version, |r, _| Ok(r.bytes()?.to_vec())).unwrap(); + assert!(!properties.is_empty(), "{version}: missing Timestamp"); let size = crate::coding::decode_varint(&mut buf, version).unwrap() as usize; assert_eq!(size, payload.len()); assert_eq!(buf.split_to(size).as_ref(), *payload); @@ -9651,7 +9377,7 @@ mod serve_tests { /// Dispatch order must not depend on which request task gets polled first. #[moq_clock::test] async fn a_joining_fetch_waits_for_its_dispatched_subscription() { - let version = Version::Draft17; + let version = Version::Draft18; let mut h = serve(version); publish_groups(&mut h, 5); settle().await; @@ -9738,7 +9464,7 @@ mod serve_tests { crate::coding::decode_buf(&mut response, version, ietf::RequestError::decode) .unwrap() .error_code, - invalid_joining_request_id(version) + INVALID_JOINING_REQUEST_ID ); assert!(response.is_empty()); assert!(h.publisher.joins.read().is_empty()); @@ -9747,7 +9473,7 @@ mod serve_tests { #[moq_clock::test] async fn a_joining_fetch_times_out_an_unresolved_subscription() { - let version = Version::Draft17; + let version = Version::Draft18; let h = serve(version); let stream = Stream::open(&mut crate::driver::Transport::new(h.session.clone()), version) .await @@ -9775,7 +9501,7 @@ mod serve_tests { /// refusal carries that error: refused before FETCH_OK, and never reset. #[moq_clock::test] async fn a_joining_fetch_refuses_a_missing_prefix_before_fetch_ok() { - let version = Version::Draft17; + let version = Version::Draft18; let h = serve(version); let mut group = h.track.create_group(group::Info { sequence: 5 }).unwrap(); group.start_at(1).unwrap(); @@ -9801,7 +9527,7 @@ mod serve_tests { crate::coding::decode_buf(&mut response, version, ietf::RequestError::decode) .unwrap() .error_code, - does_not_exist(version) + DOES_NOT_EXIST ); assert!(response.is_empty()); assert!(h.log.resets().is_empty()); @@ -9823,7 +9549,7 @@ mod serve_tests { crate::coding::decode_buf(&mut buf, version, ietf::RequestError::decode) .unwrap() .error_code, - invalid_joining_request_id(version) + INVALID_JOINING_REQUEST_ID ); assert!(buf.is_empty()); assert!(h.log.resets().is_empty()); @@ -9887,7 +9613,7 @@ mod serve_tests { crate::coding::decode_buf(&mut buf, version, ietf::RequestError::decode) .unwrap() .error_code, - invalid_range(version) + INVALID_RANGE ); assert!(buf.is_empty()); assert!(h.log.resets().is_empty()); @@ -9895,7 +9621,7 @@ mod serve_tests { } /// Every draft, each carrying a standalone FETCH or draft-20's filtered one. - const FETCH_DRAFTS: [Version; 9] = [ + const FETCH_DRAFTS: [Version; 5] = [ Version::Draft18, Version::Draft19, Version::Draft20, @@ -10139,27 +9865,21 @@ let ietf::FetchObject::Object { group, object, .. } = let (ok, objects) = fetch_answer(run_fetch(&h, range, GroupOrder::Ascending, wanted).await, version); assert_eq!(objects.len(), 1, "{version}"); - let expected = match ietf::Properties::sends_timescale(version) { - // Drafts 14-16 write no properties, as their SUBSCRIBE_OK does not. - false => ietf::Properties::default(), - true => track_properties(&info, wanted, version, true).unwrap(), - }; + let expected = track_properties(&info, wanted, version, true).unwrap(); assert_eq!(ok.properties, expected, "{version} wanted={wanted}"); - if ietf::Properties::sends_timescale(version) { - let mut properties = Vec::new(); - ietf::encode_object_time( - &mut Encoder::new(&mut properties, version.into()), - stamp, - info.timescale.expect("a timed track"), - ) - .unwrap(); - assert_eq!( - occurrences(&h.log, &properties), - 1, - "{version} wanted={wanted}: object unstamped" - ); - } + let mut properties = Vec::new(); + ietf::encode_object_time( + &mut Encoder::new(&mut properties, version.into()), + stamp, + info.timescale.expect("a timed track"), + ) + .unwrap(); + assert_eq!( + occurrences(&h.log, &properties), + 1, + "{version} wanted={wanted}: object unstamped" + ); } } } @@ -10273,7 +9993,7 @@ let ietf::FetchObject::Object { group, object, .. } = assert_eq!(occurrences(&h.log, &block[1..]), 1); // Draft 17 forbids the 7-byte varints draft 18 allows, and draft 16 has QUIC varints. - for version in [Version::Draft17] { + for version in [Version::Draft18] { let h = serve_track(version, info.clone()); let stream = Stream::open(&mut crate::driver::Transport::new(h.session.clone()), version) .await @@ -10513,7 +10233,7 @@ let ietf::FetchObject::Object { group, object, .. } = match largest { Largest::Finished | Largest::Live | Largest::IdleFinished => assert_eq!( fetch_refusal(buf, version), - invalid_range(version), + INVALID_RANGE, "{version} {largest:?} start={start}" ), _ => { @@ -10549,7 +10269,7 @@ let ietf::FetchObject::Object { group, object, .. } = GroupOrder::Ascending, ) .await; - assert_eq!(fetch_refusal(buf, version), invalid_range(version), "{version}"); + assert_eq!(fetch_refusal(buf, version), INVALID_RANGE, "{version}"); } } @@ -10739,7 +10459,7 @@ let ietf::FetchObject::Object { group, object, .. } = publish_pairs(&mut h, 1, None); h.track.finish().unwrap(); settle().await; - for (start, code) in [(0, 0x3), (maximum, does_not_exist(version))] { + for (start, code) in [(0, 0x3), (maximum, DOES_NOT_EXIST)] { let buf = standalone_fetch( &h, Location { @@ -10796,7 +10516,7 @@ let ietf::FetchObject::Object { group, object, .. } = .await; assert_eq!( fetch_refusal(buf, version), - does_not_exist(version), + DOES_NOT_EXIST, "{version}: group {missing}" ); } @@ -10892,7 +10612,7 @@ let ietf::FetchObject::Object { group, object, .. } = crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.consume(), - Control::new(None, false), + Control::new(false), None, peer_setup, version, @@ -10987,7 +10707,7 @@ let ietf::FetchObject::Object { group, object, .. } = crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.consume(), - Control::new(None, false), + Control::new(false), None, peer_setup, version, @@ -11101,7 +10821,7 @@ let ietf::FetchObject::Object { group, object, .. } = crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.consume(), - Control::new(None, false), + Control::new(false), None, peer_setup, version, @@ -11250,7 +10970,7 @@ let ietf::FetchObject::Object { group, object, .. } = crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.consume(), - Control::new(None, false), + Control::new(false), None, peer_setup, version, @@ -11327,7 +11047,6 @@ let ietf::FetchObject::Object { group, object, .. } = let wire = Wire::read(&session.log, version); let sent: Vec = wire.messages.iter().map(|(id, _)| *id).collect(); let expected = match (parked, version) { - (Parked::Resolving, Version::Draft14) => vec![ietf::SubscribeError::ID], (Parked::Resolving, _) => vec![ietf::RequestError::ID], _ => vec![ietf::SubscribeOk::ID, ietf::PublishDone::ID], }; @@ -11346,8 +11065,8 @@ let ietf::FetchObject::Object { group, object, .. } = Live, } - /// Withdraw the SUBSCRIBE on `request` as `version` cancels one: UNSUBSCRIBE through - /// draft 16, a FIN on drafts 17 and 18, a reset after. + /// Withdraw the SUBSCRIBE on `request` as `version` cancels one: a FIN on draft 18, a + /// reset after. fn withdraw(request: &ScriptedSession, version: Version) { use crate::lite::test_transport::Close; match version { @@ -11376,7 +11095,7 @@ let ietf::FetchObject::Object { group, object, .. } = crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.consume(), - Control::new(None, false), + Control::new(false), None, peer_setup, version, @@ -11526,7 +11245,7 @@ let ietf::FetchObject::Object { group, object, .. } = let buf = standalone_fetch(&h, location, location, GroupOrder::Ascending).await; assert_eq!( fetch_refusal(buf, version), - does_not_exist(version), + DOES_NOT_EXIST, "{version}: newest={newest}" ); } @@ -11595,7 +11314,7 @@ let ietf::FetchObject::Object { group, object, .. } = /// An absolute joining FETCH starting past the subscription's group names an empty range. #[moq_clock::test] async fn an_absolute_joining_fetch_past_the_subscription_is_refused() { - let version = Version::Draft16; + let version = Version::Draft18; let mut h = serve(version); publish_pairs(&mut h, 3, None); settle().await; @@ -11635,7 +11354,7 @@ let ietf::FetchObject::Object { group, object, .. } = .await .unwrap(); let buf = bytes::Bytes::from(h.log.writes.lock().unwrap()[mark..].to_vec()); - assert_eq!(fetch_refusal(buf, version), invalid_range(version)); + assert_eq!(fetch_refusal(buf, version), INVALID_RANGE); } /// A fill against an empty track has an empty range: no fetch stream is owed. @@ -11684,18 +11403,12 @@ let ietf::FetchObject::Object { group, object, .. } = .largest } - /// Through draft-15 SUBSCRIBE_OK restates the order the subscription is served in; later - /// drafts announce the publisher's default, newest first. + /// SUBSCRIBE_OK announces the publisher's default order, newest first, whatever the + /// subscription asked for. #[moq_clock::test] - async fn subscribe_ok_announces_the_served_order() { - for version in [ - Version::Draft20, - ] { - for (requested, announced) in [ - (GroupOrder::Ascending, GroupOrder::Ascending), - (GroupOrder::Descending, GroupOrder::Descending), - (GroupOrder::Any, GroupOrder::Descending), - ] { + async fn subscribe_ok_announces_the_default_order() { + for version in [Version::Draft18, Version::Draft20] { + for requested in [GroupOrder::Ascending, GroupOrder::Descending, GroupOrder::Any] { let mut h = serve(version); let mut msg = subscribe(Filter::NextObject, None); msg.group_order = requested; @@ -11708,11 +11421,11 @@ let ietf::FetchObject::Object { group, object, .. } = ietf::SubscribeOk::ID ); let ok = crate::coding::decode_buf(&mut buf, version, ietf::SubscribeOk::decode).unwrap(); - let expected = match version { - // Draft-16 has no room for it. - _ => Some(GroupOrder::Descending), - }; - assert_eq!(ok.properties.group_order, expected, "{version:?} {requested:?}"); + assert_eq!( + ok.properties.group_order, + Some(GroupOrder::Descending), + "{version:?} {requested:?}" + ); } } } @@ -11880,7 +11593,7 @@ let ietf::FetchObject::Object { group, object, .. } = crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.consume(), - Control::new(None, false), + Control::new(false), None, peer_setup, version, @@ -11957,9 +11670,8 @@ let ietf::FetchObject::Object { group, object, .. } = log.writes.lock().unwrap().clone() } - /// The wire bytes of one REQUEST_OK answering `request_id`: keyed to it on draft-15/16, - /// unkeyed on draft-17+. - async fn request_ok_bytes(version: Version, request_id: RequestId) -> Vec { + /// The wire bytes of one REQUEST_OK. + async fn request_ok_bytes(version: Version) -> Vec { let log = crate::lite::test_transport::Log::default(); let mut writer = crate::coding::Writer::new( crate::transport::boxed::SendStream::new(crate::lite::test_transport::SinkSend::new(log.clone())), @@ -11979,17 +11691,15 @@ let ietf::FetchObject::Object { group, object, .. } = /// The REQUEST_ERROR a refused renewal writes before the subscription ends: keyed to the /// update's Request ID on draft-15/16, unkeyed on draft-17+, matching /// `write_subscribe_error(.., &Error::Unauthorized, reason)`. - async fn request_error_bytes(version: Version, request_id: RequestId, reason: &str) -> Vec { + async fn request_error_bytes(version: Version, reason: &str) -> Vec { let log = crate::lite::test_transport::Log::default(); let mut writer = crate::coding::Writer::new( crate::transport::boxed::SendStream::new(crate::lite::test_transport::SinkSend::new(log.clone())), version, ); - let request_id = false.then_some(request_id); writer.varint(ietf::RequestError::ID).await.unwrap(); writer .encode(&ietf::RequestError { - request_id, error_code: request::to_code(&Error::Unauthorized, request::Kind::Subscribe, version), reason_phrase: reason.into(), retry_interval: 0, @@ -12085,36 +11795,11 @@ let ietf::FetchObject::Object { group, object, .. } = } } - /// The pre-draft-17 renewal: a SUBSCRIBE_UPDATE carrying a fresh token renews a - /// token-authorized subscription past the old grant's expiry at draft-14/15/16, where the - /// update rides the control-stream adapter. Draft-14 writes no answer (it defines none, and - /// its control stream would read a 0x05 as ending the subscription); draft-15 and draft-16 - /// (section 9.11) write exactly one REQUEST_OK, keyed to the update's own Request ID so the - /// peer matches it to the REQUEST_UPDATE it sent. The adapter's follow-up routing of the - /// update to the subscription's stream is proven by - /// `super::super::adapter::tests::test_classify_subscribe_update_followup`. - #[moq_clock::test] - async fn a_subscribe_update_renewal_is_answered_from_draft_15() { - for version in [Version::Draft15] { - renews(version, true).await; - } - } - - /// A refused renewal ends only its subscription at once (PUBLISH_DONE UPDATE_FAILED, or the - /// refusal itself on draft 14), never the session. The update is answered first: nothing on - /// draft-14, a keyed REQUEST_ERROR to the update's Request ID on draft-15/16. - #[moq_clock::test] - async fn a_refused_subscribe_update_renewal_ends_the_subscription_from_draft_14() { - for version in [Version::Draft15] { - renews(version, false).await; - } - } - /// A pause is answered before a renewal riding it could be verified, so an update carrying /// both fails instead of acknowledging a token nobody checked. #[moq_clock::test] async fn a_pause_carrying_a_token_fails_the_update() { - for version in [Version::Draft16] { + for version in [Version::Draft18] { let (auth, mut requests, _cred) = auth_covering_other(); let h = serve_with_auth(version, auth, subscribe_update_with_token(version, false).await); let rt = h.publisher.runtime.clone(); @@ -12156,145 +11841,6 @@ let ietf::FetchObject::Object { group, object, .. } = } } - async fn renews(version: Version, accept: bool) { - let (auth, mut requests, _cred) = auth_covering_other(); - let h = serve_with_auth(version, auth, subscribe_update_with_token(version, true).await); - let rt = h.publisher.runtime.clone(); - - let mut group = h.track.create_group(group::Info { sequence: 0 }).unwrap(); - group.write_frame(timestamp(), b"frame".as_slice()).unwrap(); - group.finish().unwrap(); - settle().await; - - let stream = Stream::open(&mut crate::driver::Transport::new(h.session.clone()), version) - .await - .unwrap(); - - // The renewal is held until the setup writes have settled, so anything written after - // it is released is the renewal's answer. - let release = std::sync::Arc::new(Release::default()); - let answered = std::sync::Arc::new(AtomicU64::new(0)); - let acceptor = { - let answered = answered.clone(); - let release = release.clone(); - async move { - let mut held = Vec::new(); - let first = requests.next().await.unwrap(); - held.push(first.accept(grant_all_expiring(&rt, Some(60)))); - answered.fetch_add(1, Ordering::Relaxed); - let renewal = requests.next().await.unwrap(); - release.notified().await; - if accept { - held.push(renewal.accept(grant_all_expiring(&rt, None))); - } else { - renewal.reject(crate::SessionError::Unauthorized, "no"); - } - answered.fetch_add(1, Ordering::Relaxed); - std::future::pending::<()>().await - } - }; - let mut acceptor = std::pin::pin!(acceptor); - let mut serving = std::pin::pin!(h.publisher.clone().run_subscribe_stream(stream, token_subscribe())); - - for _ in 0..200 { - let _ = futures::poll!(acceptor.as_mut()); - assert!( - futures::poll!(serving.as_mut()).is_pending(), - "{version:?}: ended during setup" - ); - settle().await; - } - assert_eq!( - answered.load(Ordering::Relaxed), - 1, - "{version:?}: the first token was answered" - ); - let before = h.log.writes.lock().unwrap().len(); - - release.notify_one(); - - if accept { - for _ in 0..200 { - let _ = futures::poll!(acceptor.as_mut()); - assert!( - futures::poll!(serving.as_mut()).is_pending(), - "{version:?}: an accepted renewal keeps serving" - ); - settle().await; - } - assert_eq!( - answered.load(Ordering::Relaxed), - 2, - "{version:?}: the renewal was answered" - ); - // Draft-14 writes nothing; draft-15/16 write exactly one keyed REQUEST_OK to the - // update's own Request ID (0x40), the id the renewing peer waits on. - let written = h.log.writes.lock().unwrap()[before..].to_vec(); - match version { - _ => assert_eq!( - written, - request_ok_bytes(version, RequestId(0x40)).await, - "{version:?}: one keyed REQUEST_OK to the update's request id" - ), - } - // The re-armed deadline keeps the subscription past the old 60s expiry. - moq_clock::sim::advance(Duration::from_secs(120)).await; - let mut ended = false; - for _ in 0..50 { - let _ = futures::poll!(acceptor.as_mut()); - if futures::poll!(serving.as_mut()).is_ready() { - ended = true; - break; - } - settle().await; - } - assert!(!ended, "{version:?}: an accepted renewal keeps the subscription"); - } else { - // Per drafts 16 section 9.11.1 / 18 section 10.9.1, a refused renewal ends only - // this subscription, promptly and without the old 60s grant having to lapse, with - // PUBLISH_DONE UPDATE_FAILED. The update is answered first: nothing on draft-14, - // exactly one keyed REQUEST_ERROR to the update's Request ID (0x40) on draft-15/16. - // The session stays up. - let mut result = None; - for _ in 0..200 { - let _ = futures::poll!(acceptor.as_mut()); - if let Poll::Ready(res) = futures::poll!(serving.as_mut()) { - result = Some(res); - break; - } - settle().await; - } - assert_eq!( - answered.load(Ordering::Relaxed), - 2, - "{version:?}: the renewal was answered" - ); - assert!( - matches!(result, Some(Err(Error::Session(crate::SessionError::Unauthorized)))), - "{version:?}: a refused renewal ends the subscription at once, got {result:?}" - ); - // Draft 14 has no UPDATE_FAILED and answers no update, so its PUBLISH_DONE - // carries the refusal itself. - let (status, _) = Wire::read(&h.log, version).publish_done.expect("PUBLISH_DONE was sent"); - let expected = ietf::PublishDoneStatus::UpdateFailed; - assert_eq!(status, expected.code(version), "{version:?}"); - let written = h.log.writes.lock().unwrap()[before..].to_vec(); - match version { - // draft-14 has no renewal reply: the refusal is signalled only by the subscription - // ending (SUBSCRIBE_DONE UNAUTHORIZED, written by the caller), with no REQUEST_ERROR. - // draft-15/16 answer with one keyed REQUEST_ERROR before the subscription ends. - _ => { - let error = request_error_bytes(version, RequestId(0x40), "no").await; - assert!( - written.starts_with(&error), - "{version:?}: a keyed REQUEST_ERROR is written before the subscription ends" - ); - } - } - assert!(h.log.closes().is_empty(), "{version:?}: the session must stay up"); - } - } - /// One REQUEST_UPDATE carrying a fresh token, keyed to its own Request ID so several can be /// told apart on the wire. async fn subscribe_update_token_rid(version: Version, rid: u64) -> Vec { @@ -12681,7 +12227,7 @@ let ietf::FetchObject::Object { group, object, .. } = assert!(futures::poll!(serving.as_mut()).is_pending(), "{version}: ended early"); settle().await; } - let ok = request_ok_bytes(version, RequestId(0x42)).await; + let ok = request_ok_bytes(version).await; let held = h.log.writes.lock().unwrap().clone(); assert!( !held.windows(ok.len()).any(|window| window == ok.as_slice()), @@ -12698,7 +12244,7 @@ let ietf::FetchObject::Object { group, object, .. } = settle().await; } let written = h.log.writes.lock().unwrap()[before..].to_vec(); - let error = request_error_bytes(version, RequestId(0x40), "no").await; + let error = request_error_bytes(version, "no").await; assert!( written.starts_with(&error), "{version}: the renewal's REQUEST_ERROR is the first answer" @@ -12706,60 +12252,6 @@ let ietf::FetchObject::Object { group, object, .. } = } } - /// Before draft-17 a token-less REQUEST_UPDATE is answered keyed to its own request id - /// (draft-15/16), or not at all (draft-14, which defines no response). This pins the keyed and - /// silent branches of the acknowledgement so a wrong key cannot misroute the peer's answer. - #[moq_clock::test] - async fn token_less_updates_are_keyed_before_draft_17() { - for version in [Version::Draft15] { - let (auth, mut requests, _cred) = auth_covering_other(); - let rids = [0x42u64, 0x44, 0x46]; - let mut script = Vec::new(); - for rid in rids { - script.extend(subscribe_update_bare_rid(version, rid).await); - } - let h = serve_with_auth(version, auth, script); - let rt = h.publisher.runtime.clone(); - - let mut group = h.track.create_group(group::Info { sequence: 0 }).unwrap(); - group.write_frame(timestamp(), b"frame".as_slice()).unwrap(); - group.finish().unwrap(); - settle().await; - - let stream = Stream::open(&mut crate::driver::Transport::new(h.session.clone()), version) - .await - .unwrap(); - let acceptor = async move { - let first = requests.next().await.unwrap(); - let _held = first.accept(grant_all_expiring(&rt, None)); - std::future::pending::<()>().await - }; - let mut acceptor = std::pin::pin!(acceptor); - let mut serving = std::pin::pin!(h.publisher.clone().run_subscribe_stream(stream, token_subscribe())); - - for _ in 0..500 { - let _ = futures::poll!(acceptor.as_mut()); - assert!( - futures::poll!(serving.as_mut()).is_pending(), - "{version}: token-less updates must not end the request" - ); - settle().await; - } - - // Draft-14 answers nothing; draft-15/16 answer each update keyed to its own request id. - let written = h.log.writes.lock().unwrap().clone(); - for rid in rids { - let one = request_ok_bytes(version, RequestId(rid)).await; - let n = written.windows(one.len()).filter(|w| *w == one.as_slice()).count(); - assert_eq!(n, 1, "{version}: update {rid:#x} gets exactly one keyed REQUEST_OK"); - } - assert!( - h.log.closes().is_empty(), - "{version}: token-less updates must not close the session" - ); - } - } - /// On drafts without the option the guard is a memory backstop, not a protocol limit: a flood /// past it ends the one request through PUBLISH_DONE, never the session. #[moq_clock::test] @@ -12894,43 +12386,6 @@ let ietf::FetchObject::Object { group, object, .. } = assert!(ended, "{label}: dropping the renewal ends the request"); } - /// One UNSUBSCRIBE keyed to the subscription, the draft-14/15/16 cancellation message. - async fn unsubscribe_bytes(version: Version) -> Vec { - let log = crate::lite::test_transport::Log::default(); - let mut writer = crate::coding::Writer::new( - crate::transport::boxed::SendStream::new(crate::lite::test_transport::SinkSend::new(log.clone())), - version, - ); - writer.varint(ietf::Unsubscribe::ID).await.unwrap(); - writer - .encode(&ietf::Unsubscribe { - request_id: RequestId(REQUEST_ID), - }) - .await - .unwrap(); - log.writes.lock().unwrap().clone() - } - - /// Before draft-17 a cancellation is an UNSUBSCRIBE message, not a FIN. It must end the - /// subscription even while a renewal verdict is pending: with a non-expiring grant and an - /// acceptor sitting on the renewal, the UNSUBSCRIBE is the only thing that can. - #[moq_clock::test] - async fn a_pending_renewal_ends_on_an_unsubscribe_before_draft_17() { - for version in [Version::Draft15] { - let (auth, requests, _cred) = auth_covering_other(); - // The stream carries the renewal, then the UNSUBSCRIBE, and never FINs, so only the - // message can end the request. - let session = ScriptedSession::new(subscribe_update_with_token(version, true).await); - let h = serve_on(version, auth, session.clone()); - let stream = Stream::open(&mut crate::driver::Transport::new(h.session.clone()), version) - .await - .unwrap(); - let unsubscribe = unsubscribe_bytes(version).await; - let cancel = || session.push(&unsubscribe); - ends_while_a_renewal_is_pending(&h, requests, stream, cancel, &format!("{version:?}")).await; - } - } - /// A REQUEST_UPDATE the acceptor refuses ends only that subscription, at once, through the /// PUBLISH_DONE UPDATE_FAILED path (drafts 16 section 9.11.1 / 18 section 10.9.1). The old /// grant does not keep it alive to its 60s expiry, and the session stays up. @@ -12994,10 +12449,10 @@ let ietf::FetchObject::Object { group, object, .. } = ietf::PublishDoneStatus::UpdateFailed.code(), "UPDATE_FAILED" ); - // Draft-17+ answers the refused update with exactly one unkeyed REQUEST_ERROR before the - // subscription ends. + // The refused update is answered with exactly one REQUEST_ERROR before the subscription + // ends. let written = h.log.writes.lock().unwrap().clone(); - let error = request_error_bytes(VERSION, RequestId(0), "no").await; + let error = request_error_bytes(VERSION, "no").await; assert_eq!( written.windows(error.len()).filter(|w| *w == error.as_slice()).count(), 1, @@ -13722,9 +13177,10 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.consume(), - Control::new(None, false), + Control::new(false), Some(assigned), peer::PeerSetup::default(), + Version::Draft18, ); let mut echoed_hops = crate::Hops::new(); @@ -13779,7 +13235,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(crate::lite::test_transport::SinkSession::new(Default::default())), origin.consume(), - Control::new(None, false), + Control::new(false), Some(assigned), peer::PeerSetup::default(), Version::Draft19, @@ -13850,9 +13306,10 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(crate::lite::test_transport::SinkSession::new(Default::default())), origin.consume(), - Control::new(None, false), + Control::new(false), Some(assigned), peer::PeerSetup::default(), + Version::Draft18, ); // The chain as ingress stores it: the peer named itself 0, and `via` is the @@ -13897,9 +13354,10 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.consume(), - Control::new(None, false), + Control::new(false), None, setup, + Version::Draft18, ); let mut clean = crate::Hops::new(); @@ -13915,7 +13373,7 @@ mod tests { .unwrap(); settle().await; - let stream = Stream::open(&mut crate::driver::Transport::new(session.clone()), Version::Draft17) + let stream = Stream::open(&mut crate::driver::Transport::new(session.clone()), Version::Draft18) .await .unwrap(); let msg = ietf::SubscribeNamespace { @@ -13932,6 +13390,7 @@ mod tests { let expected = crate::lite::test_transport::Log::default(); let mut writer = crate::coding::Writer::new( crate::transport::boxed::SendStream::new(crate::lite::test_transport::SinkSend::new(expected.clone())), + Version::Draft18, ); writer.varint(ietf::RequestOk::ID).await.unwrap(); writer @@ -13965,9 +13424,10 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.consume(), - Control::new(None, false), + Control::new(false), Some(assigned), requires_solicitation(), + Version::Draft18, ); // The prefix starts with only a route from the assigned peer: hop 0 on the @@ -13984,7 +13444,7 @@ mod tests { .unwrap(); settle().await; - let stream = Stream::open(&mut crate::driver::Transport::new(session.clone()), Version::Draft16) + let stream = Stream::open(&mut crate::driver::Transport::new(session.clone()), Version::Draft18) .await .unwrap(); let msg = ietf::SubscribeNamespace { @@ -14056,7 +13516,7 @@ mod tests { /// uninterested) into a request every few seconds for the life of the session. #[moq_clock::test] async fn a_refusal_that_forbids_retrying_is_not_retried() { - const VERSION: Version = Version::Draft17; + const VERSION: Version = Version::Draft18; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let _cam = origin.announce("lonely-cam", crate::origin::Route::default()).unwrap(); @@ -14073,7 +13533,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.consume(), - Control::new(None, false), + Control::new(false), None, declared(Some(false)), VERSION, @@ -14109,7 +13569,7 @@ mod tests { #[moq_clock::test] async fn another_epoch_is_advertised_before_the_old_is_withdrawn() { use crate::lite::test_transport::Sent; - const VERSION: Version = Version::Draft17; + const VERSION: Version = Version::Draft18; for epochs in [true, false] { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); @@ -14131,7 +13591,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.consume(), - Control::new(None, false), + Control::new(false), None, declared, VERSION, @@ -14210,102 +13670,12 @@ mod tests { writes.clone() } - /// Draft-14/15 predate the NAMESPACE message, so a SUBSCRIBE_NAMESPACE is - /// answered with one PUBLISH_NAMESPACE request per matching namespace over the - /// control stream, and PUBLISH_NAMESPACE_DONE withdraws it. The state is local - /// to the subscription's task, mirroring lite's announce handling. - #[moq_clock::test] - async fn v14_subscribe_namespace_is_answered_with_publish_namespace() { - const VERSION: Version = Version::Draft14; - - let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let consumer = origin.consume(); - - // Announced before the peer subscribes: it must only hit the wire after. - let early = origin.announce("early-cam", crate::origin::Route::default()).unwrap(); - settle().await; - - // Stream 1 is the peer's SUBSCRIBE_NAMESPACE (the peer stays quiet after); - // streams 2 and 3 answer our two PUBLISH_NAMESPACE requests. - let ok = publish_namespace_ok(VERSION).await; - let session = crate::lite::test_transport::ScriptedSession::per_stream(vec![Vec::new(), ok.clone(), ok]); - let log = session.log.clone(); - - let publisher = Publisher::new( - crate::time::sim(), - crate::driver::Transport::new(session.clone()), - consumer, - Control::new(None, false), - None, - requires_solicitation(), - VERSION, - ); - - let stream = Stream::open(&mut crate::driver::Transport::new(session.clone()), VERSION) - .await - .unwrap(); - let msg = ietf::SubscribeNamespace { - request_id: RequestId(1), - namespace: crate::Path::new(""), - hidden: false, - }; - let mut run = std::pin::pin!(publisher.run_subscribe_namespace_stream(stream, msg)); - - // The subscription solicits the already-announced namespace. - for _ in 0..100 { - assert!(futures::poll!(run.as_mut()).is_pending()); - if occurrences(&log, b"early-cam") >= 1 { - break; - } - settle().await; - } - assert_eq!( - occurrences(&log, b"early-cam"), - 1, - "PUBLISH_NAMESPACE after subscribing" - ); - - // A later announce reaches the same subscription. - let _late = origin.announce("late-cam", crate::origin::Route::default()).unwrap(); - for _ in 0..100 { - assert!(futures::poll!(run.as_mut()).is_pending()); - if occurrences(&log, b"late-cam") >= 1 { - break; - } - settle().await; - } - assert_eq!( - occurrences(&log, b"late-cam"), - 1, - "PUBLISH_NAMESPACE for a live announce" - ); - - // An unannounce closes out its own request with PUBLISH_NAMESPACE_DONE. - drop(early); - for _ in 0..100 { - assert!(futures::poll!(run.as_mut()).is_pending()); - if occurrences(&log, b"early-cam") >= 2 { - break; - } - settle().await; - } - assert_eq!( - occurrences(&log, b"early-cam"), - 2, - "PUBLISH_NAMESPACE_DONE on unannounce" - ); - - // One stream for the subscription itself, one per PUBLISH_NAMESPACE: the - // withdrawal rode the announce's own request, not a new stream. - assert_eq!(log.bi_opens(), 3, "no extra stream for the withdrawal"); - } - /// A peer that declared nothing is told without being asked. Relays that never send /// SUBSCRIBE_NAMESPACE hear nothing otherwise, and every third-party one behaves /// that way: a publisher is expected to announce itself. #[moq_clock::test] async fn a_peer_that_declared_nothing_is_told_unsolicited() { - const VERSION: Version = Version::Draft17; + const VERSION: Version = Version::Draft18; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let _local = origin.announce("local-cam", crate::origin::Route::default()).unwrap(); @@ -14323,7 +13693,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.consume(), - Control::new(None, false), + Control::new(false), None, peer_setup, VERSION, @@ -14349,7 +13719,7 @@ mod tests { /// From draft-17 a PUBLISH_NAMESPACE is withdrawn by cancelling its request: reset /// plus STOP_SENDING. A FIN there is a protocol violation some peers close on. #[moq_clock::test] - async fn publish_namespace_withdraws_by_reset_from_draft_17() { + async fn publish_namespace_withdraws_by_reset() { for version in [Version::Draft18, Version::Draft19, Version::Draft22] { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let local = origin.announce("local-cam", crate::origin::Route::default()).unwrap(); @@ -14364,7 +13734,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.consume(), - Control::new(None, false), + Control::new(false), None, peer_setup, version, @@ -14413,7 +13783,7 @@ mod tests { /// to a PUBLISH_NAMESPACE is the peer breaking the extension, negotiated or not. #[moq_clock::test] async fn a_counted_publish_namespace_ok_is_a_violation() { - const VERSION: Version = Version::Draft17; + const VERSION: Version = Version::Draft18; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let _local = origin.announce("local-cam", crate::origin::Route::default()).unwrap(); @@ -14445,7 +13815,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.consume(), - Control::new(None, false), + Control::new(false), None, peer_setup, VERSION, @@ -14487,7 +13857,7 @@ mod tests { impl Default for Discovery<'_> { fn default() -> Self { Self { - version: Version::Draft17, + version: Version::Draft18, declared: true, solicit: Some(true), prefix: "", @@ -14536,7 +13906,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), consume, - Control::new(None, false), + Control::new(false), None, setup, version, @@ -14657,7 +14027,7 @@ mod tests { assert_eq!(once, 1, "a peer that asked to be told on request is told once"); assert_eq!(streams, 1, "inline on the SUBSCRIBE_NAMESPACE stream it asked on"); - for version in [Version::Draft15] { + for version in [Version::Draft18] { let log = advertise_with_hidden(Discovery { version, solicit: Some(false), @@ -14692,7 +14062,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.consume(), - Control::new(None, false), + Control::new(false), None, peer_setup, version, @@ -14768,7 +14138,7 @@ mod tests { /// loop's progress visible while every open is blocked. #[moq_clock::test] async fn a_parked_open_still_lets_a_namespace_be_withdrawn() { - const VERSION: Version = Version::Draft14; + const VERSION: Version = Version::Draft18; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let first = origin.announce("first-cam", crate::origin::Route::default()).unwrap(); @@ -14784,7 +14154,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.consume(), - Control::new(None, false), + Control::new(false), None, declared(Some(false)), VERSION, @@ -14862,9 +14232,10 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.consume(), - Control::new(None, false), + Control::new(false), Some(assigned), declared(Some(false)), + Version::Draft18, ); // The state a refused or failed offer leaves behind: the peer holds nothing, and @@ -14889,7 +14260,7 @@ mod tests { /// peer asked for. #[moq_clock::test] async fn a_route_change_still_waits_out_a_refusal() { - const VERSION: Version = Version::Draft17; + const VERSION: Version = Version::Draft18; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); // One epoch, so the second route re-prices the instance rather than restart it. @@ -14909,7 +14280,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.consume(), - Control::new(None, false), + Control::new(false), None, declared(Some(false)), VERSION, @@ -14968,44 +14339,6 @@ mod tests { slot } - /// PUBLISH_NAMESPACE_DONE withdrawing the first request, "cam". - async fn publish_namespace_done(version: Version) -> Vec { - let log = crate::lite::test_transport::Log::default(); - let mut writer = crate::coding::Writer::new( - crate::transport::boxed::SendStream::new(crate::lite::test_transport::SinkSend::new(log.clone())), - version, - ); - writer.varint(ietf::PublishNamespaceDone::ID).await.unwrap(); - writer - .encode(&ietf::PublishNamespaceDone { - track_namespace: crate::Path::new("cam"), - request_id: RequestId(1), - }) - .await - .unwrap(); - log.writes.lock().unwrap().clone() - } - - /// PUBLISH_NAMESPACE_CANCEL letting go of the first request, "cam". - async fn publish_namespace_cancel(version: Version) -> Vec { - let log = crate::lite::test_transport::Log::default(); - let mut writer = crate::coding::Writer::new( - crate::transport::boxed::SendStream::new(crate::lite::test_transport::SinkSend::new(log.clone())), - version, - ); - writer.varint(ietf::PublishNamespaceCancel::ID).await.unwrap(); - writer - .encode(&ietf::PublishNamespaceCancel { - track_namespace: crate::Path::new("cam"), - request_id: RequestId(1), - error_code: 0, - reason_phrase: "gone".into(), - }) - .await - .unwrap(); - log.writes.lock().unwrap().clone() - } - /// The bytes of one REQUEST_UPDATE, framed as the publisher writes it. async fn request_update(version: Version, msg: &ietf::PublishNamespaceUpdate) -> Vec { let log = crate::lite::test_transport::Log::default(); @@ -15052,7 +14385,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.consume(), - Control::new(None, false), + Control::new(false), None, clustered(Some(false)), VERSION, @@ -15079,7 +14412,6 @@ mod tests { VERSION, &ietf::PublishNamespaceUpdate { request_id: RequestId(3), - namespace_request_id: None, hops: None, cost: Some(0), authorization_token: None, @@ -15139,7 +14471,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.consume(), - Control::new(None, false), + Control::new(false), None, clustered(Some(false)), VERSION, @@ -15210,7 +14542,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.consume(), - Control::new(None, false), + Control::new(false), None, clustered(Some(false)), VERSION, @@ -15240,7 +14572,6 @@ mod tests { VERSION, &ietf::PublishNamespaceUpdate { request_id: RequestId(3), - namespace_request_id: None, hops: Some(cluster::HopPath::new( crate::Hops::try_from(vec![crate::Hop::new(8).unwrap(), crate::Hop::new(1).unwrap()]).unwrap(), )), @@ -15284,7 +14615,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.consume(), - Control::new(None, false), + Control::new(false), None, declared(Some(false)), version, @@ -15320,10 +14651,10 @@ mod tests { /// A route's auth rides its PUBLISH_NAMESPACE as the request's token, and swapping it /// renews the request in place: REQUEST_UPDATE on the same stream, carrying only the - /// new token. Draft-16 names the request in the update. + /// new token. #[moq_clock::test] async fn swapping_a_route_auth_is_a_request_update() { - swaps_a_route_auth(Version::Draft16).await; + swaps_a_route_auth(Version::Draft18).await; swaps_a_route_auth(Version::Draft19).await; } @@ -15362,7 +14693,6 @@ mod tests { version, &ietf::PublishNamespaceUpdate { request_id: RequestId(3), - namespace_request_id: (false).then_some(RequestId(1)), hops: None, cost: None, authorization_token: Some(auth_token(b"second-secret")), @@ -15389,97 +14719,6 @@ mod tests { assert_eq!(log.bi_opens(), 1, "{version}: the update rode the request's own stream"); } - /// A draft-16 peer's PUBLISH_NAMESPACE_CANCEL can beat its answer to our update. It - /// withdraws only that namespace, which the jittered retry sweep offers again, and the - /// loop carries on. - #[moq_clock::test] - async fn a_draft_16_cancel_ahead_of_the_answer_ends_only_its_request() { - const VERSION: Version = Version::Draft16; - - let origin = unheld_origin(); - let auth = crate::auth::Link::ietf(false); - let first = auth.present(bytes::Bytes::from_static(b"first-secret"), false).unwrap(); - let second = auth - .present(bytes::Bytes::from_static(b"second-secret"), false) - .unwrap(); - let cam = origin - .announce("cam", crate::origin::Route::default().with_auth(first)) - .unwrap(); - settle().await; - - let ok = publish_namespace_ok(VERSION).await; - let cancel = publish_namespace_cancel(VERSION).await; - let (publisher, log) = auth_publisher(&origin, &auth, vec![[ok.clone(), cancel].concat(), ok], VERSION); - let mut run = std::pin::pin!(publisher.run_publish_namespaces()); - poll_until(&mut run, &log, b"first-secret", 1).await; - - // The re-offer waits out a randomly jittered sweep, which 1ms settles can overrun. - cam.update(crate::origin::Route::default().with_auth(second)).unwrap(); - for _ in 0..100 { - assert!(futures::poll!(run.as_mut()).is_pending()); - if occurrences(&log, b"cam") >= 2 { - break; - } - tick().await; - } - - assert_eq!(occurrences(&log, b"cam"), 2, "the namespace was not offered again"); - assert_eq!(log.bi_opens(), 2, "a fresh request after the cancel"); - assert_eq!( - occurrences(&log, &publish_namespace_done(VERSION).await), - 0, - "PUBLISH_NAMESPACE_DONE after the peer's cancel" - ); - } - - /// A draft-16 peer refuses an update with REQUEST_ERROR and then PUBLISH_NAMESPACE_CANCEL. - /// Draft 16 sends no PUBLISH_NAMESPACE_DONE after a cancel, so the namespace is only - /// offered again once the refusal's wait is out. - #[moq_clock::test] - async fn a_refused_draft_16_update_sends_no_done() { - const VERSION: Version = Version::Draft16; - - let origin = unheld_origin(); - let auth = crate::auth::Link::ietf(false); - let first = auth.present(bytes::Bytes::from_static(b"first-secret"), false).unwrap(); - let second = auth - .present(bytes::Bytes::from_static(b"second-secret"), false) - .unwrap(); - let cam = origin - .announce("cam", crate::origin::Route::default().with_auth(first)) - .unwrap(); - settle().await; - - let ok = publish_namespace_ok(VERSION).await; - let refusal = publish_namespace_error(VERSION, 50).await; - let cancel = publish_namespace_cancel(VERSION).await; - let (publisher, log) = auth_publisher( - &origin, - &auth, - vec![[ok.clone(), refusal, cancel].concat(), ok], - VERSION, - ); - let mut run = std::pin::pin!(publisher.run_publish_namespaces()); - poll_until(&mut run, &log, b"first-secret", 1).await; - - cam.update(crate::origin::Route::default().with_auth(second)).unwrap(); - for _ in 0..100 { - assert!(futures::poll!(run.as_mut()).is_pending()); - if occurrences(&log, b"cam") >= 2 { - break; - } - tick().await; - } - - assert_eq!(occurrences(&log, b"cam"), 2, "the namespace was not offered again"); - assert_eq!(log.bi_opens(), 2, "a fresh request after the refusal"); - assert_eq!( - occurrences(&log, &publish_namespace_done(VERSION).await), - 0, - "PUBLISH_NAMESPACE_DONE after the peer's refusal" - ); - } - /// An auth another handle issued is not this session's to present: the route is /// advertised under the session's scope, and the credential never reaches this peer. #[moq_clock::test] @@ -15535,40 +14774,6 @@ mod tests { assert_eq!(log.bi_opens(), 2, "a fresh stream for the fresh request"); } - /// Before draft-16 a namespace cannot be updated, so a renewal withdraws the request - /// and makes it again with the new token. - #[moq_clock::test] - async fn a_draft_14_renewal_restarts_the_request() { - const VERSION: Version = Version::Draft14; - - let origin = unheld_origin(); - let auth = crate::auth::Link::ietf(false); - let first = auth.present(bytes::Bytes::from_static(b"first-secret"), false).unwrap(); - let second = auth - .present(bytes::Bytes::from_static(b"second-secret"), false) - .unwrap(); - let cam = origin - .announce("cam", crate::origin::Route::default().with_auth(first)) - .unwrap(); - settle().await; - - let ok = publish_namespace_ok(VERSION).await; - let (publisher, log) = auth_publisher(&origin, &auth, vec![ok.clone(), ok], VERSION); - let mut run = std::pin::pin!(publisher.run_publish_namespaces()); - poll_until(&mut run, &log, b"first-secret", 1).await; - - cam.update(crate::origin::Route::default().with_auth(second)).unwrap(); - poll_until(&mut run, &log, b"second-secret", 1).await; - - assert_eq!(occurrences(&log, b"second-secret"), 1, "the renewal never went out"); - assert_eq!( - occurrences(&log, b"first-secret"), - 1, - "the first token was not repeated" - ); - assert_eq!(log.bi_opens(), 2, "a fresh request for the renewal"); - } - /// Renewals wait on their answers side by side: one the peer has not answered holds up /// neither another namespace's renewal nor a new announcement. #[moq_clock::test] @@ -15633,7 +14838,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.consume(), - Control::new(None, false), + Control::new(false), None, declared(Some(false)), VERSION, @@ -15702,7 +14907,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.consume(), - Control::new(None, false), + Control::new(false), None, declared(Some(false)), version, @@ -15757,21 +14962,18 @@ mod tests { again.writer.write_all(&mut ok).await.unwrap(); cams.remove(second); - match version { - _ => assert!( - held.reader.varint().await.is_err(), - "{version} fin={fin}: not withdrawn" - ), - } + assert!( + held.reader.varint().await.is_err(), + "{version} fin={fin}: not withdrawn" + ); assert!(!run.is_finished(), "{version} fin={fin}: the loop ended"); } - /// A draft-14/15 PUBLISH_NAMESPACE whose header fails to send closes the session: its - /// request ID is spent, and a peer that requires the next ID would refuse every later - /// request. Later drafts back off that namespace instead. + /// A PUBLISH_NAMESPACE whose header fails to send backs off that namespace rather than + /// closing the session. #[moq_clock::test] - async fn a_failed_legacy_header_closes_the_session() { - use crate::transport::{memory, poll::Session as _}; + async fn a_failed_header_backs_off_the_namespace() { + use crate::transport::memory; for version in [Version::Draft19] { let origin = unheld_origin(); @@ -15785,12 +14987,12 @@ mod tests { .unwrap(); settle().await; - let (session, mut peer) = memory::pair(memory::Config::default()); + let (session, peer) = memory::pair(memory::Config::default()); let publisher = Publisher::new( crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.consume(), - Control::new(None, false), + Control::new(false), None, declared(Some(false)), version, @@ -15840,7 +15042,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.consume(), - Control::new(None, false), + Control::new(false), None, declared(Some(false)), VERSION, @@ -15870,11 +15072,10 @@ mod tests { } /// An update the peer never answers drops its request once the timeout passes, and - /// the retry advertises the namespace afresh under the current auth. Draft-16's request - /// rides the control stream, where only PUBLISH_NAMESPACE_DONE withdraws it. + /// the retry advertises the namespace afresh under the current auth. #[moq_clock::test] async fn an_unanswered_renewal_advertises_again() { - advertises_again_unanswered(Version::Draft16).await; + advertises_again_unanswered(Version::Draft18).await; advertises_again_unanswered(Version::Draft19).await; } @@ -15935,7 +15136,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.consume(), - Control::new(None, false), + Control::new(false), None, clustered(Some(false)), VERSION, @@ -15997,7 +15198,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.consume(), - Control::new(None, false), + Control::new(false), None, clustered(Some(false)), VERSION, @@ -16032,7 +15233,6 @@ mod tests { VERSION, &ietf::PublishNamespaceUpdate { request_id: RequestId(3), - namespace_request_id: None, hops: None, cost: Some(0), authorization_token: None, @@ -16042,44 +15242,6 @@ mod tests { assert_eq!(occurrences(&log, &update), 1, "only the one update was attempted"); } - #[moq_clock::test] - async fn close_withdraws_legacy_namespaces_without_closing_the_origin() { - const VERSION: Version = Version::Draft14; - let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _cam = origin.announce("closing-cam", crate::origin::Route::default()).unwrap(); - settle().await; - let session = - crate::lite::test_transport::ScriptedSession::per_stream(vec![publish_namespace_ok(VERSION).await]); - let log = session.log.clone(); - let publisher = Publisher::new( - crate::time::sim(), - crate::driver::Transport::new(session.clone()), - origin.consume(), - Control::new(None, false), - None, - declared(None), - VERSION, - ); - let mut run = std::pin::pin!(publisher.clone().run_publish_namespaces()); - for _ in 0..100 { - assert!(futures::poll!(run.as_mut()).is_pending()); - if occurrences(&log, b"closing-cam") > 0 { - break; - } - settle().await; - } - assert_eq!(occurrences(&log, b"closing-cam"), 1); - assert!(!publisher.withdrawal.drained()); - publisher.withdrawal.begin(); - run.await.unwrap(); - assert!(publisher.withdrawal.drained()); - assert_eq!( - occurrences(&log, b"closing-cam"), - 2, - "PUBLISH_NAMESPACE_DONE names the withdrawn namespace" - ); - } - /// The peer granting a stream is only half the exchange. One it accepts and then never /// answers on wedges the loop exactly as a parked open does, so the response is bounded /// too: everything queued behind it is otherwise stranded for the session. @@ -16087,7 +15249,7 @@ mod tests { /// Draft-14 so each advertisement names its namespace on the wire. #[moq_clock::test] async fn a_silent_answer_still_lets_the_next_namespace_be_advertised() { - const VERSION: Version = Version::Draft14; + const VERSION: Version = Version::Draft18; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let _first = origin.announce("first-cam", crate::origin::Route::default()).unwrap(); @@ -16103,7 +15265,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.consume(), - Control::new(None, false), + Control::new(false), None, declared(Some(false)), VERSION, @@ -16130,12 +15292,11 @@ mod tests { ); } - /// An advertisement the peer never answers is given up at its deadline. On drafts 14-16 - /// it rides the control stream, where dropping it tells the peer nothing, so it is - /// withdrawn with PUBLISH_NAMESPACE_DONE; from draft 17 its own stream's reset ends it. + /// An advertisement the peer never answers is given up at its deadline: its own stream's + /// reset ends it. #[moq_clock::test] async fn an_unanswered_advertisement_is_withdrawn() { - for version in [Version::Draft15] { + for version in [Version::Draft18] { let origin = unheld_origin(); let _cam = origin.announce("cam", crate::origin::Route::default()).unwrap(); settle().await; @@ -16147,7 +15308,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.consume(), - Control::new(None, false), + Control::new(false), None, declared(Some(false)), version, @@ -16155,11 +15316,7 @@ mod tests { let mut run = std::pin::pin!(publisher.run_publish_namespaces()); poll_until(&mut run, &log, b"cam", 1).await; - let done = Some(publish_namespace_done(version).await); - let withdrawn = || match &done { - Some(done) => occurrences(&log, done) > 0, - None => !log.resets().is_empty(), - }; + let withdrawn = || !log.resets().is_empty(); moq_clock::sleep(ADVERTISE_TIMEOUT - Duration::from_millis(10)).await; assert!(futures::poll!(run.as_mut()).is_pending()); assert!(!withdrawn(), "{version}: withdrawn before its deadline"); @@ -16188,7 +15345,7 @@ mod tests { let session = crate::lite::test_transport::ScriptedSession::new(publish_namespace_ok(version).await).without_credit(); let log = session.log.clone(); - let control = Control::new(None, false); + let control = Control::new(false); let publisher = Publisher::new( crate::time::sim(), crate::driver::Transport::new(session.clone()), @@ -16219,8 +15376,8 @@ mod tests { ); assert!(log.closes().is_empty()); assert_eq!( - control.poll_next_request_id(&kio::Waiter::noop()), - Poll::Ready(RequestId(3)), + control.next_request_id(), + RequestId(3), "{version}: only the admitted attempt spends an ID" ); } @@ -16231,7 +15388,7 @@ mod tests { /// stays undiscoverable for the life of the session. #[moq_clock::test] async fn an_advertisement_waiting_for_send_capacity_is_retried_on_its_own() { - const VERSION: Version = Version::Draft14; + const VERSION: Version = Version::Draft18; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let _cam = origin.announce("lonely-cam", crate::origin::Route::default()).unwrap(); @@ -16247,7 +15404,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.consume(), - Control::new(None, false), + Control::new(false), None, declared(Some(false)), VERSION, @@ -16310,7 +15467,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.consume(), - Control::new(None, false), + Control::new(false), None, peer_setup, version, @@ -17262,13 +16419,13 @@ mod compression_tests { Err(Error::Unsupported) )); assert!(matches!( - track_properties(&info, wanted, true), + track_properties(&info, wanted, version, true), Err(Error::Unsupported) )); } let plain = track::Info::default().with_compress(true); assert!(!track_properties(&plain, true, version, false).unwrap().compress); - assert!(!track_properties(&plain, true, true).unwrap().compress); + assert!(!track_properties(&plain, true, version, true).unwrap().compress); } } @@ -17278,13 +16435,13 @@ mod compression_tests { async fn ietf_compression_fallback_interop() { use crate::coding::Decode; use crate::lite::test_transport::{Log, SinkSession}; - for (version, draft) in [(Version::Draft17, 17), (Version::Draft22, 22)] { + for (version, draft) in [(Version::Draft18, 18), (Version::Draft22, 22)] { let input = serde_json::json!({"draft": draft}); let bytes: Vec = serde_json::from_slice(&crate::test_interop::bun("ietf-compression.ts", input)).unwrap(); let (parameters, consumed) = ietf::Parameters::decode_slice(&bytes, version).unwrap(); assert_eq!(consumed, bytes.len()); - let negotiated = super::super::flate::from_setup(¶meters, version).unwrap(); + let negotiated = super::super::flate::from_setup(¶meters).unwrap(); assert!(!negotiated, "JS offered an unsupported codec"); let track = track::Producer::new( Arc::new(crate::broadcast::Info::default()), diff --git a/rs/moq-net/src/ietf/publisher/tracks.rs b/rs/moq-net/src/ietf/publisher/tracks.rs index 1756a70ed59..e1ed3083b96 100644 --- a/rs/moq-net/src/ietf/publisher/tracks.rs +++ b/rs/moq-net/src/ietf/publisher/tracks.rs @@ -1385,7 +1385,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.consume(), - Control::new(None, false), + Control::new(false), None, setup, version, @@ -1497,9 +1497,6 @@ mod tests { fn update(request_id: u64, forward: bool) -> ietf::SubscribeUpdate { ietf::SubscribeUpdate { request_id: RequestId(request_id), - subscription_request_id: None, - start_location: Location { group: 0, object: 0 }, - end_group: 0, subscriber_priority: None, forward: Some(forward), // Join at the live edge: draft-20 moved the filter off PUBLISH_OK. @@ -2594,7 +2591,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(h.session.clone()), h._origin.consume(), - Control::new(None, false), + Control::new(false), None, setup, version, diff --git a/rs/moq-net/src/ietf/session.rs b/rs/moq-net/src/ietf/session.rs index 52ef8e767e3..84d43bf6f00 100644 --- a/rs/moq-net/src/ietf/session.rs +++ b/rs/moq-net/src/ietf/session.rs @@ -1365,14 +1365,11 @@ mod tests { let interest = origin.consume().announced(); let session = crate::lite::test_transport::ScriptedSession::new(Vec::new()).without_credit(); let log = session.log.clone(); - let mut session = crate::driver::Transport::new(session); - let setup = None; + let session = crate::driver::Transport::new(session); let (driver, _goaway) = start(Config { runtime: crate::time::sim(), stats: Default::default(), session, - setup, - request_id_max: None, limits: Default::default(), client: true, publish: None, @@ -1473,8 +1470,6 @@ mod tests { runtime: crate::time::sim(), stats: Default::default(), session: crate::driver::Transport::new(session.clone()), - setup: None, - request_id_max: None, limits: Default::default(), client, publish: None, @@ -1531,8 +1526,6 @@ mod tests { runtime: crate::time::sim(), stats: Default::default(), session: crate::driver::Transport::new(session.clone()), - setup: None, - request_id_max: None, limits: Default::default(), client: true, publish: None, @@ -1580,8 +1573,6 @@ mod tests { runtime: crate::time::sim(), stats: Default::default(), session: crate::driver::Transport::new(session.clone()), - setup: None, - request_id_max: None, limits: Default::default(), client: false, publish: None, @@ -1685,8 +1676,6 @@ mod tests { runtime: crate::time::sim(), stats: Default::default(), session: crate::driver::Transport::new(session.clone()), - setup: None, - request_id_max: None, limits: Default::default(), client: true, publish: None, @@ -1752,8 +1741,6 @@ mod tests { runtime: crate::time::sim(), stats: Default::default(), session: crate::driver::Transport::new(session.clone()), - setup: None, - request_id_max: None, limits: Default::default(), client: true, publish: None, @@ -1788,33 +1775,19 @@ mod tests { assert_eq!(occurrences(&log, b"rootns"), 0, "asked the peer for our local root"); } - /// The bytes of one legacy SUBSCRIBE_NAMESPACE, as the session writes them. - async fn subscribe_namespace_legacy(version: Version, namespace: &str, request_id: RequestId) -> Vec { + /// The bytes of one SUBSCRIBE_NAMESPACE, as the session writes them. + async fn subscribe_namespace(version: Version, namespace: &str, request_id: RequestId) -> Vec { let log = crate::lite::test_transport::Log::default(); let mut writer = Writer::new( crate::transport::boxed::SendStream::new(crate::lite::test_transport::SinkSend::new(log.clone())), version, ); - let msg = ietf::SubscribeNamespaceLegacy { + let msg = ietf::SubscribeNamespace { request_id, namespace: crate::Path::new(namespace), - subscribe_options: ietf::SubscribeOptions::Namespace, hidden: false, }; - writer.varint(ietf::SubscribeNamespaceLegacy::ID).await.unwrap(); - writer.encode(&msg).await.unwrap(); - log.writes.lock().unwrap().clone() - } - - /// The bytes of one UNSUBSCRIBE_NAMESPACE, as the session writes them. - async fn unsubscribe_namespace(version: Version, prefix: &str, request_id: RequestId) -> Vec { - let log = crate::lite::test_transport::Log::default(); - let mut writer = Writer::new(crate::lite::test_transport::SinkSend::new(log.clone()), version); - let msg = ietf::UnsubscribeNamespace { - prefix: crate::Path::new(prefix), - request_id, - }; - writer.varint(ietf::UnsubscribeNamespace::ID).await.unwrap(); + writer.varint(ietf::SubscribeNamespace::ID).await.unwrap(); writer.encode(&msg).await.unwrap(); log.writes.lock().unwrap().clone() } @@ -1854,15 +1827,12 @@ mod tests { moq_clock::sim::JoinHandle>, ) { let log = session.log.clone(); - let mut session = crate::driver::Transport::new(session); - let setup = None; + let session = crate::driver::Transport::new(session); let (driver, _goaway) = start(Config { runtime: crate::time::sim(), stats: Default::default(), session, - setup, - request_id_max: None, limits: Default::default(), client: true, publish: None, @@ -1898,28 +1868,13 @@ mod tests { false } - /// How many times a client watching everything under `prefix` writes SUBSCRIBE_NAMESPACE - /// for it. `solicit` is what the peer's SETUP declared (MoQ Solicit). - async fn asked_namespace(version: Version, prefix: &str, solicit: Option) -> usize { - let subscribe = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _watch = watch(&subscribe, prefix); - let (log, driver) = client(version, subscribe, solicit).await; - - let needle = subscribe_namespace_legacy(version, prefix, RequestId(0)).await; - sent(&log, &needle).await; - - assert!(!driver.is_finished(), "{version:?} ended the session"); - assert!(log.closes().is_empty(), "{version:?} closed: {:?}", log.closes()); - occurrences(&log, &needle) - } - /// A client asks nothing until something is watched, then only about what is. #[moq_clock::test] async fn a_client_asks_only_about_what_is_watched() { - for version in [Version::Draft15] { + for version in [Version::Draft18] { let subscribe = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let (log, _driver) = client(version, subscribe.clone(), Some(true)).await; - let first = subscribe_namespace_legacy(version, "cam", RequestId(0)).await; + let first = subscribe_namespace(version, "cam", RequestId(0)).await; assert!( !sent(&log, &first).await, "{version:?} asked before anything was watched" @@ -1927,7 +1882,7 @@ mod tests { let _cam = watch(&subscribe, "cam"); assert!(sent(&log, &first).await, "{version:?} did not ask about the watch"); - let second = subscribe_namespace_legacy(version, "", RequestId(2)).await; + let second = subscribe_namespace(version, "", RequestId(2)).await; assert!( !sent(&log, &second).await, "{version:?} asked about more than the watch" @@ -1935,58 +1890,9 @@ mod tests { } } - /// Once nothing has watched a prefix for the linger, the request ends. Draft-14 and 15 - /// carry it on the control stream, where only UNSUBSCRIBE_NAMESPACE tells the peer; it - /// names the prefix on draft-14 and the request on draft-15. - #[moq_clock::test] - async fn an_unwatched_prefix_is_unsubscribed_after_the_linger() { - for version in [Version::Draft15] { - let subscribe = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let cam = watch(&subscribe, "cam"); - let (log, _driver) = client(version, subscribe.clone(), None).await; - let asked = subscribe_namespace_legacy(version, "cam", RequestId(0)).await; - assert!(sent(&log, &asked).await, "{version:?}"); - let unsubscribe = unsubscribe_namespace(version, "cam", RequestId(0)).await; - - drop(cam); - moq_clock::sleep(crate::discovery::LINGER / 2).await; - assert!( - !sent(&log, &unsubscribe).await, - "{version:?} ended the request before the linger" - ); - moq_clock::sleep(crate::discovery::LINGER).await; - assert!(sent(&log, &unsubscribe).await, "{version:?} never unsubscribed"); - } - } - - /// A broader watch replaces the narrower request at a foreign peer rather than - /// overlapping it, which that peer refuses: on draft-14 and 15 the UNSUBSCRIBE_NAMESPACE - /// goes out on the ordered control stream ahead of the broader SUBSCRIBE_NAMESPACE. - #[moq_clock::test] - async fn a_broader_watch_replaces_the_narrower_at_a_foreign_peer() { - for version in [Version::Draft15] { - let subscribe = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _front = watch(&subscribe, "cam/front"); - let (log, _driver) = client(version, subscribe.clone(), None).await; - let asked = subscribe_namespace_legacy(version, "cam/front", RequestId(0)).await; - assert!(sent(&log, &asked).await, "{version:?}"); - - let _cam = watch(&subscribe, "cam"); - let broader = subscribe_namespace_legacy(version, "cam", RequestId(2)).await; - assert!(sent(&log, &broader).await, "{version:?} never asked the broader prefix"); - let unsubscribe = unsubscribe_namespace(version, "cam/front", RequestId(0)).await; - let writes = log.writes.lock().unwrap().clone(); - let at = |needle: &[u8]| writes.windows(needle.len()).position(|window| window == needle); - assert!( - at(&unsubscribe).expect("unsubscribed the narrower request") < at(&broader).unwrap(), - "{version:?} overlapped the narrower request" - ); - } - } - - /// From draft-16 each request has a stream of its own, so at a foreign peer the broader - /// one waits for the peer to close the narrower one's, which ends with a FIN until - /// draft-19 makes it a reset: a peer that never closes it never sees the two overlap. + /// Each request has a stream of its own, so at a foreign peer the broader one waits for + /// the peer to close the narrower one's, which ends with a FIN until draft-19 makes it a + /// reset: a peer that never closes it never sees the two overlap. #[moq_clock::test] async fn a_broader_watch_waits_for_the_narrower_to_leave_the_wire() { for version in [ @@ -2049,57 +1955,24 @@ mod tests { /// routes over before it has synced. #[moq_clock::test] async fn a_broader_watch_keeps_the_narrower_open_at_our_peer() { - for version in [Version::Draft15] { + for version in [Version::Draft18] { let subscribe = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let _front = watch(&subscribe, "cam/front"); let (log, _driver) = client(version, subscribe.clone(), Some(true)).await; - let asked = subscribe_namespace_legacy(version, "cam/front", RequestId(0)).await; + let asked = subscribe_namespace(version, "cam/front", RequestId(0)).await; assert!(sent(&log, &asked).await, "{version:?}"); let _cam = watch(&subscribe, "cam"); - let broader = subscribe_namespace_legacy(version, "cam", RequestId(2)).await; + let broader = subscribe_namespace(version, "cam", RequestId(2)).await; assert!(sent(&log, &broader).await, "{version:?} never asked the broader prefix"); - let ended = match version { - _ => log - .trail() - .iter() - .any(|(_, sent)| !matches!(sent, crate::lite::test_transport::Sent::Write(_))), - }; + let ended = log + .trail() + .iter() + .any(|(_, sent)| !matches!(sent, crate::lite::test_transport::Sent::Write(_))); assert!(!ended, "{version:?} ended the narrower request: {:?}", log.trail()); } } - /// Draft-14 and draft-15 reject a zero-field track namespace, so a foreign peer (one - /// that declared no MoQ Solicit) is not asked for it, and a watched prefix still goes - /// out, which is how a client discovers anything through a peer that only tells when - /// asked. A peer that declared Solicit is ours: it only tells when asked, so it still - /// gets the empty prefix. Draft-16 made the empty prefix legal, so it stays. - #[moq_clock::test] - async fn an_empty_namespace_is_not_asked_of_a_foreign_peer_before_draft_16() { - for version in [Version::Draft15] { - assert_eq!( - asked_namespace(version, "", None).await, - 0, - "{version:?} asked a foreign peer for every namespace" - ); - assert_eq!( - asked_namespace(version, "cam", None).await, - 1, - "{version:?} skipped a watched prefix" - ); - assert_eq!( - asked_namespace(version, "", Some(true)).await, - 1, - "{version:?} did not ask a soliciting peer for every namespace" - ); - } - assert_eq!( - asked_namespace(Version::Draft16, "", None).await, - 1, - "draft-16 dropped the empty prefix" - ); - } - /// How many scheduling turns an advertisement gets before the count is taken. Time is /// paused in these tests, so each turn costs nothing and only runs the driver until it /// parks again; a busy machine cannot turn a slow announce into a passing silence. @@ -2123,8 +1996,6 @@ mod tests { runtime: crate::time::sim(), stats: Default::default(), session: crate::driver::Transport::new(session.clone()), - setup: None, - request_id_max: None, limits: Default::default(), client: true, publish: Some(origin.consume()), @@ -2229,8 +2100,6 @@ mod tests { runtime: crate::time::sim(), stats: Default::default(), session: crate::driver::Transport::new(session.clone()), - setup: None, - request_id_max: None, limits: Default::default(), client: true, publish: Some(origin.consume()), @@ -2317,8 +2186,6 @@ mod tests { runtime: crate::time::sim(), stats: Default::default(), session: crate::driver::Transport::new(session.clone()), - setup: None, - request_id_max: None, limits: Default::default(), client, publish: None, @@ -2416,8 +2283,6 @@ mod tests { runtime: crate::time::sim(), stats: Default::default(), session: crate::driver::Transport::new(session.clone()), - setup: None, - request_id_max: None, limits: Default::default(), client: false, publish: None, @@ -2508,8 +2373,6 @@ mod tests { runtime: crate::time::sim(), stats: Default::default(), session: crate::driver::Transport::new(session.clone()), - setup: None, - request_id_max: None, limits: Default::default(), client: true, publish: None, @@ -2554,8 +2417,6 @@ mod tests { runtime: crate::time::sim(), stats: Default::default(), session: crate::driver::Transport::new(session.clone()), - setup: None, - request_id_max: None, limits: Default::default(), client: true, publish: None, @@ -2668,7 +2529,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin, - Control::new(None, true), + Control::new(true), None, peer_setup.clone(), crate::Hop::new(1).unwrap(), @@ -2826,8 +2687,6 @@ mod tests { runtime: crate::time::sim(), stats: Default::default(), session: crate::driver::Transport::new(session.clone()), - setup: None, - request_id_max: None, limits: Default::default(), client: true, publish, @@ -2910,7 +2769,6 @@ mod tests { let session = crate::lite::test_transport::ScriptedSession::new(Vec::new()).with_incoming_unis(vec![ uni_stream(VERSION, PADDING), subgroup_header(VERSION, 7, 0).await, - setup, ]); let accepted = accept_setup(&mut crate::driver::Transport::new(session.clone()), VERSION) .await @@ -2932,14 +2790,9 @@ mod tests { async fn an_unknown_uni_type_closes_the_session() { for (version, kind) in [ (Version::Draft19, 0), - // Padding and uni SETUP arrived in later drafts, so earlier ones do not know them. - (Version::Draft17, PADDING), - (Version::Draft16, setup::SETUP_V17), + // Padding and uni SETUP arrived in later drafts, // SUBGROUP_HEADER types with the reserved SUBGROUP_ID_MODE (0b11). (Version::Draft19, 0x56), - (Version::Draft14, 0x16), - // FIRST_OBJECT (0x40) arrived in draft-18. - (Version::Draft17, 0x50), ] { let (log, result) = dispatch_uni(version, uni_stream(version, kind), None).await; @@ -2973,8 +2826,6 @@ mod tests { runtime: crate::time::sim(), stats: Default::default(), session: crate::driver::Transport::new(session.clone()), - setup: None, - request_id_max: None, limits: Default::default(), client: false, publish: None, @@ -3044,8 +2895,6 @@ mod tests { runtime: crate::time::sim(), stats: Default::default(), session: crate::driver::Transport::new(session.clone()), - setup: None, - request_id_max: None, client: false, publish: None, subscribe: None, @@ -3077,146 +2926,13 @@ mod tests { } } - /// A peer's advertisement of `room/host`, then two namespace-keyed withdrawals of it. - /// The second has no advertisement left to name. - async fn publish_namespace_then_two_withdrawals(version: Version) -> Vec { - let log = crate::lite::test_transport::Log::default(); - let mut writer = crate::coding::Writer::new( - crate::transport::boxed::SendStream::new(crate::lite::test_transport::SinkSend::new(log.clone())), - version, - ); - - writer.varint(ietf::PublishNamespace::ID).await.unwrap(); - writer - .encode(&ietf::PublishNamespace { - request_id: RequestId(1), - track_namespace: crate::Path::new("room/host"), - params: Default::default(), - authorization_token: None, - }) - .await - .unwrap(); - - for _ in 0..2 { - writer.varint(ietf::PublishNamespaceDone::ID).await.unwrap(); - writer - .encode(&ietf::PublishNamespaceDone { - track_namespace: crate::Path::new("room/host"), - request_id: RequestId(0), - }) - .await - .unwrap(); - } - - let writes = log.writes.lock().unwrap(); - writes.clone() - } - - /// The acknowledgement draft-14 answers a PUBLISH_NAMESPACE with, as bytes to look - /// for in what we wrote. - async fn publish_namespace_ok(request_id: RequestId) -> Vec { - let log = crate::lite::test_transport::Log::default(); - let mut writer = crate::coding::Writer::new( - crate::transport::boxed::SendStream::new(crate::lite::test_transport::SinkSend::new(log.clone())), - ); - - writer.varint(ietf::PublishNamespaceOk::ID).await.unwrap(); - writer.encode(&ietf::PublishNamespaceOk { request_id }).await.unwrap(); - - let writes = log.writes.lock().unwrap(); - writes.clone() - } - - /// draft-14 names its withdrawals rather than numbering them, so a repeat has no - /// advertisement left to resolve to. Dropping it is what keeps the session up: failing - /// the lookup takes the whole connection down over a message with nothing left to do. - /// - /// Driven through `start` because only the full loop shows the consequence, the read - /// task propagating the classifier's error. - #[moq_clock::test] - async fn a_repeated_publish_namespace_done_does_not_end_the_session() { - const VERSION: Version = Version::Draft14; - - let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let consumer = origin.consume(); - - let session = - crate::lite::test_transport::ScriptedSession::new(publish_namespace_then_two_withdrawals(VERSION).await); - let log = session.log.clone(); - let session = crate::driver::Transport::new(session.clone()); - let setup = Stream::open(&mut crate::driver::Transport::new(session.clone()), VERSION) - .await - .expect("open the control stream"); - - let (driver, _goaway) = start(Config { - runtime: crate::time::sim(), - stats: Default::default(), - session, - setup: Some(setup), - request_id_max: None, - limits: Default::default(), - client: true, - publish: None, - subscribe: Some(origin), - peer_hop: None, - cost: None, - version: VERSION, - path: None, - authority: None, - peer_setup_stream: None, - peer_declared: None, - auth: crate::auth::Link::new(false), - early_unis: Vec::new(), - implementation: None, - peer_implementation: Default::default(), - extensions: Default::default(), - }) - .expect("start the session"); - let driver = moq_clock::sim::spawn(driver); - - let accepted = publish_namespace_ok(RequestId(1)).await; - for _ in 0..ANNOUNCE_TURNS { - if occurrences(&log, &accepted) > 0 && consumer.get_broadcast("room/host").is_none() { - break; - } - moq_clock::sleep(std::time::Duration::from_millis(1)).await; - } - - assert_eq!(occurrences(&log, &accepted), 1, "the advertisement was not accepted"); - assert!( - consumer.get_broadcast("room/host").is_none(), - "the withdrawal did not reach the request that advertised it" - ); - assert!(!driver.is_finished(), "the repeated withdrawal ended the session"); - assert!(log.closes().is_empty(), "closed the session: {:?}", log.closes()); - } - /// A SUBSCRIBE for `room/video` whose parameters are one AUTHORIZATION TOKEN holding /// `token`, framed as a control message. fn subscribe_with_token(version: Version, token: &[u8]) -> Vec { - let msg = ietf::Subscribe { - max_age: None, - new_group: None, - request_id: RequestId(0), - track_namespace: crate::Path::new("room"), - track_name: "video".into(), - subscriber_priority: 128, - group_order: ietf::GroupOrder::Descending, - filter: ietf::Filter::NextObject, - fill: None, - properties_wanted: true, - forward: true, - rendezvous: false, - range_filters: false, - authorization_token: None, - epoch: None, - }; let mut body = Vec::new(); let mut w = crate::coding::Encoder::new(&mut body, version.into()); - match version { - // The request ID, namespace and name; every parameter but the token defaults. - _ => w.slice(&[0, 1, 4, b'r', b'o', b'o', b'm', 5, b'v', b'i', b'd', b'e', b'o']), - } + // The request ID, namespace and name; every parameter but the token defaults. + w.slice(&[0, 1, 4, b'r', b'o', b'o', b'm', 5, b'v', b'i', b'd', b'e', b'o']); let mut w = crate::coding::Encoder::new(&mut body, version.into()); w.varint(1).unwrap(); w.varint(u64::from(ietf::ParameterBytes::AuthorizationToken)).unwrap(); @@ -3263,14 +2979,11 @@ mod tests { }; let log = session.log.clone(); let session = crate::driver::Transport::new(session.clone()); - let setup = None; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let (driver, _goaway) = start(Config { runtime: crate::time::sim(), stats: Default::default(), session, - setup, - request_id_max: None, limits: Default::default(), client: false, publish: Some(origin.consume()), @@ -3510,8 +3223,6 @@ mod tests { runtime: crate::time::sim(), stats: Default::default(), session: crate::driver::Transport::new(session.clone()), - setup: None, - request_id_max: None, limits: Default::default(), client: true, publish: None, @@ -3575,7 +3286,7 @@ mod tests { for client in [false, true] { let session = crate::lite::test_transport::ScriptedSession::new(Vec::new()); let log = session.log.clone(); - let control = Control::new(None, client); + let control = Control::new(client); let first = u64::from(client); control.accept(RequestId(first)).unwrap(); control.accept(RequestId(first + 4)).unwrap(); @@ -3616,8 +3327,6 @@ mod tests { runtime: crate::time::sim(), stats: Default::default(), session: crate::driver::Transport::new(session.clone()), - setup: None, - request_id_max: None, limits: Default::default(), client, publish: Some(origin.consume()), diff --git a/rs/moq-net/src/ietf/subscribe.rs b/rs/moq-net/src/ietf/subscribe.rs index 2f98c38b393..6e557a4f67c 100644 --- a/rs/moq-net/src/ietf/subscribe.rs +++ b/rs/moq-net/src/ietf/subscribe.rs @@ -372,37 +372,8 @@ mod tests { epoch: None, }; - let encoded = encode_message(&msg, Version::Draft14); - let decoded: Subscribe = decode_message(&encoded, Version::Draft14).unwrap(); - - assert_eq!(decoded.request_id, RequestId(1)); - assert_eq!(decoded.track_namespace.as_str(), "test"); - assert_eq!(decoded.track_name, "video"); - assert_eq!(decoded.subscriber_priority, 128); - } - - #[test] - fn test_subscribe_round_trip_v15() { - let msg = Subscribe { - new_group: None, - max_age: None, - request_id: RequestId(1), - track_namespace: Path::new("test"), - track_name: "video".into(), - subscriber_priority: 128, - group_order: GroupOrder::Descending, - filter: Filter::NextObject, - fill: None, - properties_wanted: true, - forward: true, - rendezvous: false, - range_filters: false, - authorization_token: None, - epoch: None, - }; - - let encoded = encode_message(&msg, Version::Draft15); - let decoded: Subscribe = decode_message(&encoded, Version::Draft15).unwrap(); + let encoded = encode_message(&msg, Version::Draft18); + let decoded: Subscribe = decode_message(&encoded, Version::Draft18).unwrap(); assert_eq!(decoded.request_id, RequestId(1)); assert_eq!(decoded.track_namespace.as_str(), "test"); @@ -411,7 +382,7 @@ mod tests { } /// Build a SUBSCRIBE body carrying a single RENDEZVOUS_TIMEOUT parameter. - const VERSIONS: [Version; 9] = [ + const VERSIONS: [Version; 5] = [ Version::Draft18, Version::Draft19, Version::Draft20, @@ -419,12 +390,11 @@ mod tests { Version::Draft22, ]; - /// NEW_GROUP_REQUEST survives SUBSCRIBE and REQUEST_UPDATE from draft 16 on, and is - /// never written before. + /// NEW_GROUP_REQUEST survives SUBSCRIBE and REQUEST_UPDATE. #[test] - fn new_group_request_round_trips_where_the_draft_has_it() { + fn new_group_request_round_trips() { for version in VERSIONS { - let expected = has_new_group_request(version).then_some(7); + let expected = Some(7); let subscribe = Subscribe { new_group: Some(7), max_age: None, @@ -497,11 +467,11 @@ mod tests { /// that carries it is ignored. Draft-16 dropped the id, which makes it unknown. #[test] fn cache_duration_on_subscribe_follows_the_draft() { - let draft15 = subscribe_with_rendezvous(0, Version::Draft15); - decode_message::(&draft15, Version::Draft15).expect("draft-15 ignores MAX_CACHE_DURATION"); + let draft15 = subscribe_with_rendezvous(0, Version::Draft18); + decode_message::(&draft15, Version::Draft18).expect("draft-15 ignores MAX_CACHE_DURATION"); - let draft16 = subscribe_with_rendezvous(0, Version::Draft16); - decode_message::(&draft16, Version::Draft16).expect_err("draft-16 rejects unknown parameter 0x04"); + let draft16 = subscribe_with_rendezvous(0, Version::Draft18); + decode_message::(&draft16, Version::Draft18).expect_err("draft-16 rejects unknown parameter 0x04"); } /// The first message parameter key on an encoded SUBSCRIBE, or `None` when it carries no @@ -579,8 +549,8 @@ mod tests { epoch: None, }; - let encoded = encode_message(&msg, Version::Draft14); - let decoded: Subscribe = decode_message(&encoded, Version::Draft14).unwrap(); + let encoded = encode_message(&msg, Version::Draft18); + let decoded: Subscribe = decode_message(&encoded, Version::Draft18).unwrap(); assert_eq!(decoded.track_namespace.as_str(), "conference/room123"); } @@ -593,35 +563,20 @@ mod tests { properties: Properties::default(), }; - let encoded = encode_message(&msg, Version::Draft14); - let decoded: SubscribeOk = decode_message(&encoded, Version::Draft14).unwrap(); + let encoded = encode_message(&msg, Version::Draft18); + let decoded: SubscribeOk = decode_message(&encoded, Version::Draft18).unwrap(); - assert_eq!(decoded.request_id, Some(RequestId(42))); + assert_eq!(decoded.track_alias, 42); } + /// The parameter value is two bare varints. The empty Track Properties block follows the + /// parameters. #[test] fn test_subscribe_ok_accepts_largest_object() { - // request_id=4, track_alias=4, one LARGEST_OBJECT parameter at {5, 0}. - let payload = [0x04, 0x04, 0x01, 0x09, 0x02, 0x05, 0x00]; - for version in [Version::Draft16] { - let decoded: SubscribeOk = decode_message(&payload, version).unwrap(); - - assert_eq!(decoded.request_id, Some(RequestId(4))); - assert_eq!(decoded.track_alias, 4); - assert_eq!(decoded.largest, Some(Location { group: 5, object: 0 }), "{version}"); - } - } - - /// From draft-17 the parameter value is two bare varints, so the same Location costs - /// one byte less than the length-prefixed form above. The empty Track Properties block - /// follows the parameters. - #[test] - fn test_subscribe_ok_accepts_largest_object_draft17_on() { let payload = [0x04, 0x01, 0x09, 0x05, 0x00]; for version in [Version::Draft18, Version::Draft19, Version::Draft20] { let decoded: SubscribeOk = decode_message(&payload, version).unwrap(); - assert_eq!(decoded.request_id, None, "{version}"); assert_eq!(decoded.track_alias, 4, "{version}"); assert_eq!(decoded.largest, Some(Location { group: 5, object: 0 }), "{version}"); } @@ -653,9 +608,6 @@ mod tests { let largest = Some(Location { group: 9, object: 3 }); for (version, expected) in [ - (Version::Draft14, &[7, 42, 0, 1, 1, 9, 3, 0][..]), - (Version::Draft16, &[7, 42, 1, 0x09, 0x02, 0x09, 0x03][..]), - (Version::Draft17, &[42, 1, 0x09, 0x09, 0x03][..]), (Version::Draft18, &[42, 1, 0x09, 0x09, 0x03][..]), (Version::Draft19, &[42, 1, 0x09, 0x09, 0x03][..]), (Version::Draft20, &[42, 1, 0x09, 0x09, 0x03][..]), @@ -673,49 +625,6 @@ mod tests { } } - #[test] - fn test_subscribe_ok_v15() { - let msg = SubscribeOk { - track_alias: 42, - largest: None, - properties: Properties::default(), - }; - - let encoded = encode_message(&msg, Version::Draft15); - let decoded: SubscribeOk = decode_message(&encoded, Version::Draft15).unwrap(); - - assert_eq!(decoded.request_id, Some(RequestId(42))); - assert_eq!(decoded.track_alias, 42); - } - - #[test] - fn test_subscribe_error() { - let msg = SubscribeError { - request_id: RequestId(123), - error_code: 500, - reason_phrase: "Not found".into(), - }; - - let encoded = encode_message(&msg, Version::Draft14); - let decoded: SubscribeError = decode_message(&encoded, Version::Draft14).unwrap(); - - assert_eq!(decoded.request_id, RequestId(123)); - assert_eq!(decoded.error_code, 500); - assert_eq!(decoded.reason_phrase, "Not found"); - } - - #[test] - fn test_unsubscribe() { - let msg = Unsubscribe { - request_id: RequestId(999), - }; - - let encoded = encode_message(&msg, Version::Draft14); - let decoded: Unsubscribe = decode_message(&encoded, Version::Draft14).unwrap(); - - assert_eq!(decoded.request_id, RequestId(999)); - } - /// Every parameter the draft lets a message carry has to parse, even the ones we act on /// nowhere: an unlisted key fails the whole message, which tears the session down /// instead of letting the request reach its answer. @@ -788,28 +697,10 @@ mod tests { 0x00, // num_params ]; - let result: Result = decode_message(&invalid_bytes, Version::Draft14); + let result: Result = decode_message(&invalid_bytes, Version::Draft18); assert!(result.is_err()); } - /// Draft-16 registers Filter Types 0x1-0x4 and requires PROTOCOL_VIOLATION for any - /// other. Moxygen's `SubscribeRequest::make` defaults to its unregistered LargestGroup - /// (0xFA), so its interop client sends this exact SUBSCRIBE; refuse it rather than - /// guess a meaning. - #[test] - fn test_subscribe_v16_rejects_unregistered_filter_type() { - let subscribe = |filter_type: &[u8]| { - let mut bytes = vec![0x00]; // request_id - bytes.extend_from_slice(b"\x01\x0bnonexistent\x0dno-such-track"); // namespace, name - bytes.extend_from_slice(&[0x01, 0x21, filter_type.len() as u8]); // one SUBSCRIPTION_FILTER - bytes.extend_from_slice(filter_type); - decode_message::(&bytes, Version::Draft16) - }; - - assert!(matches!(subscribe(&[0x40, 0xfa]), Err(DecodeError::InvalidValue))); - assert_eq!(subscribe(&[0x02]).unwrap().filter, Filter::NextObject); - } - /// From draft-15 SUBSCRIBER_PRIORITY is a parameter whose omission means 128, not this /// stack's unset 127, so a relay forwards it unchanged. #[test] @@ -829,164 +720,6 @@ mod tests { } } - #[test] - fn test_subscribe_update_v15_round_trip() { - let msg = SubscribeUpdate { - new_group: None, - max_age: None, - request_id: RequestId(10), - subscription_request_id: Some(RequestId(5)), - subscriber_priority: Some(200), - forward: Some(true), - filter: Some(Filter::NextObject), - authorization_token: None, - fill: None, - }; - - let encoded = encode_message(&msg, Version::Draft15); - let decoded: SubscribeUpdate = decode_message(&encoded, Version::Draft15).unwrap(); - - assert_eq!(decoded.request_id, RequestId(10)); - assert_eq!(decoded.subscription_request_id, Some(RequestId(5))); - assert_eq!(decoded.subscriber_priority, Some(200)); - assert_eq!(decoded.forward, Some(true)); - } - - #[test] - fn test_subscribe_update_v14_round_trip() { - let msg = SubscribeUpdate { - new_group: None, - max_age: None, - request_id: RequestId(10), - subscription_request_id: Some(RequestId(5)), - start_location: Location { group: 1, object: 2 }, - end_group: 100, - subscriber_priority: Some(200), - forward: Some(true), - filter: Some(Filter::NextObject), - authorization_token: None, - fill: None, - }; - - let encoded = encode_message(&msg, Version::Draft14); - let decoded: SubscribeUpdate = decode_message(&encoded, Version::Draft14).unwrap(); - - assert_eq!(decoded.request_id, RequestId(10)); - assert_eq!(decoded.subscription_request_id, Some(RequestId(5))); - assert_eq!(decoded.start_location, Location { group: 1, object: 2 }); - assert_eq!(decoded.end_group, 100); - assert_eq!(decoded.subscriber_priority, Some(200)); - assert_eq!(decoded.forward, Some(true)); - } - - #[test] - fn test_subscribe_ok_ignores_expires_v14() { - #[rustfmt::skip] - let bytes = [ - 0x01, // request_id - 0x00, // track_alias - 0x05, // expires = 5 - 0x02, // group_order - 0x00, // content_exists - 0x00, // num_params - ]; - - let decoded: SubscribeOk = decode_message(&bytes, Version::Draft14).unwrap(); - assert_eq!(decoded.request_id, Some(RequestId(1))); - } - - /// The SUBSCRIBE_OK aiomoqt 0.11.0 sends: EXPIRES = 0 and nothing else (#4172). - #[test] - fn test_subscribe_ok_ignores_expires_aiomoqt() { - let bytes = [0x03, 0x00, 0x01, 0x08, 0x00]; - - let decoded: SubscribeOk = decode_message(&bytes, Version::Draft16).unwrap(); - assert_eq!(decoded.request_id, Some(RequestId(3))); - assert_eq!(decoded.track_alias, 0); - assert!(decoded.largest.is_none()); - } - - /// The SUBSCRIBE_OK a libquicr relay sends: EXPIRES = 0 followed by five track - /// properties (#4172). - #[test] - fn test_subscribe_ok_ignores_expires_libquicr() { - let bytes = [ - 0x02, 0xde, 0x53, 0x15, 0xbf, 0xd6, 0x39, 0x31, 0x88, 0x01, 0x08, 0x00, 0x02, 0x00, 0x02, 0x00, 0x0a, 0x01, - 0x14, 0x01, 0x0e, 0x01, - ]; - - let decoded: SubscribeOk = decode_message(&bytes, Version::Draft16).unwrap(); - assert_eq!(decoded.request_id, Some(RequestId(2))); - assert_eq!(decoded.properties.priority, Some(1)); - assert_eq!(decoded.properties.group_order, Some(GroupOrder::Ascending)); - } - - #[test] - fn test_subscribe_v17_round_trip() { - let msg = Subscribe { - new_group: None, - max_age: None, - request_id: RequestId(1), - track_namespace: Path::new("test"), - track_name: "video".into(), - subscriber_priority: 128, - group_order: GroupOrder::Descending, - filter: Filter::NextObject, - fill: None, - properties_wanted: true, - forward: true, - rendezvous: false, - range_filters: false, - authorization_token: None, - epoch: None, - }; - - let encoded = encode_message(&msg, Version::Draft17); - let decoded: Subscribe = decode_message(&encoded, Version::Draft17).unwrap(); - - assert_eq!(decoded.request_id, RequestId(1)); - assert_eq!(decoded.track_namespace.as_str(), "test"); - assert_eq!(decoded.track_name, "video"); - assert_eq!(decoded.subscriber_priority, 128); - } - - #[test] - fn test_subscribe_ok_v17_round_trip() { - let msg = SubscribeOk { - track_alias: 42, - largest: None, - properties: Properties::default(), - }; - - let encoded = encode_message(&msg, Version::Draft17); - let decoded: SubscribeOk = decode_message(&encoded, Version::Draft17).unwrap(); - - assert_eq!(decoded.request_id, None); - assert_eq!(decoded.track_alias, 42); - } - - #[test] - fn test_subscribe_update_v17_round_trip() { - let msg = SubscribeUpdate { - new_group: None, - max_age: None, - request_id: RequestId(10), - subscriber_priority: Some(200), - forward: Some(true), - filter: Some(Filter::NextObject), - authorization_token: None, - fill: None, - }; - - let encoded = encode_message(&msg, Version::Draft17); - let decoded: SubscribeUpdate = decode_message(&encoded, Version::Draft17).unwrap(); - - assert_eq!(decoded.request_id, RequestId(10)); - assert_eq!(decoded.subscription_request_id, None); - assert_eq!(decoded.subscriber_priority, Some(200)); - assert_eq!(decoded.forward, Some(true)); - } - #[test] fn test_subscribe_v18_round_trip() { let msg = Subscribe { @@ -1027,7 +760,6 @@ mod tests { let encoded = encode_message(&msg, Version::Draft18); let decoded: SubscribeOk = decode_message(&encoded, Version::Draft18).unwrap(); - assert_eq!(decoded.request_id, None); assert_eq!(decoded.track_alias, 42); } @@ -1094,96 +826,6 @@ mod tests { assert_eq!(decoded.properties.group_order, Some(GroupOrder::Descending)); } - /// Draft-15 is the one version that takes it as a message parameter, and has no track - /// properties to put it in. - #[test] - fn test_subscribe_ok_v15_group_order_is_a_parameter() { - let msg = SubscribeOk { - track_alias: 42, - largest: None, - properties: Properties { - unknown: Default::default(), - dynamic_groups: false, - compress: false, - max_cache_duration: None, - timescale: None, - priority: None, - group_order: Some(GroupOrder::Descending), - }, - }; - - #[rustfmt::skip] - let expected = vec![ - 7, // request id - 42, // track alias - 1, // one message parameter - 0x22, // GROUP_ORDER - 0x02, // descending - ]; - assert_eq!(encode_message(&msg, Version::Draft15), expected); - - let decoded: SubscribeOk = decode_message(&expected, Version::Draft15).unwrap(); - assert_eq!(decoded.properties.group_order, Some(GroupOrder::Descending)); - } - - /// Draft-15 has no properties block, so DYNAMIC_GROUPS is a SUBSCRIBE_OK parameter. - #[test] - fn test_subscribe_ok_v15_dynamic_groups_is_a_parameter() { - let msg = SubscribeOk { - track_alias: 42, - largest: None, - properties: Properties { - dynamic_groups: true, - compress: false, - ..Default::default() - }, - }; - - #[rustfmt::skip] - let expected = vec![ - 7, // request id - 42, // track alias - 1, // one message parameter - 0x30, // DYNAMIC_GROUPS - 0x01, - ]; - assert_eq!(encode_message(&msg, Version::Draft15), expected); - assert!( - decode_message::(&expected, Version::Draft15) - .unwrap() - .properties - .dynamic_groups - ); - - // A boolean: anything above 1 is malformed. - let malformed = [7, 42, 1, 0x30, 0x02]; - assert!(decode_message::(&malformed, Version::Draft15).is_err()); - } - - /// Draft-16 has the block too, under the name Track Extensions. We don't write one there, - /// but a peer that does used to fail the whole message as `Long`. - #[test] - fn test_subscribe_ok_v16_reads_track_extensions() { - #[rustfmt::skip] - let body = vec![ - 7, // request id - 42, // track alias - 0, // zero message parameters - 0x22, // DEFAULT_PUBLISHER_GROUP_ORDER - 0x02, // descending - ]; - - // Go through the size-prefixed path: that's what rejects unread trailing bytes. - let mut buf = Vec::new(); - Encoder::new(&mut buf, Version::Draft16.into()).u16(body.len() as u16); - buf.extend_from_slice(&body); - - let mut bytes = bytes::Bytes::from(buf); - let decoded = crate::coding::decode_buf(&mut bytes, SubscribeOk::decode).unwrap(); - assert_eq!(decoded.track_alias, 42); - assert_eq!(decoded.properties.group_order, Some(GroupOrder::Descending)); - } - /// GROUP_ORDER left SUBSCRIBE_OK after draft-15. Draft-18 closes the session when a /// known parameter shows up on a message that does not define it. #[test] @@ -1218,33 +860,10 @@ mod tests { let decoded: SubscribeUpdate = decode_message(&encoded, Version::Draft18).unwrap(); assert_eq!(decoded.request_id, RequestId(10)); - assert_eq!(decoded.subscription_request_id, None); assert_eq!(decoded.subscriber_priority, Some(200)); assert_eq!(decoded.forward, Some(true)); } - /// Cross-check: draft-17 emits an extra 0-byte (required_request_id_delta) that - /// draft-18 does not. So a draft-18 encoding should be exactly 1 byte shorter - /// than draft-17 for SUBSCRIBE_UPDATE. - #[test] - fn test_subscribe_update_v17_v18_size_differs() { - let v17_msg = SubscribeUpdate { - new_group: None, - max_age: None, - request_id: RequestId(10), - subscriber_priority: Some(200), - forward: Some(true), - filter: Some(Filter::NextObject), - authorization_token: None, - fill: None, - }; - let v18_msg = SubscribeUpdate { ..v17_msg.clone() }; - - let v17 = encode_message(&v17_msg, Version::Draft17); - let v18 = encode_message(&v18_msg, Version::Draft18); - assert_eq!(v17.len(), v18.len() + 1); - } - /// The head of a SUBSCRIBE (draft-20 Figure 10) up to its Number of Parameters: /// Request ID 1, Track Namespace ("live"), Track Name ("video"). Every value is /// below 128, so each varint is one byte in the drafts before and after 17 alike. @@ -1396,29 +1015,19 @@ mod tests { Version::Draft19, Version::Draft20, ] { - let mut body = body.clone(); - let wire = body; + let wire = body.clone(); let mut buf = Decoder::new(&wire, version.into()); Subscribe::decode_msg(&mut buf, version).unwrap_or_else(|e| panic!("{version}: {e}")); assert!(buf.is_empty(), "{version}: trailing bytes"); } } - /// Draft-15 ignores a parameter it does not know. From draft-16 on, a parameter from - /// a later draft is unknown, which closes the session. - #[test] - fn subscribe_ignores_unrecognized_parameters_in_draft15() { - let body = subscribe_body(&[0x01, 0x32, 0x00]); - decode_message::(&body, Version::Draft15).expect("draft-15 ignores NEW_GROUP_REQUEST"); - } - /// A parameter from a later draft is still an unknown parameter, which the draft makes /// a protocol violation. #[test] fn subscribe_refuses_parameters_before_their_draft() { for (version, params) in [ - // SUBGROUP_DELIVERY_TIMEOUT arrived in draft-18, and 0x06 is not a draft-16 id. - (Version::Draft16, &[0x01, 0x06, 0x00][..]), + // SUBGROUP_DELIVERY_TIMEOUT arrived in draft-18, // The Range Filters arrived in draft-19. (Version::Draft18, &[0x01, 0x25, 0x00][..]), // INCLUDE_PROPERTIES arrived in draft-20. @@ -1450,22 +1059,17 @@ mod tests { assert_eq!(decoded.request_id, RequestId(2)); } - /// SUBGROUP_DELIVERY_TIMEOUT (0x06) is not a draft-16 parameter. Draft-18 defines it - /// for SUBSCRIBE, and the value is dropped. + /// Draft-18 defines SUBGROUP_DELIVERY_TIMEOUT (0x06) for SUBSCRIBE, and the value is + /// dropped. #[test] fn subgroup_delivery_timeout_follows_its_draft() { let head: &[u8] = &[ 0x01, 0x01, 0x04, b'l', b'i', b'v', b'e', 0x05, b'v', b'i', b'd', b'e', b'o', ]; let body = [head, &[0x01, 0x06, 0x00][..]].concat(); - assert!(decode_message::(&body, Version::Draft16).is_err()); decode_message::(&body, Version::Draft18).expect("draft-18 accepts SUBGROUP_DELIVERY_TIMEOUT"); - // GROUP_ORDER (0x22) is known in draft-16 but not defined for REQUEST_UPDATE. - // Request ID, Subscription Request ID, one parameter, absolute key, varint value. - let update16: &[u8] = &[0x02, 0x0A, 0x01, 0x22, 0x02]; - decode_message::(update16, Version::Draft16).expect("draft-16 ignores GROUP_ORDER"); - // Draft-18 has no Subscription Request ID. The value is a uint8. + // GROUP_ORDER (0x22) is not defined for REQUEST_UPDATE. let update18: &[u8] = &[0x02, 0x01, 0x22, 0x02]; assert!(decode_message::(update18, Version::Draft18).is_err()); } @@ -1499,7 +1103,7 @@ mod cache_duration_tests { } #[test] - fn legacy_never_sends_cache_duration_and_modern_preserves_optional_value() { + fn cache_duration_preserves_optional_value() { for version in [ Version::Draft18, Version::Draft19, @@ -1507,10 +1111,8 @@ mod cache_duration_tests { Version::Draft21, Version::Draft22, ] { - let legacy = false; for age in [None, Some(Duration::ZERO), Some(Duration::from_secs(30))] { let ok = SubscribeOk { - request_id: legacy.then_some(RequestId(0)), track_alias: 0, largest: None, properties: Properties { @@ -1524,7 +1126,7 @@ mod cache_duration_tests { let got = crate::coding::decode_buf(&mut payload.as_slice(), version, SubscribeOk::decode_msg).unwrap(); assert_eq!( got.properties.max_cache_duration, - if legacy { None } else { age }, + age, "{version}" ); } diff --git a/rs/moq-net/src/ietf/subscribe_tracks.rs b/rs/moq-net/src/ietf/subscribe_tracks.rs index bfbb7db5610..2a886aa699e 100644 --- a/rs/moq-net/src/ietf/subscribe_tracks.rs +++ b/rs/moq-net/src/ietf/subscribe_tracks.rs @@ -280,7 +280,7 @@ mod tests { #[test] fn subscribe_tracks_starts_at_draft_18() { let mut buf = Vec::new(); - let version = Version::Draft17; + let version = Version::Draft18; assert!( paused() .encode_msg(&mut Encoder::new(&mut buf, version.into()), version) diff --git a/rs/moq-net/src/ietf/subscriber.rs b/rs/moq-net/src/ietf/subscriber.rs index b195f174785..dec647e1081 100644 --- a/rs/moq-net/src/ietf/subscriber.rs +++ b/rs/moq-net/src/ietf/subscriber.rs @@ -5657,39 +5657,6 @@ mod tests { } } - /// Draft-14 frames a fetch object's properties with a bare length, which is refused at - /// the prefix rather than buffered while the peer trickles the rest in. - #[moq_clock::test] - async fn draft14_fetch_properties_are_capped() { - use crate::lite::test_transport::ScriptedSession; - use crate::transport::poll::Session as _; - use futures::FutureExt as _; - - const VERSION: Version = Version::Draft14; - let mut wire = Vec::new(); - for field in [0u64, 0, 0] { - crate::coding::Encoder::new(&mut wire, VERSION.into()) - .varint(field) - .unwrap(); - } - wire.push(0); - crate::coding::Encoder::new(&mut wire, VERSION.into()) - .varint((super::super::group::MAX_OBJECT_EXTENSIONS + 1) as u64) - .unwrap(); - - let mut session = ScriptedSession::new(wire); - let (_, recv) = session.open_bi(Default::default()).await.unwrap(); - let mut reader = Reader::new(crate::transport::boxed::RecvStream::new(recv), VERSION); - let result = decode_fetch_object(&mut reader, true) - .now_or_never() - .expect("refused at the prefix, not parked on the body"); - assert!( - matches!(result, Err(Error::Decode(DecodeError::MessageTooLarge { .. }))), - "{:?}", - result.err() - ); - } - fn fin_responses(clean: bool) -> Vec { use crate::coding::Encode; let mut responses = Vec::new(); @@ -5818,7 +5785,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin, - Control::new(None, false), + Control::new(false), None, peer_setup, crate::Hop::new(1).unwrap(), @@ -5837,7 +5804,7 @@ mod tests { async fn an_announce_to_a_side_that_declined_solicit_is_fine() { for solicit in [Some(true), Some(false), None] { assert!( - !unsolicited_is_a_violation_to(false, solicit, Version::Draft17), + !unsolicited_is_a_violation_to(false, solicit, Version::Draft18), "{solicit:?}" ); } @@ -5852,11 +5819,11 @@ mod tests { #[moq_clock::test] async fn an_announce_from_a_peer_that_implements_solicit_is_fatal() { assert!( - unsolicited_is_a_violation(Some(true), Version::Draft17), + unsolicited_is_a_violation(Some(true), Version::Draft18), "a peer that requires solicitation itself" ); assert!( - unsolicited_is_a_violation(Some(false), Version::Draft17), + unsolicited_is_a_violation(Some(false), Version::Draft18), "an explicit 0 declares support, so ours binds it too" ); } @@ -5866,20 +5833,7 @@ mod tests { /// happens when nobody does. #[moq_clock::test] async fn an_announce_from_a_peer_that_declared_nothing_is_fine() { - assert!(!unsolicited_is_a_violation(None, Version::Draft17)); - } - - /// Draft-14/15 have no inline NAMESPACE, so a PUBLISH_NAMESPACE request is also how a - /// peer answers our own SUBSCRIBE_NAMESPACE. The message cannot say which it is, so - /// nothing there is enforceable: our own publisher advertises exactly this way. - #[moq_clock::test] - async fn a_legacy_announce_is_never_a_violation() { - for version in [Version::Draft15] { - assert!( - !unsolicited_is_a_violation(Some(true), version), - "{version:?} answers a subscription this way" - ); - } + assert!(!unsolicited_is_a_violation(None, Version::Draft18)); } /// A rooted subscriber asks the peer for its permitted SCOPE. The root names where @@ -5903,11 +5857,12 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), scoped, - Control::new(None, false), + Control::new(false), None, peer_setup, crate::Hop::new(1).unwrap(), None, + Version::Draft18, tasks, Default::default(), ); @@ -5921,7 +5876,7 @@ mod tests { let prefix = namespaces.pop().unwrap(); let (_live, live) = live(); - let stream = Stream::open(&mut crate::driver::Transport::new(session.clone()), Version::Draft16) + let stream = Stream::open(&mut crate::driver::Transport::new(session.clone()), Version::Draft18) .await .unwrap(); let mut run = @@ -5989,7 +5944,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), scoped, - Control::new(None, false), + Control::new(false), None, peer_setup, crate::Hop::new(1).unwrap(), @@ -6089,7 +6044,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin, - Control::new(None, false), + Control::new(false), None, peer_setup, us, @@ -6183,7 +6138,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin, - Control::new(None, false), + Control::new(false), None, peer_setup, us, @@ -6252,7 +6207,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin, - Control::new(None, false), + Control::new(false), None, peer_setup, crate::Hop::new(1).unwrap(), @@ -6344,7 +6299,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin, - Control::new(None, false), + Control::new(false), None, peer_setup, crate::Hop::new(1).unwrap(), @@ -6524,7 +6479,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(crate::lite::test_transport::SinkSession::new(Default::default())), crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(), - Control::new(None, false), + Control::new(false), None, peer::PeerSetup::default(), crate::Hop::new(1).unwrap(), @@ -6739,33 +6694,13 @@ mod tests { } } - /// Draft-14 through 16 have an UNSUBSCRIBE message, and draft-16 section 5.1.1 makes it - /// the thing that lets the publisher destroy the subscription. Resetting the stream - /// without it leaves a peer that predates draft-17 serving the track forever. - #[moq_clock::test] - async fn a_legacy_cancel_sends_unsubscribe() { - let log = cancel_a_subscription(Version::Draft16).await; - assert!( - occurrences(&log, &[ietf::Unsubscribe::ID as u8]) > 0, - "draft-16 cancels with UNSUBSCRIBE", - ); - - // Draft-17 removed the message, so sending one would be a protocol violation. - let log = cancel_a_subscription(Version::Draft19).await; - assert_eq!( - occurrences(&log, &[ietf::Unsubscribe::ID as u8]), - 0, - "draft-17+ has no UNSUBSCRIBE", - ); - } - /// A rejection and the last consumer leaving can both be ready when the task is next /// polled. The publisher destroyed the request when it sent the error, so treating that /// as abandonment would cancel a request that no longer exists and name a dead id back at /// a peer entitled to object. The answer wins. #[moq_clock::test] async fn a_ready_rejection_beats_local_abandonment() { - const VERSION: Version = Version::Draft16; + const VERSION: Version = Version::Draft18; // A peer that rejects the subscribe outright. let rejection = { @@ -6796,7 +6731,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(), - Control::new(None, false), + Control::new(false), None, peer::PeerSetup::declared(peer::Peer::default()), crate::Hop::new(1).unwrap(), @@ -6832,8 +6767,8 @@ mod tests { .unwrap(); assert!( - !control_message_types(&log, VERSION).contains(&ietf::Unsubscribe::ID), - "a rejected request is already gone; cancelling it names a dead id at the peer", + log.stops().is_empty(), + "a rejected request is already gone; there is nothing to cancel", ); } @@ -6859,7 +6794,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(), - Control::new(None, false), + Control::new(false), None, peer::PeerSetup::default(), crate::Hop::new(1).unwrap(), @@ -6876,7 +6811,7 @@ mod tests { /// its task and track until a token that may never be answered. #[moq_clock::test] async fn an_abandoned_subscribe_stops_waiting_for_auth() { - const VERSION: Version = Version::Draft16; + const VERSION: Version = Version::Draft18; let (mut subscriber, log, _auth, _tokens, _task_set) = waiting_on_auth(VERSION); let producer = crate::broadcast::Info::default().produce(); @@ -6915,7 +6850,7 @@ mod tests { /// ends, judged against the union as it stands, so routing can recover. #[moq_clock::test] async fn a_withdrawn_route_ends_a_subscribe_waiting_for_auth() { - const VERSION: Version = Version::Draft16; + const VERSION: Version = Version::Draft18; let (mut subscriber, log, _auth, _tokens, _task_set) = waiting_on_auth(VERSION); let producer = crate::broadcast::Info::default().produce(); @@ -6957,7 +6892,7 @@ mod tests { /// serving a track nobody reads. #[moq_clock::test] async fn abandoning_before_subscribe_ok_still_cancels() { - const VERSION: Version = Version::Draft16; + const VERSION: Version = Version::Draft18; // A peer that accepts the stream and then says nothing at all. let session = crate::lite::test_transport::ScriptedSession::new(Vec::new()); @@ -6968,7 +6903,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(), - Control::new(None, false), + Control::new(false), None, peer::PeerSetup::declared(peer::Peer::default()), crate::Hop::new(1).unwrap(), @@ -7005,14 +6940,10 @@ mod tests { .expect("run_subscribe parked waiting for a response that never came") .unwrap(); - assert!( - occurrences(&log, &[ietf::Unsubscribe::ID as u8]) > 0, - "a subscribe abandoned before SUBSCRIBE_OK must still be cancelled", - ); assert_eq!( log.stops(), vec![crate::ietf::error::CANCELLED], - "and must stop the direction the publisher writes", + "a subscribe abandoned before SUBSCRIBE_OK must still be cancelled", ); } @@ -7025,70 +6956,6 @@ mod tests { (auth, cred) } - /// A grant revoked while the SUBSCRIBE waits for request-ID credit refuses the request - /// at once, not after the ten-second give-up. - #[moq_clock::test] - async fn a_revocation_never_waits_behind_subscribe_credit() { - for version in [Version::Draft15] { - // MAX_REQUEST_ID admits nothing, so the SUBSCRIBE waits for credit. - let session = crate::lite::test_transport::ScriptedSession::new(Vec::new()); - let log = session.log.clone(); - let (tasks, _task_set) = crate::util::TaskSet::new(); - let (auth, _cred) = revocable_auth(); - let mut subscriber = Subscriber::new( - crate::time::sim(), - crate::driver::Transport::new(session.clone()), - crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(), - Control::new(Some(RequestId(1)), false), - None, - peer::PeerSetup::declared(peer::Peer::default()), - crate::Hop::new(1).unwrap(), - None, - version, - tasks, - Default::default(), - ) - .with_auth(auth.clone()); - - let producer = crate::broadcast::Info::default().produce(); - let mut dynamic = producer.dynamic(); - let consumer = producer.consume(); - let track = consumer.track("video").unwrap(); - let subscription = track.subscribe(None); - let request = dynamic.requested_track().await.expect("no track requested"); - - let serving = moq_clock::sim::spawn(async move { - subscriber - .run_subscribe(Path::new("broadcast"), dynamic, None, request) - .await; - }); - settle().await; - assert!( - log.writes.lock().unwrap().is_empty(), - "{version}: a SUBSCRIBE went out without credit" - ); - - auth.ended(0, Error::Session(SessionError::Unauthorized)); - let result = moq_clock::timeout(Duration::from_secs(1), subscription) - .await - .unwrap_or_else(|_| panic!("{version}: the revocation waited behind the credit")); - assert!( - matches!(result, Err(Error::Unauthorized)), - "{version}: the request outlived its grant: {:?}", - result.err() - ); - moq_clock::timeout(Duration::from_secs(1), serving) - .await - .unwrap_or_else(|_| panic!("{version}: run_subscribe outlived its grant")) - .unwrap(); - assert!( - log.writes.lock().unwrap().is_empty(), - "{version}: nothing was sent without credit" - ); - assert!(log.closes().is_empty(), "{version}: the session stays up"); - } - } - /// A grant revoked while the SUBSCRIBE waits for its answer refuses the request and /// cancels the subscribe at once, not once the peer answers or acknowledges the cancel. #[moq_clock::test] @@ -7104,7 +6971,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(), - Control::new(None, false), + Control::new(false), None, peer::PeerSetup::declared(peer::Peer::default()), crate::Hop::new(1).unwrap(), @@ -7121,7 +6988,6 @@ mod tests { let track = consumer.track("video").unwrap(); let subscription = track.subscribe(None); let request = dynamic.requested_track().await.expect("no track requested"); - let unsubscribes = subscriber.unsubscribes(); let serving = moq_clock::sim::spawn(async move { subscriber @@ -7144,11 +7010,8 @@ mod tests { // Only the wire cleanup still waits on the peer's acknowledgement. settle().await; drop(serving); - // A subscribe revoked before SUBSCRIBE_OK must still be cancelled: by UNSUBSCRIBE - // where the draft has one, and by stopping the publisher's direction on every draft. - if unsubscribes { - assert!(occurrences(&log, &[ietf::Unsubscribe::ID as u8]) > 0, "{version}"); - } + // A subscribe revoked before SUBSCRIBE_OK must still be cancelled, by stopping the + // publisher's direction. assert_eq!(log.stops(), vec![crate::ietf::error::CANCELLED], "{version}"); assert!(log.closes().is_empty(), "{version}: the session stays up"); } @@ -7158,7 +7021,7 @@ mod tests { /// Retiring its source cancels it even while the caller keeps its demand. #[moq_clock::test] async fn a_retirement_before_subscribe_ok_refuses_the_subscription() { - const VERSION: Version = Version::Draft16; + const VERSION: Version = Version::Draft18; // A peer that accepts the stream and then says nothing at all. let session = crate::lite::test_transport::ScriptedSession::new(Vec::new()); @@ -7169,7 +7032,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(), - Control::new(None, false), + Control::new(false), None, peer::PeerSetup::declared(peer::Peer::default()), crate::Hop::new(1).unwrap(), @@ -7201,7 +7064,6 @@ mod tests { drop(route); serving.await.unwrap(); assert!(matches!(subscription.await, Err(Error::Unroutable))); - assert!(occurrences(&log, &[ietf::Unsubscribe::ID as u8]) > 0); assert_eq!(log.stops(), vec![crate::ietf::error::CANCELLED]); } @@ -7209,10 +7071,8 @@ mod tests { enum SetupWait { SubscribeOpen, StatusOpen, - StatusCredit, StatusResponse, FetchOpen, - FetchCredit, FetchResponse, } @@ -7224,14 +7084,13 @@ mod tests { Expired, } - /// Drive each setup wait without credit or an answer. Refusal must be local even + /// Drive each setup wait without an open stream or an answer. Refusal must be local even /// when the peer never acknowledges the cancellation's FIN. async fn invalid_setup(stage: SetupWait, version: Version, cause: Invalidated) { let opening = matches!( stage, SetupWait::SubscribeOpen | SetupWait::StatusOpen | SetupWait::FetchOpen ); - let credit = matches!(stage, SetupWait::StatusCredit | SetupWait::FetchCredit); let open = kio::Producer::new(false); let session = if opening { crate::lite::test_transport::ScriptedSession::gated_open(Vec::new(), open.consume()) @@ -7241,7 +7100,7 @@ mod tests { let log = session.log.clone(); let (tasks, _task_set) = TaskSet::new(); let (auth, _cred) = revocable_auth(); - let control = Control::new(credit.then_some(RequestId(1)), false); + let control = Control::new(false); let mut subscriber = Subscriber::new( crate::time::sim(), crate::driver::Transport::new(session.clone()), @@ -7290,7 +7149,7 @@ mod tests { .is_none() ); }), - SetupWait::StatusOpen | SetupWait::StatusCredit | SetupWait::StatusResponse => Box::pin(async { + SetupWait::StatusOpen | SetupWait::StatusResponse => Box::pin(async { assert!( subscriber .track_status(&Path::new("broadcast"), "video", request, &mut gate) @@ -7316,7 +7175,7 @@ mod tests { }; let mut work = work; assert!(futures::poll!(work.as_mut()).is_pending(), "{stage:?}/{version}"); - if opening || credit { + if opening { assert!(log.writes.lock().unwrap().is_empty()); } let expected = match cause { @@ -7358,7 +7217,7 @@ mod tests { ), "{stage:?}/{version}/{cause:?}: {result:?}" ); - if opening || credit { + if opening { assert!(done, "{stage:?}/{version}/{cause:?}: cancelled wait stayed alive"); assert!(log.writes.lock().unwrap().is_empty()); } else { @@ -7371,7 +7230,7 @@ mod tests { drop(work); if opening { assert_eq!( - control.next_request_id(&subscriber.runtime).await.unwrap(), + control.next_request_id(), RequestId(1), "cancelled open spends no ID" ); @@ -7402,7 +7261,6 @@ mod tests { StatusOpen, [Draft22] ); - setup_wait_test!(invalid_status_credit_is_refused, StatusCredit, [Draft16]); setup_wait_test!( invalid_status_response_is_refused, StatusResponse, @@ -7413,125 +7271,12 @@ mod tests { FetchOpen, [Draft22] ); - setup_wait_test!(invalid_fetch_credit_is_refused, FetchCredit, [Draft16]); setup_wait_test!( invalid_fetch_response_is_refused, FetchResponse, [Draft22] ); - #[derive(Clone, Copy, Debug)] - enum Allocated { - Subscribe, - TrackStatus, - GroupFetch, - } - - /// Drafts 14-16 return MAX_REQUEST_ID credit only for requests the peer receives, so a - /// source retiring after its request ID was allocated must still send that request, - /// then cancel it if the draft can. Skipping it would leak the credit for good. - #[moq_clock::test] - async fn a_retirement_after_allocation_still_sends_the_request() { - for version in [Version::Draft15] { - retirement_after_allocation(version).await; - } - } - - async fn retirement_after_allocation(version: Version) { - for kind in [Allocated::Subscribe, Allocated::TrackStatus, Allocated::GroupFetch] { - // Every request write parks until the gate opens, after the retirement. - let gate = kio::Producer::new(false); - let session = crate::lite::test_transport::SinkSession::gated_bi(gate.consume()); - let log = session.log.clone(); - let (tasks, _task_set) = crate::util::TaskSet::new(); - let mut subscriber = Subscriber::new( - crate::time::sim(), - crate::driver::Transport::new(session.clone()), - crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(), - Control::new(None, false), - None, - peer::PeerSetup::declared(peer::Peer::default()), - crate::Hop::new(1).unwrap(), - None, - version, - tasks, - Default::default(), - ); - let route = kio::Producer::new(()); - subscriber.validity = crate::model::broadcast::RequestValidity::token(Some(route.consume())); - - let producer = crate::broadcast::Info::default().produce(); - let mut dynamic = producer.dynamic(); - let consumer = producer.consume(); - let track = consumer.track("video").unwrap(); - let _subscription = track.subscribe(None); - let request = dynamic.requested_track().await.expect("no track requested"); - - let mut fetch = None; - let serving = match kind { - Allocated::Subscribe => moq_clock::sim::spawn(async move { - subscriber - .run_subscribe(Path::new("broadcast"), dynamic, None, request) - .await; - }), - Allocated::TrackStatus => moq_clock::sim::spawn(async move { - let mut gate = crate::auth::Gate::new( - subscriber.auth.clone(), - Path::new("broadcast").to_owned(), - crate::auth::Direction::Subscribe, - ); - assert!( - subscriber - .track_status(&Path::new("broadcast"), "video", request, &mut gate) - .await - .is_none() - ); - }), - Allocated::GroupFetch => { - let track = track::Producer::new( - std::sync::Arc::new(crate::broadcast::Info::default()), - "video", - track::Info::default().with_timescale(None), - ); - let requested = track.dynamic(); - let mut pending = Box::pin(track.consume().fetch_group(0, None)); - assert!(futures::poll!(pending.as_mut()).is_pending()); - let group = requested.requested_fill_group().await.expect("group request"); - fetch = Some((track, pending)); - moq_clock::sim::spawn(subscriber.run_group_fetch( - Path::new("broadcast").to_owned(), - "video".into(), - group, - None, - )) - } - }; - - // The ID is allocated and its request parked mid-write when the source retires. - settle().await; - drop(route); - settle().await; - let Ok(mut open) = gate.write() else { - panic!("gate closed") - }; - *open = true; - drop(open); - serving.await.unwrap(); - drop(fetch); - - let expected = match kind { - Allocated::Subscribe => vec![ietf::Subscribe::ID, ietf::Unsubscribe::ID], - Allocated::TrackStatus => vec![ietf::TrackStatus::ID], - Allocated::GroupFetch => vec![ietf::Fetch::ID, ietf::FetchCancel::ID], - }; - assert_eq!(control_message_types(&log, version), expected, "{kind:?}"); - } - } - - /// The control messages that actually reached the wire, by type id. - /// - /// Decoding the framing rather than scanning for a byte: a type id is one varint among - /// many, and a substring match would happily find one inside a length or a payload. fn control_message_types(log: &crate::lite::test_transport::Log, version: Version) -> Vec { let writes = log.writes.lock().unwrap().clone(); let mut buf = Decoder::new(&writes, version.into()); @@ -7553,260 +7298,12 @@ mod tests { types } - /// Drafts 14-16 carry every request over `ControlStreamAdapter`'s virtual streams, so a - /// cancellation only counts if it traverses the mux and reaches the real control stream - /// writer. A test that drives a direct stream proves the subscriber's own logic and - /// nothing about the path production takes: the virtual writer's reset is a no-op and - /// its close returns as soon as the bytes are queued, so an adapter that dropped them - /// would look identical. - #[moq_clock::test] - async fn a_legacy_cancel_reaches_the_control_stream() { - const VERSION: Version = Version::Draft16; - - // A peer that opens the control stream and then says nothing, so the subscribe is - // abandoned before it is accepted and cancelled from there. - let session = crate::lite::test_transport::ScriptedSession::new(Vec::new()); - let log = session.log.clone(); - - let control = Control::new(None, false); - let adapter = super::super::adapter::ControlStreamAdapter::new( - crate::driver::Transport::new(session.clone()), - control.clone(), - VERSION, - ); - - // The one real bidi everything is multiplexed onto. - let control_stream = Stream::open(&mut crate::driver::Transport::new(session.clone()), VERSION) - .await - .unwrap(); - let running = adapter.clone(); - let (_goaway_handle, goaway) = crate::goaway::Handle::new(true); - moq_clock::sim::spawn(async move { - let _ = running.run(control_stream.reader, control_stream.writer, goaway).await; - }); - - let (tasks, _task_set) = crate::util::TaskSet::new(); - let mut subscriber = Subscriber::new( - crate::time::sim(), - crate::driver::Transport::new(adapter), - crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(), - control, - None, - peer::PeerSetup::declared(peer::Peer::default()), - crate::Hop::new(1).unwrap(), - None, - VERSION, - tasks, - Default::default(), - ); - - let producer = crate::broadcast::Info::default().produce(); - let mut dynamic = producer.dynamic(); - let consumer = producer.consume(); - let track = consumer.track("video").unwrap(); - let subscription = track.subscribe(None); - - let request = dynamic.requested_track().await.expect("no track requested"); - - let serving = moq_clock::sim::spawn(async move { - subscriber - .run_subscribe(Path::new("broadcast"), dynamic, None, request) - .await; - }); - - settle().await; - drop(subscription); - drop(track); - drop(consumer); - - moq_clock::timeout(std::time::Duration::from_secs(1), serving) - .await - .expect("run_subscribe did not finish") - .unwrap(); - - // Let the adapter's writer task drain the queue onto the control stream. - settle().await; - - let types = control_message_types(&log, VERSION); - assert!( - types.contains(&ietf::Subscribe::ID), - "the SUBSCRIBE reached the control stream: {types:?}" - ); - assert!( - types.contains(&ietf::Unsubscribe::ID), - "the UNSUBSCRIBE must traverse the adapter to the control stream, not stop at the \ - virtual writer: {types:?}" - ); - } - - /// Draft-14's SUBSCRIBE_UPDATE has no optional fields, so a priority update repeats the - /// subscription's bounds: a Largest Object subscription starts just past the answer's - /// Largest, open ended. Zeroes would move the start back, which the draft forbids. - #[moq_clock::test] - async fn a_draft14_priority_update_repeats_the_bounds() { - const VERSION: Version = Version::Draft14; - - let subscribe_ok = message( - ietf::SubscribeOk::ID, - &ietf::SubscribeOk { - track_alias: 7, - largest: Some(ietf::Location { group: 5, object: 2 }), - properties: Default::default(), - }, - VERSION, - ); - let session = crate::lite::test_transport::ScriptedSession::new(subscribe_ok); - let log = session.log.clone(); - - let (tasks, _task_set) = crate::util::TaskSet::new(); - let mut subscriber = Subscriber::new( - crate::time::sim(), - crate::driver::Transport::new(session.clone()), - crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(), - Control::new(None, false), - None, - peer::PeerSetup::declared(peer::Peer::default()), - crate::Hop::new(1).unwrap(), - None, - VERSION, - tasks, - Default::default(), - ); - - let producer = crate::broadcast::Info::default().produce(); - let mut dynamic = producer.dynamic(); - let consumer = producer.consume(); - let track = consumer.track("video").unwrap(); - let _low = track.subscribe(track::Subscription::default().with_priority(1)); - let request = dynamic.requested_track().await.expect("no track requested"); - let _serving = moq_clock::sim::spawn(async move { - subscriber - .run_subscribe(Path::new("broadcast"), dynamic, None, request) - .await; - }); - settle().await; - - let _high = track.subscribe(track::Subscription::default().with_priority(72)); - settle().await; - - let writes = log.writes.lock().unwrap().clone(); - let mut buf = Decoder::new(&writes, VERSION.into()); - let (mut subscribe, mut updates) = (None, Vec::new()); - while !buf.is_empty() { - let type_id = buf.varint().unwrap(); - let size = buf.u16().unwrap() as usize; - let mut body = Decoder::new(buf.slice(size).unwrap(), VERSION.into()); - match type_id { - ietf::Subscribe::ID => subscribe = Some(RequestId::decode(&mut body, VERSION).unwrap()), - ietf::SubscribeUpdate::ID => { - updates.push(ietf::SubscribeUpdate::decode_msg(&mut body, VERSION).unwrap()) - } - _ => {} - } - } - - let [update] = updates.as_slice() else { - panic!("one update, not {updates:?}"); - }; - assert_eq!(update.subscription_request_id, subscribe); - assert_eq!(update.start_location, ietf::Location { group: 5, object: 3 }); - assert_eq!(update.end_group, 0, "still open ended"); - assert_eq!(update.subscriber_priority, Some(super::super::priority::to_wire(72))); - assert_eq!(update.forward, Some(true)); - } - - /// Draft-14's SUBSCRIBE_UPDATE cannot omit the priority, so an update for the max age - /// alone restates the unset priority in force instead of the omission default 128. - #[moq_clock::test] - async fn a_draft14_max_age_update_restates_the_priority() { - const VERSION: Version = Version::Draft14; - - let subscribe_ok = message( - ietf::SubscribeOk::ID, - &ietf::SubscribeOk { - track_alias: 7, - largest: None, - properties: Default::default(), - }, - VERSION, - ); - let session = crate::lite::test_transport::ScriptedSession::new(subscribe_ok); - let log = session.log.clone(); - - let (tasks, _task_set) = crate::util::TaskSet::new(); - let mut subscriber = Subscriber::new( - crate::time::sim(), - crate::driver::Transport::new(session), - crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(), - Control::new(None, false), - None, - peer::PeerSetup::declared(peer::Peer { - max_age: true, - ..Default::default() - }), - crate::Hop::new(1).unwrap(), - None, - VERSION, - tasks, - Default::default(), - ); - - let producer = crate::broadcast::Info::default().produce(); - let mut dynamic = producer.dynamic(); - let consumer = producer.consume(); - let track = consumer.track("video").unwrap(); - let _short = track.subscribe(track::Subscription::default().with_max_delay(Duration::from_secs(1))); - let request = dynamic.requested_track().await.expect("no track requested"); - let _serving = moq_clock::sim::spawn(async move { - subscriber - .run_subscribe(Path::new("broadcast"), dynamic, None, request) - .await; - }); - settle().await; - - let _long = track.subscribe(track::Subscription::default().with_max_delay(Duration::from_secs(5))); - settle().await; - - let writes = log.writes.lock().unwrap().clone(); - let mut buf = Decoder::new(&writes, VERSION.into()); - let mut updates = Vec::new(); - while !buf.is_empty() { - let type_id = buf.varint().unwrap(); - let size = buf.u16().unwrap() as usize; - let mut body = Decoder::new(buf.slice(size).unwrap(), VERSION.into()); - if type_id == ietf::SubscribeUpdate::ID { - updates.push(ietf::SubscribeUpdate::decode_msg(&mut body, VERSION).unwrap()); - } - } - - let [update] = updates.as_slice() else { - panic!("one update, not {updates:?}"); - }; - assert_eq!(update.max_age, Some(5_000)); - assert_eq!(update.subscriber_priority, Some(super::super::priority::to_wire(0))); - } - /// Establish a subscription on `version`, then drop its last consumer, and hand back /// what the session recorded on the way out. async fn cancel_a_subscription(version: Version) -> crate::lite::test_transport::Log { cancel_a_subscription_inner(version, false).await } - /// A publisher on draft-14 through 16 that legally hands a second subscription to one - /// track the alias the first already holds. We cannot demux that, so we walk away from - /// the new subscription. Those versions carry requests over the control stream adapter, - /// whose virtual streams drop silently, so UNSUBSCRIBE is the only way the publisher - /// ever learns to stop serving it. - #[moq_clock::test] - async fn a_legacy_shared_alias_is_unsubscribed() { - let log = cancel_a_subscription_inner(Version::Draft16, true).await; - - assert!( - occurrences(&log, &[ietf::Unsubscribe::ID as u8]) > 0, - "abandoning a shared alias must still tell the publisher to stop", - ); - } - /// Writing the UNSUBSCRIBE is not the same as delivering it. A stream that has only been /// finished is still retransmitting, so the writer's Drop reset would discard the message /// before the peer read it. Closing consumes the writer, which is what removes that @@ -7853,7 +7350,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(), - Control::new(None, false), + Control::new(false), None, peer::PeerSetup::declared(peer::Peer::default()), crate::Hop::new(1).unwrap(), @@ -7961,7 +7458,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(), - Control::new(None, false), + Control::new(false), None, peer::PeerSetup::declared(peer::Peer::default()), crate::Hop::new(1).unwrap(), @@ -8091,7 +7588,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(), - Control::new(None, false), + Control::new(false), None, peer::PeerSetup::declared(peer::Peer::default()), crate::Hop::new(2).unwrap(), @@ -8161,7 +7658,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(), - Control::new(None, false), + Control::new(false), None, peer::PeerSetup::declared(peer::Peer::default()), crate::Hop::new(1).unwrap(), @@ -8245,7 +7742,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(), - Control::new(None, false), + Control::new(false), None, peer::PeerSetup::declared(peer::Peer::default()), crate::Hop::new(1).unwrap(), @@ -8363,11 +7860,12 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin, - Control::new(None, false), + Control::new(false), None, peer::PeerSetup::default(), crate::Hop::new(1).unwrap(), None, + Version::Draft18, tasks, Default::default(), ); @@ -8420,11 +7918,12 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin, - Control::new(None, false), + Control::new(false), Some(assigned), peer::PeerSetup::default(), crate::Hop::new(1).unwrap(), None, + Version::Draft18, tasks, Default::default(), ); @@ -8480,11 +7979,12 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin, - Control::new(None, false), + Control::new(false), Some(peer), peer::PeerSetup::default(), self_origin, None, + Version::Draft18, tasks, Default::default(), ); @@ -8519,11 +8019,12 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(crate::lite::test_transport::SinkSession::new(Default::default())), origin.clone(), - Control::new(None, false), + Control::new(false), Some(peer), peer::PeerSetup::default(), self_origin, None, + Version::Draft18, tasks, Default::default(), ); @@ -8567,7 +8068,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin.clone(), - Control::new(None, false), + Control::new(false), None, peer::PeerSetup::default(), self_origin, @@ -8705,7 +8206,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin, - Control::new(None, false), + Control::new(false), None, peer_setup, crate::Hop::new(1).unwrap(), @@ -8795,7 +8296,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin, - Control::new(None, false), + Control::new(false), None, peer_setup, crate::Hop::new(1).unwrap(), @@ -8848,193 +8349,58 @@ mod tests { assert!( routed_now(&consumer, "room/host").is_none(), "an explicit NAMESPACE_DONE must retract the route", - ); - } - - #[moq_clock::test] - async fn publish_namespace_requester_fin_keeps_the_route() { - for version in [Version::Draft18, Version::Draft19, Version::Draft22] { - for reset in [false, true] { - let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let consumer = origin.consume(); - let session = if reset { - crate::lite::test_transport::ScriptedSession::per_stream_reset(vec![vec![]]) - } else { - crate::lite::test_transport::ScriptedSession::per_stream_eof(vec![vec![]]) - }; - let (tasks, _task_set) = crate::util::TaskSet::new(); - let mut subscriber = Subscriber::new( - crate::time::sim(), - crate::driver::Transport::new(session.clone()), - origin, - Control::new(None, false), - None, - peer::PeerSetup::default(), - crate::Hop::new(1).unwrap(), - None, - version, - tasks, - Default::default(), - ); - let stream = Stream::open(&mut crate::driver::Transport::new(session.clone()), version) - .await - .unwrap(); - let msg = ietf::PublishNamespace { - request_id: RequestId(0), - track_namespace: crate::Path::new("room/host"), - params: Default::default(), - authorization_token: None, - }; - let mut run = std::pin::pin!(subscriber.run_publish_namespace_stream( - stream, - msg, - cluster::Peer::default(), - None - )); - assert_eq!( - futures::poll!(run.as_mut()).is_ready(), - reset || super::super::request_stream::fin_cancels(version), - "{version}" - ); - if !reset && !super::super::request_stream::fin_cancels(version) { - assert!(routed_now(&consumer, "room/host").is_some(), "{version}"); - } - } - } - } - - /// v14-16 withdraw a PUBLISH_NAMESPACE with PUBLISH_NAMESPACE_DONE, which the adapter - /// delivers as a message before it FINs the virtual stream. Reading it as a stray - /// message closes the whole session over a routine unannounce. - #[moq_clock::test] - async fn a_publish_namespace_done_retracts_without_faulting_the_session() { - const VERSION: Version = Version::Draft14; - - let path = crate::Path::new("room/host").to_owned(); - let log = crate::lite::test_transport::Log::default(); - let mut writer = crate::coding::Writer::new( - crate::transport::boxed::SendStream::new(crate::lite::test_transport::SinkSend::new(log.clone())), - VERSION, - ); - writer - .encode_message(&ietf::PublishNamespaceDone { - track_namespace: path.borrow(), - request_id: RequestId(0), - }) - .await - .unwrap(); - let script = log.writes.lock().unwrap().clone(); - - let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let consumer = origin.consume(); - let session = crate::lite::test_transport::ScriptedSession::eof(script); - let (tasks, task_set) = crate::util::TaskSet::new(); - std::mem::forget(task_set); - let mut subscriber = Subscriber::new( - crate::time::sim(), - crate::driver::Transport::new(session.clone()), - origin, - Control::new(None, false), - None, - peer::PeerSetup::default(), - crate::Hop::new(1).unwrap(), - None, - VERSION, - tasks, - Default::default(), - ); - - let stream = Stream::open(&mut crate::driver::Transport::new(session.clone()), VERSION) - .await - .unwrap(); - let msg = ietf::PublishNamespace { - request_id: RequestId(0), - track_namespace: path.borrow(), - params: Default::default(), - authorization_token: None, - }; - subscriber - .run_publish_namespace_stream(stream, msg, cluster::Peer::default(), None) - .await - .expect("a withdrawal is not a protocol violation"); - settle().await; - - assert!( - routed_now(&consumer, "room/host").is_none(), - "an explicit withdrawal must close the broadcast", - ); - } - - /// Drafts 14 and 15 have no update for an advertisement, so a SUBSCRIBE_UPDATE the - /// adapter routes onto one changes nothing and leaves it standing until the withdrawal. - /// Draft 15 still owes the update an answer: a REQUEST_ERROR naming it. - #[moq_clock::test] - async fn a_legacy_update_on_an_advertisement_is_answered() { - for version in [Version::Draft15] { - let path = crate::Path::new("room/host").to_owned(); - // Own Request ID 10, aimed at the advertisement (0). Draft 14 carries its fixed - // start, end group, priority and forward before the parameters. - let body: &[u8] = &[10, 0, 0]; - let mut script = vec![ietf::SubscribeUpdate::ID as u8, 0, body.len() as u8]; - script.extend_from_slice(body); - let log = crate::lite::test_transport::Log::default(); - let mut writer = crate::coding::Writer::new( - crate::transport::boxed::SendStream::new(crate::lite::test_transport::SinkSend::new(log.clone())), - version, - ); - writer - .encode_message(&ietf::PublishNamespaceDone { - track_namespace: path.borrow(), - request_id: RequestId(0), - }) - .await - .unwrap(); - script.extend(log.writes.lock().unwrap().iter()); - - let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let session = crate::lite::test_transport::ScriptedSession::eof(script); - let (tasks, task_set) = crate::util::TaskSet::new(); - std::mem::forget(task_set); - let mut subscriber = Subscriber::new( - crate::time::sim(), - crate::driver::Transport::new(session.clone()), - origin, - Control::new(None, false), - None, - peer::PeerSetup::default(), - crate::Hop::new(1).unwrap(), - None, - version, - tasks, - Default::default(), - ); - - let stream = Stream::open(&mut crate::driver::Transport::new(session.clone()), version) - .await - .unwrap(); - let msg = ietf::PublishNamespace { - request_id: RequestId(0), - track_namespace: path.borrow(), - params: Default::default(), - authorization_token: None, - }; - subscriber - .run_publish_namespace_stream(stream, msg, cluster::Peer::default(), None) - .await - .unwrap_or_else(|err| panic!("{version}: {err}")); - - let written = session.log.writes.lock().unwrap().clone(); - let mut rest = written.as_slice(); - let mut sent = Vec::new(); - while !rest.is_empty() { - let id = crate::coding::decode_varint(&mut rest, version).unwrap(); - let len = usize::from(u16::from_be_bytes([rest[0], rest[1]])); - sent.push((id, rest.get(2).copied())); - rest = &rest[2 + len..]; + ); + } + + #[moq_clock::test] + async fn publish_namespace_requester_fin_keeps_the_route() { + for version in [Version::Draft18, Version::Draft19, Version::Draft22] { + for reset in [false, true] { + let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); + let consumer = origin.consume(); + let session = if reset { + crate::lite::test_transport::ScriptedSession::per_stream_reset(vec![vec![]]) + } else { + crate::lite::test_transport::ScriptedSession::per_stream_eof(vec![vec![]]) + }; + let (tasks, _task_set) = crate::util::TaskSet::new(); + let mut subscriber = Subscriber::new( + crate::time::sim(), + crate::driver::Transport::new(session.clone()), + origin, + Control::new(false), + None, + peer::PeerSetup::default(), + crate::Hop::new(1).unwrap(), + None, + version, + tasks, + Default::default(), + ); + let stream = Stream::open(&mut crate::driver::Transport::new(session.clone()), version) + .await + .unwrap(); + let msg = ietf::PublishNamespace { + request_id: RequestId(0), + track_namespace: crate::Path::new("room/host"), + params: Default::default(), + authorization_token: None, + }; + let mut run = std::pin::pin!(subscriber.run_publish_namespace_stream( + stream, + msg, + cluster::Peer::default(), + None + )); + assert_eq!( + futures::poll!(run.as_mut()).is_ready(), + reset || super::super::request_stream::fin_cancels(version), + "{version}" + ); + if !reset && !super::super::request_stream::fin_cancels(version) { + assert!(routed_now(&consumer, "room/host").is_some(), "{version}"); + } } - let expected = vec![(ietf::RequestOk::ID, Some(0)), (ietf::RequestError::ID, Some(10))]; - assert_eq!(sent, expected, "{version}"); - assert!(session.log.closes().is_empty(), "{version}: the session stays up"); } } @@ -9068,7 +8434,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin, - Control::new(None, false), + Control::new(false), None, peer::PeerSetup::default(), crate::Hop::new(1).unwrap(), @@ -9509,7 +8875,6 @@ mod tests { .encode(&ietf::PublishNamespaceUpdate { // Each update consumes a request id of the peer's parity. request_id: RequestId(3 + 2 * i as u64), - namespace_request_id: None, hops: Some(advert.hops.clone()), cost: Some(advert.cost), authorization_token: None, @@ -9551,7 +8916,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin, - Control::new(None, true), + Control::new(true), None, peer::PeerSetup::default(), self_origin, @@ -9643,7 +9008,7 @@ mod tests { let (mut subscriber, _consumer, mut stream, _driver, log) = update_harness(self_origin, &peer, &clean, script).await; // The initial request is already retired; its ID remains permanently spent. - assert!(subscriber.control.accept(RequestId(3)).unwrap().is_none()); + subscriber.control.accept(RequestId(3)).unwrap(); let mut attached = Some(0); let err = subscriber .run_publish_namespace_updates( @@ -9778,7 +9143,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin, - Control::new(None, true), + Control::new(true), None, peer::PeerSetup::default(), self_origin, @@ -9875,7 +9240,6 @@ mod tests { writer .encode(&ietf::PublishNamespaceUpdate { request_id: RequestId(3), - namespace_request_id: None, hops: None, cost: Some(0), authorization_token: None, @@ -10145,7 +9509,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin, - Control::new(None, false), + Control::new(false), None, peer::PeerSetup::default(), crate::Hop::new(1).unwrap(), @@ -10278,7 +9642,7 @@ mod tests { crate::driver::Transport::new(session.clone()), origin, // The announcing peer is the server here, so its update IDs are odd. - Control::new(None, true), + Control::new(true), None, peer_setup, crate::Hop::new(1).unwrap(), @@ -10329,7 +9693,6 @@ mod tests { ); let msg = ietf::PublishNamespaceUpdate { request_id: RequestId(3), - namespace_request_id: (false).then_some(RequestId(1)), hops: None, cost: None, authorization_token: Some(announce_token()), @@ -10349,7 +9712,6 @@ mod tests { ); let msg = ietf::PublishNamespaceUpdate { request_id: RequestId(3), - namespace_request_id: None, hops: Some(hop_path(&[7, 9])), cost: Some(0), authorization_token: Some(announce_token()), @@ -10481,57 +9843,6 @@ mod tests { } } - /// On drafts 14-16 the withdrawal arrives as a message before the FIN: a - /// PUBLISH_NAMESPACE_DONE waiting behind an unanswered verification ends the announce at - /// once, giving its slot back before the application ever takes the token. - #[moq_clock::test] - async fn a_legacy_withdrawal_during_verification_ends_the_announce() { - const VERSION: Version = Version::Draft16; - let done = { - let log = crate::lite::test_transport::Log::default(); - crate::coding::Writer::new( - crate::transport::boxed::SendStream::new(crate::lite::test_transport::SinkSend::new(log.clone())), - VERSION, - ) - .encode_message(&ietf::PublishNamespaceDone { - track_namespace: crate::Path::new("room/alice"), - request_id: RequestId(1), - }) - .await - .unwrap(); - log.writes.lock().unwrap().clone() - }; - // The application never takes the token, so only the withdrawal can end the wait. - let (mut subscriber, _requests, _cred, consumer, session) = auth_announce_harness(VERSION, done); - let stream = Stream::open(&mut crate::driver::Transport::new(session.clone()), VERSION) - .await - .unwrap(); - let mut run = std::pin::pin!(subscriber.run_publish_namespace_stream( - stream, - token_publish_namespace(), - cluster::Peer::default(), - None, - )); - - let mut result = None; - for _ in 0..100 { - if let Poll::Ready(res) = futures::poll!(run.as_mut()) { - result = Some(res); - break; - } - settle().await; - } - assert!( - matches!(result, Some(Ok(()))), - "a withdrawal during verification ends the announce: {result:?}" - ); - assert!( - routed_now(&consumer, "room/alice").is_none(), - "and it was never attached" - ); - assert!(session.log.closes().is_empty(), "the session stays up"); - } - /// A refused request token is answered UNAUTHORIZED and the announce is not attached; the /// session is untouched. #[moq_clock::test] @@ -11197,7 +10508,6 @@ mod tests { ); let msg = ietf::PublishNamespaceUpdate { request_id: RequestId(rid), - namespace_request_id: None, hops, cost, authorization_token: Some(announce_token()), @@ -11596,7 +10906,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin, - Control::new(None, false), + Control::new(false), None, peer_setup, crate::Hop::new(1).unwrap(), @@ -11774,7 +11084,6 @@ mod tests { writer .encode(&ietf::PublishNamespaceUpdate { request_id: RequestId(5), - namespace_request_id: None, hops: None, cost: None, authorization_token: None, @@ -11836,7 +11145,6 @@ mod tests { writer .encode(&ietf::PublishNamespaceUpdate { request_id: RequestId(5), - namespace_request_id: None, hops: None, cost: None, authorization_token: Some(crate::ietf::token::RequestToken(crate::setup::Token { @@ -12184,7 +11492,7 @@ mod filter_tests { ); } - const JOINING_DRAFTS: [Version; 6] = [ + const JOINING_DRAFTS: [Version; 2] = [ Version::Draft18, Version::Draft19, ]; @@ -12437,7 +11745,7 @@ mod stitch_tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), origin, - Control::new(None, false), + Control::new(false), None, peer::PeerSetup::default(), crate::Hop::new(1).unwrap(), @@ -12709,7 +12017,7 @@ mod stitch_tests { crate::time::sim(), crate::driver::Transport::new(downstream.clone()), served.consume(), - Control::new(None, false), + Control::new(false), None, peer, egress, @@ -13034,8 +12342,8 @@ mod stitch_tests { } } - /// Draft-15 on, only a Normal object may carry properties: a status object with them is - /// refused on ingest, and one relayed from draft-14 leaves without them. + /// Only a Normal object may carry properties: a status object with them is refused on + /// ingest. #[moq_clock::test] async fn passthrough_keeps_properties_off_status_objects() { for version in [Version::Draft22] { @@ -13051,48 +12359,6 @@ mod stitch_tests { ); } } - - // Draft-14 allows them, but END_OF_TRACK has nowhere to keep them: a standalone one - // is peeked before any group, and one after an object is ingested with the group. - let standalone: &[(u64, &[u8], Option)] = &[(0, &[0x20, 7], Some(END_OF_TRACK))]; - let trailing: &[(u64, &[u8], Option)] = &[(0, &[], None), (1, &[0x20, 7], Some(END_OF_TRACK))]; - for objects in [standalone, trailing] { - let script = object_stream(Version::Draft14, true, objects); - let mut h = Harness::with_timescale(Fill::Done, vec![script], None); - h.subscriber.version = Version::Draft14; - let mut stream = h.stream().await.with_version(Version::Draft14); - let result = h.subscriber.clone().recv_group(&mut stream).await; - assert!(matches!(result, Err(Error::Unsupported)), "{objects:?}: {result:?}"); - assert!( - matches!( - futures::FutureExt::now_or_never(h.track.closed()), - Some(Error::Unsupported) - ), - "{objects:?}: the subscription must end with the refusal" - ); - } - - let script = object_stream( - Version::Draft14, - true, - &[(0, &[], None), (1, &[0x20, 7], Some(END_OF_GROUP))], - ); - let (bytes, log) = relay_passthrough_stream(script, Version::Draft15).await; - assert!(log.resets().is_empty()); - let mut decoder = Decoder::new(&bytes, Version::Draft15.into()); - ietf::GroupHeader::decode(&mut decoder, Version::Draft15).unwrap(); - assert_eq!(decoder.varint().unwrap(), 0); - decoder.bytes().unwrap(); - assert_eq!(decoder.varint().unwrap(), 1); - assert_eq!(decoder.slice(1).unwrap(), &[99]); - assert_eq!(decoder.varint().unwrap(), 0); - assert!( - decoder.bytes().unwrap().is_empty(), - "the status object kept its properties" - ); - assert_eq!(decoder.varint().unwrap(), 0); - assert_eq!(decoder.varint().unwrap(), END_OF_GROUP); - assert!(decoder.is_empty()); } /// Draft-14 lets a status object carry properties, and it has no frame to hold its @@ -13102,7 +12368,7 @@ mod stitch_tests { async fn a_status_object_keeps_its_timestamp() { use futures::FutureExt; - let version = Version::Draft14; + let version = Version::Draft18; let status = [0x10, 7]; let leaves = |properties: &crate::model::object::Properties| { super::super::object::write(properties, Some(version), None, version, None).unwrap() @@ -13152,7 +12418,7 @@ mod stitch_tests { /// block leaves room for the Timestamp egress restates. #[moq_clock::test] async fn a_status_object_fills_the_whole_block() { - let version = Version::Draft14; + let version = Version::Draft18; let milli = Some(Timescale::MILLI); // A block of `size` held bytes: one opaque property, its key, a four-byte length, // then bytes. A framed object's list adds its Timestamp, which the frame holds. @@ -13348,18 +12614,18 @@ mod stitch_tests { } #[moq_clock::test] - async fn passthrough_preserves_immutable_bytes_and_refuses_incompatible_drafts() { + async fn passthrough_preserves_immutable_bytes() { for ingress in [ Version::Draft18, Version::Draft22, ] { let mut inner = Vec::new(); let mut encoder = Encoder::new(&mut inner, ingress.into()); - for value in [2u64, 96_000, if ingress == Version::Draft15 { 4 } else { 2 }, 128] { + for value in [2u64, 96_000, 128] { encoder.varint(value).unwrap(); } encoder - .varint(if ingress == Version::Draft15 { 5u64 } else { 1u64 }) + .varint(1u64) .unwrap(); encoder.bytes(&[42; 130]).unwrap(); let mut properties = Vec::new(); @@ -13372,10 +12638,6 @@ mod stitch_tests { ] { let script = object_stream(ingress, true, &[(0, &properties, None)]); let (bytes, log) = relay_passthrough_stream(script, ingress, egress).await; - if !super::super::object::same_bytes(ingress, egress) { - assert!(!log.resets().is_empty(), "incompatible immutable bytes must be refused"); - continue; - } assert!(log.resets().is_empty()); let mut decoder = Decoder::new(&bytes, egress.into()); ietf::GroupHeader::decode(&mut decoder, egress).unwrap(); @@ -13475,7 +12737,7 @@ mod stitch_tests { crate::time::sim(), crate::driver::Transport::new(downstream.clone()), served.consume(), - Control::new(None, false), + Control::new(false), None, peer, version, @@ -13534,103 +12796,6 @@ mod stitch_tests { } } - /// A status datagram's properties are stripped, not the datagram dropped, where the - /// egress draft forbids them beside a non-Normal status. - #[moq_clock::test] - async fn passthrough_strips_status_datagram_properties_a_draft_forbids() { - for ingress in [Version::Draft15] { - let egresses = [ - Version::Draft18, - Version::Draft19, - Version::Draft20, - Version::Draft21, - Version::Draft22, - ]; - let pairs = egresses - .into_iter() - .flat_map(|egress| [END_OF_GROUP, END_OF_TRACK].map(|status| (egress, status))); - for (egress, status) in pairs { - let origin = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); - let broadcast = origin.publish("room", crate::origin::Route::default()).unwrap(); - let track = broadcast - .create_track("video", accepted_info(&Default::default(), ingress)) - .unwrap(); - let mut h = Harness::with_timescale(Fill::Done, vec![], None); - h.subscriber.version = ingress; - h.subscriber.state.lock().subscribes.get_mut(&REQUEST).unwrap().producer = Some(track.clone()); - let mut properties = Vec::new(); - let mut encoder = Encoder::new(&mut properties, ingress.into()); - encoder.varint(0x80u64).unwrap(); - encoder.varint(96_000u64).unwrap(); - let datagram = ietf::ObjectDatagram { - track_alias: ALIAS, - group_id: SEQUENCE, - object_id: Some(5), - publisher_priority: Some(200), - end_of_group: false, - properties: Some(properties), - body: ietf::DatagramBody::Status(status), - }; - h.subscriber - .recv_datagram(datagram.encode_bytes(ingress).unwrap()) - .unwrap(); - track.finish().unwrap(); - let downstream = ScriptedSession::per_stream(vec![vec![]]).with_datagrams(65535); - let peer = peer::PeerSetup::default(); - peer.set(peer::Peer::default()); - let publisher = crate::ietf::Publisher::new( - crate::time::sim(), - crate::driver::Transport::new(downstream.clone()), - origin.consume(), - Control::new(None, false), - None, - peer, - egress, - ); - let subscribe = ietf::Subscribe { - max_age: None, - new_group: None, - request_id: RequestId(3), - track_namespace: Path::new("room"), - track_name: "video".into(), - subscriber_priority: 128, - group_order: ietf::GroupOrder::Ascending, - filter: Filter::Unfiltered, - fill: None, - properties_wanted: true, - forward: true, - rendezvous: false, - range_filters: false, - authorization_token: None, - epoch: None, - }; - let mut body = Vec::new(); - subscribe - .encode_msg(&mut Encoder::new(&mut body, egress.into()), egress) - .unwrap(); - let stream = Stream::open(&mut crate::driver::Transport::new(downstream.clone()), egress) - .await - .unwrap(); - publisher - .handle_stream(ietf::Subscribe::ID, ietf::Body(body.into()), stream, false) - .unwrap() - .await; - let sent = downstream.log.datagrams.lock().unwrap(); - let context = format!("{ingress} to {egress}, status {status}"); - let [bytes] = sent.as_slice() else { - panic!("{context}: sent {} datagrams", sent.len()); - }; - let (actual, _) = ietf::ObjectDatagram::decode_slice(bytes, egress).unwrap(); - let carried = false; - assert_eq!( - (actual.object_id, actual.body, actual.properties.is_some()), - (Some(5), ietf::DatagramBody::Status(status), carried), - "{context}" - ); - } - } - } - #[moq_clock::test] async fn passthrough_translates_mutable_property_encodings() { for ingress in [Version::Draft22] { @@ -13654,7 +12819,7 @@ mod stitch_tests { assert_eq!(props.varint().unwrap(), 96_000); assert_eq!( props.varint().unwrap(), - if egress == Version::Draft15 { 0x81 } else { 1 } + 1 ); assert_eq!(props.bytes().unwrap(), &[42; 130]); assert!(props.is_empty()); @@ -13732,47 +12897,6 @@ mod stitch_tests { ); } - /// Old drafts preserve a nonzero first Object ID without inventing missing frames. - #[moq_clock::test] - async fn old_drafts_accept_a_nonzero_first_object() { - for version in [Version::Draft16] { - let scripts = [2u64, 0] - .into_iter() - .enumerate() - .map(|(index, first)| { - let mut bytes = Vec::new(); - ietf::GroupHeader { - track_alias: ALIAS, - group_id: SEQUENCE + index as u64, - sub_group_id: 0, - publisher_priority: 0, - flags: ietf::GroupFlags { - first_object: true, - ..Default::default() - }, - } - .encode(&mut crate::coding::Encoder::new(&mut bytes, version.into()), version) - .unwrap(); - let mut encoder = crate::coding::Encoder::new(&mut bytes, version.into()); - encoder.varint(first).unwrap(); - encoder.varint(1u64).unwrap(); - bytes.push(42); - bytes - }) - .collect(); - let mut h = Harness::with_timescale(Fill::Done, scripts, None); - h.subscriber.version = version; - let mut consumer = h.track.subscribe(None); - let mut stream = h.stream().await.with_version(version); - h.subscriber.clone().recv_group(&mut stream).await.unwrap(); - assert_eq!(h.track.latest_sequence(), Some(SEQUENCE)); - assert_eq!(read_group(&mut consumer).await, (SEQUENCE, vec![(None, vec![42])])); - let mut stream = h.stream().await.with_version(version); - h.subscriber.clone().recv_group(&mut stream).await.unwrap(); - assert_eq!(read_group(&mut consumer).await, (SEQUENCE + 1, vec![(None, vec![42])])); - } - } - /// A subgroup 1 stream costs only itself: the track's subgroup 0 stream still arrives. #[moq_clock::test] async fn a_non_zero_subgroup_leaves_the_track_flowing() { @@ -14721,48 +13845,6 @@ mod stitch_tests { )); } - /// A draft-14/15 end-of-group marker ends a group fetch, so an object after it is a - /// violation rather than another frame. - #[moq_clock::test] - async fn a_group_fetch_refuses_an_object_past_its_end_marker() { - const DRAFT: Version = Version::Draft15; - let header = |object: u64| ietf::FetchObject::Object { - subgroup: ietf::FetchSubgroup::Zero, - group: Some(SEQUENCE), - object: Some(object), - priority: Some(0), - properties: None, - }; - let mut buf = Vec::new(); - header(0) - .encode(&mut crate::coding::Encoder::new(&mut buf, DRAFT.into()), DRAFT) - .unwrap(); - crate::coding::Encoder::new(&mut buf, DRAFT.into()) - .varint(1u64) - .unwrap(); - buf.extend_from_slice(b"a"); - header(1) - .encode(&mut crate::coding::Encoder::new(&mut buf, DRAFT.into()), DRAFT) - .unwrap(); - crate::coding::Encoder::new(&mut buf, DRAFT.into()) - .varint(0u64) - .unwrap(); - crate::coding::Encoder::new(&mut buf, DRAFT.into()) - .varint(END_OF_GROUP) - .unwrap(); - header(1) - .encode(&mut crate::coding::Encoder::new(&mut buf, DRAFT.into()), DRAFT) - .unwrap(); - crate::coding::Encoder::new(&mut buf, DRAFT.into()) - .varint(1u64) - .unwrap(); - buf.extend_from_slice(b"b"); - - let mut run = GroupFetchRun::new(DRAFT, buf.to_vec()).await; - let res = run.recv_objects(0, None).await; - assert!(matches!(res, Err(Error::ProtocolViolation)), "{res:?}"); - } - /// The first object on a fetch stream has no prior object, so leaving any field to /// the prior one is a violation, not "the requested group, from its start". #[moq_clock::test] @@ -14981,7 +14063,7 @@ mod stitch_tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(), - Control::new(None, false), + Control::new(false), None, peer::PeerSetup::default(), crate::Hop::new(1).unwrap(), @@ -15060,7 +14142,7 @@ mod joining_fetch_tests { }; use futures::FutureExt; - const JOINING_DRAFTS: [Version; 6] = [ + const JOINING_DRAFTS: [Version; 2] = [ Version::Draft18, Version::Draft19, ]; @@ -15095,7 +14177,6 @@ mod joining_fetch_tests { message_bytes( ietf::FetchOk::ID, &ietf::FetchOk { - group_order: GroupOrder::Ascending, end_of_track: false, end_location: ietf::Location { group: 4, object: 2 }, properties: Default::default(), @@ -15150,7 +14231,7 @@ mod joining_fetch_tests { impl JoinRun { async fn start(version: Version, start: Option, ok: Vec, fetch: Vec) -> Self { - Self::start_with_control(version, start, [ok, fetch], Control::new(None, false)).await + Self::start_with_control(version, start, [ok, fetch], Control::new(false)).await } async fn start_with_control( @@ -15220,45 +14301,13 @@ mod joining_fetch_tests { } } - /// A peer withholding joining-FETCH credit cannot keep an unauthorized track alive. - #[moq_clock::test] - async fn revocation_does_not_wait_for_joining_fetch_credit() { - let version = Version::Draft14; - let mut run = JoinRun::start_with_control( - version, - None, - [ - subscribe_ok(version, Some(ietf::Location { group: 4, object: 1 })), - fetch_ok(version), - ], - Control::new(Some(RequestId(3)), false), - ) - .await; - assert!(run.fill_outstanding(), "accepted subscription awaits its joining FETCH"); - assert!( - !decode_messages(&run.session.log, version) - .iter() - .any(|(id, _)| *id == ietf::Fetch::ID) - ); - run.subscriber.auth.handle().authorize(&crate::auth::Grant::default()); - settle().await; - let mut received = (&mut run._hold.2) - .now_or_never() - .expect("SUBSCRIBE_OK accepted the track") - .unwrap(); - assert!(matches!( - received.finished().now_or_never(), - Some(Err(Error::Unauthorized)) - )); - } - fn pending_join(session: Transport, version: Version) -> (Subscriber, track::Producer, TaskSet) { let (tasks, task_set) = TaskSet::new(); let subscriber = Subscriber::new( crate::time::sim(), session, crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(), - Control::new(None, false), + Control::new(false), None, peer::PeerSetup::default(), crate::Hop::new(1).unwrap(), @@ -15297,7 +14346,7 @@ mod joining_fetch_tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(), - Control::new(None, false), + Control::new(false), None, peer::PeerSetup::declared(peer::Peer::default()), crate::Hop::new(1).unwrap(), @@ -15404,7 +14453,7 @@ mod joining_fetch_tests { "{version}: invalid joining open stayed alive" ); assert_eq!( - subscriber.control.next_request_id(&subscriber.runtime).await.unwrap(), + subscriber.control.next_request_id(), RequestId(1) ); assert_eq!(log.bi_opens(), 0); @@ -15412,28 +14461,6 @@ mod joining_fetch_tests { } } - #[moq_clock::test] - async fn refusing_a_joining_fetch_spends_no_request_credit() { - for version in JOINING_DRAFTS { - let session = ScriptedSession::new(Vec::new()).without_credit(); - let (mut subscriber, track, _tasks) = pending_join(crate::driver::Transport::new(session), version); - subscriber.control = Control::new( - None, - false, - ); - let mut joining = subscriber.start_joining_fetch(RequestId(99), &track).unwrap(); - assert!( - joining.poll(&kio::Waiter::noop()).is_ready(), - "{version}: refusal must be immediate" - ); - assert_eq!( - subscriber.control.poll_next_request_id(&kio::Waiter::noop()), - Poll::Ready(RequestId(1)), - "{version}: refusal spends neither an ID nor MAX_REQUEST_ID credit" - ); - } - } - /// Abandoning a blocked open leaves the next sequential ID available to unrelated work. #[moq_clock::test] async fn cancelling_a_joining_fetch_open_spends_no_id() { @@ -15448,79 +14475,13 @@ mod joining_fetch_tests { *gate.write().ok().expect("gate is open") = true; let _ = tasks.poll(&kio::Waiter::noop()); assert_eq!( - subscriber.control.next_request_id(&subscriber.runtime).await.unwrap(), + subscriber.control.next_request_id(), RequestId(1) ); assert_eq!(log.bi_opens(), 0, "{version}: the abandoned open is gone"); } } - /// A cancelled partial legacy header still precedes the next unrelated request ID. - #[moq_clock::test] - async fn cancelling_a_partial_joining_fetch_preserves_request_id_order() { - for version in [Version::Draft15] { - let gate = kio::Producer::new(false); - let session = crate::lite::test_transport::SinkSession::gated_bi_prefix(2, gate.consume()); - let log = session.log.clone(); - let (subscriber, track, mut tasks) = pending_join(crate::driver::Transport::new(session.clone()), version); - let mut joining = subscriber.start_joining_fetch(RequestId(99), &track).unwrap(); - assert!(joining.poll(&kio::Waiter::noop()).is_pending()); - assert_eq!(log.writes.lock().unwrap().len(), 2, "partial header"); - let mut unrelated = std::pin::pin!(subscriber.control.next_request_id(&subscriber.runtime)); - assert!(kio::Waiter::noop().poll_future(unrelated.as_mut()).is_pending()); - drop(joining); - let _ = tasks.poll(&kio::Waiter::noop()); - assert!(kio::Waiter::noop().poll_future(unrelated.as_mut()).is_pending()); - *gate.write().ok().expect("gate is open") = true; - let next = kio::wait(|waiter| { - let _ = tasks.poll(waiter); - waiter.poll_future(unrelated.as_mut()) - }) - .await - .unwrap(); - assert_eq!(next, RequestId(3), "{version}: no ID was skipped or reused"); - let messages = decode_messages(&log, version); - assert_eq!(messages.len(), 1); - assert_eq!(messages[0].0, ietf::Fetch::ID); - let mut body = messages[0].1.clone(); - let fetch = crate::coding::decode_buf(&mut body, version, ietf::Fetch::decode_msg).unwrap(); - assert_eq!(fetch.request_id, RequestId(1)); - assert!(log.resets().is_empty(), "header and FIN must survive cancellation"); - assert!( - log.trail() - .iter() - .any(|(_, sent)| matches!(sent, crate::lite::test_transport::Sent::Finish)) - ); - } - } - - /// A peer that never acknowledges cancellation cannot retain request-ID allocation. - #[moq_clock::test] - async fn joining_fetch_cleanup_does_not_hold_the_next_request_id() { - for version in [Version::Draft15] { - let session = ScriptedSession::per_stream(Vec::new()).with_unacked_fin(); - let log = session.log.clone(); - let (subscriber, track, mut tasks) = pending_join(crate::driver::Transport::new(session.clone()), version); - let mut joining = subscriber.start_joining_fetch(RequestId(99), &track).unwrap(); - assert!(joining.poll(&kio::Waiter::noop()).is_pending()); - drop(joining); - assert!( - tasks.poll(&kio::Waiter::noop()).is_pending(), - "FIN remains unacknowledged" - ); - assert_eq!( - subscriber.control.next_request_id(&subscriber.runtime).await.unwrap(), - RequestId(3) - ); - assert!( - log.trail() - .iter() - .any(|(_, sent)| matches!(sent, crate::lite::test_transport::Sent::Finish)) - ); - assert!(log.resets().is_empty()); - } - } - /// Every pre-draft-20 live join is Largest Object on the SUBSCRIBE and a relative /// joining FETCH at offset 0 that names the subscribe's request id. #[moq_clock::test] @@ -15739,7 +14700,7 @@ mod joining_fetch_tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(), - Control::new(None, false), + Control::new(false), None, peer::PeerSetup::default(), crate::Hop::new(1).unwrap(), @@ -15788,7 +14749,6 @@ mod joining_fetch_tests { session.push(&message_bytes( ietf::FetchOk::ID, &ietf::FetchOk { - group_order: GroupOrder::Ascending, end_of_track: false, end_location: ietf::Location { group: GROUP, @@ -15876,9 +14836,6 @@ mod joining_fetch_tests { return; } assert_eq!(session.log.stops(), [crate::ietf::error::CANCELLED]); - let messages = decode_messages(&session.log, version); - let cancels: Vec<_> = messages.iter().filter(|(id, _)| *id == ietf::FetchCancel::ID).collect(); - assert!(cancels.is_empty(), "FETCH_CANCEL was removed"); assert_eq!(session.log.resets(), [crate::ietf::error::CANCELLED]); assert!(subscriber.state.lock().group_fetches.is_empty(), "request retired"); } @@ -15937,7 +14894,6 @@ mod joining_fetch_tests { let ok = message_bytes( ietf::FetchOk::ID, &ietf::FetchOk { - group_order: GroupOrder::Ascending, end_of_track: false, end_location: ietf::Location { group: GROUP, @@ -15954,7 +14910,7 @@ mod joining_fetch_tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(), - Control::new(None, false), + Control::new(false), None, peer::PeerSetup::default(), crate::Hop::new(1).unwrap(), @@ -16005,7 +14961,6 @@ mod joining_fetch_tests { let ok = message_bytes( ietf::FetchOk::ID, &ietf::FetchOk { - group_order: GroupOrder::Ascending, end_of_track, end_location, properties: Default::default(), @@ -16019,7 +14974,7 @@ mod joining_fetch_tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(), - Control::new(None, false), + Control::new(false), None, peer::PeerSetup::default(), crate::Hop::new(1).unwrap(), @@ -16113,7 +15068,6 @@ mod joining_fetch_tests { let ok = message_bytes( ietf::FetchOk::ID, &ietf::FetchOk { - group_order: GroupOrder::Ascending, end_of_track: ended, end_location, properties: Default::default(), @@ -16154,7 +15108,7 @@ mod joining_fetch_tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(), - Control::new(None, false), + Control::new(false), None, peer::PeerSetup::default(), crate::Hop::new(1).unwrap(), @@ -16280,7 +15234,7 @@ mod new_group_tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(), - Control::new(None, false), + Control::new(false), None, peer::PeerSetup::declared(peer::Peer::default()), crate::Hop::new(1).unwrap(), @@ -16569,7 +15523,7 @@ mod track_property_tests { }; /// The newest draft and an older one, both with a request stream per subscription. - const VERSIONS: [Version; 2] = [Version::Draft22]; + const VERSIONS: [Version; 2] = [Version::Draft18, Version::Draft22]; /// Subscribe to one track through a relay on `version`, whose publisher answers with /// `block` as SUBSCRIBE_OK's Track Properties, returning what the subscriber got. @@ -16580,7 +15534,7 @@ mod track_property_tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(), - Control::new(None, false), + Control::new(false), None, peer::PeerSetup::declared(peer::Peer::default()), crate::Hop::new(1).unwrap(), @@ -16775,10 +15729,7 @@ mod compression_negotiation_tests { refused(&properties, version, false), Some(Error::UnsupportedExtension) )); - assert_eq!( - refused(&properties, version, true).is_none(), - super::super::flate::supported(version) - ); + assert!(refused(&properties, version, true).is_none(), "{version}"); } let info = accepted_info(&properties, Version::Draft22); assert!(info.compress); diff --git a/rs/moq-net/src/ietf/subscriber/tracks.rs b/rs/moq-net/src/ietf/subscriber/tracks.rs index 7984a903ab3..ffc70aad1ce 100644 --- a/rs/moq-net/src/ietf/subscriber/tracks.rs +++ b/rs/moq-net/src/ietf/subscriber/tracks.rs @@ -1264,7 +1264,7 @@ mod tests { crate::time::sim(), crate::driver::Transport::new(session.clone()), crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(), - Control::new(None, false), + Control::new(false), None, peer::PeerSetup::declared(peer::Peer::default()), crate::Hop::new(1).unwrap(), diff --git a/rs/moq-net/src/ietf/token.rs b/rs/moq-net/src/ietf/token.rs index bada6914429..185a2ec1530 100644 --- a/rs/moq-net/src/ietf/token.rs +++ b/rs/moq-net/src/ietf/token.rs @@ -202,7 +202,7 @@ mod tests { )); } - const VERSIONS: [Version; 9] = [ + const VERSIONS: [Version; 5] = [ Version::Draft18, Version::Draft19, Version::Draft20, @@ -256,8 +256,7 @@ mod tests { value: vec![0x00, 0xff], }; for (version, expected) in [ - (Version::Draft14, [0x03, 0x41, 0x2c, 0x00, 0xff]), - (Version::Draft17, [0x03, 0x81, 0x2c, 0x00, 0xff]), + (Version::Draft18, [0x03, 0x81, 0x2c, 0x00, 0xff]), ] { let mut params = Parameters::default(); into_setup(&mut params, &token, version).unwrap(); diff --git a/rs/moq-net/src/ietf/track.rs b/rs/moq-net/src/ietf/track.rs index 52f415f4820..663d046e7ad 100644 --- a/rs/moq-net/src/ietf/track.rs +++ b/rs/moq-net/src/ietf/track.rs @@ -126,6 +126,7 @@ impl Decode for TrackStatusCode { #[cfg(test)] mod tests { use super::*; + use crate::ietf::GroupOrder; fn encode_message(msg: &M, version: Version) -> Vec { let mut buf = Vec::new(); @@ -134,18 +135,9 @@ mod tests { buf.to_vec() } - /// GROUP_ORDER and MAX_CACHE_DURATION are TRACK_STATUS_OK parameters only on draft-15, - /// as on SUBSCRIBE_OK. Draft-16 ignores a GROUP_ORDER it defines elsewhere, even with a - /// value no field could hold, and rejects 0x04, which it does not define at all. Draft-18 - /// rejects a known parameter on a message that does not define it. + /// TRACK_STATUS_OK rejects a known parameter on a message that does not define it. #[test] fn track_status_ok_parameters_follow_the_draft() { - // Request 1, then GROUP_ORDER as the varint 256. - let ok = decode_message::(&[0x01, 0x01, 0x22, 0x41, 0x00], Version::Draft16) - .expect("draft-16 ignores GROUP_ORDER"); - assert_eq!(ok.properties.group_order, None); - // Request 1, then MAX_CACHE_DURATION of 5. - assert!(decode_message::(&[0x01, 0x01, 0x04, 0x05], Version::Draft16).is_err()); // GROUP_ORDER = Ascending, then an empty properties block. assert!(decode_message::(&[0x01, 0x22, 0x01], Version::Draft18).is_err()); } @@ -155,78 +147,6 @@ mod tests { crate::coding::decode_buf(&mut buf, version, M::decode_msg) } - #[test] - fn test_track_status_v14_round_trip() { - let msg = TrackStatus { - request_id: RequestId(1), - track_namespace: Path::new("test/ns"), - track_name: "video".into(), - properties_wanted: true, - epoch: None, - }; - - let encoded = encode_message(&msg, Version::Draft14); - let decoded: TrackStatus = decode_message(&encoded, Version::Draft14).unwrap(); - - assert_eq!(decoded.request_id, RequestId(1)); - assert_eq!(decoded.track_namespace.as_str(), "test/ns"); - assert_eq!(decoded.track_name, "video"); - } - - #[test] - fn test_track_status_v15_round_trip() { - let msg = TrackStatus { - request_id: RequestId(1), - track_namespace: Path::new("test/ns"), - track_name: "video".into(), - properties_wanted: true, - epoch: None, - }; - - let encoded = encode_message(&msg, Version::Draft15); - let decoded: TrackStatus = decode_message(&encoded, Version::Draft15).unwrap(); - - assert_eq!(decoded.request_id, RequestId(1)); - assert_eq!(decoded.track_namespace.as_str(), "test/ns"); - assert_eq!(decoded.track_name, "video"); - } - - #[test] - fn test_track_status_v17_round_trip() { - let msg = TrackStatus { - request_id: RequestId(1), - track_namespace: Path::new("test/ns"), - track_name: "video".into(), - properties_wanted: true, - epoch: None, - }; - - let encoded = encode_message(&msg, Version::Draft17); - let decoded: TrackStatus = decode_message(&encoded, Version::Draft17).unwrap(); - - assert_eq!(decoded.request_id, RequestId(1)); - assert_eq!(decoded.track_namespace.as_str(), "test/ns"); - assert_eq!(decoded.track_name, "video"); - } - - #[test] - fn test_track_status_v16_round_trip() { - let msg = TrackStatus { - request_id: RequestId(1), - track_namespace: Path::new("test/ns"), - track_name: "video".into(), - properties_wanted: true, - epoch: None, - }; - - let encoded = encode_message(&msg, Version::Draft16); - let decoded: TrackStatus = decode_message(&encoded, Version::Draft16).unwrap(); - - assert_eq!(decoded.request_id, RequestId(1)); - assert_eq!(decoded.track_namespace.as_str(), "test/ns"); - assert_eq!(decoded.track_name, "video"); - } - #[test] fn test_track_status_v18_round_trip() { let msg = TrackStatus { @@ -245,7 +165,7 @@ mod tests { assert_eq!(decoded.track_name, "video"); } - const ALL: [Version; 9] = [ + const ALL: [Version; 5] = [ Version::Draft18, Version::Draft19, Version::Draft20, @@ -274,9 +194,8 @@ mod tests { } } - /// TRACK_STATUS_OK carries what SUBSCRIBE_OK would, as far as each draft's answer - /// has room: draft-14 is a SUBSCRIBE_OK, drafts 15-17 a REQUEST_OK with only - /// parameters, and from draft-18 the REQUEST_OK ends with the Track Properties. + /// TRACK_STATUS_OK carries what SUBSCRIBE_OK would: a REQUEST_OK ending with the Track + /// Properties. #[test] fn test_track_status_ok_round_trip() { let properties = Properties { @@ -299,32 +218,11 @@ mod tests { decode_message(&encode_message(&msg, version), version).unwrap_or_else(|e| panic!("{version}: {e}")); let expected = properties.clone(); - assert_eq!(decoded.request_id, msg.request_id, "{version}"); assert_eq!(decoded.largest, largest, "{version}"); assert_eq!(decoded.properties, expected, "{version}"); } } - /// Draft-14's TRACK_STATUS_OK is a SUBSCRIBE_OK with Track Alias 0, under its own type. - #[test] - fn test_track_status_ok_draft_14_is_a_subscribe_ok() { - let msg = TrackStatusOk { - largest: None, - properties: Properties::default(), - }; - assert_eq!(TrackStatusOk::id(Version::Draft14), 0x0E); - assert_eq!(TrackStatusOk::id(Version::Draft15), 0x07); - let subscribe_ok = SubscribeOk { - track_alias: 0, - largest: None, - properties: Properties::default(), - }; - assert_eq!( - encode_message(&msg, Version::Draft14), - encode_message(&subscribe_ok, Version::Draft14) - ); - } - /// TRACK_STATUS is identical to SUBSCRIBE on every draft, so it carries whatever /// fields and parameters a SUBSCRIBE can. A peer that sends them must still be /// answered rather than having its session closed. @@ -336,19 +234,7 @@ mod tests { ]; #[rustfmt::skip] - let cases: [(Version, &[u8]); 3] = [ - (Version::Draft14, &[ - 0x80, // Subscriber Priority - 0x02, // Group Order - 0x00, // Forward - 0x03, 0x05, 0x01, // Filter Type AbsoluteStart, at {5, 1} - 0x00, // Number of Parameters - ]), - (Version::Draft15, &[ - 0x02, // Number of Parameters - 0x10, 0x00, // FORWARD = 0 - 0x20, 0x01, // SUBSCRIBER_PRIORITY = 1 - ]), + let cases: [(Version, &[u8]); 1] = [ (Version::Draft20, &[ 0x02, // Number of Parameters 0x03, 0x03, 0x03, 0x00, 0xAA, // AUTHORIZATION TOKEN diff --git a/rs/moq-net/src/ietf/version.rs b/rs/moq-net/src/ietf/version.rs index 59f22f18ddb..f321f8741ba 100644 --- a/rs/moq-net/src/ietf/version.rs +++ b/rs/moq-net/src/ietf/version.rs @@ -103,8 +103,6 @@ mod tests { }; let subscribe_ok = SubscribeOk { - // Draft-17 and newer carry the request on the stream, not in the message. - request_id: None, track_alias: 4, largest: Some(Location { group: 5, object: 2 }), properties: properties.clone(), diff --git a/rs/moq-net/src/lite/compress.rs b/rs/moq-net/src/lite/compress.rs index 282a898da88..41f1ff0bac9 100644 --- a/rs/moq-net/src/lite/compress.rs +++ b/rs/moq-net/src/lite/compress.rs @@ -577,7 +577,7 @@ mod tests { #[test] fn a_tie_stays_literal_where_hop_100_sizes_differ() { let quic = Form::Quic; - let leading = Form::LeadingOnes { seven: true }; + let leading = Form::LeadingOnes; assert_eq!(varint_size(100, quic), 2); assert_eq!(varint_size(100, leading), 1); diff --git a/rs/moq-net/src/lite/ietf.rs b/rs/moq-net/src/lite/ietf.rs index f39c8172bed..40f3e62dc27 100644 --- a/rs/moq-net/src/lite/ietf.rs +++ b/rs/moq-net/src/lite/ietf.rs @@ -504,9 +504,9 @@ mod tests { #[test] fn properties_round_trip() { - // An immutable block in draft-16 holding a gap of 2 (0x3e) and a timestamp. + // An immutable block holding a gap of 2 (0x3e) and a timestamp. let mut sealed = Vec::new(); - let e = &mut Encoder::new(&mut sealed, Draft::Draft16.into()); + let e = &mut Encoder::new(&mut sealed, Draft::Draft18.into()); for value in [0x10u64, 77, 0x3e - 0x10, 2] { e.varint(value).unwrap(); } @@ -522,16 +522,16 @@ mod tests { ]; let properties = Properties { sealed_time: Some(crate::Timestamp::new(77, Timescale::MILLI).unwrap()), - block: crate::ietf::object::block(&values, Draft::Draft16).unwrap(), + block: crate::ietf::object::block(&values, Draft::Draft18).unwrap(), }; let body = encode_properties(&properties); - let decoded = decode_properties(body, from(Draft::Draft16, Some(Timescale::MILLI)), true).unwrap(); + let decoded = decode_properties(body, from(Draft::Draft18, Some(Timescale::MILLI)), true).unwrap(); assert_eq!(decoded.properties, properties); assert_eq!(decoded.gap, Some(2)); // None at all is an empty body. assert!(encode_properties(&Properties::default()).is_empty()); - let empty = decode_properties(&[], from(Draft::Draft16, Some(Timescale::MILLI)), true).unwrap(); + let empty = decode_properties(&[], from(Draft::Draft18, Some(Timescale::MILLI)), true).unwrap(); assert_eq!(empty.properties, Properties::default()); // An untimed track's Timestamp has no frame to hold it, so it stays in the block. @@ -674,13 +674,6 @@ mod tests { decode(&wire(&[opaque(0x40)], 0)).is_err(), "properties on a moq-lite track" ); - for version in [Draft::Draft15] { - assert!(decode(&wire(&[], code(version))).is_ok(), "{version}"); - assert!( - decode(&wire(&[opaque(0x40)], code(version))).is_err(), - "{version} has no Track Properties" - ); - } for code in [1, 0xff000099, crate::Version::Lite(V).code()] { assert!(decode(&wire(&[], code)).is_err(), "{code:#x} is no moq-transport draft"); } @@ -789,7 +782,7 @@ mod tests { /// could not cross is refused where it arrives rather than where it would be sent. #[test] fn track_properties_that_cannot_cross_are_refused_at_ingress() { - let version = Draft::Draft16; + let version = Draft::Draft18; // The most a draft-16 answer holds beside a Request ID and an empty parameter count. let size = super::super::message::MAX_MESSAGE_SIZE - 2; // DYNAMIC_GROUPS, then the last ID whose delta from it fits four bytes. @@ -839,7 +832,7 @@ mod tests { }; let decoded = decode_datagram( &mut Decoder::new(&datagram(&wire), V.into()), - from(Draft::Draft14, None), + from(Draft::Draft18, None), ); assert_eq!(decoded.is_ok(), ok, "{status}"); } @@ -963,36 +956,21 @@ mod tests { } } - /// Only draft-14 lets a status object carry properties, so the END_OF_GROUP record has a - /// block only on a draft-14 track. + /// A status object carries no properties, so the END_OF_GROUP record has no block. #[cfg(feature = "async")] #[test] - fn an_end_record_block_needs_a_draft_that_carries_one() { - for version in [Draft::Draft22] { - let framing = from(version, None); - assert_eq!( - decode_end(&[0x20, 1], framing).is_ok(), - version == Draft::Draft14, - "{version}" - ); - assert!(decode_end(&[], framing).is_ok(), "{version}"); - } + fn an_end_record_has_no_block() { + let framing = from(Draft::Draft22, None); + assert!(decode_end(&[0x20, 1], framing).is_err()); + assert!(decode_end(&[], framing).is_ok()); } - /// A datagram must be one its track's draft defines: from draft-17 on a non-zero Status - /// carries no properties, and only drafts 14 and 15 define DOES_NOT_EXIST. + /// A datagram must be one its track's draft defines: a non-zero Status carries no + /// properties. #[test] fn a_datagram_block_needs_a_draft_that_sends_its_shape() { - let drafts = [ - Draft::Draft22, - ]; - for (status, carried) in [ - (0, &drafts[..]), - (1, &drafts[..2]), - (3, &drafts[..3]), - (4, &drafts[..3]), - ] { - for version in drafts { + for (status, carried) in [(0, true), (1, false), (3, false), (4, false)] { + for version in [Draft::Draft18, Draft::Draft22] { // Object 3 at priority 9, which every draft can send beside a status. let mut buf = Vec::new(); let w = &mut Encoder::new(&mut buf, V.into()); @@ -1002,7 +980,7 @@ mod tests { w.varint(status).unwrap(); w.bytes(&[0x20, 1]).unwrap(); let decoded = decode_datagram(&mut Decoder::new(&buf, V.into()), from(version, None)); - assert_eq!(decoded.is_ok(), carried.contains(&version), "{status}: {version}"); + assert_eq!(decoded.is_ok(), carried, "{status}: {version}"); } } } diff --git a/rs/moq-net/src/lite/test_transport.rs b/rs/moq-net/src/lite/test_transport.rs index 5614b0897a7..7b8ca73edd6 100644 --- a/rs/moq-net/src/lite/test_transport.rs +++ b/rs/moq-net/src/lite/test_transport.rs @@ -679,14 +679,6 @@ impl SinkSession { } } - /// Write this prefix on each bidi stream before holding its remaining bytes. - pub fn gated_bi_prefix(prefix: usize, gate: kio::Consumer) -> Self { - Self { - bi_prefix: prefix, - ..Self::gated_bi(gate) - } - } - /// Accept bidi streams from the peer, holding every write until `gate` flips to true. /// /// The accepted half of a control stream carries the answers (track info, diff --git a/rs/moq-net/src/server.rs b/rs/moq-net/src/server.rs index ca6f9ad1431..5901bab5f98 100644 --- a/rs/moq-net/src/server.rs +++ b/rs/moq-net/src/server.rs @@ -8,7 +8,7 @@ use crate::transport::poll::Session as _; use crate::{ ALPN_18, ALPN_19, ALPN_20, ALPN_21, ALPN_22, ALPN_LITE, ALPN_LITE_03, ALPN_LITE_04, ALPN_LITE_05, ALPN_LITE_06, ALPN_LITE_07_WIP, Consume, Error, NEGOTIATED, Session, SessionError, Version, Versions, - coding::{Decode, Encode, Stream}, + coding::{Encode, Stream}, ietf, lite, setup::{self, Role}, stats, @@ -1155,16 +1155,15 @@ mod tests { } /// Encode a draft 14-16 CLIENT_SETUP, sent on the control bidi stream. - fn legacy_setup(version: ietf::Version, params: ietf::Parameters) -> Vec { + /// A moq-lite-02 CLIENT_SETUP, sent on the bidi stream the `moql` ALPN negotiates over. + fn moql_setup() -> Vec { + let version = crate::Version::Lite(lite::Version::Lite02); let mut buf = Vec::new(); setup::Client { - versions: crate::coding::Versions::from([crate::Version::Ietf(version).into()]), - parameters: params.encode_bytes(version).unwrap(), + versions: crate::coding::Versions::from([version.into()]), + parameters: Bytes::new(), } - .encode( - &mut crate::coding::Encoder::new(&mut buf, (crate::Version::Ietf(version)).into()), - crate::Version::Ietf(version), - ) + .encode(&mut crate::coding::Encoder::new(&mut buf, version.into()), version) .unwrap(); buf } @@ -1186,20 +1185,13 @@ mod tests { /// session the driver then runs, through the REAL accept path (`accept_request` -> `ok`). /// The session's own `auth()` (the handle the driver polls) routes a request token to that /// pre-ok consumer instead of falling to the `Unsupported` default, and granting admits. - /// Both a no-AUTH-extension legacy session (draft-14, `Handle::new(false)`) and the modern - /// uni-SETUP path (draft-18); a QUIC server has no other point to install the verifier. + /// A QUIC server has no other point to install the verifier. #[moq_clock::test] async fn a_pre_ok_verifier_governs_the_session() { - let cases = [ - ( - FakeSession::new(ALPN_14, []) - .with_bi(legacy_setup(ietf::Version::Draft14, ietf::Parameters::default())), - ), - ( - FakeSession::new(ALPN_18, [ietf_setup(ietf::Version::Draft18, Some("room/alice"))]), - ietf::Version::Draft18, - ), - ]; + let cases = [( + FakeSession::new(ALPN_18, [ietf_setup(ietf::Version::Draft18, Some("room/alice"))]), + ietf::Version::Draft18, + )]; for (session, version) in cases { let mut request = Server::new() @@ -1233,10 +1225,8 @@ mod tests { #[moq_clock::test] async fn a_reply_the_peer_never_takes_fails_at_the_deadline() { let registry = stats::Registry::new(Default::default()); - let version = ietf::Version::Draft16; - let session = FakeSession::new(ALPN_16, []) - .with_bi(legacy_setup(version, ietf::Parameters::default())) - .withholding_credit(); + let version = Version::Lite(lite::Version::Lite02); + let session = FakeSession::new(ALPN_LITE, []).with_bi(moql_setup()).withholding_credit(); let start = moq_clock::now(); let deadline = start + std::time::Duration::from_secs(10); let request = Server::new() @@ -1252,7 +1242,7 @@ mod tests { assert_eq!(moq_clock::now(), deadline); assert_eq!( session.close_code(), - Some(Version::Ietf(version).session_code(&SessionError::Timeout)) + Some(version.session_code(&SessionError::Timeout)) ); let failed = registry.snapshot().sessions()[0].1.sessions_failed; assert_eq!(failed.count(stats::Failure::Application), 1, "{failed:?}"); @@ -1263,10 +1253,8 @@ mod tests { #[moq_clock::test] async fn an_abandoned_reply_fails_like_the_deadline() { let registry = stats::Registry::new(Default::default()); - let version = ietf::Version::Draft16; - let session = FakeSession::new(ALPN_16, []) - .with_bi(legacy_setup(version, ietf::Parameters::default())) - .withholding_credit(); + let version = Version::Lite(lite::Version::Lite02); + let session = FakeSession::new(ALPN_LITE, []).with_bi(moql_setup()).withholding_credit(); let request = Server::new() .accept_request(moq_clock::now(), session.clone()) .await @@ -1276,7 +1264,7 @@ mod tests { assert!(abandoned.is_err(), "a reply the peer never took completed"); assert_eq!( session.close_code(), - Some(Version::Ietf(version).session_code(&SessionError::Timeout)) + Some(version.session_code(&SessionError::Timeout)) ); let failed = registry.snapshot().sessions()[0].1.sessions_failed; assert_eq!(failed.count(stats::Failure::Application), 1, "{failed:?}"); @@ -1316,14 +1304,8 @@ mod tests { token_params(ietf::Version::Draft19), )], ); - let legacy = FakeSession::new(ALPN_16, []).with_bi(legacy_setup( - ietf::Version::Draft16, - token_params(ietf::Version::Draft16), - )); - for (name, session) in [("draft-19", modern), ("draft-16", legacy)] { - let request = Server::new().accept_request(moq_clock::now(), session).await.unwrap(); - assert_eq!(request.token(), Some(&setup_token()), "{name}"); - } + let request = Server::new().accept_request(moq_clock::now(), modern).await.unwrap(); + assert_eq!(request.token(), Some(&setup_token())); } #[moq_clock::test] @@ -1336,8 +1318,7 @@ mod tests { } } - /// A SETUP the server refuses closes the session with the code naming why, on both - /// the draft-17+ uni stream and the draft 14-16 bidi stream. + /// A SETUP the server refuses closes the session with the code naming why. #[moq_clock::test] async fn a_refused_setup_token_closes_with_its_code() { let delete = [0x0, 0x7]; // DELETE alias 7 @@ -1349,22 +1330,18 @@ mod tests { let mut params = ietf::Parameters::default(); params.set_bytes(ietf::ParameterBytes::AuthorizationToken, raw.to_vec()); - let modern = FakeSession::new(ALPN_19, [ietf_setup_with(ietf::Version::Draft19, params.clone())]); - let legacy = FakeSession::new(ALPN_16, []).with_bi(legacy_setup(ietf::Version::Draft16, params)); - for (name, session) in [("draft-19", modern), ("draft-16", legacy)] { - let result = Server::new().accept_request(moq_clock::now(), session.clone()).await; - assert!(result.is_err(), "{name}"); - assert_eq!(session.close_code(), Some(code.to_code()), "{name} {code}"); - } + let session = FakeSession::new(ALPN_19, [ietf_setup_with(ietf::Version::Draft19, params)]); + let result = Server::new().accept_request(moq_clock::now(), session.clone()).await; + assert!(result.is_err()); + assert_eq!(session.close_code(), Some(code.to_code()), "{code}"); } } #[moq_clock::test] async fn accept_request_reads_ietf_path() { - // Every draft-17+ version gates on the SETUP stream before starting, so the + // Every draft gates on the SETUP stream before starting, so the // path is known at authorization time just like lite-05. for (alpn, version) in [ - (ALPN_17, ietf::Version::Draft17), (ALPN_18, ietf::Version::Draft18), (ALPN_19, ietf::Version::Draft19), ] { diff --git a/rs/moq-net/src/test_interop.rs b/rs/moq-net/src/test_interop.rs index 4e746e4823d..aa6bc1d546a 100644 --- a/rs/moq-net/src/test_interop.rs +++ b/rs/moq-net/src/test_interop.rs @@ -36,7 +36,7 @@ fn varint_interop() { values.push(varint::MAX_QUIC); let quic = Form::Quic; - let leading_ones = Form::from(ietf::Version::Draft17); + let leading_ones = Form::from(ietf::Version::Draft18); let encode = |v: u64, form: Form| { let mut buf = Vec::new(); Encoder::new(&mut buf, form).varint(v).unwrap(); @@ -259,7 +259,7 @@ fn ietf_datagram_interop() { ietf::Version::Draft21, ietf::Version::Draft22, ]; - for (draft, version) in (14..).zip(all) { + for (draft, version) in (18..).zip(all) { let legacy = false; let mut properties = Vec::new(); let mut w = Encoder::new(&mut properties, version.into()); @@ -442,8 +442,7 @@ fn ietf_track_status_interop() { ietf::Version::Draft21, ietf::Version::Draft22, ]; - for (draft, version) in (14..).zip(all) { - let legacy = false; + for (draft, version) in (18..).zip(all) { let request = |id: u64, namespace: &str, wanted: bool| { let mut buf = Vec::new(); let mut w = Encoder::new(&mut buf, version.into()); @@ -469,12 +468,11 @@ fn ietf_track_status_interop() { for (index, wanted) in [true, false].into_iter().enumerate() { let mut r = Decoder::new(&responses[index], version.into()); - assert_eq!(r.varint().unwrap(), ietf::TrackStatusOk::ID, "{version}"); + assert_eq!(r.varint().unwrap(), ::ID, "{version}"); let ok = ietf::TrackStatusOk::decode(&mut r, version).unwrap(); assert!(r.is_empty(), "{version}: trailing bytes"); let expected = match version { - // GROUP_ORDER is a field on draft-14 and a parameter on draft-15. // Only draft-20 can carry the opt-out. _ if !wanted && ietf::Filter::is_draft20(version) => ietf::Properties::default(), _ => ietf::Properties { @@ -491,7 +489,6 @@ fn ietf_track_status_interop() { assert_eq!( ok, ietf::TrackStatusOk { - request_id: legacy.then_some(ietf::RequestId(1 + 2 * index as u64)), largest: Some(ietf::Location { group: 4, object: 1 }), properties: expected, }, diff --git a/rs/moq-net/tests/integration/announce_covering_route.rs b/rs/moq-net/tests/integration/announce_covering_route.rs index 20e152994c2..bf297c603a7 100644 --- a/rs/moq-net/tests/integration/announce_covering_route.rs +++ b/rs/moq-net/tests/integration/announce_covering_route.rs @@ -109,10 +109,6 @@ async fn remote_ietf_peer_hears_the_covering_route() { let mut expected = EXPECTED.to_vec(); expected.push("session open: true"); for version in [ - "moq-transport-14", - "moq-transport-15", - "moq-transport-16", - "moq-transport-17", "moq-transport-18", "moq-transport-19", "moq-transport-20", diff --git a/rs/moq-net/tests/integration/announce_to_serve.rs b/rs/moq-net/tests/integration/announce_to_serve.rs index eb71f54291c..452c22848cc 100644 --- a/rs/moq-net/tests/integration/announce_to_serve.rs +++ b/rs/moq-net/tests/integration/announce_to_serve.rs @@ -237,10 +237,6 @@ async fn remote_ietf_consumer_sees_what_a_local_one_does() { // Drafts 14 to 16 carry each request over the control stream; 17 and later give it // its own stream. Both have to end a finished track the way moq-lite does. for version in [ - "moq-transport-14", - "moq-transport-15", - "moq-transport-16", - "moq-transport-17", "moq-transport-18", "moq-transport-19", "moq-transport-20", diff --git a/rs/moq-net/tests/integration/auth.rs b/rs/moq-net/tests/integration/auth.rs index 91a4de62dc2..7320dce5b8b 100644 --- a/rs/moq-net/tests/integration/auth.rs +++ b/rs/moq-net/tests/integration/auth.rs @@ -31,8 +31,8 @@ const LITE_07: &str = "moq-lite-07-wip"; const LITE_06: &str = "moq-lite-06"; /// The lite Auth Stream's type byte. const AUTH_STREAM: u8 = 0x7; -/// The first draft that negotiates MoQ Auth, and the newest. -const MOQT_17: &str = "moq-transport-17"; +/// The oldest draft we speak, which negotiates MoQ Auth, and the newest. +const MOQT_18: &str = "moq-transport-18"; const MOQT_22: &str = "moq-transport-22"; /// Run each case on every version that exchanges AUTH. @@ -41,8 +41,8 @@ macro_rules! cases { mod lite_07 { $(#[moq_clock::test] async fn $case() { super::$case(super::LITE_07).await })* } - mod moqt_17 { - $(#[moq_clock::test] async fn $case() { super::$case(super::MOQT_17).await })* + mod moqt_18 { + $(#[moq_clock::test] async fn $case() { super::$case(super::MOQT_18).await })* } mod moqt_22 { $(#[moq_clock::test] async fn $case() { super::$case(super::MOQT_22).await })* @@ -87,8 +87,8 @@ async fn lite_07_presents_a_transiently_refused_token_again() { /// moq-transport's u16 message size is the one a test can overflow quickly. #[moq_clock::test] -async fn moqt_17_a_grant_too_large_for_one_message_is_unsupported() { - a_grant_too_large_for_one_message_is_unsupported(MOQT_17).await +async fn moqt_18_a_grant_too_large_for_one_message_is_unsupported() { + a_grant_too_large_for_one_message_is_unsupported(MOQT_18).await } #[moq_clock::test] @@ -125,37 +125,11 @@ async fn lite_05_has_no_grant() { older_versions_have_no_grant("moq-lite-05").await } -/// The #6566 matrix's drafts: one without MoQ Auth, and one with it. -#[moq_clock::test] -async fn moqt_16_admits_exact_and_subtree_grants() { - exact_and_subtree_grants_admit_their_broadcast("moq-transport-16").await -} - -#[moq_clock::test] -async fn moqt_18_admits_exact_and_subtree_grants() { - exact_and_subtree_grants_admit_their_broadcast("moq-transport-18").await -} - -#[moq_clock::test] -async fn moqt_16_has_no_grant() { - older_versions_have_no_grant("moq-transport-16").await -} - -#[moq_clock::test] -async fn moqt_16_route_auth_renews_its_announce() { - a_route_auth_renews_its_announce("moq-transport-16").await -} - #[moq_clock::test] async fn moqt_22_route_auth_renews_its_announce() { a_route_auth_renews_its_announce(MOQT_22).await } -#[moq_clock::test] -async fn moqt_16_route_auth_survives_a_reconnect() { - a_route_auth_survives_a_reconnect("moq-transport-16").await -} - #[moq_clock::test] async fn moqt_22_route_auth_survives_a_reconnect() { a_route_auth_survives_a_reconnect(MOQT_22).await @@ -1072,10 +1046,7 @@ async fn exact_and_subtree_grants_admit_their_broadcast(version: &'static str) { let mut sub = remote.track("video").unwrap().subscribe(prefs).await.unwrap(); sub.recv_group().await.unwrap().expect("a group"); - match version == "moq-transport-16" { - true => assert_eq!(pair.client.auth().grant().peek(), None), - false => assert_eq!(granted(&pair.client).await.subscribe, scope), - } + assert_eq!(granted(&pair.client).await.subscribe, scope); assert_eq!(pair.client_transport.close_reason(), None); }) .await @@ -1493,11 +1464,8 @@ macro_rules! limit_cases { mod limit_lite_07 { $(#[moq_clock::test] async fn $case() { super::$case(super::LITE_07).await })* } - mod limit_moqt_16 { - $(#[moq_clock::test] async fn $case() { super::$case("moq-transport-16").await })* - } - mod limit_moqt_17 { - $(#[moq_clock::test] async fn $case() { super::$case(super::MOQT_17).await })* + mod limit_moqt_18 { + $(#[moq_clock::test] async fn $case() { super::$case(super::MOQT_18).await })* } }; } @@ -1526,7 +1494,7 @@ async fn lite_07_narrowing_resets_a_fetch_in_flight() { /// Whether `version` exchanges AUTH, so the peer also hears of a narrowing. fn speaks_auth(version: &str) -> bool { - matches!(version, LITE_07 | MOQT_17 | MOQT_22) + matches!(version, LITE_07 | MOQT_18 | MOQT_22) } /// A revocation as the reader sees it: the local gate's own error, or the peer's diff --git a/rs/moq-net/tests/integration/broadcast_close.rs b/rs/moq-net/tests/integration/broadcast_close.rs index b2126764dc0..1c6d1e8628d 100644 --- a/rs/moq-net/tests/integration/broadcast_close.rs +++ b/rs/moq-net/tests/integration/broadcast_close.rs @@ -59,7 +59,7 @@ async fn close_ends_a_local_consumer() { #[moq_clock::test] async fn close_ends_a_remote_consumer() { - for version in ["moq-lite-05", "moq-transport-14", "moq-transport-19"] { + for version in ["moq-lite-05", "moq-transport-19"] { let publisher = produce_origin(1); let subscriber = produce_origin(2); let mut options = MockConnectOptions::new(version.parse::().unwrap()); diff --git a/rs/moq-net/tests/integration/catalog_acquisition.rs b/rs/moq-net/tests/integration/catalog_acquisition.rs index ca4bc66cf77..8a5f8111b25 100644 --- a/rs/moq-net/tests/integration/catalog_acquisition.rs +++ b/rs/moq-net/tests/integration/catalog_acquisition.rs @@ -80,6 +80,6 @@ async fn epochless_replacement_refuses_pending_catalog() { #[moq_clock::test] async fn same_epoch_replacement_acquires_pending_catalog() { acquisition("moq-lite-07-wip", true).await; - acquisition("moq-transport-17", true).await; + acquisition("moq-transport-18", true).await; acquisition("moq-transport-22", true).await; } diff --git a/rs/moq-net/tests/integration/compress.rs b/rs/moq-net/tests/integration/compress.rs index 8f6b53cca01..2df16b3434f 100644 --- a/rs/moq-net/tests/integration/compress.rs +++ b/rs/moq-net/tests/integration/compress.rs @@ -19,10 +19,6 @@ const VERSIONS: &[&str] = &[ "moq-lite-07-wip", "moq-lite-06", "moq-lite-03", - "moq-transport-14", - "moq-transport-15", - "moq-transport-16", - "moq-transport-17", "moq-transport-18", "moq-transport-22", ]; @@ -123,7 +119,6 @@ async fn relay(published: Published, hops: [&str; 2], subscription: moq_net::tra /// draft-17 and later. const RANGED: &[&str] = &[ "moq-lite-07-wip", - "moq-transport-17", "moq-transport-18", "moq-transport-22", ]; @@ -200,7 +195,7 @@ async fn relay_serves_every_version() { fixture.subscriber.info().compress, !matches!( version, - "moq-lite-06" | "moq-lite-03" | "moq-transport-14" | "moq-transport-15" | "moq-transport-16" + "moq-lite-06" | "moq-lite-03" ), "{version}: compression declared" ); @@ -249,8 +244,7 @@ async fn datagrams_serve_every_version() { for &version in &[ "moq-lite-07-wip", "moq-lite-06", - "moq-transport-16", - "moq-transport-17", + "moq-transport-18", "moq-transport-22", ] { moq_clock::timeout(TIMEOUT, async { @@ -343,18 +337,16 @@ async fn datagrams_meter_the_bytes_on_the_wire() { /// Negotiated IETF ingress stays compressed across a relay to IETF or lite-07 egress. #[moq_clock::test] async fn ietf_ingress_stays_compressed_across_protocols() { - for upstream in ["moq-transport-17", "moq-transport-18", "moq-transport-22"] { + for upstream in ["moq-transport-18", "moq-transport-22"] { for downstream in [ "moq-lite-07-wip", - "moq-transport-16", "moq-transport-22", - "moq-transport-14", ] { moq_clock::timeout(TIMEOUT, async { let mut fixture = connect(upstream, downstream).await; assert_eq!( fixture.subscriber.info().compress, - !matches!(downstream, "moq-transport-14" | "moq-transport-16"), + true, "{upstream} -> {downstream}" ); let mut group = fixture.track.append_group().unwrap(); @@ -397,7 +389,7 @@ async fn ietf_ingress_stays_compressed_across_protocols() { /// A finished compressed track remains fetchable without subscribing to its live feed. #[moq_clock::test] async fn ietf_fetch_keeps_the_stored_form() { - for version in ["moq-transport-16", "moq-transport-18", "moq-transport-22"] { + for version in [ "moq-transport-18", "moq-transport-22"] { moq_clock::timeout(TIMEOUT, async { let publisher = produce_origin(1); let broadcast = publisher.create_broadcast("bcast").unwrap(); @@ -419,7 +411,7 @@ async fn ietf_fetch_keeps_the_stored_form() { origin.consume().routed("bcast").await.unwrap(); let remote = origin.consume().request_broadcast("bcast", None).await.unwrap(); let consumer = remote.track("data").unwrap(); - assert_eq!(consumer.query().await.unwrap().compress, version != "moq-transport-16"); + assert!(consumer.query().await.unwrap().compress, "{version}"); let mut fetched = consumer.fetch_group(0, moq_net::group::Fetch::default()).await.unwrap(); for index in 0..3 { assert_eq!( diff --git a/rs/moq-net/tests/integration/control_stats.rs b/rs/moq-net/tests/integration/control_stats.rs index 554859399b6..ac1795fb18e 100644 --- a/rs/moq-net/tests/integration/control_stats.rs +++ b/rs/moq-net/tests/integration/control_stats.rs @@ -23,9 +23,6 @@ async fn control_classes_cross_lite_and_ietf_sessions_without_counting_payload() "moq-lite-03", "moq-lite-06", "moq-lite-07-wip", - "moq-transport-14", - "moq-transport-15", - "moq-transport-16", "moq-transport-22", ] { let publisher = origin(); @@ -76,7 +73,7 @@ async fn control_classes_cross_lite_and_ietf_sessions_without_counting_payload() /// admitted with, even for a session with neither origin. #[moq_clock::test] async fn setup_counts_under_the_admitted_stats() { - for version in ["moq-lite-07-wip", "moq-transport-14", "moq-transport-22"] { + for version in ["moq-lite-07-wip", "moq-transport-22"] { let version: moq_net::Version = version.parse().unwrap(); let registry = Registry::new(Default::default()); let tier = Tier::new("internal"); diff --git a/rs/moq-net/tests/integration/datagram.rs b/rs/moq-net/tests/integration/datagram.rs index 2b373c9c6f6..2544bf07394 100644 --- a/rs/moq-net/tests/integration/datagram.rs +++ b/rs/moq-net/tests/integration/datagram.rs @@ -125,9 +125,7 @@ async fn datagrams_reach_the_subscriber_in_order() { #[moq_clock::test] async fn ietf_delivers_datagrams() { for version in [ - "moq-transport-14", - "moq-transport-16", - "moq-transport-17", + "moq-transport-18", "moq-transport-20", ] { moq_clock::timeout(TEST_TIMEOUT, ietf_delivers_datagrams_on(version)) @@ -160,13 +158,10 @@ async fn ietf_delivers_datagrams_on(version: &str) { .unwrap(); let mut before = subscriber.recv_group().await.unwrap().unwrap(); assert_eq!(before.sequence, 0, "{version}"); - // Drafts 14 to 16 can't carry TIMESCALE, so the track arrives untimed, datagrams - // included. - let timed = !matches!(version, "moq-transport-14" | "moq-transport-16"); let first = before.next_frame().await.unwrap().unwrap().timestamp; assert_eq!( first.map(|timestamp| timestamp.is_zero()), - timed.then_some(true), + Some(true), "{version}" ); @@ -185,7 +180,7 @@ async fn ietf_delivers_datagrams_on(version: &str) { datagram .timestamp .map(|timestamp| timestamp.convert(expected.scale()).unwrap()), - timed.then_some(expected), + Some(expected), "{version}" ); diff --git a/rs/moq-net/tests/integration/dial_split_horizon.rs b/rs/moq-net/tests/integration/dial_split_horizon.rs index ca4df3e39e7..dc05613fde1 100644 --- a/rs/moq-net/tests/integration/dial_split_horizon.rs +++ b/rs/moq-net/tests/integration/dial_split_horizon.rs @@ -22,7 +22,7 @@ use support::{ const SETTLE: Duration = Duration::from_secs(1); fn version() -> Version { - "moq-transport-16".parse().unwrap() + "moq-transport-18".parse().unwrap() } fn produce(hop: u64) -> origin::Producer { diff --git a/rs/moq-net/tests/integration/empty_group.rs b/rs/moq-net/tests/integration/empty_group.rs index ad7e1dd7c65..10e9fefe93c 100644 --- a/rs/moq-net/tests/integration/empty_group.rs +++ b/rs/moq-net/tests/integration/empty_group.rs @@ -20,9 +20,7 @@ const TIMEOUT: Duration = Duration::from_secs(10); const VERSIONS: &[&str] = &[ "moq-lite-06", - "moq-transport-14", - "moq-transport-16", - "moq-transport-17", + "moq-transport-18", "moq-transport-22", ]; diff --git a/rs/moq-net/tests/integration/extensions.rs b/rs/moq-net/tests/integration/extensions.rs index 7e8364c60db..c23ce64e9eb 100644 --- a/rs/moq-net/tests/integration/extensions.rs +++ b/rs/moq-net/tests/integration/extensions.rs @@ -16,11 +16,7 @@ use support::harness::{MockConnectOptions, MockPair, connect_mock}; const SETTLE: Duration = Duration::from_secs(1); /// Every moq-transport draft, each of which carries the SOLICIT option. -const MOQT: [&str; 9] = [ - "moq-transport-14", - "moq-transport-15", - "moq-transport-16", - "moq-transport-17", +const MOQT: [&str; 5] = [ "moq-transport-18", "moq-transport-19", "moq-transport-20", @@ -28,8 +24,8 @@ const MOQT: [&str; 9] = [ "moq-transport-22", ]; -/// The first draft that negotiates MoQ Auth, and the newest. -const AUTH: [&str; 2] = ["moq-transport-17", "moq-transport-22"]; +/// The oldest draft we speak, which negotiates MoQ Auth, and the newest. +const AUTH: [&str; 2] = ["moq-transport-18", "moq-transport-22"]; fn produce_origin(hop: u64) -> origin::Producer { let (producer, driver) = origin::Producer::new(origin::Config::new(Hop::new(hop).unwrap())); @@ -183,7 +179,6 @@ fn route(origin: &origin::Producer, path: &str) -> Option { async fn an_epoch_crosses_only_when_both_offer_it() { for name in MOQT { let version: Version = name.parse().unwrap(); - let negotiable = !matches!(name, "moq-transport-14" | "moq-transport-15" | "moq-transport-16"); for server_publishes in [true, false] { for declines in [None, Some("server"), Some("client")] { let context = format!("{name}, server publishes: {server_publishes}, declines: {declines:?}"); @@ -217,7 +212,7 @@ async fn an_epoch_crosses_only_when_both_offer_it() { moq_clock::sleep(SETTLE).await; let route = route(&subscriber, "room/cam").unwrap_or_else(|| panic!("{context}: never announced")); - let expected = (negotiable && declines.is_none()).then_some(epoch); + let expected = declines.is_none().then_some(epoch); assert_eq!(route.epoch, expected, "{context}"); assert_open(&pair, &context); } diff --git a/rs/moq-net/tests/integration/fetch_only.rs b/rs/moq-net/tests/integration/fetch_only.rs index 70d7bd7fffb..9f70c97e990 100644 --- a/rs/moq-net/tests/integration/fetch_only.rs +++ b/rs/moq-net/tests/integration/fetch_only.rs @@ -91,9 +91,6 @@ fn frames(sequence: u64) -> Vec> { /// Draft-17 is absent: its TRACK_STATUS answer cannot say whether the track is timed, /// so it still SUBSCRIBEs to learn the track. const VERSIONS: &[&str] = &[ - "moq-transport-14", - "moq-transport-15", - "moq-transport-16", "moq-transport-18", "moq-transport-19", "moq-transport-22", diff --git a/rs/moq-net/tests/integration/finite_relay.rs b/rs/moq-net/tests/integration/finite_relay.rs index ff700f21e43..8d16ffad4f9 100644 --- a/rs/moq-net/tests/integration/finite_relay.rs +++ b/rs/moq-net/tests/integration/finite_relay.rs @@ -33,8 +33,7 @@ const VERSIONS: &[&str] = &[ "moq-lite-05", "moq-lite-06", "moq-lite-07-wip", - "moq-transport-14", - "moq-transport-17", + "moq-transport-18", "moq-transport-22", ]; diff --git a/rs/moq-net/tests/integration/goaway.rs b/rs/moq-net/tests/integration/goaway.rs index 72f1395032f..0d69667c91a 100644 --- a/rs/moq-net/tests/integration/goaway.rs +++ b/rs/moq-net/tests/integration/goaway.rs @@ -35,9 +35,6 @@ const TEST_TIMEOUT: Duration = Duration::from_secs(10); const GOAWAY_VERSIONS: &[&str] = &[ "moq-lite-04", "moq-lite-05", - "moq-transport-14", - "moq-transport-16", - "moq-transport-17", "moq-transport-18", "moq-transport-19", ]; @@ -138,7 +135,7 @@ async fn goaway_send_receive_all_versions() { #[moq_clock::test] async fn goaway_wire_timeout_moq_transport_17() { moq_clock::timeout(TEST_TIMEOUT, async { - let version: Version = "moq-transport-17".parse().unwrap(); + let version: Version = "moq-transport-18".parse().unwrap(); let pair = connect_mock(MockConnectOptions::new(version)).await; pair.server @@ -253,7 +250,7 @@ async fn goaway_client_redirect_refused_moq_transport_19() { #[moq_clock::test] async fn goaway_timeout_force_close_moq_transport_17() { moq_clock::timeout(TEST_TIMEOUT, async { - let version: Version = "moq-transport-17".parse().unwrap(); + let version: Version = "moq-transport-18".parse().unwrap(); let pair = connect_mock(MockConnectOptions::new(version)).await; pair.server diff --git a/rs/moq-net/tests/integration/group_order.rs b/rs/moq-net/tests/integration/group_order.rs index 581fe3c63bc..9b11f292572 100644 --- a/rs/moq-net/tests/integration/group_order.rs +++ b/rs/moq-net/tests/integration/group_order.rs @@ -160,8 +160,7 @@ async fn a_backlog_is_served_in_the_subscription_order() { "moq-lite-05", "moq-lite-06", "moq-lite-07-wip", - "moq-transport-14", - "moq-transport-17", + "moq-transport-18", "moq-transport-22", ] { for relay in [false, true] { @@ -186,7 +185,7 @@ async fn a_backlog_is_served_in_the_subscription_order() { /// its own subscriber's backlog in that subscriber's order. #[moq_clock::test] async fn merged_subscribers_keep_their_own_order() { - for version in ["moq-lite-07-wip", "moq-transport-17"] { + for version in ["moq-lite-07-wip", "moq-transport-18"] { let version: Version = version.parse().unwrap(); let publisher = produce_origin(1); let broadcast = publisher.create_broadcast("bcast").unwrap(); diff --git a/rs/moq-net/tests/integration/history_groups.rs b/rs/moq-net/tests/integration/history_groups.rs index e7ada798343..fd813fb17c2 100644 --- a/rs/moq-net/tests/integration/history_groups.rs +++ b/rs/moq-net/tests/integration/history_groups.rs @@ -25,8 +25,7 @@ const VERSIONS: &[&str] = &[ "moq-lite-03", "moq-lite-05", "moq-lite-07-wip", - "moq-transport-14", - "moq-transport-17", + "moq-transport-18", "moq-transport-22", ]; diff --git a/rs/moq-net/tests/integration/idle_session.rs b/rs/moq-net/tests/integration/idle_session.rs index 593ee2ead4f..342441eb920 100644 --- a/rs/moq-net/tests/integration/idle_session.rs +++ b/rs/moq-net/tests/integration/idle_session.rs @@ -110,7 +110,7 @@ async fn busy_viewer_sees_the_estimate_move() { /// A transport estimate demanded locally still costs one poll per sampling deadline. #[moq_clock::test] async fn ietf_stats_refresh_costs_one_driver_poll() { - for version in ["moq-transport-16", "moq-transport-22"] { + for version in [ "moq-transport-22"] { let polls = Arc::new(AtomicUsize::new(0)); let mut options = MockConnectOptions::new(version.parse::().unwrap()); options.stats = STATS; @@ -175,7 +175,7 @@ async fn probe_follows_consumer_lifetime() { /// A stats tick reads the transport's wire counters and adds no sampler timer or session wake. #[moq_clock::test] async fn wire_collection_never_arms_the_idle_sampler() { - for version in ["moq-lite-06", "moq-lite-07-wip", "moq-transport-16", "moq-transport-22"] { + for version in ["moq-lite-06", "moq-lite-07-wip", "moq-transport-22"] { let registry = moq_net::stats::Registry::new(Default::default()); let polls = Arc::new(AtomicUsize::new(0)); let mut options = MockConnectOptions::new(version.parse().unwrap()); diff --git a/rs/moq-net/tests/integration/ietf_conformance.rs b/rs/moq-net/tests/integration/ietf_conformance.rs index 07c18ad865e..fc66a14e1d5 100644 --- a/rs/moq-net/tests/integration/ietf_conformance.rs +++ b/rs/moq-net/tests/integration/ietf_conformance.rs @@ -76,14 +76,14 @@ async fn routing(version: &str, cluster: bool) { #[moq_clock::test] async fn conformance_namespaces_route_through_one_relay() { - for version in ["moq-transport-16", "moq-transport-18"] { + for version in [ "moq-transport-18"] { routing(version, false).await; } } #[moq_clock::test] async fn conformance_namespaces_route_through_a_lite_cluster() { - for version in ["moq-transport-16", "moq-transport-18"] { + for version in [ "moq-transport-18"] { routing(version, true).await; } } diff --git a/rs/moq-net/tests/integration/implementation.rs b/rs/moq-net/tests/integration/implementation.rs index 2866cd9db04..1fd35c1ee53 100644 --- a/rs/moq-net/tests/integration/implementation.rs +++ b/rs/moq-net/tests/integration/implementation.rs @@ -10,7 +10,7 @@ use moq_net::Version; use support::harness::{MockConnectOptions, connect_mock}; /// Every version, and whether its SETUP carries an implementation. -const VERSIONS: [(&str, bool); 16] = [ +const VERSIONS: [(&str, bool); 12] = [ ("moq-lite-01", false), ("moq-lite-02", false), ("moq-lite-03", false), @@ -18,10 +18,6 @@ const VERSIONS: [(&str, bool); 16] = [ ("moq-lite-05", true), ("moq-lite-06", true), ("moq-lite-07-wip", true), - ("moq-transport-14", true), - ("moq-transport-15", true), - ("moq-transport-16", true), - ("moq-transport-17", true), ("moq-transport-18", true), ("moq-transport-19", true), ("moq-transport-20", true), @@ -62,7 +58,7 @@ async fn each_side_reads_the_others_implementation() { /// Unconfigured, each side names this crate; configured empty, it advertises nothing. #[moq_clock::test] async fn the_default_names_the_crate_and_empty_omits_it() { - for name in ["moq-lite-06", "moq-transport-16", "moq-transport-22"] { + for name in ["moq-lite-06", "moq-transport-22"] { let version: Version = name.parse().unwrap(); let (seen_by_server, seen_by_client) = exchange(version, None, Some("")).await; assert_eq!(seen_by_server.as_deref(), Some(moq_net::IMPLEMENTATION), "{name}"); diff --git a/rs/moq-net/tests/integration/late_lower_group.rs b/rs/moq-net/tests/integration/late_lower_group.rs index a7aa035cdbd..06e8a1a2191 100644 --- a/rs/moq-net/tests/integration/late_lower_group.rs +++ b/rs/moq-net/tests/integration/late_lower_group.rs @@ -25,7 +25,7 @@ const FOREVER: Duration = Duration::from_millis((1 << 53) - 1); const LITE: &[&str] = &["moq-lite-05", "moq-lite-06", "moq-lite-07-wip"]; -const TRANSPORT: &[&str] = &["moq-transport-14", "moq-transport-17", "moq-transport-22"]; +const TRANSPORT: &[&str] = &[ "moq-transport-18", "moq-transport-22"]; /// From `start`, or the oldest group still around when there is none. fn floored(start: Option) -> Range { diff --git a/rs/moq-net/tests/integration/lazy_discovery.rs b/rs/moq-net/tests/integration/lazy_discovery.rs index 42075bce0fb..ff71398649a 100644 --- a/rs/moq-net/tests/integration/lazy_discovery.rs +++ b/rs/moq-net/tests/integration/lazy_discovery.rs @@ -363,10 +363,6 @@ async fn serving_the_peer_asks_nothing() { /// 15 answer with PUBLISH_NAMESPACE requests after the OK), so these read what arrived once /// everything in flight has. const IETF: &[&str] = &[ - "moq-transport-14", - "moq-transport-15", - "moq-transport-16", - "moq-transport-17", "moq-transport-18", "moq-transport-19", "moq-transport-20", diff --git a/rs/moq-net/tests/integration/mesh_withdraw.rs b/rs/moq-net/tests/integration/mesh_withdraw.rs index c27e0cfb016..bdac9970d91 100644 --- a/rs/moq-net/tests/integration/mesh_withdraw.rs +++ b/rs/moq-net/tests/integration/mesh_withdraw.rs @@ -631,7 +631,6 @@ async fn hop_limit_bounds_receive_and_send() { "moq-lite-05", "moq-lite-06", "moq-lite-07-wip", - "moq-transport-17", "moq-transport-18", "moq-transport-19", "moq-transport-20", @@ -703,7 +702,6 @@ async fn hop_limit_falls_back_to_a_forwardable_route() { for name in [ "moq-lite-06", "moq-lite-07-wip", - "moq-transport-17", "moq-transport-18", "moq-transport-19", "moq-transport-20", diff --git a/rs/moq-net/tests/integration/multi_cdn.rs b/rs/moq-net/tests/integration/multi_cdn.rs index 9c65bc72952..c5c66d052ae 100644 --- a/rs/moq-net/tests/integration/multi_cdn.rs +++ b/rs/moq-net/tests/integration/multi_cdn.rs @@ -355,59 +355,6 @@ async fn transport_secondary_is_refused() { /// The same over the first draft that can carry the epoch. #[moq_clock::test] async fn transport_17_secondary_is_refused() { - refused_across_protocols("moq-transport-17").await; + refused_across_protocols("moq-transport-18").await; } -/// A moq-transport `B` before draft-17 carries no epoch, so `S` cannot resume onto it: -/// losing `A` restarts the path and ends the subscription, and a re-request lands on `B`. -/// `A` returning is another restart, and a re-request lands back on `A`. -#[moq_clock::test] -async fn epochless_secondary_restarts() { - moq_clock::timeout(TEST_TIMEOUT, async { - let mut topology = Topology::new("moq-transport-16".parse().unwrap()).await; - let mut announced = topology.subscriber.consume().announced(); - let start = announced.next().await.expect("announced"); - assert!(via_a(&start), "{start:?}"); - - let mut rx = topology.subscribe().await; - let seen = topology.group_through_a(&mut rx).await; - assert_continuous(&seen, 1); - - topology.lose_a().await; - let restart = announced.next().await.expect("announced"); - assert!( - matches!(restart, announce::Event::Restart(_)) && !via_a(&restart), - "no epoch over B: {restart:?}" - ); - topology.group(); - settle().await; - match moq_clock::timeout(Duration::from_secs(10), rx.next()) - .await - .expect("reader hung") - { - None | Some((_, Err(_))) => {} - Some((group, Ok(_))) => panic!("resumed onto B at group {group}"), - } - - // A re-request lands on B, the only CDN left. It may start at the latest group, - // written while nobody was subscribed, before reaching the next one. - let mut rx = topology.subscribe().await; - topology.group(); - while next(&mut rx).await.0 != 2 {} - - topology.restore_a().await; - let restart = announced.next().await.expect("announced"); - assert!( - matches!(restart, announce::Event::Restart(_)) && via_a(&restart), - "back on A: {restart:?}" - ); - // A re-request lands on A: the next group arrives while B holds back its own. - let mut rx = topology.subscribe().await; - topology.s_to_b.server_transport.hold_unis(); - topology.group(); - while next(&mut rx).await.0 != 3 {} - topology.s_to_b.server_transport.release_unis(); - }) - .await - .expect("timed out"); -} diff --git a/rs/moq-net/tests/integration/partial_group.rs b/rs/moq-net/tests/integration/partial_group.rs index 609ee7e5462..ba9baaedf8c 100644 --- a/rs/moq-net/tests/integration/partial_group.rs +++ b/rs/moq-net/tests/integration/partial_group.rs @@ -20,10 +20,6 @@ const BUDGET: Duration = Duration::from_millis(500); const VERSIONS: &[&str] = &[ "moq-lite-06", "moq-lite-07-wip", - "moq-transport-14", - "moq-transport-15", - "moq-transport-16", - "moq-transport-17", "moq-transport-18", "moq-transport-19", "moq-transport-20", diff --git a/rs/moq-net/tests/integration/quiet_catalog.rs b/rs/moq-net/tests/integration/quiet_catalog.rs index dab2e9e4a32..ead5d7c4860 100644 --- a/rs/moq-net/tests/integration/quiet_catalog.rs +++ b/rs/moq-net/tests/integration/quiet_catalog.rs @@ -19,7 +19,7 @@ fn timed() -> moq_net::track::Info { const TIMEOUT: Duration = Duration::from_secs(5); -const VERSIONS: &[&str] = &["moq-lite-06", "moq-lite-07-wip", "moq-transport-16", "moq-transport-22"]; +const VERSIONS: &[&str] = &["moq-lite-06", "moq-lite-07-wip", "moq-transport-22"]; /// The versions that forward a resume's floor upstream; the IETF relay subscribes without one. const LITE: &[&str] = &["moq-lite-06", "moq-lite-07-wip"]; diff --git a/rs/moq-net/tests/integration/range_anchors.rs b/rs/moq-net/tests/integration/range_anchors.rs index d1d1c3e2c7d..f6494697596 100644 --- a/rs/moq-net/tests/integration/range_anchors.rs +++ b/rs/moq-net/tests/integration/range_anchors.rs @@ -24,9 +24,7 @@ const VERSIONS: &[&str] = &[ "moq-lite-05", "moq-lite-06", "moq-lite-07-wip", - "moq-transport-14", - "moq-transport-16", - "moq-transport-17", + "moq-transport-18", "moq-transport-20", "moq-transport-22", ]; @@ -133,7 +131,7 @@ async fn each_wire_refuses_only_the_anchors_it_drops() { let timed = !matches!( version, Some( - "moq-lite-03" | "moq-lite-04" | "moq-lite-05" | "moq-lite-06" | "moq-transport-14" | "moq-transport-16" + "moq-lite-03" | "moq-lite-04" | "moq-lite-05" | "moq-lite-06" ) ); for (range, held) in anchored() { diff --git a/rs/moq-net/tests/integration/relay_upstream_close.rs b/rs/moq-net/tests/integration/relay_upstream_close.rs index ee3096ca8dd..c1a54a1f6fd 100644 --- a/rs/moq-net/tests/integration/relay_upstream_close.rs +++ b/rs/moq-net/tests/integration/relay_upstream_close.rs @@ -36,8 +36,7 @@ const VERSIONS: &[&str] = &[ "moq-lite-05", "moq-lite-06", "moq-lite-07-wip", - "moq-transport-14", - "moq-transport-17", + "moq-transport-18", "moq-transport-22", ]; diff --git a/rs/moq-net/tests/integration/replacement.rs b/rs/moq-net/tests/integration/replacement.rs index 98c33b1bc87..068cbf5e425 100644 --- a/rs/moq-net/tests/integration/replacement.rs +++ b/rs/moq-net/tests/integration/replacement.rs @@ -174,7 +174,7 @@ async fn epoch_lite07() { /// moq-transport carries the epoch with the MoQ Epoch extension, from draft-17. #[moq_clock::test] async fn epoch_ietf() { - for version in ["moq-transport-17", "moq-transport-22"] { + for version in ["moq-transport-18", "moq-transport-22"] { moq_clock::timeout(TEST_TIMEOUT, replace(version, Some(epoch()))) .await .expect("timed out"); diff --git a/rs/moq-net/tests/integration/request_caps.rs b/rs/moq-net/tests/integration/request_caps.rs index ca70c7b092b..f48881be810 100644 --- a/rs/moq-net/tests/integration/request_caps.rs +++ b/rs/moq-net/tests/integration/request_caps.rs @@ -1,10 +1,9 @@ #![cfg(feature = "async")] -//! A server bounds what one client can make it hold: flow control bounds its requests, a -//! client past [`moq_net::session::Limits::announces`] loses the session with -//! TOO_MANY_REQUESTS, and on moq-transport drafts 14 to 16 the MAX_REQUEST_ID window the -//! limits size is granted back as requests close, so a client that keeps opening and closing -//! requests within them never stalls. +//! A server bounds what one client can make it hold: stream flow control bounds its +//! requests, and a client past [`moq_net::session::Limits::announces`] loses the session +//! with TOO_MANY_REQUESTS. Credit is granted back as requests close, so a client that keeps +//! opening and closing requests never stalls. use crate::support; @@ -15,14 +14,8 @@ use support::harness::{MockConnectOptions, MockPair, connect_mock}; const TIMEOUT: Duration = Duration::from_secs(10); -/// Drafts with MAX_REQUEST_ID, a draft without it, and the lite draft production runs. -const VERSIONS: [&str; 5] = [ - "moq-transport-14", - "moq-transport-15", - "moq-transport-16", - "moq-transport-17", - "moq-lite-06", -]; +/// A moq-transport draft and the lite draft production runs. +const VERSIONS: [&str; 2] = ["moq-transport-18", "moq-lite-06"]; fn produce_origin(hop: u64) -> moq_net::origin::Producer { let (producer, driver) = moq_net::origin::Producer::new(moq_net::origin::Config::new(Hop::new(hop).unwrap())); @@ -65,23 +58,20 @@ async fn setup(version: &str, limits: Limits, tracks: usize) -> Setup { } } -fn limits(announces: usize, requests: usize) -> Limits { +fn limits(announces: usize) -> Limits { let mut limits = Limits::default(); limits.announces = announces; - limits.requests = requests; limits } -/// Many more requests than the window admits at once, opened and closed in turn, all +/// Many more requests than the stream credit admits at once, opened and closed in turn, all /// succeed: each one that closes is granted back. #[moq_clock::test] async fn closed_requests_are_granted_back() { const ROUNDS: usize = 64; for version in VERSIONS { - // A window of 8 requests, far fewer than the rounds below. Doubling the limit leaves - // room for an UNSUBSCRIBE still in flight when the next SUBSCRIBE lands. - let setup = setup(version, limits(0, 4), ROUNDS).await; + let setup = setup(version, limits(0), ROUNDS).await; let broadcast = moq_clock::timeout(TIMEOUT, setup.client.consume().routed_broadcast("bcast")) .await .expect("announce timeout") @@ -107,11 +97,11 @@ async fn closed_requests_are_granted_back() { } /// With no subscription cap, a client asking for more subscriptions than the server admits -/// still holds no more than the request window (drafts 14 to 16) or the stream credit -/// (moq-lite, draft 17 and later) at once. The rest wait rather than close the session. +/// still holds no more than the stream credit at once. The rest wait rather than close the +/// session. #[moq_clock::test] async fn flow_control_bounds_the_subscriptions_a_peer_holds() { - // A window of 8 requests, and 8 bidi streams toward the server. + // 8 bidi streams toward the server. const BOUND: usize = 8; const TRACKS: usize = 3 * BOUND; @@ -129,7 +119,7 @@ async fn flow_control_bounds_the_subscriptions_a_peer_holds() { options.transport.max_concurrent_bi_streams = Some(BOUND); options.server_publish = Some(server.consume()); options.client_subscribe = Some(client.clone()); - options.server_limits = Some(limits(0, BOUND / 2)); + options.server_limits = Some(limits(0)); let pair = connect_mock(options).await; let remote = moq_clock::timeout(TIMEOUT, client.consume().routed_broadcast("bcast")) @@ -177,7 +167,7 @@ async fn an_announce_past_the_cap_closes_the_session() { let mut options = MockConnectOptions::new(version); options.client_publish = Some(client.consume()); options.server_subscribe = Some(server.clone()); - options.server_limits = Some(limits(1, 1)); + options.server_limits = Some(limits(1)); let pair = connect_mock(options).await; let err = moq_clock::timeout(TIMEOUT, pair.client.closed()) diff --git a/rs/moq-net/tests/integration/restart.rs b/rs/moq-net/tests/integration/restart.rs index cec0496f1a9..4efbcde258d 100644 --- a/rs/moq-net/tests/integration/restart.rs +++ b/rs/moq-net/tests/integration/restart.rs @@ -520,10 +520,6 @@ retired_fetch_tests! { retired_fetch_lite05: "moq-lite-05", retired_fetch_lite06: "moq-lite-06", retired_fetch_lite07: "moq-lite-07-wip", - retired_fetch_ietf14: "moq-transport-14", - retired_fetch_ietf15: "moq-transport-15", - retired_fetch_ietf16: "moq-transport-16", - retired_fetch_ietf17: "moq-transport-17", retired_fetch_ietf18: "moq-transport-18", retired_fetch_ietf19: "moq-transport-19", retired_fetch_ietf20: "moq-transport-20", @@ -544,7 +540,6 @@ async fn withdrawal_refuses_new_fetches_but_keeps_open_reads() { "moq-lite-05", "moq-lite-06", "moq-lite-07-wip", - "moq-transport-14", "moq-transport-22", ] { let version: Version = version.parse().unwrap(); @@ -573,7 +568,6 @@ async fn a_more_specific_source_cannot_fill_a_held_covering_track() { "moq-lite-05", "moq-lite-06", "moq-lite-07-wip", - "moq-transport-14", "moq-transport-22", ] { let version: Version = name.parse().unwrap(); @@ -714,7 +708,6 @@ claim_restart_tests! { claim_restart_lite05: "moq-lite-05", claim_restart_lite06: "moq-lite-06", claim_restart_lite07: "moq-lite-07-wip", - claim_restart_ietf14: "moq-transport-14", - claim_restart_ietf16: "moq-transport-16", + claim_restart_ietf18: "moq-transport-18", claim_restart_ietf22: "moq-transport-22", } diff --git a/rs/moq-net/tests/integration/route_change.rs b/rs/moq-net/tests/integration/route_change.rs index 82787cf5888..7ea04e379a8 100644 --- a/rs/moq-net/tests/integration/route_change.rs +++ b/rs/moq-net/tests/integration/route_change.rs @@ -468,7 +468,7 @@ macro_rules! route_change_tests { route_change_tests! { lite_07: "moq-lite-07-wip", - ietf_17: "moq-transport-17", + ietf_18: "moq-transport-18", ietf_19: "moq-transport-19", ietf_22: "moq-transport-22", } @@ -512,8 +512,6 @@ pinned_tests! { lite_06: "moq-lite-06", lite_05: "moq-lite-05", lite_04: "moq-lite-04", - ietf_14: "moq-transport-14", - ietf_16: "moq-transport-16", } /// `P` feeds `A` slowly and `B` promptly, and `R` reads through `A` until that route dies @@ -614,7 +612,7 @@ async fn lite_resumes_after_a_lagging_route_dies() { #[moq_clock::test] async fn ietf_17_resumes_after_a_lagging_route_dies() { - lagging_route_dies("moq-transport-17".parse().unwrap()).await; + lagging_route_dies("moq-transport-18".parse().unwrap()).await; } #[moq_clock::test] diff --git a/rs/moq-net/tests/integration/session_close.rs b/rs/moq-net/tests/integration/session_close.rs index 6b6cbe01cee..81c8992d07a 100644 --- a/rs/moq-net/tests/integration/session_close.rs +++ b/rs/moq-net/tests/integration/session_close.rs @@ -229,7 +229,7 @@ async fn abort_cuts_a_drain_short_for(version: &str) { #[moq_clock::test] async fn close_withdraws_announcements_before_closing_the_transport() { - for version in ["moq-lite-01", "moq-lite-07-wip", "moq-transport-17", "moq-transport-22"] { + for version in ["moq-lite-01", "moq-lite-07-wip", "moq-transport-18", "moq-transport-22"] { let publisher = produce_origin(1); let broadcast = publisher.create_broadcast("bcast").unwrap(); broadcast.announce(Default::default()).unwrap(); @@ -250,7 +250,7 @@ async fn close_withdraws_announcements_before_closing_the_transport() { #[moq_clock::test] async fn close_times_out_waiting_for_announcement_acknowledgements() { - for version in ["moq-lite-01", "moq-lite-07-wip", "moq-transport-17", "moq-transport-22"] { + for version in ["moq-lite-01", "moq-lite-07-wip", "moq-transport-18", "moq-transport-22"] { let publisher = produce_origin(1); let broadcast = publisher.create_broadcast("bcast").unwrap(); broadcast.announce(Default::default()).unwrap(); @@ -332,7 +332,7 @@ async fn earlier_lite_peer_close_reads_buffered_tail() { #[moq_clock::test] async fn ietf_peer_close_reads_buffered_tail() { - for version in ["moq-transport-14", "moq-transport-17", "moq-transport-22"] { + for version in [ "moq-transport-18", "moq-transport-22"] { peer_close_reads_buffered_tail(version).await; } } @@ -362,8 +362,7 @@ async fn peer_close_before_receiver_poll_keeps_buffered_tail() { "moq-lite-02", "moq-lite-05", "moq-lite-06", - "moq-transport-14", - "moq-transport-17", + "moq-transport-18", ] { let gate = kio::Producer::new(true); let Setup { @@ -385,7 +384,7 @@ async fn peer_close_before_receiver_poll_keeps_buffered_tail() { /// A locally unsupported feature uses only the negotiated session registry. #[moq_clock::test] async fn unsupported_abort_uses_the_negotiated_session_registry() { - for protocol in ["moq-lite-06", "moq-lite-07-wip", "moq-transport-17", "moq-transport-22"] { + for protocol in ["moq-lite-06", "moq-lite-07-wip", "moq-transport-18", "moq-transport-22"] { let version: Version = protocol.parse().unwrap(); let pair = connect_mock(MockConnectOptions::new(version)).await; pair.client.abort(Error::Unsupported); @@ -398,7 +397,7 @@ async fn unsupported_abort_uses_the_negotiated_session_registry() { /// A Lite-only close code arriving on IETF stays unknown instead of gaining Lite semantics. #[moq_clock::test] async fn unsupported_close_is_decoded_by_the_negotiated_session_registry() { - for protocol in ["moq-lite-06", "moq-lite-07-wip", "moq-transport-17", "moq-transport-22"] { + for protocol in ["moq-lite-06", "moq-lite-07-wip", "moq-transport-18", "moq-transport-22"] { let version: Version = protocol.parse().unwrap(); let mut pair = connect_mock(MockConnectOptions::new(version)).await; moq_net::transport::poll::Session::close(&mut pair.server_transport, 0x30, "unsupported"); @@ -416,7 +415,7 @@ async fn unsupported_close_is_decoded_by_the_negotiated_session_registry() { /// wire, while a code outside it passes through. #[moq_clock::test] async fn an_unknown_lite_range_abort_is_unspecified_on_every_wire() { - for protocol in ["moq-lite-06", "moq-lite-07-wip", "moq-transport-17", "moq-transport-22"] { + for protocol in ["moq-lite-06", "moq-lite-07-wip", "moq-transport-18", "moq-transport-22"] { for (unknown, expected) in [(0x31, 0x1), (0x20, 0x20)] { let version: Version = protocol.parse().unwrap(); let pair = connect_mock(MockConnectOptions::new(version)).await; @@ -452,7 +451,7 @@ async fn ended(version: &str, close: impl FnOnce(&MockPair)) -> (Error, moq_net: #[moq_clock::test] async fn a_session_records_how_it_ended() { use moq_net::stats::Failures; - for version in ["moq-lite-06", "moq-lite-07-wip", "moq-transport-16", "moq-transport-22"] { + for version in ["moq-lite-06", "moq-lite-07-wip", "moq-transport-22"] { let (err, failed) = ended(version, |pair| pair.client.abort(Error::Cancel)).await; assert!(matches!(err, Error::Cancel), "{version}: {err:?}"); assert_eq!(failed, Failures::default(), "{version}"); diff --git a/rs/moq-net/tests/integration/subscribe_priority.rs b/rs/moq-net/tests/integration/subscribe_priority.rs index 1ec161c36b1..9be3289cab3 100644 --- a/rs/moq-net/tests/integration/subscribe_priority.rs +++ b/rs/moq-net/tests/integration/subscribe_priority.rs @@ -16,10 +16,6 @@ const TIMEOUT: Duration = Duration::from_secs(10); const VERSIONS: &[&str] = &[ "moq-lite-06", "moq-lite-07-wip", - "moq-transport-14", - "moq-transport-15", - "moq-transport-16", - "moq-transport-17", "moq-transport-18", "moq-transport-19", "moq-transport-20", diff --git a/rs/moq-net/tests/integration/subscribe_ranges.rs b/rs/moq-net/tests/integration/subscribe_ranges.rs index 7375b7f8eb7..4372bcc5ef1 100644 --- a/rs/moq-net/tests/integration/subscribe_ranges.rs +++ b/rs/moq-net/tests/integration/subscribe_ranges.rs @@ -18,7 +18,7 @@ const LITE: &[&str] = &["moq-lite-05", "moq-lite-06", "moq-lite-07-wip"]; /// Draft-20 and later are left out: the first subscriber's absolute start goes upstream /// in the SUBSCRIBE filter, and the subscriber never widens it when a live one joins /// (`quest/m1/subscribe-ranges/ietf.md`), so group 3 never arrives. -const TRANSPORT: &[&str] = &["moq-transport-14", "moq-transport-17"]; +const TRANSPORT: &[&str] = &[ "moq-transport-18"]; fn produce_origin(hop: u64) -> moq_net::origin::Producer { let (producer, driver) = diff --git a/rs/moq-net/tests/integration/subscribe_tracks.rs b/rs/moq-net/tests/integration/subscribe_tracks.rs index abda5ccd5b4..c22fe76cf85 100644 --- a/rs/moq-net/tests/integration/subscribe_tracks.rs +++ b/rs/moq-net/tests/integration/subscribe_tracks.rs @@ -173,7 +173,7 @@ async fn subscribe_tracks_needs_forward_0_on_draft_18() { /// Before draft-18, 0x51 is not a message at all, so it is still a protocol violation. #[moq_clock::test] async fn subscribe_tracks_before_draft_18_closes_the_session() { - let setup = setup("moq-transport-17".parse().unwrap()).await; + let setup = setup("moq-transport-18".parse().unwrap()).await; let (mut send, _recv) = setup .pair .server_transport diff --git a/rs/moq-net/tests/integration/subscription_end_integrity.rs b/rs/moq-net/tests/integration/subscription_end_integrity.rs index 3814ece5db2..7cf37edc556 100644 --- a/rs/moq-net/tests/integration/subscription_end_integrity.rs +++ b/rs/moq-net/tests/integration/subscription_end_integrity.rs @@ -194,8 +194,7 @@ const DEATH_VERSIONS: &[&str] = &[ "moq-lite-03", "moq-lite-05", "moq-lite-07-wip", - "moq-transport-14", - "moq-transport-17", + "moq-transport-18", "moq-transport-22", ]; diff --git a/rs/moq-net/tests/integration/synced.rs b/rs/moq-net/tests/integration/synced.rs index cbb741d5c8d..c15b506e5af 100644 --- a/rs/moq-net/tests/integration/synced.rs +++ b/rs/moq-net/tests/integration/synced.rs @@ -72,8 +72,6 @@ async fn an_exact_boundary_catches_up_with_the_initial_set() { "moq-lite-05", "moq-lite-06", "moq-lite-07-wip", - "moq-transport-16", - "moq-transport-17", "moq-transport-18", "moq-transport-19", "moq-transport-20", @@ -87,7 +85,7 @@ async fn an_exact_boundary_catches_up_with_the_initial_set() { /// Versions without a boundary still sync, so nothing waiting on it hangs. #[moq_clock::test] async fn a_best_effort_boundary_still_catches_up() { - for version in ["moq-lite-03", "moq-lite-04", "moq-transport-14", "moq-transport-15"] { + for version in ["moq-lite-03", "moq-lite-04"] { synced(version).await; } } diff --git a/rs/moq-net/tests/integration/track_tail.rs b/rs/moq-net/tests/integration/track_tail.rs index 10fbf478745..ac30c90045e 100644 --- a/rs/moq-net/tests/integration/track_tail.rs +++ b/rs/moq-net/tests/integration/track_tail.rs @@ -35,8 +35,7 @@ const VERSIONS: &[&str] = &[ "moq-lite-03", "moq-lite-05", "moq-lite-07-wip", - "moq-transport-14", - "moq-transport-17", + "moq-transport-18", "moq-transport-20", "moq-transport-22", ]; @@ -261,8 +260,7 @@ async fn lite07_empty_track_ends_without_the_grace() { /// IETF drafts over the control stream adapter (14), on their own streams (17), and with /// subscription fills (20+). const IETF: &[&str] = &[ - "moq-transport-14", - "moq-transport-17", + "moq-transport-18", "moq-transport-20", "moq-transport-22", ]; diff --git a/rs/moq-net/tests/integration/tracks_ietf.rs b/rs/moq-net/tests/integration/tracks_ietf.rs index f1fe79db18b..618130a195c 100644 --- a/rs/moq-net/tests/integration/tracks_ietf.rs +++ b/rs/moq-net/tests/integration/tracks_ietf.rs @@ -193,7 +193,7 @@ async fn before_draft_18_the_listing_is_refused() { let a = broadcast.create_track("a", None).unwrap(); broadcast.announce(Default::default()).unwrap(); - let (subscriber, _pair) = connect(&publisher, "moq-transport-17").await; + let (subscriber, _pair) = connect(&publisher, "moq-transport-18").await; let remote = resolve(&subscriber, "bcast").await; let mut tracks = remote.tracks().unwrap(); assert_eq!( diff --git a/rs/moq-net/tests/integration/untimed.rs b/rs/moq-net/tests/integration/untimed.rs index f80e65755cd..ea408df516d 100644 --- a/rs/moq-net/tests/integration/untimed.rs +++ b/rs/moq-net/tests/integration/untimed.rs @@ -35,8 +35,6 @@ fn expected(version: &str) -> Arrives { match version { // Lite-05 and lite-06 stamp untimed tracks with send times, so their receivers drop them. "moq-lite-03" | "moq-lite-04" | "moq-lite-05" | "moq-lite-06" => Arrives::Untimed, - // Drafts 14 to 16 can't carry TIMESCALE. - "moq-transport-14" | "moq-transport-16" => Arrives::Untimed, _ => Arrives::Faithful, } } @@ -47,9 +45,7 @@ const VERSIONS: &[&str] = &[ "moq-lite-05", "moq-lite-06", "moq-lite-07-wip", - "moq-transport-14", - "moq-transport-16", - "moq-transport-17", + "moq-transport-18", "moq-transport-20", ]; @@ -148,7 +144,7 @@ async fn frames_arrive_as_published() { #[moq_clock::test] async fn a_relay_forwards_an_untimed_track_untimed() { for hops in [ - &["moq-transport-17", "moq-transport-20"][..], + &["moq-transport-18", "moq-transport-20"][..], &["moq-lite-07-wip", "moq-lite-07-wip"][..], ] { let (frame, info) = frame_through(hops, untimed()).await; @@ -157,8 +153,8 @@ async fn a_relay_forwards_an_untimed_track_untimed() { } for hops in [ - &["moq-lite-03", "moq-transport-17"][..], - &["moq-transport-16", "moq-transport-20"][..], + &["moq-lite-03", "moq-transport-18"][..], + &[ "moq-transport-20"][..], ] { let (frame, info) = frame_through(hops, timed()).await; assert_eq!(frame, None, "{hops:?}: the first hop has no timestamps to forward"); @@ -210,7 +206,7 @@ async fn an_explicit_start_holds_on_an_untimed_track() { /// time that the receiver drops. #[moq_clock::test] async fn datagrams_arrive_as_published() { - for version in ["moq-lite-05", "moq-lite-07-wip", "moq-transport-16", "moq-transport-20"] { + for version in ["moq-lite-05", "moq-lite-07-wip", "moq-transport-20"] { let chain = Chain::new(&[version]).await; let broadcast = chain.nodes[0].create_broadcast("room").unwrap(); let mut producer = broadcast.create_track("data", untimed()).unwrap(); From 386d3663b4791a5c84ede3a19ef4ba0db2fbb364 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sun, 25 Oct 2026 03:22:43 -0700 Subject: [PATCH 12/67] wip: drop drafts 14-17 from the relay, tooling and CI lanes Co-Authored-By: Claude Opus 5.5 --- .github/workflows/interop.yml | 2 +- rs/moq-cli/src/publish.rs | 2 +- rs/moq-cli/tests/integration/epochs.rs | 6 +- rs/moq-e2ee/tests/support/harness.rs | 2 +- rs/moq-ffi/src/test.rs | 24 +- rs/moq-gst/src/connection.rs | 8 +- rs/moq-net/src/client.rs | 8 +- rs/moq-net/src/coding/writer.rs | 4 - rs/moq-net/src/fuzz.rs | 25 + rs/moq-net/src/ietf/cluster.rs | 1 - rs/moq-net/src/ietf/datagram.rs | 13 +- rs/moq-net/src/ietf/error.rs | 10 +- rs/moq-net/src/ietf/filter.rs | 9 +- rs/moq-net/src/ietf/group.rs | 6 +- rs/moq-net/src/ietf/namespace.rs | 4 +- rs/moq-net/src/ietf/object.rs | 5 +- rs/moq-net/src/ietf/parameters.rs | 44 +- rs/moq-net/src/ietf/properties.rs | 1 - rs/moq-net/src/ietf/publish.rs | 32 +- rs/moq-net/src/ietf/publisher.rs | 297 ++------- rs/moq-net/src/ietf/publisher/tracks.rs | 23 +- rs/moq-net/src/ietf/request_stream.rs | 5 +- rs/moq-net/src/ietf/request_update.rs | 9 +- rs/moq-net/src/ietf/session.rs | 15 +- rs/moq-net/src/ietf/subscribe.rs | 258 ++++---- rs/moq-net/src/ietf/subscribe_namespace.rs | 2 - rs/moq-net/src/ietf/subscribe_tracks.rs | 11 - rs/moq-net/src/ietf/subscriber.rs | 589 +++++------------- rs/moq-net/src/ietf/token.rs | 4 +- rs/moq-net/src/lite/ietf.rs | 36 +- rs/moq-net/src/server.rs | 27 +- rs/moq-net/src/setup.rs | 33 +- rs/moq-net/src/test_interop.rs | 18 +- rs/moq-net/tests/integration/compress.rs | 31 +- rs/moq-net/tests/integration/control_stats.rs | 7 +- rs/moq-net/tests/integration/datagram.rs | 11 +- rs/moq-net/tests/integration/empty_group.rs | 6 +- rs/moq-net/tests/integration/fetch_only.rs | 6 +- rs/moq-net/tests/integration/goaway.rs | 7 +- rs/moq-net/tests/integration/idle_session.rs | 2 +- .../tests/integration/ietf_conformance.rs | 4 +- .../tests/integration/late_lower_group.rs | 2 +- rs/moq-net/tests/integration/multi_cdn.rs | 1 - rs/moq-net/tests/integration/range_anchors.rs | 4 +- rs/moq-net/tests/integration/restart.rs | 14 +- rs/moq-net/tests/integration/session_close.rs | 2 +- .../tests/integration/subscribe_ranges.rs | 2 +- .../tests/integration/subscribe_tracks.rs | 18 - .../tests/integration/subscriber_max_age.rs | 2 +- rs/moq-net/tests/integration/track_tail.rs | 6 +- rs/moq-net/tests/integration/tracks_ietf.rs | 31 - rs/moq-net/tests/integration/untimed.rs | 17 +- rs/moq-quic/src/connection/mux/params.rs | 2 +- rs/moq-relay/src/cluster.rs | 12 +- rs/moq-relay/src/config.rs | 36 +- rs/moq-relay/src/limits.rs | 41 +- rs/moq-relay/src/settings.rs | 4 - rs/moq-relay/src/websocket.rs | 12 +- .../tests/integration/auth_lifetime.rs | 24 +- .../tests/integration/cluster_unknown.rs | 10 +- rs/moq-relay/tests/integration/drain.rs | 2 +- .../tests/integration/hidden_cluster.rs | 2 +- .../tests/integration/runtime_uring.rs | 29 +- .../tests/integration/shutdown_signal.rs | 8 +- rs/moq-relay/tests/integration/smoke.rs | 18 +- rs/moq-tokio/src/connect.rs | 8 - rs/moq-tokio/src/deprecated.rs | 8 +- rs/moq-tokio/src/listen.rs | 8 - rs/moq-tokio/src/quic/backend.rs | 28 +- rs/moq-tokio/src/server.rs | 12 +- rs/moq-tokio/tests/integration/broadcast.rs | 178 +----- rs/moq-tokio/tests/integration/max_age.rs | 4 +- .../tests/integration/receive_credit.rs | 6 +- rs/moq-wasm/src/transport.rs | 6 +- rs/qmux/src/alpn.rs | 8 +- test/ietf-conformance/README.md | 7 +- test/ietf-conformance/run.sh | 4 +- test/interop/interop.sh | 29 +- test/interop/interop.toml | 4 - test/smoke/README.md | 2 +- test/smoke/clients/cloudflare/Cargo.toml | 4 +- test/smoke/cloudflare.sh | 19 +- test/smoke/freshness.sh | 25 +- test/smoke/moxygen.sh | 8 +- 84 files changed, 650 insertions(+), 1624 deletions(-) diff --git a/.github/workflows/interop.yml b/.github/workflows/interop.yml index a036636c49b..eb0cc1eb5d5 100644 --- a/.github/workflows/interop.yml +++ b/.github/workflows/interop.yml @@ -115,7 +115,7 @@ jobs: nix develop --command just test interop "${args[@]}" shell: bash -leo pipefail {0} env: - INTEROP_ARGS: ${{ github.event_name == 'pull_request' && '--publishers rust --subscribers rust,js-native-node,js-native-bun --versions moq-transport-14,moq-transport-22' || '--all --versions ietf' }} + INTEROP_ARGS: ${{ github.event_name == 'pull_request' && '--publishers rust --subscribers rust,js-native-node,js-native-bun --versions moq-transport-18,moq-transport-22' || '--all --versions ietf' }} MOQ_TEST_RUNS: ${{ runner.temp }}/moq-test-runs MOQ_TEST_RESULTS: ${{ runner.temp }}/moq-test-runs/results.jsonl diff --git a/rs/moq-cli/src/publish.rs b/rs/moq-cli/src/publish.rs index 7068dc971ba..38f59ddadee 100644 --- a/rs/moq-cli/src/publish.rs +++ b/rs/moq-cli/src/publish.rs @@ -1257,7 +1257,7 @@ pub(crate) mod tests { let input = [&lead[..], &second].concat(); let _ = moq_tokio::crypto::install_default(); - for version in ["moq-lite-06", "moq-lite-07-wip", "moq-transport-14"] { + for version in ["moq-lite-06", "moq-lite-07-wip", "moq-transport-18"] { let fixture = moq_relay::test_relay().await.unwrap(); let ready = fixture.relay.ready(); tokio::spawn(fixture.relay.run()); diff --git a/rs/moq-cli/tests/integration/epochs.rs b/rs/moq-cli/tests/integration/epochs.rs index e55907363ba..d0d7626abfe 100644 --- a/rs/moq-cli/tests/integration/epochs.rs +++ b/rs/moq-cli/tests/integration/epochs.rs @@ -201,10 +201,7 @@ async fn replacement(version: &str) { (changed(&mut catalog_follow).await, changed(&mut media_follow).await) }) .await; - assert_eq!( - catalog_restart, - version != "moq-lite-06" && version != "moq-transport-14" - ); + assert_eq!(catalog_restart, version != "moq-lite-06"); assert_eq!(media_restart, catalog_restart); println!( "{version}: relay replacement observed in {:?} of {:?} (publisher already connected)", @@ -307,6 +304,5 @@ macro_rules! versions { versions! { lite07: "moq-lite-07-wip", lite06: "moq-lite-06", - ietf14: "moq-transport-14", ietf22: "moq-transport-22", } diff --git a/rs/moq-e2ee/tests/support/harness.rs b/rs/moq-e2ee/tests/support/harness.rs index eb221f97f76..1b22c466208 100644 --- a/rs/moq-e2ee/tests/support/harness.rs +++ b/rs/moq-e2ee/tests/support/harness.rs @@ -82,7 +82,7 @@ pub async fn connect_mock(opts: MockConnectOptions) -> MockPair { } // Run both handshakes concurrently and spawn each side's driver - // the moment its handshake resolves: on draft-17+ the server's accept blocks + // the moment its handshake resolves: on moq-transport the server's accept blocks // on the client's SETUP, which only reaches the wire once the client's // machine is polled (and vice versa for the server's own SETUP). let client_fut = async { diff --git a/rs/moq-ffi/src/test.rs b/rs/moq-ffi/src/test.rs index c0bede188d1..8ca18f24498 100644 --- a/rs/moq-ffi/src/test.rs +++ b/rs/moq-ffi/src/test.rs @@ -7624,7 +7624,7 @@ fn grant(publish: &[&str], subscribe: &[&str]) -> crate::auth::MoqGrant { /// unsupported. #[tokio::test] async fn auth_reads_the_peer_grant() { - for version in ["moq-lite-07-wip", "moq-transport-17"] { + for version in ["moq-lite-07-wip", "moq-transport-18"] { auth_reads_the_peer_grant_on(version).await; } } @@ -7655,28 +7655,6 @@ async fn auth_reads_the_peer_grant_on(version: &str) { server.cancel(); } -/// moq-transport without the Auth extension carries a token only on a request that names it, -/// which no binding can, so both sides refuse one rather than report a token nothing sends. -#[tokio::test] -async fn auth_refuses_a_token_nothing_carries() { - let (server, client, accepted) = tokio::time::timeout(TIMEOUT, session_pair("moq-transport-14")) - .await - .expect("pair"); - for session in [&client, &accepted] { - let err = tokio::time::timeout(TIMEOUT, session.auth().add("extra".into())) - .await - .expect("add timed out") - .err() - .expect("a token nothing carries is refused"); - assert!(matches!(err, MoqError::Unsupported), "refusal: {err:?}"); - assert_eq!(session.auth().grant(), None, "no AUTH, no grant"); - } - - client.cancel(0); - accepted.cancel(0); - server.cancel(); -} - /// A token added through a client session joins the union with its own grant, leaves it on /// cancel, and a refusal or revocation carries the peer's code. #[tokio::test] diff --git a/rs/moq-gst/src/connection.rs b/rs/moq-gst/src/connection.rs index 270eb21d079..e2b824c3b3c 100644 --- a/rs/moq-gst/src/connection.rs +++ b/rs/moq-gst/src/connection.rs @@ -128,10 +128,10 @@ mod tests { element.set_property(name, value); assert_eq!(element.property::(name), value); } - element.set_property("connect-version", " moq-transport-14 , moq-lite-06 "); + element.set_property("connect-version", " moq-transport-18 , moq-lite-06 "); assert_eq!( element.property::("connect-version"), - " moq-transport-14 , moq-lite-06 " + " moq-transport-18 , moq-lite-06 " ); } } @@ -140,7 +140,7 @@ mod tests { fn properties_reach_versions_tls_and_quic_config() { let mut settings = Settings::default(); for (name, value) in [ - ("connect-version", " moq-transport-14 , moq-lite-06 ".to_value()), + ("connect-version", " moq-transport-18 , moq-lite-06 ".to_value()), ("tls-disable-verify", true.to_value()), ("quic-idle-timeout", 15_000u64.to_value()), ("quic-keep-alive", 0u64.to_value()), @@ -151,7 +151,7 @@ mod tests { let (connect, quic) = settings.resolve().unwrap(); assert_eq!( connect.version, - ["moq-transport-14".parse().unwrap(), "moq-lite-06".parse().unwrap()] + ["moq-transport-18".parse().unwrap(), "moq-lite-06".parse().unwrap()] ); assert_eq!(connect.tls.insecure, Some(true)); assert_eq!(connect.backoff.timeout, Some(Duration::ZERO.into())); diff --git a/rs/moq-net/src/client.rs b/rs/moq-net/src/client.rs index ceddb21dd0c..1e875ad47ce 100644 --- a/rs/moq-net/src/client.rs +++ b/rs/moq-net/src/client.rs @@ -3,7 +3,8 @@ use crate::origin; use crate::time::{Deadlines, Instant}; use crate::transport::poll::Session as _; use crate::{ - ALPN_18, ALPN_19, ALPN_20, ALPN_21, ALPN_22, ALPN_LITE, ALPN_LITE_03, ALPN_LITE_04, ALPN_LITE_05, ALPN_LITE_06, ALPN_LITE_07_WIP, Consume, Error, NEGOTIATED, Session, Version, Versions, + ALPN_18, ALPN_19, ALPN_20, ALPN_21, ALPN_22, ALPN_LITE, ALPN_LITE_03, ALPN_LITE_04, ALPN_LITE_05, ALPN_LITE_06, + ALPN_LITE_07_WIP, Consume, Error, NEGOTIATED, Session, Version, Versions, coding::{self, Encode, Stream}, ietf, lite, setup, stats, }; @@ -740,7 +741,10 @@ mod tests { parameters: Bytes::new(), }; server - .encode(&mut crate::coding::Encoder::new(&mut encoded, negotiated.into()), negotiated) + .encode( + &mut crate::coding::Encoder::new(&mut encoded, negotiated.into()), + negotiated, + ) .unwrap(); // Add a setup-stream SessionInfo frame using the negotiated Lite version. diff --git a/rs/moq-net/src/coding/writer.rs b/rs/moq-net/src/coding/writer.rs index c372dc222f1..bfb5c8374a7 100644 --- a/rs/moq-net/src/coding/writer.rs +++ b/rs/moq-net/src/coding/writer.rs @@ -327,10 +327,6 @@ mod tests { #[moq_clock::test] async fn raw_payload_stop_uses_the_negotiated_registry() { for (version, expected) in [ - ( - crate::Version::Ietf(crate::ietf::Version::Draft18), - Error::Stream(crate::StreamError::Unknown(0x4)), - ), ( crate::Version::Ietf(crate::ietf::Version::Draft20), Error::Stream(crate::StreamError::GoingAway), diff --git a/rs/moq-net/src/fuzz.rs b/rs/moq-net/src/fuzz.rs index 3abbfaeca16..6cd8ebcffcc 100644 --- a/rs/moq-net/src/fuzz.rs +++ b/rs/moq-net/src/fuzz.rs @@ -1069,6 +1069,31 @@ pub fn seeds() -> Vec { } } + // The `moql` SETUP pair, which only lite-01/02 negotiate, also has its own type prefix. + for (index, version) in LITE_VERSIONS.iter().enumerate() { + let outer = crate::Version::Lite(*version); + let client = crate::setup::Client { + versions: coding::Versions::from([outer.into()]), + parameters: Default::default(), + }; + let server = crate::setup::Server { + version: outer.into(), + parameters: Default::default(), + }; + let (Ok(client), Ok(server)) = (client.encode_bytes(outer), server.encode_bytes(outer)) else { + continue; + }; + for (kind, message) in [(22, client), (23, server)] { + let mut data = vec![index as u8, kind]; + data.extend(message); + seeds.push(Seed { + target: "lite", + kind, + data, + }); + } + } + // FETCH is the one arm the sweep above cannot reach: its body ends in a parameter // count, and a uniform fill never lands a zero there. Build it from the encoder // instead, which also means a field change breaks the build rather than the seed. diff --git a/rs/moq-net/src/ietf/cluster.rs b/rs/moq-net/src/ietf/cluster.rs index 2bb89d1f388..6b77115433d 100644 --- a/rs/moq-net/src/ietf/cluster.rs +++ b/rs/moq-net/src/ietf/cluster.rs @@ -532,5 +532,4 @@ mod tests { let peer = peer_from_setup(&decoded).unwrap(); assert!(!peer.negotiated()); } - } diff --git a/rs/moq-net/src/ietf/datagram.rs b/rs/moq-net/src/ietf/datagram.rs index 431ff8030ea..a070288ae78 100644 --- a/rs/moq-net/src/ietf/datagram.rs +++ b/rs/moq-net/src/ietf/datagram.rs @@ -278,17 +278,8 @@ mod tests { body: DatagramBody::Status(3), }; for version in ALL { - let legacy = false; - match datagram.encode_bytes(version) { - Ok(buf) => { - assert!(legacy, "{version}"); - assert_eq!(decode(&buf, version).unwrap(), datagram); - } - Err(err) => { - assert!(!legacy, "{version}"); - assert!(matches!(err, EncodeError::InvalidState)); - } - } + let err = datagram.encode_bytes(version).unwrap_err(); + assert!(matches!(err, EncodeError::InvalidState), "{version}"); } } diff --git a/rs/moq-net/src/ietf/error.rs b/rs/moq-net/src/ietf/error.rs index ee711790324..f9a77d02c42 100644 --- a/rs/moq-net/src/ietf/error.rs +++ b/rs/moq-net/src/ietf/error.rs @@ -179,9 +179,7 @@ pub(crate) mod request { return None; } match version { - Version::Draft18 | Version::Draft19 => { - Some(INVALID_JOINING_REQUEST_ID) - } + Version::Draft18 | Version::Draft19 => Some(INVALID_JOINING_REQUEST_ID), _ => None, } } @@ -434,7 +432,6 @@ pub(crate) mod request { ] } - // Sent but never read back as itself: a peer's MALFORMED_AUTH_TOKEN stays remote. let malformed = Error::Decode(DecodeError::MalformedAuthToken); for version in ALL { @@ -641,7 +638,10 @@ mod tests { const REGISTERED: &[u32] = &[0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x9, 0x12]; for err in EVERY_ERROR { let code = to_stream_code(&err); - assert!(REGISTERED.contains(&code), "{err:?} sends {code:#x}, which is not registered"); + assert!( + REGISTERED.contains(&code), + "{err:?} sends {code:#x}, which is not registered" + ); } } diff --git a/rs/moq-net/src/ietf/filter.rs b/rs/moq-net/src/ietf/filter.rs index 9e67b79356f..4a0eb763360 100644 --- a/rs/moq-net/src/ietf/filter.rs +++ b/rs/moq-net/src/ietf/filter.rs @@ -75,11 +75,7 @@ impl Filter { /// Draft-22 names the meaning with a Location Filter Type instead, but keeps those /// parameters, so this still gates them. pub(crate) fn is_draft20(version: Version) -> bool { - !matches!( - version, - Version::Draft18 - | Version::Draft19 - ) + !matches!(version, Version::Draft18 | Version::Draft19) } /// The absolute end group, given the start, or an error when the range runs backwards. @@ -294,8 +290,7 @@ impl Param for Filter { let mut buf = Vec::new(); let mut inner = Encoder::new(&mut buf, sv.into()); match version { - Version::Draft18 - | Version::Draft19 => self.encode_tag(&mut inner, sv)?, + Version::Draft18 | Version::Draft19 => self.encode_tag(&mut inner, sv)?, Version::Draft20 | Version::Draft21 => self.encode_fields(&mut inner)?, // Draft-22 drops the Length, since the Location Filter Type says which fields follow. _ => return self.encode_typed(w), diff --git a/rs/moq-net/src/ietf/group.rs b/rs/moq-net/src/ietf/group.rs index 223c200c323..c8ecc0f43c6 100644 --- a/rs/moq-net/src/ietf/group.rs +++ b/rs/moq-net/src/ietf/group.rs @@ -44,11 +44,7 @@ impl Decode for ObjectExtensionsLength { /// timescale on every object would cost bytes per frame to restate something fixed for /// the track's lifetime. `timescale` is what the track advertised, and the timestamp is /// converted into it so the value on the wire matches the declared units. -pub fn encode_object_time( - w: &mut Encoder<'_>, - timestamp: Timestamp, - timescale: Timescale, -) -> Result<(), EncodeError> { +pub fn encode_object_time(w: &mut Encoder<'_>, timestamp: Timestamp, timescale: Timescale) -> Result<(), EncodeError> { let timestamp = timestamp.convert(timescale).map_err(|_| EncodeError::BoundsExceeded)?; // The first property's type is a delta from zero, so it is written as is. w.varint(PROP_TIMESTAMP)?; diff --git a/rs/moq-net/src/ietf/namespace.rs b/rs/moq-net/src/ietf/namespace.rs index b5641842472..a86c24bdf18 100644 --- a/rs/moq-net/src/ietf/namespace.rs +++ b/rs/moq-net/src/ietf/namespace.rs @@ -117,9 +117,7 @@ pub fn decode_track(r: &mut Decoder<'_>) -> Result<(Path<'static>, String), Deco pub(super) fn refusal(namespace: &Path, version: super::Version) -> Option> { if matches!( version, - super::Version::Draft18 - | super::Version::Draft19 - | super::Version::Draft20 + super::Version::Draft18 | super::Version::Draft19 | super::Version::Draft20 ) { return None; } diff --git a/rs/moq-net/src/ietf/object.rs b/rs/moq-net/src/ietf/object.rs index 1073d0430b3..ca41027047c 100644 --- a/rs/moq-net/src/ietf/object.rs +++ b/rs/moq-net/src/ietf/object.rs @@ -9,10 +9,7 @@ use crate::{ /// Draft-19 assigns property 0x06 to SUBGROUP_DELIVERY_TIMEOUT. pub(crate) fn has_delivery_timeout(version: Version) -> bool { - !matches!( - version, - Version::Draft18 - ) + !matches!(version, Version::Draft18) } /// Object status: no object at or past this location in the group exists. diff --git a/rs/moq-net/src/ietf/parameters.rs b/rs/moq-net/src/ietf/parameters.rs index 8e204185527..5d28d580218 100644 --- a/rs/moq-net/src/ietf/parameters.rs +++ b/rs/moq-net/src/ietf/parameters.rs @@ -565,9 +565,7 @@ mod tests { #[test] fn test_param_u8_all_versions() { - for version in [ - Version::Draft18, - ] { + for version in [Version::Draft18] { round_trip_params( version, |w, v| { @@ -607,9 +605,7 @@ mod tests { #[test] fn test_param_bool_all_versions() { - for version in [ - Version::Draft18, - ] { + for version in [Version::Draft18] { round_trip_params( version, |w, v| { @@ -628,9 +624,7 @@ mod tests { #[test] fn test_param_location_all_versions() { let loc = Location { group: 5, object: 3 }; - for version in [ - Version::Draft18, - ] { + for version in [Version::Draft18] { round_trip_params( version, |w, v| { @@ -676,9 +670,7 @@ mod tests { #[test] fn test_param_filter_all_versions() { - for version in [ - Version::Draft18, - ] { + for version in [Version::Draft18] { round_trip_params( version, |w, v| { @@ -696,9 +688,7 @@ mod tests { #[test] fn test_param_multiple_delta_encoding() { - for version in [ - Version::Draft18, - ] { + for version in [Version::Draft18] { round_trip_params( version, |w, v| { @@ -729,9 +719,7 @@ mod tests { #[test] fn test_param_empty_set() { - for version in [ - Version::Draft18, - ] { + for version in [Version::Draft18] { round_trip_params( version, |w, v| { @@ -748,9 +736,7 @@ mod tests { #[test] fn test_param_option_skip_none() { - for version in [ - Version::Draft18, - ] { + for version in [Version::Draft18] { round_trip_params( version, |w, v| { @@ -776,9 +762,7 @@ mod tests { #[test] fn test_param_option_encode_some() { - for version in [ - Version::Draft18, - ] { + for version in [Version::Draft18] { round_trip_params( version, |w, v| { @@ -805,9 +789,7 @@ mod tests { #[test] fn test_param_bare_type_defaults() { // Bare types use T::default() when the parameter is absent - for version in [ - Version::Draft18, - ] { + for version in [Version::Draft18] { round_trip_params( version, |w, v| { @@ -831,9 +813,7 @@ mod tests { #[test] fn test_param_unknown_rejected() { // 0x3E is not a message parameter, which closes the session. - for version in [ - Version::Draft18, - ] { + for version in [Version::Draft18] { let mut buf = Vec::new(); let mut w = Encoder::new(&mut buf, version.into()); w.varint(1).unwrap(); @@ -877,9 +857,7 @@ mod tests { #[test] fn test_param_duplicate_rejected() { // Manually construct a buffer with duplicate key 0x20 - for version in [ - Version::Draft18, - ] { + for version in [Version::Draft18] { let mut buf = Vec::new(); let mut w = Encoder::new(&mut buf, version.into()); // Encode count = 2 diff --git a/rs/moq-net/src/ietf/properties.rs b/rs/moq-net/src/ietf/properties.rs index a6880097180..f8efa8370ed 100644 --- a/rs/moq-net/src/ietf/properties.rs +++ b/rs/moq-net/src/ietf/properties.rs @@ -109,7 +109,6 @@ impl Properties { /// A property the publisher sealed inside Immutable Properties travels there, so it is /// not restated in the mutable list. pub fn encode(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { - let int = |id, value| Property { id, value: Value::Int(value), diff --git a/rs/moq-net/src/ietf/publish.rs b/rs/moq-net/src/ietf/publish.rs index c64a6fa60c3..7cb33c05511 100644 --- a/rs/moq-net/src/ietf/publish.rs +++ b/rs/moq-net/src/ietf/publish.rs @@ -160,14 +160,7 @@ impl PublishDone<'_> { code if code == PublishDoneStatus::Unauthorized.code() => Err(crate::Error::Unauthorized), // SUBSCRIPTION_ENDED: the subscription reached the end its filter asked for. // Draft-20 removed it and left 0x3 unassigned. - 0x3 if matches!( - version, - Version::Draft18 - | Version::Draft19 - ) => - { - Ok(()) - } + 0x3 if matches!(version, Version::Draft18 | Version::Draft19) => Ok(()), code => Err(crate::Error::Remote(u32::try_from(code).unwrap_or(u32::MAX))), } } @@ -310,18 +303,12 @@ impl Message for PublishOk { _ => { // GROUP_ORDER left PUBLISH_OK in draft-19. Sending it there is a parameter // on the wrong message, which closes the session. - let group_order = matches!( - version, - Version::Draft18 - ) - .then_some(self.group_order) - .flatten(); - let new_group = matches!( - version, - Version::Draft18 | Version::Draft19 - ) - .then_some(self.new_group) - .flatten(); + let group_order = matches!(version, Version::Draft18) + .then_some(self.group_order) + .flatten(); + let new_group = matches!(version, Version::Draft18 | Version::Draft19) + .then_some(self.new_group) + .flatten(); encode_params!(w, version, 0x10 => self.forward, 0x20 => self.subscriber_priority, @@ -465,10 +452,7 @@ mod tests { #[test] fn test_publish_done_registered_statuses_all_versions() { - for version in [ - Version::Draft18, - Version::Draft19, - ] { + for version in [Version::Draft18, Version::Draft19] { for (status, expected) in [ (PublishDoneStatus::InternalError, 0x0), (PublishDoneStatus::TrackEnded, 0x2), diff --git a/rs/moq-net/src/ietf/publisher.rs b/rs/moq-net/src/ietf/publisher.rs index f2742cafc25..2f19ef862db 100644 --- a/rs/moq-net/src/ietf/publisher.rs +++ b/rs/moq-net/src/ietf/publisher.rs @@ -1165,9 +1165,7 @@ impl Publisher { match admitted { Ok(grant) => (gate.named(), Some(grant)), Err(refusal) => { - return self - .reject_subscribe(stream, &refusal.error, &refusal.reason) - .await; + return self.reject_subscribe(stream, &refusal.error, &refusal.reason).await; } } } @@ -1437,14 +1435,11 @@ impl Publisher { Err(refusal) => match acked { Some(opened) => (Served::Track(Err(refusal.error)), opened.load(Ordering::Relaxed)), None => { - return self - .reject_subscribe(stream, &refusal.error, &refusal.reason) - .await; + return self.reject_subscribe(stream, &refusal.error, &refusal.reason).await; } }, }; - self.write_publish_done(stream, served, streams, Some(&credit)) - .await + self.write_publish_done(stream, served, streams, Some(&credit)).await } } @@ -1619,8 +1614,7 @@ impl Publisher { if session.poll_closed(&mut cx).is_ready() { return Poll::Ready(Turn::Cancelled); } - if stream.writer.poll_closed(&mut cx).is_ready() - { + if stream.writer.poll_closed(&mut cx).is_ready() { return Poll::Ready(Turn::Cancelled); } if let Poll::Ready(renewed) = renewal.poll(waiter) { @@ -1649,10 +1643,6 @@ impl Publisher { }) .await; - // Draft 14 answers no update. Drafts 15 and 16 answer on the control stream, - // naming the update's own Request ID; later drafts name none. - let answer = true; - match turn { // A malformed update, such as one whose AUTHORIZATION TOKEN names an alias, // closes the session rather than only ending this subscription, as the same @@ -1669,16 +1659,13 @@ impl Publisher { } Turn::Served(res) => return Some(Served::Track(res)), Turn::Cancelled => return None, - Turn::Renewal(request_update::Verdict { - verdict, - grant: res, - }) => { + Turn::Renewal(request_update::Verdict { verdict, grant: res }) => { // Only a token-authorized request starts a renewal. let rg = request_grant.as_ref().expect("a renewal without a request grant"); // On accept the old grant is dropped (ending the old token) and the deadline // re-armed at the new expiry. let Err(refusal) = rg.renew(verdict, res) else { - if answer && let Err(err) = self.write_request_ok(&mut stream.writer, None).await { + if let Err(err) = self.write_request_ok(&mut stream.writer, None).await { return Some(Served::Track(Err(err))); } continue; @@ -1686,10 +1673,9 @@ impl Publisher { // Per drafts 16 section 9.11.1 / 18 section 10.9.1, a refused or uncovered // renewal ends only this subscription: REQUEST_ERROR, then PUBLISH_DONE // UPDATE_FAILED. The session stays up and the old grant does not survive. - if answer - && let Err(err) = self - .write_subscribe_error(&mut stream.writer, &refusal.error, &refusal.reason) - .await + if let Err(err) = self + .write_subscribe_error(&mut stream.writer, &refusal.error, &refusal.reason) + .await { return Some(Served::Track(Err(err))); } @@ -1823,8 +1809,7 @@ impl Publisher { if session.poll_closed(&mut cx).is_ready() { return Poll::Ready(UpdateRead::Cancelled); } - if stream.writer.poll_closed(&mut cx).is_ready() - { + if stream.writer.poll_closed(&mut cx).is_ready() { return Poll::Ready(UpdateRead::Cancelled); } self.poll_update(stream, finished, goaways, &mut cx) @@ -1934,9 +1919,6 @@ impl Publisher { renewal: &mut request_update::Renewal, update: super::request_stream::Update, ) -> Result<(), Served> { - // Draft 14 answers no update. Drafts 15 and 16 answer on the control stream, naming the - // update's own Request ID; later drafts name none. - let answer = true; let failed = |err| Served::Track(Err(err)); // A token renews a token-authorized request. Where tokens decide, one arriving on a // request admitted without one is refused rather than taken unread, so every token this @@ -1976,12 +1958,10 @@ impl Publisher { None => None, }; if let Some((reason, err)) = refused { - if answer { - self.write_subscribe_error(&mut stream.writer, &err, reason) - .await - .map_err(failed)?; - } - // Either way the update failed, which ends the subscription. + self.write_subscribe_error(&mut stream.writer, &err, reason) + .await + .map_err(failed)?; + // The update failed, which ends the subscription. return Err(Served::UpdateFailed(Error::Unsupported)); } if let Some(priority) = update.priority { @@ -2005,30 +1985,18 @@ impl Publisher { renewal.verify(grant.verify_renewal(&self.auth, token.0)); return Ok(()); } - if answer { - self.write_request_ok(&mut stream.writer, None) - .await - .map_err(failed)?; - } + self.write_request_ok(&mut stream.writer, None).await.map_err(failed)?; Ok(()) } /// Answer a REQUEST_UPDATE with REQUEST_OK, carrying the `largest` Location a resumed /// subscription now starts from. - /// - /// Drafts 15 and 16 answer on the control stream, naming the update's own Request ID; - /// later drafts name none. Draft-14 answers nothing and never reaches here. async fn write_request_ok( &self, writer: &mut Writer, largest: Option, ) -> Result<(), Error> { - writer - .encode_message(&ietf::RequestOk { - largest, - active: None, - }) - .await + writer.encode_message(&ietf::RequestOk { largest, active: None }).await } /// Reject a SUBSCRIBE, ending the request stream. @@ -2043,8 +2011,7 @@ impl Publisher { err: &Error, reason: &str, ) -> Result<(), Error> { - self.write_subscribe_error(&mut stream.writer, err, reason) - .await?; + self.write_subscribe_error(&mut stream.writer, err, reason).await?; // The peer dropping the stream once it has the rejection is a normal end, not our failure. let _ = stream.writer.close().await; @@ -2058,8 +2025,7 @@ impl Publisher { err: &Error, reason: &str, ) -> Result<(), Error> { - super::request_stream::write_error(writer, request::Kind::Subscribe, err, reason, self.version) - .await + super::request_stream::write_error(writer, request::Kind::Subscribe, err, reason, self.version).await } /// Serve a draft-20 fill on its own fetch stream: the requested range, read from the @@ -2335,11 +2301,7 @@ impl Publisher { // Every frame on a timed track is timed (see `track::Info::timescale`). let timestamp = timestamp.ok_or(Error::TimestampMismatch)?; let mut properties = Vec::new(); - ietf::encode_object_time( - &mut Encoder::new(&mut properties, version.into()), - timestamp, - timescale, - )?; + ietf::encode_object_time(&mut Encoder::new(&mut properties, version.into()), timestamp, timescale)?; Some(properties) } None => None, @@ -2458,11 +2420,7 @@ impl Publisher { // don't write, so waiting on upstream regardless would ignore what was asked. if msg.fill_timeout { return self - .reject_fetch( - stream, - &Error::Unsupported, - "FILL_TIMEOUT not supported", - ) + .reject_fetch(stream, &Error::Unsupported, "FILL_TIMEOUT not supported") .await; } @@ -2526,18 +2484,14 @@ impl Publisher { return Err(Error::Unauthorized); }; if !gate.allows() { - return self - .reject_fetch(stream, &Error::Unauthorized, "not granted") - .await; + return self.reject_fetch(stream, &Error::Unauthorized, "not granted").await; } // End Object 0 includes the entire End Group, even at the largest Group ID. if start.group > end.group || (start.group == end.group && end.object != 0 && start.object >= end.object) { - return self - .reject_fetch(stream, &Error::InvalidRange, "empty range") - .await; + return self.reject_fetch(stream, &Error::InvalidRange, "empty range").await; } // The peer must have seen the announcement to name this namespace, so this @@ -2594,11 +2548,7 @@ impl Publisher { FetchType::AbsoluteJoining { group_id, .. } if group_id <= end.group => group_id, _ => { return self - .reject_fetch( - stream, - &Error::InvalidRange, - "joining group past the subscription", - ) + .reject_fetch(stream, &Error::InvalidRange, "joining group past the subscription") .await; } }; @@ -2616,9 +2566,7 @@ impl Publisher { } // Rewritten as standalone or refused above. FetchType::Filtered { .. } => { - return self - .reject_fetch(stream, &Error::Unsupported, "not supported") - .await; + return self.reject_fetch(stream, &Error::Unsupported, "not supported").await; } }; @@ -2684,10 +2632,7 @@ impl Publisher { group.end_object = group.end_object.map(|end| status_fields(end)); // FETCH keeps each object's Timestamp, in the units FETCH_OK declares wherever the // draft can declare them. Opting out of the properties strips nothing from the objects. - let timescale = group - .info - .timescale -; + let timescale = group.info.timescale; let frames = group .frames .iter() @@ -2731,11 +2676,7 @@ impl Publisher { let past_largest = largest.is_some_and(|largest| largest.is_none_or(|object| start.object > object)); if draft20 && past_largest { return self - .reject_fetch( - stream, - &Error::InvalidRange, - "start past Largest Object", - ) + .reject_fetch(stream, &Error::InvalidRange, "start past Largest Object") .await; } @@ -2950,15 +2891,12 @@ impl Publisher { })) => return Ok(Ok((end, cache, namespace, ranking, token))), Ok(None) => ( match self.version { - Version::Draft18 - | Version::Draft19 => Error::InvalidJoiningRequestId, + Version::Draft18 | Version::Draft19 => Error::InvalidJoiningRequestId, _ => Error::NotFound, }, "no such subscription", ), - Ok(Some(Joined::Unsupported)) => { - (Error::Unsupported, "joining filter not supported") - } + Ok(Some(Joined::Unsupported)) => (Error::Unsupported, "joining filter not supported"), Ok(Some(Joined::Empty)) => (Error::InvalidRange, "no objects at subscription start"), }; Ok(Err(refusal)) @@ -3049,9 +2987,7 @@ impl Publisher { largest: live_edge(&track).largest, properties, }; - stream - .writer - .buffer_message(ietf::TrackStatusOk::ID, &ok)?; + stream.writer.buffer_message(ietf::TrackStatusOk::ID, &ok)?; std::future::poll_fn(|cx| stream.writer.poll_flush(cx)).await?; Ok::<(), Error>(()) }; @@ -3076,11 +3012,7 @@ impl Publisher { Ok(()) } - async fn reject_track_status( - &self, - mut stream: Stream, - err: &Error, - ) -> Result<(), Error> { + async fn reject_track_status(&self, mut stream: Stream, err: &Error) -> Result<(), Error> { let (kind, reason) = (request::Kind::TrackStatus, err.to_string()); super::request_stream::write_error(&mut stream.writer, kind, err, &reason, self.version).await?; let _ = stream.writer.close().await; @@ -3148,10 +3080,7 @@ impl Publisher { // moq-transport renames a request's auth with REQUEST_UPDATE, but cannot name one on // a request that had none, nor drop one, and before draft-16 cannot update a // namespace at all: those withdraw the request and make it again. - let restart = renamed - || held_auth != auth - && (held_auth.is_none() - || auth.is_none()); + let restart = renamed || held_auth != auth && (held_auth.is_none() || auth.is_none()); // An update already waiting or in flight carries whatever is current once it goes // out, and its answer brings the loop back here for anything after that. @@ -3224,8 +3153,7 @@ impl Publisher { } } // Register an idle reader too: GOAWAY can arrive without an update in flight. - if requests.contains_key(suffix) - { + if requests.contains_key(suffix) { woken.suffixes.lock().unwrap().push(suffix.clone()); } // The peer can reject a fresh PUBLISH_NAMESPACE or an update, which leaves @@ -3886,10 +3814,7 @@ impl Publisher { // Send OK response stream .writer - .encode_message(&ietf::RequestOk { - largest: None, - active, - }) + .encode_message(&ietf::RequestOk { largest: None, active }) .await?; // Draft-14/15 predate NAMESPACE, so they answer with their own PUBLISH_NAMESPACE @@ -4023,9 +3948,7 @@ impl Publisher { // Each update in flight is answered on its own stream, so many renew at // once and none holds up the announcements behind it. let now = self.runtime.now(); - if let Poll::Ready((suffix, answer)) = - Self::poll_answer(requests, inflight, woken, now, &mut cx) - { + if let Poll::Ready((suffix, answer)) = Self::poll_answer(requests, inflight, woken, now, &mut cx) { return Poll::Ready(NamespaceEvent::Answered(suffix, answer)); } // The front is now the earliest update still waiting. @@ -4561,20 +4484,14 @@ impl TrackServe { Some(wire) => { // A datagram this draft cannot carry is dropped like an oversized one: it // is best-effort, and the track's groups do not depend on it. - if wire - .status - .is_some_and(|status| !super::object::status_defined(status)) - { + if wire.status.is_some_and(|status| !super::object::status_defined(status)) { tracing::debug!(sequence, "dropping a datagram status this draft cannot carry"); continue; } // A status keeps its meaning without the properties this draft forbids // beside it, as a stream's status object does. let stripped = Default::default(); - let forwarded = match wire - .status - .is_some_and(|status| status != 0) - { + let forwarded = match wire.status.is_some_and(|status| status != 0) { true => &stripped, false => &wire.properties, }; @@ -5194,8 +5111,7 @@ impl GroupServe { } Poll::Ready(Ok(None)) => { if !self.ended - && let Some(end) = - self.group.end_object().map(|end| status_fields(end)) + && let Some(end) = self.group.end_object().map(|end| status_fields(end)) && end.id >= self.slice.skip && self .slice .until @@ -6456,9 +6372,7 @@ mod serve_tests { let mut inflight = VecDeque::new(); let runtime = crate::time::sim(); let mut cx = std::task::Context::from_waker(std::task::Waker::noop()); - assert!( - Publisher::poll_answer(&mut requests, &mut inflight, &woken, runtime.now(), &mut cx).is_pending() - ); + assert!(Publisher::poll_answer(&mut requests, &mut inflight, &woken, runtime.now(), &mut cx).is_pending()); assert!(session.log.closes().is_empty()); session.push(&[0x10, 0, 2, 0, 0]); woken.suffixes.lock().unwrap().push(suffix); @@ -7188,10 +7102,7 @@ mod serve_tests { .await .expect("the track's error ends the subscription"); assert!(matches!(served, Served::Track(Err(Error::Unsupported))), "{served:?}"); - assert_eq!( - served.status().0, - ietf::PublishDoneStatus::InternalError - ); + assert_eq!(served.status().0, ietf::PublishDoneStatus::InternalError); assert_eq!( Served::UpdateFailed(Error::Unsupported).status().0, ietf::PublishDoneStatus::UpdateFailed @@ -7728,7 +7639,7 @@ mod serve_tests { /// a single token is answered as usual. #[moq_clock::test] async fn a_request_with_repeated_or_several_tokens_is_refused_alone() { - for (version, malformed) in [ (Version::Draft22, 0x4)] { + for (version, malformed) in [(Version::Draft22, 0x4)] { let request = |tokens: &[&[u8]]| { let mut body = track_status("room", true, version); assert_eq!(body.pop(), Some(0), "{version}"); @@ -8127,11 +8038,7 @@ mod serve_tests { /// origin's own, which is what carries a refusal the registry has no value for. #[moq_clock::test] async fn a_missing_broadcast_is_refused_with_the_draft_s_code() { - for version in [ - Version::Draft18, - Version::Draft19, - Version::Draft20, - ] { + for version in [Version::Draft18, Version::Draft19, Version::Draft20] { let error_code = 0x10; let h = serve(version); @@ -9202,10 +9109,7 @@ mod serve_tests { const FETCH_ID: RequestId = RequestId(0x2C); /// Every draft that still carries a joining FETCH. - const JOINING_DRAFTS: [Version; 2] = [ - Version::Draft18, - Version::Draft19, - ]; + const JOINING_DRAFTS: [Version; 2] = [Version::Draft18, Version::Draft19]; const INVALID_JOINING_REQUEST_ID: u64 = 0x32; @@ -9354,8 +9258,7 @@ mod serve_tests { assert_eq!(crate::coding::decode_varint(&mut buf, version).unwrap(), 0); assert_eq!(bytes::Buf::try_get_u8(&mut buf).unwrap(), 0); } - let properties = - crate::coding::decode_buf(&mut buf, version, |r, _| Ok(r.bytes()?.to_vec())).unwrap(); + let properties = crate::coding::decode_buf(&mut buf, version, |r, _| Ok(r.bytes()?.to_vec())).unwrap(); assert!(!properties.is_empty(), "{version}: missing Timestamp"); let size = crate::coding::decode_varint(&mut buf, version).unwrap() as usize; assert_eq!(size, payload.len()); @@ -9773,7 +9676,7 @@ mod serve_tests { let mut prior: Option<(u64, u64)> = None; while !buf.is_empty() { let (group, object) = { -let ietf::FetchObject::Object { group, object, .. } = + let ietf::FetchObject::Object { group, object, .. } = ietf::FetchObject::decode(&mut buf, version).unwrap() else { panic!("{version}: unexpected End of Range"); @@ -9787,7 +9690,7 @@ let ietf::FetchObject::Object { group, object, .. } = (group, object.unwrap()) } } -}; + }; let size = buf.varint().unwrap() as usize; let payload = String::from_utf8(buf.slice(size).unwrap().to_vec()).unwrap(); objects.push((group, object, payload)); @@ -9961,8 +9864,7 @@ let ietf::FetchObject::Object { group, object, .. } = } } - /// Immutable Properties keep the bytes their publisher sealed, so they are forwarded - /// only to a draft that encodes them the same way, and refused elsewhere. + /// Immutable Properties keep the bytes their publisher sealed. #[moq_clock::test] async fn immutable_track_properties_keep_their_encoding() { // Sealed: OBJECT_DELIVERY_TIMEOUT = 42 and DYNAMIC_GROUPS = 1. @@ -9991,28 +9893,6 @@ let ietf::FetchObject::Object { group, object, .. } = assert_eq!(ok.properties.unknown, upstream.unknown); // Its key is delta-encoded against TIMESCALE now, but the sealed bytes are verbatim. assert_eq!(occurrences(&h.log, &block[1..]), 1); - - // Draft 17 forbids the 7-byte varints draft 18 allows, and draft 16 has QUIC varints. - for version in [Version::Draft18] { - let h = serve_track(version, info.clone()); - let stream = Stream::open(&mut crate::driver::Transport::new(h.session.clone()), version) - .await - .unwrap(); - h.publisher - .clone() - .run_subscribe_stream(stream, subscribe(Filter::NextObject, None)) - .await - .unwrap(); - let wire = h.log.writes.lock().unwrap().clone(); - let mut buf = Decoder::new(&wire, version.into()); - assert_eq!(buf.varint().unwrap(), ietf::RequestError::ID, "{version}"); - let error = ietf::RequestError::decode(&mut buf, version).unwrap(); - assert_eq!( - error.error_code, - request::to_code(&Error::Unsupported, request::Kind::Subscribe, version), - "{version}" - ); - } } /// The info a relay behind a moq-lite hop with the `ietf` extension learns of a track @@ -11432,10 +11312,7 @@ let ietf::FetchObject::Object { group, object, .. } = #[moq_clock::test] async fn largest_object_is_the_live_edge_before_draft20() { - for version in [ - Version::Draft18, - Version::Draft19, - ] { + for version in [Version::Draft18, Version::Draft19] { assert_eq!( subscribe_ok_largest(version).await, Some(Location { group: 5, object: 3 }), @@ -11833,11 +11710,7 @@ let ietf::FetchObject::Object { group, object, .. } = "{version:?}: nothing acknowledged it" ); let (status, _) = wire.publish_done.expect("PUBLISH_DONE was sent"); - assert_eq!( - status, - ietf::PublishDoneStatus::UpdateFailed.code(), - "{version:?}" - ); + assert_eq!(status, ietf::PublishDoneStatus::UpdateFailed.code(), "{version:?}"); } } @@ -12444,11 +12317,7 @@ let ietf::FetchObject::Object { group, object, .. } = "a refused renewal ends the subscription at once, got {result:?}" ); let (status, _) = Wire::read(&h.log, VERSION).publish_done.expect("PUBLISH_DONE was sent"); - assert_eq!( - status, - ietf::PublishDoneStatus::UpdateFailed.code(), - "UPDATE_FAILED" - ); + assert_eq!(status, ietf::PublishDoneStatus::UpdateFailed.code(), "UPDATE_FAILED"); // The refused update is answered with exactly one REQUEST_ERROR before the subscription // ends. let written = h.log.writes.lock().unwrap().clone(); @@ -13969,10 +13838,7 @@ mod tests { #[moq_clock::test] async fn hidden_discovery_obeys_peer_setup_and_requested_prefix() { - for version in [ - Version::Draft19, - Version::Draft22, - ] { + for version in [Version::Draft19, Version::Draft22] { for declared in [false, true] { for solicit in [Some(false), Some(true)] { for scoped in [false, true] { @@ -13988,18 +13854,10 @@ mod tests { .await; // Visible on the subscription: not filtered, opted in, or the prefix // names the dot segment. The unsolicited loop sends a dot namespace - // only when the peer did not declare MoQ Hidden. Draft-14/15 keep - // the two paths disjoint; draft-16 and later fill the stream too. + // only when the peer did not declare MoQ Hidden. let on_stream = !declared || hidden || prefix == ".stats"; let unsolicited = solicit != Some(true) && !declared; - let legacy = false; - let inline = if legacy { - (solicit == Some(true) && on_stream) - || (solicit != Some(true) && declared && (hidden || prefix == ".stats")) - } else { - on_stream - }; - let expected = usize::from(inline) + usize::from(unsolicited); + let expected = usize::from(on_stream) + usize::from(unsolicited); assert_eq!( occurrences(&log, b"node"), expected, @@ -14012,11 +13870,10 @@ mod tests { } } - /// On draft-16 and later a peer that did not ask to be solicited hears each - /// namespace twice: an unsolicited PUBLISH_NAMESPACE and a NAMESPACE on the - /// SUBSCRIBE_NAMESPACE stream. Those are two discoveries of one namespace, not - /// two routes. A peer that asked to be solicited hears it only on the stream. - /// Draft-14 and 15 still answer a non-solicit peer only with PUBLISH_NAMESPACE. + /// A peer that did not ask to be solicited hears each namespace twice: an + /// unsolicited PUBLISH_NAMESPACE and a NAMESPACE on the SUBSCRIBE_NAMESPACE stream. + /// Those are two discoveries of one namespace, not two routes. A peer that asked to + /// be solicited hears it only on the stream. #[moq_clock::test] async fn a_non_solicit_peer_hears_a_namespace_both_ways() { let (times, streams) = advertise_both_ways(Some(false)).await; @@ -14026,20 +13883,6 @@ mod tests { let (once, streams) = advertise_both_ways(Some(true)).await; assert_eq!(once, 1, "a peer that asked to be told on request is told once"); assert_eq!(streams, 1, "inline on the SUBSCRIBE_NAMESPACE stream it asked on"); - - for version in [Version::Draft18] { - let log = advertise_with_hidden(Discovery { - version, - solicit: Some(false), - ..Discovery::default() - }) - .await; - assert_eq!( - occurrences(&log, b"cam"), - 1, - "{version:?} still answers only with PUBLISH_NAMESPACE" - ); - } } /// A peer that did not send SOLICIT still gets NAMESPACE on its SUBSCRIBE_NAMESPACE @@ -14132,10 +13975,8 @@ mod tests { } /// Send capacity can park an admitted stream's header. That must not wedge the loop: - /// withdrawals queued behind it still need to progress. - /// - /// Draft-14 so the withdrawal names its namespace on the wire, which is what makes the - /// loop's progress visible while every open is blocked. + /// withdrawals queued behind it still need to progress. A withdrawal ends its request's + /// own stream, which needs no new open, so it is visible while every open is blocked. #[moq_clock::test] async fn a_parked_open_still_lets_a_namespace_be_withdrawn() { const VERSION: Version = Version::Draft18; @@ -14183,18 +14024,19 @@ mod tests { // it despite the open above. drop(first); + let ended = || { + log.trail() + .into_iter() + .any(|(_, sent)| !matches!(sent, crate::lite::test_transport::Sent::Write(_))) + }; for _ in 0..100 { assert!(futures::poll!(run.as_mut()).is_pending()); - if occurrences(&log, b"first-cam") >= 2 { + if ended() { break; } tick().await; } - assert_eq!( - occurrences(&log, b"first-cam"), - 2, - "PUBLISH_NAMESPACE_DONE never sent: the open wedged the loop" - ); + assert!(ended(), "the withdrawal never went out: the open wedged the loop"); // Send capacity returns, and nothing else about the origin changes. set_gate(&gate, true); @@ -15336,9 +15178,7 @@ mod tests { #[moq_clock::test] async fn an_advertisement_without_credit_is_retried_and_spends_no_id() { use std::sync::atomic::Ordering; - for version in [ - Version::Draft19, - ] { + for version in [Version::Draft19] { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let _cam = origin.announce("lonely-cam", crate::origin::Route::default()).unwrap(); settle().await; @@ -16418,14 +16258,9 @@ mod compression_tests { track_properties(&info, wanted, version, false), Err(Error::Unsupported) )); - assert!(matches!( - track_properties(&info, wanted, version, true), - Err(Error::Unsupported) - )); } let plain = track::Info::default().with_compress(true); assert!(!track_properties(&plain, true, version, false).unwrap().compress); - assert!(!track_properties(&plain, true, version, true).unwrap().compress); } } diff --git a/rs/moq-net/src/ietf/publisher/tracks.rs b/rs/moq-net/src/ietf/publisher/tracks.rs index e1ed3083b96..01f4565f474 100644 --- a/rs/moq-net/src/ietf/publisher/tracks.rs +++ b/rs/moq-net/src/ietf/publisher/tracks.rs @@ -1090,8 +1090,7 @@ impl Publisher { None => None, }; if let Some((reason, err)) = refusal { - self.write_subscribe_error(&mut stream.writer, &err, reason) - .await?; + self.write_subscribe_error(&mut stream.writer, &err, reason).await?; break Served::UpdateFailed(Error::Unsupported); } if let Some(priority) = update.priority { @@ -1204,9 +1203,7 @@ impl Publisher { Some(Ok(subscriber)) => subscriber, Some(Err(err)) => return self.resume_failed(stream, how.answer, err).await, None => { - return self - .resume_failed(stream, how.answer, Error::NotFound) - .await; + return self.resume_failed(stream, how.answer, Error::NotFound).await; } }; let live = kio::wait(|waiter| { @@ -1220,19 +1217,14 @@ impl Publisher { }) .await?; if !live { - return self - .resume_failed(stream, how.answer, Error::NotFound) - .await; + return self.resume_failed(stream, how.answer, Error::NotFound).await; } let edge = live_edge(track); let range = subscribe_range(params.filter, edge, self.version); range.apply(&mut subscription); let _ = subscriber.update(subscription); - let timescale = subscriber - .info() - .timescale -; + let timescale = subscriber.info().timescale; let mut serve = TrackServe::new( self.session.clone(), subscriber, @@ -1270,12 +1262,7 @@ impl Publisher { .filter(|_| Filter::is_draft20(self.version)) .map(|fill| fill_range(fill, params.filter, edge.largest)); - if how.answer - && self - .write_request_ok(&mut stream.writer, edge.largest) - .await - .is_err() - { + if how.answer && self.write_request_ok(&mut stream.writer, edge.largest).await.is_err() { return Err(()); } diff --git a/rs/moq-net/src/ietf/request_stream.rs b/rs/moq-net/src/ietf/request_stream.rs index 7a6b24c3b9d..d756872e93c 100644 --- a/rs/moq-net/src/ietf/request_stream.rs +++ b/rs/moq-net/src/ietf/request_stream.rs @@ -9,10 +9,7 @@ use crate::{ }; pub(super) fn fin_cancels(version: Version) -> bool { - matches!( - version, - Version::Draft18 - ) + matches!(version, Version::Draft18) } /// Watch abrupt cancellation after the requester has finished sending messages. diff --git a/rs/moq-net/src/ietf/request_update.rs b/rs/moq-net/src/ietf/request_update.rs index e22740abd78..eeb19514aec 100644 --- a/rs/moq-net/src/ietf/request_update.rs +++ b/rs/moq-net/src/ietf/request_update.rs @@ -40,10 +40,7 @@ pub const UNNEGOTIATED_GUARD: usize = 64; /// Whether this version defines MAX_REQUEST_UPDATES. Draft-19 section 10.3.1.7 added it; the /// drafts below carry no such Setup Option. pub fn supported(version: Version) -> bool { - !matches!( - version, - Version::Draft18 - ) + !matches!(version, Version::Draft18) } /// A request's in-band renewal: the verdict on the token being verified, and the updates that @@ -163,9 +160,7 @@ mod tests { ); } - for version in [ - Version::Draft18, - ] { + for version in [Version::Draft18] { let mut params = super::super::Parameters::default(); into_setup(&mut params, version); assert_eq!( diff --git a/rs/moq-net/src/ietf/session.rs b/rs/moq-net/src/ietf/session.rs index 84d43bf6f00..38bda97bb34 100644 --- a/rs/moq-net/src/ietf/session.rs +++ b/rs/moq-net/src/ietf/session.rs @@ -10,8 +10,8 @@ use crate::{ }; use super::{ - Control, Message, Publisher, Subscriber, Version, active_count, auth, cluster, - epoch, hidden, max_age, peer, request_update, solicit, subscriber::is_protocol_violation, + Control, Message, Publisher, Subscriber, Version, active_count, auth, cluster, epoch, hidden, max_age, peer, + request_update, solicit, subscriber::is_protocol_violation, }; /// Keep the session's SUBSCRIBE_NAMESPACE requests open as `discovery` decides, each on @@ -318,8 +318,7 @@ pub fn start(config: Config) -> Result<(Driver, crate::goaway::Handle), Error> { async move { match peer_setup_stream { Some(reader) => { - run_goaway(reader.with_stats(&stats).with_version(version), version, client, goaway) - .await + run_goaway(reader.with_stats(&stats).with_version(version), version, client, goaway).await } None => std::future::pending().await, } @@ -1895,11 +1894,7 @@ mod tests { /// reset: a peer that never closes it never sees the two overlap. #[moq_clock::test] async fn a_broader_watch_waits_for_the_narrower_to_leave_the_wire() { - for version in [ - Version::Draft18, - Version::Draft19, - Version::Draft22, - ] { + for version in [Version::Draft18, Version::Draft19, Version::Draft22] { let subscribe = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let _front = watch(&subscribe, "cam/front"); let (log, _driver) = client(version, subscribe.clone(), None).await; @@ -2769,6 +2764,7 @@ mod tests { let session = crate::lite::test_transport::ScriptedSession::new(Vec::new()).with_incoming_unis(vec![ uni_stream(VERSION, PADDING), subgroup_header(VERSION, 7, 0).await, + setup, ]); let accepted = accept_setup(&mut crate::driver::Transport::new(session.clone()), VERSION) .await @@ -2790,7 +2786,6 @@ mod tests { async fn an_unknown_uni_type_closes_the_session() { for (version, kind) in [ (Version::Draft19, 0), - // Padding and uni SETUP arrived in later drafts, // SUBGROUP_HEADER types with the reserved SUBGROUP_ID_MODE (0b11). (Version::Draft19, 0x56), ] { diff --git a/rs/moq-net/src/ietf/subscribe.rs b/rs/moq-net/src/ietf/subscribe.rs index 6e557a4f67c..1c11ce6363d 100644 --- a/rs/moq-net/src/ietf/subscribe.rs +++ b/rs/moq-net/src/ietf/subscribe.rs @@ -54,10 +54,7 @@ pub struct Subscribe<'a> { /// The Range Filters (0x25-0x29) arrived in draft-19. pub(super) fn has_range_filters(version: Version) -> bool { - !matches!( - version, - Version::Draft18 - ) + !matches!(version, Version::Draft18) } impl Message for Subscribe<'_> { @@ -68,65 +65,65 @@ impl Message for Subscribe<'_> { let (track_namespace, track_name) = decode_track(r)?; let track_name = Cow::Owned(track_name); - decode_params!(r, version, - 0x02 => _object_delivery_timeout: Option, - 0x03 => authorization_token: Vec, - 0x04 => rendezvous_timeout: Option, - 0x06 => _subgroup_delivery_timeout: Option, - 0x10 => forward: Option, - 0x20 => subscriber_priority: Option, - 0x21 => filter: Option, - 0x22 => group_order: Option, - 0x23 => fill: Option where Filter::is_draft20(version), - 0x25 => subgroup_filter: Vec where has_range_filters(version), - 0x26 => object_id_filter: Vec where has_range_filters(version), - 0x27 => priority_filter: Vec where has_range_filters(version), - 0x28 => object_property_filter: Vec where has_range_filters(version), - 0x32 => new_group: Option, - 0x35 => include_properties: Option where Filter::is_draft20(version), - epoch::EPOCH_PARAM => epoch: Option, - super::max_age::PARAMETER => max_age: Option, - ); - let authorization_token = super::token::single(authorization_token)?; - - let range_filters = [ - subgroup_filter, - object_id_filter, - priority_filter, - object_property_filter, - ] - .iter() - .any(|filter| !filter.is_empty()); - - // Defaults to 1, so an absent parameter means the subscriber wants them. - let properties_wanted = include_properties.unwrap_or(true); - - // A zero cap still distinguishes a requested wait from an immediate miss. - let rendezvous = rendezvous_timeout.is_some_and(|millis| millis > 0); - - let subscriber_priority = subscriber_priority.unwrap_or(super::priority::DEFAULT_WIRE); - let group_order = group_order.unwrap_or(GroupOrder::Descending); - // An absent LOCATION_FILTER means the subscription is unfiltered. - let filter = filter.unwrap_or(Filter::Unfiltered); - - Ok(Self { - request_id, - track_namespace, - track_name, - subscriber_priority, - group_order, - filter, - fill, - properties_wanted, - // Absent means 1. - forward: forward.unwrap_or(true), - rendezvous, - range_filters, - authorization_token, - new_group, - max_age: super::max_age::validate(max_age)?, - epoch, - }) + decode_params!(r, version, + 0x02 => _object_delivery_timeout: Option, + 0x03 => authorization_token: Vec, + 0x04 => rendezvous_timeout: Option, + 0x06 => _subgroup_delivery_timeout: Option, + 0x10 => forward: Option, + 0x20 => subscriber_priority: Option, + 0x21 => filter: Option, + 0x22 => group_order: Option, + 0x23 => fill: Option where Filter::is_draft20(version), + 0x25 => subgroup_filter: Vec where has_range_filters(version), + 0x26 => object_id_filter: Vec where has_range_filters(version), + 0x27 => priority_filter: Vec where has_range_filters(version), + 0x28 => object_property_filter: Vec where has_range_filters(version), + 0x32 => new_group: Option, + 0x35 => include_properties: Option where Filter::is_draft20(version), + epoch::EPOCH_PARAM => epoch: Option, + super::max_age::PARAMETER => max_age: Option, + ); + let authorization_token = super::token::single(authorization_token)?; + + let range_filters = [ + subgroup_filter, + object_id_filter, + priority_filter, + object_property_filter, + ] + .iter() + .any(|filter| !filter.is_empty()); + + // Defaults to 1, so an absent parameter means the subscriber wants them. + let properties_wanted = include_properties.unwrap_or(true); + + // A zero cap still distinguishes a requested wait from an immediate miss. + let rendezvous = rendezvous_timeout.is_some_and(|millis| millis > 0); + + let subscriber_priority = subscriber_priority.unwrap_or(super::priority::DEFAULT_WIRE); + let group_order = group_order.unwrap_or(GroupOrder::Descending); + // An absent LOCATION_FILTER means the subscription is unfiltered. + let filter = filter.unwrap_or(Filter::Unfiltered); + + Ok(Self { + request_id, + track_namespace, + track_name, + subscriber_priority, + group_order, + filter, + fill, + properties_wanted, + // Absent means 1. + forward: forward.unwrap_or(true), + rendezvous, + range_filters, + authorization_token, + new_group, + max_age: super::max_age::validate(max_age)?, + epoch, + }) } fn encode_msg(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { @@ -134,30 +131,30 @@ impl Message for Subscribe<'_> { encode_namespace(w, &self.track_namespace)?; w.string(&self.track_name)?; - // FILL_PARAMETERS arrived in draft-20. Sending it to an older peer would be an - // unknown parameter, which is a protocol violation, so it is dropped instead. - // A subscriber there simply joins mid-group, which is what it did all along. - let fill = self.fill.filter(|_| Filter::is_draft20(version)); + // FILL_PARAMETERS arrived in draft-20. Sending it to an older peer would be an + // unknown parameter, which is a protocol violation, so it is dropped instead. + // A subscriber there simply joins mid-group, which is what it did all along. + let fill = self.fill.filter(|_| Filter::is_draft20(version)); - // INCLUDE_PROPERTIES defaults to 1, so only the opt-out is worth bytes. It - // arrived in draft-20, and an older peer would read it as an unknown - // parameter, which is a protocol violation. - let include_properties = (!self.properties_wanted && Filter::is_draft20(version)).then_some(false); - // Only a session that negotiated MoQ Epoch names one. - let epoch = self.epoch.clone(); + // INCLUDE_PROPERTIES defaults to 1, so only the opt-out is worth bytes. It + // arrived in draft-20, and an older peer would read it as an unknown + // parameter, which is a protocol violation. + let include_properties = (!self.properties_wanted && Filter::is_draft20(version)).then_some(false); + // Only a session that negotiated MoQ Epoch names one. + let epoch = self.epoch.clone(); - encode_params!(w, version, - 0x03 => self.authorization_token.clone(), - 0x10 => self.forward, - 0x20 => self.subscriber_priority, - 0x21 => self.filter, - 0x22 => self.group_order, - 0x23 => fill, - 0x32 => self.new_group, - 0x35 => include_properties, - epoch::EPOCH_PARAM => epoch, - super::max_age::PARAMETER => self.max_age, - ); + encode_params!(w, version, + 0x03 => self.authorization_token.clone(), + 0x10 => self.forward, + 0x20 => self.subscriber_priority, + 0x21 => self.filter, + 0x22 => self.group_order, + 0x23 => fill, + 0x32 => self.new_group, + 0x35 => include_properties, + epoch::EPOCH_PARAM => epoch, + super::max_age::PARAMETER => self.max_age, + ); Ok(()) } @@ -257,37 +254,37 @@ impl Message for SubscribeUpdate { } fn decode_msg(r: &mut Decoder<'_>, version: Version) -> Result { - // REQUEST_UPDATE - let request_id = RequestId::decode(r, version)?; - // Nothing reads an update's Range Filters yet; they are - // consumed so a legal update does not fail the session. - decode_params!(r, version, - 0x02 => _object_delivery_timeout: Option, - 0x03 => authorization_token: Vec, - 0x06 => _subgroup_delivery_timeout: Option, - 0x10 => forward: Option, - 0x20 => subscriber_priority: Option, - 0x21 => filter: Option, - 0x23 => fill: Option where Filter::is_draft20(version), - 0x25 => _subgroup_filter: Vec where has_range_filters(version), - 0x26 => _object_id_filter: Vec where has_range_filters(version), - 0x27 => _priority_filter: Vec where has_range_filters(version), - 0x28 => _object_property_filter: Vec where has_range_filters(version), - 0x29 => _track_property_filter: Vec where has_range_filters(version), - 0x32 => new_group: Option, - super::max_age::PARAMETER => max_age: Option, - ); + // REQUEST_UPDATE + let request_id = RequestId::decode(r, version)?; + // Nothing reads an update's Range Filters yet; they are + // consumed so a legal update does not fail the session. + decode_params!(r, version, + 0x02 => _object_delivery_timeout: Option, + 0x03 => authorization_token: Vec, + 0x06 => _subgroup_delivery_timeout: Option, + 0x10 => forward: Option, + 0x20 => subscriber_priority: Option, + 0x21 => filter: Option, + 0x23 => fill: Option where Filter::is_draft20(version), + 0x25 => _subgroup_filter: Vec where has_range_filters(version), + 0x26 => _object_id_filter: Vec where has_range_filters(version), + 0x27 => _priority_filter: Vec where has_range_filters(version), + 0x28 => _object_property_filter: Vec where has_range_filters(version), + 0x29 => _track_property_filter: Vec where has_range_filters(version), + 0x32 => new_group: Option, + super::max_age::PARAMETER => max_age: Option, + ); - Ok(Self { - request_id, - subscriber_priority, - forward, - filter, - authorization_token: super::token::single(authorization_token)?, - new_group, - max_age: super::max_age::validate(max_age)?, - fill, - }) + Ok(Self { + request_id, + subscriber_priority, + forward, + filter, + authorization_token: super::token::single(authorization_token)?, + new_group, + max_age: super::max_age::validate(max_age)?, + fill, + }) } } @@ -463,17 +460,6 @@ mod tests { } } - /// 0x04 is MAX_CACHE_DURATION in draft-15, defined for other messages, so a SUBSCRIBE - /// that carries it is ignored. Draft-16 dropped the id, which makes it unknown. - #[test] - fn cache_duration_on_subscribe_follows_the_draft() { - let draft15 = subscribe_with_rendezvous(0, Version::Draft18); - decode_message::(&draft15, Version::Draft18).expect("draft-15 ignores MAX_CACHE_DURATION"); - - let draft16 = subscribe_with_rendezvous(0, Version::Draft18); - decode_message::(&draft16, Version::Draft18).expect_err("draft-16 rejects unknown parameter 0x04"); - } - /// The first message parameter key on an encoded SUBSCRIBE, or `None` when it carries no /// parameters. /// @@ -487,7 +473,7 @@ mod tests { RequestId::decode(r, version).unwrap(); decode_track(r).unwrap(); - // draft-14/15 write absolute keys, draft-16+ deltas, but the first is absolute either way. + // Keys are delta coded, but the first is absolute. let count = r.varint().unwrap(); (count > 0).then(|| r.varint().unwrap()) } @@ -974,11 +960,7 @@ mod tests { /// FORWARD=0 is legal on every draft, a paused request rather than a session error. #[test] fn subscribe_decodes_forward_zero() { - for version in [ - Version::Draft18, - Version::Draft19, - Version::Draft20, - ] { + for version in [Version::Draft18, Version::Draft19, Version::Draft20] { let msg = Subscribe { new_group: None, max_age: None, @@ -1010,11 +992,7 @@ mod tests { 0x01, // Number of Parameters 0x03, 0x03, 0x03, 0x00, 0xAA, // AUTHORIZATION TOKEN ]); - for version in [ - Version::Draft18, - Version::Draft19, - Version::Draft20, - ] { + for version in [Version::Draft18, Version::Draft19, Version::Draft20] { let wire = body.clone(); let mut buf = Decoder::new(&wire, version.into()); Subscribe::decode_msg(&mut buf, version).unwrap_or_else(|e| panic!("{version}: {e}")); @@ -1124,11 +1102,7 @@ mod cache_duration_tests { ok.encode_msg(&mut Encoder::new(&mut payload, version.into()), version) .unwrap(); let got = crate::coding::decode_buf(&mut payload.as_slice(), version, SubscribeOk::decode_msg).unwrap(); - assert_eq!( - got.properties.max_cache_duration, - age, - "{version}" - ); + assert_eq!(got.properties.max_cache_duration, age, "{version}"); } } } diff --git a/rs/moq-net/src/ietf/subscribe_namespace.rs b/rs/moq-net/src/ietf/subscribe_namespace.rs index 658c0352152..54cd532a1fb 100644 --- a/rs/moq-net/src/ietf/subscribe_namespace.rs +++ b/rs/moq-net/src/ietf/subscribe_namespace.rs @@ -1,6 +1,5 @@ //! IETF moq-transport subscribe namespace messages - use crate::{Path, coding::*, ietf::RequestId}; use super::Message; @@ -416,7 +415,6 @@ mod tests { .hidden, hidden ); - } } } diff --git a/rs/moq-net/src/ietf/subscribe_tracks.rs b/rs/moq-net/src/ietf/subscribe_tracks.rs index 2a886aa699e..84b15e2aea2 100644 --- a/rs/moq-net/src/ietf/subscribe_tracks.rs +++ b/rs/moq-net/src/ietf/subscribe_tracks.rs @@ -277,17 +277,6 @@ mod tests { assert_eq!(decoded.new_group, Some(0)); } - #[test] - fn subscribe_tracks_starts_at_draft_18() { - let mut buf = Vec::new(); - let version = Version::Draft18; - assert!( - paused() - .encode_msg(&mut Encoder::new(&mut buf, version.into()), version) - .is_err() - ); - } - #[test] fn publish_skipped_round_trips() { for version in [Version::Draft18, Version::Draft22] { diff --git a/rs/moq-net/src/ietf/subscriber.rs b/rs/moq-net/src/ietf/subscriber.rs index dec647e1081..e06fa30b172 100644 --- a/rs/moq-net/src/ietf/subscriber.rs +++ b/rs/moq-net/src/ietf/subscriber.rs @@ -1625,12 +1625,8 @@ impl Subscriber { let epoch = msg.params.epoch.clone(); let Some(advert) = self.route(msg.params.cluster.as_ref(), &peer) else { tracing::debug!(%path, "dropping reflected publish_namespace"); - self.write_error( - &mut stream, - &Error::Unroutable, - "route loops through this relay", - ) - .await?; + self.write_error(&mut stream, &Error::Unroutable, "route loops through this relay") + .await?; let _ = stream.writer.close().await; return Ok(()); }; @@ -1682,8 +1678,7 @@ impl Subscriber { match admitted { Ok(grant) => (Admit::Token(slot), Some(grant)), Err(refusal) => { - self.write_error(&mut stream, &refusal.error, &refusal.reason) - .await?; + self.write_error(&mut stream, &refusal.error, &refusal.reason).await?; let _ = stream.writer.close().await; return Ok(()); } @@ -1734,13 +1729,11 @@ impl Subscriber { Err(refusal) => { tracing::info!(%path, err = %refusal.error, reason = %refusal.reason, "request token grant ended"); if !acked { - self.write_error(&mut stream, &refusal.error, &refusal.reason) - .await?; + self.write_error(&mut stream, &refusal.error, &refusal.reason).await?; let _ = stream.writer.close().await; return Ok(()); } - self.cancel_announce(&mut stream) - .await?; + self.cancel_announce(&mut stream).await?; return Err(refusal.error); } }; @@ -1750,15 +1743,12 @@ impl Subscriber { let _ = stream.writer.close().await; } Withdraw::Reject(refusal) => { - self.write_error(&mut stream, &refusal.error, &refusal.reason) - .await?; + self.write_error(&mut stream, &refusal.error, &refusal.reason).await?; let _ = stream.writer.close().await; } Withdraw::Cancel(refusal) => { - self.write_error(&mut stream, &refusal.error, &refusal.reason) - .await?; - self.cancel_announce(&mut stream) - .await?; + self.write_error(&mut stream, &refusal.error, &refusal.reason).await?; + self.cancel_announce(&mut stream).await?; } } Ok(()) @@ -1818,8 +1808,7 @@ impl Subscriber { } else { kio::wait(|waiter| { let mut cx = waiter.context(); - if let Poll::Ready(result) = stream.writer.poll_closed(&mut cx) - { + if let Poll::Ready(result) = stream.writer.poll_closed(&mut cx) { return Poll::Ready(Turn::WriterClosed(result)); } if let Poll::Ready(renewed) = renewal.poll(waiter) { @@ -1850,12 +1839,10 @@ impl Subscriber { let update_id = ietf::RequestId::decode(&mut body.decoder(self.version), self.version)?; if let Err(err) = self.spend(update_id) { if matches!(err, Error::GoingAway) { - return Ok(Withdraw::Cancel( - crate::auth::Refusal { - error: err, - reason: "going away".to_string(), - }, - )); + return Ok(Withdraw::Cancel(crate::auth::Refusal { + error: err, + reason: "going away".to_string(), + })); } return Err(err); } @@ -1906,10 +1893,7 @@ impl Subscriber { return Ok(Withdraw::Done); } Turn::Failed(err) => return Err(err), - Turn::Renewal(request_update::Verdict { - verdict, - grant: res, - }) => { + Turn::Renewal(request_update::Verdict { verdict, grant: res }) => { // Only a token-authorized announce starts a renewal. let rg = token_grant.as_ref().expect("a renewal without a request grant"); // On accept the old grant is dropped and the deadline re-armed (REQUEST_OK). @@ -1940,12 +1924,10 @@ impl Subscriber { && let Err(err) = self.spend(update_id) { if matches!(err, Error::GoingAway) { - return Ok(Withdraw::Cancel( - crate::auth::Refusal { - error: err, - reason: "going away".to_string(), - }, - )); + return Ok(Withdraw::Cancel(crate::auth::Refusal { + error: err, + reason: "going away".to_string(), + })); } return Err(err); } @@ -2069,10 +2051,7 @@ impl Subscriber { } /// End an advertisement we accepted, leaving the session up: a closed stream. - async fn cancel_announce( - &self, - stream: &mut Stream, - ) -> Result<(), Error> { + async fn cancel_announce(&self, stream: &mut Stream) -> Result<(), Error> { // An OK cut short by the grant ending is still buffered, and goes out ahead of the FIN. std::future::poll_fn(|cx| stream.writer.poll_flush(cx)).await?; if stream.writer.finish().is_ok() { @@ -2109,12 +2088,8 @@ impl Subscriber { // it, and a rejected request has no lifetime of ours to hang the cleanup on, so the // entry would have to be swept asynchronously. Any data streams the publisher opened // before reading this are dropped by the unknown-alias path instead. - self.write_publish_error( - &mut stream, - &Error::Unsupported, - "PUBLISH is not supported", - ) - .await?; + self.write_publish_error(&mut stream, &Error::Unsupported, "PUBLISH is not supported") + .await?; // The rejection is the whole exchange, but it still has to arrive: a finish alone // leaves the drop-time reset free to discard it before the peer acknowledges it. let _ = stream.writer.close().await; @@ -2173,14 +2148,7 @@ impl Subscriber { err: &Error, reason: &str, ) -> Result<(), Error> { - super::request_stream::write_error( - &mut stream.writer, - request::Kind::Publish, - err, - reason, - self.version, - ) - .await + super::request_stream::write_error(&mut stream.writer, request::Kind::Publish, err, reason, self.version).await } /// Attach the route for one newly advertised namespace, returning the id that names @@ -2875,9 +2843,7 @@ impl Subscriber { max_age_supported.then(|| super::max_age::millis(aggregate.as_ref().map_or(Duration::MAX, |s| s.budget()))); let order = aggregate.map(|s| s.order).unwrap_or_default(); // Without an Established subscription, a relay includes the request it holds. - let new_group = target - .new_group() -; + let new_group = target.new_group(); let written = match &held { // Resume the held subscription: its group order is the one it was made with, // since no update can change it. Its groups wait on the answer from here. @@ -4054,9 +4020,7 @@ impl Subscriber { id if id == ietf::TrackStatusOk::ID => { return Ok(ietf::TrackStatusOk::decode_msg(&mut data, self.version)?); } - ietf::RequestError::ID if true => { - ietf::RequestError::decode_msg(&mut data, self.version)?.error_code - } + ietf::RequestError::ID if true => ietf::RequestError::decode_msg(&mut data, self.version)?.error_code, _ => return Err(Error::UnexpectedMessage), }; Err(request::from_code(code, request::Kind::TrackStatus, self.version)) @@ -5376,7 +5340,6 @@ async fn decode_fetch_object( stream: &mut Reader, first: bool, ) -> Result, Error> { - Ok(match stream.decode_maybe::().await? { None => None, Some(ietf::FetchObject::EndOfRange { .. }) => { @@ -6245,13 +6208,7 @@ mod tests { version, ); writer.varint(ietf::RequestOk::ID).await.unwrap(); - writer - .encode(&ietf::RequestOk { - largest: None, - active, - }) - .await - .unwrap(); + writer.encode(&ietf::RequestOk { largest: None, active }).await.unwrap(); for entry in entries { match entry.strip_prefix('-') { Some(suffix) => { @@ -7229,11 +7186,7 @@ mod tests { } drop(work); if opening { - assert_eq!( - control.next_request_id(), - RequestId(1), - "cancelled open spends no ID" - ); + assert_eq!(control.next_request_id(), RequestId(1), "cancelled open spends no ID"); } assert!(log.closes().is_empty(), "the session stays up"); } @@ -7251,31 +7204,11 @@ mod tests { }; } - setup_wait_test!( - invalid_subscribe_open_is_refused, - SubscribeOpen, - [Draft22] - ); - setup_wait_test!( - invalid_status_open_is_refused, - StatusOpen, - [Draft22] - ); - setup_wait_test!( - invalid_status_response_is_refused, - StatusResponse, - [Draft22] - ); - setup_wait_test!( - invalid_fetch_open_is_refused, - FetchOpen, - [Draft22] - ); - setup_wait_test!( - invalid_fetch_response_is_refused, - FetchResponse, - [Draft22] - ); + setup_wait_test!(invalid_subscribe_open_is_refused, SubscribeOpen, [Draft22]); + setup_wait_test!(invalid_status_open_is_refused, StatusOpen, [Draft22]); + setup_wait_test!(invalid_status_response_is_refused, StatusResponse, [Draft22]); + setup_wait_test!(invalid_fetch_open_is_refused, FetchOpen, [Draft22]); + setup_wait_test!(invalid_fetch_response_is_refused, FetchResponse, [Draft22]); fn control_message_types(log: &crate::lite::test_transport::Log, version: Version) -> Vec { let writes = log.writes.lock().unwrap().clone(); @@ -7635,22 +7568,18 @@ mod tests { /// including NOT_SUPPORTED and undefined codes, without opening a subscription. #[moq_clock::test] async fn a_refused_track_status_never_subscribes() { - for version in [ - Version::Draft18, - Version::Draft19, - Version::Draft22, - ] { + for version in [Version::Draft18, Version::Draft19, Version::Draft22] { for code in [3, u64::from(u32::MAX)] { for fetching in [false, true] { let refused = message( - ietf::RequestError::ID, - &ietf::RequestError { - error_code: code, - reason_phrase: "TRACK_STATUS is refused".into(), - retry_interval: 0, - }, - version, - ); + ietf::RequestError::ID, + &ietf::RequestError { + error_code: code, + reason_phrase: "TRACK_STATUS is refused".into(), + retry_interval: 0, + }, + version, + ); let session = crate::lite::test_transport::ScriptedSession::new(refused); let log = session.log.clone(); let (tasks, _task_set) = crate::util::TaskSet::new(); @@ -9764,10 +9693,7 @@ mod tests { /// only afterwards, and on drafts 14-16 with a PUBLISH_NAMESPACE_CANCEL after the OK. #[moq_clock::test] async fn a_revoked_token_retracts_an_announce_whose_ok_is_blocked() { - for version in [ - Version::Draft18, - Version::Draft22, - ] { + for version in [Version::Draft18, Version::Draft22] { let gate = kio::Producer::new(false); let session = crate::lite::test_transport::SinkSession::gated_bi(gate.consume()); let (mut subscriber, mut requests, _cred, consumer, session) = @@ -11492,10 +11418,7 @@ mod filter_tests { ); } - const JOINING_DRAFTS: [Version; 2] = [ - Version::Draft18, - Version::Draft19, - ]; + const JOINING_DRAFTS: [Version; 2] = [Version::Draft18, Version::Draft19]; /// Every pre-draft-20 join is Largest Object plus a joining FETCH, whatever its start, /// so the current group's head arrives on the fetch stream and the live tail on the @@ -12273,21 +12196,15 @@ mod stitch_tests { } } - /// Drafts 14 and 15 carry a relayed END_OF_GROUP object through FETCH, and the next - /// relay fills its cache from that answer. Later drafts end the answer at the last frame. + /// A relayed FETCH ends its answer at the last frame rather than carrying the + /// END_OF_GROUP object, and the next relay fills its cache from that answer. #[moq_clock::test] - async fn passthrough_fetch_keeps_the_end_of_group_object() { - for version in [ - Version::Draft22, - ] { - // Only draft-14 lets a status object carry properties, so later drafts cannot mark - // a gap before it. - let legacy = false; - let terminal = if legacy { (11, &[0x3e, 2][..]) } else { (9, &[][..]) }; + async fn passthrough_fetch_ends_at_the_last_frame() { + for version in [Version::Draft22] { let objects = [ (6, &[0x3e, 6][..], None), (8, &[0x3e, 1][..], None), - (terminal.0, terminal.1, Some(END_OF_GROUP)), + (9, &[][..], Some(END_OF_GROUP)), ]; let script = object_stream(version, true, &objects); let (bytes, log) = relay_passthrough(script, version, version, Some((0, 12))).await; @@ -12295,12 +12212,7 @@ mod stitch_tests { let mut decoder = Decoder::new(&bytes, version.into()); assert_eq!(decoder.varint().unwrap(), ietf::FetchOk::ID, "{version}"); let ok = ietf::FetchOk::decode(&mut decoder, version).unwrap(); - let carried = false; - let last = match () { - _ if carried => terminal.0 + 1, - _ if Filter::is_draft20(version) => 8, - _ => 9, - }; + let last = if Filter::is_draft20(version) { 8 } else { 9 }; assert_eq!(ok.end_location.object, last, "{version}"); assert_eq!(decoder.varint().unwrap(), ietf::FetchHeader::TYPE); ietf::FetchHeader::decode(&mut decoder, version).unwrap(); @@ -12325,20 +12237,7 @@ mod stitch_tests { assert_eq!(frame.fields.as_ref().unwrap().id, id, "{version}"); } assert!(reader.read_frame().await.unwrap().is_none()); - let end_object = reader.end_object(); - assert_eq!( - end_object.as_ref().map(|end| end.id), - carried.then_some(terminal.0), - "{version}" - ); - if let Some(end) = end_object { - assert_eq!( - super::super::object::listed(&end.properties, version) - .first() - .map(|property| property.id), - legacy.then_some(0x3e) - ); - } + assert!(reader.end_object().is_none(), "{version}"); } } @@ -12361,141 +12260,6 @@ mod stitch_tests { } } - /// Draft-14 lets a status object carry properties, and it has no frame to hold its - /// time, so a mutable Timestamp stays in its block on a timed track: through a subgroup - /// and a FETCH, and out again as it arrived. - #[moq_clock::test] - async fn a_status_object_keeps_its_timestamp() { - use futures::FutureExt; - - let version = Version::Draft18; - let status = [0x10, 7]; - let leaves = |properties: &crate::model::object::Properties| { - super::super::object::write(properties, Some(version), None, version, None).unwrap() - }; - - let script = object_stream( - version, - true, - &[(0, &[0x10, 5], None), (1, &status, Some(END_OF_GROUP))], - ); - let mut h = Harness::with_timescale(Fill::Done, vec![script], Some(Timescale::MILLI)); - h.subscriber.version = version; - let mut consumer = h.track.subscribe(None); - let mut stream = h.stream().await.with_version(version); - h.subscriber.clone().recv_group(&mut stream).await.unwrap(); - let group = consumer.recv_group().now_or_never().unwrap().unwrap().unwrap(); - let end = group.end_object().expect("the END_OF_GROUP object"); - assert_eq!(leaves(&end.properties), status, "subgroup"); - - // A draft-14 FETCH object: Group, Subgroup, Object, priority, then its properties, - // an empty payload, and the status. - let mut objects = Vec::new(); - let w = &mut Encoder::new(&mut objects, version.into()); - for value in [SEQUENCE, 0, 0] { - w.varint(value).unwrap(); - } - w.u8(128); - w.bytes(&status).unwrap(); - w.varint(0u64).unwrap(); - w.varint(END_OF_GROUP).unwrap(); - let mut run = GroupFetchRun::new(version, objects).await; - let mut producer = crate::recv::Group::new(run.track.create_group(group::Info { sequence: SEQUENCE }).unwrap()); - run.subscriber - .recv_group_fetch_objects(&mut run.stream, &mut producer, 0, Some(1), Some(Timescale::MILLI)) - .await - .unwrap(); - let end = producer - .into_inner() - .consume() - .end_object() - .expect("the END_OF_GROUP object"); - assert_eq!(leaves(&end.properties), status, "fetch"); - } - - /// A draft-14 status object has no frame, so its block may fill the whole limit on a - /// timed track, though its list arrives before the status says so. A framed object's - /// block leaves room for the Timestamp egress restates. - #[moq_clock::test] - async fn a_status_object_fills_the_whole_block() { - let version = Version::Draft18; - let milli = Some(Timescale::MILLI); - // A block of `size` held bytes: one opaque property, its key, a four-byte length, - // then bytes. A framed object's list adds its Timestamp, which the frame holds. - let block = |size: usize, framed: bool| { - let mut block = Vec::new(); - let w = &mut Encoder::new(&mut block, version.into()); - if framed { - w.varint(0x10u64).unwrap(); - w.varint(5u64).unwrap(); - } - w.varint(0x21u64).unwrap(); - w.bytes(&vec![7; size - 5]).unwrap(); - block - }; - let full = block(super::super::object::MAX_BLOCK, false); - let limit = super::super::object::max_block(milli); - - for (properties, status, ok) in [ - (&full, Some(END_OF_GROUP), true), - (&block(limit + 1, true), None, false), - (&block(limit, true), None, true), - ] { - let script = object_stream(version, true, &[(0, properties, status)]); - let mut h = Harness::with_timescale(Fill::Done, vec![script], milli); - h.subscriber.version = version; - let mut stream = h.stream().await.with_version(version); - let result = h.subscriber.clone().recv_group(&mut stream).await; - match ok { - true => assert!(result.is_ok(), "subgroup {}: {result:?}", properties.len()), - false => assert!(matches!(result, Err(Error::Unsupported)), "subgroup: {result:?}"), - } - - // The fetch harness's track is untimed, so a framed object it keeps cannot be timed. - if ok && status.is_none() { - continue; - } - // A draft-14 FETCH object: Group, Subgroup, Object, priority, then its properties, - // and an empty payload with its status or a one-byte payload. - let mut objects = Vec::new(); - let w = &mut Encoder::new(&mut objects, version.into()); - for value in [SEQUENCE, 0, 0] { - w.varint(value).unwrap(); - } - w.u8(128); - w.bytes(properties).unwrap(); - match status { - Some(status) => { - w.varint(0u64).unwrap(); - w.varint(status).unwrap(); - } - None => { - w.varint(1u64).unwrap(); - w.u8(99); - } - } - let mut run = GroupFetchRun::new(version, objects).await; - let mut producer = - crate::recv::Group::new(run.track.create_group(group::Info { sequence: SEQUENCE }).unwrap()); - let result = run - .subscriber - .recv_group_fetch_objects(&mut run.stream, &mut producer, 0, Some(1), milli) - .await; - match ok { - true => assert!(result.is_ok(), "fetch {}: {result:?}", properties.len()), - false => assert!(matches!(result, Err(Error::Unsupported)), "fetch: {result:?}"), - } - if status.is_some() { - let end = producer - .into_inner() - .consume() - .end_object() - .expect("the END_OF_GROUP object"); - assert_eq!(end.properties.heap(), full.len() as u64); - } - } - } - #[moq_clock::test] async fn passthrough_refuses_contradictory_gap_properties() { for properties in [vec![0x3e, 2], vec![0x3e, 3], vec![0x3e, 1, 0, 1]] { @@ -12615,27 +12379,18 @@ mod stitch_tests { #[moq_clock::test] async fn passthrough_preserves_immutable_bytes() { - for ingress in [ - Version::Draft18, - Version::Draft22, - ] { + for ingress in [Version::Draft18, Version::Draft22] { let mut inner = Vec::new(); let mut encoder = Encoder::new(&mut inner, ingress.into()); - for value in [2u64, 96_000, 128] { + for value in [2u64, 96_000, 2, 128, 1] { encoder.varint(value).unwrap(); } - encoder - .varint(1u64) - .unwrap(); encoder.bytes(&[42; 130]).unwrap(); let mut properties = Vec::new(); let mut encoder = Encoder::new(&mut properties, ingress.into()); encoder.varint(0x0bu64).unwrap(); encoder.bytes(&inner).unwrap(); - for egress in [ - Version::Draft18, - Version::Draft22, - ] { + for egress in [Version::Draft18, Version::Draft22] { let script = object_stream(ingress, true, &[(0, &properties, None)]); let (bytes, log) = relay_passthrough_stream(script, ingress, egress).await; assert!(log.resets().is_empty()); @@ -12691,108 +12446,108 @@ mod stitch_tests { .filter(|(version, ranged)| !*ranged || *version == Version::Draft22) .flat_map(|(version, ranged)| [(version, ranged, false), (version, ranged, true)]) { - let origin = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); - let broadcast = origin.publish("room", crate::origin::Route::default()).unwrap(); - let track = broadcast - .create_track("video", accepted_info(&Default::default(), version)) - .unwrap(); - let mut h = Harness::with_timescale(Fill::Done, vec![], None); - h.subscriber.version = version; - h.subscriber.state.lock().subscribes.get_mut(&REQUEST).unwrap().producer = Some(track.clone()); - let properties = vec![2, 7, 3, 1, 42]; - let mut original = Vec::new(); - for id in [6, 7, 8] { - let datagram = ietf::ObjectDatagram { - track_alias: ALIAS, - group_id: SEQUENCE, - object_id: Some(id), - // An omitted priority inherits the track default, which the - // downstream response need not carry. - publisher_priority: (id != 6).then_some(200), - end_of_group: false, - properties: (id != 8).then(|| properties.clone()), - body: if id == 8 { - ietf::DatagramBody::Status(END_OF_GROUP) + let origin = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); + let broadcast = origin.publish("room", crate::origin::Route::default()).unwrap(); + let track = broadcast + .create_track("video", accepted_info(&Default::default(), version)) + .unwrap(); + let mut h = Harness::with_timescale(Fill::Done, vec![], None); + h.subscriber.version = version; + h.subscriber.state.lock().subscribes.get_mut(&REQUEST).unwrap().producer = Some(track.clone()); + let properties = vec![2, 7, 3, 1, 42]; + let mut original = Vec::new(); + for id in [6, 7, 8] { + let datagram = ietf::ObjectDatagram { + track_alias: ALIAS, + group_id: SEQUENCE, + object_id: Some(id), + // An omitted priority inherits the track default, which the + // downstream response need not carry. + publisher_priority: (id != 6).then_some(200), + end_of_group: false, + properties: (id != 8).then(|| properties.clone()), + body: if id == 8 { + ietf::DatagramBody::Status(END_OF_GROUP) + } else { + ietf::DatagramBody::Payload(bytes::Bytes::from_static(b"object")) + }, + }; + h.subscriber + .recv_datagram(datagram.encode_bytes(version).unwrap()) + .unwrap(); + original.push(datagram); + } + track.finish().unwrap(); + let (served, _sessions) = match hop { + true => { + let (served, sessions) = crate::lite::ietf::test_hop(&origin, "room", [true, true]).await; + (served, Some(sessions)) + } + false => (origin, None), + }; + let downstream = ScriptedSession::per_stream(vec![vec![]]).with_datagrams(65535); + let peer = peer::PeerSetup::default(); + peer.set(peer::Peer::default()); + let publisher = crate::ietf::Publisher::new( + crate::time::sim(), + crate::driver::Transport::new(downstream.clone()), + served.consume(), + Control::new(false), + None, + peer, + version, + ); + let subscribe = ietf::Subscribe { + max_age: None, + new_group: None, + request_id: RequestId(3), + track_namespace: Path::new("room"), + track_name: "video".into(), + subscriber_priority: 128, + group_order: ietf::GroupOrder::Ascending, + filter: if ranged { + Filter::Absolute { + start: ietf::Location { + group: SEQUENCE, + object: 7, + }, + end: Some(ietf::EndLocation { + group: SEQUENCE, + object: Some(7), + }), + } } else { - ietf::DatagramBody::Payload(bytes::Bytes::from_static(b"object")) + Filter::Unfiltered }, + fill: None, + properties_wanted: true, + forward: true, + rendezvous: false, + range_filters: false, + authorization_token: None, + epoch: None, }; - h.subscriber - .recv_datagram(datagram.encode_bytes(version).unwrap()) + let mut body = Vec::new(); + subscribe + .encode_msg(&mut Encoder::new(&mut body, version.into()), version) .unwrap(); - original.push(datagram); - } - track.finish().unwrap(); - let (served, _sessions) = match hop { - true => { - let (served, sessions) = crate::lite::ietf::test_hop(&origin, "room", [true, true]).await; - (served, Some(sessions)) + let stream = Stream::open(&mut crate::driver::Transport::new(downstream.clone()), version) + .await + .unwrap(); + publisher + .handle_stream(ietf::Subscribe::ID, ietf::Body(body.into()), stream, false) + .unwrap() + .await; + let sent = downstream.log.datagrams.lock().unwrap(); + original.retain(|datagram| !ranged || datagram.object_id == Some(7)); + assert_eq!(sent.len(), original.len(), "{version} ranged={ranged} hop={hop}"); + let inherited = super::super::priority::to_wire(track.publisher_priority()); + for (bytes, mut expected) in sent.iter().zip(original) { + expected.track_alias = 3; + expected.publisher_priority = expected.publisher_priority.or(Some(inherited)); + let (actual, _) = ietf::ObjectDatagram::decode_slice(bytes, version).unwrap(); + assert_eq!(actual, expected); } - false => (origin, None), - }; - let downstream = ScriptedSession::per_stream(vec![vec![]]).with_datagrams(65535); - let peer = peer::PeerSetup::default(); - peer.set(peer::Peer::default()); - let publisher = crate::ietf::Publisher::new( - crate::time::sim(), - crate::driver::Transport::new(downstream.clone()), - served.consume(), - Control::new(false), - None, - peer, - version, - ); - let subscribe = ietf::Subscribe { - max_age: None, - new_group: None, - request_id: RequestId(3), - track_namespace: Path::new("room"), - track_name: "video".into(), - subscriber_priority: 128, - group_order: ietf::GroupOrder::Ascending, - filter: if ranged { - Filter::Absolute { - start: ietf::Location { - group: SEQUENCE, - object: 7, - }, - end: Some(ietf::EndLocation { - group: SEQUENCE, - object: Some(7), - }), - } - } else { - Filter::Unfiltered - }, - fill: None, - properties_wanted: true, - forward: true, - rendezvous: false, - range_filters: false, - authorization_token: None, - epoch: None, - }; - let mut body = Vec::new(); - subscribe - .encode_msg(&mut Encoder::new(&mut body, version.into()), version) - .unwrap(); - let stream = Stream::open(&mut crate::driver::Transport::new(downstream.clone()), version) - .await - .unwrap(); - publisher - .handle_stream(ietf::Subscribe::ID, ietf::Body(body.into()), stream, false) - .unwrap() - .await; - let sent = downstream.log.datagrams.lock().unwrap(); - original.retain(|datagram| !ranged || datagram.object_id == Some(7)); - assert_eq!(sent.len(), original.len(), "{version} ranged={ranged} hop={hop}"); - let inherited = super::super::priority::to_wire(track.publisher_priority()); - for (bytes, mut expected) in sent.iter().zip(original) { - expected.track_alias = 3; - expected.publisher_priority = expected.publisher_priority.or(Some(inherited)); - let (actual, _) = ietf::ObjectDatagram::decode_slice(bytes, version).unwrap(); - assert_eq!(actual, expected); - } } } @@ -12803,9 +12558,7 @@ mod stitch_tests { let mut encoder = Encoder::new(&mut properties, ingress.into()); encoder.varint(0x80u64).unwrap(); encoder.varint(96_000u64).unwrap(); - encoder - .varint(1u64) - .unwrap(); + encoder.varint(1u64).unwrap(); encoder.bytes(&[42; 130]).unwrap(); for egress in [Version::Draft22] { let script = object_stream(ingress, true, &[(0, &properties, None)]); @@ -12817,10 +12570,7 @@ mod stitch_tests { let mut props = Decoder::new(decoder.bytes().unwrap(), egress.into()); assert_eq!(props.varint().unwrap(), 0x80); assert_eq!(props.varint().unwrap(), 96_000); - assert_eq!( - props.varint().unwrap(), - 1 - ); + assert_eq!(props.varint().unwrap(), 1); assert_eq!(props.bytes().unwrap(), &[42; 130]); assert!(props.is_empty()); } @@ -13810,22 +13560,11 @@ mod stitch_tests { assert_eq!(frames[0].1, b"whole-0"); } - /// From draft-18 on, a later object's Group ID field is a delta: 7 then 8 is 0, not 8. - /// Draft-17 and earlier still send the absolute ID. + /// A later object's Group ID field is a delta: 7 then 8 is 0, not 8. #[test] fn a_later_fetch_group_field_is_a_delta() { - assert_eq!( - resolve_fetch_group(Some(7), Some(0)).unwrap(), - Some(8) - ); - assert_eq!( - resolve_fetch_group(Some(7), Some(0)).unwrap(), - Some(8) - ); - assert_eq!( - resolve_fetch_group(Some(7), Some(8)).unwrap(), - Some(8) - ); + assert_eq!(resolve_fetch_group(Some(7), Some(0)).unwrap(), Some(8)); + assert_eq!(resolve_fetch_group(Some(7), Some(1)).unwrap(), Some(9)); } /// A joining FETCH carries the one group its subscription joins, so a second group on @@ -14142,10 +13881,7 @@ mod joining_fetch_tests { }; use futures::FutureExt; - const JOINING_DRAFTS: [Version; 2] = [ - Version::Draft18, - Version::Draft19, - ]; + const JOINING_DRAFTS: [Version; 2] = [Version::Draft18, Version::Draft19]; async fn settle() { moq_clock::sleep(Duration::from_millis(1)).await; @@ -14452,10 +14188,7 @@ mod joining_fetch_tests { joining.poll(&kio::Waiter::noop()).is_ready(), "{version}: invalid joining open stayed alive" ); - assert_eq!( - subscriber.control.next_request_id(), - RequestId(1) - ); + assert_eq!(subscriber.control.next_request_id(), RequestId(1)); assert_eq!(log.bi_opens(), 0); } } @@ -14474,10 +14207,7 @@ mod joining_fetch_tests { drop(joining); *gate.write().ok().expect("gate is open") = true; let _ = tasks.poll(&kio::Waiter::noop()); - assert_eq!( - subscriber.control.next_request_id(), - RequestId(1) - ); + assert_eq!(subscriber.control.next_request_id(), RequestId(1)); assert_eq!(log.bi_opens(), 0, "{version}: the abandoned open is gone"); } } @@ -15721,10 +15451,7 @@ mod compression_negotiation_tests { compress: true, ..Default::default() }; - for version in [ - Version::Draft18, - Version::Draft22, - ] { + for version in [Version::Draft18, Version::Draft22] { assert!(matches!( refused(&properties, version, false), Some(Error::UnsupportedExtension) diff --git a/rs/moq-net/src/ietf/token.rs b/rs/moq-net/src/ietf/token.rs index 185a2ec1530..a787c155405 100644 --- a/rs/moq-net/src/ietf/token.rs +++ b/rs/moq-net/src/ietf/token.rs @@ -255,9 +255,7 @@ mod tests { kind: 300, value: vec![0x00, 0xff], }; - for (version, expected) in [ - (Version::Draft18, [0x03, 0x81, 0x2c, 0x00, 0xff]), - ] { + for (version, expected) in [(Version::Draft18, [0x03, 0x81, 0x2c, 0x00, 0xff])] { let mut params = Parameters::default(); into_setup(&mut params, &token, version).unwrap(); assert_eq!( diff --git a/rs/moq-net/src/lite/ietf.rs b/rs/moq-net/src/lite/ietf.rs index 40f3e62dc27..dbb705435ba 100644 --- a/rs/moq-net/src/lite/ietf.rs +++ b/rs/moq-net/src/lite/ietf.rs @@ -778,39 +778,6 @@ mod tests { } } - /// Dropping an understood property can widen the delta that spans it, so a list that - /// could not cross is refused where it arrives rather than where it would be sent. - #[test] - fn track_properties_that_cannot_cross_are_refused_at_ingress() { - let version = Draft::Draft18; - // The most a draft-16 answer holds beside a Request ID and an empty parameter count. - let size = super::super::message::MAX_MESSAGE_SIZE - 2; - // DYNAMIC_GROUPS, then the last ID whose delta from it fits four bytes. - let id = 0x30 + (1 << 30) - 1; - let mut list = Vec::new(); - let e = &mut Encoder::new(&mut list, version.into()); - for value in [0x30, 1, id - 0x30] { - e.varint(value).unwrap(); - } - let fill = size - list.len() - 4; - let e = &mut Encoder::new(&mut list, version.into()); - e.bytes(&vec![0; fill]).unwrap(); - assert_eq!(list.len(), size); - - // The delta from zero takes eight bytes once DYNAMIC_GROUPS leaves the list. - let ingress = crate::ietf::Properties::decode(&mut Decoder::new(&list, version.into()), version).unwrap(); - assert!(ingress.dynamic_groups); - let forwarded = crate::model::object::TrackProperties { - version, - values: ingress.unknown, - }; - assert!(!fits(&forwarded)); - assert!(matches!( - forwarded.refused(&crate::track::Info::default()), - Some(crate::Error::Unsupported) - )); - } - fn datagram(wire: &crate::model::datagram::Wire) -> Vec { let mut buf = Vec::new(); encode_datagram(&mut Encoder::new(&mut buf, V.into()), Some(wire)).unwrap(); @@ -821,8 +788,7 @@ mod tests { /// would close the session it reached: it is refused where it arrives. #[test] fn datagram_statuses_are_ones_moq_transport_defines() { - for (status, ok) in [(0, true), (1, true), (2, false), (3, true), (4, true), (5, false)] { - // Draft 14 sends a status datagram's Object ID and priority. + for (status, ok) in [(0, true), (1, false), (2, false), (3, true), (4, true), (5, false)] { let wire = crate::model::datagram::Wire { object_id: Some(3), priority: Some(9), diff --git a/rs/moq-net/src/server.rs b/rs/moq-net/src/server.rs index 5901bab5f98..c05cb624a3d 100644 --- a/rs/moq-net/src/server.rs +++ b/rs/moq-net/src/server.rs @@ -6,8 +6,8 @@ use crate::origin; use crate::time::{Deadlines, Instant}; use crate::transport::poll::Session as _; use crate::{ - ALPN_18, ALPN_19, ALPN_20, ALPN_21, ALPN_22, ALPN_LITE, ALPN_LITE_03, ALPN_LITE_04, ALPN_LITE_05, ALPN_LITE_06, ALPN_LITE_07_WIP, Consume, Error, NEGOTIATED, Session, SessionError, - Version, Versions, + ALPN_18, ALPN_19, ALPN_20, ALPN_21, ALPN_22, ALPN_LITE, ALPN_LITE_03, ALPN_LITE_04, ALPN_LITE_05, ALPN_LITE_06, + ALPN_LITE_07_WIP, Consume, Error, NEGOTIATED, Session, SessionError, Version, Versions, coding::{Encode, Stream}, ietf, lite, setup::{self, Role}, @@ -1226,7 +1226,9 @@ mod tests { async fn a_reply_the_peer_never_takes_fails_at_the_deadline() { let registry = stats::Registry::new(Default::default()); let version = Version::Lite(lite::Version::Lite02); - let session = FakeSession::new(ALPN_LITE, []).with_bi(moql_setup()).withholding_credit(); + let session = FakeSession::new(ALPN_LITE, []) + .with_bi(moql_setup()) + .withholding_credit(); let start = moq_clock::now(); let deadline = start + std::time::Duration::from_secs(10); let request = Server::new() @@ -1240,10 +1242,7 @@ mod tests { }; assert!(matches!(err, Error::Timeout), "{err:?}"); assert_eq!(moq_clock::now(), deadline); - assert_eq!( - session.close_code(), - Some(version.session_code(&SessionError::Timeout)) - ); + assert_eq!(session.close_code(), Some(version.session_code(&SessionError::Timeout))); let failed = registry.snapshot().sessions()[0].1.sessions_failed; assert_eq!(failed.count(stats::Failure::Application), 1, "{failed:?}"); } @@ -1254,7 +1253,9 @@ mod tests { async fn an_abandoned_reply_fails_like_the_deadline() { let registry = stats::Registry::new(Default::default()); let version = Version::Lite(lite::Version::Lite02); - let session = FakeSession::new(ALPN_LITE, []).with_bi(moql_setup()).withholding_credit(); + let session = FakeSession::new(ALPN_LITE, []) + .with_bi(moql_setup()) + .withholding_credit(); let request = Server::new() .accept_request(moq_clock::now(), session.clone()) .await @@ -1262,10 +1263,7 @@ mod tests { .with_stats(registry.tier(Default::default()).session("room")); let abandoned = moq_clock::timeout(std::time::Duration::from_secs(1), request.ok()).await; assert!(abandoned.is_err(), "a reply the peer never took completed"); - assert_eq!( - session.close_code(), - Some(version.session_code(&SessionError::Timeout)) - ); + assert_eq!(session.close_code(), Some(version.session_code(&SessionError::Timeout))); let failed = registry.snapshot().sessions()[0].1.sessions_failed; assert_eq!(failed.count(stats::Failure::Application), 1, "{failed:?}"); } @@ -1341,10 +1339,7 @@ mod tests { async fn accept_request_reads_ietf_path() { // Every draft gates on the SETUP stream before starting, so the // path is known at authorization time just like lite-05. - for (alpn, version) in [ - (ALPN_18, ietf::Version::Draft18), - (ALPN_19, ietf::Version::Draft19), - ] { + for (alpn, version) in [(ALPN_18, ietf::Version::Draft18), (ALPN_19, ietf::Version::Draft19)] { let session = FakeSession::new(alpn, [ietf_setup(version, Some("/team/room"))]); let request = Server::new().accept_request(moq_clock::now(), session).await.unwrap(); assert_eq!(request.path(), "/team/room", "{alpn}"); diff --git a/rs/moq-net/src/setup.rs b/rs/moq-net/src/setup.rs index bbc37ad9c2c..be10fe08ca4 100644 --- a/rs/moq-net/src/setup.rs +++ b/rs/moq-net/src/setup.rs @@ -8,7 +8,8 @@ use bytes::Bytes; use crate::{ Version, - coding::{self, Decode, DecodeError, Decoder, Encode, EncodeError, Encoder}, lite, + coding::{self, Decode, DecodeError, Decoder, Encode, EncodeError, Encoder}, + lite, }; /// The session direction a client advertises in its SETUP (moq-lite-05+). @@ -162,8 +163,8 @@ fn negotiated(v: Version) -> bool { /// The client half of the `moql` bidi SETUP exchange, offering moq-lite 01/02. /// -/// The framing is moq-transport draft-14's CLIENT_SETUP, which moq-lite 01/02 borrowed: -/// a u16 size, the offered versions, then parameters. +/// The framing is moq-transport draft-14's CLIENT_SETUP, which moq-lite 01/02 borrowed with a +/// varint size: the size, the offered versions, then parameters. #[derive(Debug, Clone)] pub(crate) struct Client { /// The list of supported versions in preferred order. @@ -184,8 +185,7 @@ impl Decode for Client { return Err(DecodeError::InvalidValue); } - let size = r.u16()? as usize; - let mut msg = r.sub(size)?; + let mut msg = decode_body(r)?; let versions = coding::Versions::decode(&mut msg, v).map_err(DecodeError::complete)?; Ok(Self { @@ -202,13 +202,25 @@ impl Encode for Client { return Err(EncodeError::Version); } w.u8(CLIENT_SETUP); - let prefix = w.prefix_u16(); + let prefix = w.prefix_varint(); self.versions.encode(w, v)?; w.slice(&self.parameters); fill_body(w, prefix) } } +/// Read a SETUP body's varint size, refusing one past [`MAX_SETUP_SIZE`] before buffering it. +fn decode_body<'a>(r: &mut Decoder<'a>) -> Result, DecodeError> { + let size = usize::try_from(r.varint()?).map_err(|_| DecodeError::BoundsExceeded)?; + if size > MAX_SETUP_SIZE { + return Err(DecodeError::MessageTooLarge { + size, + max: MAX_SETUP_SIZE, + }); + } + r.sub(size) +} + /// Size a SETUP body, refusing one our own receiver would refuse. fn fill_body(w: &mut Encoder<'_>, prefix: coding::Prefix) -> Result<(), EncodeError> { if w.since(&prefix) > MAX_SETUP_SIZE { @@ -220,8 +232,8 @@ fn fill_body(w: &mut Encoder<'_>, prefix: coding::Prefix) -> Result<(), EncodeEr /// The server half of the `moql` bidi SETUP exchange, selecting moq-lite 01 or 02. /// -/// The framing is moq-transport draft-14's SERVER_SETUP: a u16 size, the selected version, -/// then parameters. +/// The framing is moq-transport draft-14's SERVER_SETUP with a varint size: the size, the +/// selected version, then parameters. #[derive(Debug, Clone)] pub(crate) struct Server { /// The selected version. @@ -238,7 +250,7 @@ impl Encode for Server { return Err(EncodeError::Version); } w.u8(SERVER_SETUP); - let prefix = w.prefix_u16(); + let prefix = w.prefix_varint(); self.version.encode(w, v)?; w.slice(&self.parameters); fill_body(w, prefix) @@ -256,8 +268,7 @@ impl Decode for Server { return Err(DecodeError::InvalidValue); } - let size = r.u16()? as usize; - let mut msg = r.sub(size)?; + let mut msg = decode_body(r)?; let version = coding::Version::decode(&mut msg, v).map_err(DecodeError::complete)?; Ok(Self { diff --git a/rs/moq-net/src/test_interop.rs b/rs/moq-net/src/test_interop.rs index aa6bc1d546a..6cbe23b6773 100644 --- a/rs/moq-net/src/test_interop.rs +++ b/rs/moq-net/src/test_interop.rs @@ -260,7 +260,6 @@ fn ietf_datagram_interop() { ietf::Version::Draft22, ]; for (draft, version) in (18..).zip(all) { - let legacy = false; let mut properties = Vec::new(); let mut w = Encoder::new(&mut properties, version.into()); ietf::encode_object_time(&mut w, Timestamp::from_millis(1234).unwrap(), Timescale::MILLI).unwrap(); @@ -293,17 +292,6 @@ fn ietf_datagram_interop() { properties: None, body: ietf::DatagramBody::Payload(bytes::Bytes::new()), }); - if legacy { - datagrams.push(ietf::ObjectDatagram { - track_alias: 1, - group_id: 2, - object_id: Some(0), - publisher_priority: Some(0), - end_of_group: false, - properties: Some(properties.clone()), - body: ietf::DatagramBody::Status(3), - }); - } let encoded: Vec> = datagrams .iter() .map(|datagram| datagram.encode_bytes(version).unwrap().to_vec()) @@ -468,7 +456,11 @@ fn ietf_track_status_interop() { for (index, wanted) in [true, false].into_iter().enumerate() { let mut r = Decoder::new(&responses[index], version.into()); - assert_eq!(r.varint().unwrap(), ::ID, "{version}"); + assert_eq!( + r.varint().unwrap(), + ::ID, + "{version}" + ); let ok = ietf::TrackStatusOk::decode(&mut r, version).unwrap(); assert!(r.is_empty(), "{version}: trailing bytes"); diff --git a/rs/moq-net/tests/integration/compress.rs b/rs/moq-net/tests/integration/compress.rs index 2df16b3434f..4a5dbef041a 100644 --- a/rs/moq-net/tests/integration/compress.rs +++ b/rs/moq-net/tests/integration/compress.rs @@ -117,11 +117,7 @@ async fn relay(published: Published, hops: [&str; 2], subscription: moq_net::tra /// Hops that carry a start group and negotiate compression: lite-07, and moq-transport /// draft-17 and later. -const RANGED: &[&str] = &[ - "moq-lite-07-wip", - "moq-transport-18", - "moq-transport-22", -]; +const RANGED: &[&str] = &["moq-lite-07-wip", "moq-transport-18", "moq-transport-22"]; /// A subscription starting at a group delivers it whole from its first frame across every /// pair of hops, compressed or not, whether the group began before it subscribed or after. @@ -193,10 +189,7 @@ async fn relay_serves_every_version() { let mut fixture = connect("moq-lite-07-wip", version).await; assert_eq!( fixture.subscriber.info().compress, - !matches!( - version, - "moq-lite-06" | "moq-lite-03" - ), + !matches!(version, "moq-lite-06" | "moq-lite-03"), "{version}: compression declared" ); @@ -241,12 +234,7 @@ async fn relay_serves_every_version() { /// compressed or inflated. #[moq_clock::test] async fn datagrams_serve_every_version() { - for &version in &[ - "moq-lite-07-wip", - "moq-lite-06", - "moq-transport-18", - "moq-transport-22", - ] { + for &version in &["moq-lite-07-wip", "moq-lite-06", "moq-transport-18", "moq-transport-22"] { moq_clock::timeout(TIMEOUT, async { let mut fixture = connect("moq-lite-07-wip", version).await; fixture @@ -338,17 +326,10 @@ async fn datagrams_meter_the_bytes_on_the_wire() { #[moq_clock::test] async fn ietf_ingress_stays_compressed_across_protocols() { for upstream in ["moq-transport-18", "moq-transport-22"] { - for downstream in [ - "moq-lite-07-wip", - "moq-transport-22", - ] { + for downstream in ["moq-lite-07-wip", "moq-transport-22"] { moq_clock::timeout(TIMEOUT, async { let mut fixture = connect(upstream, downstream).await; - assert_eq!( - fixture.subscriber.info().compress, - true, - "{upstream} -> {downstream}" - ); + assert_eq!(fixture.subscriber.info().compress, true, "{upstream} -> {downstream}"); let mut group = fixture.track.append_group().unwrap(); for index in 0..3 { group @@ -389,7 +370,7 @@ async fn ietf_ingress_stays_compressed_across_protocols() { /// A finished compressed track remains fetchable without subscribing to its live feed. #[moq_clock::test] async fn ietf_fetch_keeps_the_stored_form() { - for version in [ "moq-transport-18", "moq-transport-22"] { + for version in ["moq-transport-18", "moq-transport-22"] { moq_clock::timeout(TIMEOUT, async { let publisher = produce_origin(1); let broadcast = publisher.create_broadcast("bcast").unwrap(); diff --git a/rs/moq-net/tests/integration/control_stats.rs b/rs/moq-net/tests/integration/control_stats.rs index ac1795fb18e..d9eb95c7a45 100644 --- a/rs/moq-net/tests/integration/control_stats.rs +++ b/rs/moq-net/tests/integration/control_stats.rs @@ -19,12 +19,7 @@ fn origin() -> origin::Producer { #[moq_clock::test] async fn control_classes_cross_lite_and_ietf_sessions_without_counting_payload() { - for version in [ - "moq-lite-03", - "moq-lite-06", - "moq-lite-07-wip", - "moq-transport-22", - ] { + for version in ["moq-lite-03", "moq-lite-06", "moq-lite-07-wip", "moq-transport-22"] { let publisher = origin(); let subscriber = origin(); let registry = Registry::new(Default::default()); diff --git a/rs/moq-net/tests/integration/datagram.rs b/rs/moq-net/tests/integration/datagram.rs index 2544bf07394..64d803906fd 100644 --- a/rs/moq-net/tests/integration/datagram.rs +++ b/rs/moq-net/tests/integration/datagram.rs @@ -124,10 +124,7 @@ async fn datagrams_reach_the_subscriber_in_order() { /// datagram with its sequence, alongside the groups on streams. #[moq_clock::test] async fn ietf_delivers_datagrams() { - for version in [ - "moq-transport-18", - "moq-transport-20", - ] { + for version in ["moq-transport-18", "moq-transport-20"] { moq_clock::timeout(TEST_TIMEOUT, ietf_delivers_datagrams_on(version)) .await .unwrap_or_else(|_| panic!("{version}: timed out")); @@ -159,11 +156,7 @@ async fn ietf_delivers_datagrams_on(version: &str) { let mut before = subscriber.recv_group().await.unwrap().unwrap(); assert_eq!(before.sequence, 0, "{version}"); let first = before.next_frame().await.unwrap().unwrap().timestamp; - assert_eq!( - first.map(|timestamp| timestamp.is_zero()), - Some(true), - "{version}" - ); + assert_eq!(first.map(|timestamp| timestamp.is_zero()), Some(true), "{version}"); producer .insert_datagram( diff --git a/rs/moq-net/tests/integration/empty_group.rs b/rs/moq-net/tests/integration/empty_group.rs index 10e9fefe93c..ab55a756ea1 100644 --- a/rs/moq-net/tests/integration/empty_group.rs +++ b/rs/moq-net/tests/integration/empty_group.rs @@ -18,11 +18,7 @@ fn timed() -> moq_net::track::Info { const TIMEOUT: Duration = Duration::from_secs(10); -const VERSIONS: &[&str] = &[ - "moq-lite-06", - "moq-transport-18", - "moq-transport-22", -]; +const VERSIONS: &[&str] = &["moq-lite-06", "moq-transport-18", "moq-transport-22"]; fn produce_origin(hop: u64) -> origin::Producer { let (producer, driver) = origin::Producer::new(origin::Config::new(Hop::new(hop).unwrap())); diff --git a/rs/moq-net/tests/integration/fetch_only.rs b/rs/moq-net/tests/integration/fetch_only.rs index 9f70c97e990..2df8a459218 100644 --- a/rs/moq-net/tests/integration/fetch_only.rs +++ b/rs/moq-net/tests/integration/fetch_only.rs @@ -90,11 +90,7 @@ fn frames(sequence: u64) -> Vec> { /// Draft-17 is absent: its TRACK_STATUS answer cannot say whether the track is timed, /// so it still SUBSCRIBEs to learn the track. -const VERSIONS: &[&str] = &[ - "moq-transport-18", - "moq-transport-19", - "moq-transport-22", -]; +const VERSIONS: &[&str] = &["moq-transport-18", "moq-transport-19", "moq-transport-22"]; async fn direct(version: &str) { let version: Version = version.parse().unwrap(); diff --git a/rs/moq-net/tests/integration/goaway.rs b/rs/moq-net/tests/integration/goaway.rs index 0d69667c91a..605c9d6c15a 100644 --- a/rs/moq-net/tests/integration/goaway.rs +++ b/rs/moq-net/tests/integration/goaway.rs @@ -32,12 +32,7 @@ const TEST_TIMEOUT: Duration = Duration::from_secs(10); /// Every version with GOAWAY support, across both wires and their distinct /// channels: the lite Goaway control stream, the IETF draft-14-16 shared /// control stream, and the IETF draft-17+ SETUP uni streams. -const GOAWAY_VERSIONS: &[&str] = &[ - "moq-lite-04", - "moq-lite-05", - "moq-transport-18", - "moq-transport-19", -]; +const GOAWAY_VERSIONS: &[&str] = &["moq-lite-04", "moq-lite-05", "moq-transport-18", "moq-transport-19"]; /// A full receive window or missing FIN ACK cannot hold a drain beyond its local deadline. async fn closes_stalled_goaway(version: Version, writes: bool) { diff --git a/rs/moq-net/tests/integration/idle_session.rs b/rs/moq-net/tests/integration/idle_session.rs index 342441eb920..770f5947c43 100644 --- a/rs/moq-net/tests/integration/idle_session.rs +++ b/rs/moq-net/tests/integration/idle_session.rs @@ -110,7 +110,7 @@ async fn busy_viewer_sees_the_estimate_move() { /// A transport estimate demanded locally still costs one poll per sampling deadline. #[moq_clock::test] async fn ietf_stats_refresh_costs_one_driver_poll() { - for version in [ "moq-transport-22"] { + for version in ["moq-transport-22"] { let polls = Arc::new(AtomicUsize::new(0)); let mut options = MockConnectOptions::new(version.parse::().unwrap()); options.stats = STATS; diff --git a/rs/moq-net/tests/integration/ietf_conformance.rs b/rs/moq-net/tests/integration/ietf_conformance.rs index fc66a14e1d5..5e170e45d8f 100644 --- a/rs/moq-net/tests/integration/ietf_conformance.rs +++ b/rs/moq-net/tests/integration/ietf_conformance.rs @@ -76,14 +76,14 @@ async fn routing(version: &str, cluster: bool) { #[moq_clock::test] async fn conformance_namespaces_route_through_one_relay() { - for version in [ "moq-transport-18"] { + for version in ["moq-transport-18"] { routing(version, false).await; } } #[moq_clock::test] async fn conformance_namespaces_route_through_a_lite_cluster() { - for version in [ "moq-transport-18"] { + for version in ["moq-transport-18"] { routing(version, true).await; } } diff --git a/rs/moq-net/tests/integration/late_lower_group.rs b/rs/moq-net/tests/integration/late_lower_group.rs index 06e8a1a2191..93f25a21042 100644 --- a/rs/moq-net/tests/integration/late_lower_group.rs +++ b/rs/moq-net/tests/integration/late_lower_group.rs @@ -25,7 +25,7 @@ const FOREVER: Duration = Duration::from_millis((1 << 53) - 1); const LITE: &[&str] = &["moq-lite-05", "moq-lite-06", "moq-lite-07-wip"]; -const TRANSPORT: &[&str] = &[ "moq-transport-18", "moq-transport-22"]; +const TRANSPORT: &[&str] = &["moq-transport-18", "moq-transport-22"]; /// From `start`, or the oldest group still around when there is none. fn floored(start: Option) -> Range { diff --git a/rs/moq-net/tests/integration/multi_cdn.rs b/rs/moq-net/tests/integration/multi_cdn.rs index c5c66d052ae..3c1de07ac30 100644 --- a/rs/moq-net/tests/integration/multi_cdn.rs +++ b/rs/moq-net/tests/integration/multi_cdn.rs @@ -357,4 +357,3 @@ async fn transport_secondary_is_refused() { async fn transport_17_secondary_is_refused() { refused_across_protocols("moq-transport-18").await; } - diff --git a/rs/moq-net/tests/integration/range_anchors.rs b/rs/moq-net/tests/integration/range_anchors.rs index f6494697596..b79ba931517 100644 --- a/rs/moq-net/tests/integration/range_anchors.rs +++ b/rs/moq-net/tests/integration/range_anchors.rs @@ -130,9 +130,7 @@ async fn each_wire_refuses_only_the_anchors_it_drops() { // A wire without timestamps refuses a time anchor for that first. let timed = !matches!( version, - Some( - "moq-lite-03" | "moq-lite-04" | "moq-lite-05" | "moq-lite-06" - ) + Some("moq-lite-03" | "moq-lite-04" | "moq-lite-05" | "moq-lite-06") ); for (range, held) in anchored() { let result = read(version, range).await; diff --git a/rs/moq-net/tests/integration/restart.rs b/rs/moq-net/tests/integration/restart.rs index 4efbcde258d..47b9c5d0b28 100644 --- a/rs/moq-net/tests/integration/restart.rs +++ b/rs/moq-net/tests/integration/restart.rs @@ -536,12 +536,7 @@ async fn retired_fetch_explicit_epoch_control() { #[moq_clock::test] async fn withdrawal_refuses_new_fetches_but_keeps_open_reads() { - for version in [ - "moq-lite-05", - "moq-lite-06", - "moq-lite-07-wip", - "moq-transport-22", - ] { + for version in ["moq-lite-05", "moq-lite-06", "moq-lite-07-wip", "moq-transport-22"] { let version: Version = version.parse().unwrap(); let publisher = produce_origin(1); let viewer = produce_origin(2); @@ -564,12 +559,7 @@ async fn withdrawal_refuses_new_fetches_but_keeps_open_reads() { #[moq_clock::test] async fn a_more_specific_source_cannot_fill_a_held_covering_track() { - for name in [ - "moq-lite-05", - "moq-lite-06", - "moq-lite-07-wip", - "moq-transport-22", - ] { + for name in ["moq-lite-05", "moq-lite-06", "moq-lite-07-wip", "moq-transport-22"] { let version: Version = name.parse().unwrap(); let publisher = produce_origin(1); let viewer = produce_origin(2); diff --git a/rs/moq-net/tests/integration/session_close.rs b/rs/moq-net/tests/integration/session_close.rs index 81c8992d07a..4fa6073a3a8 100644 --- a/rs/moq-net/tests/integration/session_close.rs +++ b/rs/moq-net/tests/integration/session_close.rs @@ -332,7 +332,7 @@ async fn earlier_lite_peer_close_reads_buffered_tail() { #[moq_clock::test] async fn ietf_peer_close_reads_buffered_tail() { - for version in [ "moq-transport-18", "moq-transport-22"] { + for version in ["moq-transport-18", "moq-transport-22"] { peer_close_reads_buffered_tail(version).await; } } diff --git a/rs/moq-net/tests/integration/subscribe_ranges.rs b/rs/moq-net/tests/integration/subscribe_ranges.rs index 4372bcc5ef1..71ea39d54d4 100644 --- a/rs/moq-net/tests/integration/subscribe_ranges.rs +++ b/rs/moq-net/tests/integration/subscribe_ranges.rs @@ -18,7 +18,7 @@ const LITE: &[&str] = &["moq-lite-05", "moq-lite-06", "moq-lite-07-wip"]; /// Draft-20 and later are left out: the first subscriber's absolute start goes upstream /// in the SUBSCRIBE filter, and the subscriber never widens it when a live one joins /// (`quest/m1/subscribe-ranges/ietf.md`), so group 3 never arrives. -const TRANSPORT: &[&str] = &[ "moq-transport-18"]; +const TRANSPORT: &[&str] = &["moq-transport-18"]; fn produce_origin(hop: u64) -> moq_net::origin::Producer { let (producer, driver) = diff --git a/rs/moq-net/tests/integration/subscribe_tracks.rs b/rs/moq-net/tests/integration/subscribe_tracks.rs index c22fe76cf85..cecaeb6e14f 100644 --- a/rs/moq-net/tests/integration/subscribe_tracks.rs +++ b/rs/moq-net/tests/integration/subscribe_tracks.rs @@ -169,21 +169,3 @@ async fn subscribe_tracks_needs_forward_0_on_draft_18() { deliver(&mut setup, b"after").await; } - -/// Before draft-18, 0x51 is not a message at all, so it is still a protocol violation. -#[moq_clock::test] -async fn subscribe_tracks_before_draft_18_closes_the_session() { - let setup = setup("moq-transport-18".parse().unwrap()).await; - let (mut send, _recv) = setup - .pair - .server_transport - .clone() - .open_bi(Default::default()) - .await - .expect("open_bi"); - send.write(SUBSCRIBE_TRACKS).await.expect("write"); - - moq_clock::timeout(TIMEOUT, setup.pair.client.closed()) - .await - .expect("the session stayed open"); -} diff --git a/rs/moq-net/tests/integration/subscriber_max_age.rs b/rs/moq-net/tests/integration/subscriber_max_age.rs index 1b53354830f..3c6d77acaa8 100644 --- a/rs/moq-net/tests/integration/subscriber_max_age.rs +++ b/rs/moq-net/tests/integration/subscriber_max_age.rs @@ -32,7 +32,7 @@ async fn budget(track: &mut track::Producer, millis: u64, version: Version) { #[moq_clock::test] async fn relay_forwards_the_most_tolerant_subscriber_max_age() { - for draft in 14..=22 { + for draft in 18..=22 { let version: Version = format!("moq-transport-{draft}").parse().unwrap(); let publisher = origin(1); let relay = origin(2); diff --git a/rs/moq-net/tests/integration/track_tail.rs b/rs/moq-net/tests/integration/track_tail.rs index ac30c90045e..5f02b93975a 100644 --- a/rs/moq-net/tests/integration/track_tail.rs +++ b/rs/moq-net/tests/integration/track_tail.rs @@ -259,11 +259,7 @@ async fn lite07_empty_track_ends_without_the_grace() { /// IETF drafts over the control stream adapter (14), on their own streams (17), and with /// subscription fills (20+). -const IETF: &[&str] = &[ - "moq-transport-18", - "moq-transport-20", - "moq-transport-22", -]; +const IETF: &[&str] = &["moq-transport-18", "moq-transport-20", "moq-transport-22"]; /// A subscriber that leaves while END_OF_TRACK waits for stream credit ends the publisher's /// request, instead of parking it until credit that may never come. diff --git a/rs/moq-net/tests/integration/tracks_ietf.rs b/rs/moq-net/tests/integration/tracks_ietf.rs index 618130a195c..9578900dfd8 100644 --- a/rs/moq-net/tests/integration/tracks_ietf.rs +++ b/rs/moq-net/tests/integration/tracks_ietf.rs @@ -184,37 +184,6 @@ async fn a_listing_carries_track_info() { assert_eq!(info.priority, 9); } -/// Before draft-18 there is no SUBSCRIBE_TRACKS, so the listing is refused rather than -/// answered empty, and a reader still subscribes. -#[moq_clock::test] -async fn before_draft_18_the_listing_is_refused() { - let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); - let a = broadcast.create_track("a", None).unwrap(); - broadcast.announce(Default::default()).unwrap(); - - let (subscriber, _pair) = connect(&publisher, "moq-transport-18").await; - let remote = resolve(&subscriber, "bcast").await; - let mut tracks = remote.tracks().unwrap(); - assert_eq!( - next(&mut tracks).await, - format!("error: {}", moq_net::Error::Unsupported) - ); - - let mut sub = moq_clock::timeout(TIMEOUT, remote.track("a").unwrap().subscribe(None)) - .await - .expect("subscribe timeout") - .expect("subscribe"); - moq_clock::timeout(TIMEOUT, support::wanted(a.demand())) - .await - .expect("never subscribed") - .unwrap(); - let mut group = a.append_group().unwrap(); - group.write_frame(None, &b"frame"[..]).unwrap(); - group.finish().unwrap(); - assert_eq!(read(&mut sub).await, Some((0, b"frame".to_vec()))); -} - /// A reader of a listed track resumes its held PUBLISH, so its data arrives with no /// SUBSCRIBE at all; draft-18 would refuse one as a second subscription to the track. /// Once the reader leaves, the PUBLISH pauses and stays listed, and the next reader diff --git a/rs/moq-net/tests/integration/untimed.rs b/rs/moq-net/tests/integration/untimed.rs index ea408df516d..442e81595dc 100644 --- a/rs/moq-net/tests/integration/untimed.rs +++ b/rs/moq-net/tests/integration/untimed.rs @@ -152,23 +152,18 @@ async fn a_relay_forwards_an_untimed_track_untimed() { assert_eq!(info.timescale, None, "{hops:?}: the relay must not claim a timeline"); } - for hops in [ - &["moq-lite-03", "moq-transport-18"][..], - &[ "moq-transport-20"][..], - ] { - let (frame, info) = frame_through(hops, timed()).await; - assert_eq!(frame, None, "{hops:?}: the first hop has no timestamps to forward"); - assert_eq!(info.timescale, None, "{hops:?}: the relay must not claim a timeline"); - } + let hops = ["moq-lite-03", "moq-transport-18"]; + let (frame, info) = frame_through(&hops, timed()).await; + assert_eq!(frame, None, "{hops:?}: the first hop has no timestamps to forward"); + assert_eq!(info.timescale, None, "{hops:?}: the relay must not claim a timeline"); } /// An explicit start on an untimed track is honored the same way on lite and /// moq-transport: only an unfloored subscriber jumps to the latest group. /// /// The subscription asks for history the way a resume does, with a budget covering it. -/// moq-transport before draft -/// 20 can only join a past group through a joining FETCH, which our publisher refuses for -/// groups before the live one, so draft 20 stands in for it. +/// moq-transport before draft 20 can only join a past group through a joining FETCH, +/// which our publisher refuses for groups before the live one, so draft 20 stands in for it. #[moq_clock::test] async fn an_explicit_start_holds_on_an_untimed_track() { for version in ["moq-lite-03", "moq-lite-06", "moq-lite-07-wip", "moq-transport-20"] { diff --git a/rs/moq-quic/src/connection/mux/params.rs b/rs/moq-quic/src/connection/mux/params.rs index 5adef1eecd1..fba68ff809d 100644 --- a/rs/moq-quic/src/connection/mux/params.rs +++ b/rs/moq-quic/src/connection/mux/params.rs @@ -203,7 +203,7 @@ mod tests { let params = Params { tp, max_record_size: VarInt::from_u32(32_768), - protocols: Some(vec!["moq-lite-03".into(), "moqt-16".into()]), + protocols: Some(vec!["moq-lite-03".into(), "moqt-18".into()]), }; let mut buf = Vec::new(); params.encode(&mut buf); diff --git a/rs/moq-relay/src/cluster.rs b/rs/moq-relay/src/cluster.rs index 58e3f6d69e3..ac6a924ffd0 100644 --- a/rs/moq-relay/src/cluster.rs +++ b/rs/moq-relay/src/cluster.rs @@ -989,9 +989,9 @@ struct LanAuth { #[derive(Default)] #[non_exhaustive] pub struct Options { - /// Request caps for ordinary client sessions. + /// Session limits for ordinary client sessions. pub session: crate::limits::Client, - /// Request caps and QUIC limits for authenticated peers and outbound cluster links. + /// Session and QUIC limits for authenticated peers and outbound cluster links. pub peer: crate::limits::Peer, /// Cluster identity, peers, and discovery. pub config: Config, @@ -2320,14 +2320,12 @@ mod tests { use crate::Config as RelayConfig; #[tokio::test] - async fn request_limits_follow_the_admitted_grant() { + async fn session_limits_follow_the_admitted_grant() { let mut options = Options::default(); options.session.announces = 2; - options.session.requests = 3; options.peer.announces = 20; - options.peer.requests = 30; let cluster = Cluster::new(options).unwrap(); - for (peer, upstream, expected) in [(false, false, (2, 3)), (true, false, (20, 30)), (true, true, (20, 30))] { + for (peer, upstream, expected) in [(false, false, 2), (true, false, 20), (true, true, 20)] { let mut grant = moq_auth::Grant::new(moq_auth::Patterns::new(), moq_auth::Patterns::new()); grant.peer = peer; grant.upstream = upstream; @@ -2335,7 +2333,7 @@ mod tests { // A cluster-looking path alone never selects the peer policy. let lease = auth::Lease::new("/.cluster/untrusted", consumer); let limits = cluster.limits(&lease); - assert_eq!((limits.announces, limits.requests), expected); + assert_eq!(limits.announces, expected); } } diff --git a/rs/moq-relay/src/config.rs b/rs/moq-relay/src/config.rs index e39bec088fb..ec7854f8634 100644 --- a/rs/moq-relay/src/config.rs +++ b/rs/moq-relay/src/config.rs @@ -530,39 +530,39 @@ mod tests { #[test] fn session_limits_merge_without_crossing_peer_policy() { - if !test_env::Env::without(&[ - "MOQ_LIMITS_CLIENT_ANNOUNCES", - "MOQ_LIMITS_CLIENT_REQUESTS", - "MOQ_LIMITS_PEER_ANNOUNCES", - "MOQ_LIMITS_PEER_REQUESTS", - ]) - .isolate() - { + if !test_env::Env::without(&["MOQ_LIMITS_CLIENT_ANNOUNCES", "MOQ_LIMITS_PEER_ANNOUNCES"]).isolate() { return; } let dir = tempfile::tempdir().unwrap(); let path = dir.path().join("limits.toml"); - std::fs::write( - &path, - "[limits.client]\nannounces = 7\nrequests = 8\n[limits.peer]\nannounces = 90\nrequests = 91\n", - ) - .unwrap(); + std::fs::write(&path, "[limits.client]\nannounces = 7\n[limits.peer]\nannounces = 90\n").unwrap(); let config = Config::parse_and_merge([std::ffi::OsString::from("moq-relay"), path.clone().into()]).unwrap(); assert_eq!(config.limits.client.resolve().announces, 7); - assert_eq!(config.limits.client.resolve().requests, 8); assert_eq!(config.limits.peer.resolve().announces, 90); - assert_eq!(config.limits.peer.resolve().requests, 91); let config = Config::parse_and_merge([ std::ffi::OsString::from("moq-relay"), path.into(), "--limits-client-announces=0".into(), - "--limits-peer-requests=1000".into(), ]) .unwrap(); assert_eq!(config.limits.client.resolve().announces, 0); - assert_eq!(config.limits.client.resolve().requests, 8); assert_eq!(config.limits.peer.resolve().announces, 90); - assert_eq!(config.limits.peer.resolve().requests, 1000); + } + + /// Sizing the removed request window refuses to start rather than run without the + /// setting. + #[test] + fn removed_request_limits_are_refused() { + if !test_env::Env::without(&["MOQ_LIMITS_CLIENT_REQUESTS", "MOQ_LIMITS_PEER_REQUESTS"]).isolate() { + return; + } + let error = Config::parse_and_merge(["moq-relay", "--limits-peer-requests=1000"]).unwrap_err(); + assert!(error.to_string().contains("--limits-peer-requests"), "{error}"); + + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("limits.toml"); + std::fs::write(&path, "[limits.client]\nrequests = 8\n").unwrap(); + assert!(Config::parse_and_merge([std::ffi::OsString::from("moq-relay"), path.into()]).is_err()); } /// `[limits.peer.quic]` mirrors `[quic]`'s keys without touching `[quic]` itself. diff --git a/rs/moq-relay/src/limits.rs b/rs/moq-relay/src/limits.rs index 15634ecc581..b95c8fa9570 100644 --- a/rs/moq-relay/src/limits.rs +++ b/rs/moq-relay/src/limits.rs @@ -32,28 +32,17 @@ pub struct Client { setting = "limits.client.announces" )] pub announces: usize, - /// Maximum other simultaneously held moq-transport requests, sizing the drafts 14 to 16 request window. - #[usage( - long = "limits-client-requests", - env = "MOQ_LIMITS_CLIENT_REQUESTS", - default = "10000", - setting = "limits.client.requests" - )] - pub requests: usize, } impl Default for Client { fn default() -> Self { - Self { - announces: 1000, - requests: 10000, - } + Self { announces: 1000 } } } impl Client { pub(crate) fn resolve(&self) -> moq_net::session::Limits { - resolve(self.announces, self.requests) + resolve(self.announces) } } @@ -70,14 +59,6 @@ pub struct Peer { setting = "limits.peer.announces" )] pub announces: usize, - /// Maximum other simultaneously held moq-transport requests, sizing the drafts 14 to 16 request window. - #[usage( - long = "limits-peer-requests", - env = "MOQ_LIMITS_PEER_REQUESTS", - default = "20000", - setting = "limits.peer.requests" - )] - pub requests: usize, /// QUIC limits a peer session widens to (`[limits.peer.quic]`). #[usage(flatten)] pub quic: Quic, @@ -87,7 +68,6 @@ impl Default for Peer { fn default() -> Self { Self { announces: 100000, - requests: 20000, quic: Quic::default(), } } @@ -95,7 +75,7 @@ impl Default for Peer { impl Peer { pub(crate) fn resolve(&self) -> moq_net::session::Limits { - resolve(self.announces, self.requests) + resolve(self.announces) } } @@ -170,10 +150,9 @@ impl Quic { } } -fn resolve(announces: usize, requests: usize) -> moq_net::session::Limits { +fn resolve(announces: usize) -> moq_net::session::Limits { let mut limits = moq_net::session::Limits::default(); limits.announces = announces; - limits.requests = requests; limits } @@ -189,6 +168,10 @@ pub(crate) struct Legacy { peer_quic_receive_window: Option, #[usage(long = "peer-quic-send-window", env = "MOQ_PEER_QUIC_SEND_WINDOW", hide = true)] peer_quic_send_window: Option, + #[usage(long = "limits-client-requests", env = "MOQ_LIMITS_CLIENT_REQUESTS", hide = true)] + client_requests: Option, + #[usage(long = "limits-peer-requests", env = "MOQ_LIMITS_PEER_REQUESTS", hide = true)] + peer_requests: Option, } impl Legacy { @@ -229,6 +212,14 @@ impl Legacy { "--limits-peer-quic-send-window", ); } + const REQUESTS: &str = + "the request window left with moq-transport drafts 14 to 16; stream flow control bounds requests"; + if self.client_requests.is_some() { + found.removed("--limits-client-requests", Some("MOQ_LIMITS_CLIENT_REQUESTS"), REQUESTS); + } + if self.peer_requests.is_some() { + found.removed("--limits-peer-requests", Some("MOQ_LIMITS_PEER_REQUESTS"), REQUESTS); + } found } } diff --git a/rs/moq-relay/src/settings.rs b/rs/moq-relay/src/settings.rs index 52622b36b72..35fed361a8e 100644 --- a/rs/moq-relay/src/settings.rs +++ b/rs/moq-relay/src/settings.rs @@ -268,8 +268,6 @@ struct Limits { struct Client { #[usage(env = "MOQ_LIMITS_CLIENT_ANNOUNCES", cli("--limits-client-announces"))] announces: Option, - #[usage(env = "MOQ_LIMITS_CLIENT_REQUESTS", cli("--limits-client-requests"))] - requests: Option, } #[derive(usage_rs::Config)] @@ -277,8 +275,6 @@ struct Client { struct Peer { #[usage(env = "MOQ_LIMITS_PEER_ANNOUNCES", cli("--limits-peer-announces"))] announces: Option, - #[usage(env = "MOQ_LIMITS_PEER_REQUESTS", cli("--limits-peer-requests"))] - requests: Option, #[usage(flatten)] quic: PeerQuic, } diff --git a/rs/moq-relay/src/websocket.rs b/rs/moq-relay/src/websocket.rs index d5d953a91c5..d3de9298dec 100644 --- a/rs/moq-relay/src/websocket.rs +++ b/rs/moq-relay/src/websocket.rs @@ -439,21 +439,21 @@ mod tests { #[test] fn supported_subprotocols_only_lists_configured_alpns() { - let list = supported_subprotocols(&["moqt-16"]); + let list = supported_subprotocols(&["moqt-20"]); - assert!(list.contains(&"qmux-01.moqt-16".to_string())); - assert!(list.contains(&"qmux-00.moqt-16".to_string())); + assert!(list.contains(&"qmux-01.moqt-20".to_string())); + assert!(!list.contains(&"qmux-00.moqt-20".to_string())); assert!(list.iter().all(|entry| !entry.contains("moq-lite"))); assert!(list.iter().all(|entry| !entry.contains("moqt-19"))); } #[test] fn supported_subprotocols_preserves_moq_preference_across_qmux_versions() { - let list = supported_subprotocols(&["moqt-16", "moqt-18"]); + let list = supported_subprotocols(&["moq-lite-06", "moqt-18"]); let preferred = list .iter() - .position(|entry| entry == "qmux-00.moqt-16") - .expect("missing preferred moqt-16 pair"); + .position(|entry| entry == "qmux-00.moq-lite-06") + .expect("missing preferred moq-lite-06 pair"); let newer_qmux = list .iter() .position(|entry| entry == "qmux-01.moqt-18") diff --git a/rs/moq-relay/tests/integration/auth_lifetime.rs b/rs/moq-relay/tests/integration/auth_lifetime.rs index 44e67f7958a..968ba80c905 100644 --- a/rs/moq-relay/tests/integration/auth_lifetime.rs +++ b/rs/moq-relay/tests/integration/auth_lifetime.rs @@ -442,34 +442,38 @@ async fn forwards_the_setup_token() { spawn_relay(auth).await }; - // Draft-16 CLIENT_SETUP: AUTHORIZATION TOKEN (3), USE_VALUE (3), Token Type 0. + // Draft-18 SETUP (0x2F00): AUTHORIZATION TOKEN (3), USE_VALUE (3), Token Type 0. let encoded = [&[0x03, 0x00][..], &value].concat(); let params = [&[0x01, 0x03, encoded.len() as u8][..], &encoded].concat(); - let setup = [&[0x20][..], &(params.len() as u16).to_be_bytes(), ¶ms].concat(); + let setup = [&[0x6f, 0x00][..], &(params.len() as u16).to_be_bytes(), ¶ms].concat(); let mut session = if websocket { qmux::ws::Client::new() - .with_protocol("moqt-16", &[qmux::Version::QMux01]) + .with_protocol("moqt-18", &[qmux::Version::QMux01]) .connect(&format!("ws://127.0.0.1:{port}/room?source=setup")) .await .expect("connect WebSocket") } else { qmux::tcp::connect(("127.0.0.1", port), { let mut config = qmux::Config::new(qmux::Version::QMux01); - config.protocol = qmux::Protocol::Negotiate(vec!["moqt-16".into()]); + config.protocol = qmux::Protocol::Negotiate(vec!["moqt-18".into()]); config }) .await .expect("connect TCP") }; - let (mut send, mut recv) = session - .open_bi(Default::default()) + let mut send = session + .open_uni(Default::default()) .await - .expect("open the control stream"); + .expect("open the setup stream"); write_all(&mut send, &setup).await; + let mut recv = tokio::time::timeout(TIMEOUT, session.accept_uni()) + .await + .expect("SETUP timeout") + .expect("the server's setup stream"); let reply = tokio::time::timeout(TIMEOUT, recv.read_chunk(1)) .await - .expect("SERVER_SETUP timeout") - .expect("SERVER_SETUP"); + .expect("SETUP timeout") + .expect("SETUP"); assert_eq!(reply.map(|chunk| chunk.len()), Some(1)); let seen = script.seen.lock().unwrap().clone(); let connect = seen.iter().find(|r| r.event == Event::Connect).expect("a connect"); @@ -481,7 +485,7 @@ async fn forwards_the_setup_token() { // Plain `ws://` has no SNI; the `Host` header never stands in for one. assert_eq!(connect.server_name, None); assert!(connect.remote.is_some_and(|addr| addr.ip().is_loopback())); - assert_eq!(connect.alpn.as_deref(), Some("qmux-01.moqt-16")); + assert_eq!(connect.alpn.as_deref(), Some("qmux-01.moqt-18")); } relay.abort(); } diff --git a/rs/moq-relay/tests/integration/cluster_unknown.rs b/rs/moq-relay/tests/integration/cluster_unknown.rs index 267bc3471a8..8ea2e02fbfb 100644 --- a/rs/moq-relay/tests/integration/cluster_unknown.rs +++ b/rs/moq-relay/tests/integration/cluster_unknown.rs @@ -186,9 +186,9 @@ async fn publish_version(port: u16, version: &str) -> Publisher { } async fn publish_unknown(port: u16) -> Publisher { - // Draft-14 has no Cluster extension, so the accepting relay must represent + // Lite-03 declares no origin identity, so the accepting relay must represent // this external publisher with the wire-defined UNKNOWN Hop ID. - publish_version(port, "moq-transport-14").await + publish_version(port, "moq-lite-03").await } /// Subscribe to [`PATH`] through the relay on `port` and read its first frame. @@ -305,7 +305,7 @@ async fn assert_unknown_publisher_stays_announced(cluster_version: Option tokio::t /// only after its lease recorded the shutdown. #[tokio::test(start_paused = true)] async fn a_session_ignoring_the_goaway_is_closed_at_the_deadline() { - for alpn in ["moq-lite-06", "moq-lite-03", "moq-transport-17"] { + for alpn in ["moq-lite-06", "moq-lite-03", "moq-transport-18"] { let (trigger, observer) = shutdown::Observer::new(WINDOW); let session = admit(&observer, alpn.parse().unwrap(), false).await; let started = tokio::time::Instant::now(); diff --git a/rs/moq-relay/tests/integration/hidden_cluster.rs b/rs/moq-relay/tests/integration/hidden_cluster.rs index f9e4ef7cd24..2a6ecad6a69 100644 --- a/rs/moq-relay/tests/integration/hidden_cluster.rs +++ b/rs/moq-relay/tests/integration/hidden_cluster.rs @@ -41,7 +41,7 @@ async fn listen_tcp(version: moq_net::Version) -> (u16, moq_tokio::Listener) { #[test] fn old_peers_keep_hidden_paths() { - for version in ["moq-lite-05", "moq-lite-06", "moq-transport-17"] { + for version in ["moq-lite-05", "moq-lite-06", "moq-transport-18"] { run_cluster_test(old_peer_keeps_hidden_paths(version.parse().unwrap())); } } diff --git a/rs/moq-relay/tests/integration/runtime_uring.rs b/rs/moq-relay/tests/integration/runtime_uring.rs index f586b950e30..f949ba91619 100644 --- a/rs/moq-relay/tests/integration/runtime_uring.rs +++ b/rs/moq-relay/tests/integration/runtime_uring.rs @@ -248,14 +248,9 @@ async fn uring_workers_serve_every_configured_version() { let publisher = connect(client.with_publisher(&origin), raw.parse().unwrap()).await; assert_eq!(publisher.version(), Some(version), "publisher version"); - // moq-transport-14 and moq-lite-02 negotiate in the SETUP; 16 has its own - // ALPN but still a bidi SETUP; 22 reads its SETUP off a uni stream. - for name in [ - "moq-transport-22", - "moq-transport-16", - "moq-transport-14", - "moq-lite-02", - ] { + // moq-lite-02 negotiates in the SETUP; moq-transport-22 reads its SETUP off a + // uni stream. + for name in ["moq-transport-22", "moq-lite-02"] { for scheme in ["moql", "https"] { let url: url::Url = format!("{scheme}://127.0.0.1:{port}/versions").parse().unwrap(); let (version, client) = pinned(name); @@ -364,7 +359,7 @@ async fn uring_workers_report_link_facts() { /// threads joined and the port free. /// /// What an arrival is told is left of the window only reaches the wire on -/// moq-transport-17+, which this test does not dial; `shutdown_signal.rs` +/// moq-transport, which this test does not dial; `shutdown_signal.rs` /// reads it through the shared runtime, whose supervision this path shares. #[tokio::test] async fn uring_workers_drain_on_the_trigger() { @@ -881,7 +876,7 @@ async fn uring_forwards_the_setup_token() { tls.alpn_protocols = vec![if webtransport { b"h3".to_vec() } else { - b"moqt-16".to_vec() + b"moqt-18".to_vec() }]; let crypto = driver::crypto::rustls::QuicClientConfig::try_from(tls).unwrap(); let conn = client @@ -895,17 +890,21 @@ async fn uring_forwards_the_setup_token() { .unwrap(); let session = if webtransport { let url: url::Url = format!("https://{addr}/room?source=setup").parse().unwrap(); - let request = web::proto::ConnectRequest::new(url).with_protocol("moqt-16".to_string()); + let request = web::proto::ConnectRequest::new(url).with_protocol("moqt-18".to_string()); web::Session::connect(conn, request).await.unwrap() } else { web::Session::raw(conn) }; - // Draft-16 CLIENT_SETUP: AUTHORIZATION TOKEN (3), USE_VALUE (3), Token Type 0. + // Draft-18 SETUP (0x2F00): AUTHORIZATION TOKEN (3), USE_VALUE (3), Token Type 0. let encoded = [&[0x03, 0x00][..], &token.value].concat(); let params = [&[0x01, 0x03, encoded.len() as u8][..], &encoded].concat(); - let setup = [&[0x20][..], &(params.len() as u16).to_be_bytes(), ¶ms].concat(); - let (mut send, mut recv) = session.open_bi(Default::default()).await.unwrap(); + let setup = [&[0x6f, 0x00][..], &(params.len() as u16).to_be_bytes(), ¶ms].concat(); + let mut send = session.open_uni().await.unwrap(); send.write_all(&setup).await.unwrap(); + let mut recv = tokio::time::timeout(TIMEOUT, session.accept_uni()) + .await + .unwrap() + .unwrap(); let mut reply = [0u8; 1]; assert_eq!( tokio::time::timeout(TIMEOUT, recv.read(&mut reply)) @@ -913,7 +912,7 @@ async fn uring_forwards_the_setup_token() { .unwrap() .unwrap(), Some(1), - "SERVER_SETUP" + "SETUP" ); } deciding.await.unwrap(); diff --git a/rs/moq-relay/tests/integration/shutdown_signal.rs b/rs/moq-relay/tests/integration/shutdown_signal.rs index ee214e825cf..e499983df65 100644 --- a/rs/moq-relay/tests/integration/shutdown_signal.rs +++ b/rs/moq-relay/tests/integration/shutdown_signal.rs @@ -158,7 +158,7 @@ async fn sigint_drains_sessions_before_exiting_inner() { .expect("no GOAWAY within 5s of SIGINT") .expect("session closed without a GOAWAY"); // Empty URI: the relay is restarting, not moving. The window itself is the - // sender's own timer here (only moq-transport draft-17+ puts it on the wire), + // sender's own timer here (only moq-transport puts it on the wire), // so it is the elapsed time below that proves it was honored. assert_eq!(goaway.uri(), "", "expected a reconnect-to-me GOAWAY"); @@ -292,9 +292,9 @@ async fn a_session_arriving_mid_drain_gets_what_is_left_inner() { let port = relay.tcp_addr().expect("TCP listener bound").port(); let trigger = relay.shutdown_trigger().clone(); let run = tokio::spawn(relay.run()); - // moq-transport-17 is the first version whose GOAWAY carries its deadline on - // the wire, which is what this test reads. - let client = client(vec!["moq-transport-17".parse().expect("parse version")]); + // moq-transport's GOAWAY carries its deadline on the wire, which is what this + // test reads. + let client = client(vec!["moq-transport-18".parse().expect("parse version")]); let established = connect(&client, port).await; let draining = established.draining().expect("connected"); diff --git a/rs/moq-relay/tests/integration/smoke.rs b/rs/moq-relay/tests/integration/smoke.rs index 4dc925b4f72..24fd78bcd18 100644 --- a/rs/moq-relay/tests/integration/smoke.rs +++ b/rs/moq-relay/tests/integration/smoke.rs @@ -373,7 +373,7 @@ async fn hidden_broadcasts_need_a_lite07_opt_in() { /// `--server-version` applies to the WebSocket fallback as well as QUIC. #[tokio::test] async fn relay_websocket_honors_server_version() { - let allowed: moq_net::Version = "moq-transport-16".parse().expect("parse allowed version"); + let allowed: moq_net::Version = "moq-transport-18".parse().expect("parse allowed version"); let excluded = newest_lite_version(); let (port, web_handle) = spawn_versioned_relay(vec![allowed]).await; let url: url::Url = format!("ws://127.0.0.1:{port}/smoke").parse().expect("parse url"); @@ -792,18 +792,10 @@ async fn internal_unix_round_trip() { /// (Setup Stream) and moq-transport 14-18 (the `Path` SETUP parameter, in-band on /// the bidi stream for 14-16 and the uni Setup Stream for 17-18). fn path_versions() -> Vec { - [ - "moq-lite-05", - "moq-lite-06", - "moq-transport-14", - "moq-transport-15", - "moq-transport-16", - "moq-transport-17", - "moq-transport-18", - ] - .iter() - .map(|alpn| alpn.parse().expect("parse version alpn")) - .collect() + ["moq-lite-05", "moq-lite-06", "moq-transport-18"] + .iter() + .map(|alpn| alpn.parse().expect("parse version alpn")) + .collect() } /// Publisher and subscriber (both pinned to `version`) that announce/observe diff --git a/rs/moq-tokio/src/connect.rs b/rs/moq-tokio/src/connect.rs index 4cf1c56ed4e..ed621eed3e3 100644 --- a/rs/moq-tokio/src/connect.rs +++ b/rs/moq-tokio/src/connect.rs @@ -206,10 +206,6 @@ pub(crate) struct Legacy { "moq-lite-05", "moq-lite-06", "moq-lite-07-wip", - "moq-transport-14", - "moq-transport-15", - "moq-transport-16", - "moq-transport-17", "moq-transport-18", "moq-transport-19", "moq-transport-20", @@ -598,10 +594,6 @@ pub struct Config { "moq-lite-05", "moq-lite-06", "moq-lite-07-wip", - "moq-transport-14", - "moq-transport-15", - "moq-transport-16", - "moq-transport-17", "moq-transport-18", "moq-transport-19", "moq-transport-20", diff --git a/rs/moq-tokio/src/deprecated.rs b/rs/moq-tokio/src/deprecated.rs index 16ed82488d5..4a245c8093b 100644 --- a/rs/moq-tokio/src/deprecated.rs +++ b/rs/moq-tokio/src/deprecated.rs @@ -46,6 +46,12 @@ impl Deprecated { self.entry(&Self::spelling(old, env), new, Some(note)); } + /// Record a released flag that was removed without a replacement, with a note saying + /// what covers it now. + pub fn removed(&mut self, old: &str, env: Option<&str>, note: &str) { + self.entry(&Self::spelling(old, env), "removed", Some(note)); + } + /// Record a released config-file key or table, which has no environment variable. pub fn toml(&mut self, old: &str, new: &str, note: Option<&str>) { self.entry(old, new, note); @@ -70,7 +76,7 @@ impl std::fmt::Display for Deprecated { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { write!( f, - "these settings were renamed and are no longer applied; update them and try again:" + "these settings were renamed or removed and are no longer applied; update them and try again:" )?; for entry in &self.0 { write!(f, "\n {entry}")?; diff --git a/rs/moq-tokio/src/listen.rs b/rs/moq-tokio/src/listen.rs index f1fb920d62d..30305568c20 100644 --- a/rs/moq-tokio/src/listen.rs +++ b/rs/moq-tokio/src/listen.rs @@ -133,10 +133,6 @@ pub struct Config { "moq-lite-05", "moq-lite-06", "moq-lite-07-wip", - "moq-transport-14", - "moq-transport-15", - "moq-transport-16", - "moq-transport-17", "moq-transport-18", "moq-transport-19", "moq-transport-20", @@ -296,10 +292,6 @@ pub(crate) struct Legacy { "moq-lite-05", "moq-lite-06", "moq-lite-07-wip", - "moq-transport-14", - "moq-transport-15", - "moq-transport-16", - "moq-transport-17", "moq-transport-18", "moq-transport-19", "moq-transport-20", diff --git a/rs/moq-tokio/src/quic/backend.rs b/rs/moq-tokio/src/quic/backend.rs index 1dee2b630e3..63636956524 100644 --- a/rs/moq-tokio/src/quic/backend.rs +++ b/rs/moq-tokio/src/quic/backend.rs @@ -469,7 +469,7 @@ impl Client { let session = match url.scheme() { "https" => { let mut request = web::proto::ConnectRequest::new(url.clone()); - for protocol in web_protocols(versions) { + for protocol in versions.alpns() { request = request.with_protocol(protocol.to_string()); } web::Session::connect(connection, request) @@ -542,22 +542,6 @@ impl Error { } } -/// The WebTransport subprotocols to offer for `versions`. -/// -/// Draft-14 predates WebTransport subprotocols: `moq-00` is only its QUIC ALPN, and a peer that -/// accepts it over WebTransport picks draft-14 over a newer draft both support. It rides `moql` -/// and negotiates in SETUP instead, as `js/net` does. -fn web_protocols(versions: &moq_net::Versions) -> Vec<&'static str> { - let mut protocols = Vec::new(); - for alpn in versions.alpns() { - let protocol = if alpn == "moq-00" { "moql" } else { alpn }; - if !protocols.contains(&protocol) { - protocols.push(protocol); - } - } - protocols -} - fn map_client_error(err: web::ClientError) -> Error { match client_status(&err).and_then(crate::ConnectError::from_status_u16) { Some(rejected) => rejected.into(), @@ -1062,16 +1046,6 @@ mod tests { use super::*; use url::Url; - #[test] - fn web_protocols_never_offer_moq_00() { - let all = moq_net::Versions::all(); - assert!(!web_protocols(&all).contains(&"moq-00")); - assert_eq!(web_protocols(&all).len(), all.alpns().len() - 1); - - let draft14: moq_net::Version = "moq-transport-14".parse().unwrap(); - assert_eq!(web_protocols(&draft14.into()), ["moql"]); - } - #[tokio::test] async fn pinned_ipv6_connection() { pinned_connection("[::1]:0", None).await; diff --git a/rs/moq-tokio/src/server.rs b/rs/moq-tokio/src/server.rs index b3eee76602e..7731f4cd363 100644 --- a/rs/moq-tokio/src/server.rs +++ b/rs/moq-tokio/src/server.rs @@ -2398,15 +2398,15 @@ mod tests { ); } - /// Answering SETUP is part of the handshake: a moq-transport peer that sends - /// its SETUP but never grants credit for the reply is refused at the same + /// Answering SETUP is part of the handshake: a peer that sends its SETUP but + /// never grants credit for the reply is refused at the same /// deadline, rather than held open by keep-alives, and the session counts it. #[cfg(feature = "websocket")] #[tokio::test(start_paused = true)] async fn stalled_setup_reply_is_closed_at_the_deadline() { - // Record a real moq-transport-14 CLIENT_SETUP. The client then waits on a - // reply that never comes. - let recorder = Scripted::new("moq-00"); + // Record a real CLIENT_SETUP. The client then waits on a reply that never + // comes. + let recorder = Scripted::new("moql"); let client = tokio::spawn({ let recorder = crate::transport::Session::new(recorder.clone(), moq_net::transport::Binding::Uri); async move { @@ -2420,7 +2420,7 @@ mod tests { let bytes = std::mem::take(&mut *recorder.written.lock().unwrap()); assert!(!bytes.is_empty(), "the client never wrote its SETUP"); - let mut peer = Scripted::new("moq-00"); + let mut peer = Scripted::new("moql"); peer.setup = Some(bytes.into()); let timeout = std::time::Duration::from_secs(10); let setup = Setup { diff --git a/rs/moq-tokio/tests/integration/broadcast.rs b/rs/moq-tokio/tests/integration/broadcast.rs index fd2bccb83ed..ae4600ff1de 100644 --- a/rs/moq-tokio/tests/integration/broadcast.rs +++ b/rs/moq-tokio/tests/integration/broadcast.rs @@ -470,18 +470,6 @@ async fn transport_fetch_roundtrip(version: &str) { .expect("server task failed"); } -#[tracing_test::traced_test] -#[tokio::test] -async fn fetch_moq_transport_14() { - transport_fetch_roundtrip("moq-transport-14").await; -} - -#[tracing_test::traced_test] -#[tokio::test] -async fn fetch_moq_transport_16() { - transport_fetch_roundtrip("moq-transport-16").await; -} - #[tracing_test::traced_test] #[tokio::test] async fn fetch_moq_transport_18() { @@ -1556,30 +1544,6 @@ async fn broadcast_moq_lite_07() { broadcast_test("moqt", Some("moq-lite-07-wip"), Some("moq-lite-07-wip")).await; } -#[tracing_test::traced_test] -#[tokio::test] -async fn broadcast_moq_transport_14() { - broadcast_test("moqt", Some("moq-transport-14"), Some("moq-transport-14")).await; -} - -#[tracing_test::traced_test] -#[tokio::test] -async fn broadcast_moq_transport_15() { - broadcast_test("moqt", Some("moq-transport-15"), Some("moq-transport-15")).await; -} - -#[tracing_test::traced_test] -#[tokio::test] -async fn broadcast_moq_transport_16() { - broadcast_test("moqt", Some("moq-transport-16"), Some("moq-transport-16")).await; -} - -#[tracing_test::traced_test] -#[tokio::test] -async fn broadcast_moq_transport_17() { - broadcast_test("moqt", Some("moq-transport-17"), Some("moq-transport-17")).await; -} - #[tracing_test::traced_test] #[tokio::test] async fn broadcast_moq_transport_18() { @@ -1630,30 +1594,6 @@ async fn broadcast_negotiate_server_all_client_lite_03() { broadcast_test("moqt", Some("moq-lite-03"), None).await; } -#[tracing_test::traced_test] -#[tokio::test] -async fn broadcast_negotiate_server_all_client_transport_14() { - broadcast_test("moqt", Some("moq-transport-14"), None).await; -} - -#[tracing_test::traced_test] -#[tokio::test] -async fn broadcast_negotiate_server_all_client_transport_15() { - broadcast_test("moqt", Some("moq-transport-15"), None).await; -} - -#[tracing_test::traced_test] -#[tokio::test] -async fn broadcast_negotiate_server_all_client_transport_16() { - broadcast_test("moqt", Some("moq-transport-16"), None).await; -} - -#[tracing_test::traced_test] -#[tokio::test] -async fn broadcast_negotiate_server_all_client_transport_17() { - broadcast_test("moqt", Some("moq-transport-17"), None).await; -} - #[tracing_test::traced_test] #[tokio::test] async fn broadcast_negotiate_server_all_client_transport_18() { @@ -1686,30 +1626,6 @@ async fn broadcast_negotiate_client_all_server_lite_03() { broadcast_test("moqt", None, Some("moq-lite-03")).await; } -#[tracing_test::traced_test] -#[tokio::test] -async fn broadcast_negotiate_client_all_server_transport_14() { - broadcast_test("moqt", None, Some("moq-transport-14")).await; -} - -#[tracing_test::traced_test] -#[tokio::test] -async fn broadcast_negotiate_client_all_server_transport_15() { - broadcast_test("moqt", None, Some("moq-transport-15")).await; -} - -#[tracing_test::traced_test] -#[tokio::test] -async fn broadcast_negotiate_client_all_server_transport_16() { - broadcast_test("moqt", None, Some("moq-transport-16")).await; -} - -#[tracing_test::traced_test] -#[tokio::test] -async fn broadcast_negotiate_client_all_server_transport_17() { - broadcast_test("moqt", None, Some("moq-transport-17")).await; -} - #[tracing_test::traced_test] #[tokio::test] async fn broadcast_negotiate_client_all_server_transport_18() { @@ -1804,7 +1720,6 @@ async fn broadcast_max_age() { "moq-lite-05", "moq-lite-06", "moq-lite-07-wip", - "moq-transport-17", "moq-transport-18", "moq-transport-22", ] { @@ -1816,12 +1731,7 @@ async fn broadcast_max_age() { #[tokio::test] async fn broadcast_max_age_legacy_omits_property() { - for version in [ - "moq-lite-01", - "moq-transport-14", - "moq-transport-15", - "moq-transport-16", - ] { + for version in ["moq-lite-01"] { assert_eq!( max_age_test(version, Some(Duration::from_secs(30))).await, None, @@ -1856,30 +1766,6 @@ async fn broadcast_webtransport_moq_lite_03() { broadcast_test("https", Some("moq-lite-03"), Some("moq-lite-03")).await; } -#[tracing_test::traced_test] -#[tokio::test] -async fn broadcast_webtransport_moq_transport_14() { - broadcast_test("https", Some("moq-transport-14"), Some("moq-transport-14")).await; -} - -#[tracing_test::traced_test] -#[tokio::test] -async fn broadcast_webtransport_moq_transport_15() { - broadcast_test("https", Some("moq-transport-15"), Some("moq-transport-15")).await; -} - -#[tracing_test::traced_test] -#[tokio::test] -async fn broadcast_webtransport_moq_transport_16() { - broadcast_test("https", Some("moq-transport-16"), Some("moq-transport-16")).await; -} - -#[tracing_test::traced_test] -#[tokio::test] -async fn broadcast_webtransport_moq_transport_17() { - broadcast_test("https", Some("moq-transport-17"), Some("moq-transport-17")).await; -} - #[tracing_test::traced_test] #[tokio::test] async fn broadcast_webtransport_moq_transport_18() { @@ -1930,30 +1816,6 @@ async fn broadcast_webtransport_negotiate_server_all_client_lite_03() { broadcast_test("https", Some("moq-lite-03"), None).await; } -#[tracing_test::traced_test] -#[tokio::test] -async fn broadcast_webtransport_negotiate_server_all_client_transport_14() { - broadcast_test("https", Some("moq-transport-14"), None).await; -} - -#[tracing_test::traced_test] -#[tokio::test] -async fn broadcast_webtransport_negotiate_server_all_client_transport_15() { - broadcast_test("https", Some("moq-transport-15"), None).await; -} - -#[tracing_test::traced_test] -#[tokio::test] -async fn broadcast_webtransport_negotiate_server_all_client_transport_16() { - broadcast_test("https", Some("moq-transport-16"), None).await; -} - -#[tracing_test::traced_test] -#[tokio::test] -async fn broadcast_webtransport_negotiate_server_all_client_transport_17() { - broadcast_test("https", Some("moq-transport-17"), None).await; -} - #[tracing_test::traced_test] #[tokio::test] async fn broadcast_webtransport_negotiate_server_all_client_transport_18() { @@ -1986,30 +1848,6 @@ async fn broadcast_webtransport_negotiate_client_all_server_lite_03() { broadcast_test("https", None, Some("moq-lite-03")).await; } -#[tracing_test::traced_test] -#[tokio::test] -async fn broadcast_webtransport_negotiate_client_all_server_transport_14() { - broadcast_test("https", None, Some("moq-transport-14")).await; -} - -#[tracing_test::traced_test] -#[tokio::test] -async fn broadcast_webtransport_negotiate_client_all_server_transport_15() { - broadcast_test("https", None, Some("moq-transport-15")).await; -} - -#[tracing_test::traced_test] -#[tokio::test] -async fn broadcast_webtransport_negotiate_client_all_server_transport_16() { - broadcast_test("https", None, Some("moq-transport-16")).await; -} - -#[tracing_test::traced_test] -#[tokio::test] -async fn broadcast_webtransport_negotiate_client_all_server_transport_17() { - broadcast_test("https", None, Some("moq-transport-17")).await; -} - #[tracing_test::traced_test] #[tokio::test] async fn broadcast_webtransport_negotiate_client_all_server_transport_18() { @@ -3350,7 +3188,7 @@ fn expect_connect_err(result: moq_tokio::Result<(moq_tokio::Client, moq_tokio::C /// observes the URI (and the deadline on versions that carry one) and keeps an /// existing subscription flowing before leaving. /// -/// Real-QUIC coverage matters beyond the mock: on draft-17+ the GOAWAY rides +/// Real-QUIC coverage matters beyond the mock: on moq-transport the GOAWAY rides /// the SETUP uni streams, where dropping the reader mid-session would emit a /// STOP_SENDING a strict peer treats as a protocol violation. async fn goaway_test(scheme: &str, version: &str, expect_wire_timeout: bool) { @@ -3466,7 +3304,7 @@ async fn goaway_test(scheme: &str, version: &str, expect_wire_timeout: bool) { assert_eq!( goaway.timeout(), Some(Duration::from_secs(5)), - "draft-17+ carries the deadline" + "moq-transport carries the deadline" ); } else { assert_eq!(goaway.timeout(), None, "no wire timeout on this version"); @@ -3492,16 +3330,6 @@ async fn goaway_moq_lite_05_webtransport() { goaway_test("https", "moq-lite-05", false).await; } -#[tokio::test] -async fn goaway_moq_transport_14_quic() { - goaway_test("moqt", "moq-transport-14", false).await; -} - -#[tokio::test] -async fn goaway_moq_transport_17_quic() { - goaway_test("moqt", "moq-transport-17", true).await; -} - #[tokio::test] async fn goaway_moq_transport_19_quic() { goaway_test("moqt", "moq-transport-19", true).await; diff --git a/rs/moq-tokio/tests/integration/max_age.rs b/rs/moq-tokio/tests/integration/max_age.rs index fe1233b0aac..6addcf7612f 100644 --- a/rs/moq-tokio/tests/integration/max_age.rs +++ b/rs/moq-tokio/tests/integration/max_age.rs @@ -125,7 +125,7 @@ async fn relay(version: moq_net::Version, javascript: Option) -> anyhow::R #[tokio::test] async fn max_age_relay_rust() { - for version in ["moq-lite-07-wip", "moq-transport-17", "moq-transport-22"] { + for version in ["moq-lite-07-wip", "moq-transport-18", "moq-transport-22"] { tokio::time::timeout(TIMEOUT, relay(version.parse().unwrap(), None)) .await .unwrap() @@ -136,7 +136,7 @@ async fn max_age_relay_rust() { #[tokio::test] #[ignore = "requires Bun; run by just test max-age in the interop workflow"] async fn max_age_relay_javascript() { - for version in ["moq-lite-07-wip", "moq-transport-17", "moq-transport-22"] { + for version in ["moq-lite-07-wip", "moq-transport-18", "moq-transport-22"] { for publish in [false, true] { tokio::time::timeout(TIMEOUT, relay(version.parse().unwrap(), Some(publish))) .await diff --git a/rs/moq-tokio/tests/integration/receive_credit.rs b/rs/moq-tokio/tests/integration/receive_credit.rs index 22a413e7fbd..f6c67ff3e33 100644 --- a/rs/moq-tokio/tests/integration/receive_credit.rs +++ b/rs/moq-tokio/tests/integration/receive_credit.rs @@ -301,7 +301,7 @@ async fn lite_partial_frame_gives_way() { #[tokio::test] async fn ietf_partial_frame_gives_way() { - the_less_urgent_partial_frame_gives_way("moq-transport-16", None).await; + the_less_urgent_partial_frame_gives_way("moq-transport-18", None).await; } /// The same recovery when a slow link with a deep queue sits between them. @@ -589,7 +589,7 @@ async fn lite_largest_unit_completes_under_pressure() { #[tokio::test] async fn ietf_largest_unit_completes_under_pressure() { - the_largest_unit_completes_under_pressure("moq-transport-16").await; + the_largest_unit_completes_under_pressure("moq-transport-18").await; } /// A Bun publisher (`test/receive-credit/sender.ts`) dials a WebTransport server whose @@ -691,7 +691,7 @@ async fn javascript_partial_frame_gives_way(version: &str) { #[tokio::test] #[ignore = "requires Bun; run by just test receive-credit in the interop workflow"] async fn javascript_partial_frame_gives_way_tokio() { - for version in ["moq-lite-06", "moq-transport-16"] { + for version in ["moq-lite-06", "moq-transport-18"] { javascript_partial_frame_gives_way(version).await; } } diff --git a/rs/moq-wasm/src/transport.rs b/rs/moq-wasm/src/transport.rs index 21c34845f6d..6549215f5e6 100644 --- a/rs/moq-wasm/src/transport.rs +++ b/rs/moq-wasm/src/transport.rs @@ -25,12 +25,8 @@ pub struct Options { /// Advertise every version `moq-net` supports, so the peer picks one via ALPN. /// Without this the browser negotiates no subprotocol and the session has no /// version to start from. -/// -/// Draft-14 predates WebTransport subprotocols: `moq-00` is only its QUIC ALPN, and a -/// peer that accepts it here picks draft-14 over a newer draft both support. It rides -/// `moql` (also offered) and negotiates in SETUP instead, as `js/net` does. fn builder() -> ClientBuilder { - ClientBuilder::new().with_protocols(moq_net::ALPNS.iter().copied().filter(|alpn| *alpn != "moq-00")) + ClientBuilder::new().with_protocols(moq_net::ALPNS.iter().copied()) } /// Open a browser WebTransport connection to `url`. diff --git a/rs/qmux/src/alpn.rs b/rs/qmux/src/alpn.rs index 87fe2807fa1..a3b1860eec7 100644 --- a/rs/qmux/src/alpn.rs +++ b/rs/qmux/src/alpn.rs @@ -79,11 +79,11 @@ mod tests { let out = build( [ ("moq-lite-04", &[Version::QMux01][..]), - ("moq-transport-17", &[Version::QMux00][..]), + ("moq-transport-18", &[Version::QMux00][..]), ], true, ); - assert_eq!(out, vec!["qmux-01.moq-lite-04", "qmux-00.moq-transport-17"]); + assert_eq!(out, vec!["qmux-01.moq-lite-04", "qmux-00.moq-transport-18"]); } #[test] @@ -126,8 +126,8 @@ mod tests { (Version::QMux01, Some("moq-lite-04".to_string())) ); assert_eq!( - parse(Some("qmux-00.moq-transport-17")).unwrap(), - (Version::QMux00, Some("moq-transport-17".to_string())) + parse(Some("qmux-00.moq-transport-18")).unwrap(), + (Version::QMux00, Some("moq-transport-18".to_string())) ); } diff --git a/test/ietf-conformance/README.md b/test/ietf-conformance/README.md index a252809a15d..f3fc9fbeb45 100644 --- a/test/ietf-conformance/README.md +++ b/test/ietf-conformance/README.md @@ -6,9 +6,9 @@ builds the Moxygen revision and matching Meta dependencies pinned in `conformance_test.sh` through this checkout's relay. This is separate from the published-package smoke matrix. -Sections 1-7 run on both shared drafts, 16 and 18, through one relay. Each cell +Sections 1-7 run on draft 18, the one draft both support, through one relay. Each cell runs 29 upstream SUBSCRIBE cases. A direct-origin control runs the same cases -once per draft, separating suite or pin failures from relay behavior. FETCH is +once, separating suite or pin failures from relay behavior. FETCH is skipped using upstream's `SKIP_FETCH`; section 8 uses PUBLISH and is outside the relay's support. Cases using forwarding modes 1 or 2 send nonzero subgroups and are explicitly excluded. Modes 0 and 3 are retained. @@ -19,7 +19,7 @@ these exclusions and failure sensitivity, and refuse a changed script anchor. The publisher advertises the `moq-test-00` prefix. The client subscribes to 16-field namespaces below it. Mock-clock integration tests in [`ietf_conformance.rs`](../../rs/moq-net/tests/integration/ietf_conformance.rs) -prove this routing path on both drafts, through one relay and through two +prove this routing path on draft 18, through one relay and through two relays joined with native lite-07. The live harness waits for that prefix at the relay before starting cases and rejects upstream publisher reconnects, so a recovered session cannot @@ -57,7 +57,6 @@ Measured over six consecutive runs: | Draft | Direct origin | One relay | | --- | --- | --- | -| 16 | 29 pass | 29 pass | | 18 | 29 pass | 29 pass | A two-relay cell is not run yet. The edge needs metadata from TRACK\_STATUS diff --git a/test/ietf-conformance/run.sh b/test/ietf-conformance/run.sh index df3502a4b81..14de8dde520 100755 --- a/test/ietf-conformance/run.sh +++ b/test/ietf-conformance/run.sh @@ -101,11 +101,11 @@ run_suite() { fi } -# The pinned MoQVersions.h supports drafts 16 and 18; this relay supports both. +# The pinned MoQVersions.h supports drafts 16 and 18; this relay supports only 18. failed=0 # A two-relay cell waits on a test publisher that answers TRACK_STATUS; see the # passthrough quest. -for version in 16 18; do +for version in 18; do label="single-$version" start_relay "$label-origin" "$version" relay_port="$HARNESS_PORT" diff --git a/test/interop/interop.sh b/test/interop/interop.sh index b3d392c568a..166df066ca8 100755 --- a/test/interop/interop.sh +++ b/test/interop/interop.sh @@ -79,7 +79,7 @@ FINISH_ONLY=0 # except the clients the harness reads a grant from, which offer $AUTH_VERSION alone. Any other # entry pins every client in its pass to that version, and `ietf` expands to IETF_VERSIONS. VERSIONS="auto" -IETF_VERSIONS="moq-transport-14,moq-transport-16,moq-transport-18,moq-transport-20,moq-transport-22" +IETF_VERSIONS="moq-transport-18,moq-transport-20,moq-transport-22" # Cargo profile for the relay/cli/moq-c builds. Debug compiles faster, which is # what an interop test wants; the workload (320x240@30) is trivial either way. @@ -459,15 +459,7 @@ plan_pass() { record "not run" case="wire track status" publisher=rust subscriber="$runtime" record "not run" case=goaway publisher=rust subscriber="$runtime" [[ "$runtime" != js-native-bun ]] || record "not run" case=goaway publisher="$runtime" subscriber=rust - case "$VERSION" in - moq-transport-14 | moq-transport-16) - record "not run" case="request credit" publisher="$runtime" subscriber=rust - [[ "$runtime" != js-native-bun ]] || record "not run" case="request credit" publisher="$runtime" subscriber="$runtime" - ;; - *) - record "not run" case="track status" publisher="$runtime" subscriber=rust - ;; - esac + record "not run" case="track status" publisher="$runtime" subscriber=rust fi done [[ "$VERSION" == auto ]] || return 0 @@ -895,7 +887,7 @@ token_url() { # The pattern a cell's token grants its publisher, or its subscribers, on . The `auto` # pass mints patterns no prefix could carry, so AUTH must deliver them as minted. moq-transport's -# AUTH extension (draft-17 on) carries prefixes alone and refuses a narrower grant, closing the +# AUTH extension carries prefixes alone and refuses a narrower grant, closing the # session, so a pinned pass grants the broadcast's subtree. publish_grant() { if [[ "$VERSION" == auto ]]; then printf '%s' "$1"; else printf '%s/**' "$1"; fi @@ -2095,16 +2087,11 @@ run_control_case() { local command=("$TARGET_BASE/$PROFILE/examples/interop-control" "$kind" "$version" "${runtime##*-}") case "$kind" in status) cell=(case="wire track status" publisher=rust subscriber="$runtime" log="$LOGS/$name.log") ;; - credit) cell=(case="request credit" publisher="$runtime" subscriber=rust log="$LOGS/$name.log") ;; goaway) command=("$TARGET_BASE/$PROFILE/examples/interop-goaway" "$version" "${runtime##*-}") ;; reverse-goaway) command=("$TARGET_BASE/$PROFILE/examples/interop-goaway-client" "$version") cell=(case=goaway publisher="$runtime" subscriber=rust log="$LOGS/$name.log") ;; - js-credit) - command=(bun "$CLIENTS/js-native/server.ts" credit "$version") - cell=(case="request credit" publisher="$runtime" subscriber="$runtime" log="$LOGS/$name.log") - ;; esac if is_broken "$runtime"; then record fail "${cell[@]}" detail="client unavailable" @@ -2141,15 +2128,7 @@ run_tails() { run_control_case "$runtime" status run_control_case "$runtime" goaway [[ "$runtime" != js-native-bun ]] || run_control_case "$runtime" reverse-goaway - case "$VERSION" in - moq-transport-14 | moq-transport-16) - run_control_case "$runtime" credit - [[ "$runtime" != js-native-bun ]] || run_control_case "$runtime" js-credit - ;; - *) - run_tail_pair "$runtime" rust "track status" - ;; - esac + run_tail_pair "$runtime" rust "track status" fi fi done diff --git a/test/interop/interop.toml b/test/interop/interop.toml index b3802beb343..928d675b92e 100644 --- a/test/interop/interop.toml +++ b/test/interop/interop.toml @@ -23,10 +23,6 @@ version = [ "moq-transport-20", "moq-transport-19", "moq-transport-18", - "moq-transport-17", - "moq-transport-16", - "moq-transport-15", - "moq-transport-14", ] [web.http] diff --git a/test/smoke/README.md b/test/smoke/README.md index 1e8461460eb..c15293ff549 100644 --- a/test/smoke/README.md +++ b/test/smoke/README.md @@ -13,7 +13,7 @@ This suite installs the published moq packages and checks that they exchange med | Packages | `just smoke`, `just full` | Published clients through a local `moq-relay`. `smoke` is Rust only. `full` is the cross-language matrix. | | Public relays | `just relays` | Rust publisher and subscriber through every relay in the [moq-interop-runner](https://github.com/englishm/moq-interop-runner) registry. CI publishes with Rust and the browser (`js-web`) and subscribes with Rust, `js-web`, and `js-bun`. On those relays `js-web` and `js-bun` run only on WebTransport (`@moq/web-transport` has no raw QUIC mode); a client that does not belong is omitted. WebSocket is its own column for the relays in `WEBSOCKET_KEYS` (`moq-dev-rs`): each of their `http(s)` endpoints also runs as `ws(s)`, and every other relay keeps that fallback off. A relay that refuses anonymous root broadcasts is dialed on the path `publish_path` names (`stitcher-moq` publishes under `/moq-test`). That run is what the [results page](https://moq-dev.github.io/moq/relays/) shows. Only `--required` relays fail the run; the default is moq-dev's `cdn.moq.dev`, including its WebSocket endpoint. | | Upstream Docker runner | `just runner-build`, `just runner UPSTREAM OUTPUT` | Every published registry client against this checkout's relay, and the moq-dev clients against published Docker relays. Uses unpinned upstream HEAD and its HTML report. Local-build-only adapters appear as not run. Any failed pair or setup step fails the run, after the report is written. CI publishes it to [interop-runner/](https://git.moq.dev/interop-runner/). | -| Cloudflare | `just cloudflare` | Relays built from the default branches of [cloudflare/moq-rs](https://github.com/cloudflare/moq-rs) and moq-dev/moq, driven by a Cloudflare client over WebTransport and raw QUIC. | +| Cloudflare | `just cloudflare` | Relays built from the heads of [cloudflare/moq-rs](https://github.com/cloudflare/moq-rs)'s `draft-18-dev` branch and moq-dev/moq's default branch, driven by a Cloudflare client over WebTransport and raw QUIC. | | moxygen | `just moxygen` | Meta's [`moxygen`](https://github.com/facebookexperimental/moxygen) interop client through the latest moq-dev relay. Needs Linux Docker. | | Tokens | `just token`, `just token-full` | `moq auth` and npm [`@moq/auth`](https://www.npmjs.com/package/@moq/auth) mint and verify each other's JWTs, and each verifier rejects a tampered token. | diff --git a/test/smoke/clients/cloudflare/Cargo.toml b/test/smoke/clients/cloudflare/Cargo.toml index 46c995a3219..f275b973a8b 100644 --- a/test/smoke/clients/cloudflare/Cargo.toml +++ b/test/smoke/clients/cloudflare/Cargo.toml @@ -12,8 +12,8 @@ publish = false anyhow = "1" bytes = "1" clap = { version = "4", features = ["derive"] } -moq-native-ietf = { git = "https://github.com/cloudflare/moq-rs" } -moq-transport = { git = "https://github.com/cloudflare/moq-rs" } +moq-native-ietf = { git = "https://github.com/cloudflare/moq-rs", branch = "draft-18-dev" } +moq-transport = { git = "https://github.com/cloudflare/moq-rs", branch = "draft-18-dev" } tokio = { version = "1", features = ["full"] } tracing = "0.1" tracing-subscriber = { version = "0.3", features = ["env-filter"] } diff --git a/test/smoke/cloudflare.sh b/test/smoke/cloudflare.sh index edc6ed39e1b..5860ff96b84 100755 --- a/test/smoke/cloudflare.sh +++ b/test/smoke/cloudflare.sh @@ -1,16 +1,19 @@ #!/usr/bin/env bash -# End-to-end smoke test using the current cloudflare/moq-rs default branch. +# End-to-end smoke test using the head of cloudflare/moq-rs's draft-18 branch. # # This is intentionally separate from smoke.sh's public-package media matrix: # cloudflare/moq-rs uses a different application catalog/track layout. We build # a purpose-built Cloudflare client and both projects' relays from their latest -# Git source. The client validates every byte of sustained subgroup payloads +# Git source. cloudflare/moq-rs's default branch speaks only moq-transport-16, +# which moq-dev/moq dropped, so both Cloudflare builds follow its draft-18 branch. +# The client validates every byte of sustained subgroup payloads # through both relays; Cloudflare's relay also exercises datagrams. set -euo pipefail SMOKE_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) CLOUDFLARE_CLIENT="$SMOKE_DIR/clients/cloudflare" CLOUDFLARE_MOQ_REPO="https://github.com/cloudflare/moq-rs" +CLOUDFLARE_MOQ_BRANCH="draft-18-dev" MOQ_REPO="https://github.com/moq-dev/moq" PORT="${CLOUDFLARE_SMOKE_PORT:-4443}" TIMEOUT="${CLOUDFLARE_SMOKE_TIMEOUT:-20}" @@ -26,13 +29,13 @@ CLIENT="${CLOUDFLARE_CLIENT_BIN:-}" have() { command -v "$1" >/dev/null 2>&1; } -# build_git

: build one package from a repo's default -# branch with its committed Cargo.lock, into /target/release. A plain +# build_git [branch]: build one package from the head of +# a repo's branch (its default branch when omitted) with its committed Cargo.lock, into /target/release. A plain # `cargo build` in a checkout rather than `cargo install --git`: a compile cache # (mbx in CI) reuses unchanged crates across builds, but not across installs. build_git() { - local repo="$1" package="$2" dir="$3" - git clone --quiet --depth 1 "$repo" "$dir" && + local repo="$1" package="$2" dir="$3" branch="${4:-}" + git clone --quiet --depth 1 ${branch:+--branch "$branch"} "$repo" "$dir" && cargo build --quiet --release --locked --manifest-path "$dir/Cargo.toml" -p "$package" \ --target-dir "$dir/target" } @@ -65,11 +68,11 @@ if [[ ${#missing[@]} -gt 0 ]]; then fi if [[ -z "$CLOUDFLARE_RELAY" ]]; then - echo "building moq-relay-ietf from $CLOUDFLARE_MOQ_REPO (latest default branch)..." + echo "building moq-relay-ietf from $CLOUDFLARE_MOQ_REPO (latest $CLOUDFLARE_MOQ_BRANCH)..." # Follow Git HEAD, but honor that checkout's committed Cargo.lock. Without # --locked Cargo currently selects a newer hyper-util that does not compile # with moq-rs's hyper-serve dependency. - if build_git "$CLOUDFLARE_MOQ_REPO" moq-relay-ietf "$TMP/cloudflare-moq" >"$TMP/relay-build.log" 2>&1; then + if build_git "$CLOUDFLARE_MOQ_REPO" moq-relay-ietf "$TMP/cloudflare-moq" "$CLOUDFLARE_MOQ_BRANCH" >"$TMP/relay-build.log" 2>&1; then CLOUDFLARE_RELAY="$TMP/cloudflare-moq/target/release/moq-relay-ietf" else echo "error: failed to build moq-relay-ietf" >&2 diff --git a/test/smoke/freshness.sh b/test/smoke/freshness.sh index 3c5e881d2a0..b1c69450ef2 100755 --- a/test/smoke/freshness.sh +++ b/test/smoke/freshness.sh @@ -89,22 +89,25 @@ else note FAIL "smoke.sh no longer go-gets moq.dev/moq @latest" fail=1 fi -# Both relays and the local integrity client deliberately follow their -# repositories' default branches. A rev/tag/branch would silently turn this -# into a stale snapshot rather than a Git-head smoke test. +# Both relays and the local integrity client deliberately follow a branch head: +# moq-dev/moq's default branch, and cloudflare/moq-rs's draft-18 branch, since its +# default speaks only moq-transport-16. A rev or tag would silently turn this into +# a stale snapshot rather than a Git-head smoke test. # shellcheck disable=SC2016 # the greps match literal variable references builds_head() { # builds_head