Add process killer

renderer.js

@@ -8,6 +8,7 @@ import { platform } from 'os';
 import { renderSSR } from './ssr.js';
 import path from 'path';
 import { renderProxy } from './proxy-renderer.js';
+import { ProcessKiller } from './utils/ProcessKiller.js';
 const { UnzipFiles, Utils, ZipFiles } = pkg;
 
 const __filename = fileURLToPath(import.meta.url);
@@ -109,98 +110,7 @@ export async function doRender(
 
 	const childProcess = spawn('npx', remotionArgs, spawnOptions);
 	let isProcessKilled = false;
-	let processTreePids = new Set(); // Track all process PIDs for cleanup
-
-	// Function to find and kill all child processes
-	const killProcessTree = async (pid, signal = 'SIGTERM') => {
-		try {
-			if (platform() === 'win32') {
-				// On Windows, use taskkill to kill the entire process tree
-				const { exec } = await import('child_process');
-				return new Promise((resolve) => {
-					exec(`taskkill /pid ${pid} /t /f`, (error) => {
-						if (error && !error.message.includes('not found')) {
-							console.error('Failed to kill Windows process tree:', error.message);
-						} else {
-							console.log(`Windows process tree ${pid} killed`);
-						}
-						resolve();
-					});
-				});
-			} else {
-				// On Unix systems, kill the process group
-				try {
-					process.kill(-pid, signal);
-					console.log(`Unix process group ${pid} killed with ${signal}`);
-				} catch (e) {
-					if (e.code !== 'ESRCH') {
-						// Try individual process kill as fallback
-						try {
-							process.kill(pid, signal);
-							console.log(`Unix process ${pid} killed with ${signal}`);
-						} catch (e2) {
-							if (e2.code !== 'ESRCH') {
-								console.error('Failed to kill Unix process:', e2.message);
-							}
-						}
-					}
-				}
-			}
-		} catch (e) {
-			if (e.code !== 'ESRCH') {
-				console.error('Failed to kill process tree:', e.message);
-			}
-		}
-	};
-
-	// Additional cleanup function to kill any remaining remotion processes
-	const killRemainingRemotionProcesses = async () => {
-		try {
-			if (platform() === 'win32') {
-				// On Windows, find and kill remotion processes
-				const { exec } = await import('child_process');
-				exec('tasklist /fi "imagename eq node.exe" /fo csv | findstr remotion', (error, stdout) => {
-					if (!error && stdout) {
-						console.log('Found remaining remotion processes, attempting cleanup...');
-						exec('taskkill /f /im node.exe /fi "windowtitle eq *remotion*"', (killError) => {
-							if (!killError) {
-								console.log('Cleaned up remaining remotion processes');
-							}
-						});
-					}
-				});
-			} else {
-				// On Unix systems, use pkill to find remotion processes
-				const { exec } = await import('child_process');
-				exec('pkill -f "remotion.*render"', (error) => {
-					if (!error) {
-						console.log('Cleaned up remaining remotion processes');
-					}
-				});
-			}
-		} catch (e) {
-			// Ignore cleanup errors
-			console.log('Cleanup attempt completed');
-		}
-	};
-
-	// Function to verify if process is actually terminated
-	const verifyProcessTerminated = async (pid) => {
-		try {
-			if (platform() === 'win32') {
-				const { execSync } = await import('child_process');
-				const result = execSync(`tasklist /fi "pid eq ${pid}"`, { encoding: 'utf8' });
-				return !result.includes(pid.toString());
-			} else {
-				// On Unix, sending signal 0 checks if process exists
-				process.kill(pid, 0);
-				return false; // If no error thrown, process still exists
-			}
-		} catch (e) {
-			// If error thrown, process doesn't exist
-			return true;
-		}
-	};
+	const processKiller = new ProcessKiller();
 
 	if (controller && controller.stop) {
 		controller.stop = async () => {
@@ -212,42 +122,18 @@ export async function doRender(
 
 			isProcessKilled = true;
 
-			if (!childProcess.pid) {
-				console.log('No PID available');
-				return;
-			}
-
-			try {
-				console.log(`Attempting to kill process tree with PID: ${childProcess.pid}`);
-
-				// Kill the entire process tree
-				await killProcessTree(childProcess.pid, 'SIGTERM');
+			// Use the ProcessKiller utility for comprehensive termination
+			const success = await processKiller.terminateProcess(childProcess.pid, {
+				gracefulTimeout: 2000,
+				forceTimeout: 1000,
+				processPattern: "remotion.*render",
+				onProgress: (message) => console.log(message)
+			});
 
-				// Give it a moment to terminate gracefully
-				setTimeout(async () => {
-					const isTerminated = await verifyProcessTerminated(childProcess.pid);
-					if (!childProcess.killed && !isTerminated) {
-						console.log('Process still running, trying SIGKILL');
-						await killProcessTree(childProcess.pid, 'SIGKILL');
-
-						// Final verification and cleanup attempt
-						setTimeout(async () => {
-							const isFinallyTerminated = await verifyProcessTerminated(childProcess.pid);
-							if (!isFinallyTerminated) {
-								console.log('Process still exists after SIGKILL, attempting additional cleanup');
-								await killRemainingRemotionProcesses();
-							} else {
-								console.log('Process successfully terminated');
-							}
-						}, 1000);
-					} else {
-						console.log('Process terminated successfully with SIGTERM');
-					}
-				}, 2000); console.log('Process termination initiated');
-			} catch (e) {
-				console.error('Failed to stop process:', e.message);
-				// Try cleanup as fallback
-				await killRemainingRemotionProcesses();
+			if (success) {
+				console.log('Process termination completed');
+			} else {
+				console.log('Process termination attempted (may have already been terminated)');
 			}
 		}
 	}
@@ -255,8 +141,8 @@ export async function doRender(
 	console.log('Starting video render. ' + cmd);
 	console.log(`Spawned process with PID: ${childProcess.pid}`);
 
-	// Store the process for cleanup
-	processTreePids.add(childProcess.pid);
+	// Track the process for cleanup
+	processKiller.trackPid(childProcess.pid);
 
 	let updateCounter = 0;
 	childProcess.stdout.on('data', (data) => {
@@ -279,7 +165,7 @@ export async function doRender(
 			console.log(`Render process closed with code: ${code}, signal: ${signal}`);
 
 			// Clean up tracked PIDs
-			processTreePids.clear();
+			processKiller.clearTrackedPids();
 
 			sendToObserver(jobId, code === 0 ? 'completed' : 'failed');
 			if (code === 0) {
@@ -296,7 +182,7 @@ export async function doRender(
 
 		childProcess.on('error', (error) => {
 			isProcessKilled = true; // Mark process as terminated
-			processTreePids.clear();
+			processKiller.clearTrackedPids();
 			console.error('Child process error:', error);
 			sendToObserver(jobId, 'failed');
 			reject(error);

utils/ProcessKiller.js

@@ -0,0 +1,271 @@
+import { exec, execSync } from 'child_process';
+import { platform } from 'os';
+
+/**
+ * Enhanced process killer utility for handling stubborn processes
+ * Handles cross-platform process tree termination with multiple fallback strategies
+ */
+export class ProcessKiller {
+  constructor() {
+    this.isWindows = platform() === 'win32';
+    this.trackedPids = new Set();
+  }
+
+  /**
+   * Track a PID for cleanup
+   * @param {number} pid - Process ID to track
+   */
+  trackPid(pid) {
+    if (pid) {
+      this.trackedPids.add(pid);
+    }
+  }
+
+  /**
+   * Kill a process tree with the specified signal
+   * @param {number} pid - Process ID to kill
+   * @param {string} signal - Signal to send (SIGTERM, SIGKILL, etc.)
+   * @returns {Promise<boolean>} - True if successful
+   */
+  async killProcessTree(pid, signal = 'SIGTERM') {
+    try {
+      if (this.isWindows) {
+        return await this._killWindowsProcessTree(pid);
+      } else {
+        return await this._killUnixProcessTree(pid, signal);
+      }
+    } catch (e) {
+      if (e.code !== 'ESRCH') {
+        console.error('Failed to kill process tree:', e.message);
+      }
+      return false;
+    }
+  }
+
+  /**
+   * Windows-specific process tree killing
+   * @param {number} pid - Process ID
+   * @returns {Promise<boolean>}
+   */
+  async _killWindowsProcessTree(pid) {
+    return new Promise((resolve) => {
+      exec(`taskkill /pid ${pid} /t /f`, (error) => {
+        if (error && !error.message.includes('not found')) {
+          console.error('Failed to kill Windows process tree:', error.message);
+          resolve(false);
+        } else {
+          console.log(`Windows process tree ${pid} killed`);
+          resolve(true);
+        }
+      });
+    });
+  }
+
+  /**
+   * Unix-specific process tree killing
+   * @param {number} pid - Process ID
+   * @param {string} signal - Signal to send
+   * @returns {Promise<boolean>}
+   */
+  async _killUnixProcessTree(pid, signal) {
+    try {
+      // Try to kill the process group first
+      process.kill(-pid, signal);
+      console.log(`Unix process group ${pid} killed with ${signal}`);
+      return true;
+    } catch (e) {
+      if (e.code !== 'ESRCH') {
+        // Try individual process kill as fallback
+        try {
+          process.kill(pid, signal);
+          console.log(`Unix process ${pid} killed with ${signal}`);
+          return true;
+        } catch (e2) {
+          if (e2.code !== 'ESRCH') {
+            console.error('Failed to kill Unix process:', e2.message);
+          }
+          return false;
+        }
+      }
+      return false;
+    }
+  }
+
+  /**
+   * Verify if a process is actually terminated
+   * @param {number} pid - Process ID to check
+   * @returns {Promise<boolean>} - True if terminated
+   */
+  async verifyProcessTerminated(pid) {
+    try {
+      if (this.isWindows) {
+        const result = execSync(`tasklist /fi "pid eq ${pid}"`, { encoding: 'utf8' });
+        return !result.includes(pid.toString());
+      } else {
+        // On Unix, sending signal 0 checks if process exists
+        process.kill(pid, 0);
+        return false; // If no error thrown, process still exists
+      }
+    } catch (e) {
+      // If error thrown, process doesn't exist
+      return true;
+    }
+  }
+
+  /**
+   * Kill any remaining processes matching a pattern
+   * @param {string} processPattern - Pattern to match (e.g., "remotion.*render")
+   * @returns {Promise<void>}
+   */
+  async killRemainingProcesses(processPattern = "remotion.*render") {
+    try {
+      if (this.isWindows) {
+        await this._killRemainingWindowsProcesses(processPattern);
+      } else {
+        await this._killRemainingUnixProcesses(processPattern);
+      }
+    } catch (e) {
+      console.log('Cleanup attempt completed');
+    }
+  }
+
+  /**
+   * Windows-specific remaining process cleanup
+   * @param {string} pattern - Process pattern
+   */
+  async _killRemainingWindowsProcesses(pattern) {
+    return new Promise((resolve) => {
+      exec('tasklist /fi "imagename eq node.exe" /fo csv | findstr remotion', (error, stdout) => {
+        if (!error && stdout) {
+          console.log('Found remaining remotion processes, attempting cleanup...');
+          exec('taskkill /f /im node.exe /fi "windowtitle eq *remotion*"', (killError) => {
+            if (!killError) {
+              console.log('Cleaned up remaining remotion processes');
+            }
+            resolve();
+          });
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+
+  /**
+   * Unix-specific remaining process cleanup
+   * @param {string} pattern - Process pattern
+   */
+  async _killRemainingUnixProcesses(pattern) {
+    return new Promise((resolve) => {
+      exec(`pkill -f "${pattern}"`, (error) => {
+        if (!error) {
+          console.log('Cleaned up remaining remotion processes');
+        }
+        resolve();
+      });
+    });
+  }
+
+  /**
+   * Comprehensive process termination with multiple strategies
+   * @param {number} pid - Process ID to terminate
+   * @param {Object} options - Termination options
+   * @returns {Promise<boolean>} - True if successfully terminated
+   */
+  async terminateProcess(pid, options = {}) {
+    const {
+      gracefulTimeout = 2000,
+      forceTimeout = 1000,
+      processPattern = "remotion.*render",
+      onProgress = () => { }
+    } = options;
+
+    if (!pid) {
+      onProgress('No PID available');
+      return false;
+    }
+
+    try {
+      onProgress(`Attempting to kill process tree with PID: ${pid}`);
+
+      // Stage 1: Graceful termination
+      await this.killProcessTree(pid, 'SIGTERM');
+
+      // Wait and verify
+      await new Promise(resolve => setTimeout(resolve, gracefulTimeout));
+
+      const isTerminated = await this.verifyProcessTerminated(pid);
+      if (isTerminated) {
+        onProgress('Process terminated successfully with SIGTERM');
+        return true;
+      }
+
+      // Stage 2: Force termination
+      onProgress('Process still running, trying SIGKILL');
+      await this.killProcessTree(pid, 'SIGKILL');
+
+      // Final verification
+      await new Promise(resolve => setTimeout(resolve, forceTimeout));
+
+      const isFinallyTerminated = await this.verifyProcessTerminated(pid);
+      if (isFinallyTerminated) {
+        onProgress('Process successfully terminated');
+        return true;
+      }
+
+      // Stage 3: Cleanup remaining processes
+      onProgress('Process still exists after SIGKILL, attempting additional cleanup');
+      await this.killRemainingProcesses(processPattern);
+
+      return true; // Assume success after cleanup attempt
+
+    } catch (e) {
+      console.error('Failed to terminate process:', e.message);
+      // Final fallback cleanup
+      await this.killRemainingProcesses(processPattern);
+      return false;
+    }
+  }
+
+  /**
+   * Clean up all tracked PIDs
+   */
+  clearTrackedPids() {
+    this.trackedPids.clear();
+  }
+
+  /**
+   * Get all tracked PIDs
+   * @returns {Set<number>}
+   */
+  getTrackedPids() {
+    return new Set(this.trackedPids);
+  }
+}
+
+/**
+ * Default export - singleton instance
+ */
+export default new ProcessKiller();
+
+/**
+ * Convenience function for quick process termination
+ * @param {number} pid - Process ID
+ * @param {Object} options - Termination options
+ * @returns {Promise<boolean>}
+ */
+export async function terminateProcess(pid, options = {}) {
+  const killer = new ProcessKiller();
+  return await killer.terminateProcess(pid, options);
+}
+
+/**
+ * Convenience function for process tree killing
+ * @param {number} pid - Process ID
+ * @param {string} signal - Signal to send
+ * @returns {Promise<boolean>}
+ */
+export async function killProcessTree(pid, signal = 'SIGTERM') {
+  const killer = new ProcessKiller();
+  return await killer.killProcessTree(pid, signal);
+}