diff --git a/drafts/draft-lcurley-moq-lite.md b/drafts/draft-lcurley-moq-lite.md index 66b1073b584..24497ccb9c0 100644 --- a/drafts/draft-lcurley-moq-lite.md +++ b/drafts/draft-lcurley-moq-lite.md @@ -415,9 +415,6 @@ The publisher replies with a single ANNOUNCE_OK message followed by the matching - ANNOUNCE_UPDATE: a claim's cost changed. - ANNOUNCE_RESTART: a claim now serves another Instance, or a higher Epoch of the same one. - ANNOUNCE_FLOOR: a batch of a route's claims is complete. -- WARM_START: the publisher offers the copy of a broadcast the subscriber gets by pulling through it (see [Warm Routes](#warm-routes)). -- WARM_UPDATE: a warm route's Warm Cost, drain, priority, or Hops changed. -- WARM_END: the publisher withdrew a warm route. - SYNCED: the initial set is complete. The subscriber sends nothing on the stream after its ANNOUNCE_REQUEST. @@ -428,10 +425,10 @@ The initial set is relative to this hop: a relay answers with what it holds with The publisher MAY coalesce changes to a claim it has not yet sent, and sends no more claims before SYNCED than the initial set holds. A retraction of a claim or route already sent MAY precede SYNCED. -Each ROUTE_START implicitly assigns the next Route ID on the stream, each ANNOUNCE_START the next Announce ID, and each WARM_START the next Warm ID: three counters starting at 0 that increment by 1 per assignment. -No id appears on the wire where it is assigned; both endpoints derive it from the message order on the (reliable, ordered) stream, and other messages reference it instead of repeating the origin node and the route's prefix, the claim's prefix, or the warm route's path. +Each ROUTE_START implicitly assigns the next Route ID on the stream and each ANNOUNCE_START the next Announce ID: two counters starting at 0 that increment by 1 per assignment. +No id appears on the wire where it is assigned; both endpoints derive it from the message order on the (reliable, ordered) stream, and other messages reference it instead of repeating the origin node and the route's prefix, or the claim's prefix. Ids are never reused within a stream. -A ROUTE_END retires its Route ID, the Announce ID of every claim under the route, and the Warm ID of every warm route under it; an ANNOUNCE_END retires one Announce ID, and a WARM_END one Warm ID. +A ROUTE_END retires its Route ID and the Announce ID of every claim under the route; an ANNOUNCE_END retires one Announce ID. A stream has at most one live route per origin node and prefix, and each route at most one live claim per prefix, at or below the route's prefix. Another origin claiming the same prefix is another claim, under its own route. @@ -475,13 +472,12 @@ The subscriber MUST close the session with a PROTOCOL_VIOLATION if a non-zero `P A resolved path that breaks its own rules, or a base whose path the subscriber refused, refuses the claim (see [Refused Content](#refused-content)). #### Refused Content {#refused-content} -Route messages carry content the publisher may only have forwarded: a route's Node ID, Route Suffix, and [Route Offer](#route-offer), a claim's path, Instance, and Lite-06 Chain, and a warm route's path, Instance, Flags, and Hops. +Route messages carry content the publisher may only have forwarded: a route's Node ID, Route Suffix, and [Route Offer](#route-offer), and a claim's path, Instance, and Lite-06 Chain. A newer version or release may send such content that an older receiver cannot use, so a receiver that refuses it withdraws only the route or claim it describes and keeps the session, as BGP treats a malformed attribute as a withdrawal ({{?RFC7606}}). This specification marks each such value "refused"; the receiver skips the rest of the message's body, and SHOULD log and count each refusal so a refused route is never silently missing. - A refused ROUTE_START still assigns its Route ID, and a refused ROUTE_UPDATE, or a refused Route Offer among a [DEAD](#dead)'s moved routes, keeps it; each leaves the receiver no route, so its claims go offline as on ROUTE_END. The messages naming the Route ID stay valid, and a later ROUTE_UPDATE the receiver can use makes the route usable again, with the claims its last floor certified. A route to Node ID 0, or whose Route Suffix was refused, stays refused. A refused Route Offer's Path still counts, so a later DEAD naming a hop on it applies to the route as to any other. - A refused ANNOUNCE_START still assigns its Announce ID, and a refused ANNOUNCE_UPDATE or ANNOUNCE_RESTART keeps it; the claim goes offline at its route's next floor, which is not an ANNOUNCE_END. A claim whose path was refused stays refused; any other comes back with a later ANNOUNCE_RESTART the receiver can use. Its origin withdrew nothing, so while a route has a live claim the receiver refused, the receiver takes the route's floors as certifying nothing, and a relay forwards no withdrawal for the claim. -- A refused WARM_START still assigns its Warm ID. Only the publisher's own framing and stream state close the session: a message that does not decode within its Message Length, and a message naming an id that was never assigned or already retired, or breaking the stream's order, as above. A relay never forwards content a peer would refuse for the relay's own part in it: a route that arrives with 32 hops is unusable, so the relay's own hop never takes one past 32. @@ -540,7 +536,7 @@ An origin never advertises a Revision of 2^64-1: a change that would reach it in A SUBSCRIBE, FETCH, TRACK, TRACKS, or DATAGRAMS request names the origin node that serves it, and the Route Depth of the route it follows: how many leading segments of its Broadcast Path make up the route's prefix. A subscriber that names 0 lets the publisher select one (see [Resolution](#resolution)), and a relay forwarding a request names the origin node and Route Depth of the route it selected or was given. -A relay forwards a request naming an origin node only along the route it sent the requester to that node at that prefix, or a SUBSCRIBE through the neighbor [Warm Routes](#warm-routes) chooses for its broadcast, and resets it with UNROUTABLE when that route is no longer usable or its Path names the requester, so the request never reaches another origin, and loops only briefly after an origin on three or more relays leaves them all at once (see [Dead Hops](#dead-hops)). +A relay forwards a request naming an origin node only along the route it sent the requester to that node at that prefix, and resets it with UNROUTABLE when that route is no longer usable or its Path names the requester, so the request never reaches another origin, and loops only briefly after an origin on three or more relays leaves them all at once (see [Dead Hops](#dead-hops)). Claims with the same Instance serve the same Broadcast, so a relay MAY move a live subscription between them, including onto a higher Epoch, continuing from the first frame the subscriber lacks, and a route change (a reconnect, a cheaper path, a draining session) is invisible to the subscriber. A relay MUST NOT move a subscription to a claim with a different Instance: it stays on its Instance's claims and ends with the last of them. @@ -614,36 +610,6 @@ An advertiser that will not serve a resolved request resets the request stream w Every refusal is terminal and propagates without re-resolution, so probing unserved paths costs one round trip per path. An advertiser signals capacity through its claim alone, withdrawing or re-pricing it before it runs out. -#### Warm Routes {#warm-routes} -A relay MAY pull each broadcast through a neighbor of its choosing rather than along its selected route to the origin node, so a broadcast crosses fewer relays and neighboring relays share one copy. -A warm route offers a neighbor a copy of one broadcast: the Hops it crossed, its `Warm Cost`, whether it drains, and its priority. -An endpoint that does not choose per broadcast ignores every WARM_START, WARM_UPDATE, and WARM_END, sends none, pulls each broadcast along its selected route, and says so in each SUBSCRIBE. - -A relay's **source** for a broadcast is where it pulls it from: its next hop on its selected route to the origin node, or a neighbor whose warm route it joins. -A source ranks as a route does (see [Routing](#routing)): one crossing no draining session first, then the one whose lowest link priority is highest, then the cheapest. -The next hop ranks as the relay's selected route; a warm route ranks by its own drain, priority, and `Warm Cost`, combined with the link it arrives on as a route's are. -Among sources of equal rank a relay prefers a warm route, then the one whose carrier has the lower Rendezvous Hash, then any fixed order. - -A relay with a local reader of a broadcast is that copy's **carrier**: it offers every neighbor its copy, with its own Hop ID as the only Hop, a `Warm Cost` of 0, no drain, and a priority of 127, whatever it pulls. -A relay with no local reader offers each neighbor the best of its sources whose Hops name neither relay, when that is a warm route: its Hops with the relay's own Hop ID appended, and its rank as the relay sees it. -What a relay offers so depends only on its readers, its route, and the warm routes offered to it, never on who pulls what, and a warm route ranks no better at each relay it crosses, so the warm routes of a broadcast settle once its readers and the routes do, as any path vector whose rank only worsens along a path does. -A relay offers a warm route only while it has a selected route to the origin node and the Hops fit in 32, on the Announce Stream it answers whose request covers the broadcast's path, under that route. -It sends a WARM_UPDATE when the copy it offers a neighbor changes, and a WARM_END once it offers none, so a broadcast no relay reads costs no message of its own. - -A carrier pulls through its best source, so what it pulls depends only on the warm routes offered to it and its route, never on who pulls from it. -A relay with no local reader that has a neighbor's SUBSCRIBE pulls through its best source whose Hops name no neighbor whose subscription it serves. -A carrier MUST NOT join a warm route whose carrier ranks above its own by the Rendezvous Hash of the broadcast's path and the carrier's Hop ID, as defined in [Resolution](#resolution), so two carriers never join each other. -Each SUBSCRIBE says in `Warm` whether it joins the copy the publisher offered or follows the subscriber's route. -A relay that serves a SUBSCRIBE from a relay following its route MUST pull along its own route, so a pull that follows routes reaches the origin node. -A relay with no local reader gets the copy it pulls to each neighbor whose subscription it serves, so it MUST pull along its own route unless, for each of them it offered a warm route, what it pulls is that warm route or a copy whose carrier ranks below that warm route's carrier; a neighbor it offered none, such as one whose SUBSCRIBE crossed a WARM_END, bounds nothing. -A relay MUST NOT join a copy of another Instance. - -Once the warm routes and subscriptions in flight are delivered, the pulls of a broadcast are free of loops. -A relay following its route forwards along the routes' tree to the origin node. -A relay that joins a warm route gets a copy whose carrier, then whose warm route, ranks strictly better than what it gives each relay joined to it: a carrier gives its own copy and joins only a lower-ranked carrier's, and a relay with no local reader joins either the warm route it offered, which ranks strictly better one hop closer to its carrier, or a lower-ranked carrier's copy. -So no chain of joins returns to a relay already on it, and a join that reaches a relay following its route continues along the routes' tree. -Two relays acting on each other's stale offers can still join each other until the WARM_END or WARM_UPDATE crossing their link arrives, and the pull then moves on. - ### Subscribe A subscriber opens Subscribe Streams to request a Track. @@ -1240,7 +1206,7 @@ An Announce Stream ending before SYNCED is a PROTOCOL_VIOLATION; a Tracks Stream ## ROUTE_START {#route-start} A publisher sends a ROUTE_START message when it reaches an origin node for a prefix (see [Routing](#routing)). -Each ROUTE_START implicitly assigns the next Route ID on the stream, later referenced by ROUTE_UPDATE, ROUTE_HOLD, ROUTE_END, DEAD, ANNOUNCE_FLOOR, ANNOUNCE_START, and WARM_START (see [Announce](#announce)). +Each ROUTE_START implicitly assigns the next Route ID on the stream, later referenced by ROUTE_UPDATE, ROUTE_HOLD, ROUTE_END, DEAD, ANNOUNCE_FLOOR, and ANNOUNCE_START (see [Announce](#announce)). ~~~ ROUTE_START Message { @@ -1599,108 +1565,6 @@ The ordinal implicitly assigned by a prior ROUTE_START on this stream. The origin's Revision at which the floor certifies the stream's claims for the route, plus one, or 0 when it certifies nothing. -## WARM_START {#warm-start} -A publisher sends a WARM_START message to offer the subscriber its copy of a broadcast (see [Warm Routes](#warm-routes)). -Each WARM_START implicitly assigns the next Warm ID on the stream, later referenced by WARM_UPDATE and WARM_END (see [Announce](#announce)). - -~~~ -WARM_START Message { - Type (i) = 0xC - Message Length (i) - Route ID (i), - Broadcast Path Suffix (s), - Instance (b), - Minted (8), - Warm Cost (i), - Flags (8), - Priority (8), - Hop Count (i), - Hop ID (i) ..., -} -~~~ - -**Type**: -Set to 0xC to indicate a WARM_START message. - -**Route ID**: -The route to the broadcast's origin node: the ordinal implicitly assigned by a prior ROUTE_START on this stream. -A warm route never changes its Route ID. - -**Broadcast Path Suffix**: -Combined with the requested prefix to form the broadcast's path. - -**Instance** and **Minted**: -The Instance of the copy the publisher carries, as defined for [ANNOUNCE_START](#announce-start). - -**Warm Cost**: -What pulling the copy costs the publisher, 0 when it is the copy's carrier (see [Warm Routes](#warm-routes)), in the units of the route's Metric. - -**Flags**: -A bit field: 0x1 when a session on the copy's Hops drains (see [Routing](#routing)). -Any other bit set is refused (see [Refused Content](#refused-content)). - -**Priority**: -The lowest local priority of a link on the copy's Hops as a signed 8-bit integer, 127 at its carrier (see [Routing](#routing)). - -**Hop Count**: -The number of Hop IDs that follow. -0, which names no carrier, or more than 32 is refused. - -**Hop ID**: -The copy's Hops (see [Warm Routes](#warm-routes)), in order, its carrier first and the publisher's own last. - -A stream has at most one live warm route per route and Broadcast: a relay still pulling an Instance for readers pinned to it offers that copy beside the one of the Instance that replaced it. -A subscriber that uses warm routes MUST close the session with a PROTOCOL_VIOLATION on a WARM_START naming a Route ID that was never assigned or already retired, or a path and Instance its route already has a live warm route for. - - -## WARM_UPDATE {#warm-update} -A publisher sends a WARM_UPDATE message when the copy a warm route offers changes, referencing its Warm ID. -The id stays live. - -~~~ -WARM_UPDATE Message { - Type (i) = 0xD - Message Length (i) - Warm ID (i), - Warm Cost (i), - Flags (8), - Priority (8), - Hop Count (i), - Hop ID (i) ..., -} -~~~ - -**Type**: -Set to 0xD to indicate a WARM_UPDATE message. - -**Warm ID**: -The ordinal implicitly assigned by a prior WARM_START on this stream. - -**Warm Cost**, **Flags**, **Priority**, **Hop Count**, and **Hop ID**: -As defined for [WARM_START](#warm-start), replacing the warm route's. - - -## WARM_END {#warm-end} -A publisher sends a WARM_END message when it withdraws a warm route, referencing its Warm ID. -The id is retired and MUST NOT be referenced again. -A ROUTE_END retires the warm routes under its route without a WARM_END. - -~~~ -WARM_END Message { - Type (i) = 0xE - Message Length (i) - Warm ID (i) -} -~~~ - -**Type**: -Set to 0xE to indicate a WARM_END message. - -**Warm ID**: -As defined for [WARM_UPDATE](#warm-update). -A subscriber that uses warm routes MUST close the session with a PROTOCOL_VIOLATION on a WARM_UPDATE or WARM_END naming a Warm ID that was never assigned or already retired. - - ## SUBSCRIBE SUBSCRIBE is sent by a subscriber to start a subscription. @@ -1721,7 +1585,6 @@ SUBSCRIBE Message { Range Count (i) Range (..) ... Update (i) - Warm (8) } Range { @@ -1794,10 +1657,6 @@ A Range resolves once: an update that leaves it live does not resolve it again. The number of the subscription's terms this message sets: 0 on SUBSCRIBE, and on each SUBSCRIBE_UPDATE a larger value than the one before it. A [SUBSCRIBE_DROP](#subscribe-drop) echoes the number in effect when its groups were given up, so the subscriber can tell a stale verdict on its current terms from one an update has since replaced. -**Warm**: -1 when the subscriber joins the copy the publisher offered it in a warm route, and 0 when it follows the subscriber's selected route, as an endpoint that does not choose per broadcast always does (see [Warm Routes](#warm-routes)). -Any other value is a PROTOCOL_VIOLATION. - A `Start` is a floor, not a request; `Subscriber Max Age` is the only thing that asks for data. The publisher SHOULD start at the oldest group at or above the floor that [Expiration](#expiration) has not expired, and MUST NOT deliver an older one. A `Subscriber Max Age` of 0 therefore starts at the latest group, since every older group is already stale. @@ -1831,7 +1690,6 @@ SUBSCRIBE_UPDATE Message { Range (..) ... Update (i) Wanted Group (i) - Warm (8) } ~~~ @@ -2548,7 +2406,6 @@ An application-specific payload. - The Cost parameter must be at least 1. - Replaced the shortest-path, Hop ID, Instance Hash, and Chain Hash tie-breaks with the route's drain and priority, the Announce Cost plus the route's metric, and a Rendezvous Hash of the requested path and the origin's Node ID. - Removed the standby-ordering deployment requirements on Route Cost seeds and bounds. -- Added warm routes: WARM_START (0xC), WARM_UPDATE (0xD), and WARM_END (0xE) on the Announce Stream, and `Warm` on SUBSCRIBE and SUBSCRIBE_UPDATE. A relay MAY pull each broadcast through a neighbor that offers a copy of it, carrying the copy's Hops from its carrier, its Warm Cost, its drain, and its priority. A carrier offers its copy whatever it pulls and joins only a lower-ranked carrier's; a relay with no reader offers each neighbor its best source that avoids it, pulls it only while that is what it offered each relay it serves, and follows its route when a neighbor following its own pulls through it. The offers settle as a path vector does, and the pulls are then free of loops. - Added the temporary Lite-06 Chain Setup Parameter (0x9) and a trailing Lite-06 Chain on ANNOUNCE_START, ANNOUNCE_UPDATE, and ANNOUNCE_RESTART: the moq-lite-06 Hop ID list of a claim learned over moq-lite-06, which a node drops when it names that node. ### Tracks {#changelog-07-tracks} diff --git a/js/net/src/lite/subscribe.test.ts b/js/net/src/lite/subscribe.test.ts index 2027cfd67c2..678dc05a089 100644 --- a/js/net/src/lite/subscribe.test.ts +++ b/js/net/src/lite/subscribe.test.ts @@ -203,11 +203,10 @@ test("lite-07 carries the span as its only range, exclusive at the end", async ( test("a lite-07 list decodes as the span covering it", async () => { // Priority, order, max delay, and an unstated min delay as SubscribeUpdate writes them, - // then no Range ID to retire, the ranges it adds, the update number, an absent wanted group, and - // a pull that follows the subscriber's route. + // then no Range ID to retire, the ranges it adds, the update number, and an absent wanted group. const head = (await encodeMessage(Version.DRAFT_07, new SubscribeUpdate({ priority: 0, ranges: [] }))).slice(1, 5); const update = async (ranges: number[]) => { - const body = [...head, 0, ...ranges, 0, 0, 0]; + const body = [...head, 0, ...ranges, 0, 0]; const got = await SubscribeUpdate.decode( new Reader(undefined, new Uint8Array([body.length, ...body]), Version.DRAFT_07), Version.DRAFT_07, diff --git a/js/net/src/lite/subscribe.ts b/js/net/src/lite/subscribe.ts index 6f14cfdb044..7dd534d0680 100644 --- a/js/net/src/lite/subscribe.ts +++ b/js/net/src/lite/subscribe.ts @@ -28,7 +28,6 @@ import { hasRanges, hasRefresh, hasSkip, - hasWarm, resolvesStart, Version, } from "./version.ts"; @@ -43,18 +42,6 @@ async function encodeUpdate(w: Writer, version: Version, update: bigint) { if (hasSkip(version)) await w.u62(update); } -/** Encode `Warm`: the pull follows this endpoint's route (0), since it chooses no source per broadcast. */ -async function encodeWarm(w: Writer, version: Version) { - if (hasWarm(version)) await w.u8(0); -} - -/** Decode `Warm`, whether the pull joins this side's copy, and ignore it: only a relay choosing a source per broadcast acts on it. */ -async function decodeWarm(r: Reader, version: Version) { - if (!hasWarm(version)) return; - const warm = await r.u8(); - if (warm > 1) throw new ProtocolViolation(`unknown warm ${warm}`); -} - /** * Encode the `Group Start` field shared by SUBSCRIBE and SUBSCRIBE_UPDATE. * @@ -708,7 +695,6 @@ export class SubscribeUpdate { } await encodeUpdate(w, version, this.update); if (hasRefresh(version)) await w.u62(this.wantedGroup === undefined ? 0n : this.wantedGroup + 1n); - await encodeWarm(w, version); break; } } @@ -734,7 +720,6 @@ export class SubscribeUpdate { } const update = await decodeUpdate(r, version); const wanted = hasRefresh(version) ? await r.u62() : 0n; - await decodeWarm(r, version); return new SubscribeUpdate({ wantedGroup: wanted === 0n ? undefined : wanted - 1n, priority, @@ -872,7 +857,6 @@ export class Subscribe { break; } await encodeUpdate(w, version, this.update); - await encodeWarm(w, version); } static async #decode(r: Reader, version: Version): Promise { @@ -893,7 +877,6 @@ export class Subscribe { const minDelay = await decodeMinDelay(r, version); const span = await decodeSpan(r, version); const update = await decodeUpdate(r, version); - await decodeWarm(r, version); return new Subscribe({ id, broadcast, diff --git a/js/net/src/lite/version.ts b/js/net/src/lite/version.ts index b635e705bb4..56dc6455bdc 100644 --- a/js/net/src/lite/version.ts +++ b/js/net/src/lite/version.ts @@ -488,23 +488,6 @@ export function hasAnnounceCompression(version: Version): boolean { } } -/** Whether the announce stream carries warm routes (WARM_START, WARM_UPDATE, and WARM_END), and - * SUBSCRIBE and SUBSCRIBE_UPDATE say whether each pull joins the publisher's copy. Added in lite-07. */ -export function hasWarm(version: Version): boolean { - // Explicitly list older versions so future versions keep the lite-07+ behavior. - switch (version) { - case Version.DRAFT_01: - case Version.DRAFT_02: - case Version.DRAFT_03: - case Version.DRAFT_04: - case Version.DRAFT_05: - case Version.DRAFT_06: - return false; - default: - return true; - } -} - /** Whether TRACK_INFO carries the refresh ratio and SUBSCRIBE_UPDATE a wanted group. Added in lite-07. * Older peers see a track that never refreshes. */ export function hasRefresh(version: Version): boolean { diff --git a/quest/m2/lite07-finalize.md b/quest/m2/lite07-finalize.md index 858eac6c026..bb1dbb5193a 100644 --- a/quest/m2/lite07-finalize.md +++ b/quest/m2/lite07-finalize.md @@ -170,7 +170,6 @@ route key lane's early signal above end when - [Routes and announces](/quest/m2/cluster-routes/README.md) - lite-07 carries the route layer: ROUTE per origin node and path-less ANNOUNCE, with the native hop list gone (only the temporary lite-06 compatibility chain remains) - [Lite-07 by start](/quest/m2/time-addressing/lite07.md) - lite-07 carries group starts, previous-start links, GROUP_END, and time bounds instead of sequence numbers - [@moq/net by start](/quest/m2/time-addressing/js.md) - JS speaks the same lite-07 wire -- [Warm routes on the wire](/quest/m2/warm-routes-wire.md) - removes WARM_* and SUBSCRIBE's `Warm` byte from lite-07 - [Subscriber Min Age](/quest/m2/subscriber-min-age.md) - removes SUBSCRIBE's minimum age, which nothing reads ## Related diff --git a/quest/m2/warm-routes-wire.md b/quest/m2/warm-routes-wire.md deleted file mode 100644 index a51eb2d422d..00000000000 --- a/quest/m2/warm-routes-wire.md +++ /dev/null @@ -1,47 +0,0 @@ -# [S] lite-07 freezes without warm routes - -## Goal - -lite-07 freezes without WARM_START, WARM_UPDATE, WARM_END, and SUBSCRIBE's -`Warm` byte: the draft, `rs/moq-net`, and `js/net` drop them, and the merge -gate stops running `sweep_cache_routing`, which runs nightly until a -production implementation brings the warm wire back in a later wip version. - -## Plan - -Found 2026-11-14 by the [feature review](/quest/m3/release/feature-review.md) -on [moq-dev/moq#8732](https://github.com/moq-dev/moq/pull/8732). - -- The rule lives only in test code (`rs/moq-net/src/route/tests/cache.rs`, - `offer_from` and `decide`); production reads the warm messages and ignores - them. The sweep's `steady()` and `fixed_point()` check relays against the - same functions they run, so it is a consistency check, not an independent - oracle, and it checks none of the Goal's efficiency properties: a rule that - never offered a copy would pass it. -- `sweep_cache_routing` was the slowest route test, 36 s in a debug run, on - every moq-net PR, for code that never ships; the long sweep already runs - nightly from `test/route-sweep.sh`. -- No sweep compares copies or relays crossed against plain path routing, - which already shares one copy along each publisher's tree; the only gain - shown is LAN siblings with their own uplinks - (`lan_relays_share_uplink_copies`). Pull cycles form in 3.3% of churn steps - and about 9 in 10 of those leave a reader unfed (#8732), a stall plain - routing cannot have. -- The warm wire changed on 2026-11-12, 11-13, and 11-14, while the - implementation ([select](/quest/m3/cache-routing/select.md), XL) lands - after the cut. Item 7 of the [epic](/quest/m3/cache-routing/README.md) - moved the proof into m2 for a downstream fleet plan, and on 2026-11-14 the - mesh work moved downstream - ([moq-dev/moq#8756](https://github.com/moq-dev/moq/pull/8756)); item 11's - choice of lite-07 had neither as evidence. - -Before select is planned, measure copies and relays -crossed against plain path routing on an edge/core topology; if the only win -is LAN siblings, (d). Whatever is picked, move `sweep_cache_routing` out of -the gate into the nightly sweep until a production rule exists. - -Decided 2026-11-14 (maintainer, pick on [moq-dev/moq#8764](https://github.com/moq-dev/moq/pull/8764)): ✅ (b) strip WARM_START, WARM_UPDATE, WARM_END, and SUBSCRIBE's `Warm` byte from lite-07, and re-add them in the then-current wip version with the implementation, after measuring copies and relays crossed against plain path routing; `sweep_cache_routing` leaves the merge gate for the nightly sweep (rejected: (a) keep the wire as it is; (c) keep the messages and drop the byte; (d) move the epic downstream). - -Public API: none. Wire: lite-07-wip loses or keeps the warm messages and the -`Warm` byte. - diff --git a/quest/m3/cache-routing/README.md b/quest/m3/cache-routing/README.md index 8aa8595761b..840bb8545ae 100644 --- a/quest/m3/cache-routing/README.md +++ b/quest/m3/cache-routing/README.md @@ -49,7 +49,7 @@ The earlier Plan, items 1 to 14 (2026-11-08 to 2026-11-14), is in over plain path routing was never measured ([moq-dev/moq#8732](https://github.com/moq-dev/moq/pull/8732)). The maintainer stripped its wire from lite-07 on 2026-11-14 - ([warm routes on the wire](/quest/m2/warm-routes-wire.md)). + ([moq-dev/moq#8840](https://github.com/moq-dev/moq/pull/8840)). This README's own work, once its child lands: diff --git a/rs/moq-net/src/lite/announce.rs b/rs/moq-net/src/lite/announce.rs index a0010adbc64..071d1d68211 100644 --- a/rs/moq-net/src/lite/announce.rs +++ b/rs/moq-net/src/lite/announce.rs @@ -29,10 +29,8 @@ const ROUTE_UPDATE: u64 = 7; const ROUTE_END: u64 = 8; const ANNOUNCE_FLOOR: u64 = 9; const ROUTE_HOLD: u64 = 11; -// lite-07: warm routes, copies of one broadcast offered toward the subscriber. -const WARM_START: u64 = 12; -const WARM_UPDATE: u64 = 13; -const WARM_END: u64 = 14; +// 12 to 14 were WARM_START, WARM_UPDATE, and WARM_END, which return in a later wip version +// with an implementation that picks a source per broadcast. // lite-07: news of a closed session or a draining node on the routes the sender offered. const DEAD: u64 = 15; @@ -131,19 +129,6 @@ pub enum AnnounceBroadcast { /// with this id, certifying them across the whole requested prefix at the origin's /// revision, or certifying nothing (`None`). Floor { id: u64, revision: Option }, - /// WARM_START (lite-07+): under the route with Route ID `route`, the sender offers the - /// copy of the broadcast at `suffix` that the receiver gets by joining it, and assigns - /// it the next Warm ID. See [`Warm`] for what the copy carries. - WarmStart { - route: u64, - suffix: Path, - instance: Instance, - warm: Warm, - }, - /// WARM_UPDATE (lite-07+): the warm route with this id carries `warm` now. - WarmUpdate { id: u64, warm: Warm }, - /// WARM_END (lite-07+): the sender withdrew the warm route with this id. - WarmEnd { id: u64 }, /// A route message (lite-07+) whose content, which the sender only forwarded, this /// node refuses. The receiver withdraws what it names and keeps the session. Decoded /// only as far as keeps the stream's ids in step; never sent. @@ -169,10 +154,6 @@ pub(crate) enum Refusable { Start { route: u64, suffix: Option }, /// ANNOUNCE_UPDATE or ANNOUNCE_RESTART of the claim with this Announce ID. Change { id: u64 }, - /// WARM_START under the route with Route ID `route`: assigns the next Warm ID. - WarmStart { route: u64 }, - /// WARM_UPDATE of the warm route with this id. - WarmUpdate { id: u64 }, } /// Why a node refuses content a peer forwarded: well framed, but nothing it can use. @@ -184,8 +165,6 @@ pub(crate) enum Refusal { Flags(u8), #[error("{0} hops, past the limit")] Hops(u64), - #[error("a warm route with no hops, so no carrier")] - Carrier, #[error("an invalid path")] Path, #[error("an invalid instance")] @@ -204,76 +183,6 @@ fn refuse(r: &mut Decoder<'_>, reason: Refusal) -> Content { Ok(Err(reason)) } -/// A copy of a broadcast a warm route offers. -#[derive(Clone, Debug, PartialEq, Eq)] -pub(crate) struct Warm { - /// What pulling the copy through the sender costs, in the units of the route's - /// metric: 0 at its carrier, the relay with a local reader that offers it. - pub cost: u64, - /// A node on `hops` sent GOAWAY, which ranks the copy below every source that avoids one. - pub draining: bool, - /// The lowest local priority of a link on `hops`, ranked before cost; the carrier's - /// own copy has no link to lower it, so `i8::MAX`. - pub priority: i8, - /// Every relay the copy crossed, the carrier first and the sender last. - pub hops: Arc<[route::Id]>, -} - -/// WARM_START and WARM_UPDATE flag: a node on the copy's hops drains. -const WARM_DRAINING: u8 = 0x1; - -/// Encode a warm route's cost, drain, priority, and hops. No relay offers a copy with no -/// carrier, or that crossed too many hops. -fn encode_warm(w: &mut Encoder<'_>, warm: &Warm) -> Result<(), EncodeError> { - if warm.hops.is_empty() || warm.hops.len() > route::MAX_HOPS { - return Err(EncodeError::InvalidState); - } - w.varint(warm.cost)?; - w.u8(if warm.draining { WARM_DRAINING } else { 0 }); - w.u8(warm.priority as u8); - w.varint(warm.hops.len() as u64)?; - for hop in warm.hops.iter() { - w.varint(*hop)?; - } - Ok(()) -} - -fn decode_warm(r: &mut Decoder<'_>) -> Content { - let cost = r.varint()?; - let draining = match r.u8()? { - 0 => false, - WARM_DRAINING => true, - flags => return refuse(r, Refusal::Flags(flags)), - }; - let priority = r.u8()? as i8; - let count = r.varint()?; - if count > route::MAX_HOPS as u64 { - return refuse(r, Refusal::Hops(count)); - } - if count == 0 { - return refuse(r, Refusal::Carrier); - } - let hops = (0..count).map(|_| r.varint()).collect::>()?; - Ok(Ok(Warm { - cost, - draining, - priority, - hops, - })) -} - -/// Decode a WARM_START's body after its Route ID. -fn decode_warm_start(r: &mut Decoder<'_>) -> Content<(Path, Instance, Warm)> { - let suffix = match decode_path(r)? { - Ok(suffix) => suffix, - Err(reason) => return refuse(r, reason), - }; - let Some(instance) = super::instance::decode_copy(r)? else { - return refuse(r, Refusal::Instance); - }; - Ok(decode_warm(r)?.map(|warm| (suffix, instance, warm))) -} - /// Route Offer flag: an upstream link is on the path, so the route is down-only. const DOWN_ONLY: u8 = 0x1; /// Route Offer flag: a node on the path sent GOAWAY. @@ -797,18 +706,12 @@ impl Encode for AnnounceBroadcast { Self::RouteEnd { .. } if version.has_routes() => ROUTE_END, Self::Dead(_) if version.has_routes() => DEAD, Self::Floor { .. } if version.has_routes() => ANNOUNCE_FLOOR, - Self::WarmStart { .. } if version.has_warm() => WARM_START, - Self::WarmUpdate { .. } if version.has_warm() => WARM_UPDATE, - Self::WarmEnd { .. } if version.has_warm() => WARM_END, Self::RouteStart { .. } | Self::RouteUpdate { .. } | Self::RouteHold { .. } | Self::RouteEnd { .. } | Self::Dead(_) - | Self::Floor { .. } - | Self::WarmStart { .. } - | Self::WarmUpdate { .. } - | Self::WarmEnd { .. } => return Err(EncodeError::Version), + | Self::Floor { .. } => return Err(EncodeError::Version), // The pre-lite-06 path-form retraction has no place on lite-06. Self::Ended { .. } => return Err(EncodeError::Version), // Decode-only: an unknown type or refused content is never sent. @@ -868,22 +771,6 @@ impl Encode for AnnounceBroadcast { Self::RouteHold { id } | Self::RouteEnd { id } => w.varint(*id)?, Self::Dead(dead) => encode_dead(w, dead)?, Self::Floor { id, revision } => encode_floor(w, *id, *revision)?, - Self::WarmStart { - route, - suffix, - instance, - warm, - } => { - w.varint(*route)?; - suffix.encode(w, version)?; - super::instance::encode_copy(w, instance)?; - encode_warm(w, warm)?; - } - Self::WarmUpdate { id, warm } => { - w.varint(*id)?; - encode_warm(w, warm)?; - } - Self::WarmEnd { id } => w.varint(*id)?, Self::Ended { .. } | Self::Skipped | Self::Refused { .. } => unreachable!("refused above"), } if w.since(&prefix) > MAX_MESSAGE_SIZE { @@ -929,10 +816,7 @@ impl Encode for AnnounceBroadcast { | Self::RouteHold { .. } | Self::RouteEnd { .. } | Self::Dead(_) - | Self::Floor { .. } - | Self::WarmStart { .. } - | Self::WarmUpdate { .. } - | Self::WarmEnd { .. } => { + | Self::Floor { .. } => { return Err(EncodeError::Version); } } @@ -1019,32 +903,6 @@ impl<'a> Decode<'a, Version> for AnnounceBroadcast { ROUTE_HOLD if version.has_routes() => Self::RouteHold { id: body.varint()? }, ROUTE_END if version.has_routes() => Self::RouteEnd { id: body.varint()? }, ANNOUNCE_FLOOR if version.has_routes() => decode_floor(&mut body)?, - WARM_START if version.has_warm() => { - let route = body.varint()?; - decode_warm_start(&mut body)?.map_or_else( - |reason| Self::Refused { - message: Refusable::WarmStart { route }, - reason, - }, - |(suffix, instance, warm)| Self::WarmStart { - route, - suffix, - instance, - warm, - }, - ) - } - WARM_UPDATE if version.has_warm() => { - let id = body.varint()?; - decode_warm(&mut body)?.map_or_else( - |reason| Self::Refused { - message: Refusable::WarmUpdate { id }, - reason, - }, - |warm| Self::WarmUpdate { id, warm }, - ) - } - WARM_END if version.has_warm() => Self::WarmEnd { id: body.varint()? }, // Unknown types are skipped by length so an earlier Lite06 build // negotiating the same ALPN does not kill the announce stream. _ => { @@ -1630,92 +1488,6 @@ mod tests { ); } - /// The draft's warm route layouts, byte for byte: WARM_START is the Route ID, the path - /// suffix, the instance and its minted flag, then the copy's cost, its flags, its - /// priority as a signed byte, and its hops; WARM_UPDATE the Warm ID and the same four; - /// WARM_END the Warm ID. Lite-06 skips the types as unknown. - #[test] - fn lite07_warm_route_layout() { - let encode = |msg: &AnnounceBroadcast, version: Version| { - let mut buf = Vec::new(); - msg.encode(&mut Encoder::new(&mut buf, version.into()), version) - .map(|()| buf) - }; - let warm = Warm { - cost: 4, - draining: true, - priority: -1, - hops: Arc::from([5, 9, 6]), - }; - let start = AnnounceBroadcast::WarmStart { - route: 3, - suffix: Path::from_static("c"), - instance: "a".parse().unwrap(), - warm: warm.clone(), - }; - let update = AnnounceBroadcast::WarmUpdate { id: 7, warm }; - let end = AnnounceBroadcast::WarmEnd { id: 7 }; - let layouts: [(&AnnounceBroadcast, &[u8]); 3] = [ - (&start, &[12, 13, 3, 1, b'c', 1, b'a', 0, 4, 1, 0xff, 3, 5, 9, 6]), - (&update, &[13, 8, 7, 4, 1, 0xff, 3, 5, 9, 6]), - (&end, &[14, 1, 7]), - ]; - for (msg, wire) in layouts { - assert_eq!(encode(msg, Version::Lite07).unwrap(), wire); - assert_eq!(&broadcast_round_trip(msg, Version::Lite07), msg); - assert!(matches!(encode(msg, Version::Lite06), Err(EncodeError::Version))); - let got = - crate::coding::decode_buf(&mut &wire[..], Version::Lite06, |r, v| AnnounceBroadcast::decode(r, v)); - assert_eq!(got.unwrap(), AnnounceBroadcast::Skipped); - } - } - - /// A warm route starts at its carrier, so it has at least one hop and at most 32, and - /// sets no flag but drain. A receiver refuses one that breaks any, without failing - /// the stream. - #[test] - fn lite07_warm_route_hops_and_flags_are_bounded() { - let empty = AnnounceBroadcast::WarmUpdate { - id: 7, - warm: Warm { - cost: 4, - draining: false, - priority: 0, - hops: Arc::from([]), - }, - }; - let mut buf = Vec::new(); - assert!(matches!( - empty.encode(&mut Encoder::new(&mut buf, Version::Lite07.into()), Version::Lite07), - Err(EncodeError::InvalidState) - )); - let decode = |wire: &[u8]| { - crate::coding::decode_buf(&mut &wire[..], Version::Lite07, |r, v| AnnounceBroadcast::decode(r, v)) - }; - let refused = |reason| AnnounceBroadcast::Refused { - message: Refusable::WarmUpdate { id: 7 }, - reason, - }; - assert_eq!( - decode(&[13, 5, 7, 4, 0, 0, 0]).unwrap(), - refused(Refusal::Carrier), - "no hops, so no carrier" - ); - assert_eq!( - decode(&[13, 6, 7, 4, 2, 0, 1, 5]).unwrap(), - refused(Refusal::Flags(2)), - "an unknown flag" - ); - decode(&[13, 6, 7, 4, 0, 0, 1, 5]).unwrap(); - let mut long = vec![13, 38, 7, 4, 0, 0, 33]; - long.extend([1; 33]); - assert_eq!(decode(&long).unwrap(), refused(Refusal::Hops(33))); - long[1] = 37; - long[6] = 32; - long.pop(); - decode(&long).unwrap(); - } - /// Lite-07 carries a lite-06 chain after the cost, only when it is not empty, so an /// explicitly empty one is refused. #[test] diff --git a/rs/moq-net/src/lite/instance.rs b/rs/moq-net/src/lite/instance.rs index bcc0596a4eb..4bc7d9dbe7a 100644 --- a/rs/moq-net/src/lite/instance.rs +++ b/rs/moq-net/src/lite/instance.rs @@ -92,17 +92,6 @@ pub(super) fn decode_forwarded(r: &mut Decoder<'_>) -> Result, instance: &Instance) -> Result<(), EncodeError> { - encode(w, instance) -} - -/// Decode the instance of a copy a warm route names, `None` when it is well framed but -/// not one this node can use; see [`encode_copy`]. -pub(super) fn decode_copy(r: &mut Decoder<'_>) -> Result, DecodeError> { - Ok(decode(r.bytes()?, r.bool()?).ok()) -} - fn encode(w: &mut Encoder<'_>, instance: &Instance) -> Result<(), EncodeError> { w.bytes(instance.as_str().as_bytes())?; w.bool(instance.is_minted()); diff --git a/rs/moq-net/src/lite/subscribe.rs b/rs/moq-net/src/lite/subscribe.rs index 8bc11b06f97..7e17aa6a199 100644 --- a/rs/moq-net/src/lite/subscribe.rs +++ b/rs/moq-net/src/lite/subscribe.rs @@ -158,7 +158,6 @@ impl<'a> Message<'a> for Subscribe<'a> { } }; let update = decode_update(r, version)?; - decode_warm(r, version)?; Ok(Self { id, @@ -195,7 +194,6 @@ impl<'a> Message<'a> for Subscribe<'a> { } } encode_update(w, version, self.update)?; - encode_warm(w, version); Ok(()) } @@ -217,24 +215,6 @@ fn encode_update(w: &mut Encoder<'_>, version: Version, update: u64) -> Result<( } } -/// Encode whether the pull joins the copy the publisher offered (1) or follows the -/// subscriber's route (0). This endpoint chooses no source per broadcast, so it always -/// follows its route. -fn encode_warm(w: &mut Encoder<'_>, version: Version) { - if version.has_warm() { - w.u8(0); - } -} - -/// Decode whether the pull joins the publisher's copy, and ignore it: only a relay -/// choosing a source per broadcast acts on it, which this endpoint does not do. -fn decode_warm(r: &mut Decoder<'_>, version: Version) -> Result<(), DecodeError> { - if version.has_warm() && r.u8()? > 1 { - return Err(DecodeError::InvalidValue); - } - Ok(()) -} - /// Decode the `Subscriber Min Age` after the max age: milliseconds plus one, zero meaning not /// stated. A wire without the field decodes as not stated. fn decode_min_delay(r: &mut Decoder<'_>, version: Version) -> Result, DecodeError> { @@ -786,7 +766,6 @@ impl<'a> Message<'a> for SubscribeUpdate { true => r.varint()?.checked_sub(1), false => None, }; - decode_warm(r, version)?; Ok(Self { wanted_group, @@ -827,7 +806,6 @@ impl<'a> Message<'a> for SubscribeUpdate { if version.has_refresh() { w.varint_opt(self.wanted_group)?; } - encode_warm(w, version); Ok(()) } } @@ -1506,25 +1484,6 @@ mod test { )); } - /// Lite-07 ends SUBSCRIBE with whether the pull joins the publisher's copy: this - /// endpoint follows its route (0), and reads and ignores 0 or 1. Any other value is - /// malformed. - #[test] - fn warm_trails_subscribe_only_on_lite07() { - let msg = subscribe_sample(); - let lite07 = encode(&msg, Version::Lite07).unwrap(); - assert_eq!(lite07.last(), Some(&0)); - let head = &lite07[..lite07.len() - 1]; - let decode = |warm: &[u8]| { - let buf = [head, warm].concat(); - crate::coding::decode_from(&mut buf.as_slice(), Version::Lite07, Subscribe::decode_msg).map(|_| ()) - }; - decode(&[0]).unwrap(); - decode(&[1]).unwrap(); - assert!(decode(&[2]).is_err()); - assert!(decode(&[]).is_err()); - } - /// SUBSCRIBE and SUBSCRIBE_UPDATE carry their update number on lite-07 alone. #[test] fn update_number_roundtrips_only_on_lite07() { @@ -1970,10 +1929,10 @@ mod test { msg.ranges = vec![Range::OLDEST]; let mut buf = encode(&msg, version).unwrap(); - // The list is last but for the update number and whether the pull joins a copy: a - // count of one, then two anchors of type 0. - let at = buf.len() - 5; - assert_eq!(&buf[at..], [1, 0, 0, 0, 0]); + // The list is last but for the update number: a count of one, then two anchors of + // type 0. + let at = buf.len() - 4; + assert_eq!(&buf[at..], [1, 0, 0, 0]); buf[at] = 0; buf.truncate(at + 1); assert!(matches!( @@ -1982,7 +1941,7 @@ mod test { )); let mut buf = encode(&msg, version).unwrap(); - let last = buf.len() - 3; + let last = buf.len() - 2; buf[last] = 4; assert!(matches!( crate::coding::decode_from(&mut buf.as_slice(), version, Subscribe::decode_msg), diff --git a/rs/moq-net/src/lite/subscriber.rs b/rs/moq-net/src/lite/subscriber.rs index c83c533f5ea..035030d3a17 100644 --- a/rs/moq-net/src/lite/subscriber.rs +++ b/rs/moq-net/src/lite/subscriber.rs @@ -922,9 +922,6 @@ impl Subscriber { | lite::AnnounceBroadcast::RouteEnd { .. } | lite::AnnounceBroadcast::Dead(_) | lite::AnnounceBroadcast::Floor { .. } - | lite::AnnounceBroadcast::WarmStart { .. } - | lite::AnnounceBroadcast::WarmUpdate { .. } - | lite::AnnounceBroadcast::WarmEnd { .. } | lite::AnnounceBroadcast::Refused { .. } => return Err(Error::ProtocolViolation), } Ok(()) diff --git a/rs/moq-net/src/lite/subscriber/routed.rs b/rs/moq-net/src/lite/subscriber/routed.rs index 6bec5653da5..ed49f5785c9 100644 --- a/rs/moq-net/src/lite/subscriber/routed.rs +++ b/rs/moq-net/src/lite/subscriber/routed.rs @@ -325,9 +325,6 @@ impl Routed { Msg::Refused { message, reason } => self.refused(prefix, message, reason, decoder)?, // Lite-07 ends a claim by its Announce ID only. Msg::Ended { .. } => return Err(Error::ProtocolViolation), - // Only a relay choosing a parent per broadcast uses warm routes, which this - // endpoint does not do. - Msg::WarmStart { .. } | Msg::WarmUpdate { .. } | Msg::WarmEnd { .. } => {} Msg::Skipped | Msg::Synced => {} } Ok(()) @@ -581,13 +578,6 @@ impl Routed { } self.pending(id, None)?; } - // Warm routes are ignored here anyway, so refusing one changes nothing. - Refusable::WarmStart { route } => { - tracing::warn!(route, %reason, "refusing a forwarded warm route"); - } - Refusable::WarmUpdate { id } => { - tracing::warn!(warm = id, %reason, "refusing a forwarded warm route"); - } } self.stats.refuse_route(); Ok(()) diff --git a/rs/moq-net/src/lite/version.rs b/rs/moq-net/src/lite/version.rs index 21ff2916d51..ed399c5e5ff 100644 --- a/rs/moq-net/src/lite/version.rs +++ b/rs/moq-net/src/lite/version.rs @@ -397,16 +397,6 @@ impl Version { ) } - /// Whether the announce stream carries warm routes (WARM_START, WARM_UPDATE, and - /// WARM_END), and SUBSCRIBE and SUBSCRIBE_UPDATE say whether each pull joins the - /// publisher's copy. Added in lite-07. - pub(crate) fn has_warm(self) -> bool { - !matches!( - self, - Self::Lite01 | Self::Lite02 | Self::Lite03 | Self::Lite04 | Self::Lite05 | Self::Lite06 - ) - } - /// Whether TRACK_INFO carries the refresh ratio and SUBSCRIBE_UPDATE a wanted group, /// so a join at any hop reaches the publisher. Added in lite-07; older peers see a /// track that never refreshes. diff --git a/rs/moq-net/src/route/tests/cache.rs b/rs/moq-net/src/route/tests/cache.rs index b270e4e2149..f43cb048d5e 100644 --- a/rs/moq-net/src/route/tests/cache.rs +++ b/rs/moq-net/src/route/tests/cache.rs @@ -30,6 +30,11 @@ //! broadcast's pulls form a cycle, which stale offers allow until the change crossing a //! link is delivered, and once quiet that every reader is fed and the offers are the //! fixed point computed centrally. +//! +//! No lite-07 wire carries the rule: WARM_START, WARM_UPDATE, WARM_END, and SUBSCRIBE's +//! `Warm` byte were stripped until `quest/m3/cache-routing/select.md` brings them back +//! with a production rule, and the draft's Warm Routes section went with them. Only +//! the nightly sweep runs the churned meshes. use std::{ cmp::Reverse, @@ -1491,23 +1496,15 @@ fn a_copy_that_goes_takes_its_offers_along() { /// a lower priority. Once churn stops every mesh settles on the steady state, and a /// broadcast nobody reads has sent no copy offer. The pulls form a cycle only while a /// change crosses a link, which the sweep counts. -#[test] -fn sweep_cache_routing() { - for holds in [true, false] { - sweep(SEED, 100, holds); - } -} - -/// The gate's seed, and the long sweep's unless `MOQ_ROUTE_SEED` names another. -const SEED: u64 = 0xcac4_e5ee; - -/// The sweep at length from `MOQ_ROUTE_SEED` over `MOQ_ROUTE_CASES` scenarios each way, -/// which prints what it measured. +/// +/// Nightly alone (`test/route-sweep.sh`): the warm wire is frozen out of lite-07 until +/// a production rule brings it back, so the gate does not pay for it. Runs from +/// `MOQ_ROUTE_SEED` over `MOQ_ROUTE_CASES` scenarios each way, and prints what it measured. #[test] #[ignore = "slow: nightly"] fn sweep_cache_routing_long() { let setting = |name: &str, fallback: u64| std::env::var(name).map_or(fallback, |value| value.parse().expect(name)); - let seed = setting("MOQ_ROUTE_SEED", SEED); + let seed = setting("MOQ_ROUTE_SEED", 0xcac4_e5ee); let cases = setting("MOQ_ROUTE_CASES", 3000) as usize; println!("MOQ_ROUTE_SEED={seed} MOQ_ROUTE_CASES={cases}"); for holds in [true, false] { diff --git a/rs/moq-net/src/stats.rs b/rs/moq-net/src/stats.rs index 650c71ab839..7ab2b6611ca 100644 --- a/rs/moq-net/src/stats.rs +++ b/rs/moq-net/src/stats.rs @@ -727,7 +727,7 @@ pub struct Presence { pub wire_tx: u64, /// Cumulative transport bytes received, including transport framing. pub wire_rx: u64, - /// Cumulative routes, warm routes, and claims a lite-07 session forwarded that this + /// Cumulative routes and claims a lite-07 session forwarded that this /// node refused, withdrawing each and keeping the session. pub routes_refused: u64, }