added try/catch blocks and ignore non-zero code on kill

Author: mishushakov

js/tests/supervisord.test.ts

@@ -3,11 +3,15 @@ import { sandboxTest, wait } from './setup'
 
 async function waitForHealth(sandbox: any, maxRetries = 10, intervalMs = 100) {
   for (let i = 0; i < maxRetries; i++) {
-    const result = await sandbox.commands.run(
-      'curl -s -o /dev/null -w "%{http_code}" http://0.0.0.0:49999/health'
-    )
-    if (result.stdout.trim() === '200') {
-      return true
+    try {
+      const result = await sandbox.commands.run(
+        'curl -s -o /dev/null -w "%{http_code}" http://0.0.0.0:49999/health'
+      )
+      if (result.stdout.trim() === '200') {
+        return true
+      }
+    } catch {
+      // Connection refused or other error, retry
     }
     await wait(intervalMs)
   }
@@ -20,12 +24,12 @@ sandboxTest('restart after jupyter kill', async ({ sandbox }) => {
   expect(initialHealth).toBe(true)
 
   // Kill the jupyter process as root
-  await sandbox.commands.run("kill -9 $(pgrep -f 'jupyter server')", {
+  await sandbox.commands.run("kill -9 $(pgrep -f 'jupyter server') || true", {
     user: 'root',
   })
 
   // Wait for supervisord to restart it and health to come back
-  const recovered = await waitForHealth(sandbox, 10, 100)
+  const recovered = await waitForHealth(sandbox, 20, 100)
   expect(recovered).toBe(true)
 
   // Verify code execution works after recovery
@@ -39,12 +43,12 @@ sandboxTest('restart after code-interpreter kill', async ({ sandbox }) => {
   expect(initialHealth).toBe(true)
 
   // Kill the code-interpreter process as root
-  await sandbox.commands.run('kill -9 $(cat /var/run/code-interpreter.pid)', {
+  await sandbox.commands.run('kill -9 $(cat /var/run/code-interpreter.pid) || true', {
     user: 'root',
   })
 
   // Wait for supervisord to restart it and health to come back
-  const recovered = await waitForHealth(sandbox, 10, 100)
+  const recovered = await waitForHealth(sandbox, 20, 100)
   expect(recovered).toBe(true)
 
   // Verify code execution works after recovery

python/tests/async/test_async_supervisord.py

@@ -5,11 +5,14 @@
 
 async def wait_for_health(sandbox: AsyncSandbox, max_retries=10, interval_ms=100):
     for _ in range(max_retries):
-        result = await sandbox.commands.run(
-            'curl -s -o /dev/null -w "%{http_code}" http://0.0.0.0:49999/health'
-        )
-        if result.stdout.strip() == "200":
-            return True
+        try:
+            result = await sandbox.commands.run(
+                'curl -s -o /dev/null -w "%{http_code}" http://0.0.0.0:49999/health'
+            )
+            if result.stdout.strip() == "200":
+                return True
+        except Exception:
+            pass
         await asyncio.sleep(interval_ms / 1000)
     return False
 
@@ -18,11 +21,11 @@ async def test_restart_after_jupyter_kill(async_sandbox: AsyncSandbox):
     # Verify health is up initially
     assert await wait_for_health(async_sandbox)
 
-    # Kill the jupyter process by pid
-    await async_sandbox.commands.run("kill -9 $(pgrep -f 'jupyter server')", user="root")
+    # Kill the jupyter process as root
+    await async_sandbox.commands.run("kill -9 $(pgrep -f 'jupyter server') || true", user="root")
 
     # Wait for supervisord to restart it and health to come back
-    assert await wait_for_health(async_sandbox, 10, 100)
+    assert await wait_for_health(async_sandbox, 20, 100)
 
     # Verify code execution works after recovery
     result = await async_sandbox.run_code("x = 1; x")
@@ -33,11 +36,11 @@ async def test_restart_after_code_interpreter_kill(async_sandbox: AsyncSandbox):
     # Verify health is up initially
     assert await wait_for_health(async_sandbox)
 
-    # Kill the code-interpreter process by pid
-    await async_sandbox.commands.run("kill -9 $(cat /var/run/code-interpreter.pid)", user="root")
+    # Kill the code-interpreter process as root
+    await async_sandbox.commands.run("kill -9 $(cat /var/run/code-interpreter.pid) || true", user="root")
 
     # Wait for supervisord to restart it and health to come back
-    assert await wait_for_health(async_sandbox, 10, 100)
+    assert await wait_for_health(async_sandbox, 20, 100)
 
     # Verify code execution works after recovery
     result = await async_sandbox.run_code("x = 1; x")

python/tests/sync/test_supervisord.py

@@ -5,11 +5,14 @@
 
 def wait_for_health(sandbox: Sandbox, max_retries=10, interval_ms=100):
     for _ in range(max_retries):
-        result = sandbox.commands.run(
-            'curl -s -o /dev/null -w "%{http_code}" http://0.0.0.0:49999/health'
-        )
-        if result.stdout.strip() == "200":
-            return True
+        try:
+            result = sandbox.commands.run(
+                'curl -s -o /dev/null -w "%{http_code}" http://0.0.0.0:49999/health'
+            )
+            if result.stdout.strip() == "200":
+                return True
+        except Exception:
+            pass
         time.sleep(interval_ms / 1000)
     return False
 
@@ -19,10 +22,10 @@ def test_restart_after_jupyter_kill(sandbox: Sandbox):
     assert wait_for_health(sandbox)
 
     # Kill the jupyter process as root
-    sandbox.commands.run("kill -9 $(pgrep -f 'jupyter server')", user="root")
+    sandbox.commands.run("kill -9 $(pgrep -f 'jupyter server') || true", user="root")
 
     # Wait for supervisord to restart it and health to come back
-    assert wait_for_health(sandbox, 10, 100)
+    assert wait_for_health(sandbox, 20, 100)
 
     # Verify code execution works after recovery
     result = sandbox.run_code("x = 1; x")
@@ -35,11 +38,11 @@ def test_restart_after_code_interpreter_kill(sandbox: Sandbox):
 
     # Kill the code-interpreter process as root
     sandbox.commands.run(
-        "kill -9 $(cat /var/run/code-interpreter.pid)", user="root"
+        "kill -9 $(cat /var/run/code-interpreter.pid) || true", user="root"
     )
 
     # Wait for supervisord to restart it and health to come back
-    assert wait_for_health(sandbox, 10, 100)
+    assert wait_for_health(sandbox, 20, 100)
 
     # Verify code execution works after recovery
     result = sandbox.run_code("x = 1; x")