grix-connector 4.9.2 → 4.9.3

package/scripts/launcher.mjs

@@ -15,15 +15,23 @@
 //     崩溃时间戳落在 `<store>/crashes.json`，launcher 自身被重拉也不会把计数归零。
 // 收到 SIGTERM/SIGINT/SIGHUP 时转发给子进程并随其退出（服务停止语义）。
 //
+// 同一个 store 只允许一个 launcher：启动时抢 store 级单例锁，抢不到就退出，
+// 避免两个 launcher 各自拉起一个 daemon、把对方的 daemon 记成崩溃、再用共享的
+// crashes.json 叠加计数，几秒内把健康版本"三振出局"回滚掉。
+//
 // 本文件由 daemon 在启动时按 LAUNCHER_TEMPLATE_VERSION 比对并原子重写，改动行为时必须 +1。
-export const LAUNCHER_TEMPLATE_VERSION = 2;
+export const LAUNCHER_TEMPLATE_VERSION = 3;
 
 import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
 import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync, appendFileSync } from 'node:fs';
+import { connect, createServer } from 'node:net';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const RESTART_EXIT_CODE = 75;
+const LOCK_RETRY_ATTEMPTS = 20;
+const LOCK_RETRY_INTERVAL_MS = 250;
 const RAPID_CRASH_WINDOW_MS = 5 * 60 * 1000;
 const RAPID_CRASH_LIMIT = 3;
 const MAX_BACKOFF_MS = 30_000;
@@ -35,6 +43,79 @@ function resolveStoreDir() {
   return dirname(real);
 }
 
+/**
+ * store 级单例锁的端点。Windows 用命名管道（进程消失即随之消失，不留残留）；
+ * POSIX 用 store 里的 unix socket 文件——端口派生会和机器上无关服务撞车，
+ * 一旦撞上 launcher 就永远起不来，socket 路径没有这个风险。
+ */
+function launcherLockEndpoint(store, platform = process.platform) {
+  if (platform === 'win32') {
+    const digest = createHash('sha256').update(store).digest('hex');
+    return `\\\\.\\pipe\\grix-launcher-${digest.slice(0, 24)}`;
+  }
+  return join(store, 'launcher.lock.sock');
+}
+
+function listenOnce(server, endpoint) {
+  return new Promise((resolve, reject) => {
+    const onError = (error) => {
+      if (error?.code === 'EADDRINUSE' || error?.code === 'EACCES') resolve(error.code);
+      else reject(error);
+    };
+    server.once('error', onError);
+    server.once('listening', () => {
+      server.removeListener('error', onError);
+      server.on('error', () => { /* 锁只需活到进程结束，后续错误无需处理 */ });
+      // 锁只用监听端点本身表态，探活连上来就断掉，别攒着不放。
+      server.on('connection', (socket) => socket.destroy());
+      resolve(null);
+    });
+    server.listen(endpoint);
+  });
+}
+
+/** unix socket 文件在 launcher 被强杀后会留下，连得上才说明真有 launcher 在跑。 */
+function isEndpointAlive(endpoint) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const socket = connect(endpoint);
+    const done = (alive) => {
+      if (settled) return;
+      settled = true;
+      try { socket.destroy(); } catch { /* already gone */ }
+      resolve(alive);
+    };
+    socket.once('connect', () => done(true));
+    socket.once('error', () => done(false));
+    setTimeout(() => done(false), 1000).unref?.();
+  });
+}
+
+/**
+ * 抢 store 级单例锁。拿到返回持锁的 server（进程退出时由系统释放），
+ * 已被别的 launcher 持有返回 null。
+ *
+ * 锁机制本身出错（既不是占用也不是权限）时向上抛：调用方按放行处理——
+ * launcher 起不来比偶尔多一个 launcher 严重得多。
+ */
+export async function acquireLauncherStoreLock(store, deps = {}) {
+  const endpoint = deps.lockEndpoint ?? launcherLockEndpoint(store, deps.platform);
+  const create = deps.createServer ?? createServer;
+  const isSocketPath = typeof endpoint === 'string' && !endpoint.startsWith('\\\\');
+  let server = create();
+  let blocked = await listenOnce(server, endpoint);
+  if (blocked && isSocketPath) {
+    if (await isEndpointAlive(endpoint)) return null;
+    // 空壳 socket：上一轮 launcher 被强杀留下的，删掉再抢一次。
+    try { rmSync(endpoint, { force: true }); } catch { return null; }
+    server = create();
+    blocked = await listenOnce(server, endpoint);
+  }
+  if (blocked) return null;
+  server.unref?.();
+  return server;
+}
+
 function readPointer(store, name) {
   try {
     const value = readFileSync(join(store, name), 'utf8').trim();
@@ -183,6 +264,27 @@ async function main() {
   const store = resolveStoreDir();
   const args = process.argv.slice(2);
   mkdirSync(join(store, 'health'), { recursive: true });
+
+  // 升级交接时新旧 launcher 会短暂重叠，退几拍再判定，别把交接当成重复实例。
+  let storeLock = null;
+  let lockError = null;
+  for (let attempt = 0; attempt < LOCK_RETRY_ATTEMPTS && !storeLock; attempt++) {
+    try {
+      storeLock = await acquireLauncherStoreLock(store);
+    } catch (error) {
+      lockError = error;
+      break;
+    }
+    if (!storeLock) await sleep(LOCK_RETRY_INTERVAL_MS);
+  }
+  if (lockError) {
+    log(store, `store lock unavailable (${lockError instanceof Error ? lockError.message : lockError}); continuing without it`);
+  } else if (!storeLock) {
+    // 退出码 0：supervisor 见 0 不会当成崩溃，也不会去动 crashes.json。
+    log(store, 'another launcher already holds this store; exiting without starting a daemon');
+    process.exit(0);
+  }
+
   let backoffMs = 1000;
   log(store, `started node=${process.version} store=${store} template=${LAUNCHER_TEMPLATE_VERSION}`);