Start autosave thread when in dispatcher init

Author: jsouter

softioc/asyncio_dispatcher.py

@@ -4,6 +4,7 @@
 import threading
 import atexit
 import signal
+from . import autosave
 
 class AsyncioDispatcher:
     def __init__(self, loop=None, debug=False):
@@ -41,6 +42,13 @@ def __init__(self, loop=None, debug=False):
             raise ValueError("Provided asyncio event loop is not running")
         else:
             self.loop = loop
+        # set up autosave thread
+        autosaver = autosave.Autosave()
+        self.__autosave_worker = threading.Thread(
+            target=autosaver.loop,
+        )
+        self.__autosave_worker.daemon = True
+        self.__autosave_worker.start()
 
     def close(self):
         if self.__atexit is not None:

softioc/autosave.py

@@ -1,41 +1,66 @@
 import json
 from pathlib import Path
 from typing import Dict, List, Optional
-from softioc.pythonSoftIoc import RecordWrapper
 from datetime import datetime
 import shutil
-from softioc import builder
+from softioc.device_core import LookupRecordList
+import time
+import threading
 
 SAV_SUFFIX = "softsav"
 SAVB_SUFFIX = "softsavB"
 
+def configure(device=None, directory=None, save_period=None, poll_period=None):
+    Autosave.poll_period = poll_period or Autosave.poll_period
+    Autosave.save_period = save_period or Autosave.save_period
+    if device is None and Autosave.device_name is None:
+        from .builder import GetRecordNames
+        Autosave.device_name = GetRecordNames().prefix[0]
+    else:
+        Autosave.device_name = device
+    if directory is None and Autosave.directory is None:
+        raise RuntimeError("Autosave directory is not known, "
+                           "call autosave.configure() with directory keyword argument")
+    else:
+        Autosave.directory = Path(directory)
 
 class Autosave:
+    _instance = None
+    poll_period = 1.0
+    save_period = 30.0
+    device_name = None
+    directory = None
+    enabled = True
+    backup_on_restart = True
+
     def __init__(
         self,
-        directory: str,
-        pvs: List[RecordWrapper],
-        save_period: float = 30.0,
-        enabled: bool = True,
-        backup_on_restart: bool = True
     ):
-        self._device_name: str = builder.GetRecordNames().prefix[0]
-        self._directory: Path = Path(directory)  # cast string to Path
+        if not self.directory:
+            raise RuntimeError("Autosave directory is not known, "
+                           "call autosave.configure() with directory keyword argument")
+        if not self.device_name:
+            raise RuntimeError("Device name is not known to autosave thread, "
+                "call autosave.configure() with device keyword argument")
         self._last_saved_time = datetime.now()
-        if not self._directory.is_dir():
+        if not self.directory.is_dir():
             raise RuntimeError(f"{directory} is not a valid autosave directory")
-        if backup_on_restart:
+        if self.backup_on_restart:
             self.backup_sav_file()
-        self._enabled = enabled
-        self._save_period = save_period
-        self._pvs = {pv.name: pv for pv in pvs}
-        self._state: Dict[str, RecordWrapper] = {}
+        self.get_autosave_pvs()
+        self._state = {}
         self._last_saved_state = {}
+        self._started = False
+        if self.enabled:
+            self.load()  # load at startup if enabled
+
+    def get_autosave_pvs(self):
+        self._pvs = {name: pv for name, pv in LookupRecordList() if pv.autosave}
 
     def _change_directory(self, directory: str):
         dir_path = Path(directory)
         if dir_path.is_dir():
-            self._directory = dir_path
+            self.directory = dir_path
         else:
             raise ValueError(f"{directory} is not a valid autosave directory")
 
@@ -44,27 +69,29 @@ def backup_sav_file(self):
         if sav_path.is_file():
             shutil.copy2(sav_path, self._get_timestamped_backup_sav_path())
 
-    def add_pv(self, pv: RecordWrapper):
+    def add_pv(self, pv):
+        pv.autosave = True
         self._pvs[pv.name] = pv
 
-    def remove_pv(self, pv: RecordWrapper):
+    def remove_pv(self, pv):
+        pv.autosave = False
         self._pvs.pop(pv.name, None)
 
     def _get_state_from_device(self):
         for name, pv in self._pvs.items():
             self._state[name] = pv.get()
 
