orchestrator-lso 2.0.0__tar.gz → 2.1.0__tar.gz

{orchestrator_lso-2.0.0 → orchestrator_lso-2.1.0}/.bumpversion.cfg

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

{orchestrator_lso-2.0.0 → orchestrator_lso-2.1.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.0.0"
+RUN pip install orchestrator-lso=="2.1.0"
 RUN pip install -r requirements.txt
 
 # Install required Ansible Galaxy roles and collections

{orchestrator_lso-2.0.0 → orchestrator_lso-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: orchestrator-lso
-Version: 2.0.0
+Version: 2.1.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
@@ -25,15 +25,16 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+License-File: LICENSE
 Requires-Dist: ansible-runner==2.4.0
-Requires-Dist: ansible==10.6.0
-Requires-Dist: fastapi==0.115.5
-Requires-Dist: httpx==0.27.2
-Requires-Dist: uvicorn[standard]==0.32.0
+Requires-Dist: ansible==10.7.0
+Requires-Dist: fastapi==0.115.8
+Requires-Dist: httpx==0.28.1
+Requires-Dist: uvicorn[standard]==0.34.0
 Requires-Dist: requests==2.32.3
-Requires-Dist: pydantic-settings==2.5.2
+Requires-Dist: pydantic-settings==2.7.1
 Requires-Dist: celery==5.4.0
-Requires-Dist: redis==5.2.0
+Requires-Dist: redis==5.2.1
 Requires-Dist: types-setuptools ; extra == "dev"
 Requires-Dist: types-requests ; extra == "dev"
 Requires-Dist: toml ; extra == "dev"

orchestrator_lso-2.1.0/docs/source/index.rst

@@ -0,0 +1,34 @@
+Lightweight Service Orchestrator (LSO) Documentation
+=====================================================
+
+Introduction
+------------
+
+The Lightweight Service Orchestrator (LSO) is a simple tool designed to run Ansible playbooks remotely.
+It provides a straightforward way to send instructions, like inventory and variables, to Ansible through
+a REST API, making automation easier and more flexible.
+
+Why LSO?
+--------
+
+LSO was built to solve a common problem: running Ansible playbooks from a remote machine without setting
+up a complicated system. Many tools, like AWX, are powerful but require complex setups, like Kubernetes,
+and are tied to specific ecosystems.
+
+We wanted a lightweight, easy-to-use solution that works without extra layers. That’s why we created LSO.
+
+What LSO Does
+-------------
+
+LSO is a small FastAPI server that receives requests from remote services and uses `ansible-runner` to execute playbooks.
+
+It:
+- Accepts the playbook name, inventory details, and extra variables as input.
+- Runs the playbook on Ansible using this information.
+- Sends the results back, including the output and execution status.
+
+.. toctree::
+   :maxdepth: 1
+   :caption: Contents:
+
+   modules

{orchestrator_lso-2.0.0 → orchestrator_lso-2.1.0}/env.example

@@ -14,8 +14,6 @@ REQUEST_TIMEOUT_SEC=10
 # Celery configuration
 CELERY_BROKER_URL="redis://localhost:6379/0"
 CELERY_RESULT_BACKEND="redis://localhost:6379/0"
-CELERY_TIMEZONE="Europe/Amsterdam"
-CELERY_ENABLE_UTC=True
 CELERY_RESULT_EXPIRES=3600
 WORKER_QUEUE_NAME="lso-worker-queue"
 

{orchestrator_lso-2.0.0 → orchestrator_lso-2.1.0}/lso/__init__.py

@@ -13,7 +13,7 @@
 
 """LSO, an API for remotely running Ansible playbooks."""
 
-__version__ = "2.0.0"
+__version__ = "2.1.0"
 
 import logging
 
@@ -22,8 +22,11 @@ from fastapi.middleware.cors import CORSMiddleware
 
 from lso import environment
 from lso.routes.default import router as default_router
+from lso.routes.execute import router as executable_router
 from lso.routes.playbook import router as playbook_router
 
+logger = logging.getLogger(__name__)
+
 
 def create_app() -> FastAPI:
     """Initialise the :term:`LSO` app."""
@@ -35,9 +38,10 @@ def create_app() -> FastAPI:
 
     app.include_router(default_router, prefix="/api")
     app.include_router(playbook_router, prefix="/api/playbook")
+    app.include_router(executable_router, prefix="/api/execute")
 
     environment.setup_logging()
 
-    logging.info("FastAPI app initialized")
+    logger.info("FastAPI app initialized")
 
     return app

{orchestrator_lso-2.0.0 → orchestrator_lso-2.1.0}/lso/config.py

@@ -34,15 +34,15 @@ class Config(BaseSettings):
 
     TESTING: bool = False
     ANSIBLE_PLAYBOOKS_ROOT_DIR: str = "/path/to/ansible/playbooks"
+    EXECUTABLES_ROOT_DIR: str = "/path/to/executables"
     EXECUTOR: ExecutorType = ExecutorType.THREADPOOL
     MAX_THREAD_POOL_WORKERS: int = min(32, (os.cpu_count() or 1) + 4)
     REQUEST_TIMEOUT_SEC: int = 10
     CELERY_BROKER_URL: str = "redis://localhost:6379/0"
     CELERY_RESULT_BACKEND: str = "redis://localhost:6379/0"
-    CELERY_TIMEZONE: str = "Europe/Amsterdam"
-    CELERY_ENABLE_UTC: bool = True
     CELERY_RESULT_EXPIRES: int = 3600
     WORKER_QUEUE_NAME: str | None = None
+    EXECUTABLE_TIMEOUT_SEC: int = 300
 
 
 settings = Config()

orchestrator_lso-2.1.0/lso/execute.py

@@ -0,0 +1,31 @@
+"""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.0.0 → orchestrator_lso-2.1.0}/lso/playbook.py

@@ -14,7 +14,6 @@
 """Module that gathers common API responses and data models."""
 
 import uuid
-from concurrent.futures import ThreadPoolExecutor
 from pathlib import Path
 from typing import Any
 
@@ -22,22 +21,7 @@ from pydantic import HttpUrl
 
 from lso.config import ExecutorType, settings
 from lso.tasks import run_playbook_proc_task
-
-_executor = None
-
-
-def get_thread_pool() -> ThreadPoolExecutor:
-    """Get and optionally initialise a ThreadPoolExecutor.
-
-    Returns:
-        ThreadPoolExecutor
-
-    """
-    global _executor  # noqa: PLW0603
-    if _executor is None:
-        _executor = ThreadPoolExecutor(max_workers=settings.MAX_THREAD_POOL_WORKERS)
-
-    return _executor
+from lso.utils import get_thread_pool
 
 
 def get_playbook_path(playbook_name: Path) -> Path:
@@ -53,7 +37,7 @@ def run_playbook(
 ) -> uuid.UUID:
     """Run an Ansible playbook against a specified inventory.
 
-    :param Path playbook_path: playbook to be executed.
+    :param Path playbook_path: Playbook to be executed.
     :param dict[str, Any] extra_vars: Any extra vars needed for the playbook to run.
     :param dict[str, Any] | str inventory: The inventory that the playbook is executed against.
     :param HttpUrl callback: Callback URL where the playbook should send a status update when execution is completed.

orchestrator_lso-2.1.0/lso/routes/execute.py

@@ -0,0 +1,51 @@
+"""FastAPI route for running arbitrary executables."""
+
+import uuid
+from pathlib import Path
+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
+
+router = APIRouter()
+
+
+def _executable_path_validator(executable_name: Path) -> Path:
+    """Validate that the executable exists, is a file, and is marked as executable."""
+    executable_path = get_executable_path(executable_name)
+    if not executable_path.exists():
+        msg = f"Executable '{executable_path}' does not exist."
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=msg)
+    if not executable_path.is_file():
+        msg = f"Executable '{executable_name}' is not a valid file."
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=msg)
+    if not executable_path.stat().st_mode & 0o111:
+        msg = f"Executable '{executable_name}' is not marked as executable."
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=msg)
+    return executable_path
+
+
+ExecutableName = Annotated[Path, AfterValidator(_executable_path_validator)]
+
+
+class ExecutableRunParams(BaseModel):
+    """Request parameters for running an arbitrary executable."""
+
+    executable_name: ExecutableName
+    args: list[str] = []
+    callback: HttpUrl
+
+
+class ExecutableRunResponse(BaseModel):
+    """Response for running an arbitrary executable."""
+
+    job_id: uuid.UUID
+
+
+@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)

