~ knotless Search/
↑↓ move↵ open⇧↵ all results

johnandersen777.bsky.social/socialweb-computer-console

console.socialweb.computer: kcp, kubectl and ssh compiled to wasm in a browser tab with a terminal; a kcp fork

0
0
main
284 lines · 10.6 KB Raw History
// Copyright 2026 The KCP Authors.
// SPDX-License-Identifier: Apache-2.0

import { createIngressManager, DROP_AFTER_MS } from "./ingress_manager.js";

function assertEquals(actual, expected) {
  const a = JSON.stringify(actual);
  const e = JSON.stringify(expected);
  if (a !== e) throw new Error(`expected:\n${e}\nactual:\n${a}`);
}

const flush = () => new Promise((resolve) => setTimeout(resolve, 0));

// harness wires a manager to a fake clock and a fake connect whose promise
// and subscriber the test settles by hand.
function harness() {
  let time = 0;
  let timers = [];
  const calls = [];
  const statuses = [];
  const logs = [];
  const manager = createIngressManager({
    now: () => time,
    setTimer: (fn, ms) => {
      const t = { at: time + ms, fn };
      timers.push(t);
      return t;
    },
    clearTimer: (t) => (timers = timers.filter((x) => x !== t)),
    onStatus: (entries) => statuses.push(entries),
    log: (level, message) => logs.push(`${level} ${message}`),
    connect: (entry, hooks) =>
      new Promise((resolve, reject) => {
        const sub = { connecting: true, closed: 0, close() { this.closed++; } };
        calls.push({ entry, hooks, sub, resolve: () => resolve(sub), reject });
      }),
  });
  const advance = async (ms) => {
    const end = time + ms;
    for (;;) {
      timers.sort((a, b) => a.at - b.at);
      const next = timers[0];
      if (!next || next.at > end) break;
      timers.shift();
      time = next.at;
      next.fn();
      await flush();
    }
    time = end;
  };
  const state = (host) => manager.status().find((e) => e.host === host)?.state;
  return { manager, calls, statuses, logs, advance, state, timers: () => timers };
}

const entry = (host) => ({ name: `exp-${host}`, host, url: `https://${host}`, did: `did:key:${host}`, proxyHost: "relay" });

Deno.test("single-flight: repeated lists start one subscriber per host", async () => {
  const h = harness();
  h.manager.apply([entry("a")]);
  h.manager.apply([entry("a")]);
  h.manager.apply([entry("a"), entry("a")]);
  assertEquals(h.calls.length, 1);
  h.calls[0].resolve();
  await flush();
  h.manager.apply([entry("a")]);
  assertEquals(h.calls.length, 1);
});

Deno.test("status transitions connecting -> registered -> reconnecting -> registered", async () => {
  const h = harness();
  h.manager.apply([entry("a")]);
  assertEquals(h.state("a"), "connecting");
  h.calls[0].resolve();
  await flush();
  h.calls[0].sub.connecting = false;
  h.calls[0].hooks.onRegistered({});
  assertEquals(h.state("a"), "registered");
  h.calls[0].hooks.onClose({ code: 1006, reason: "" });
  assertEquals(h.manager.status()[0], { name: "exp-a", host: "a", url: "https://a", state: "reconnecting", lastError: null, closeCode: 1006 });
  h.calls[0].hooks.onError(new Error("boom"));
  assertEquals(h.manager.status()[0].lastError, "boom");
  h.calls[0].hooks.onRegistered({});
  assertEquals(h.manager.status()[0], { name: "exp-a", host: "a", url: "https://a", state: "registered", lastError: null, closeCode: null });
  assertEquals(h.logs.filter((l) => l.startsWith("ok ")), ["ok ingress exp-a registered at https://a", "ok ingress exp-a registered at https://a"]);
  assertEquals(h.logs.includes("warn ingress exp-a closed: code 1006"), true);
  assertEquals(h.statuses.map((s) => s[0].state), ["connecting", "registered", "reconnecting", "reconnecting", "registered"]);
});