-    def _get_timestamped_backup_sav_path(self) -> Path:
+    def _get_timestamped_backup_sav_path(self):
         sav_path = self._get_current_sav_path()
         return sav_path.parent / (
             sav_path.name + self._last_saved_time.strftime("_%y%m%d-%H%M%S")
         )
 
-    def _get_backup_save_path(self) -> Path:
-        return self._directory / f"{self._device_name}.{SAVB_SUFFIX}"
+    def _get_backup_save_path(self):
+        return self.directory / f"{self.device_name}.{SAVB_SUFFIX}"
 
-    def _get_current_sav_path(self) -> Path:
-        return self._directory / f"{self._device_name}.{SAV_SUFFIX}"
+    def _get_current_sav_path(self):
+        return self.directory / f"{self.device_name}.{SAV_SUFFIX}"
 
     def _update_last_saved(self):
         self._last_saved_state = self._state.copy()
@@ -80,19 +107,19 @@ def _save(self):
             print(f"Could not save state to file: {e}")
 
     def save(self):
-        if not self._enabled:
+        if not self.enabled:
             print("Not saving to file as autosave adapter disabled")
             return
         timenow = datetime.now()
         self._get_state_from_device()
         if (
-            (timenow - self._last_saved_time).total_seconds() > self._save_period
+            (timenow - self._last_saved_time).total_seconds() > self.save_period
             and self._state != self._last_saved_state  # only save if changed
         ):
             self._save()
 
-    def load(self, path: Optional[str] = None):
-        if not self._enabled:
+    def load(self, path = None):
+        if not self.enabled:
             print("Not loading from file as autosave adapter disabled")
             return
         sav_path = path or self._get_current_sav_path()
@@ -108,3 +135,10 @@ def load(self, path: Optional[str] = None):
                 continue
             pv.set(value)
         self._get_state_from_device()
+
+    def loop(self):
+        if not self._pvs:
+            return  # end thread if no PVs to save
+        while True:
+            time.sleep(self.poll_period)
+            self.save()

softioc/cothread_dispatcher.py

@@ -1,4 +1,5 @@
-
+import threading
+from . import autosave
 class CothreadDispatcher:
     def __init__(self, dispatcher = None):
         """A dispatcher for `cothread` based IOCs, suitable to be passed to
@@ -20,6 +21,13 @@ def __init__(self, dispatcher = None):
             self.__dispatcher = dispatcher
 
         self.wait_for_quit = cothread.WaitForQuit
+        # set up autosave thread
+        autosaver = autosave.Autosave()
+        self.__autosave_worker = threading.Thread(
+            target=autosaver.loop,
+        )
+        self.__autosave_worker.daemon = True
+        self.__autosave_worker.start()
 
     def __call__(
             self,

softioc/device.py

@@ -109,6 +109,7 @@ class ProcessDeviceSupportIn(ProcessDeviceSupportCore):
     _link_ = 'INP'
 
     def __init__(self, name, **kargs):
+        self.autosave = kargs.pop("autosave", False)
         if 'initial_value' in kargs:
             value = self._value_to_epics(kargs.pop('initial_value'))
         else:
@@ -159,6 +160,7 @@ class ProcessDeviceSupportOut(ProcessDeviceSupportCore):
     _link_ = 'OUT'
 
     def __init__(self, name, **kargs):
+        self.autosave = kargs.pop('autosave', False)
         on_update = kargs.pop('on_update', None)
         on_update_name = kargs.pop('on_update_name', None)
         # At most one of on_update and on_update_name can be specified
@@ -432,6 +434,7 @@ class WaveformBase(ProcessDeviceSupportCore):
 
 
     def __init__(self, name, _wf_nelm, _wf_dtype, **kargs):
+        self.autosave = kargs.pop("autosave", False)
         self._dtype = _wf_dtype
         self._nelm = _wf_nelm
         self.__super.__init__(name, **kargs)

softioc/pythonSoftIoc.py

@@ -24,7 +24,7 @@ def __init__(self, builder, device, name, **fields):
         # have to maintain this separately from the corresponding device list.
         DeviceKeywords = [
             'on_update', 'on_update_name', 'validate', 'always_update',
-            'initial_value', '_wf_nelm', '_wf_dtype', 'blocking']
+            'initial_value', '_wf_nelm', '_wf_dtype', 'blocking', 'autosave']
         device_kargs = {}
         for keyword in DeviceKeywords:
             if keyword in fields: