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

ddeutil/workflow/scheduler.py

@@ -5,16 +5,16 @@
 # ------------------------------------------------------------------------------
 """
 The main schedule running is ``schedule_runner`` function that trigger the
-multiprocess of ``workflow_control`` function for listing schedules on 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
+    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
+    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.
 """
@@ -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
 
@@ -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_date=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,13 +500,20 @@ 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"{'=' * 80}"
+    )
+    return result.catch(
+        status=Status.SUCCESS, context={"task_date": current_date}
+    )
 
 
 def monitor(threads: ReleaseThreads) -> None:  # pragma: no cov
@@ -560,69 +526,44 @@ def monitor(threads: ReleaseThreads) -> None:  # pragma: no cov
     logger.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_date,
+    queue,
+    threads,
+    result: Result,
+    audit: type[Audit],
+) -> Result:  # pragma: no cov
+    """
 
-    :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:
+    :param stop_date:
+    :param queue:
+    :param threads:
+    :param result:
+    :param audit:
 
-    :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)
@@ -633,7 +574,8 @@ def schedule_control(
             stop=stop_date,
             queue=queue,
             threads=threads,
-            log=log,
+            audit=audit,
+            parent_run_id=result.parent_run_id,
         )
         .tag("control")
     )
@@ -651,9 +593,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_date:%Y-%m-%d %H:%M:%S}"
     )
 
     while True:
@@ -664,8 +605,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 +615,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_date=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
@@ -707,9 +718,10 @@ def schedule_runner(
                                         --> thread of release task 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 +733,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 +748,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)