redesign of the state machine

With the current implementation, we run into a deadlock with the lock
from the state machine interfering with the accessLock on the module.
We can not wait for the state machine to finish while having the
accessLock locked by write_target. As a consequence, when restarting
the state machine we should not wait, but remember the state function
to call and postpone the restart after the cleanup has finished.
For this, we want to know the status before calling the state function.

- create HasState mixin, using doPoll for driving the machine
- StatusCode decorator for assigning a status to a state function
- remove the state machines 'threaded' option
- 'Retry' is now a unique value instead of a class. The retry period
  is determined by the (fast) poll interval.
- return 'Finish' instead of None for finishing the machine. returning
  None for state function is now an error, as this might happen
  easily inadvertently.

Change-Id: Icb31367442f10e98be69af3e05a84f12ce5cc966

frappy_psi/convergence.py

@@ -97,7 +97,7 @@ class HasConvergence:
             state.timeout_base = state.now
             return self.state_inside
         if not self.timeout:
-            return Retry()
+            return Retry
         if state.init:
             state.timeout_base = state.now
             state.dif_crit = dif  # criterium for resetting timeout base
@@ -108,7 +108,7 @@ class HasConvergence:
         elif state.now > state.timeout_base + self.timeout:
             self.status = WARN, 'convergence timeout'
             return self.state_instable
-        return Retry()
+        return Retry
 
     def state_inside(self, state):
         """inside tolerance, still busy"""
@@ -121,7 +121,7 @@ class HasConvergence:
             return self.state_stable
         if state.init:
             self.status = BUSY, 'inside tolerance'
-        return Retry()
+        return Retry
 
     def state_outside(self, state):
         """temporarely outside tolerance, busy"""
@@ -135,13 +135,13 @@ class HasConvergence:
             self.status = BUSY, 'outside tolerance'
         # do not reset the settling time on occasional outliers, count backwards instead
         state.spent_inside = max(0.0, state.spent_inside - state.delta())
-        return Retry()
+        return Retry
 
     def state_stable(self, state):
         """stable, after settling_time spent within tolerance, idle"""
         dif, tol = self.get_dif_tol()
         if dif <= tol:
-            return Retry()
+            return Retry
         self.status = WARN, 'instable'
         state.spent_inside = max(self.settling_time, state.spent_inside)
         return self.state_instable
@@ -156,7 +156,7 @@ class HasConvergence:
                 return self.state_stable
         else:
             state.spent_inside = max(0, state.spent_inside - state.delta())
-        return Retry()
+        return Retry
 
     def state_interrupt(self, state):
         """stopping"""