Use TLS for SpaceAPI updates

[saartuer.git] / statemachine.py

diff --git a/statemachine.py b/statemachine.py
index a019eef83ad0054d6108b0d2c457365db92df319..a937f50c035140cef91d504006a0dbbce60f7014 100644 (file)
--- a/statemachine.py
+++ b/statemachine.py
@@ -1,4 +1,4 @@
-from libtuer import ThreadFunction, logger, fire_and_forget
+from libtuer import ThreadFunction, logger, fire_and_forget, fire_and_forget_cmd
 from actor import Actor
 import os, random, time, threading
 
@@ -90,6 +90,8 @@ class StateMachine():
                        return self.state_machine.old_pins
                def actor(self):
                        return self.state_machine.actor
+               def api(self):
+                       return self.state_machine.api
                def handle_event(self,ev,arg): # don't override
                        if ev == StateMachine.CMD_PINS:
                                return self.handle_pins_event()
@@ -156,7 +158,6 @@ class StateMachine():
        class StateFallback(State):
                def __init__(self, sm, nervlist = None):
                        super().__init__(sm, nervlist)
-                       self._last_blink_time = time.time()
                        self._red_state = False
                def handle_pins_event(self):
                        pins = self.pins()
@@ -178,14 +179,12 @@ class StateMachine():
                        # not calling superclass because we want to stay in fallback mode
                def handle_wakeup_event(self):
                        # blink red LED
-                       now = time.time()
                        if self._red_state:
                                self.actor().act(Actor.CMD_RED_OFF)
                                self._red_state = False
                        else:
                                self.actor().act(Actor.CMD_RED_ON)
                                self._red_state = True
-                       self._last_blink_time = now
                def handle_cmd_unlock_event(self,arg):
                        if arg is not None:
                                arg("298 Fallback Okay: Trying to unlock the door. The System is in fallback mode, success information is not available.")
@@ -244,6 +243,7 @@ class StateMachine():
                        nervlist = [(24*60*60, lambda: logger.critical("Space is now open for 24h. Is everything all right?"))]
                        super().__init__(sm, nervlist)
                        self.last_buzzed = None
+                       self.api().set_state(True)
                def handle_pins_event(self):
                        pins = self.pins()
                        if pins.bell_ringing and not self.old_pins().bell_ringing: # first thing to check: edge detection
@@ -254,6 +254,8 @@ class StateMachine():
                                logger.info("StateMachine: space switch turned off - starting leaving procedure")
                                return StateMachine.StateAboutToLeave(self.state_machine)
                        return super().handle_pins_event()
+               def on_leave(self):
+                       self.api().set_state(False)
        
        class StateLocking(AbstractUnlockedState):
                def __init__(self,sm):
@@ -302,13 +304,16 @@ class StateMachine():
                                return StateMachine.StateAuf(self.state_machine)
                        return super().handle_pins_event()
        
-       def __init__(self, actor, waker, fallback = False):
+       def __init__(self, actor, waker, api, fallback = False):
                self.actor = actor
+               self.api = api
                self.callback = ThreadFunction(self._callback, name="StateMachine")
                self.current_state = StateMachine.StateStart(self, fallback=fallback)
                self.pins = None
                self.old_pins = None
                waker.register(lambda: self.callback(StateMachine.CMD_WAKEUP), 1.0) # wake up every second
+               # initially, the space is closed
+               api.set_state(False)
        
        def stop (self):
                self.callback.stop()