Deno.test("a host missing for less than the drop delay keeps its subscriber", async () => {
  const h = harness();
  h.manager.apply([entry("a")]);
  h.calls[0].resolve();
  await flush();
  h.calls[0].sub.connecting = false;
  h.calls[0].hooks.onRegistered({});
  h.manager.apply([]);
  await h.advance(DROP_AFTER_MS - 1);
  h.manager.apply([entry("a")]);
  await h.advance(DROP_AFTER_MS * 2);
  assertEquals(h.calls[0].sub.closed, 0);
  assertEquals(h.state("a"), "registered");
  assertEquals(h.calls.length, 1);
});

Deno.test("a host missing for the drop delay is closed, even without another list", async () => {
  const h = harness();
  h.manager.apply([entry("a"), entry("b")]);
  for (const c of h.calls) c.resolve();
  await flush();
  for (const c of h.calls) {
    c.sub.connecting = false;
    c.hooks.onRegistered({});
  }
  h.manager.apply([entry("b")]);
  await h.advance(DROP_AFTER_MS);
  assertEquals(h.calls[0].sub.closed, 1);
  assertEquals(h.calls[1].sub.closed, 0);
  assertEquals(h.statuses.at(-1).map((e) => [e.host, e.state]), [["a", "closed"], ["b", "registered"]]);
  assertEquals(h.manager.status().map((e) => e.host), ["b"]);
  // A stopped subscriber's own close event does not revive the entry.
  h.calls[0].hooks.onClose({ code: 1000, reason: "" });
  assertEquals(h.manager.status().map((e) => e.host), ["b"]);
  // Listed again: a fresh subscriber.
  h.manager.apply([entry("a"), entry("b")]);
  assertEquals(h.calls.length, 3);
});

Deno.test("a connecting socket is never closed by a list update", async () => {
  const h = harness();
  h.manager.apply([entry("a")]);
  h.manager.apply([]);
  // register() still in flight past the drop delay.
  await h.advance(DROP_AFTER_MS * 3);
  assertEquals(h.state("a"), "connecting");
  h.calls[0].resolve();
  await flush();
  // Socket created but still CONNECTING.
  await h.advance(DROP_AFTER_MS);
  assertEquals(h.calls[0].sub.closed, 0);
  h.calls[0].sub.connecting = false;
  h.calls[0].hooks.onRegistered({});
  await h.advance(1_000);
  assertEquals(h.calls[0].sub.closed, 1);
  assertEquals(h.manager.status(), []);
  assertEquals(h.calls.length, 1);
});

Deno.test("a failed first registration retries with backoff, one timer at a time", async () => {
  const h = harness();
  h.manager.apply([entry("a")]);
  h.calls[0].reject(new Error("nonce request failed: 502"));
  await flush();
  assertEquals(h.state("a"), "reconnecting");
  assertEquals(h.manager.status()[0].lastError, "nonce request failed: 502");
  h.manager.apply([entry("a")]);
  assertEquals(h.timers().length, 1);
  await h.advance(999);
  assertEquals(h.calls.length, 1);
  await h.advance(1);
  assertEquals(h.calls.length, 2);
  h.calls[1].reject(new Error("again"));
  await flush();
  await h.advance(1_999);
  assertEquals(h.calls.length, 2);
  await h.advance(1);
  assertEquals(h.calls.length, 3);
  h.calls[2].resolve();
  await flush();
  h.calls[2].sub.connecting = false;
  h.calls[2].hooks.onRegistered({});
  assertEquals(h.state("a"), "registered");
  assertEquals(h.timers().length, 0);
});

Deno.test("retry backoff caps at 30s and a dropped host stops retrying", async () => {
  const h = harness();
  h.manager.apply([entry("a")]);
  for (let i = 0; i < 7; i++) {
    h.calls.at(-1).reject(new Error("down"));
    await flush();
    await h.advance(Math.min(1_000 * 2 ** i, 30_000));
    assertEquals(h.calls.length, i + 2);
  }
  h.calls.at(-1).reject(new Error("down"));
  await flush();
  h.manager.apply([]);
  await h.advance(DROP_AFTER_MS);
  assertEquals(h.manager.status(), []);
  await h.advance(60_000);
  assertEquals(h.calls.length, 8);
});

