ddeutil-workflow 0.0.33__py3-none-any.whl → 0.0.35__py3-none-any.whl

ddeutil/workflow/scheduler.py

@@ -4,18 +4,18 @@
 # license information.
 # ------------------------------------------------------------------------------
 """
-The main schedule running is ``schedule_runner`` function that trigger the
-multiprocess of ``workflow_control`` function for listing schedules on the
-config by ``Loader.finds(Schedule)``.
+The main schedule running is `schedule_runner` function that trigger the
+multiprocess of `schedule_control` function for listing schedules on the
+config by `Loader.finds(Schedule)`.
 
-    The ``workflow_control`` is the scheduler function that release 2 schedule
-functions; ``workflow_task``, and ``workflow_monitor``.
+    The `schedule_control` is the scheduler function that release 2 schedule
+functions; `workflow_task`, and `workflow_monitor`.
 
-    ``workflow_control`` --- Every minute at :02 --> ``workflow_task``
-                         --- Every 5 minutes     --> ``workflow_monitor``
+    `schedule_control` ---( Every minute at :02 )--> `schedule_task`
+                       ---( Every 5 minutes     )--> `monitor`
 
-    The ``workflow_task`` will run ``task.release`` method in threading object
-for multithreading strategy. This ``release`` method will run only one crontab
+    The `schedule_task` will run `task.release` method in threading object
+for multithreading strategy. This `release` method will run only one crontab
 value with the on field.
 """
 from __future__ import annotations
@@ -55,7 +55,7 @@ from .audit import Audit, get_audit
 from .conf import Loader, config, get_logger
 from .cron import On
 from .exceptions import ScheduleException, WorkflowException
-from .result import Result
+from .result import Result, Status
 from .utils import batch, delay
 from .workflow import Release, ReleaseQueue, Workflow, WorkflowTask
 
@@ -134,7 +134,7 @@ class ScheduleWorkflow(BaseModel):
                 on: list[str] = [on]
 
             if any(not isinstance(n, (dict, str)) for n in on):
-                raise TypeError("The ``on`` key should be list of str or dict")
+                raise TypeError("The `on` key should be list of str or dict")
 
             # NOTE: Pass on value to Loader and keep on model object to on
             #   field.
@@ -314,25 +314,19 @@ class Schedule(BaseModel):
         *,
         stop: datetime | None = None,
         externals: DictData | None = None,
-        log: type[Audit] | None = None,
-    ) -> None:  # pragma: no cov
+        audit: type[Audit] | None = None,
+        parent_run_id: str | None = None,
+    ) -> Result:  # pragma: no cov
         """Pending this schedule tasks with the schedule package.
 
         :param stop: A datetime value that use to stop running schedule.
         :param externals: An external parameters that pass to Loader.
-        :param log: A log class that use on the workflow task release for
-            writing its release log context.
+        :param audit: An audit class that use on the workflow task release for
+            writing its release audit context.
+        :param parent_run_id: A parent workflow running ID for this release.
         """
-        try:
-            from schedule import Scheduler
-        except ImportError:
-            raise ImportError(
-                "Should install schedule package before use this method."
-            ) from None
-
-        # NOTE: Get default logging.
-        log: type[Audit] = log or get_audit()
-        scheduler: Scheduler = Scheduler()
+        audit: type[Audit] = audit or get_audit()
+        result: Result = Result().set_parent_run_id(parent_run_id)
 
         # NOTE: Create the start and stop datetime.
         start_date: datetime = datetime.now(tz=config.tz)
@@ -346,66 +340,23 @@ class Schedule(BaseModel):
             second=0, microsecond=0
         ) + timedelta(minutes=1)
 
