Skip to content

armgit / Piik

Public Imported from GitHub
0

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.ts
index 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.ts
index 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 });
});
});