バックグラウンドから戻ったWebSocketのOPENは、確かめるまで主張にすぎない

// What does a server see when the client process is frozen (SIGSTOP) but its kernel and network are fine?
// Linux stand-in for "the OS suspended the app". Run: node freeze_lab.mjs
import { WebSocketServer } from "ws";
import { spawn } from "node:child_process";

const t0 = Date.now(); const at = () => `[${((Date.now() - t0) / 1000).toFixed(1).padStart(4)}s]`;
const wss = new WebSocketServer({ port: 0 });
await new Promise((r) => wss.on("listening", r));
const port = wss.address().port;

const client = spawn(process.execPath, ["-e", `
  const WebSocket = require("ws"); let n = 0;
  const ws = new WebSocket("ws://127.0.0.1:${port}");
  ws.on("message", () => n++);
  ws.on("close", (c) => { console.log("client: close event, code " + c + ", messages seen: " + n); process.exit(0); });
  ws.on("error", (e) => console.log("client: error " + e.code));
`], { stdio: "inherit", cwd: process.cwd() });

wss.on("connection", (ws) => {
  let seq = 0, lastPong = Date.now(), sent = 0, acked = 0;
  ws.on("pong", () => { lastPong = Date.now(); });
  const tick = setInterval(() => {
    ws.send(`m${++seq}`, () => acked++);               // callback = handed to the kernel
    sent++;
    ws.ping();
    const quiet = Date.now() - lastPong;
    if (seq % 2 === 0) console.log(`${at()} server: sent=${sent} handed-to-kernel=${acked} bufferedAmount=${ws.bufferedAmount} quiet-for=${quiet} ms readyState=${ws.readyState}`);
    if (quiet > 3000) {
      console.log(`${at()} server: no pong for ${quiet} ms -> declare the client gone, terminate()`);
      clearInterval(tick); ws.terminate();
    }
  }, 500);
  ws.on("close", () => console.log(`${at()} server: close event`));
});

setTimeout(() => { console.log(`${at()} >>> SIGSTOP the client process`); client.kill("SIGSTOP"); }, 2000);
setTimeout(() => { console.log(`${at()} >>> SIGCONT the client process`); client.kill("SIGCONT"); }, 9000);
setTimeout(() => process.exit(0), 11000);

[ 1.2s] server: sent=2 handed-to-kernel=1 bufferedAmount=0 quiet-for=497 ms readyState=1
[ 2.0s] >>> SIGSTOP the client process
[ 2.2s] server: sent=4 handed-to-kernel=3 bufferedAmount=0 quiet-for=501 ms readyState=1
[ 3.2s] server: sent=6 handed-to-kernel=5 bufferedAmount=0 quiet-for=1503 ms readyState=1
[ 4.2s] server: sent=8 handed-to-kernel=7 bufferedAmount=0 quiet-for=2504 ms readyState=1
[ 4.7s] server: no pong for 3004 ms -> declare the client gone, terminate()
[ 4.7s] server: close event
[ 9.0s] >>> SIGCONT the client process
client: close event, code 1006, messages seen: 9

// On "active": do not trust readyState. Prove the socket is alive, otherwise rebuild it and catch up.
export function keepFresh({ lifecycle, connect, catchUp, probeMs = 2000, log = () => {} }) {
  let socket = null, busy = null;

  const probe = (ws) => new Promise((resolve) => {          // a round trip that the peer *application* must answer
    if (!ws || ws.readyState !== 1) return resolve(false);
    const done = (ok) => { clearTimeout(timer); ws.removeEventListener("message", onMessage); resolve(ok); };
    const onMessage = (e) => { if (e.data === "pong") done(true); };
    const timer = setTimeout(() => done(false), probeMs);
    ws.addEventListener("message", onMessage);
    try { ws.send("ping"); } catch { done(false); }
  });

  async function ensure(reason) {
    if (busy) return busy;                                   // "active" can fire repeatedly
    return (busy = (async () => {
      if (await probe(socket)) { log(`${reason}: socket proved alive, nothing to do`); return; }
      log(`${reason}: socket is ${socket ? "readyState " + socket.readyState : "missing"} or silent -> rebuild`);
      try { socket?.close(); } catch {}
      socket = await connect();
      await catchUp();                                       // whatever was missed while we were away
    })().finally(() => { busy = null; }));
  }

  lifecycle.addEventListener("change", (state) => { if (state === "active") ensure("foreground"); });
  return { start: () => ensure("start"), get socket() { return socket; } };
}

import { WebSocketServer, WebSocket } from "ws";
import { EventEmitter } from "node:events";
import { keepFresh } from "./keep_fresh.mjs";
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

const wss = new WebSocketServer({ port: 0 }); await new Promise((r) => wss.on("listening", r));
const serverSide = [];
wss.on("connection", (ws) => { serverSide.push(ws); ws.on("message", (m) => { if (m.toString() === "ping") ws.send("pong"); }); });
const url = `ws://127.0.0.1:${wss.address().port}`;

class FakeAppState extends EventEmitter { addEventListener(t, f) { this.on(t, f); } }   // same shape as React Native's AppState.addEventListener
const lifecycle = new FakeAppState();
let catchUps = 0, connects = 0;
const t0 = Date.now(); const log = (m) => console.log(`[${String(Date.now() - t0).padStart(5)} ms] ${m}`);
const app = keepFresh({
  lifecycle, log, probeMs: 500,
  connect: async () => { connects++; const c = new WebSocket(url); await new Promise((r) => c.on("open", r)); c.on("error", () => {}); return c; },
  catchUp: async () => { catchUps++; },
});
await app.start(); await sleep(100);
log(`connects=${connects} catchUps=${catchUps}`);

log("--- case 1: app goes background and comes back; connection is fine");
lifecycle.emit("change", "background"); await sleep(100); lifecycle.emit("change", "active"); await sleep(300);
log(`connects=${connects} catchUps=${catchUps}`);

log("--- case 2: the connection silently died while we were away (server stops reading, so no pong)");
serverSide.at(-1)._socket.pause();
log(`client still thinks: readyState=${app.socket.readyState} (1 = OPEN)`);
lifecycle.emit("change", "active"); await sleep(900);
log(`connects=${connects} catchUps=${catchUps}`);

log("--- case 3: the server closed it while we were away");
serverSide.at(-1).terminate(); await sleep(100);
lifecycle.emit("change", "active"); await sleep(300);
log(`connects=${connects} catchUps=${catchUps}`);

log("--- case 4: three 'active' events in a row");
lifecycle.emit("change", "active"); lifecycle.emit("change", "active"); lifecycle.emit("change", "active"); await sleep(300);
log(`connects=${connects} catchUps=${catchUps}`);
process.exit(0);

[    0 ms] start: socket is missing or silent -> rebuild
[  113 ms] connects=1 catchUps=1
[  113 ms] --- case 1: app goes background and comes back; connection is fine
[  217 ms] foreground: socket proved alive, nothing to do
[  516 ms] connects=1 catchUps=1
[  516 ms] --- case 2: the connection silently died while we were away (server stops reading, so no pong)
[  517 ms] client still thinks: readyState=1 (1 = OPEN)
[ 1017 ms] foreground: socket is readyState 1 or silent -> rebuild
[ 1418 ms] connects=2 catchUps=2
[ 1419 ms] --- case 3: the server closed it while we were away
[ 1520 ms] foreground: socket is readyState 3 or silent -> rebuild
[ 1821 ms] connects=3 catchUps=3
[ 1822 ms] --- case 4: three 'active' events in a row
[ 1822 ms] foreground: socket proved alive, nothing to do
[ 2122 ms] connects=3 catchUps=3