orchestrator-lso 2.1.1__tar.gz → 2.2.0__tar.gz

{orchestrator_lso-2.1.1 → orchestrator_lso-2.2.0}/.bumpversion.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 2.1.1
+current_version = 2.2.0
 commit = False
 tag = False
 parse = (?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)(rc(?P<build>\d+))?

{orchestrator_lso-2.1.1 → orchestrator_lso-2.2.0}/Dockerfile.example

@@ -11,7 +11,7 @@ COPY ./ansible-galaxy-requirements.yaml ./ansible-galaxy-requirements.yaml
 RUN apk add --update --no-cache gcc libc-dev libffi-dev openssh
 
 # Install the LSO python package, and additional requirements
-RUN pip install orchestrator-lso=="2.1.1"
+RUN pip install orchestrator-lso=="2.2.0"
 RUN pip install -r requirements.txt
 
 # Install required Ansible Galaxy roles and collections

{orchestrator_lso-2.1.1 → orchestrator_lso-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orchestrator-lso
-Version: 2.1.1
+Version: 2.2.0
 Summary: LSO, an API for remotely running Ansible playbooks.
 Author-email: GÉANT Orchestration and Automation Team <goat@geant.org>
 Requires-Python: >=3.11,<3.13
@@ -30,10 +30,10 @@ Requires-Dist: ansible-runner==2.4.1
 Requires-Dist: ansible==10.7.0
 Requires-Dist: fastapi==0.115.12
 Requires-Dist: httpx==0.28.1
-Requires-Dist: uvicorn[standard]==0.34.2
-Requires-Dist: requests==2.32.3
+Requires-Dist: uvicorn[standard]==0.34.3
+Requires-Dist: requests==2.32.4
 Requires-Dist: pydantic-settings==2.9.1
-Requires-Dist: celery==5.5.2
+Requires-Dist: celery==5.5.3
 Requires-Dist: redis==5.2.1
 Requires-Dist: types-setuptools ; extra == "dev"
 Requires-Dist: types-requests ; extra == "dev"

{orchestrator_lso-2.1.1 → orchestrator_lso-2.2.0}/lso/__init__.py

@@ -13,7 +13,7 @@
 
 """LSO, an API for remotely running Ansible playbooks."""
 
-__version__ = "2.1.1"
+__version__ = "2.2.0"
 
 import logging
 

orchestrator_lso-2.2.0/lso/execute.py

@@ -0,0 +1,59 @@
+"""Module for handling the execution of arbitrary executables."""
+
+import subprocess  # noqa: S404
+import uuid
+from pathlib import Path
+
+from pydantic import HttpUrl
+
+from lso.config import ExecutorType, settings
+from lso.schema import ExecutionResult
+from lso.tasks import run_executable_proc_task
+from lso.utils import get_thread_pool
+
+
+def get_executable_path(executable_name: Path) -> Path:
+    """Return the full path of an executable, based on the configured EXECUTABLES_ROOT_DIR."""
+    return Path(settings.EXECUTABLES_ROOT_DIR) / executable_name
+
+
+def run_executable_async(executable_path: Path, args: list[str], callback: HttpUrl | None) -> uuid.UUID:
+    """Dispatch the task for executing an arbitrary executable remotely.
+
+    Uses a ThreadPoolExecutor (for local execution) or a Celery worker (for distributed tasks).
+    """
+    job_id = uuid.uuid4()
+    callback_url = str(callback) if callback else None
+    if settings.EXECUTOR == ExecutorType.THREADPOOL:
+        executor = get_thread_pool()
+        future = executor.submit(run_executable_proc_task, str(job_id), str(executable_path), args, callback_url)
+        if settings.TESTING:
+            future.result()
+    elif settings.EXECUTOR == ExecutorType.WORKER:
+        run_executable_proc_task.delay(str(job_id), str(executable_path), args, callback_url)
+    return job_id
+
+
+def run_executable_sync(executable_path: str, args: list[str]) -> ExecutionResult:
+    """Run the given executable synchronously and return the result."""
+    try:
+        result = subprocess.run(  # noqa: S603
+            [executable_path, *args],
+            text=True,
+            capture_output=True,
+            timeout=settings.EXECUTABLE_TIMEOUT_SEC,
+            check=False,
+        )
+        output = result.stdout + result.stderr
+        return_code = result.returncode
+    except subprocess.TimeoutExpired:
+        output = "Execution timed out."
+        return_code = -1
+    except Exception as e:  # noqa: BLE001
+        output = str(e)
+        return_code = -1
+
+    return ExecutionResult(  # type: ignore[call-arg]
+        output=output,
+        return_code=return_code,
+    )

{orchestrator_lso-2.1.1 → orchestrator_lso-2.2.0}/lso/routes/execute.py

@@ -1,5 +1,6 @@
 """FastAPI route for running arbitrary executables."""
 
+import asyncio
 import uuid
 from pathlib import Path
 from typing import Annotated
@@ -7,7 +8,8 @@ from typing import Annotated
 from fastapi import APIRouter, HTTPException, status
 from pydantic import AfterValidator, BaseModel, HttpUrl
 
-from lso.execute import get_executable_path, run_executable
+from lso.execute import get_executable_path, run_executable_async, run_executable_sync
+from lso.schema import ExecutableRunResponse
 
 router = APIRouter()
 
@@ -35,17 +37,17 @@ class ExecutableRunParams(BaseModel):
 
     executable_name: ExecutableName
     args: list[str] = []
-    callback: HttpUrl
-
-
-class ExecutableRunResponse(BaseModel):
-    """Response for running an arbitrary executable."""
-
-    job_id: uuid.UUID
+    callback: HttpUrl | None = None
+    is_async: bool = True
 
 
 @router.post("/", response_model=ExecutableRunResponse, status_code=status.HTTP_201_CREATED)
-def run_executable_endpoint(params: ExecutableRunParams) -> ExecutableRunResponse:
-    """Dispatch an asynchronous task to run an arbitrary executable."""
-    job_id = run_executable(params.executable_name, params.args, params.callback)
-    return ExecutableRunResponse(job_id=job_id)
+async def run_executable_endpoint(params: ExecutableRunParams) -> ExecutableRunResponse:
+    """Dispatch a task to run an arbitrary executable."""
+    if params.is_async:
+        job_id = run_executable_async(params.executable_name, params.args, params.callback)
+        return ExecutableRunResponse(job_id=job_id)
+
+    job_id = uuid.uuid4()
+    result = await asyncio.to_thread(run_executable_sync, str(params.executable_name), params.args)
+    return ExecutableRunResponse(job_id=job_id, result=result)

orchestrator_lso-2.2.0/lso/schema.py

@@ -0,0 +1,50 @@
+# Copyright 2024-2025 GÉANT Vereniging.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Module for defining the schema for running arbitrary executables."""
+
+import uuid
+from enum import StrEnum
+
+from pydantic import BaseModel, model_validator
+
+
+class JobStatus(StrEnum):
+    """Enumeration of possible job statuses."""
+
+    SUCCESSFUL = "successful"
+    FAILED = "failed"
+
+
+class ExecutionResult(BaseModel):
+    """Model for capturing the result of an executable run."""
+
+    output: str
+    return_code: int
+    status: JobStatus
+
+    @model_validator(mode="before")
+    def populate_status(cls, values: dict) -> dict:
+        """Set the status based on the return code."""
+        rc = values.get("return_code")
+        if rc is not None:
+            values["status"] = JobStatus.SUCCESSFUL if rc == 0 else JobStatus.FAILED
+
+        return values
+
+
+class ExecutableRunResponse(BaseModel):
+    """Response for running an arbitrary executable."""
+
+    job_id: uuid.UUID
+    result: ExecutionResult | None = None

{orchestrator_lso-2.1.1 → orchestrator_lso-2.2.0}/lso/tasks.py

@@ -1,4 +1,4 @@
-# Copyright 2023-2024 GÉANT Vereniging.
+# Copyright 2024-2025 GÉANT Vereniging.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
@@ -18,15 +18,15 @@ the results to a specified callback URL.
 """
 
 import logging
-import subprocess  # noqa: S404
-from enum import StrEnum
 from typing import Any
+from uuid import UUID
 
 import ansible_runner
 import requests
 from starlette import status
 
 from lso.config import settings
+from lso.schema import ExecutableRunResponse
 from lso.worker import RUN_EXECUTABLE, RUN_PLAYBOOK, celery
 
 logger = logging.getLogger(__name__)
@@ -36,13 +36,6 @@ class CallbackFailedError(Exception):
     """Exception raised when a callback url can't be reached."""
 
 
-class JobStatus(StrEnum):
-    """Enumeration of possible job statuses."""
-
-    SUCCESSFUL = "successful"
-    FAILED = "failed"
-
-
 @celery.task(name=RUN_PLAYBOOK)  # type: ignore[misc]
 def run_playbook_proc_task(
     job_id: str, playbook_path: str, extra_vars: dict[str, Any], inventory: dict[str, Any] | str, callback: str
@@ -74,48 +67,34 @@ def run_playbook_proc_task(
 
 
 @celery.task(name=RUN_EXECUTABLE)  # type: ignore[misc]
-def run_executable_proc_task(job_id: str, executable_path: str, args: list[str], callback: str) -> None:
+def run_executable_proc_task(job_id: str, executable_path: str, args: list[str], callback: str | None) -> None:
     """Celery task to run an arbitrary executable and notify via callback.
 
-    Executes the executable with the provided arguments and posts back the output and status.
+    Executes the executable with the provided arguments and posts back the result if a callback URL is provided.
     """
+    from lso.execute import run_executable_sync  # noqa: PLC0415
+
     msg = f"Executing executable: {executable_path} with args: {args}, callback: {callback}"
     logger.info(msg)
-    try:
-        result = subprocess.run(  # noqa: S603
-            [executable_path, *args],
-            text=True,
-            capture_output=True,
-            timeout=settings.EXECUTABLE_TIMEOUT_SEC,
-            check=False,
-        )
-        output = result.stdout + result.stderr
-        return_code = result.returncode
-    except subprocess.TimeoutExpired:
-        output = "Execution timed out."
-        return_code = -1
-    except Exception as e:  # noqa: BLE001
-        output = str(e)
-        return_code = -1
-
-    payload = {
-        "job_id": job_id,
-        "output": output,
-        "return_code": return_code,
-        "status": JobStatus.SUCCESSFUL if return_code == 0 else JobStatus.FAILED,
-    }
-
-    def _raise_callback_error(message: str, error: Exception | None = None) -> None:
-        if error:
-            raise CallbackFailedError(message) from error
-        raise CallbackFailedError(message)
-
-    try:
-        response = requests.post(str(callback), json=payload, timeout=settings.REQUEST_TIMEOUT_SEC)
-        if not (status.HTTP_200_OK <= response.status_code < status.HTTP_300_MULTIPLE_CHOICES):
-            msg = f"Callback failed: {response.text}, url: {callback}"
-            _raise_callback_error(msg)
-    except Exception as e:
-        error_msg = f"Callback error: {e}"
-        logger.exception(error_msg)
-        _raise_callback_error(error_msg, e)
+    result = run_executable_sync(executable_path, args)
+
+    if callback:
+        payload = ExecutableRunResponse(
+            job_id=UUID(job_id),
+            result=result,
+        ).model_dump(mode="json")
+
+        def _raise_callback_error(message: str, error: Exception | None = None) -> None:
+            if error:
+                raise CallbackFailedError(message) from error
+            raise CallbackFailedError(message)
+
+        try:
+            response = requests.post(str(callback), json=payload, timeout=settings.REQUEST_TIMEOUT_SEC)
+            if not (status.HTTP_200_OK <= response.status_code < status.HTTP_300_MULTIPLE_CHOICES):
+                msg = f"Callback failed: {response.text}, url: {callback}"
+                _raise_callback_error(msg)
+        except Exception as e:
+            error_msg = f"Callback error: {e}"
+            logger.exception(error_msg)
+            _raise_callback_error(error_msg, e)

orchestrator_lso-2.2.0/lso/utils.py

@@ -0,0 +1,29 @@
+# Copyright 2024-2025 GÉANT Vereniging.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Utility functions for the LSO package."""
+
+from concurrent.futures import ThreadPoolExecutor
+
+from lso.config import settings
+
+_executor = None
+
+
+def get_thread_pool() -> ThreadPoolExecutor:
+    """Initialize or return a cached ThreadPoolExecutor for local asynchronous execution."""
+    global _executor  # noqa: PLW0603
+    if _executor is None:
+        _executor = ThreadPoolExecutor(max_workers=settings.MAX_THREAD_POOL_WORKERS)
+
+    return _executor

{orchestrator_lso-2.1.1 → orchestrator_lso-2.2.0}/pyproject.toml

@@ -33,10 +33,10 @@ dependencies = [
     "ansible==10.7.0",
     "fastapi==0.115.12",
     "httpx==0.28.1",
-    "uvicorn[standard]==0.34.2",
-    "requests==2.32.3",
+    "uvicorn[standard]==0.34.3",
+    "requests==2.32.4",
     "pydantic-settings==2.9.1",
-    "celery==5.5.2",
+    "celery==5.5.3",
     "redis==5.2.1",
 ]
 

{orchestrator_lso-2.1.1 → orchestrator_lso-2.2.0}/test/routes/test_execute.py

@@ -7,6 +7,7 @@ from fastapi import status
 from fastapi.testclient import TestClient
 
 from lso.config import ExecutorType
+from lso.schema import JobStatus
 from test.utils import temp_executable_env
 
 TEST_CALLBACK_URL = "http://localhost/callback"
@@ -121,3 +122,66 @@ def test_execute_endpoint_not_a_file(client: TestClient):
         response = client.post("/api/execute/", json=params)
         assert response.status_code == status.HTTP_404_NOT_FOUND
         assert response.json() == {"detail": "Executable 'not_a_file' is not a valid file."}
+
+
+@responses.activate
+def test_execute_endpoint_async_and_sync(client: TestClient, temp_executable: Path):
+    """Endpoint: async missing callback →422; async with callback →201+job_id; sync →201+job_id+result."""
+    with temp_executable_env(ExecutorType.THREADPOOL) as exec_dir:
+        target_exe = exec_dir / temp_executable.name
+        target_exe.write_text(temp_executable.read_text())
+        target_exe.chmod(0o755)
+
+        responses.add(responses.POST, TEST_CALLBACK_URL, status=200)
+
+        # async without callback
+        r1 = client.post("/api/execute/", json={"executable_name": temp_executable.name})
+        assert r1.status_code == status.HTTP_201_CREATED
+        responses.assert_call_count(TEST_CALLBACK_URL, 0)
+
+        # async with callback
+        r2 = client.post("/api/execute/", json={"executable_name": temp_executable.name, "callback": TEST_CALLBACK_URL})
+        assert r2.status_code == status.HTTP_201_CREATED
+        d2 = r2.json()
+        assert "job_id" in d2
+        assert d2.get("result") is None
+        responses.assert_call_count(TEST_CALLBACK_URL, 1)
+
+        # sync path
+        r3 = client.post("/api/execute/", json={"executable_name": temp_executable.name, "args": [], "is_async": False})
+        assert r3.status_code == status.HTTP_201_CREATED
+        d3 = r3.json()
+        assert "job_id" in d3
+        assert "result" in d3
+        res = d3["result"]
+        assert res["return_code"] == 0
+        assert res["status"] == JobStatus.SUCCESSFUL
+        assert "Executable Test" in res["output"]
+        responses.assert_call_count(TEST_CALLBACK_URL, 1)
+
+
+@responses.activate
+def test_execute_endpoint_sync_ignores_callback(client: TestClient, temp_executable: Path):
+    """When is_async=False, callback is accepted but not invoked."""
+    with temp_executable_env(ExecutorType.THREADPOOL) as exec_dir:
+        target_exe = exec_dir / temp_executable.name
+        target_exe.write_text(temp_executable.read_text())
+        target_exe.chmod(0o755)
+
+        # prepare a bogus callback just to see if it's ever called
+        responses.add(responses.POST, TEST_CALLBACK_URL, status=200)
+
+        rv = client.post(
+            "/api/execute/",
+            json={
+                "executable_name": temp_executable.name,
+                "is_async": False,
+                "callback": TEST_CALLBACK_URL,
+            },
+        )
+        assert rv.status_code == status.HTTP_201_CREATED
+        data = rv.json()
+        # result must be present
+        assert data["result"] is not None
+        # and no callback should have been invoked:
+        responses.assert_call_count(TEST_CALLBACK_URL, 0)

orchestrator_lso-2.2.0/test/test_execute.py

@@ -0,0 +1,126 @@
+import subprocess  # noqa: S404
+import uuid
+from pathlib import Path
+
+import pytest
+import responses
+
+from lso.config import ExecutorType
+from lso.execute import get_executable_path, run_executable_async, run_executable_sync
+from lso.schema import JobStatus
+from lso.tasks import CallbackFailedError
+from test.utils import temp_executable_env
+
+TEST_CALLBACK_URL = "http://localhost/callback"
+
+
+@responses.activate
+def test_run_executable_async_threadpool_success(temp_executable: Path):
+    """ThreadPool mode: successful async run invokes callback once."""
+    with temp_executable_env(ExecutorType.THREADPOOL) as exec_dir:
+        target_exe = exec_dir / temp_executable.name
+        target_exe.write_text(temp_executable.read_text())
+        target_exe.chmod(0o755)
+
+        responses.add(responses.POST, TEST_CALLBACK_URL, status=200)
+
+        job_id = run_executable_async(target_exe, ["--version"], TEST_CALLBACK_URL)
+        assert isinstance(job_id, uuid.UUID)
+        responses.assert_call_count(TEST_CALLBACK_URL, 1)
+
+
+@responses.activate
+def test_run_executable_async_threadpool_callback_failure(temp_executable: Path):
+    """ThreadPool mode: non-2xx callback raises CallbackFailedError."""
+    with temp_executable_env(ExecutorType.THREADPOOL) as exec_dir:
+        target_exe = exec_dir / temp_executable.name
+        target_exe.write_text(temp_executable.read_text())
+        target_exe.chmod(0o755)
+
+        responses.add(responses.POST, TEST_CALLBACK_URL, status=500)
+
+        with pytest.raises(CallbackFailedError) as exc:
+            run_executable_async(target_exe, [], TEST_CALLBACK_URL)
+
+        assert f"Callback failed: , url: {TEST_CALLBACK_URL}" in str(exc.value)
+
+
+def test_run_executable_async_worker_delay(monkeypatch, temp_executable: Path):
+    """Worker mode: schedules Celery .delay without HTTP calls."""
+    with temp_executable_env(ExecutorType.WORKER) as exec_dir:
+        target_exe = exec_dir / temp_executable.name
+        target_exe.write_text(temp_executable.read_text())
+        target_exe.chmod(0o755)
+
+        calls = []
+        import lso.execute as exec_mod  # noqa: PLC0415
+
+        monkeypatch.setattr(
+            exec_mod.run_executable_proc_task,
+            "delay",
+            lambda job_id, path, args, callback: calls.append((job_id, path, args, callback)),
+        )
+
+        job_id = run_executable_async(target_exe, ["a", "b"], TEST_CALLBACK_URL)
+        assert isinstance(job_id, uuid.UUID)
+        assert len(calls) == 1
+        called_job_id, called_path, called_args, called_callback = calls[0]
+        assert called_job_id == str(job_id)
+        assert called_path == str(target_exe)
+        assert called_args == ["a", "b"]
+        assert called_callback == TEST_CALLBACK_URL
+
+
+@pytest.mark.parametrize("args", [[], ["x"], ["1", "2", "3"]])
+def test_run_executable_sync_various_args(temp_executable: Path, args):
+    """Sync helper accepts different arg lists and returns correct status."""
+    # success exit
+    result = run_executable_sync(str(temp_executable), args)
+    assert result.return_code == 0
+    assert "Executable Test" in result.output
+    assert result.status == JobStatus.SUCCESSFUL
+
+    # failure exit
+    fail = temp_executable.with_name("fail.sh")
+    fail.write_text("#!/bin/sh\nexit 1\n")
+    fail.chmod(0o755)
+    result2 = run_executable_sync(str(fail), [])
+    assert result2.return_code == 1
+    assert result2.status == JobStatus.FAILED
+
+
+def test_get_executable_path_under_root():
+    """get_executable_path returns a path under EXECUTABLES_ROOT_DIR."""
+    with temp_executable_env(ExecutorType.THREADPOOL):
+        p = get_executable_path(Path("foo.sh"))
+        assert Path(p).parent.exists()
+
+
+def test_run_executable_sync_timeout(monkeypatch):
+    """If subprocess.run raises TimeoutExpired, we get return_code=-1 and the timeout message."""
+
+    # simulate subprocess.run raising TimeoutExpired
+    def fake_run(*args, **kwargs):  # noqa: ARG001
+        raise subprocess.TimeoutExpired(cmd=kwargs.get("args", []), timeout=0)
+
+    monkeypatch.setattr(subprocess, "run", fake_run)
+
+    result = run_executable_sync("/does/not/matter", [])
+    assert result.return_code == -1
+    assert result.output == "Execution timed out."
+    assert result.status == JobStatus.FAILED
+
+
+def test_run_executable_sync_exception(monkeypatch):
+    """If subprocess.run raises a generic Exception, it's captured as output and rc=-1."""
+
+    def fake_run(*args, **kwargs):  # noqa: ARG001
+        msg = "boom!"
+        raise RuntimeError(msg)
+
+    monkeypatch.setattr(subprocess, "run", fake_run)
+
+    result = run_executable_sync("/does/not/matter", ["x"])
+    assert result.return_code == -1
+    assert "boom!" in result.output
+    assert result.status == JobStatus.FAILED

orchestrator_lso-2.1.1/lso/execute.py

@@ -1,31 +0,0 @@
-"""Module for handling the execution of arbitrary executables."""
-
-import uuid
-from pathlib import Path
-
-from pydantic import HttpUrl
-
-from lso.config import ExecutorType, settings
-from lso.tasks import run_executable_proc_task
-from lso.utils import get_thread_pool
-
-
-def get_executable_path(executable_name: Path) -> Path:
-    """Return the full path of an executable, based on the configured EXECUTABLES_ROOT_DIR."""
-    return Path(settings.EXECUTABLES_ROOT_DIR) / executable_name
-
-
-def run_executable(executable_path: Path, args: list[str], callback: HttpUrl) -> uuid.UUID:
-    """Dispatch the task for executing an arbitrary executable remotely.
-
-    Uses a ThreadPoolExecutor (for local execution) or a Celery worker (for distributed tasks).
-    """
-    job_id = uuid.uuid4()
-    if settings.EXECUTOR == ExecutorType.THREADPOOL:
-        executor = get_thread_pool()
-        future = executor.submit(run_executable_proc_task, str(job_id), str(executable_path), args, str(callback))
-        if settings.TESTING:
-            future.result()
-    elif settings.EXECUTOR == ExecutorType.WORKER:
-        run_executable_proc_task.delay(str(job_id), str(executable_path), args, str(callback))
-    return job_id

orchestrator_lso-2.1.1/lso/utils.py

@@ -1,16 +0,0 @@
-"""Utility functions for the LSO package."""
-
-from concurrent.futures import ThreadPoolExecutor
-
-from lso.config import settings
-
-_executor = None
-
-
-def get_thread_pool() -> ThreadPoolExecutor:
-    """Initialize or return a cached ThreadPoolExecutor for local asynchronous execution."""
-    global _executor  # noqa: PLW0603
-    if _executor is None:
-        _executor = ThreadPoolExecutor(max_workers=settings.MAX_THREAD_POOL_WORKERS)
-
-    return _executor

orchestrator_lso-2.1.1/test/test_execute.py

@@ -1,27 +0,0 @@
-import uuid
-from pathlib import Path
-
-import responses
-
-from lso.config import ExecutorType
-from lso.execute import run_executable
-from test.utils import temp_executable_env
-
-TEST_CALLBACK_URL = "http://localhost/callback"
-
-
-@responses.activate
-def test_run_executable_threadpool(temp_executable: Path):
-    """
-    Test direct invocation of run_executable using the ThreadPool executor.
-    """
-    with temp_executable_env(ExecutorType.THREADPOOL) as exec_dir:
-        target_exe = exec_dir / temp_executable.name
-        target_exe.write_text(temp_executable.read_text())
-        target_exe.chmod(0o755)
-
-        # Simulate a successful callback.
-        responses.add(responses.POST, TEST_CALLBACK_URL, status=200)
-
-        job_id = run_executable(target_exe, ["--version"], TEST_CALLBACK_URL)
-        uuid.UUID(str(job_id))  # Validate job_id format.