channel-worker 2.3.0 → 2.3.1

package/lib/cache-server.js

@@ -13,6 +13,7 @@
 
 const http = require('http');
 const url = require('url');
+const { execSync } = require('child_process');
 
 class CacheServer {
   constructor(api, options = {}) {
@@ -110,25 +111,76 @@ class CacheServer {
     res.end(JSON.stringify({ success: false, message: 'not found' }));
   }
 
-  start() {
-    return new Promise((resolve, reject) => {
-      this.server = http.createServer((req, res) => this._handleRequest(req, res));
-      this.server.on('error', (err) => {
-        if (err.code === 'EADDRINUSE') {
-          console.error(`[cache-server] Port ${this.port} is already in use. ` +
-            `Another daemon may be running, or a previous instance crashed and the OS hasn't released the port yet ` +
-            `(usually clears in 30-60s). On Windows: 'netstat -ano | findstr ${this.port}' then 'taskkill /PID <pid> /F'. ` +
-            `On Mac/Linux: 'lsof -ti:${this.port} | xargs kill -9'.`);
+  // Find PID(s) holding our port and kill them. Cross-platform best-effort.
+  // Used when bind fails with EADDRINUSE — typically a leaked previous daemon.
+  _killPortHolder() {
+    try {
+      if (process.platform === 'win32') {
+        // netstat columns: Proto Local Foreign State PID
+        const out = execSync(`netstat -ano -p TCP | findstr :${this.port} | findstr LISTENING`,
+          { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+        const pids = new Set();
+        for (const line of out.split('\n')) {
+          const m = line.trim().match(/\s(\d+)\s*$/);
+          if (m) pids.add(m[1]);
         }
-        reject(err);
-      });
-      this.server.listen(this.port, this.host, () => {
-        console.log(`[cache-server] Listening on http://${this.host}:${this.port} (max ${this.maxEntries} entries)`);
+        for (const pid of pids) {
+          if (Number(pid) === process.pid) continue;
+          console.log(`[cache-server] Killing leaked PID ${pid} holding port ${this.port}`);
+          try { execSync(`taskkill /PID ${pid} /F`, { stdio: 'ignore' }); } catch {}
+        }
+        return pids.size;
+      }
+      // mac/linux
+      const out = execSync(`lsof -ti:${this.port} -sTCP:LISTEN`,
+        { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+      const pids = out.split('\n').map(s => s.trim()).filter(Boolean);
+      for (const pid of pids) {
+        if (Number(pid) === process.pid) continue;
+        console.log(`[cache-server] Killing leaked PID ${pid} holding port ${this.port}`);
+        try { execSync(`kill -9 ${pid}`, { stdio: 'ignore' }); } catch {}
+      }
+      return pids.length;
+    } catch {
+      return 0;
+    }
+  }
+
+  _bindOnce() {
+    return new Promise((resolve, reject) => {
+      const server = http.createServer((req, res) => this._handleRequest(req, res));
+      server.on('error', (err) => reject(err));
+      server.listen(this.port, this.host, () => {
+        this.server = server;
         resolve();
       });
     });
   }
 
+  async start() {
+    try {
+      await this._bindOnce();
+    } catch (err) {
+      if (err.code !== 'EADDRINUSE') throw err;
+      console.warn(`[cache-server] Port ${this.port} busy — trying to kill leaked holder...`);
+      const killed = this._killPortHolder();
+      if (killed === 0) {
+        console.error(`[cache-server] No leaked process found for port ${this.port}. ` +
+          `Maybe TIME_WAIT — wait 30-60s and retry.`);
+        throw err;
+      }
+      // Wait for OS to release the port after kill, then retry once
+      await new Promise(r => setTimeout(r, 500));
+      try {
+        await this._bindOnce();
+      } catch (err2) {
+        console.error(`[cache-server] Still cannot bind ${this.port} after killing leaked PIDs.`);
+        throw err2;
+      }
+    }
+    console.log(`[cache-server] Listening on http://${this.host}:${this.port} (max ${this.maxEntries} entries)`);
+  }
+
   stop() {
     if (this.server) {
       this.server.close();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "channel-worker",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "description": "Channel Manager worker daemon — runs on remote machines to execute video pipeline jobs",
   "main": "lib/daemon.js",
   "bin": {