sound_sensor_server: persistent guard_enabled state

1 files changed, 40 insertions, 6 deletions

diff --git a/src/home/soundsensor/server.py b/src/home/soundsensor/server.py
index 0a53ae6..3e4fa03 100644
--- a/src/home/soundsensor/server.py
+++ b/src/home/soundsensor/server.py
@@ -3,6 +3,7 @@ import json
 import logging
 import threading
 
+from ..database.sqlite import SQLiteBase
 from ..config import config
 from .. import http
 
@@ -34,26 +35,60 @@ class SoundSensorHitHandler(asyncio.DatagramProtocol):
         pass
 
 
+class Database(SQLiteBase):
+    SCHEMA = 1
+
+    def __init__(self):
+        super().__init__(dbname='sound_sensor_server')
+
+    def schema_init(self, version: int) -> None:
+        cursor = self.cursor()
+
+        if version < 1:
+            cursor.execute("CREATE TABLE IF NOT EXISTS status (guard_enabled) INTEGER NOT NULL")
+            cursor.execute("INSERT INTO status (guard_enabled) VALUES (-1)")
+
+        self.commit()
+
+    def get_guard_enabled(self) -> int:
+        cur = self.cursor()
+        cur.execute("SELECT guard_enabled FROM status LIMIT 1")
+        return int(cur.fetchone()[0])
+
+    def set_guard_enabled(self, enabled: bool) -> None:
+        cur = self.cursor()
+        cur.execute("UPDATE status SET guard_enabled=?", (int(enabled),))
+
+
 class SoundSensorServer:
     def __init__(self,
                  addr: Addr,
                  handler_impl: Type[SoundSensorHitHandler]):
         self.addr = addr
         self.impl = handler_impl
+        self.db = Database()
 
         self._recording_lock = threading.Lock()
         self._recording_enabled = True
 
         if self.guard_control_enabled():
-            if 'guard_recording_default' in config['server']:
-                self._recording_enabled = config['server']['guard_recording_default']
-
-    def guard_control_enabled(self) -> bool:
+            current_status = self.db.get_guard_enabled()
+            if current_status == -1:
+                self.set_recording(config['server']['guard_recording_default']
+                                   if 'guard_recording_default' in config['server']
+                                   else False)
+            else:
+                self.set_recording(bool(current_status), update=False)
+
+    @staticmethod
+    def guard_control_enabled() -> bool:
         return 'guard_control' in config['server'] and config['server']['guard_control'] is True
 
-    def set_recording(self, enabled: bool):
+    def set_recording(self, enabled: bool, update=True):
         with self._recording_lock:
             self._recording_enabled = enabled
+        if update:
+            self.db.set_guard_enabled(enabled)
 
     def is_recording_enabled(self) -> bool:
         with self._recording_lock:
@@ -89,4 +124,3 @@ class SoundSensorServer:
 
         asyncio.set_event_loop(asyncio.new_event_loop())  # need to create new event loop in new thread
         http.serve(self.addr, routes, handle_signals=False)  # handle_signals=True doesn't work in separate thread
-