git.maemo.org Git - theonering/blob - src/gvoice/state_machine.py

   1 #!/usr/bin/env python
   2
   3 import logging
   4
   5 import gobject
   6
   7 import util.go_utils as gobject_utils
   8 import util.coroutines as coroutines
   9 import util.misc as misc_utils
  10
  11
  12 _moduleLogger = logging.getLogger("gvoice.state_machine")
  13
  14
  15 def to_milliseconds(**kwd):
  16         if "milliseconds" in kwd:
  17                 return kwd["milliseconds"]
  18         elif "seconds" in kwd:
  19                 return kwd["seconds"] * 1000
  20         elif "minutes" in kwd:
  21                 return kwd["minutes"] * 1000 * 60
  22         elif "hours" in kwd:
  23                 return kwd["hours"] * 1000 * 60 * 60
  24         raise KeyError("Unknown arg: %r" % kwd)
  25
  26
  27 def to_seconds(**kwd):
  28         if "milliseconds" in kwd:
  29                 return kwd["milliseconds"] / 1000
  30         elif "seconds" in kwd:
  31                 return kwd["seconds"]
  32         elif "minutes" in kwd:
  33                 return kwd["minutes"] * 60
  34         elif "hours" in kwd:
  35                 return kwd["hours"] * 60 * 60
  36         raise KeyError("Unknown arg: %r" % kwd)
  37
  38
  39 class NopStateStrategy(object):
  40
  41         def __init__(self):
  42                 pass
  43
  44         def initialize_state(self):
  45                 pass
  46
  47         def reinitialize_state(self):
  48                 pass
  49
  50         def increment_state(self):
  51                 pass
  52
  53         @property
  54         def timeout(self):
  55                 return UpdateStateMachine.INFINITE_PERIOD
  56
  57         def __repr__(self):
  58                 return "NopStateStrategy()"
  59
  60
  61 class ConstantStateStrategy(object):
  62
  63         def __init__(self, timeout):
  64                 assert 0 < timeout or timeout == UpdateStateMachine.INFINITE_PERIOD
  65                 self._timeout = timeout
  66
  67         def initialize_state(self):
  68                 pass
  69
  70         def reinitialize_state(self):
  71                 pass
  72
  73         def increment_state(self):
  74                 pass
  75
  76         @property
  77         def timeout(self):
  78                 return self._timeout
  79
  80         def __repr__(self):
  81                 return "ConstantStateStrategy(timeout=%r)" % self._timeout
  82
  83
  84 class NTimesStateStrategy(object):
  85
  86         def __init__(self, timeouts, postTimeout):
  87                 assert 0 < len(timeouts)
  88                 for timeout in timeouts:
  89                         assert 0 < timeout or timeout == UpdateStateMachine.INFINITE_PERIOD
  90                 assert 0 < postTimeout or postTimeout == UpdateStateMachine.INFINITE_PERIOD
  91                 self._timeouts = timeouts
  92                 self._postTimeout = postTimeout
  93
  94                 self._attemptCount = 0
  95
  96         def initialize_state(self):
  97                 self._attemptCount = len(self._timeouts)
  98
  99         def reinitialize_state(self):
 100                 self._attemptCount = 0
 101
 102         def increment_state(self):
 103                 self._attemptCount += 1
 104
 105         @property
 106         def timeout(self):
 107                 try:
 108                         return self._timeouts[self._attemptCount]
 109                 except IndexError:
 110                         return self._postTimeout
 111
 112         def __repr__(self):
 113                 return "NTimesStateStrategy(timeouts=%r, postTimeout=%r)" % (
 114                         self._timeouts,
 115                         self._postTimeout,
 116                 )
 117
 118
 119 class GeometricStateStrategy(object):
 120
 121         def __init__(self, init, min, max):
 122                 assert 0 < init and init < max or init == UpdateStateMachine.INFINITE_PERIOD
 123                 assert 0 < min or min == UpdateStateMachine.INFINITE_PERIOD
 124                 assert min < max or max == UpdateStateMachine.INFINITE_PERIOD
 125                 self._min = min
 126                 self._max = max
 127                 self._init = init
 128                 self._current = 0
 129
 130         def initialize_state(self):
 131                 self._current = self._max
 132
 133         def reinitialize_state(self):
 134                 self._current = self._min
 135
 136         def increment_state(self):
 137                 if self._current == UpdateStateMachine.INFINITE_PERIOD:
 138                         pass
 139                 if self._init == UpdateStateMachine.INFINITE_PERIOD:
 140                         self._current = UpdateStateMachine.INFINITE_PERIOD
 141                 elif self._max == UpdateStateMachine.INFINITE_PERIOD:
 142                         self._current *= 2
 143                 else:
 144                         self._current = min(2 * self._current, self._max - self._init)
 145
 146         @property
 147         def timeout(self):
 148                 if UpdateStateMachine.INFINITE_PERIOD in (self._init, self._current):
 149                         timeout = UpdateStateMachine.INFINITE_PERIOD
 150                 else:
 151                         timeout = self._init + self._current
 152                 return timeout
 153
 154         def __repr__(self):
 155                 return "GeometricStateStrategy(init=%r, min=%r, max=%r)" % (
 156                         self._init, self._min, self._max
 157                 )
 158
 159
 160 class StateMachine(object):
 161
 162         STATE_ACTIVE = 0, "active"
 163         STATE_IDLE = 1, "idle"
 164         STATE_DND = 2, "dnd"
 165
 166         def start(self):
 167                 raise NotImplementedError("Abstract")
 168
 169         def stop(self):
 170                 raise NotImplementedError("Abstract")
 171
 172         def close(self):
 173                 raise NotImplementedError("Abstract")
 174
 175         def set_state(self, state):
 176                 raise NotImplementedError("Abstract")
 177
 178         @property
 179         def state(self):
 180                 raise NotImplementedError("Abstract")
 181
 182
 183 class MasterStateMachine(StateMachine):
 184
 185         def __init__(self):
 186                 self._machines = []
 187                 self._state = self.STATE_ACTIVE
 188
 189         def append_machine(self, machine):
 190                 self._machines.append(machine)
 191
 192         def start(self):
 193                 # Confirm we are all on the same page
 194                 for machine in self._machines:
 195                         machine.set_state(self._state)
 196                 for machine in self._machines:
 197                         machine.start()
 198
 199         def stop(self):
 200                 for machine in self._machines:
 201                         machine.stop()
 202
 203         def close(self):
 204                 for machine in self._machines:
 205                         machine.close()
 206
 207         def set_state(self, state):
 208                 self._state = state
 209                 for machine in self._machines:
 210                         machine.set_state(state)
 211
 212         @property
 213         def state(self):
 214                 return self._state
 215
 216
 217 class UpdateStateMachine(StateMachine):
 218         # Making sure the it is initialized is finicky, be careful
 219
 220         INFINITE_PERIOD = -1
 221         DEFAULT_MAX_TIMEOUT = to_seconds(hours=24)
 222
 223         _IS_DAEMON = True
 224
 225         def __init__(self, updateItems, name="", maxTime = DEFAULT_MAX_TIMEOUT):
 226                 self._name = name
 227                 self._updateItems = updateItems
 228                 self._maxTime = maxTime
 229
 230                 self._state = self.STATE_ACTIVE
 231                 self._onTimeout = gobject_utils.Timeout(self._on_timeout)
 232
 233                 self._strategies = {}
 234                 self._callback = coroutines.func_sink(
 235                         coroutines.expand_positional(
 236                                 self._request_reset_timers
 237                         )
 238                 )
 239
 240         def __repr__(self):
 241                 return """UpdateStateMachine(
 242         name=%r,
 243         strategie=%r,
 244 )""" % (self._name, self._strategies)
 245
 246         def set_state_strategy(self, state, strategy):
 247                 self._strategies[state] = strategy
 248
 249         def start(self):
 250                 for strategy in self._strategies.itervalues():
 251                         strategy.initialize_state()
 252                 if self._strategy.timeout != self.INFINITE_PERIOD:
 253                         self._onTimeout.start(seconds=0)
 254                 _moduleLogger.info("%s Starting State Machine" % (self._name, ))
 255
 256         def stop(self):
 257                 _moduleLogger.info("%s Stopping State Machine" % (self._name, ))
 258                 self._onTimeout.cancel()
 259
 260         def close(self):
 261                 self._onTimeout.cancel()
 262                 self._callback = None
 263
 264         def set_state(self, newState):
 265                 if self._state == newState:
 266                         return
 267                 oldState = self._state
 268                 _moduleLogger.info("%s Transitioning from %s to %s" % (self._name, oldState, newState))
 269
 270                 self._state = newState
 271                 self._reset_timers(initialize=True)
 272
 273         @property
 274         def state(self):
 275                 return self._state
 276
 277         def reset_timers(self):
 278                 self._reset_timers()
 279
 280         @property
 281         def request_reset_timers(self):
 282                 return self._callback
 283
 284         @property
 285         def _strategy(self):
 286                 return self._strategies[self._state]
 287
 288         @property
 289         def maxTime(self):
 290                 return self._maxTime
 291
 292         @misc_utils.log_exception(_moduleLogger)
 293         def _request_reset_timers(self, *args):
 294                 self._reset_timers()
 295
 296         def _reset_timers(self, initialize=False):
 297                 if self._timeoutId is None:
 298                         return # not started yet
 299                 _moduleLogger.info("%s Resetting State Machine" % (self._name, ))
 300                 self._onTimeout.cancel()
 301                 if initialize:
 302                         self._strategy.initialize_state()
 303                 else:
 304                         self._strategy.reinitialize_state()
 305                 self._schedule_update()
 306
 307         def _schedule_update(self):
 308                 self._strategy.increment_state()
 309                 nextTimeout = self._strategy.timeout
 310                 if nextTimeout != self.INFINITE_PERIOD and nextTimeout < self._maxTime:
 311                         assert 0 < nextTimeout
 312                         self._onTimeout.start(seconds=nextTimeout)
 313                         _moduleLogger.info("%s Next update in %s seconds" % (self._name, nextTimeout, ))
 314                 else:
 315                         _moduleLogger.info("%s No further updates (timeout is %s seconds)" % (self._name, nextTimeout, ))
 316
 317         @misc_utils.log_exception(_moduleLogger)
 318         def _on_timeout(self):
 319                 self._schedule_update()
 320                 for item in self._updateItems:
 321                         try:
 322                                 item.update(force=True)
 323                         except Exception:
 324                                 _moduleLogger.exception("Update failed for %r" % item)