introduce abstract states for each side of the Rubikon

diff --git a/actor.py b/actor.py
index 8dd73231e18b53f9001ded2b8f816f48160cf6b6..0a53263d3cdd9485da0b26ddaa2039f18c8ebea4 100644 (file)
--- a/actor.py
+++ b/actor.py
@@ -8,9 +8,9 @@ class Actor:
        CMD_LOCK = 2
        
        CMDs = {
        CMD_LOCK = 2
        
        CMDs = {

-               CMD_UNLOCK:  ("unlock", 12, [(None, 0.2), (True, 0.3), (False, 0.5)]),
-               CMD_LOCK:  ("lock", 16, [(None, 0.2), (True, 0.3), (False, 0.5)]),
-               CMD_BUZZ: ("buzz", 22, [(None, 0.2), (True, 2.0), (False, 0.5)]),
+               CMD_UNLOCK:  ("unlock", 12, [(True, 0.3), (False, 0.1)]),
+               CMD_LOCK:  ("lock", 16, [(True, 0.3), (False, 0.1)]),
+               CMD_BUZZ: ("buzz", 22, [(True, 2.0), (False, 0.1)]),

        }
        
        def __init__(self):
        }
        
        def __init__(self):

diff --git a/libtuer.py b/libtuer.py
index afef36e9b261981fb8359af2e0b3de85c6600f89..05607f6e8b9f5cc9cad3397e000aaa233aa77205 100644 (file)
--- a/libtuer.py
+++ b/libtuer.py
@@ -62,7 +62,7 @@ def fire_and_forget (cmd, log, prefix):
                with open("/dev/null", "w") as fnull:
                        retcode = subprocess.call(cmd, stdout=fnull, stderr=fnull)
                        if retcode is not 0:
                with open("/dev/null", "w") as fnull:
                        retcode = subprocess.call(cmd, stdout=fnull, stderr=fnull)
                        if retcode is not 0:

-                               log("%sReturn code %d at command: %s" % (prefix,retcode,str(cmd)))
+                               logger.error("%sReturn code %d at command: %s" % (prefix,retcode,str(cmd)))

        t = threading.Thread(target=_fire_and_forget)
        t.start()
 
        t = threading.Thread(target=_fire_and_forget)
        t.start()
 

diff --git a/statemachine.py b/statemachine.py
index 9e5032747c31fbc40ffe3176b234d18829a0868d..f2fb8178a608b9623a1f08781d63e2a0d5971813 100644 (file)
--- a/statemachine.py
+++ b/statemachine.py
@@ -25,7 +25,8 @@ CLOSE_REPEAT_NUMBER = 3
 # StateAboutToOpen constants
 ABOUTOPEN_NERVLIST = [(5, lambda : play_sound("flipswitch")), (5, lambda:play_sound("flipswitch")), (0, lambda:logger.warning("Space open but switch not flipped for 10 seconds")),\
        (10, lambda:play_sound("flipswitch")), (10, lambda:play_sound("flipswitch")), (0, lambda:logger.error("Space open but switch not flipped for 30 seconds")),\
 # StateAboutToOpen constants
 ABOUTOPEN_NERVLIST = [(5, lambda : play_sound("flipswitch")), (5, lambda:play_sound("flipswitch")), (0, lambda:logger.warning("Space open but switch not flipped for 10 seconds")),\
        (10, lambda:play_sound("flipswitch")), (10, lambda:play_sound("flipswitch")), (0, lambda:logger.error("Space open but switch not flipped for 30 seconds")),\

-       (10, lambda:play_sound("flipswitch")), (10, lambda:play_sound("flipswitch")), (6, lambda:play_sound("flipswitch")), (4, lambda:logger.critical("Space open but switch not flipped for 60 seconds"))]
+       (10, lambda:play_sound("flipswitch")), (10, lambda:play_sound("flipswitch")), (6, lambda:play_sound("flipswitch")), (4, lambda:logger.critical("Space open but switch not flipped for 60 seconds")),
+       (59*60, lambda:logger.critical("Space open but switch not flipped for one hour"))]

 
 # Timeout we wait after the switch was switched to "Closed", until we assume nobody will open the door and we just lock it
 # ALso the time we wait after the door was opend, till we assume something went wrong and start nerving
 
 # Timeout we wait after the switch was switched to "Closed", until we assume nobody will open the door and we just lock it
 # ALso the time we wait after the door was opend, till we assume something went wrong and start nerving


@@ -74,7 +75,7 @@ class StateMachine():
                        arg("200 okay: buzz executed")
                def handle_cmd_unlock_event(self,arg):
                        if arg is not None:
                        arg("200 okay: buzz executed")
                def handle_cmd_unlock_event(self,arg):
                        if arg is not None:

-                               arg("412 Precondition Failed: The current state (%s) cannot handle the OPEN event" % self.__class__.__name__)
+                               arg("412 Precondition Failed: The current state (%s) cannot handle the UNLOCK command. Try again later." % self.__class__.__name__)

                def handle_wakeup_event(self):
                        if self._nerver is not None:
                                return self._nerver.nerv()
                def handle_wakeup_event(self):
                        if self._nerver is not None:
                                return self._nerver.nerv()


@@ -96,49 +97,59 @@ class StateMachine():
                        else:
                                raise Exception("Unknown command number: %d" % ev)
        
                        else:
                                raise Exception("Unknown command number: %d" % ev)
        

-       class StateStart(State):
+       class AbstractLockedState(State):
+               '''A state with invariant "The space is locked", switching to StateAboutToOpen when the space becomes unlocked'''

                def handle_pins_event(self):
                def handle_pins_event(self):

-                       super().handle_pins_event()
-                       pins = self.pins()
-                       if pins.door_locked is None or pins.door_closed is None or pins.space_active is None or pins.bell_ringing is None:
-                               return None # wait till we have all sensors non-None
-                       if pins.door_locked:
-                               return StateMachine.StateZu(self.state_machine)
-                       else:
-                               return StateMachine.StateAuf(self.state_machine)
+                       if not self.pins().door_locked:
+                               return StateAboutToOpen(self.state_machine)
+                       return super().handle_pins_event

        
        

-       class StateZu(State):
+       class AbstractUnlockedState(State):
+               '''A state with invariant "The space is unlocked", switching to StateZu when the space becomes locked'''
+               def handle_pins_event(self):
+                       if self.pins().door_locked:
+                               if self.pins().space_active:
+                                       # FIXME the same state can be reached by first locking the door, and then activating the space. What to do then?
+                                       logger.info("StateMachine: door manually locked, but space switch is still on - going to StateZu")
+                                       play_sound("manual_lock")
+                               return StateZu(self.state_machine)
+                       return super().handle_pins_event
+       
+       class StateStart(State):

                def handle_pins_event(self):
                def handle_pins_event(self):

-                       super().handle_pins_event()

                        pins = self.pins()
                        pins = self.pins()

-                       if not pins.door_locked:
-                               return StateMachine.StateAboutToOpen(self.state_machine)
+                       if not (pins.door_locked is None or pins.door_closed is None or pins.space_active is None or pins.bell_ringing is None):
+                               # All sensors got a value, switch to a proper state
+                               if pins.door_locked:
+                                       return StateMachine.StateZu(self.state_machine)
+                               else:
+                                       return StateMachine.StateAboutToOpen(self.state_machine)
+                       return super().handle_pins_event()
+       
+       class StateZu(AbstractLockedState):

                def handle_cmd_unlock_event(self,callback):
                def handle_cmd_unlock_event(self,callback):

-                       # intentionally not calling super() implementation

                        return StateMachine.StateUnlocking(self.state_machine, callback)
        
                        return StateMachine.StateUnlocking(self.state_machine, callback)
        

-       class StateUnlocking(State):
+       class StateUnlocking(AbstractLockedState):

                def __init__(self,sm,callback=None):
                        # construct a nervlist
                        nervlist = [(OPEN_REPEAT_TIMEOUT, lambda: self.actor().act(Actor.CMD_UNLOCK)) for t in range(OPEN_REPEAT_NUMBER)]
                        nervlist += [(OPEN_REPEAT_TIMEOUT, self.could_not_open)]
                        super().__init__(sm,nervlist)
                        self.callbacks=[callback]
                def __init__(self,sm,callback=None):
                        # construct a nervlist
                        nervlist = [(OPEN_REPEAT_TIMEOUT, lambda: self.actor().act(Actor.CMD_UNLOCK)) for t in range(OPEN_REPEAT_NUMBER)]
                        nervlist += [(OPEN_REPEAT_TIMEOUT, self.could_not_open)]
                        super().__init__(sm,nervlist)
                        self.callbacks=[callback]

-                       # TODO: can we send "202 processing: Trying to open the door" here? Are the callbacks multi-use?
+                       # TODO: can we send "202 processing: Trying to unlock the door" here? Are the callbacks multi-use?

                        self.actor().act(Actor.CMD_UNLOCK)
                def notify(self, did_it_work):
                        self.actor().act(Actor.CMD_UNLOCK)
                def notify(self, did_it_work):

-                       s = "200 okay: door open" if did_it_work else ("500 internal server error: Couldn't open door with %d tries à %f seconds" % (OPEN_REPEAT_NUMBER,OPEN_REPEAT_TIMEOUT))
+                       s = "200 okay: door unlocked" if did_it_work else ("500 internal server error: Couldn't unlock door with %d tries à %f seconds" % (OPEN_REPEAT_NUMBER,OPEN_REPEAT_TIMEOUT))

                        for cb in self.callbacks:
                                if cb is not None:
                                        cb(s)
                def handle_pins_event(self):
                        for cb in self.callbacks:
                                if cb is not None:
                                        cb(s)
                def handle_pins_event(self):