// End to end against a local fake relay, wired the way kcp_worker.js wires
// the manager to ingress_ws.js register.
Deno.test("fake relay: register, keepalive 204, request frames, reconnect with fresh tokens", async () => {
  const { register, frame, parseFrame, KEEPALIVE_PATH } = await import("./ingress_ws.js");
  const sockets = [];
  const authHeaders = [];
  const subscribeTokens = [];
  const responses = [];
  let open = 0;
  let maxOpen = 0;
  const server = Deno.serve({ hostname: "127.0.0.1", port: 0, onListen() {} }, (req) => {
    const url = new URL(req.url);
    if (url.pathname.endsWith("getRegistrationNonce")) {
      authHeaders.push(req.headers.get("authorization"));
      return Response.json({ nonce: btoa("nonce") });
    }
    const { socket, response } = Deno.upgradeWebSocket(req);
    subscribeTokens.push(url.searchParams.get("service_auth"));
    socket.onopen = () => {
      open++;
      maxOpen = Math.max(maxOpen, open);
      sockets.push(socket);
      socket.send(frame("registered", { subdomain: "abc" }));
      socket.send(frame("request", { requestId: "k", method: "GET", path: KEEPALIVE_PATH }));
      socket.send(frame("request", { requestId: "b", method: "POST", path: "/xrpc/submitBid", body: { bid: 1 } }));
    };
    socket.onmessage = (e) => responses.push(parseFrame(e.data));
    socket.onclose = () => open--;
    return response;
  });
  const proxyHost = `http://127.0.0.1:${server.addr.port}`;
  let tokens = 0;
  const statuses = [];
  const handled = [];
  const manager = createIngressManager({
    onStatus: (entries) => statuses.push(entries.map((e) => e.state).join(",")),
    connect: (entry, hooks) =>
      register({
        proxyHost: entry.proxyHost,
        did: entry.did,
        getServiceAuthToken: async (nsid) => `token-${++tokens}-${nsid.split(".").pop()}`,
        signer: async (nonce) => nonce,
        handler: async (req) => {
          handled.push(req.path);
          return { status: 200, body: JSON.stringify({ ok: true }), contentType: "application/json" };
        },
        ...hooks,
      }),
  });
  const waitFor = async (cond) => {
    for (let i = 0; i < 400 && !cond(); i++) await new Promise((r) => setTimeout(r, 10));
    if (!cond()) throw new Error("timed out");
  };
  try {
    const e = { name: "req", host: "h", url: "https://h", did: "did:key:z", proxyHost };
    manager.apply([e]);
    manager.apply([e]);
    await waitFor(() => responses.length >= 2);
    assertEquals(manager.status()[0].state, "registered");
    assertEquals(responses.find((r) => r.requestId === "k").status, 204);
    assertEquals(responses.find((r) => r.requestId === "b").status, 200);
    assertEquals(handled, ["/xrpc/submitBid"]);
    sockets[0].close(1011, "relay restart");
    await waitFor(() => responses.length >= 4);
    assertEquals(manager.status()[0].state, "registered");
    assertEquals(subscribeTokens.length, 2);
    assertEquals(new Set([...authHeaders, ...subscribeTokens]).size, 4);
    assertEquals(maxOpen, 1);
    assertEquals(statuses, ["connecting", "registered", "reconnecting", "registered"]);
  } finally {
    manager.apply([]);
    for (const s of sockets) s.close();
    await server.shutdown();
  }
});

Deno.test("an Exposure not served yet is a quiet wait with a fixed 2s retry", async () => {
  const h = harness();
  h.manager.apply([entry("a")]);
  for (let i = 0; i < 4; i++) {
    h.calls.at(-1).reject(new Error('exposure: no ingress Exposure serves "a.example"'));
    await flush();
    assertEquals(h.state("a"), "waiting");
    await h.advance(2_000);
    assertEquals(h.calls.length, i + 2);
  }
  h.calls.at(-1).resolve();
  await flush();
  h.calls.at(-1).sub.connecting = false;
  h.calls.at(-1).hooks.onRegistered({});
  assertEquals(h.state("a"), "registered");
});