Experiment with audit events in bootstrap.

[python_utils.git] / state_tracker.py

diff --git a/state_tracker.py b/state_tracker.py
index 225584bb1a907314de374c9da159d7afb5c96cb1..4f77ff42241474d214f222c428ae0f60e1da1e51 100644 (file)
--- a/state_tracker.py
+++ b/state_tracker.py
@@ -4,12 +4,12 @@ from abc import ABC, abstractmethod
 import datetime
 import logging
 import time
+import threading
 from typing import Dict, Optional
 
 import pytz
 
 from thread_utils import background_thread
-import math_utils
 
 logger = logging.getLogger(__name__)
 
@@ -67,33 +67,34 @@ class StateTracker(ABC):
         """
         self.now = datetime.datetime.now(tz=pytz.timezone("US/Pacific"))
         for update_id in sorted(self.last_reminder_ts.keys()):
-            refresh_secs = self.update_ids_to_update_secs[update_id]
             if force_all_updates_to_run:
                 logger.debug('Forcing all updates to run')
                 self.update(
                     update_id, self.now, self.last_reminder_ts[update_id]
                 )
                 self.last_reminder_ts[update_id] = self.now
+                return
+
+            refresh_secs = self.update_ids_to_update_secs[update_id]
+            last_run = self.last_reminder_ts[update_id]
+            if last_run is None:  # Never run before
+                logger.debug(
+                    f'id {update_id} has never been run; running it now'
+                )
+                self.update(
+                    update_id, self.now, self.last_reminder_ts[update_id]
+                )
+                self.last_reminder_ts[update_id] = self.now
             else:
-                last_run = self.last_reminder_ts[update_id]
-                if last_run is None:  # Never run before
-                    logger.debug(
-                        f'id {update_id} has never been run; running it now'
-                    )
+                delta = self.now - last_run
+                if delta.total_seconds() >= refresh_secs:  # Is overdue?
+                    logger.debug(f'id {update_id} is overdue; running it now')
                     self.update(
-                        update_id, self.now, self.last_reminder_ts[update_id]
+                        update_id,
+                        self.now,
+                        self.last_reminder_ts[update_id],
                     )
                     self.last_reminder_ts[update_id] = self.now
-                else:
-                    delta = self.now - last_run
-                    if delta.total_seconds() >= refresh_secs:  # Is overdue
-                        logger.debug('id {update_id} is overdue; running it now')
-                        self.update(
-                            update_id,
-                            self.now,
-                            self.last_reminder_ts[update_id],
-                        )
-                        self.last_reminder_ts[update_id] = self.now
 
 
 class AutomaticStateTracker(StateTracker):
@@ -112,7 +113,7 @@ class AutomaticStateTracker(StateTracker):
                 logger.debug('pace_maker noticed event; shutting down')
                 return
             self.heartbeat()
-            logger.debug(f'page_maker is sleeping for {self.sleep_delay}s')
+            logger.debug(f'pace_maker is sleeping for {self.sleep_delay}s')
             time.sleep(self.sleep_delay)
 
     def __init__(
@@ -121,6 +122,7 @@ class AutomaticStateTracker(StateTracker):
         *,
         override_sleep_delay: Optional[float] = None,
     ) -> None:
+        import math_utils
         super().__init__(update_ids_to_update_secs)
         if override_sleep_delay is not None:
             logger.debug(f'Overriding sleep delay to {override_sleep_delay}')
@@ -143,3 +145,32 @@ class AutomaticStateTracker(StateTracker):
         self.should_terminate.set()
         self.updater_thread.join()
         logger.debug('Background thread terminated.')
+
+
+class WaitableAutomaticStateTracker(AutomaticStateTracker):
+
+    def __init__(
+            self,
+            update_ids_to_update_secs: Dict[str, float],
+            *,
+            override_sleep_delay: Optional[float] = None,
+    ) -> None:
+        self._something_changed = threading.Event()
+        super().__init__(update_ids_to_update_secs,
+                         override_sleep_delay=override_sleep_delay)
+
+    def something_changed(self):
+        self._something_changed.set()
+
+    def did_something_change(self) -> bool:
+        return self._something_changed.is_set()
+
+    def reset(self):
+        self._something_changed.clear()
+
+    def wait(self,
+             *,
+             timeout=None):
+        return self._something_changed.wait(
+            timeout=timeout
+        )