spoint 0.1.588 → 0.1.589

package/bin/room-orchestrator-boot.js

@@ -35,7 +35,7 @@ import { existsSync } from 'node:fs'
 import { join, dirname } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { createServer as createHttpServer } from 'node:http'
-import { RoomOrchestrator } from '../src/sdk/RoomOrchestrator.js'
+import { RoomOrchestrator, readJsonBody } from '../src/sdk/RoomOrchestrator.js'
 import { assertNodeModulesLinked } from '../src/sdk/server.js'
 
 const SDK_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..')
@@ -130,6 +130,41 @@ async function main() {
         res.end(JSON.stringify({ roomId, stopped }))
         return
       }
+      if (req.method === 'POST' && url.pathname === '/workers/register') {
+        const body = await readJsonBody(req)
+        if (!body || !body.host) { res.writeHead(400, { 'Content-Type': 'application/json' }); res.end(JSON.stringify({ error: 'host field required' })); return }
+        try {
+          const result = await orchestrator.registerWorker({ host: body.host, portRange: body.portRange, commandPort: body.commandPort })
+          res.writeHead(201, { 'Content-Type': 'application/json' })
+          res.end(JSON.stringify(result))
+        } catch (e) {
+          res.writeHead(409, { 'Content-Type': 'application/json' })
+          res.end(JSON.stringify({ error: e?.message || String(e) }))
+        }
+        return
+      }
+      if (req.method === 'DELETE' && url.pathname.match(/^\/workers\/(\d+)$/)) {
+        const wm = url.pathname.match(/^\/workers\/(\d+)$/)
+        const ok = await orchestrator.deregisterWorker(parseInt(wm[1], 10))
+        res.writeHead(ok ? 200 : 404, { 'Content-Type': 'application/json' })
+        res.end(JSON.stringify({ deregistered: ok }))
+        return
+      }
+      if (url.pathname === '/workers') {
+        const list = []
+        for (let i = 0; i < orchestrator.workers.length; i++) {
+          const w = orchestrator.workers[i]
+          if (w) list.push({ workerIndex: i, host: w.host, ready: w.ready, isExternal: w.isExternal, roomCount: w.roomIds.size })
+        }
+        res.writeHead(200, { 'Content-Type': 'application/json' })
+        res.end(JSON.stringify(list))
+        return
+      }
+      if (url.pathname === '/crash-stats') {
+        res.writeHead(200, { 'Content-Type': 'application/json' })
+        res.end(JSON.stringify(orchestrator.getCrashStats()))
+        return
+      }
       if (url.pathname === '/elastic-stats') {
         const stats = orchestrator.getElasticStats()
         res.writeHead(200, { 'Content-Type': 'application/json' })

package/bin/room-worker-boot.js

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+import { existsSync } from 'node:fs'
+import { join, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { createServer as createHttpServer, request as httpRequest } from 'node:http'
+import { request as httpsRequest } from 'node:https'
+import { RoomDirectory } from '../src/sdk/RoomDirectory.js'
+import { assertNodeModulesLinked } from '../src/sdk/server.js'
+
+const SDK_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..')
+
+function readJsonBody(req) {
+  return new Promise((resolve) => {
+    let buf = ''
+    req.on('data', (chunk) => { buf += chunk })
+    req.on('end', () => { try { resolve(JSON.parse(buf)) } catch (_) { resolve(null) } })
+    req.on('error', () => resolve(null))
+  })
+}
+
+function httpPostJson(url, body) {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify(body)
+    const requestFn = url.startsWith('https') ? httpsRequest : httpRequest
+    const req = requestFn(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data) },
+    }, (res) => {
+      let buf = ''
+      res.on('data', (c) => { buf += c })
+      res.on('end', () => {
+        try { resolve({ status: res.statusCode, body: JSON.parse(buf) }) } catch (e) { reject(e) }
+      })
+    })
+    req.on('error', reject)
+    req.write(data)
+    req.end()
+  })
+}
+
+function httpDelete(url) {
+  return new Promise((resolve, reject) => {
+    const requestFn = url.startsWith('https') ? httpsRequest : httpRequest
+    const req = requestFn(url, { method: 'DELETE' }, (res) => {
+      let buf = ''
+      res.on('data', (c) => { buf += c })
+      res.on('end', () => { try { resolve({ status: res.statusCode, body: JSON.parse(buf) }) } catch (e) { resolve({ status: res.statusCode, body: null }) } })
+    })
+    req.on('error', reject)
+    req.end()
+  })
+}
+
+async function main() {
+  assertNodeModulesLinked(SDK_ROOT)
+  const PROJECT = process.cwd()
+  const orchestratorUrl = process.env.ORCHESTRATOR_URL || 'http://localhost:3400'
+  const workerHost = process.env.WORKER_HOST || '127.0.0.1'
+  const workerCommandPort = parseInt(process.env.WORKER_COMMAND_PORT || '0', 10)
+  const portRangeMin = parseInt(process.env.ROOM_PORT_MIN || '19100', 10)
+  const portRangeMax = parseInt(process.env.ROOM_PORT_MAX || '19199', 10)
+
+  const directory = new RoomDirectory({
+    sdkRoot: SDK_ROOT,
+    projectRoot: existsSync(join(PROJECT, 'apps')) ? PROJECT : SDK_ROOT,
+    portRange: [portRangeMin, portRangeMax],
+  })
+
+  const commandServer = createHttpServer(async (req, res) => {
+    try {
+      const url = new URL(req.url, 'http://localhost')
+      if (req.method === 'POST' && url.pathname === '/rooms') {
+        const body = await readJsonBody(req)
+        if (!body || !body.roomId) { res.writeHead(400, { 'Content-Type': 'application/json' }); res.end(JSON.stringify({ error: 'roomId required' })); return }
+        try {
+          const handle = await directory.createRoom(body.roomId, body.worldName || 'tps-game', body.opts || {})
+          res.writeHead(201, { 'Content-Type': 'application/json' })
+          res.end(JSON.stringify({ roomId: body.roomId, port: handle.port, worldName: handle.worldName }))
+        } catch (e) {
+          res.writeHead(409, { 'Content-Type': 'application/json' })
+          res.end(JSON.stringify({ error: e?.message || String(e) }))
+        }
+        return
+      }
+      if (req.method === 'DELETE' && url.pathname.startsWith('/rooms/')) {
+        const roomId = decodeURIComponent(url.pathname.slice('/rooms/'.length))
+        const stopped = await directory.stopRoom(roomId)
+        res.writeHead(200, { 'Content-Type': 'application/json' })
+        res.end(JSON.stringify({ roomId, stopped }))
+        return
+      }
+      if (url.pathname === '/status') {
+        res.writeHead(200, { 'Content-Type': 'application/json' })
+        res.end(JSON.stringify({ rooms: directory.getStatus() }))
+        return
+      }
+      if (req.method === 'POST' && url.pathname === '/shutdown') {
+        res.writeHead(200, { 'Content-Type': 'application/json' })
+        res.end(JSON.stringify({ shuttingDown: true }))
+        await directory.stopAll()
+        process.exit(0)
+        return
+      }
+      res.writeHead(404); res.end('not found')
+    } catch (e) {
+      res.writeHead(500, { 'Content-Type': 'application/json' })
+      res.end(JSON.stringify({ error: e?.message || String(e) }))
+    }
+  })
+
+  const { port: boundCommandPort } = await new Promise((resolve, reject) => {
+    commandServer.once('error', reject)
+    commandServer.listen(workerCommandPort, () => resolve({ port: commandServer.address().port }))
+  })
+
+  console.log(`[room-worker] command server listening on http://${workerHost}:${boundCommandPort}`)
+
+  const registration = await httpPostJson(`${orchestratorUrl}/workers/register`, {
+    host: workerHost,
+    portRange: [portRangeMin, portRangeMax],
+    commandPort: boundCommandPort,
+  })
+
+  if (registration.status !== 201) {
+    console.error(`[room-worker] registration failed: ${JSON.stringify(registration.body)}`)
+    process.exit(1)
+  }
+
+  const workerIndex = registration.body.workerIndex
+  console.log(`[room-worker] registered as worker ${workerIndex} with orchestrator at ${orchestratorUrl}`)
+
+  const shutdown = async (signal) => {
+    console.log(`[room-worker] received ${signal}, deregistering and shutting down...`)
+    try { await httpDelete(`${orchestratorUrl}/workers/${workerIndex}`) } catch (_) {}
+    await directory.stopAll()
+    await new Promise((resolve) => commandServer.close(() => resolve()))
+    process.exit(0)
+  }
+  process.on('SIGINT', () => shutdown('SIGINT'))
+  process.on('SIGTERM', () => shutdown('SIGTERM'))
+}
+
+main().catch(err => {
+  console.error('[room-worker] FATAL:', err)
+  process.exit(1)
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spoint",
-  "version": "0.1.588",
+  "version": "0.1.589",
   "description": "Physics and netcode SDK for multiplayer game servers",
   "type": "module",
   "workspaces": [

package/src/sdk/RoomOrchestrator.js

@@ -47,7 +47,8 @@
 import { fork } from 'node:child_process'
 import { fileURLToPath } from 'node:url'
 import { join, dirname } from 'node:path'
-import { createServer as createHttpServer } from 'node:http'
+import { createServer as createHttpServer, request as httpRequest } from 'node:http'
+import { request as httpsRequest } from 'node:https'
 
 const SDK_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..', '..')
 const WORKER_ENTRY = join(SDK_ROOT, 'src', 'sdk', 'RoomProcessWorker.js')
@@ -205,15 +206,15 @@ export class RoomOrchestrator {
    *  for route() lookups -- no child_process is forked, and crash auto-restart does not apply
    *  (the orchestrator cannot fork a process on a different machine).
    *  Returns { workerIndex, host } once registered. */
-  async registerWorker({ host, portRange }) {
+  async registerWorker({ host, portRange, commandPort }) {
     if (!host) throw new Error('registerWorker requires { host }')
     const workerIndex = this._nextWorkerIndex++
     const range = portRange || this._subRangeFor(workerIndex)
     this._workerHosts[workerIndex] = host
-    const entry = { proc: null, ready: true, roomIds: new Set(), host, isExternal: true }
+    const entry = { proc: null, ready: true, roomIds: new Set(), host, isExternal: true, commandPort: commandPort || null }
     this.workers[workerIndex] = entry
     this.workerCount = Math.max(this.workerCount, workerIndex + 1)
-    console.log(`[RoomOrchestrator] registered external worker ${workerIndex} at ${host} (port range ${range[0]}-${range[1]})`)
+    console.log(`[RoomOrchestrator] registered external worker ${workerIndex} at ${host}:${commandPort || '?'} (port range ${range[0]}-${range[1]})`)
     return { workerIndex, host, portRange: range }
   }
 
@@ -384,7 +385,7 @@ export class RoomOrchestrator {
   _send(workerIndex, payload) {
     const entry = this.workers[workerIndex]
     if (!entry || !entry.ready) return Promise.reject(new Error(`RoomOrchestrator: worker ${workerIndex} is not ready`))
-    if (entry.isExternal) return Promise.reject(new Error(`RoomOrchestrator: worker ${workerIndex} is external (no local IPC) -- use HTTP to communicate with it`))
+    if (entry.isExternal) return this._sendExternal(entry, payload)
     const reqId = this._nextReqId++
     return new Promise((resolve, reject) => {
       this._pending.set(reqId, { resolve, reject })
@@ -392,6 +393,45 @@ export class RoomOrchestrator {
     })
   }
 
+  async _sendExternal(entry, payload) {
+    if (!entry.commandPort) throw new Error('RoomOrchestrator: external worker registered without a commandPort -- cannot route commands to it')
+    const base = `http://${entry.host}:${entry.commandPort}`
+    try {
+      if (payload.type === 'CREATE_ROOM') {
+        const res = await httpJsonRequest(`${base}/rooms`, 'POST', { roomId: payload.roomId, worldName: payload.worldName, opts: payload.opts })
+        if (res.status !== 201) throw new Error(res.body?.error || `external worker CREATE_ROOM failed (status ${res.status})`)
+        return { type: 'ROOM_CREATED', roomId: payload.roomId, port: res.body.port, worldName: res.body.worldName }
+      }
+      if (payload.type === 'STOP_ROOM') {
+        const res = await httpJsonRequest(`${base}/rooms/${encodeURIComponent(payload.roomId)}`, 'DELETE')
+        return { type: 'ROOM_STOPPED', roomId: payload.roomId, stopped: !!res.body?.stopped }
+      }
+      if (payload.type === 'GET_STATUS') {
+        const res = await httpJsonRequest(`${base}/status`, 'GET')
+        return { type: 'STATUS', rooms: res.body?.rooms || [] }
+      }
+      if (payload.type === 'SHUTDOWN') {
+        const res = await httpJsonRequest(`${base}/shutdown`, 'POST')
+        return { type: 'SHUTDOWN_DONE' }
+      }
+      throw new Error(`RoomOrchestrator: unsupported external command type ${payload.type}`)
+    } catch (e) {
+      if (e && (e.code === 'ECONNREFUSED' || e.code === 'ECONNRESET' || e.code === 'ETIMEDOUT')) {
+        this._markExternalWorkerDead(entry)
+      }
+      throw e
+    }
+  }
+
+  _markExternalWorkerDead(entry) {
+    if (!entry.ready) return
+    const workerIndex = this.workers.indexOf(entry)
+    console.error(`[RoomOrchestrator] external worker ${workerIndex} (${entry.host}:${entry.commandPort}) unreachable -- marking dead, evicting ${entry.roomIds.size} room(s)`)
+    for (const roomId of entry.roomIds) this.roomToWorker.delete(roomId)
+    entry.roomIds.clear()
+    entry.ready = false
+  }
+
   /** Picks the worker currently hosting the fewest rooms (ties broken by lowest index). Pure room-count fallback -- used when no live per-room status is available yet (e.g. a worker that just came up with zero rooms/zero tick history), and as _pickWeightedWorker's own tie-break when every ready worker's weighted score is identical (all-idle fleet). Skips workers that are currently retiring. */
   _pickLeastLoadedWorker() {
     let best = -1, bestCount = Infinity
@@ -504,7 +544,7 @@ export class RoomOrchestrator {
   /** Directory-wide status: real per-room rows fetched live from every worker (parallel GET_STATUS), flattened -- the shape a Prometheus /metrics `rooms` source (see src/sdk/Metrics.js) can consume directly across an ENTIRE multi-process fleet, not just one process's RoomDirectory. */
   async getStatus() {
     const perWorker = await Promise.all(
-      this.workers.map((w, i) => (w?.ready && !w.isExternal ? this._send(i, { type: 'GET_STATUS' }).then(r => r.rooms).catch(() => []) : Promise.resolve([])))
+      this.workers.map((w, i) => (w?.ready ? this._send(i, { type: 'GET_STATUS' }).then(r => r.rooms).catch(() => []) : Promise.resolve([])))
     )
     return perWorker.flat()
   }
@@ -597,7 +637,7 @@ export class RoomOrchestrator {
 }
 
 /** Reads a JSON body from an IncomingMessage, returning the parsed object or null. */
-function readJsonBody(req) {
+export function readJsonBody(req) {
   return new Promise((resolve) => {
     let buf = ''
     req.on('data', (chunk) => { buf += chunk })
@@ -606,4 +646,22 @@ function readJsonBody(req) {
     })
     req.on('error', () => resolve(null))
   })
+}
+
+function httpJsonRequest(url, method, body) {
+  return new Promise((resolve, reject) => {
+    const requestFn = url.startsWith('https') ? httpsRequest : httpRequest
+    const data = body !== undefined ? JSON.stringify(body) : null
+    const headers = data ? { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data) } : {}
+    const req = requestFn(url, { method, headers }, (res) => {
+      let buf = ''
+      res.on('data', (c) => { buf += c })
+      res.on('end', () => {
+        try { resolve({ status: res.statusCode, body: buf ? JSON.parse(buf) : null }) } catch (e) { reject(e) }
+      })
+    })
+    req.on('error', reject)
+    if (data) req.write(data)
+    req.end()
+  })
 }