feat(load-task): implement interactive=False to execute tasks without pausing

By default, we load the task with `run-task` then pause execution so the
user can mess around before executing the task. This introduces a way to
support non run-task based tasks by setting interactive=False. This
simply runs the task right away without pausing execution.

Author: ahal

src/taskgraph/docker.py

@@ -6,6 +6,7 @@
 import os
 import shlex
 import subprocess
+import sys
 import tarfile
 import tempfile
 from io import BytesIO
@@ -378,6 +379,7 @@ def load_task(
     remove: bool = True,
     user: Optional[str] = None,
     custom_image: Optional[str] = None,
+    interactive: Optional[bool] = True,
 ) -> int:
     """Load and run a task interactively in a Docker container.
 
@@ -392,14 +394,12 @@ def load_task(
         remove: Whether to remove the container after exit (default True).
         user: The user to switch to in the container (default 'worker').
         custom_image: A custom image to use instead of the task's image.
+        interactive: If True, execution of the task will be paused and user
+          will be dropped into a shell. They can run `exec-task` to resume
+          it (default: True).
 
     Returns:
         int: The exit code from the Docker container.
-
-    Note:
-        Only supports tasks that use 'run-task' and have a payload.image.
-        The task's actual command is made available via an 'exec-task' function
-        in the interactive shell.
     """
     user = user or "worker"
     if isinstance(task, str):
