orionis 0.510.0__tar.gz → 0.512.0__tar.gz

{orionis-0.510.0/orionis.egg-info → orionis-0.512.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orionis
-Version: 0.510.0
+Version: 0.512.0
 Summary: Orionis Framework – Elegant, Fast, and Powerful.
 Home-page: https://github.com/orionis-framework/framework
 Author: Raul Mauricio Uñate Castro

orionis-0.512.0/orionis/console/base/scheduler_event_listener.py

@@ -0,0 +1,136 @@
+from orionis.console.contracts.schedule import ISchedule
+from orionis.console.contracts.schedule_event_listener import IScheduleEventListener
+from orionis.console.entities.job_error import JobError
+from orionis.console.entities.job_executed import JobExecuted
+from orionis.console.entities.job_max_instances import JobMaxInstances
+from orionis.console.entities.job_missed import JobMissed
+from orionis.console.entities.job_pause import JobPause
+from orionis.console.entities.job_removed import JobRemoved
+from orionis.console.entities.job_resume import JobResume
+from orionis.console.entities.job_submitted import JobSubmitted
+
+class BaseScheduleEventListener(IScheduleEventListener):
+    """
+    Base implementation of the IScheduleEventListener interface.
+
+    This class provides method definitions for handling various job events in a
+    scheduling system. Subclasses should override these methods to implement
+    specific behavior for each event type.
+    """
+
+    async def before(self, event: JobSubmitted, schedule: ISchedule):
+        """
+        Called before processing a job submission event.
+
+        Parameters
+        ----------
+        event : JobSubmitted
+            The job submission event.
+        schedule : ISchedule
+            The associated schedule.
+        """
+        pass
+
+    async def after(self, event: JobExecuted, schedule: ISchedule):
+        """
+        Called after processing a job execution event.
+
+        Parameters
+        ----------
+        event : JobExecuted
+            The job execution event.
+        schedule : ISchedule
+            The associated schedule.
+        """
+        pass
+
+    async def onSuccess(self, event: JobExecuted, schedule: ISchedule):
+        """
+        Called when a job is successfully executed.
+
+        Parameters
+        ----------
+        event : JobExecuted
+            The successful job execution event.
+        schedule : ISchedule
+            The associated schedule.
+        """
+        pass
+
+    async def onFailure(self, event: JobError, schedule: ISchedule):
+        """
+        Called when a job execution fails.
+
+        Parameters
+        ----------
+        event : JobError
+            The job error event.
+        schedule : ISchedule
+            The associated schedule.
+        """
+        pass
+
+    async def onMissed(self, event: JobMissed, schedule: ISchedule):
+        """
+        Called when a job execution is missed.
+
+        Parameters
+        ----------
+        event : JobMissed
+            The missed job event.
+        schedule : ISchedule
+            The associated schedule.
+        """
+        pass
+
+    async def onMaxInstances(self, event: JobMaxInstances, schedule: ISchedule):
+        """
+        Called when a job exceeds the maximum allowed instances.
+
+        Parameters
+        ----------
+        event : JobMaxInstances
+            The max instances event.
+        schedule : ISchedule
+            The associated schedule.
+        """
+        pass
+
+    async def onPaused(self, event: JobPause, schedule: ISchedule):
+        """
+        Called when the scheduler is paused.
+
+        Parameters
+        ----------
+        event : JobPause
+            The pause event.
+        schedule : ISchedule
+            The associated schedule.
+        """
+        pass
+
+    async def onResumed(self, event: JobResume, schedule: ISchedule):
+        """
+        Called when the scheduler is resumed.
+
+        Parameters
+        ----------
+        event : JobResume
+            The resume event.
+        schedule : ISchedule
+            The associated schedule.
+        """
+        pass
+
+    async def onRemoved(self, event: JobRemoved, schedule: ISchedule):
+        """
+        Called when a job is removed from the scheduler.
+
+        Parameters
+        ----------
+        event : JobRemoved
+            The job removal event.
+        schedule : ISchedule
+            The associated schedule.
+        """
+        pass

{orionis-0.510.0 → orionis-0.512.0}/orionis/console/commands/scheduler_work.py

@@ -4,6 +4,7 @@ from rich.panel import Panel
 from rich.text import Text
 from orionis.console.base.command import BaseCommand
 from orionis.console.contracts.schedule import ISchedule
+from orionis.console.enums.listener import ListeningEvent
 from orionis.console.exceptions import CLIOrionisRuntimeError
 from orionis.container.exceptions.exception import OrionisContainerException
 from orionis.foundation.contracts.application import IApplication
@@ -74,16 +75,16 @@ class ScheduleWorkCommand(BaseCommand):
         try:
 
             # Retrieve the Scheduler instance from the application
-            Scheduler = app.getScheduler()
+            scheduler = app.getScheduler()
 
             # Create an instance of the ISchedule service
-            schedule_serice: ISchedule = app.make(ISchedule)
+            schedule_service: ISchedule = app.make(ISchedule)
 
             # Register scheduled tasks using the Scheduler's tasks method
-            Scheduler.tasks(schedule_serice)
+            await scheduler.tasks(schedule_service)
 
             # Retrieve the list of scheduled jobs/events
-            list_tasks = schedule_serice.events()
+            list_tasks = schedule_service.events()
 
             # Display a message if no scheduled jobs are found
             if not list_tasks:
@@ -92,33 +93,44 @@ class ScheduleWorkCommand(BaseCommand):
                 console.line()
                 return True
 
-            # Display a start message for the scheduler worker
-            console.line()
-            start_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
-            panel_content = Text.assemble(
-                (" Orionis Scheduler Worker ", "bold white on green"),
-                ("\n\n", ""),
-                ("The scheduled tasks worker has started successfully.\n", "white"),
-                (f"Started at: {start_time}\n", "dim"),
-                ("To stop the worker, press ", "white"),
-                ("Ctrl+C", "bold yellow"),
-                (".", "white")
-            )
-            console.print(
-                Panel(panel_content, border_style="green", padding=(1, 2))
-            )
-            console.line()
+            # If there are scheduled jobs and the scheduler has an onStarted method
+            if hasattr(scheduler, "onStarted"):
+                schedule_service._setListener(ListeningEvent.SCHEDULER_STARTED.value, scheduler.onStarted)
+
+            # If the scheduler has an onPaused method
+            if hasattr(scheduler, "onPaused"):
+                schedule_service._setListener(ListeningEvent.SCHEDULER_PAUSED.value, scheduler.onPaused)
+
+            # If the scheduler has an onResumed method
+            if hasattr(scheduler, "onResumed"):
+                schedule_service._setListener(ListeningEvent.SCHEDULER_RESUMED.value, scheduler.onResumed)
+
+            # If the scheduler has an onFinalized method
+            if hasattr(scheduler, "onFinalized"):
+                schedule_service._setListener(ListeningEvent.SCHEDULER_SHUTDOWN.value, scheduler.onFinalized)
+
+            # If the scheduler has an onError method
+            if hasattr(scheduler, "onError"):
+                schedule_service._setListener(ListeningEvent.SCHEDULER_ERROR.value, scheduler.onError)
+
+            # Check if the scheduler has specific pause, resume, and finalize times
+            if hasattr(scheduler, "PAUSE_AT") and isinstance(scheduler.PAUSE_AT, datetime):
+                schedule_service.pauseEverythingAt(scheduler.PAUSE_AT)
+
+            if hasattr(scheduler, "RESUME_AT") and isinstance(scheduler.RESUME_AT, datetime):
+                schedule_service.resumeEverythingAt(scheduler.RESUME_AT)
+
+            if hasattr(scheduler, "FINALIZE_AT") and isinstance(scheduler.FINALIZE_AT, datetime):
+                schedule_service.shutdownEverythingAt(scheduler.FINALIZE_AT)
 
             # Start the scheduler worker asynchronously
-            await schedule_serice.start()
+            await schedule_service.start()
+
+            # Flag to indicate the scheduler is running
             return True
 
         except Exception as e:
 
-            # If the exception is already a CLIOrionisRuntimeError or OrionisContainerException, re-raise it
-            if isinstance(e, (OrionisRuntimeError, OrionisContainerException)):
-                raise
-
             # Raise any unexpected exceptions as CLIOrionisRuntimeError
             raise CLIOrionisRuntimeError(
                 f"An unexpected error occurred while starting the scheduler worker: {e}"