chore: consolidate subprocess utils (#2011)

Author: gau-nernst

engine/extensions/python-engine/python_engine.cc

@@ -89,30 +89,11 @@ bool PythonEngine::TerminateModelProcess(const std::string& model) {
     return false;
   }
 
-#if defined(_WIN32)
-  HANDLE hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, it->second);
-  if (hProcess == NULL) {
-    LOG_ERROR << "Failed to open process";
-    return false;
-  }
-
-  bool terminated = TerminateProcess(hProcess, 0) == TRUE;
-  CloseHandle(hProcess);
-
-  if (terminated) {
+  bool success = cortex::process::KillProcess(it->second);
+  if (success) {
     process_map_.erase(it);
-    return true;
   }
-
-#elif defined(__APPLE__) || defined(__linux__)
-  int result = kill(it->second, SIGTERM);
-  if (result == 0) {
-    process_map_.erase(it);
-    return true;
-  }
-#endif
-
-  return false;
+  return success;
 }
 
 CurlResponse PythonEngine::MakeGetRequest(const std::string& model,
@@ -823,7 +804,7 @@ void PythonEngine::GetModelStatus(
   auto model_config = models_[model];
   auto health_endpoint = model_config.heath_check;
   auto pid = process_map_[model];
-  auto is_process_live = process_status_utils::IsProcessRunning(pid);
+  auto is_process_live = cortex::process::IsProcessAlive(pid);
   auto response_health = MakeGetRequest(model, health_endpoint.path);
 
   if (response_health.error && is_process_live) {

engine/extensions/python-engine/python_engine.h

@@ -14,7 +14,6 @@
 #include "extensions/template_renderer.h"
 #include "utils/file_logger.h"
 #include "utils/file_manager_utils.h"
-#include "utils/process_status_utils.h"
 #include "utils/curl_utils.h"
 #include "utils/process/utils.h"
 

engine/utils/process/utils.cc

@@ -1,7 +1,9 @@
 #include "utils/process/utils.h"
 #include "utils/logging_utils.h"
 
-#if defined(__APPLE__) || defined(__linux__)
+#if defined(_WIN32)
+#include <tlhelp32.h>
+#elif defined(__APPLE__) || defined(__linux__)
 extern char **environ;  // environment variables
 #endif
 
@@ -103,4 +105,66 @@ pid_t SpawnProcess(const std::vector<std::string>& command) {
   }
 }
 
-}  // namespace cortex::process
+bool IsProcessAlive(pid_t pid) {
+#ifdef _WIN32
+  // Windows implementation
+  HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
+  if (snapshot == INVALID_HANDLE_VALUE) {
+    return false;
+  }
+
+  PROCESSENTRY32 processEntry = {0};
+  processEntry.dwSize = sizeof(processEntry);
+
+  if (Process32First(snapshot, &processEntry)) {
+    do {
+      if (processEntry.th32ProcessID == pid) {
+        CloseHandle(snapshot);
+        return true;
+      }
+    } while (Process32Next(snapshot, &processEntry));
+  }
+
+  CloseHandle(snapshot);
+  return false;
+
+#elif defined(__APPLE__) || defined(__linux__)
+  // Unix-like systems (Linux and macOS) implementation
+  if (pid <= 0) {
+    return false;
+  }
+
+  // Try to send signal 0 to the process
+  // This doesn't actually send a signal but checks if we can send signals to the process
+  int result = kill(pid, 0);
+
+  if (result == 0) {
+    return true;  // Process exists and we have permission to send it signals
+  }
+
+  return errno != ESRCH;  // ESRCH means "no such process"
+#else
+#error "Unsupported platform"
+#endif
+}
+
+bool KillProcess(pid_t pid) {
+#if defined(_WIN32)
+  HANDLE hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, pid);
+  if (hProcess == NULL) {
+    LOG_ERROR << "Failed to open process";
+    return false;
+  }
+
+  bool is_success = TerminateProcess(hProcess, 0) == TRUE;
+  CloseHandle(hProcess);
+  return is_success;
+#elif defined(__APPLE__) || defined(__linux__)
+  // NOTE: should we use SIGKILL here to be consistent with Windows?
+  return kill(pid, SIGTERM) == 0;
+#else
+#error "Unsupported platform"
+#endif
+}
+
+}  // namespace cortex::process

engine/utils/process/utils.h

@@ -21,5 +21,7 @@ std::string ConstructWindowsCommandLine(const std::vector<std::string>& args);
 std::vector<char*> ConvertToArgv(const std::vector<std::string>& args);
 
 pid_t SpawnProcess(const std::vector<std::string>& command);
+bool IsProcessAlive(pid_t pid);
+bool KillProcess(pid_t pid);
 
-}
+}