orchestrator-lso 2.4.0__py3-none-any.whl → 2.4.2__py3-none-any.whl

lso/__init__.py

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

lso/playbook.py

@@ -13,22 +13,15 @@
 
 """Module that gathers common API responses and data models."""
 
-import logging
-from collections.abc import Callable
 from pathlib import Path
 from typing import Any
 from uuid import UUID, uuid4
 
-import requests
-from ansible_runner import Runner
 from pydantic import HttpUrl
-from starlette import status
 
 from lso.config import ExecutorType, settings
 from lso.tasks import run_playbook_proc_task
-from lso.utils import CallbackFailedError, get_thread_pool
-
-logger = logging.getLogger(__name__)
+from lso.utils import get_thread_pool
 
 
 def get_playbook_path(playbook_name: Path) -> Path:
@@ -36,57 +29,6 @@ def get_playbook_path(playbook_name: Path) -> Path:
     return Path(settings.ANSIBLE_PLAYBOOKS_ROOT_DIR) / playbook_name
 
 
-def playbook_event_handler_factory(progress: str, *, progress_is_incremental: bool) -> Callable[[dict], bool]:
-    """Create an event handler for Ansible playbook runs.
-
-    This is used to send incremental progress updates to the external system that called for this playbook to be run.
-
-    :param str progress: The progress URL where the external system expects to receive updates.
-    :param bool progress_is_incremental: Whether progress updates are sent incrementally, or only contain the latest
-                                         event data.
-    :return Callable[[dict], bool]]: A handler method that processes every Ansible playbook event.
-    """
-    events_stdout = []
-
-    def _playbook_event_handler(event: dict) -> bool:
-        if progress_is_incremental:
-            emit_body = event["stdout"].strip()
-        else:
-            events_stdout.append(event["stdout"].strip())
-            emit_body = events_stdout
-
-        requests.post(str(progress), json={"progress": emit_body}, timeout=settings.REQUEST_TIMEOUT_SEC)
-        return True
-
-    return _playbook_event_handler
-
-
-def playbook_finished_handler_factory(callback: str, job_id: UUID) -> Callable[[Runner], None]:
-    """Create an event handler for finished Ansible playbook runs.
-
-    Once Ansible runner is finished, it will call the handler method created by this factory before teardown.
-
-    :param str callback: The callback URL that ansible runner should report to.
-    :param UUID job_id: The job ID of this playbook run, used for reporting.
-    :return Callable[[Runner], None]: A handler method that sends one request to the callback URL.
-    """
-
-    def _playbook_finished_handler(runner: Runner) -> None:
-        payload = {
-            "status": runner.status,
-            "job_id": str(job_id),
-            "output": runner.stdout.readlines(),
-            "return_code": int(runner.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)
-
-    return _playbook_finished_handler
-
-
 def run_playbook(
     playbook_path: Path,
     extra_vars: dict[str, Any],
@@ -105,39 +47,38 @@ def run_playbook(
                              This is used for workflow-orchestrator to continue with the next step in a workflow.
     :return UUID: Job ID of the launched playbook.
     """
-    msg = f"playbook_path: {playbook_path}"
     job_id = uuid4()
     callback_str = None
     progress_str = None
-    event_handler = None
-    finished_callback = None
-
     if callback:
         callback_str = str(callback)
-        msg += f", callback URL: {callback_str}"
-        finished_callback = playbook_finished_handler_factory(callback_str, job_id)
     if progress:
         progress_str = str(progress)
-        msg += f", progress URL: {progress_str}"
-        event_handler = playbook_event_handler_factory(progress_str, progress_is_incremental=progress_is_incremental)
-
-    logger.info(msg)
 
     if settings.EXECUTOR == ExecutorType.THREADPOOL:
         executor = get_thread_pool()
         executor_handle = executor.submit(
-            run_playbook_proc_task, str(playbook_path), extra_vars, inventory, event_handler, finished_callback
+            run_playbook_proc_task,
+            str(job_id),
+            str(playbook_path),
+            extra_vars,
+            inventory,
+            callback_str,
+            progress_str,
+            progress_is_incremental=progress_is_incremental,
         )
         if settings.TESTING:
             executor_handle.result()
 
     elif settings.EXECUTOR == ExecutorType.WORKER:
         run_playbook_proc_task.delay(
+            str(job_id),
             str(playbook_path),
             extra_vars,
             inventory,
-            event_handler,
-            finished_callback,
+            callback_str,
+            progress_str,
+            progress_is_incremental=progress_is_incremental,
         )
 
     return job_id

lso/tasks.py

@@ -28,37 +28,106 @@ from starlette import status
 
 from lso.config import settings
 from lso.schema import ExecutableRunResponse
-from lso.utils import CallbackFailedError
 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."""
+
+
+def playbook_event_handler_factory(
+    progress: str | None, *, progress_is_incremental: bool
+) -> Callable[[dict], bool] | None:
+    """Create an event handler for Ansible playbook runs.
+
+    This is used to send incremental progress updates to the external system that called for this playbook to be run.
+
+    :param str progress: The progress URL where the external system expects to receive updates.
+    :param bool progress_is_incremental: Whether progress updates are sent incrementally, or contain the whole history
+                                         of event data.
+    """
+    events_stdout = []
+
+    def _playbook_event_handler(event: dict) -> bool:
+        event_data = event["stdout"].strip()
+        if not event_data:
+            return False
+
+        event_data_lines = event_data.split("\r\n")
+        if progress_is_incremental:
+            emit_body = event_data_lines
+        else:
+            events_stdout.extend(event_data_lines)
+            emit_body = events_stdout
+
+        requests.post(str(progress), json={"progress": emit_body}, timeout=settings.REQUEST_TIMEOUT_SEC)
+        return True
+
+    if progress:
+        return _playbook_event_handler
+    return None
+
+
+def playbook_finished_handler_factory(callback: str | None, job_id: str) -> Callable[[Runner], None] | None:
+    """Create an event handler for finished Ansible playbook runs.
+
+    Once Ansible runner is finished, it will call the handler method created by this factory before teardown.
+
+    :param str callback: The callback URL that ansible runner should report to.
+    :param str job_id: The job ID of this playbook run, used for reporting.
+    :return Callable: A handler method that sends one request to the callback URL.
+    """
+
+    def _playbook_finished_handler(runner: Runner) -> None:
+        payload = {
+            "status": runner.status,
+            "job_id": job_id,
+            "output": runner.stdout.readlines(),
+            "return_code": int(runner.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)
+
+    if callback:
+        return _playbook_finished_handler
+    return None
+
+
 @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,
-    event_handler: Callable[[dict], bool] | None = None,
-    finished_callback: Callable[[Runner], None] | None = None,
+    callback: str | None,
+    progress: str | None,
+    *,
+    progress_is_incremental: bool,
 ) -> 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 Callable[[dict], bool] event_handler: Event handler method that is executed on every event while the playbook
-                                                 runs.
-    :param Callable[[Runner], None] finished_callback: Callback handler method that is executed once the playbook run is
-                                                       completed.
+    :param str callback: Callback URL for status updates.
+    :param str progress: URL for sending progress updates.
+    :param bool progress_is_incremental: Whether progress updates include all past progress.
     :return: None
     """
+    msg = f"playbook_path: {playbook_path}, callback: {callback}"
+    logger.info(msg)
     run(
         playbook=playbook_path,
         inventory=inventory,
         extravars=extra_vars,
-        event_handler=event_handler,
-        finished_callback=finished_callback,
+        event_handler=playbook_event_handler_factory(progress, progress_is_incremental=progress_is_incremental),
+        finished_callback=playbook_finished_handler_factory(callback, job_id),
     )
 
 

lso/utils.py

@@ -20,10 +20,6 @@ from lso.config import settings
 _executor = None
 
 
-class CallbackFailedError(Exception):
-    """Exception raised when a callback url can't be reached."""
-
-
 def get_thread_pool() -> ThreadPoolExecutor:
     """Initialize or return a cached ThreadPoolExecutor for local asynchronous execution."""
     global _executor  # noqa: PLW0603

{orchestrator_lso-2.4.0.dist-info → orchestrator_lso-2.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orchestrator-lso
-Version: 2.4.0
+Version: 2.4.2
 Summary: LSO, an API for remotely running Ansible playbooks.
 Author: GÉANT Orchestration and Automation Team
 Author-email: GÉANT Orchestration and Automation Team <goat@geant.org>

{orchestrator_lso-2.4.0.dist-info → orchestrator_lso-2.4.2.dist-info}/RECORD

@@ -1,17 +1,17 @@
-lso/__init__.py,sha256=uZ6rBsNmtFc11EZl1eag4GsGhtFpLCDEzdzO4GH-H5o,1589
+lso/__init__.py,sha256=-1xhYhBAtzdi8TaFrK-xyzqp29irj-3lhitkNlZefyU,1589
 lso/app.py,sha256=PCdL4hY5i1fho_pMSiNAHuaIKWPgfQNyePsZ-LdasCg,775
 lso/config.py,sha256=tyxjq67EJLEMLmpIlkxrtwJ3arm8ZUBNGkj9NTsBJxw,1639
 lso/environment.py,sha256=4k8a8cSLwgLjBIU-XUa7Y6Clns2VjmsBkiKvkzK2Pp4,1771
 lso/execute.py,sha256=T-HL9Q86vGU5VunjP7mjokRYvaVs0EnkSOFXZUT_GJE,2731
-lso/playbook.py,sha256=-WcL-kFXaBqSnvA4XlS7r0Rga8b05g5Ynk9VewTa3kQ,5500
+lso/playbook.py,sha256=Hh2k3hpBcm5lVeEnmsPguYfJw6uQhaCUUjDprjWDLBQ,2866
 lso/routes/__init__.py,sha256=l2hfxU8DF_bhbZ4GQ24VzcLjlZMfVSjUNBWSk1beEPw,639
 lso/routes/default.py,sha256=ScSrDFjbGqjcjeOodMTKZUMzZqXZ0zC6L-I9hrP0dqk,1438
 lso/routes/execute.py,sha256=nDmilV2THCnPzAIHGUjYBuETrL0QeOQSUC7z5M3EaMA,2713
 lso/routes/playbook.py,sha256=9ughP7zqnqRpBV31KQbTMoJdfgzF0qyjxiXw1l3TlUE,5270
 lso/schema.py,sha256=Xp4D7FRc21Mhh-1xlp0EbjTvdu5kGEHRpQvQp6ic6ro,1518
-lso/tasks.py,sha256=Ddj5smLkbafpdBbS3_fbz-stX72Zy3-jqODuyV5QhGc,3847
-lso/utils.py,sha256=Ml2JCHdy9BPJ4ItjYhx5z3lHwKQiJ9JzMySktrRzo_Q,1148
+lso/tasks.py,sha256=F-Wbis-ylL7Vwy6qMu2fS-S9WRzIUvkkIcD8LFCDMUw,6377
+lso/utils.py,sha256=eVKyYRtdu_yPkbUQqDJlCKlCPAgc0dFxG1E1kY2Qsao,1043
 lso/worker.py,sha256=ZAXii3EctILrpnHInvVMTyjOs_40gqR_VybVLBzGRw4,1727
-orchestrator_lso-2.4.0.dist-info/WHEEL,sha256=5w2T7AS2mz1-rW9CNagNYWRCaB0iQqBMYLwKdlgiR4Q,78
-orchestrator_lso-2.4.0.dist-info/METADATA,sha256=xPixjYkEuCEDtHbOpFsGm5TuzCLSuLKRewrcL8rKGDQ,5621
-orchestrator_lso-2.4.0.dist-info/RECORD,,
+orchestrator_lso-2.4.2.dist-info/WHEEL,sha256=5w2T7AS2mz1-rW9CNagNYWRCaB0iQqBMYLwKdlgiR4Q,78
+orchestrator_lso-2.4.2.dist-info/METADATA,sha256=uQS0-YaAJ6xo-8_PtrT65XdKjlZtdmsl-ZCvw0sLtFk,5621
+orchestrator_lso-2.4.2.dist-info/RECORD,,