-                       super().handle_pins_event()
-                       pins = self.pins()
-                       if not pins.door_locked:
+                       # overriding superclass as we need to do notification (TODO can this be done better? on_leave?)
+                       if not self.pins().door_locked:

                                self.notify(True)
                                return StateMachine.StateAboutToOpen(self.state_machine)
                def handle_cmd_unlock_event(self,callback):
                                self.notify(True)
                                return StateMachine.StateAboutToOpen(self.state_machine)
                def handle_cmd_unlock_event(self,callback):

-                       # intentionally not calling super() implementation

                        # TODO: 202 notification also here if possible
                        self.callbacks.append(callback)
                def could_not_open(self):
                        # TODO: 202 notification also here if possible
                        self.callbacks.append(callback)
                def could_not_open(self):


@@ -146,45 +157,37 @@ class StateMachine():
                        self.notify(False)
                        return StateMachine.StateZu(self.state_machine)
        
                        self.notify(False)
                        return StateMachine.StateZu(self.state_machine)
        

-       class AbstractStateWhereOpeningIsRedundant(State):
+       class AbstractStateWhereOpeningIsRedundant(AbstractUnlockedState):

                def handle_cmd_unlock_event(self, callback):
                def handle_cmd_unlock_event(self, callback):

-                       # intentionally not calling super() implementation

                        callback("299 redundant: Space seems to be already open. Still processing your request tough.")
                        callback("299 redundant: Space seems to be already open. Still processing your request tough.")

-                       logger.info("StateMachine: Received UNLOCK command in StateAboutToOpen. This should not be necessary.")
+                       logger.info("StateMachine: Received UNLOCK command in %s. This should not be necessary." % self.__class__.__name__)

                        self.actor().act(Actor.CMD_UNLOCK)
        
        class StateAboutToOpen(AbstractStateWhereOpeningIsRedundant):
                def __init__(self, sm):
                        super().__init__(sm, ABOUTOPEN_NERVLIST)
                def handle_pins_event(self):
                        self.actor().act(Actor.CMD_UNLOCK)
        
        class StateAboutToOpen(AbstractStateWhereOpeningIsRedundant):
                def __init__(self, sm):
                        super().__init__(sm, ABOUTOPEN_NERVLIST)
                def handle_pins_event(self):

-                       super().handle_pins_event()

                        pins = self.pins()
                        pins = self.pins()

-                       if pins.door_locked:
-                               return StateMachine.StateZu(self.state_machine)
-                       elif pins.space_active:
+                       if pins.space_active:

                                return StateMachine.StateAuf(self.state_machine)
                                return StateMachine.StateAuf(self.state_machine)

+                       return super().handle_pins_event()

        
        class StateAuf(AbstractStateWhereOpeningIsRedundant):
                def __init__(self,sm):
                        super().__init__(sm)
                        self.last_buzzed = None
                def handle_pins_event(self):
        
        class StateAuf(AbstractStateWhereOpeningIsRedundant):
                def __init__(self,sm):
                        super().__init__(sm)
                        self.last_buzzed = None
                def handle_pins_event(self):

-                       super().handle_pins_event()

                        pins = self.pins()
                        if pins.bell_ringing and not self.old_pins().bell_ringing:
                                # someone just pressed the bell
                        pins = self.pins()
                        if pins.bell_ringing and not self.old_pins().bell_ringing:
                                # someone just pressed the bell

-                               logger.info("StateMachine: buzzing because of bell ringing in state auf")
+                               logger.info("StateMachine: buzzing because of bell ringing in StateAuf")

                                self.actor().act(Actor.CMD_BUZZ)
                        if not pins.space_active:
                                self.actor().act(Actor.CMD_BUZZ)
                        if not pins.space_active:

-                               logger.info("StateMachine: space switch off - starting leaving procedure")
+                               logger.info("StateMachine: space switch turned off - starting leaving procedure")

                                return StateMachine.StateAboutToLeave(self.state_machine)
                                return StateMachine.StateAboutToLeave(self.state_machine)

-                       if pins.door_locked:
-                               logger.info("StateMachine: door manually locked, but space switch on - going to StateZu")
-                               play_sound("manual_lock")
-                               return StateMachine.StateZu(self.state_machine)
+                       return super().handle_pins_event()

        
        

