Merge pull request #65 from xcube-dev/pont-62-sigint

Stop running container on SIGINT

Author: pont-us

CHANGES.md

@@ -1,6 +1,7 @@
 ## Changes in 0.1.2 (in development)
 
 * Improve handling of environment file specification (#63)
+* Stop running container on SIGINT (#62)
 
 ## Changes in 0.1.1
 

docs/xcetool.md

@@ -21,6 +21,10 @@ This subcommand runs an xcengine container image. An image can also be run using
 `docker run` command, but `xcetool image run` provides some additional convenience
 (e.g. easy configuration of the HTTP port).
 
+If you give the `--server` flag, `xcetool` will run the container indefinitely as an
+xcube server. You can stop the container and force `xcetool` to exit by pressing
+ctrl-C on the command line (or by sending it an interrupt signal in some other way).
+
 ### `xcetool make-script` 
 
 This subcommand does not generate a container image, but a directory containing

test/test_core.py

@@ -1,6 +1,11 @@
 import datetime
 import json
+import os
 import pathlib
+import signal
+import threading
+import time
+
 import pytz
 from io import BufferedReader
 import yaml
@@ -11,6 +16,8 @@
 
 import docker.models.images
 import schema_salad.exceptions
+from docker import DockerClient
+from docker.models.containers import Container
 
 import xcengine.core
 import xcengine.parameters
@@ -90,6 +97,65 @@ def test_runner_init_with_image():
     )
     assert runner.image == image
 
+@pytest.mark.parametrize("keep", [False, True])
+def test_runner_run_keep(keep: bool):
+    runner = xcengine.core.ContainerRunner(
+        image := Mock(docker.models.images.Image),
+        None,
+        client := Mock(DockerClient)
+    )
+    image.tags = []
+    client.containers.run.return_value = (container := MagicMock(Container))
+    container.status = "exited"
+    runner.run(False, 8080, False, keep)
+    if keep:
+        container.remove.assert_not_called()
+    else:
+        container.remove.assert_called_once_with(force=True)
+
+
+def test_runner_sigint():
+    runner = xcengine.core.ContainerRunner(
+        image := Mock(docker.models.images.Image),
+        None,
+        client := Mock(DockerClient)
+    )
+    image.tags = []
+    client.containers.run.return_value = (container := Mock(Container))
+    container.status = "running"
+    def container_stop():
+        container.status = "stopped"
+    container.stop = container_stop
+    pid = os.getpid()
+
+    old_alarm_handler = signal.getsignal(signal.SIGALRM)
+    class AlarmException(Exception):
+        pass
+    def alarm_handler(signum, frame):
+        raise AlarmException()
+    signal.signal(signal.SIGALRM, alarm_handler)
+
+    def interrupt_process():
+        time.sleep(1)  # allow one second for runner to start
+        os.kill(pid, signal.SIGINT)
+    thread = threading.Thread(target=interrupt_process, daemon=True)
+    thread.start()
+
+    signal.alarm(5)
+    try:
+        # Should trap imminent SIGINT from interrupt_process and exit quickly
+        runner.run(False, 8080, False, False)
+    except AlarmException:
+        # time-out, exception raised by alarm_handler
+        # We need a time-out so that the test fails rather than hanging.
+        assert False, "Container did not stop on SIGINT"
+    finally:
+        # Reset the alarm handler and cancel the alarm to avoid affecting
+        # subsequent tests.
+        signal.signal(signal.SIGALRM, old_alarm_handler)
+        signal.alarm(0)
+    assert container.status == "stopped"
+
 
 @patch("xcengine.core.subprocess.run")
 def test_pip(mock_run):

xcengine/core.py

@@ -6,6 +6,8 @@
 import json
 import os
 import shutil
+import signal
+import socket
 import sys
 import tarfile
 import subprocess
@@ -337,7 +339,7 @@ class ContainerRunner:
     def __init__(
         self,
         image: Image | str,
-        output_dir: pathlib.Path,
+        output_dir: pathlib.Path | None,
         client: docker.DockerClient = None,
     ):
         self._client = client
@@ -388,13 +390,20 @@ def run(
             run_args["ports"] = {"8080": host_port}
         container: Container = self.client.containers.run(**run_args)
         LOGGER.info(f"Waiting for container {container.short_id} to complete.")
+        default_sigint_handler = signal.getsignal(signal.SIGINT)
+        def signal_hander(signum, frame):
+            signal.signal(signal.SIGINT, default_sigint_handler)
+            LOGGER.info(f"Caught SIGINT. Stopping container {container.short_id}")
+            container.stop()
+        signal.signal(signal.SIGINT, signal_hander)
         while container.status in {"created", "running"}:
             LOGGER.debug(
                 f"Waiting for {container.short_id} "
                 f"(status: {container.status})"
             )
             time.sleep(2)
             container.reload()
+        signal.signal(signal.SIGINT, default_sigint_handler)
         LOGGER.info(
             f'Container {container.short_id} has status "{container.status}".'
         )
@@ -404,7 +413,7 @@ def run(
             )
             self.extract_output_from_container(container)
             LOGGER.info(f"Results copied.")
-        if host_port is None and not keep:
+        if not keep:
             LOGGER.info(f"Removing container {container.short_id}...")
             container.remove(force=True)
             LOGGER.info(f"Container {container.short_id} removed.")