@@ -419,9 +419,9 @@ def load_task(
 
         return 1
 
-    command = task_def["payload"].get("command")  # type: ignore
-    if not command or not command[0].endswith("run-task"):
-        logger.error("Only tasks using `run-task` are supported!")
+    task_command = task_def["payload"].get("command")  # type: ignore
+    if interactive and (not task_command or not task_command[0].endswith("run-task")):
+        logger.error("Only tasks using `run-task` are supported with interactive!")
         return 1
 
     try:
@@ -431,33 +431,40 @@ def load_task(
         logger.exception(e)
         return 1
 
-    # Remove the payload section of the task's command. This way run-task will
-    # set up the task (clone repos, download fetches, etc) but won't actually
-    # start the core of the task. Instead we'll drop the user into an interactive
-    # shell and provide the ability to resume the task command.
-    task_command = None
-    if index := _index(command, "--"):
-        task_command = shlex.join(command[index + 1 :])
-        # I attempted to run the interactive bash shell here, but for some
-        # reason when executed through `run-task`, the interactive shell
-        # doesn't work well. There's no shell prompt on newlines and tab
-        # completion doesn't work. That's why it is executed outside of
-        # `run-task` below, and why we need to parse `--task-cwd`.
-        command[index + 1 :] = [
-            "echo",
-            "Task setup complete!\nRun `exec-task` to execute the task's command.",
-        ]
-
-    # Parse `--task-cwd` so we know where to execute the task's command later.
-    if index := _index(command, "--task-cwd"):
-        task_cwd = command[index + 1]
-    else:
-        for arg in command:
-            if arg.startswith("--task-cwd="):
-                task_cwd = arg.split("=", 1)[1]
-                break
+    exec_command = task_cwd = None
+    if interactive:
+        # Remove the payload section of the task's command. This way run-task will
+        # set up the task (clone repos, download fetches, etc) but won't actually
+        # start the core of the task. Instead we'll drop the user into an interactive
+        # shell and provide the ability to resume the task command.
+        if index := _index(task_command, "--"):
+            exec_command = shlex.join(task_command[index + 1 :])
+            # I attempted to run the interactive bash shell here, but for some
+            # reason when executed through `run-task`, the interactive shell
+            # doesn't work well. There's no shell prompt on newlines and tab
+            # completion doesn't work. That's why it is executed outside of
+            # `run-task` below, and why we need to parse `--task-cwd`.
+            task_command[index + 1 :] = [
+                "echo",
+                "Task setup complete!\nRun `exec-task` to execute the task's command.",
+            ]
+
+        # Parse `--task-cwd` so we know where to execute the task's command later.
+        if index := _index(task_command, "--task-cwd"):
+            task_cwd = task_command[index + 1]
         else:
-            task_cwd = "$TASK_WORKDIR"
+            for arg in task_command:
+                if arg.startswith("--task-cwd="):
+                    task_cwd = arg.split("=", 1)[1]
+                    break
+            else:
+                task_cwd = "$TASK_WORKDIR"
+
+        task_command = [
+            "bash",
+            "-c",
+            f"{shlex.join(task_command)} && cd $TASK_WORKDIR && su -p {user}",
+        ]
 
     # Set some env vars the worker would normally set.
     env = {
@@ -476,17 +483,21 @@ def load_task(
 
     envfile = None
     initfile = None
+    isatty = os.isatty(sys.stdin.fileno())
     try:
         command = [
             "docker",
             "run",
-            "-it",
-            image_tag,
-            "bash",
-            "-c",
-            f"{shlex.join(command)} && cd $TASK_WORKDIR && su -p {user}",
+            "-i",
         ]
 
+        if isatty:
+            command.append("-t")
+
+        command.append(image_tag)
+
+        if task_command:
+            command.extend(task_command)
         if remove:
             command.insert(2, "--rm")
 
@@ -497,16 +508,16 @@ def load_task(
 
             command.insert(2, f"--env-file={envfile.name}")
 
-        if task_command:
+        if exec_command:
             initfile = tempfile.NamedTemporaryFile("w+", delete=False)
             os.fchmod(initfile.fileno(), 0o644)
             initfile.write(
                 dedent(
                     f"""
             function exec-task() {{
-                echo Starting task: {shlex.quote(task_command)}
+                echo Starting task: {shlex.quote(exec_command)}
                 pushd {task_cwd}
-                {task_command}
+                {exec_command}
                 popd
             }}
             """
@@ -516,6 +527,7 @@ def load_task(
 
             command[2:2] = ["-v", f"{initfile.name}:/builds/worker/.bashrc"]
 
+        logger.info(f"Running: {' '.join(command)}")
         proc = subprocess.run(command)
     finally:
         if envfile:

test/test_docker.py

@@ -110,7 +110,9 @@ def mock_run(*popenargs, check=False, **kwargs):
 
 @pytest.fixture
 def run_load_task(mocker):
-    def inner(task, remove=False, custom_image=None, pass_task_def=False):
+    def inner(
+        task, remove=False, custom_image=None, pass_task_def=False, interactive=True
+    ):
         proc = mocker.MagicMock()
         proc.returncode = 0
 
@@ -134,6 +136,12 @@ def inner(task, remove=False, custom_image=None, pass_task_def=False):
             ),
         }
 
+        # Mock sys.stdin.fileno() to avoid issues in pytest
+        mock_stdin = mocker.MagicMock()
+        mock_stdin.fileno.return_value = 0
+        mocker.patch.object(docker.sys, "stdin", mock_stdin)
+        mocker.patch.object(docker.os, "isatty", return_value=True)
+
         # If testing with task ID, mock get_task_definition
         if not pass_task_def:
             task_id = "abc"
@@ -146,7 +154,11 @@ def inner(task, remove=False, custom_image=None, pass_task_def=False):
             input_arg = task
 
         ret = docker.load_task(
-            graph_config, input_arg, remove=remove, custom_image=custom_image
+            graph_config,
+            input_arg,
+            remove=remove,
+            custom_image=custom_image,
+            interactive=interactive,
         )
         return ret, mocks
 
@@ -199,7 +211,8 @@ def test_load_task(run_load_task):
         "-v",
         re.compile(f"{tempfile.gettempdir()}/tmp.*:/builds/worker/.bashrc"),
         re.compile(f"--env-file={tempfile.gettempdir()}/tmp.*"),
-        "-it",
+        "-i",
+        "-t",
         "image/tag",
         "bash",
         "-c",
@@ -389,6 +402,43 @@ def test_load_task_with_task_definition(run_load_task, caplog):
     assert "Loading 'test-task-direct' from provided definition" in caplog.text
 
 
+def test_load_task_with_interactive_false(run_load_task):
+    # Test non-interactive mode that doesn't require run-task
+    # Task that doesn't use run-task (would fail in interactive mode)
+    task = {
+        "metadata": {"name": "test-task-non-interactive"},
+        "payload": {
+            "command": ["echo", "hello world"],
+            "image": {"taskId": "def", "type": "task-image"},
+        },
+    }
+
+    # Test with interactive=False - should succeed
+    ret, mocks = run_load_task(task, pass_task_def=True, interactive=False)
+    assert ret == 0
+
+    # Verify subprocess was called
+    mocks["subprocess_run"].assert_called_once()
+    command = mocks["subprocess_run"].call_args[0][0]
+
+    # Should run the task command directly
+    # Find and remove --env-file arg as it contains a tempdir
+    for i, arg in enumerate(command):
+        if arg.startswith("--env-file="):
+            del command[i]
+            break
+
+    assert command == [
+        "docker",
+        "run",
+        "-i",
+        "-t",
+        "image/tag",
+        "echo",
+        "hello world",
+    ]
+
+
 @pytest.fixture
 def task():
     return {
@@ -413,7 +463,22 @@ def test_load_task_with_custom_image_in_tree(run_load_task, task):
 
     mocks["build_image"].assert_called_once()
     args = mocks["subprocess_run"].call_args[0][0]
-    tag = args[args.index("-it") + 1]
+    # Find the image tag - it should be after all docker options and before the command
+    # Structure: ['docker', 'run', ...options..., 'image:tag', ...command...]
+    image_index = None
+    for i, arg in enumerate(args):
+        if (
+            not arg.startswith("-")
+            and not arg.startswith("/")
+            and arg != "docker"
+            and arg != "run"
+            and ":" in arg
+            and not arg.startswith("/tmp")
+        ):
+            image_index = i
+            break
+    assert image_index is not None, f"Could not find image tag in {args}"
+    tag = args[image_index]
     assert tag == f"taskcluster/{image}:latest"