{orchestrator_lso-2.0.0 → orchestrator_lso-2.1.0}/lso/routes/playbook.py

@@ -36,7 +36,7 @@ def _inventory_validator(inventory: dict[str, Any] | str) -> dict[str, Any] | st
     """Validate the provided inventory format.
 
     Attempts to parse the inventory to verify its validity. If the inventory cannot be parsed or the inventory
-    format is incorrect an HTTP 422 error is raised.
+    format is incorrect, an HTTP 422 error is raised.
 
     :param inventory: The inventory to validate, can be a dictionary or a string.
     :return: The validated inventory if no errors are found.

orchestrator_lso-2.1.0/lso/tasks.py

@@ -0,0 +1,121 @@
+# Copyright 2023-2024 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 defines tasks for executing Ansible playbooks asynchronously using Celery.
+
+The primary task, `run_playbook_proc_task`, runs an Ansible playbook and sends a POST request with
+the results to a specified callback URL.
+"""
+
+import logging
+import subprocess  # noqa: S404
+from enum import StrEnum
+from typing import Any
+
+import ansible_runner
+import requests
+from starlette import status
+
+from lso.config import settings
+from lso.worker import RUN_EXECUTABLE, RUN_PLAYBOOK, celery
+
+logger = logging.getLogger(__name__)
+
+
+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
+) -> None:
+    """Celery task to run a playbook.
+
+    :param str job_id: Identifier of the job being executed.
+    :param str playbook_path: Path to the playbook to be executed.
+    :param dict[str, Any] extra_vars: Extra variables to pass to the playbook.
+    :param dict[str, Any] | str inventory: Inventory to run the playbook against.
+    :param HttpUrl callback: Callback URL for status updates.
+    :return: None
+    """
+    msg = f"playbook_path: {playbook_path}, callback: {callback}"
+    logger.info(msg)
+    ansible_playbook_run = ansible_runner.run(playbook=playbook_path, inventory=inventory, extravars=extra_vars)
+
+    payload = {
+        "status": ansible_playbook_run.status,
+        "job_id": job_id,
+        "output": ansible_playbook_run.stdout.readlines(),
+        "return_code": int(ansible_playbook_run.rc),
+    }
+
+    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 CallbackFailedError(msg)
+
+
+@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:
+    """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.
+    """
+    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)