-        # NOTE: This schedule job will start every minute at :02 seconds.
-        (
-            scheduler.every(1)
-            .minutes.at(":02")
-            .do(
-                schedule_task,
-                tasks=self.tasks(
-                    start_date_waiting, queue=queue, externals=externals
-                ),
-                stop=stop_date,
-                queue=queue,
-                threads=threads,
-                log=log,
-            )
-            .tag("control")
-        )
-
-        # NOTE: Checking zombie task with schedule job will start every 5 minute at
-        #   :10 seconds.
-        (
-            scheduler.every(5)
-            .minutes.at(":10")
-            .do(
-                monitor,
-                threads=threads,
-            )
-            .tag("monitor")
-        )
-
-        # NOTE: Start running schedule
-        logger.info(
-            f"[SCHEDULE]: Schedule with stopper: {stop_date:%Y-%m-%d %H:%M:%S}"
+        scheduler_pending(
+            tasks=self.tasks(
+                start_date_waiting, queue=queue, externals=externals
+            ),
+            stop=stop_date,
+            queue=queue,
+            threads=threads,
+            result=result,
+            audit=audit,
         )
 
-        while True:
-            scheduler.run_pending()
-            time.sleep(1)
+        return result.catch(status=Status.SUCCESS)
 
-            # NOTE: Break the scheduler when the control job does not exist.
-            if not scheduler.get_jobs("control"):
-                scheduler.clear("monitor")
 
-                while len(threads) > 0:
-                    logger.warning(
-                        "[SCHEDULE]: Waiting schedule release thread that still "
-                        "running in background."
-                    )
-                    delay(10)
-                    monitor(threads)
-
-                break
-
-        logger.warning(
-            f"[SCHEDULE]: Queue: {[list(queue[wf].queue) for wf in queue]}"
-        )
-
-
-ResultOrCancelJob = Union[type[CancelJob], Result]
-ReturnCancelJob = Callable[P, ResultOrCancelJob]
-DecoratorCancelJob = Callable[[ReturnCancelJob], ReturnCancelJob]
+ResultOrCancel = Union[type[CancelJob], Result]
+ReturnResultOrCancel = Callable[P, ResultOrCancel]
+DecoratorCancelJob = Callable[[ReturnResultOrCancel], ReturnResultOrCancel]
 
 
 def catch_exceptions(cancel_on_failure: bool = False) -> DecoratorCancelJob:
@@ -418,10 +369,12 @@ def catch_exceptions(cancel_on_failure: bool = False) -> DecoratorCancelJob:
     :rtype: DecoratorCancelJob
     """
 
-    def decorator(func: ReturnCancelJob) -> ReturnCancelJob:  # pragma: no cov
+    def decorator(
+        func: ReturnResultOrCancel,
+    ) -> ReturnResultOrCancel:  # pragma: no cov
 
         @wraps(func)
-        def wrapper(*args: P.args, **kwargs: P.kwargs) -> ResultOrCancelJob:
+        def wrapper(*args: P.args, **kwargs: P.kwargs) -> ResultOrCancel:
             try:
                 return func(*args, **kwargs)
             except Exception as err:
@@ -438,8 +391,9 @@ def catch_exceptions(cancel_on_failure: bool = False) -> DecoratorCancelJob:
 class ReleaseThread(TypedDict):
     """TypeDict for the release thread."""
 
-    thread: Thread
+    thread: Optional[Thread]
     start_date: datetime
+    release_date: datetime
 
 
 ReleaseThreads = dict[str, ReleaseThread]
@@ -451,8 +405,9 @@ def schedule_task(
     stop: datetime,
     queue: dict[str, ReleaseQueue],
     threads: ReleaseThreads,
-    log: type[Audit],
-) -> type[CancelJob] | None:
+    audit: type[Audit],
+    parent_run_id: str | None = None,
+) -> ResultOrCancel:
     """Schedule task function that generate thread of workflow task release
     method in background. This function do the same logic as the workflow poke
     method, but it runs with map of schedules and the on values.
@@ -464,10 +419,12 @@ def schedule_task(
     :param stop: A stop datetime object that force stop running scheduler.
     :param queue: A mapping of alias name and ReleaseQueue object.
     :param threads: A mapping of alias name and Thread object.
-    :param log: A log class that want to make log object.
+    :param audit: An audit class that want to make audit object.
+    :param parent_run_id: A parent workflow running ID for this release.
 
-    :rtype: type[CancelJob] | None
+    :rtype: ResultOrCancel
     """
+    result: Result = Result().set_parent_run_id(parent_run_id)
     current_date: datetime = datetime.now(tz=config.tz)
     if current_date > stop.replace(tzinfo=config.tz):
         return CancelJob
@@ -490,14 +447,16 @@ def schedule_task(
         q: ReleaseQueue = queue[task.alias]
 
         # NOTE: Start adding queue and move the runner date in the WorkflowTask.
-        task.queue(stop, q, log=log)
+        task.queue(stop, q, audit=audit)
 
         # NOTE: Get incoming datetime queue.
-        logger.debug(f"[WORKFLOW]: Queue: {task.alias!r} : {list(q.queue)}")
+        result.trace.debug(
+            f"[WORKFLOW]: Queue: {task.alias!r} : {list(q.queue)}"
+        )
 
         # VALIDATE: Check the queue is empty or not.
         if not q.is_queued:
-            logger.warning(
+            result.trace.warning(
                 f"[WORKFLOW]: Queue is empty for : {task.alias!r} : "
                 f"{task.runner.cron}"
             )
@@ -508,7 +467,7 @@ def schedule_task(
             second=0, microsecond=0
         )
         if (first_date := q.first_queue.date) > current_release:
-            logger.debug(
+            result.trace.debug(
                 f"[WORKFLOW]: Skip schedule "
                 f"{first_date:%Y-%m-%d %H:%M:%S} for : {task.alias!r}"
             )
@@ -523,7 +482,7 @@ def schedule_task(
         release: Release = heappop(q.queue)
         heappush(q.running, release)
 
-        logger.info(
+        result.trace.info(
             f"[WORKFLOW]: Start thread: '{task.alias}|"
             f"{release.date:%Y%m%d%H%M}'"
         )
@@ -533,7 +492,7 @@ def schedule_task(
         thread_name: str = f"{task.alias}|{release.date:%Y%m%d%H%M}"
         thread: Thread = Thread(
             target=catch_exceptions(cancel_on_failure=True)(task.release),
-            kwargs={"release": release, "queue": q, "log": log},
+            kwargs={"release": release, "queue": q, "audit": audit},
             name=thread_name,
             daemon=True,
         )
@@ -541,88 +500,76 @@ def schedule_task(
         threads[thread_name] = {
             "thread": thread,
             "start_date": datetime.now(tz=config.tz),
+            "release_date": release.date,
         }
 
         thread.start()
 
         delay()
 
-    logger.debug(f"[SCHEDULE]: End schedule task {'=' * 80}")
+    result.trace.debug(
+        f"[SCHEDULE]: End schedule task at {current_date:%Y-%m-%d %H:%M:%S} "
+        f"{'=' * 60}"
+    )
+    return result.catch(
+        status=Status.SUCCESS, context={"task_date": current_date}
+    )
 
 
-def monitor(threads: ReleaseThreads) -> None:  # pragma: no cov
+def monitor(
+    threads: ReleaseThreads,
+    parent_run_id: str | None = None,
+) -> None:  # pragma: no cov
     """Monitoring function that running every five minute for track long-running
     thread instance from the schedule_control function that run every minute.
 
     :param threads: A mapping of Thread object and its name.
+    :param parent_run_id: A parent workflow running ID for this release.
+
     :type threads: ReleaseThreads
     """
-    logger.debug("[MONITOR]: Start checking long running schedule task.")
+    result: Result = Result().set_parent_run_id(parent_run_id)
+    result.trace.debug("[MONITOR]: Start checking long running schedule task.")
 
     snapshot_threads: list[str] = list(threads.keys())
-    for t_name in snapshot_threads:
+    for thread_name in snapshot_threads:
 
-        thread_release: ReleaseThread = threads[t_name]
+        thread_release: ReleaseThread = threads[thread_name]
 
         # NOTE: remove the thread that running success.
-        if not thread_release["thread"].is_alive():
-            threads.pop(t_name)
+        thread = thread_release["thread"]
+        if thread and (not thread_release["thread"].is_alive()):
+            thread_release["thread"] = None
 
 
-def schedule_control(
-    schedules: list[str],
-    stop: datetime | None = None,
-    externals: DictData | None = None,
-    *,
-    log: type[Audit] | None = None,
-) -> list[str]:  # pragma: no cov
-    """Scheduler control function that run the chuck of schedules every minute
-    and this function release monitoring thread for tracking undead thread in
-    the background.
+def scheduler_pending(
+    tasks: list[WorkflowTask],
+    stop: datetime,
+    queue: dict[str, ReleaseQueue],
+    threads: ReleaseThreads,
+    result: Result,
+    audit: type[Audit],
+) -> Result:  # pragma: no cov
+    """Scheduler pending function.
 
-    :param schedules: A list of workflow names that want to schedule running.
-    :param stop: A datetime value that use to stop running schedule.
-    :param externals: An external parameters that pass to Loader.
-    :param log: A log class that use on the workflow task release for writing
-        its release log context.
+    :param tasks: A list of WorkflowTask object.
+    :param stop: A stop datetime object that force stop running scheduler.
+    :param queue: A mapping of alias name and ReleaseQueue object.
+    :param threads: A mapping of alias name and Thread object.
+    :param result: A result object.
+    :param audit: An audit class that want to make audit object.
 
-    :rtype: list[str]
+    :rtype: Result
     """
-    # NOTE: Lazy import Scheduler object from the schedule package.
     try:
         from schedule import Scheduler
     except ImportError:
         raise ImportError(
-            "Should install schedule package before use this module."
+            "Should install schedule package before use this method."
         ) from None
 
-    # NOTE: Get default logging.
-    log: type[Audit] = log or get_audit()
     scheduler: Scheduler = Scheduler()
 
-    # NOTE: Create the start and stop datetime.
-    start_date: datetime = datetime.now(tz=config.tz)
-    stop_date: datetime = stop or (start_date + config.stop_boundary_delta)
-
-    # IMPORTANT: Create main mapping of queue and thread object.
-    queue: dict[str, ReleaseQueue] = {}
-    threads: ReleaseThreads = {}
-
-    start_date_waiting: datetime = start_date.replace(
-        second=0, microsecond=0
-    ) + timedelta(minutes=1)
-
-    tasks: list[WorkflowTask] = []
-    for name in schedules:
-        schedule: Schedule = Schedule.from_loader(name, externals=externals)
-        tasks.extend(
-            schedule.tasks(
-                start_date_waiting,
-                queue=queue,
-                externals=externals,
-            ),
-        )
-
     # NOTE: This schedule job will start every minute at :02 seconds.
     (
         scheduler.every(1)
@@ -630,10 +577,11 @@ def schedule_control(
         .do(
             schedule_task,
             tasks=tasks,
-            stop=stop_date,
+            stop=stop,
             queue=queue,
             threads=threads,
-            log=log,
+            audit=audit,
+            parent_run_id=result.parent_run_id,
         )
         .tag("control")
     )
@@ -651,9 +599,8 @@ def schedule_control(
     )
 
     # NOTE: Start running schedule
-    logger.info(
-        f"[SCHEDULE]: Schedule: {schedules} with stopper: "
-        f"{stop_date:%Y-%m-%d %H:%M:%S}"
+    result.trace.info(
+        f"[SCHEDULE]: Schedule with stopper: {stop:%Y-%m-%d %H:%M:%S}"
     )
 
     while True:
@@ -664,8 +611,8 @@ def schedule_control(
         if not scheduler.get_jobs("control"):
             scheduler.clear("monitor")
 
-            while len(threads) > 0:
-                logger.warning(
+            while len([t for t in threads.values() if t["thread"]]) > 0:
+                result.trace.warning(
                     "[SCHEDULE]: Waiting schedule release thread that still "
                     "running in background."
                 )
@@ -674,17 +621,87 @@ def schedule_control(
 
             break
 
-    logger.warning(
+    result.trace.warning(
         f"[SCHEDULE]: Queue: {[list(queue[wf].queue) for wf in queue]}"
     )
-    return schedules
+    return result.catch(
+        status=Status.SUCCESS,
+        context={
+            "threads": [
+                {
+                    "name": thread,
+                    "start_date": threads[thread]["start_date"],
+                    "release_date": threads[thread]["release_date"],
+                }
+                for thread in threads
+            ],
+        },
+    )
+
+
+def schedule_control(
+    schedules: list[str],
+    stop: datetime | None = None,
+    externals: DictData | None = None,
+    *,
+    audit: type[Audit] | None = None,
+    parent_run_id: str | None = None,
+) -> Result:  # pragma: no cov
+    """Scheduler control function that run the chuck of schedules every minute
+    and this function release monitoring thread for tracking undead thread in
+    the background.
+
+    :param schedules: A list of workflow names that want to schedule running.
+    :param stop: A datetime value that use to stop running schedule.
+    :param externals: An external parameters that pass to Loader.
+    :param audit: An audit class that use on the workflow task release for
+        writing its release audit context.
+    :param parent_run_id: A parent workflow running ID for this release.
+
+    :rtype: Result
+    """
+    audit: type[Audit] = audit or get_audit()
+    result: Result = Result().set_parent_run_id(parent_run_id)
+
+    # NOTE: Create the start and stop datetime.
+    start_date: datetime = datetime.now(tz=config.tz)
+    stop_date: datetime = stop or (start_date + config.stop_boundary_delta)
+
+    # IMPORTANT: Create main mapping of queue and thread object.
+    queue: dict[str, ReleaseQueue] = {}
+    threads: ReleaseThreads = {}
+
+    start_date_waiting: datetime = start_date.replace(
+        second=0, microsecond=0
+    ) + timedelta(minutes=1)
+
+    tasks: list[WorkflowTask] = []
+    for name in schedules:
+        tasks.extend(
+            Schedule.from_loader(name, externals=externals).tasks(
+                start_date_waiting,
+                queue=queue,
+                externals=externals,
+            ),
+        )
+
+    scheduler_pending(
+        tasks=tasks,
+        stop=stop_date,
+        queue=queue,
+        threads=threads,
+        result=result,
+        audit=audit,
+    )
+
+    return result.catch(status=Status.SUCCESS, context={"schedules": schedules})
 
 
 def schedule_runner(
     stop: datetime | None = None,
     externals: DictData | None = None,
     excluded: list[str] | None = None,
-) -> list[str]:  # pragma: no cov
+) -> Result:  # pragma: no cov
     """Schedule runner function it the multiprocess controller function for
     split the setting schedule to the `schedule_control` function on the
     process pool. It chunks schedule configs that exists in config
@@ -696,20 +713,22 @@ def schedule_runner(
 
         This function will get all workflows that include on value that was
     created in config path and chuck it with application config variable
-    ``WORKFLOW_APP_MAX_SCHEDULE_PER_PROCESS`` env var to multiprocess executor
+    `WORKFLOW_APP_MAX_SCHEDULE_PER_PROCESS` env var to multiprocess executor
     pool.
 
         The current workflow logic that split to process will be below diagram:
 
-        MAIN ==> process 01 ==> schedule --> thread of release task 01 01
-                                        --> thread of release task 01 02
-                            ==> schedule --> thread of release task 02 01
-                                        --> thread of release task 02 02
+        MAIN ==> process 01 ==> schedule ==> thread 01 --> 01
+                                         ==> thread 01 --> 02
+                            ==> schedule ==> thread 02 --> 01
+                                         ==> thread 02 --> 02
+                                         ==> ...
             ==> process 02  ==> ...
 
-    :rtype: list[str]
+    :rtype: Result
     """
-    results: list[str] = []
+    result: Result = Result()
+    context: DictData = {"schedules": [], "threads": []}
 
     with ProcessPoolExecutor(
         max_workers=config.max_schedule_process,
@@ -721,6 +740,7 @@ def schedule_runner(
                 schedules=[load[0] for load in loader],
                 stop=stop,
                 externals=(externals or {}),
+                parent_run_id=result.parent_run_id,
             )
             for loader in batch(
                 Loader.finds(Schedule, excluded=excluded),
@@ -735,6 +755,8 @@ def schedule_runner(
                 logger.error(str(err))
                 raise WorkflowException(str(err)) from err
 
-            results.extend(future.result(timeout=1))
+            rs: Result = future.result(timeout=1)
+            context["schedule"].extend(rs.context.get("schedules", []))
+            context["threads"].extend(rs.context.get("threads", []))
 
-    return results
+    return result.catch(status=0, context=context)