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

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
9 changes: 8 additions & 1 deletion src/listen-policy.ts
Original file line number Diff line number Diff line change
Expand Up @@ -67,6 +67,13 @@ export interface EaddrinuseContext {
lastTriedPort: number;
}

/** Use the existing ephemeral fallback when either the retry budget or the
* valid numeric port range is exhausted. Both pre- and post-bind retries
* must avoid handing 65536 to Node's listener. */
export function nextListenPort(port: number, nextAttempt: number, maxAttempts: number): number {
return nextAttempt >= maxAttempts || port >= 65535 ? 0 : port + 1;
}

export function decideEaddrinuse(ctx: EaddrinuseContext): EaddrinuseAction {
// The twin rule outranks everything else: a healthy peer already serves
// real traffic on that port, so no wait/ladder variant may touch it — the
Expand All @@ -89,7 +96,7 @@ export function decideEaddrinuse(ctx: EaddrinuseContext): EaddrinuseAction {
return { kind: "wait-predecessor", port: ctx.lastTriedPort };
}
const nextAttempts = ctx.attempts + 1;
return { kind: "ladder", nextPort: nextAttempts === ctx.maxAttempts ? 0 : ctx.lastTriedPort + 1 };
return { kind: "ladder", nextPort: nextListenPort(ctx.lastTriedPort, nextAttempts, ctx.maxAttempts) };
}

/** #3044/#2941: ladder rights for the POST-BIND claim check (port-owner's
Expand Down
3 changes: 2 additions & 1 deletion src/port-owner.ts
Original file line number Diff line number Diff line change
@@ -1,4 +1,5 @@
import { isProxyInstanceFile, type ProxyInstanceFile } from "./instance.js";
import { nextListenPort } from "./listen-policy.js";

/** #2941: post-bind port-ownership verification + pointer-clobber guard for
* same-lane double-spawn residuals (#707 follow-ups). Conservative by
Expand Down Expand Up @@ -170,7 +171,7 @@ export async function resolvePortClaim(params: {
return { kind: "die", message: `port ${portOf(params.origin)} is shared with ${who} — refusing to serve a contested port (#2941)` };
}
const attempts = params.listenAttempts + 1;
const nextPort = attempts >= params.maxListenAttempts ? 0 : portOf(params.origin) + 1;
const nextPort = nextListenPort(portOf(params.origin), attempts, params.maxListenAttempts);
return { kind: "ladder", nextPort, foreign };
}

Expand Down
65 changes: 65 additions & 0 deletions tests/listen-retry-boundary.test.ts
Original file line number Diff line number Diff line change
@@ -0,0 +1,65 @@
import test from "node:test";
import assert from "node:assert/strict";
import { createServer } from "node:net";
import { resolveZonePortBase } from "../src/config.ts";
import { decideEaddrinuse, type EaddrinuseContext } from "../src/listen-policy.ts";
import { resolvePortClaim } from "../src/port-owner.ts";

const base: EaddrinuseContext = {
upgradeReplacement: false, twinHolds: false, newerHolderHolds: false,
launchToken: true, strictPort: false, attempts: 0, maxAttempts: 17,
predecessorTicksLeft: 10, predecessorHolds: false,
lastTriedPort: resolveZonePortBase({ BILI_ZONE_PORT: "65535" }),
};

async function bindRetry(port: number): Promise<void> {
const server = createServer();
try {
// Exercise what the listener does with the decision. The old boundary result is
// 65536, which throws ERR_SOCKET_BAD_PORT before a listen event can be emitted.
await new Promise<void>((resolve, reject) => {
server.once("error", reject);
server.listen(port, "127.0.0.1", resolve);
});
const address = server.address();
assert.ok(address && typeof address === "object" && address.port > 0 && address.port <= 65535);
assert.equal(port, 0, "the OS chooses a free port when the numeric ladder is exhausted");
} finally {
if (server.listening) await new Promise<void>((resolve, reject) => server.close(error => error ? reject(error) : resolve()));
}
}

async function foreignClaim(port: number, canLadder = true) {
return resolvePortClaim({
origin: `http://127.0.0.1:${port}`, ownPid: 100, canLadder,
listenAttempts: 0, maxListenAttempts: 17,
probe: { fetchImpl: async () => ({ ok: true, json: async () => ({ ok: true, pid: 200 }) }) },
});
}

test("a busy highest valid zone port retries on a bindable ephemeral port", async () => {
assert.equal(base.lastTriedPort, 65535, "the configured zone boundary is valid");
const action = decideEaddrinuse(base);
assert.equal(action.kind, "ladder");
if (action.kind === "ladder") await bindRetry(action.nextPort);
});

test("post-bind foreign ownership at the port boundary retries on a bindable ephemeral port", async () => {
const action = await foreignClaim(65535);
assert.equal(action.kind, "ladder");
if (action.kind === "ladder") await bindRetry(action.nextPort);
});

test("both retry paths still try the last valid numeric port before using an ephemeral port", async () => {
assert.deepEqual(decideEaddrinuse({ ...base, lastTriedPort: 65534 }), { kind: "ladder", nextPort: 65535 });
const action = await foreignClaim(65534);
assert.equal(action.kind === "ladder" ? action.nextPort : undefined, 65535);
});

test("the numeric boundary does not grant retry rights or bypass a predecessor wait", async () => {
assert.deepEqual(decideEaddrinuse({ ...base, strictPort: true }), { kind: "fail-fast", reason: "strict-port" });
assert.deepEqual(decideEaddrinuse({ ...base, launchToken: false }), { kind: "fail-fast", reason: "port-busy" });
assert.deepEqual(decideEaddrinuse({ ...base, upgradeReplacement: true }), { kind: "fail-fast", reason: "upgrade-replacement" });
assert.deepEqual(decideEaddrinuse({ ...base, predecessorHolds: true }), { kind: "wait-predecessor", port: 65535 });
assert.equal((await foreignClaim(65535, false)).kind, "die");
});
Loading