X-Git-Url: http://git.maemo.org/git/?a=blobdiff_plain;ds=sidebyside;f=src%2Fgvoice%2Fstate_machine.py;h=888d62d0a0dbb1cce7cc03fad66b72566b7be340;hb=dc9f6a05edd1d1d94f3687f4344ae45c9101b1b3;hp=6b0a58d8255b5c9550181a978613373deddf76c6;hpb=68d1653679bdce47f008d9167a263dbb2259e91d;p=theonering diff --git a/src/gvoice/state_machine.py b/src/gvoice/state_machine.py index 6b0a58d..888d62d 100644 --- a/src/gvoice/state_machine.py +++ b/src/gvoice/state_machine.py @@ -1,10 +1,5 @@ #!/usr/bin/env python -""" -@todo Look into switching from POLL_TIME = min(F * 2^n, MAX) to POLL_TIME = min(CONST + F * 2^n, MAX) -@todo Look into supporting more states that have a different F and MAX -""" - import logging import gobject @@ -17,74 +12,232 @@ import gtk_toolbox _moduleLogger = logging.getLogger("gvoice.state_machine") -def _to_milliseconds(**kwd): +def to_milliseconds(**kwd): if "milliseconds" in kwd: return kwd["milliseconds"] elif "seconds" in kwd: return kwd["seconds"] * 1000 elif "minutes" in kwd: return kwd["minutes"] * 1000 * 60 + elif "hours" in kwd: + return kwd["hours"] * 1000 * 60 * 60 + raise KeyError("Unknown arg: %r" % kwd) + + +def to_seconds(**kwd): + if "milliseconds" in kwd: + return kwd["milliseconds"] / 1000 + elif "seconds" in kwd: + return kwd["seconds"] + elif "minutes" in kwd: + return kwd["minutes"] * 60 + elif "hours" in kwd: + return kwd["hours"] * 60 * 60 raise KeyError("Unknown arg: %r" % kwd) +class NopStateStrategy(object): + + def __init__(self): + pass + + def initialize_state(self): + pass + + def reinitialize_state(self): + pass + + def increment_state(self): + pass + + @property + def timeout(self): + return UpdateStateMachine.INFINITE_PERIOD + + def __repr__(self): + return "NopStateStrategy()" + + +class ConstantStateStrategy(object): + + def __init__(self, timeout): + assert 0 < timeout or timeout == UpdateStateMachine.INFINITE_PERIOD + self._timeout = timeout + + def initialize_state(self): + pass + + def reinitialize_state(self): + pass + + def increment_state(self): + pass + + @property + def timeout(self): + return self._timeout + + def __repr__(self): + return "ConstantStateStrategy(timeout=%r)" % self._timeout + + +class GeometricStateStrategy(object): + + def __init__(self, init, min, max): + assert 0 < init and init < max or init == UpdateStateMachine.INFINITE_PERIOD + assert 0 < min or min == UpdateStateMachine.INFINITE_PERIOD + assert min < max or max == UpdateStateMachine.INFINITE_PERIOD + self._min = min + self._max = max + self._init = init + self._current = 0 + + def initialize_state(self): + self._current = self._max + + def reinitialize_state(self): + self._current = self._min + + def increment_state(self): + if self._current == UpdateStateMachine.INFINITE_PERIOD: + pass + if self._init == UpdateStateMachine.INFINITE_PERIOD: + self._current = UpdateStateMachine.INFINITE_PERIOD + elif self._max == UpdateStateMachine.INFINITE_PERIOD: + self._current *= 2 + else: + self._current = min(2 * self._current, self._max - self._init) + + @property + def timeout(self): + if UpdateStateMachine.INFINITE_PERIOD in (self._init, self._current): + timeout = UpdateStateMachine.INFINITE_PERIOD + else: + timeout = self._init + self._current + return timeout + + def __repr__(self): + return "GeometricStateStrategy(init=%r, min=%r, max=%r)" % ( + self._init, self._min, self._max + ) + + class StateMachine(object): STATE_ACTIVE = 0, "active" STATE_IDLE = 1, "idle" STATE_DND = 2, "dnd" - _ACTION_UPDATE = "update" - _ACTION_RESET = "reset" - _ACTION_STOP = "stop" + def start(self): + raise NotImplementedError("Abstract") + + def stop(self): + raise NotImplementedError("Abstract") + + def close(self): + raise NotImplementedError("Abstract") + + def set_state(self, state): + raise NotImplementedError("Abstract") + + @property + def state(self): + raise NotImplementedError("Abstract") + + +class MasterStateMachine(StateMachine): - _INITIAL_ACTIVE_PERIOD = int(_to_milliseconds(seconds=5)) - _FINAL_ACTIVE_PERIOD = int(_to_milliseconds(minutes=2)) - _IDLE_PERIOD = int(_to_milliseconds(minutes=10)) - _INFINITE_PERIOD = -1 + def __init__(self): + self._machines = [] + self._state = self.STATE_ACTIVE + + def append_machine(self, machine): + self._machines.append(machine) + + def start(self): + # Confirm we are all on the same page + for machine in self._machines: + machine.set_state(self._state) + for machine in self._machines: + machine.start() + + def stop(self): + for machine in self._machines: + machine.stop() + + def close(self): + for machine in self._machines: + machine.close() + + def set_state(self, state): + self._state = state + for machine in self._machines: + machine.set_state(state) + + @property + def state(self): + return self._state + + +class UpdateStateMachine(StateMachine): + # Making sure the it is initialized is finicky, be careful + + INFINITE_PERIOD = -1 + DEFAULT_MAX_TIMEOUT = to_seconds(hours=24) _IS_DAEMON = True - def __init__(self, initItems, updateItems): - self._initItems = initItems + def __init__(self, updateItems, name="", maxTime = DEFAULT_MAX_TIMEOUT): + self._name = name self._updateItems = updateItems + self._maxTime = maxTime self._state = self.STATE_ACTIVE self._timeoutId = None - self._currentPeriod = self._INITIAL_ACTIVE_PERIOD - self._set_initial_period() + self._strategies = {} self._callback = coroutines.func_sink( coroutines.expand_positional( self._request_reset_timers ) ) - def close(self): - self._callback = None + def __repr__(self): + return """UpdateStateMachine( + name=%r, + strategie=%r, +)""" % (self._name, self._strategies) + + def set_state_strategy(self, state, strategy): + self._strategies[state] = strategy - @gobject_utils.async - @gtk_toolbox.log_exception(_moduleLogger) def start(self): - _moduleLogger.info("Starting State Machine") - for item in self._initItems: - try: - item.update() - except Exception: - _moduleLogger.exception("Initial update failed for %r" % item) - self._schedule_update() + 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) + _moduleLogger.info("%s Starting State Machine" % (self._name, )) def stop(self): - _moduleLogger.info("Stopping an already stopped state machine") + _moduleLogger.info("%s Stopping State Machine" % (self._name, )) self._stop_update() + def close(self): + assert self._timeoutId is None + self._callback = None + def set_state(self, newState): + if self._state == newState: + return oldState = self._state - _moduleLogger.info("Transitioning from %s to %s" % (oldState, newState)) + _moduleLogger.info("%s Transitioning from %s to %s" % (self._name, oldState, newState)) self._state = newState - self.reset_timers() + self._reset_timers() - def get_state(self): + @property + def state(self): return self._state def reset_timers(self): @@ -94,21 +247,21 @@ class StateMachine(object): def request_reset_timers(self): return self._callback - @gobject_utils.async + @property + def _strategy(self): + return self._strategies[self._state] + @gtk_toolbox.log_exception(_moduleLogger) def _request_reset_timers(self, *args): - self.reset_timers() - - def _set_initial_period(self): - self._currentPeriod = self._INITIAL_ACTIVE_PERIOD / 2 # We will double it later + self._reset_timers() - def _schedule_update(self): - nextTimeout = self._calculate_step(self._state, self._currentPeriod) - nextTimeout = int(nextTimeout) - if nextTimeout != self._INFINITE_PERIOD: - self._timeoutId = gobject.timeout_add(nextTimeout, self._on_timeout) - _moduleLogger.info("Next update in %s ms" % (nextTimeout, )) - self._currentPeriod = nextTimeout + def _reset_timers(self): + if self._timeoutId is None: + return # not started yet + _moduleLogger.info("%s Resetting State Machine" % (self._name, )) + self._stop_update() + self._strategy.reinitialize_state() + self._schedule_update() def _stop_update(self): if self._timeoutId is None: @@ -116,28 +269,24 @@ class StateMachine(object): gobject.source_remove(self._timeoutId) self._timeoutId = None - def _reset_timers(self): - self._stop_update() - self._set_initial_period() - self._schedule_update() + 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) + _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) def _on_timeout(self): - _moduleLogger.info("Update") + 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) - self._schedule_update() return False # do not continue - - @classmethod - def _calculate_step(cls, state, period): - if state == cls.STATE_ACTIVE: - return min(period * 2, cls._FINAL_ACTIVE_PERIOD) - elif state == cls.STATE_IDLE: - return cls._IDLE_PERIOD - elif state == cls.STATE_DND: - return cls._INFINITE_PERIOD - else: - raise RuntimeError("Unknown state: %r" % (state, ))