Function main

script/computerd-soak.mjs:259–386

()

}

async function main() {
  if (!DISABLE_FUSE) await ensureImage();

  process.stderr.write("booting A (sink) ...\n");
  const a = await bootContainer();
  process.stderr.write(`  A: ${a.url} (${a.cid.slice(0, 12)})\n`);

  process.stderr.write("booting B (source, UPSTREAM_URL -> A) ...\n");
  // B's sync loop will push to A. Hostname inside docker:
  // we can't reach the host's 127.0.0.1 portably; use
  // host.docker.internal which docker-desktop sets up on
  // macOS/Windows. On linux we'd need --add-host=host.docker.internal:host-gateway.
  // Inside a docker container we reach the host's mapped
  // port via host.docker.internal. The capnweb client needs
  // a ws:// URL pointing at the /ws endpoint (not just the
  // host).
  const upstreamForB = `${a.url.replace("http://127.0.0.1", "ws://host.docker.internal")}/ws`;
  // Inside the docker container, the host port we're trying
  // to reach is 127.0.0.1:<a.port> on the host. Pass the
  // mapped host port via host.docker.internal.
  const b = await bootContainer({
    UPSTREAM_URL: upstreamForB,
  });
  process.stderr.write(`  B: ${b.url} (${b.cid.slice(0, 12)}) -> upstream ${upstreamForB}\n`);

  // Header row.
  console.log(
    "t_ms\tA_currentRev\tA_pushRev\tA_fetchRev\tB_currentRev\tB_pushRev\tB_fetchRev\tA_mem\tB_mem\twrites_sent",
  );

  const start = Date.now();
  const stopAt = start + DURATION_MS;
  const intervalMs = Math.max(1, Math.floor(1000 / WRITES_PER_S));
  let writeSeq = 0;
  let writesSent = 0;
  let writesInFlight = 0;

  // Writes go through B's SyncRPC /ws push path with
  // senderRev=0. The server treats them as local writes;
  // B's outbound sync loop ships them to A on the next
  // tick. This is the path an external orchestrator (a
  // DO accepting agent requests, the agent itself) would
  // take — the same wire surface a computerd-to-computerd peer
  // uses, just with a different senderRev value.
  const writeStub = wsStub(b.url);

  // Fire-and-forget write loop. We don't await every write
  // because the goal is to saturate; we cap the in-flight
  // count to keep memory bounded.
  const MAX_INFLIGHT = 32;
  const writeLoop = (async () => {
    while (Date.now() < stopAt) {
      if (writesInFlight >= MAX_INFLIGHT) {
        await new Promise((r) => setTimeout(r, 1));
        continue;
      }
      const i = writeSeq++;
      writesInFlight++;