-       class StateLocking(State):
-               # TODO: share code with StateUnlocking
+       class StateLocking(AbstractUnlockedState):

                def __init__(self,sm):
                        # construct a nervlist
                        nervlist = [(CLOSE_REPEAT_TIMEOUT, lambda: self.actor().act(Actor.CMD_LOCK)) for t in range(CLOSE_REPEAT_NUMBER)]
                def __init__(self,sm):
                        # construct a nervlist
                        nervlist = [(CLOSE_REPEAT_TIMEOUT, lambda: self.actor().act(Actor.CMD_LOCK)) for t in range(CLOSE_REPEAT_NUMBER)]


@@ -198,37 +201,35 @@ class StateMachine():
                                # TODO play a sound? This shouldn't happen, door was opened while we are locking
                                logger.warning("StateMachine: door manually opened during locking")
                                return StateMachine.StateAboutToOpen(self.state_machine)
                                # TODO play a sound? This shouldn't happen, door was opened while we are locking
                                logger.warning("StateMachine: door manually opened during locking")
                                return StateMachine.StateAboutToOpen(self.state_machine)

-                       if pins.door_locked:
-                               return StateMachine.StateZu(self.state_machine)
+                       # TODO do anything here if the switch is activated now?
+                       return super().handle_pins_event()

                def handle_cmd_unlock_event(self,callback):
                        callback("409 conflict: The sphinx is currently trying to lock the door. Try again later.")
                def could_not_close(self):
                        logger.critical("StateMachine: Couldn't close door after %d tries. Going back to StateAboutToOpen." % CLOSE_REPEAT_NUMBER)
                        return StateMachine.StateAboutToOpen(self.state_machine)
        
                def handle_cmd_unlock_event(self,callback):
                        callback("409 conflict: The sphinx is currently trying to lock the door. Try again later.")
                def could_not_close(self):
                        logger.critical("StateMachine: Couldn't close door after %d tries. Going back to StateAboutToOpen." % CLOSE_REPEAT_NUMBER)
                        return StateMachine.StateAboutToOpen(self.state_machine)
        

-       class StateAboutToLeave(State):
+       class StateAboutToLeave(AbstractUnlockedState):

                def __init__(self, sm):
                        nervlist = [(LEAVE_TIMEOUT, lambda: StateMachine.StateLocking(self.state_machine))]
                        super().__init__(sm, nervlist)
                def handle_pins_event(self):
                        if not self.pins().door_closed:
                                return StateMachine.StateLeaving(self.state_machine)
                def __init__(self, sm):
                        nervlist = [(LEAVE_TIMEOUT, lambda: StateMachine.StateLocking(self.state_machine))]
                        super().__init__(sm, nervlist)
                def handle_pins_event(self):
                        if not self.pins().door_closed:
                                return StateMachine.StateLeaving(self.state_machine)

-                       if self.pins().door_locked:
-                               return StateMachine.StateZu(self.state_machine)

                        if self.pins().space_active:
                                return StateMachine.StateAuf(self.state_machine)
                        if self.pins().space_active:
                                return StateMachine.StateAuf(self.state_machine)

+                       return super().handle_pins_event()

        
        

-       class StateLeaving(State):
+       class StateLeaving(AbstractUnlockedState):

                def __init__(self, sm):
                        nervlist = [(LEAVE_TIMEOUT, lambda: StateMachine.StateAboutToOpen(self.state_machine))]
                        super().__init__(sm, nervlist)
                def handle_pins_event(self):
                        if self.pins().door_closed:
                                return StateMachine.StateLocking(self.state_machine)
                def __init__(self, sm):
                        nervlist = [(LEAVE_TIMEOUT, lambda: StateMachine.StateAboutToOpen(self.state_machine))]
                        super().__init__(sm, nervlist)
                def handle_pins_event(self):
                        if self.pins().door_closed:
                                return StateMachine.StateLocking(self.state_machine)

-                       if self.pins().door_locked:
-                               return StateMachine.StateZu(self.state_machine)

                        if self.pins().space_active:
                                return StateMachine.StateAuf(self.state_machine)
                        if self.pins().space_active:
                                return StateMachine.StateAuf(self.state_machine)

+                       return super().handle_pins_event()

        
        def __init__(self, actor):
                self.actor = actor
        
        def __init__(self, actor):
                self.actor = actor

diff --git a/tysock.py b/tysock.py
index cd112144544e25beb5b06c8812dde0aa476f2e4c..82d26a8075ab097d90fc39f177699722eddbea21 100644 (file)
--- a/tysock.py
+++ b/tysock.py
@@ -74,4 +74,4 @@ class TySocket():
                        except KeyboardInterrupt:
                                raise # forward Ctrl-C to the outside
                        except Exception as e:
                        except KeyboardInterrupt:
                                raise # forward Ctrl-C to the outside
                        except Exception as e:

-                               logger.error("TySocket: Something went wrong: %s" % str(e))
+                               logger.critical("TySocket: Something went wrong: %s" % str(e))