Adding fancier version checks to allow to the cache to be preserved longer

[theonering] / src / gvoice / state_machine.py

diff --git a/src/gvoice/state_machine.py b/src/gvoice/state_machine.py
index bb58c7e..6d184d0 100644 (file)
--- a/src/gvoice/state_machine.py
+++ b/src/gvoice/state_machine.py
@@ -2,14 +2,12 @@
 
 import logging
 
-import gobject
-
 import util.go_utils as gobject_utils
 import util.coroutines as coroutines
-import gtk_toolbox
+import util.misc as misc_utils
 
 
-_moduleLogger = logging.getLogger("gvoice.state_machine")
+_moduleLogger = logging.getLogger(__name__)
 
 
 def to_milliseconds(**kwd):
@@ -109,6 +107,11 @@ class NTimesStateStrategy(object):
                except IndexError:
                        return self._postTimeout
 
+       def __str__(self):
+               return "NTimesStateStrategy(timeout=%r)" % (
+                       self.timeout,
+               )
+
        def __repr__(self):
                return "NTimesStateStrategy(timeouts=%r, postTimeout=%r)" % (
                        self._timeouts,
@@ -151,6 +154,11 @@ class GeometricStateStrategy(object):
                        timeout = self._init + self._current
                return timeout
 
+       def __str__(self):
+               return "GeometricStateStrategy(timeout=%r)" % (
+                       self.timeout
+               )
+
        def __repr__(self):
                return "GeometricStateStrategy(init=%r, min=%r, max=%r)" % (
                        self._init, self._min, self._max
@@ -226,9 +234,10 @@ class UpdateStateMachine(StateMachine):
                self._name = name
                self._updateItems = updateItems
                self._maxTime = maxTime
+               self._isActive = False
 
                self._state = self.STATE_ACTIVE
-               self._timeoutId = None
+               self._onTimeout = gobject_utils.Timeout(self._on_timeout)
 
                self._strategies = {}
                self._callback = coroutines.func_sink(
@@ -237,6 +246,14 @@ class UpdateStateMachine(StateMachine):
                        )
                )
 
+       def __str__(self):
+               return """UpdateStateMachine(
+       name=%r,
+       strategie=%s,
+       isActive=%r,
+       isPolling=%r,
+)""" % (self._name, self._strategy, self._isActive, self._onTimeout.is_running())
+
        def __repr__(self):
                return """UpdateStateMachine(
        name=%r,
@@ -247,19 +264,20 @@ class UpdateStateMachine(StateMachine):
                self._strategies[state] = strategy
 
        def start(self):
-               assert self._timeoutId is None
                for strategy in self._strategies.itervalues():
                        strategy.initialize_state()
                if self._strategy.timeout != self.INFINITE_PERIOD:
-                       self._timeoutId = gobject.idle_add(self._on_timeout)
+                       self._onTimeout.start(seconds=0)
+               self._isActive = True
                _moduleLogger.info("%s Starting State Machine" % (self._name, ))
 
        def stop(self):
                _moduleLogger.info("%s Stopping State Machine" % (self._name, ))
-               self._stop_update()
+               self._isActive = False
+               self._onTimeout.cancel()
 
        def close(self):
-               assert self._timeoutId is None
+               self._onTimeout.cancel()
                self._callback = None
 
        def set_state(self, newState):
@@ -290,45 +308,36 @@ class UpdateStateMachine(StateMachine):
        def maxTime(self):
                return self._maxTime
 
-       @gtk_toolbox.log_exception(_moduleLogger)
+       @misc_utils.log_exception(_moduleLogger)
        def _request_reset_timers(self, *args):
                self._reset_timers()
 
        def _reset_timers(self, initialize=False):
-               if self._timeoutId is None:
+               if not self._isActive:
                        return # not started yet
                _moduleLogger.info("%s Resetting State Machine" % (self._name, ))
-               self._stop_update()
+               self._onTimeout.cancel()
                if initialize:
                        self._strategy.initialize_state()
                else:
                        self._strategy.reinitialize_state()
                self._schedule_update()
 
-       def _stop_update(self):
-               if self._timeoutId is None:
-                       return
-               gobject.source_remove(self._timeoutId)
-               self._timeoutId = None
-
        def _schedule_update(self):
-               assert self._timeoutId is None
                self._strategy.increment_state()
                nextTimeout = self._strategy.timeout
                if nextTimeout != self.INFINITE_PERIOD and nextTimeout < self._maxTime:
                        assert 0 < nextTimeout
-                       self._timeoutId = gobject_utils.timeout_add_seconds(nextTimeout, self._on_timeout)
+                       self._onTimeout.start(seconds=nextTimeout)
                        _moduleLogger.info("%s Next update in %s seconds" % (self._name, nextTimeout, ))
                else:
                        _moduleLogger.info("%s No further updates (timeout is %s seconds)" % (self._name, nextTimeout, ))
 
-       @gtk_toolbox.log_exception(_moduleLogger)
+       @misc_utils.log_exception(_moduleLogger)
        def _on_timeout(self):
-               self._timeoutId = None
                self._schedule_update()
                for item in self._updateItems:
                        try:
                                item.update(force=True)
                        except Exception:
                                _moduleLogger.exception("Update failed for %r" % item)
-               return False # do not continue