fix: add safeguard against early triggers

Author: lukasthaler

coc/ext/triggers/triggers.py

@@ -85,6 +85,7 @@ def __init__(self,
         self.kwargs = kwargs
 
         self.task = None  # placeholder for the repeat task created in self.__wrapper
+        self.__next_run_time = None  # placeholder for the current target run time
 
     def __call__(self, func: CoroFunction):
         return self.__wrapper(func)
@@ -102,19 +103,24 @@ async def wrapped() -> None:
             async def inner():
                 # maybe wait for next trigger cycle
                 if not self.on_startup:
-                    next_run = self.next_run
+                    self.__next_run_time = self.next_run
                     if self.logger:
                         self.logger.info(
                             f'`on_startup` is set to `False`. First run of {self.__class__.__name__} for '
-                            f'{func.__name__}: {next_run.isoformat()}'
+                            f'{func.__name__}: {self.__next_run_time.isoformat()}'
                         )
-                    await self.sleep_until(next_run)
+                    await self.sleep_until(self.__next_run_time)
 
                 # repeat indefinitely
                 while True:
                     if self.logger:
                         self.logger.info(f'Running {self.__class__.__name__} for {func.__name__}')
 
+                    # safeguard against early triggers - apparently, a desync is possible
+                    now = datetime.now().astimezone()
+                    if self.__next_run_time is not None and now < self.__next_run_time:
+                        await asyncio.sleep(max((self.__next_run_time - now).total_seconds(), 0))
+
                     # call the decorated function
                     try:
                         if self.iter_args:
@@ -130,17 +136,18 @@ async def inner():
                         await self.__handle_exception(func, None, e)
 
                     # sleep until next execution time
-                    next_run = self.next_run
-                    if self.logger and datetime.now().astimezone() <= next_run:
+                    self.__next_run_time = self.next_run
+                    if self.logger and datetime.now().astimezone() <= self.__next_run_time:
                         self.logger.info(
-                            f'{self.__class__.__name__} finished for {func.__name__}. Next run: {next_run.isoformat()}'
+                            f'{self.__class__.__name__} finished for {func.__name__}. '
+                            f'Next run: {self.__next_run_time.isoformat()}'
                         )
                     elif self.logger:  # i.e. next_run is in the past
                         self.logger.warning(
                             f'{self.__class__.__name__} missed the scheduled run time for {func.__name__}. Running now'
                         )
 
-                    await self.sleep_until(next_run)
+                    await self.sleep_until(self.__next_run_time)
 
             # create a reference to the repeating task to prevent it from accidentally being garbage collected
             self.task = self.loop.create_task(inner())