geniejars 0.2.7

package/src/server.mjs

@@ -0,0 +1,262 @@
+// Shell server — runs as the manager, manages geniejars agent lifecycle.
+// Started by `geniejars sys up`, stopped by `geniejars sys down`.
+//
+// Protocol (newline-delimited JSON):
+//   ensure <name>  — guarantee agent is up and healthy, respond when ready
+//   status         — list running agents
+//   shutdown       — graceful full teardown
+
+import net from 'net'
+import { spawn } from 'child_process'
+import fs from 'fs/promises'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import { loadConfig, allNames, readState } from './pool.mjs'
+import { stopProcess } from './run.mjs'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const agentScript = path.resolve(__dirname, 'agent.mjs')
+
+const config = await loadConfig()
+const serverSockPath = path.join(config.socketDir, 'server.sock')
+const shutdownGraceMs = config.shutdownGraceMs ?? 10000
+
+// name -> { pid }
+const agents = new Map()
+
+// Per-name ensure serialization: name -> Promise (chain)
+const ensureLocks = new Map()
+
+function sleep(ms) { return new Promise(r => setTimeout(r, ms)) }
+
+function isRunning(pid) {
+  try { process.kill(pid, 0); return true } catch { return false }
+}
+
+function agentSockPath(name) {
+  return path.join(config.socketDir, `${name}.sock`)
+}
+
+function agentPidPath(name) {
+  return path.join(config.socketDir, `${name}.pid`)
+}
+
+// Ping a geniejars agent socket — returns true if alive
+async function pingAgent(name) {
+  return new Promise(resolve => {
+    const client = net.createConnection(agentSockPath(name))
+    const timeout = setTimeout(() => { client.destroy(); resolve(false) }, 1000)
+    let buf = ''
+    client.on('connect', () => { client.write(JSON.stringify({ type: 'status' }) + '\n') })
+    client.on('data', chunk => {
+      buf += chunk.toString()
+      if (buf.includes('\n')) {
+        try {
+          const msg = JSON.parse(buf.split('\n')[0].trim())
+          if (msg.type === 'status') { clearTimeout(timeout); client.destroy(); resolve(true) }
+        } catch {}
+      }
+    })
+    client.on('error', () => { clearTimeout(timeout); resolve(false) })
+    client.on('close', () => { clearTimeout(timeout); resolve(false) })
+  })
+}
+
+// Spawn a geniejars agent and wait until its socket is ready
+async function spawnAgent(name) {
+  return new Promise(resolve => {
+    const child = spawn('sudo', ['-u', name, '-H', config.nodePath, agentScript, name], {
+      detached: true,
+      stdio: ['ignore', 'ignore', 'pipe'],
+    })
+    let errOutput = ''
+    child.stderr.on('data', d => { errOutput += d.toString() })
+
+    const timer = setTimeout(async () => {
+      if (!isRunning(child.pid)) {
+        resolve({ ok: false, error: errOutput.trim() || 'process exited immediately' })
+        return
+      }
+      // Poll until socket responds (up to 3s)
+      for (let i = 0; i < 10; i++) {
+        await sleep(300)
+        if (await pingAgent(name)) {
+          child.stderr.destroy()
+          child.unref()
+          await fs.writeFile(agentPidPath(name), String(child.pid))
+          resolve({ ok: true, pid: child.pid })
+          return
+        }
+      }
+      resolve({ ok: false, error: 'agent started but socket not ready' })
+    }, 300)
+
+    child.on('exit', code => {
+      clearTimeout(timer)
+      resolve({ ok: false, error: errOutput.trim() || `exited with code ${code}` })
+    })
+  })
+}
+
+// Ensure agent is up — serialized per name
+async function ensureAgent(name) {
+  const prev = ensureLocks.get(name) ?? Promise.resolve()
+  const promise = prev.catch(() => {}).then(async () => {
+    // Check existing entry
+    const entry = agents.get(name)
+    if (entry && isRunning(entry.pid) && await pingAgent(name)) return  // healthy
+
+    // Stale — clean up and respawn
+    agents.delete(name)
+    await fs.unlink(agentSockPath(name)).catch(() => {})
+
+    const result = await spawnAgent(name)
+    if (!result.ok) throw new Error(`Failed to start agent for ${name}: ${result.error}`)
+    agents.set(name, { pid: result.pid })
+  }).finally(() => {
+    if (ensureLocks.get(name) === promise) ensureLocks.delete(name)
+  })
+  ensureLocks.set(name, promise)
+  await promise
+}
+
+// On startup: probe all geniejars sockets and rebuild agent map
+async function reconcile() {
+  const names = allNames(config)
+  await Promise.all(names.map(async name => {
+    if (await pingAgent(name)) {
+      try {
+        const pid = parseInt(await fs.readFile(agentPidPath(name), 'utf8'), 10)
+        agents.set(name, { pid })
+        console.log(`[server] ${name}: already running (pid ${pid})`)
+      } catch {
+        agents.set(name, { pid: -1 })
+        console.log(`[server] ${name}: already running (no pid file)`)
+      }
+    } else {
+      await fs.unlink(agentSockPath(name)).catch(() => {})
+    }
+  }))
+}
+
+// Graceful full teardown
+async function shutdown() {
+  console.log('[server] shutting down...')
+
+  // 1. Stop all running CMDs
+  const state = await readState(config)
+  await Promise.all(allNames(config).map(async name => {
+    if (state.pool[name]?.status !== 'occupied') return
+    try { await stopProcess(config, name) } catch {}
+  }))
+
+  // 2. SIGTERM all agents
+  for (const [, { pid }] of agents) {
+    if (isRunning(pid)) {
+      try { process.kill(pid, 'SIGTERM') } catch {}
+    }
+  }
+
+  // 3. Wait grace period, then SIGKILL stragglers
+  const deadline = Date.now() + shutdownGraceMs
+  while (Date.now() < deadline) {
+    const anyRunning = [...agents.values()].some(({ pid }) => isRunning(pid))
+    if (!anyRunning) break
+    await sleep(200)
+  }
+  for (const [, { pid }] of agents) {
+    if (isRunning(pid)) {
+      try { process.kill(pid, 'SIGKILL') } catch {}
+    }
+  }
+
+  // 4. Clean up and exit
+  server.close()
+  await fs.unlink(serverSockPath).catch(() => {})
+  console.log('[server] done')
+  process.exit(0)
+}
+
+// Request handler
+function send(socket, obj) {
+  if (!socket.destroyed) socket.write(JSON.stringify(obj) + '\n')
+}
+
+function handleConnection(socket) {
+  let buf = ''
+  socket.on('data', chunk => {
+    buf += chunk.toString()
+    let nl
+    while ((nl = buf.indexOf('\n')) !== -1) {
+      const line = buf.slice(0, nl).trim()
+      buf = buf.slice(nl + 1)
+      if (!line) continue
+      let req
+      try { req = JSON.parse(line) } catch {
+        send(socket, { type: 'error', message: 'Invalid JSON' })
+        socket.end()
+        return
+      }
+      handleRequest(req, socket)
+    }
+  })
+  socket.on('error', () => {})
+}
+
+async function handleRequest(req, socket) {
+  switch (req.type) {
+
+    case 'ensure': {
+      if (!req.name) { send(socket, { type: 'error', message: 'ensure requires name' }); socket.end(); return }
+      try {
+        await ensureAgent(req.name)
+        send(socket, { type: 'ready' })
+      } catch (err) {
+        send(socket, { type: 'error', message: err.message })
+      }
+      socket.end()
+      break
+    }
+
+    case 'status': {
+      const running = []
+      for (const [name, { pid }] of agents) {
+        if (isRunning(pid)) running.push({ name, pid })
+        else agents.delete(name)
+      }
+      send(socket, { type: 'status', agents: running })
+      socket.end()
+      break
+    }
+
+    case 'shutdown': {
+      send(socket, { type: 'ok' })
+      socket.end()
+      setImmediate(() => shutdown())
+      break
+    }
+
+    default: {
+      send(socket, { type: 'error', message: `Unknown request: ${req.type}` })
+      socket.end()
+    }
+  }
+}
+
+// Start
+await fs.mkdir(config.socketDir, { recursive: true })
+await fs.unlink(serverSockPath).catch(() => {})
+await reconcile()
+
+const server = net.createServer(handleConnection)
+server.listen(serverSockPath, async () => {
+  await fs.chmod(serverSockPath, 0o660)
+  console.log(`[server] listening on ${serverSockPath}`)
+})
+
+server.on('error', err => {
+  console.error('[server] error:', err.message)
+  process.exit(1)
+})
+
+process.on('SIGTERM', () => shutdown())