Free, open-source screen sharing for private live streams with friends. Watch together in a browser or self-host Piik. 免费开源的私密屏幕共享,支持游戏直播、一起看电影与自部署。
refactor(route): account reusable SFU subscriptions
AAAb656f479519a
diff --git a/src/server/sfu-resource-admission.ts b/src/server/sfu-resource-admission.tsindex e365aaa3..5349d685 100644--- a/src/server/sfu-resource-admission.ts+++ b/src/server/sfu-resource-admission.ts@@ -4,6 +4,10 @@ export interface SfuResourceFence {publicationGeneration: string;}+export interface SfuSubscriptionFence extends SfuResourceFence {+ viewerPeerId: string;+}+export interface SfuResourceAdmissionOptions {readonly ingressCapacity: number;readonly egressCapacity: number;@@ -14,19 +18,27 @@ export interface SfuResourceUsage {egress: number;}-interface SfuResourceEntry {+type ResourceState = "reserved" | "committed" | "draining";++interface SubscriptionEntry {+ fence: SfuSubscriptionFence;+ state: ResourceState;+ reservedFromDraining: boolean;+}++interface PublicationEntry {fence: SfuResourceFence;- egress: number;+ state: ResourceState;+ subscriptions: Map<string, SubscriptionEntry>;+ legacyEgress?: number;}-interface RoomSfuResources {- committed?: SfuResourceEntry;- reserved?: SfuResourceEntry;- draining: Map<string, SfuResourceEntry>;+interface RoomResources {+ publications: Map<string, PublicationEntry>;}export class SfuResourceAdmission {- private readonly rooms = new Map<string, RoomSfuResources>();+ private readonly rooms = new Map<string, RoomResources>();private readonly ingressCapacity: number;private readonly egressCapacity: number;private ingressInUse = 0;@@ -39,110 +51,220 @@ export class SfuResourceAdmission {this.egressCapacity = options.egressCapacity;}- reserve(fence: SfuResourceFence, egress: number): boolean {+ reservePublication(fence: SfuResourceFence): boolean {assertFence(fence);- assertPositiveSafeInteger(egress, "SFU egress reservation");const room = this.rooms.get(fence.roomId);- if (room?.reserved) {- return sameEntry(room.reserved, fence, egress);- }- if (room?.committed && sameFence(room.committed.fence, fence)) {- return room.committed.egress === egress;- }- if (room?.draining.has(fenceKey(fence))) {- return false;+ const existing = room?.publications.get(publicationKey(fence));+ if (existing) {+ return existing.state !== "draining" && sameFence(existing.fence, fence);}if (this.ingressInUse >= this.ingressCapacity ||- egress > this.egressCapacity - this.egressInUse+ [...(room?.publications.values() ?? [])].some(+ (publication) => publication.state === "reserved",+ )) {return false;}- const resources: RoomSfuResources = room ?? { draining: new Map() };- resources.reserved = { fence: { ...fence }, egress };+ const resources = room ?? { publications: new Map() };+ resources.publications.set(publicationKey(fence), {+ fence: cloneFence(fence),+ state: "reserved",+ subscriptions: new Map(),+ });this.rooms.set(fence.roomId, resources);this.ingressInUse += 1;- this.egressInUse += egress;return true;}- commit(fence: SfuResourceFence): readonly SfuResourceFence[] | null {+ reserveSubscription(fence: SfuSubscriptionFence): boolean {+ assertSubscriptionFence(fence);+ const publication = this.publication(fence);+ if (!publication || publication.state === "draining") {+ return false;+ }+ const existing = publication.subscriptions.get(fence.viewerPeerId);+ if (existing) {+ if (!sameSubscriptionFence(existing.fence, fence)) return false;+ if (existing.state === "reserved" || existing.state === "committed") {+ return true;+ }+ if (publication.state !== "committed") return false;+ existing.state = "reserved";+ existing.reservedFromDraining = true;+ return true;+ }+ if (this.egressInUse >= this.egressCapacity) return false;++ publication.subscriptions.set(fence.viewerPeerId, {+ fence: cloneSubscriptionFence(fence),+ state: "reserved",+ reservedFromDraining: false,+ });+ this.egressInUse += 1;+ return true;+ }++ commitPublication(fence: SfuResourceFence): readonly SfuResourceFence[] | null {assertFence(fence);const room = this.rooms.get(fence.roomId);- if (room?.committed && sameFence(room.committed.fence, fence)) {- return [];- }- if (!room?.reserved || !sameFence(room.reserved.fence, fence)) {+ const publication = room?.publications.get(publicationKey(fence));+ if (!room || !publication || !sameFence(publication.fence, fence)) {return null;}+ if (publication.state === "committed") return [];+ if (publication.state !== "reserved") return null;const draining: SfuResourceFence[] = [];- if (room.committed) {- this.addDraining(room, room.committed);- draining.push({ ...room.committed.fence });+ for (const other of room.publications.values()) {+ if (other === publication || other.state !== "committed") continue;+ this.markDraining(other);+ draining.push(cloneFence(other.fence));+ }+ publication.state = "committed";+ for (const subscription of publication.subscriptions.values()) {+ if (subscription.state === "reserved") {+ subscription.state = "committed";+ subscription.reservedFromDraining = false;+ }}- room.committed = room.reserved;- room.reserved = undefined;return draining;}- beginDrain(fence: SfuResourceFence): boolean {- assertFence(fence);- const room = this.rooms.get(fence.roomId);- if (!room) {+ commitSubscription(fence: SfuSubscriptionFence): boolean {+ assertSubscriptionFence(fence);+ const publication = this.publication(fence);+ const subscription = publication?.subscriptions.get(fence.viewerPeerId);+ if (+ publication?.state !== "committed" ||+ !subscription ||+ !sameSubscriptionFence(subscription.fence, fence)+ ) {return false;}+ if (subscription.state === "committed") return true;+ if (subscription.state !== "reserved") return false;+ subscription.state = "committed";+ subscription.reservedFromDraining = false;+ return true;+ }- if (room.draining.has(fenceKey(fence))) {+ releaseSubscription(fence: SfuSubscriptionFence): boolean {+ assertSubscriptionFence(fence);+ const publication = this.publication(fence);+ const subscription = publication?.subscriptions.get(fence.viewerPeerId);+ if (+ !publication ||+ !subscription ||+ !sameSubscriptionFence(subscription.fence, fence)+ ) {+ return false;+ }+ if (subscription.state === "reserved") {+ if (subscription.reservedFromDraining) {+ subscription.state = "draining";+ subscription.reservedFromDraining = false;+ } else {+ publication.subscriptions.delete(fence.viewerPeerId);+ this.subtractEgress(1);+ }return true;}- let entry: SfuResourceEntry | undefined;- if (room.reserved && sameFence(room.reserved.fence, fence)) {- entry = room.reserved;- room.reserved = undefined;+ if (subscription.state === "committed") {+ subscription.state = "draining";}- if (room.committed && sameFence(room.committed.fence, fence)) {- entry = room.committed;- room.committed = undefined;+ return true;+ }++ /** Compatibility wrapper for the pre-controller aggregate reservation. */+ reserve(fence: SfuResourceFence, egress: number): boolean {+ assertFence(fence);+ assertPositiveSafeInteger(egress, "SFU egress reservation");+ const existing = this.publication(fence);+ if (existing) {+ return (+ existing.state !== "draining" && existing.legacyEgress === egress+ );}- if (!entry) {+ const room = this.rooms.get(fence.roomId);+ if (+ this.ingressInUse >= this.ingressCapacity ||+ egress > this.egressCapacity - this.egressInUse ||+ [...(room?.publications.values() ?? [])].some(+ (publication) => publication.state === "reserved",+ )+ ) {return false;}- this.addDraining(room, entry);++ const resources = room ?? { publications: new Map() };+ const publication: PublicationEntry = {+ fence: cloneFence(fence),+ state: "reserved",+ subscriptions: new Map(),+ legacyEgress: egress,+ };+ for (let index = 0; index < egress; index += 1) {+ const viewerPeerId = `legacy_${index}`;+ publication.subscriptions.set(viewerPeerId, {+ fence: { ...cloneFence(fence), viewerPeerId },+ state: "reserved",+ reservedFromDraining: false,+ });+ }+ resources.publications.set(publicationKey(fence), publication);+ this.rooms.set(fence.roomId, resources);+ this.ingressInUse += 1;+ this.egressInUse += egress;+ return true;+ }++ /** Compatibility wrapper for the pre-controller aggregate commit. */+ commit(fence: SfuResourceFence): readonly SfuResourceFence[] | null {+ return this.commitPublication(fence);+ }++ beginDrain(fence: SfuResourceFence): boolean {+ assertFence(fence);+ const publication = this.publication(fence);+ if (!publication) return false;+ this.markDraining(publication);return true;}completeDrain(fence: SfuResourceFence): boolean {assertFence(fence);const room = this.rooms.get(fence.roomId);- const entry = room?.draining.get(fenceKey(fence));- if (!room || !entry) {+ const key = publicationKey(fence);+ const publication = room?.publications.get(key);+ if (+ !room ||+ !publication ||+ publication.state !== "draining" ||+ !sameFence(publication.fence, fence)+ ) {return false;}- room.draining.delete(fenceKey(fence));- this.subtract(entry);- this.deleteEmptyRoom(fence.roomId, room);++ room.publications.delete(key);+ this.ingressInUse -= 1;+ this.subtractEgress(publication.subscriptions.size);+ this.assertNoUnderflow();+ if (room.publications.size === 0) this.rooms.delete(fence.roomId);return true;}beginDrainRoom(roomId: string): readonly SfuResourceFence[] {- if (!roomId) {- throw new Error("SFU resource room ID is invalid");- }+ if (!roomId) throw new Error("SFU resource room ID is invalid");const room = this.rooms.get(roomId);- if (!room) {- return [];- }- if (room.reserved) {- this.addDraining(room, room.reserved);- room.reserved = undefined;- }- if (room.committed) {- this.addDraining(room, room.committed);- room.committed = undefined;+ if (!room) return [];+ for (const publication of room.publications.values()) {+ this.markDraining(publication);}- return [...room.draining.values()].map((entry) => ({ ...entry.fence }));+ return [...room.publications.values()].map((publication) =>+ cloneFence(publication.fence),+ );}beginDrainAll(): readonly SfuResourceFence[] {@@ -155,35 +277,49 @@ export class SfuResourceAdmission {return { ingress: this.ingressInUse, egress: this.egressInUse };}- private subtract(entry: SfuResourceEntry): void {- this.ingressInUse -= 1;- this.egressInUse -= entry.egress;- if (this.ingressInUse < 0 || this.egressInUse < 0) {- throw new Error("SFU resource accounting underflow");+ private publication(+ fence: SfuResourceFence,+ ): PublicationEntry | undefined {+ const publication = this.rooms+ .get(fence.roomId)+ ?.publications.get(publicationKey(fence));+ return publication && sameFence(publication.fence, fence)+ ? publication+ : undefined;+ }++ private markDraining(publication: PublicationEntry): void {+ publication.state = "draining";+ for (const subscription of publication.subscriptions.values()) {+ subscription.state = "draining";+ subscription.reservedFromDraining = false;}}- private addDraining(room: RoomSfuResources, entry: SfuResourceEntry): void {- room.draining.set(fenceKey(entry.fence), entry);+ private subtractEgress(count: number): void {+ this.egressInUse -= count;+ this.assertNoUnderflow();}- private deleteEmptyRoom(roomId: string, room: RoomSfuResources): void {- if (!room.committed && !room.reserved && room.draining.size === 0) {- this.rooms.delete(roomId);+ private assertNoUnderflow(): void {+ if (this.ingressInUse < 0 || this.egressInUse < 0) {+ throw new Error("SFU resource accounting underflow");}}}-function fenceKey(fence: SfuResourceFence): string {+function publicationKey(fence: SfuResourceFence): string {return `${fence.shareGeneration}\u0000${fence.publicationGeneration}`;}-function sameEntry(- entry: SfuResourceEntry,- fence: SfuResourceFence,- egress: number,-): boolean {- return entry.egress === egress && sameFence(entry.fence, fence);+function cloneFence(fence: SfuResourceFence): SfuResourceFence {+ return { ...fence };+}++function cloneSubscriptionFence(+ fence: SfuSubscriptionFence,+): SfuSubscriptionFence {+ return { ...fence };}function sameFence(left: SfuResourceFence, right: SfuResourceFence): boolean {@@ -194,12 +330,26 @@ function sameFence(left: SfuResourceFence, right: SfuResourceFence): boolean {);}+function sameSubscriptionFence(+ left: SfuSubscriptionFence,+ right: SfuSubscriptionFence,+): boolean {+ return sameFence(left, right) && left.viewerPeerId === right.viewerPeerId;+}+function assertFence(fence: SfuResourceFence): void {if (!fence.roomId || !fence.shareGeneration || !fence.publicationGeneration) {throw new Error("SFU resource fence is invalid");}}+function assertSubscriptionFence(fence: SfuSubscriptionFence): void {+ assertFence(fence);+ if (!fence.viewerPeerId) {+ throw new Error("SFU subscription fence is invalid");+ }+}+function assertPositiveSafeInteger(value: number, name: string): void {if (!Number.isSafeInteger(value) || value <= 0) {throw new Error(`${name} must be a positive safe integer`);diff --git a/tests/sfu-resource-admission.test.ts b/tests/sfu-resource-admission.test.tsindex c122a198..cbc5c8e7 100644--- a/tests/sfu-resource-admission.test.ts+++ b/tests/sfu-resource-admission.test.ts@@ -3,9 +3,10 @@ import { describe, expect, it } from "vitest";import {SfuResourceAdmission,type SfuResourceFence,+ type SfuSubscriptionFence,} from "../src/server/sfu-resource-admission.ts";-function fence(+function publication(roomId: string,publicationGeneration: string,shareGeneration = `share_${roomId}`,@@ -13,8 +14,15 @@ function fence(return { roomId, shareGeneration, publicationGeneration };}+function subscription(+ fence: SfuResourceFence,+ viewerPeerId: string,+): SfuSubscriptionFence {+ return { ...fence, viewerPeerId };+}+describe("SfuResourceAdmission", () => {- it("requires explicit positive safe capacities", () => {+ it("requires explicit capacities and enforces ingress and egress independently", () => {for (const ingressCapacity of [0, 1.5, Number.MAX_SAFE_INTEGER + 1]) {expect(() => new SfuResourceAdmission({ ingressCapacity, egressCapacity: 1 }),@@ -23,102 +31,208 @@ describe("SfuResourceAdmission", () => {expect(() => new SfuResourceAdmission({ ingressCapacity: 1, egressCapacity: 0 }),).toThrow("positive safe integer");- });- it("enforces deployment-wide ingress and egress across rooms", () => {const admission = new SfuResourceAdmission({ingressCapacity: 2,- egressCapacity: 4,+ egressCapacity: 2,+ });+ const first = publication("1", "publication_first");+ const second = publication("2", "publication_second");+ expect(admission.reservePublication(first)).toBe(true);+ expect(admission.reservePublication(second)).toBe(true);+ expect(+ admission.reservePublication(publication("3", "publication_third")),+ ).toBe(false);+ expect(admission.reserveSubscription(subscription(first, "viewer_a"))).toBe(+ true,+ );+ expect(admission.reserveSubscription(subscription(first, "viewer_b"))).toBe(+ true,+ );+ expect(+ admission.reserveSubscription(subscription(second, "viewer_c")),+ ).toBe(false);+ expect(admission.usage()).toEqual({ ingress: 2, egress: 2 });+ });++ it("keeps exact publication and subscription operations idempotent", () => {+ const admission = new SfuResourceAdmission({+ ingressCapacity: 1,+ egressCapacity: 1,});- expect(admission.reserve(fence("1", "publication_a"), 2)).toBe(true);- expect(admission.reserve(fence("2", "publication_b"), 2)).toBe(true);- expect(admission.usage()).toEqual({ ingress: 2, egress: 4 });+ const active = publication("1", "publication_active");+ const viewer = subscription(active, "viewer_a");+ expect(admission.reservePublication(active)).toBe(true);+ expect(admission.reservePublication({ ...active })).toBe(true);+ expect(admission.reserveSubscription(viewer)).toBe(true);+ expect(admission.reserveSubscription({ ...viewer })).toBe(true);+ expect(admission.commitSubscription(viewer)).toBe(false);+ expect(admission.commitPublication(active)).toEqual([]);+ expect(admission.commitPublication({ ...active })).toEqual([]);+ expect(admission.commitSubscription(viewer)).toBe(true);+ expect(admission.usage()).toEqual({ ingress: 1, egress: 1 });- expect(admission.reserve(fence("3", "publication_c"), 1)).toBe(false);- expect(admission.usage()).toEqual({ ingress: 2, egress: 4 });+ const stale = publication("1", "publication_stale");+ expect(admission.reserveSubscription(subscription(stale, "viewer_a"))).toBe(+ false,+ );+ expect(admission.commitPublication(stale)).toBeNull();+ expect(admission.commitSubscription(subscription(active, "viewer_b"))).toBe(+ false,+ );+ expect(admission.releaseSubscription(subscription(active, "viewer_b"))).toBe(+ false,+ );+ expect(admission.beginDrain(stale)).toBe(false);});- it("charges old and candidate generations until exact drain proof", () => {+ it("commits a new publication and its subscriptions before draining the old generation", () => {const admission = new SfuResourceAdmission({ingressCapacity: 2,- egressCapacity: 5,+ egressCapacity: 3,});- const first = fence("1", "publication_first");- const second = fence("1", "publication_second");- expect(admission.reserve(first, 1)).toBe(true);- expect(admission.commit(first)).toEqual([]);- expect(admission.reserve(second, 2)).toBe(true);- expect(admission.usage()).toEqual({ ingress: 2, egress: 3 });+ const first = publication("1", "publication_first");+ const second = publication("1", "publication_second");+ const firstViewer = subscription(first, "viewer_a");+ expect(admission.reservePublication(first)).toBe(true);+ expect(admission.reserveSubscription(firstViewer)).toBe(true);+ expect(admission.commitPublication(first)).toEqual([]);- expect(admission.commit(fence("1", "publication_stale"))).toBeNull();- expect(admission.commit(second)).toEqual([first]);+ expect(admission.reservePublication(second)).toBe(true);+ expect(admission.reserveSubscription(subscription(second, "viewer_b"))).toBe(+ true,+ );+ expect(admission.reserveSubscription(subscription(second, "viewer_c"))).toBe(+ true,+ );expect(admission.usage()).toEqual({ ingress: 2, egress: 3 });+ expect(admission.commitPublication(second)).toEqual([first]);+ expect(admission.commitSubscription(subscription(second, "viewer_b"))).toBe(+ true,+ );+ expect(admission.reservePublication(first)).toBe(false);+ expect(admission.reserveSubscription(firstViewer)).toBe(false);+expect(admission.completeDrain(first)).toBe(true);- expect(admission.usage()).toEqual({ ingress: 1, egress: 2 });expect(admission.completeDrain(first)).toBe(false);+ expect(admission.usage()).toEqual({ ingress: 1, egress: 2 });});- it("makes duplicate operations idempotent without weakening fences", () => {+ it("refunds a new reserved subscription when its candidate aborts", () => {const admission = new SfuResourceAdmission({- ingressCapacity: 2,- egressCapacity: 3,+ ingressCapacity: 1,+ egressCapacity: 2,});- const pending = fence("1", "publication_pending");- expect(admission.reserve(pending, 2)).toBe(true);- expect(admission.reserve(pending, 2)).toBe(true);- expect(admission.reserve(pending, 1)).toBe(false);- expect(admission.reserve(fence("1", "publication_other"), 1)).toBe(false);- expect(admission.usage()).toEqual({ ingress: 1, egress: 2 });+ const active = publication("1", "publication_active");+ const first = subscription(active, "viewer_a");+ const candidate = subscription(active, "viewer_b");+ expect(admission.reservePublication(active)).toBe(true);+ expect(admission.reserveSubscription(first)).toBe(true);+ expect(admission.commitPublication(active)).toEqual([]);- expect(admission.beginDrain(pending)).toBe(true);- expect(admission.beginDrain(pending)).toBe(true);+ expect(admission.reserveSubscription(candidate)).toBe(true);expect(admission.usage()).toEqual({ ingress: 1, egress: 2 });- expect(admission.completeDrain(pending)).toBe(true);- expect(admission.completeDrain(pending)).toBe(false);+ expect(admission.releaseSubscription(candidate)).toBe(true);+ expect(admission.releaseSubscription(candidate)).toBe(false);+ expect(admission.commitSubscription(candidate)).toBe(false);+ expect(admission.usage()).toEqual({ ingress: 1, egress: 1 });+ });++ it("reactivates a draining subscription in the current generation without double charging", () => {+ const admission = new SfuResourceAdmission({+ ingressCapacity: 1,+ egressCapacity: 1,+ });+ const active = publication("1", "publication_active");+ const viewer = subscription(active, "viewer_a");+ expect(admission.reservePublication(active)).toBe(true);+ expect(admission.reserveSubscription(viewer)).toBe(true);+ expect(admission.commitPublication(active)).toEqual([]);+ expect(admission.releaseSubscription(viewer)).toBe(true);+ expect(admission.usage()).toEqual({ ingress: 1, egress: 1 });++ expect(admission.reserveSubscription(viewer)).toBe(true);+ expect(admission.reserveSubscription(viewer)).toBe(true);+ expect(admission.usage()).toEqual({ ingress: 1, egress: 1 });+ expect(admission.releaseSubscription(viewer)).toBe(true);+ expect(+ admission.reserveSubscription(subscription(active, "viewer_b")),+ ).toBe(false);+ expect(admission.reserveSubscription(viewer)).toBe(true);+ expect(admission.commitSubscription(viewer)).toBe(true);+ expect(admission.usage()).toEqual({ ingress: 1, egress: 1 });+ });++ it("keeps departed subscription egress charged until publication drain proof", () => {+ const admission = new SfuResourceAdmission({+ ingressCapacity: 1,+ egressCapacity: 1,+ });+ const active = publication("1", "publication_active");+ const viewer = subscription(active, "viewer_a");+ expect(admission.reservePublication(active)).toBe(true);+ expect(admission.reserveSubscription(viewer)).toBe(true);+ expect(admission.commitPublication(active)).toEqual([]);+ expect(admission.releaseSubscription(viewer)).toBe(true);+ expect(+ admission.reserveSubscription(subscription(active, "viewer_b")),+ ).toBe(false);+ expect(admission.beginDrain(active)).toBe(true);+ expect(admission.beginDrain(active)).toBe(true);+ expect(admission.usage()).toEqual({ ingress: 1, egress: 1 });+ expect(admission.completeDrain(active)).toBe(true);expect(admission.usage()).toEqual({ ingress: 0, egress: 0 });});- it("moves a room's committed and reserved resources into draining together", () => {+ it("drains every reserved and committed generation exactly once", () => {const admission = new SfuResourceAdmission({- ingressCapacity: 2,+ ingressCapacity: 3,egressCapacity: 4,});- const active = fence("1", "publication_active");- expect(admission.reserve(active, 1)).toBe(true);- expect(admission.commit(active)).toEqual([]);- expect(admission.reserve(fence("1", "publication_candidate"), 2)).toBe(+ const active = publication("1", "publication_active");+ const replacement = publication("1", "publication_replacement");+ const other = publication("2", "publication_other");+ expect(admission.reservePublication(active)).toBe(true);+ expect(admission.reserveSubscription(subscription(active, "viewer_a"))).toBe(+ true,+ );+ expect(admission.commitPublication(active)).toEqual([]);+ expect(admission.reservePublication(replacement)).toBe(true);+ expect(+ admission.reserveSubscription(subscription(replacement, "viewer_b")),+ ).toBe(true);+ expect(admission.reservePublication(other)).toBe(true);+ expect(admission.reserveSubscription(subscription(other, "viewer_c"))).toBe(true,);- const draining = admission.beginDrainRoom("1");- expect(draining).toHaveLength(2);- expect(admission.beginDrainRoom("1")).toEqual(draining);- expect(admission.usage()).toEqual({ ingress: 2, egress: 3 });- for (const resourceFence of draining) {- expect(admission.completeDrain(resourceFence)).toBe(true);+ const firstRoom = admission.beginDrainRoom("1");+ expect(firstRoom).toEqual([active, replacement]);+ expect(admission.beginDrainRoom("1")).toEqual(firstRoom);+ expect(admission.beginDrainAll()).toEqual([active, replacement, other]);+ expect(admission.usage()).toEqual({ ingress: 3, egress: 3 });+ for (const fence of [active, replacement, other]) {+ expect(admission.completeDrain(fence)).toBe(true);+ expect(admission.completeDrain(fence)).toBe(false);}expect(admission.usage()).toEqual({ ingress: 0, egress: 0 });});- it("moves every room to draining before its process owner closes", () => {+ it("keeps the aggregate API available while the router migrates", () => {const admission = new SfuResourceAdmission({ingressCapacity: 2,egressCapacity: 3,});- const active = fence("1", "publication_active");- expect(admission.reserve(active, 1)).toBe(true);- expect(admission.commit(active)).toEqual([]);- expect(admission.reserve(fence("2", "publication_pending"), 2)).toBe(- true,- );-- const draining = admission.beginDrainAll();- expect(draining).toHaveLength(2);- expect(admission.beginDrainAll()).toEqual(draining);+ const first = publication("1", "publication_first");+ const second = publication("1", "publication_second");+ expect(admission.reserve(first, 1)).toBe(true);+ expect(admission.reserve(first, 1)).toBe(true);+ expect(admission.reserve(first, 2)).toBe(false);+ expect(admission.commit(first)).toEqual([]);+ expect(admission.reserve(second, 2)).toBe(true);+ expect(admission.commit(second)).toEqual([first]);expect(admission.usage()).toEqual({ ingress: 2, egress: 3 });- for (const resourceFence of draining) {- expect(admission.completeDrain(resourceFence)).toBe(true);- }- expect(admission.usage()).toEqual({ ingress: 0, egress: 0 });+ expect(admission.completeDrain(first)).toBe(true);+ expect(admission.usage()).toEqual({ ingress: 1, egress: 2 });});});