orchestrator_lso-2.1.0/lso/utils.py

@@ -0,0 +1,16 @@
+"""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.0.0 → orchestrator_lso-2.1.0}/lso/worker.py

@@ -19,6 +19,7 @@ from celery.signals import worker_shutting_down
 from lso.config import settings
 
 RUN_PLAYBOOK = "lso.tasks.run_playbook_proc_task"
+RUN_EXECUTABLE = "lso.tasks.run_executable_proc_task"
 
 celery = Celery(
     "lso-worker",
@@ -26,11 +27,6 @@ celery = Celery(
     backend=settings.CELERY_RESULT_BACKEND,
 )
 
-if settings.TESTING:
-    celery.conf.update(backend=settings.CELERY_RESULT_BACKEND, task_ignore_result=False)
-else:
-    celery.conf.update(task_ignore_result=True)
-
 celery.conf.update(
     result_expires=settings.CELERY_RESULT_EXPIRES,
     worker_prefetch_multiplier=1,
@@ -38,11 +34,13 @@ celery.conf.update(
     task_send_sent_event=True,
     redbeat_redis_url=settings.CELERY_BROKER_URL,
     broker_connection_retry_on_startup=True,
+    task_ignore_result=not settings.TESTING,
 )
 
 if settings.WORKER_QUEUE_NAME:
     celery.conf.task_routes = {
         RUN_PLAYBOOK: {"queue": settings.WORKER_QUEUE_NAME},
+        RUN_EXECUTABLE: {"queue": settings.WORKER_QUEUE_NAME},
     }
 
 

{orchestrator_lso-2.0.0 → orchestrator_lso-2.1.0}/pyproject.toml

@@ -30,14 +30,14 @@ classifiers = [
 ]
 dependencies = [
     "ansible-runner==2.4.0",
-    "ansible==10.6.0",
-    "fastapi==0.115.5",
-    "httpx==0.27.2",
-    "uvicorn[standard]==0.32.0",
+    "ansible==10.7.0",
+    "fastapi==0.115.8",
+    "httpx==0.28.1",
+    "uvicorn[standard]==0.34.0",
     "requests==2.32.3",
-    "pydantic-settings==2.5.2",
+    "pydantic-settings==2.7.1",
     "celery==5.4.0",
-    "redis==5.2.0",
+    "redis==5.2.1",
 ]
 
 readme = "README.md"

{orchestrator_lso-2.0.0 → orchestrator_lso-2.1.0}/test/conftest.py

@@ -68,3 +68,12 @@ def client() -> TestClient:
 @pytest.fixture(scope="session")
 def faker() -> Faker:
     return Faker(locale="en_GB")
+
+
+@pytest.fixture
+def temp_executable(tmp_path: Path) -> Path:
+    # Create a temporary executable that echoes a message.
+    exe_file = tmp_path / "test_executable.sh"
+    exe_file.write_text("#!/bin/sh\necho 'Executable Test'\n")
+    exe_file.chmod(0o755)
+    return exe_file

orchestrator_lso-2.1.0/test/routes/test_execute.py

@@ -0,0 +1,123 @@
+import uuid
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import responses
+from fastapi import status
+from fastapi.testclient import TestClient
+
+from lso.config import ExecutorType
+from test.utils import temp_executable_env
+
+TEST_CALLBACK_URL = "http://localhost/callback"
+
+
+@responses.activate
+def test_execute_endpoint_threadpool_success(client: TestClient, temp_executable: Path):
+    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)
+
+        params = {
+            "executable_name": temp_executable.name,
+            "args": [],
+            "callback": TEST_CALLBACK_URL,
+        }
+        with (
+            patch("lso.execute.run_executable_proc_task") as mock_run_executable_proc_task,
+            patch("lso.execute.get_thread_pool") as mock_get_thread_pool,
+        ):
+            mock_executor = MagicMock()
+            mock_get_thread_pool.return_value = mock_executor
+            rv = client.post("/api/execute/", json=params)
+
+            assert rv.status_code == status.HTTP_201_CREATED
+            response = rv.json()
+
+        assert isinstance(response, dict)
+        uuid.UUID(response["job_id"])  # Validate job_id format.
+        mock_executor.submit.assert_called_once()
+        assert mock_run_executable_proc_task.call_count == 0
+
+
+@responses.activate
+def test_execute_endpoint_worker_success(client: TestClient, temp_executable: Path):
+    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)
+
+        # Simulate a successful callback.
+        responses.add(responses.POST, TEST_CALLBACK_URL, status=200)
+
+        params = {
+            "executable_name": temp_executable.name,
+            "args": [],
+            "callback": TEST_CALLBACK_URL,
+        }
+        with patch("lso.tasks.run_executable_proc_task.delay") as mock_celery_delay:
+            rv = client.post("/api/execute/", json=params)
+            assert rv.status_code == status.HTTP_201_CREATED
+            response = rv.json()
+
+        assert isinstance(response, dict)
+        uuid.UUID(response["job_id"])  # Validate job_id format.
+        mock_celery_delay.assert_called_once()
+
+
+@responses.activate
+def test_execute_endpoint_not_found(client: TestClient):
+    # Request with a non-existent executable should return 404.
+    params = {
+        "executable_name": "nonexistent.sh",
+        "args": [],
+        "callback": TEST_CALLBACK_URL,
+    }
+    response = client.post("/api/execute/", json=params)
+    assert response.status_code == status.HTTP_404_NOT_FOUND
+
+
+@responses.activate
+def test_execute_endpoint_not_executable(client: TestClient, tmp_path: Path):
+    # Create a file that exists but is not executable.
+    non_exe = tmp_path / "non_executable.sh"
+    non_exe.write_text("echo 'Hello'")
+    non_exe.chmod(0o644)
+    with temp_executable_env(ExecutorType.THREADPOOL) as exec_dir:
+        target_file = exec_dir / non_exe.name
+        target_file.write_text(non_exe.read_text())
+        target_file.chmod(0o644)
+        params = {
+            "executable_name": non_exe.name,
+            "args": [],
+            "callback": TEST_CALLBACK_URL,
+        }
+        response = client.post("/api/execute/", json=params)
+        assert response.status_code == status.HTTP_403_FORBIDDEN
+        assert response.json() == {"detail": f"Executable '{non_exe.name}' is not marked as executable."}
+
+
+@responses.activate
+def test_execute_endpoint_not_a_file(client: TestClient):
+    """
+    Test that if the provided executable path is a directory (exists but is not a file),
+    the endpoint returns a 404 with an appropriate error message.
+    """
+    with temp_executable_env(ExecutorType.THREADPOOL) as exec_dir:
+        # Create a directory within the temporary executables' environment.
+        target_dir = exec_dir / "not_a_file"
+        target_dir.mkdir()
+
+        params = {
+            "executable_name": "not_a_file",
+            "args": [],
+            "callback": TEST_CALLBACK_URL,
+        }
+
+        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."}

{orchestrator_lso-2.0.0 → orchestrator_lso-2.1.0}/test/routes/test_playbook.py

@@ -12,7 +12,6 @@
 # limitations under the License.
 import re
 from collections.abc import Callable
-from contextlib import contextmanager
 from pathlib import Path
 from unittest.mock import MagicMock, patch
 
@@ -21,22 +20,13 @@ import responses
 from fastapi import status
 from fastapi.testclient import TestClient
 
-from lso.config import ExecutorType, settings
+from lso.config import ExecutorType
 from lso.playbook import get_playbook_path
+from test.utils import temporary_executor
 
 TEST_CALLBACK_URL = "https://fqdn.abc.xyz/api/resume"
 
 
-@contextmanager
-def temporary_executor(executor_type: ExecutorType):
-    original_executor = settings.EXECUTOR
-    settings.EXECUTOR = executor_type
-    try:
-        yield
-    finally:
-        settings.EXECUTOR = original_executor
-
-
 @responses.activate
 def test_playbook_endpoint_dict_inventory_success(client: TestClient, mocked_ansible_runner_run: Callable) -> None:
     responses.post(url=TEST_CALLBACK_URL, status=status.HTTP_200_OK)
@@ -122,7 +112,7 @@ def test_playbook_endpoint_invalid_hosts(client: TestClient, mocked_ansible_runn
         response = rv.json()
 
     assert isinstance(response, dict)
-    assert 'Invalid "hosts" entry for "all" group' in re.sub("\n", " ", "".join(response["detail"]))
+    assert 'Invalid "hosts" entry for "all" group' in re.sub(r"\n", " ", "".join(response["detail"]))
     responses.assert_call_count(TEST_CALLBACK_URL, 0)
 
 
@@ -130,6 +120,7 @@ def test_playbook_endpoint_invalid_hosts(client: TestClient, mocked_ansible_runn
 def test_run_playbook_threadpool_execution(client: TestClient, mocked_ansible_runner_run: Callable) -> None:
     """Test that the playbook runs with ThreadPoolExecutor when ExecutorType is THREADPOOL."""
     with temporary_executor(ExecutorType.THREADPOOL):
+        # Simulate a successful callback.
         responses.post(url=TEST_CALLBACK_URL, status=status.HTTP_200_OK)
 
         params = {

orchestrator_lso-2.1.0/test/test_execute.py

@@ -0,0 +1,27 @@
+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.

orchestrator_lso-2.1.0/test/utils.py

@@ -0,0 +1,27 @@
+import tempfile
+from contextlib import contextmanager
+from pathlib import Path
+
+from lso.config import ExecutorType, settings
+
+
+@contextmanager
+def temporary_executor(executor_type: ExecutorType):
+    original_executor = settings.EXECUTOR
+    settings.EXECUTOR = executor_type
+    try:
+        yield
+    finally:
+        settings.EXECUTOR = original_executor
+
+
+@contextmanager
+def temp_executable_env(executor_type: ExecutorType) -> Path:
+    """Sets up a temporary executables environment and adjusts the executor type."""
+    original_executable_dir = settings.EXECUTABLES_ROOT_DIR
+    try:
+        with temporary_executor(executor_type), tempfile.TemporaryDirectory() as exec_dir:
+            settings.EXECUTABLES_ROOT_DIR = exec_dir
+            yield Path(exec_dir)
+    finally:
+        settings.EXECUTABLES_ROOT_DIR = original_executable_dir

orchestrator_lso-2.0.0/docs/source/index.rst

@@ -1,10 +0,0 @@
-Lightweight Service Orchestrator
-================================
-
-Code documentation for LSO (Lightweight Service Orchestrator).
-
-.. toctree::
-   :maxdepth: 1
-   :caption: Contents:
-
-   modules

orchestrator_lso-2.0.0/lso/tasks.py

@@ -1,64 +0,0 @@
-# Copyright 2023-2024 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 defines tasks for executing Ansible playbooks asynchronously using Celery.
-
-The primary task, `run_playbook_proc_task`, runs an Ansible playbook and sends a POST request with
-the results to a specified callback URL.
-"""
-
-import logging
-from typing import Any
-
-import ansible_runner
-import requests
-from starlette import status
-
-from lso.config import settings
-from lso.worker import RUN_PLAYBOOK, celery
-
-logger = logging.getLogger(__name__)
-
-
-class CallbackFailedError(Exception):
-    """Exception raised when a callback url can't be reached."""
-
-
-@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
-) -> None:
-    """Celery task to run a playbook.
-
-    :param str job_id: Identifier of the job being executed.
-    :param str playbook_path: Path to the playbook to be executed.
-    :param dict[str, Any] extra_vars: Extra variables to pass to the playbook.
-    :param dict[str, Any] | str inventory: Inventory to run the playbook against.
-    :param HttpUrl callback: Callback URL for status updates.
-    :return: None
-    """
-    msg = f"playbook_path: {playbook_path}, callback: {callback}"
-    logger.info(msg)
-    ansible_playbook_run = ansible_runner.run(playbook=playbook_path, inventory=inventory, extravars=extra_vars)
-
-    payload = {
-        "status": ansible_playbook_run.status,
-        "job_id": job_id,
-        "output": ansible_playbook_run.stdout.readlines(),
-        "return_code": int(ansible_playbook_run.rc),
-    }
-
-    request_result = requests.post(str(callback), json=payload, timeout=settings.REQUEST_TIMEOUT_SEC)
-    if not status.HTTP_200_OK <= request_result.status_code < status.HTTP_300_MULTIPLE_CHOICES:
-        msg = f"Callback failed: {request_result.text}, url: {callback}"
-        raise CallbackFailedError(msg)