teardown tasks when the backend is deleted

Author: evvaaaa

src/fastcs/backend.py

@@ -1,7 +1,6 @@
 import asyncio
 from collections import defaultdict
 from collections.abc import Callable
-from concurrent.futures import Future
 from types import MethodType
 
 from softioc.asyncio_dispatcher import AsyncioDispatcher
@@ -21,7 +20,7 @@ def __init__(
         self._controller = controller
 
         self._initial_tasks = [controller.connect]
-        self._scan_tasks: list[Future] = []
+        self._scan_tasks: list[asyncio.Task] = []
 
         asyncio.run_coroutine_threadsafe(
             self._controller.initialise(), self._loop
@@ -41,30 +40,31 @@ def _link_process_tasks(self):
             _link_single_controller_put_tasks(single_mapping)
             _link_attribute_sender_class(single_mapping)
 
+    def __del__(self):
+        self.stop_scan_tasks()
+
     def run(self):
         self._run_initial_tasks()
-        self._start_scan_tasks()
-
+        self.start_scan_tasks()
         self._run()
 
     def _run_initial_tasks(self):
         for task in self._initial_tasks:
             future = asyncio.run_coroutine_threadsafe(task(), self._loop)
             future.result()
 
-    def _start_scan_tasks(self):
-        async def run_tasks():
-            futures = [task() for task in _get_scan_tasks(self._mapping)]
-            for future in asyncio.as_completed(futures):
-                try:
-                    await future
-                except Exception as e:
-                    # We don't exit the ioc when a scan loop errors,
-                    # but we do print the information.
-                    print(f"Scan loop stopped with exception:\n    {e}")
-                    raise e
+    def start_scan_tasks(self):
+        self._scan_tasks = [
+            self._loop.create_task(coro()) for coro in _get_scan_coros(self._mapping)
+        ]
 
-        asyncio.run_coroutine_threadsafe(run_tasks(), self._loop)
+    def stop_scan_tasks(self):
+        for task in self._scan_tasks:
+            if not task.done():
+                try:
+                    task.cancel()
+                except asyncio.CancelledError:
+                    pass
 
     def _run(self):
         raise NotImplementedError("Specific Backend must implement _run")
@@ -106,15 +106,15 @@ async def callback(value):
     return callback
 
 
-def _get_scan_tasks(mapping: Mapping) -> list[Callable]:
+def _get_scan_coros(mapping: Mapping) -> list[Callable]:
     scan_dict: dict[float, list[Callable]] = defaultdict(list)
 
     for single_mapping in mapping.get_controller_mappings():
         _add_scan_method_tasks(scan_dict, single_mapping)
         _add_attribute_updater_tasks(scan_dict, single_mapping)
 
-    scan_tasks = _get_periodic_scan_tasks(scan_dict)
-    return scan_tasks
+    scan_coros = _get_periodic_scan_coros(scan_dict)
+    return scan_coros
 
 
 def _add_scan_method_tasks(
@@ -152,18 +152,18 @@ async def callback():
     return callback
 
 
-def _get_periodic_scan_tasks(scan_dict: dict[float, list[Callable]]) -> list[Callable]:
-    periodic_scan_tasks: list[Callable] = []
+def _get_periodic_scan_coros(scan_dict: dict[float, list[Callable]]) -> list[Callable]:
+    periodic_scan_coros: list[Callable] = []
     for period, methods in scan_dict.items():
-        periodic_scan_tasks.append(_create_periodic_scan_task(period, methods))
+        periodic_scan_coros.append(_create_periodic_scan_coro(period, methods))
 
-    return periodic_scan_tasks
+    return periodic_scan_coros
 
 
-def _create_periodic_scan_task(period, methods: list[Callable]) -> Callable:
-    async def scan_task() -> None:
+def _create_periodic_scan_coro(period, methods: list[Callable]) -> Callable:
+    async def scan_coro() -> None:
         while True:
             await asyncio.gather(*[method() for method in methods])
             await asyncio.sleep(period)
 
-    return scan_task
+    return scan_coro

src/fastcs/backends/epics/ioc.py

@@ -226,7 +226,7 @@ async def async_write_display(value: T):
 def _get_output_record(pv: str, attribute: AttrW, on_update: Callable) -> Any:
     if attr_is_enum(attribute):
         assert attribute.allowed_values is not None and all(
-            isinstance(v, str) for v in attribute.allowed_values
+            isinstance(v, str) or isinstance(v, int) for v in attribute.allowed_values
         )
         state_keys = dict(zip(MBB_STATE_FIELDS, attribute.allowed_values, strict=False))
         return builder.mbbOut(pv, always_update=True, on_update=on_update, **state_keys)

tests/backends/epics/test_ioc.py

@@ -7,11 +7,7 @@
 from fastcs.backends.epics.ioc import (
     EPICS_MAX_NAME_LENGTH,
     EpicsIOC,
-    _add_attr_pvi_info,
     _add_pvi_info,
-    _add_sub_controller_pvi_info,
-    _create_and_link_read_pv,
-    _create_and_link_write_pv,
     _get_input_record,
     _get_output_record,
 )
@@ -27,17 +23,31 @@
 ONOFF_STATES = {"ZRST": "disabled", "ONST": "enabled"}
 
 
+@pytest.fixture
+def ioc_without_mapping(mocker: MockerFixture, mapping: Mapping):
+    mocker.patch("fastcs.backends.epics.ioc.builder")
+    mocker.patch("fastcs.backends.epics.ioc.EpicsIOC._create_and_link_attribute_pvs")
+    mocker.patch("fastcs.backends.epics.ioc.EpicsIOC._create_and_link_command_pvs")
+
+    return EpicsIOC(DEVICE, mapping)
+
+
 @pytest.mark.asyncio
-async def test_create_and_link_read_pv(mocker: MockerFixture):
+async def test_create_and_link_read_pv(
+    mocker: MockerFixture, ioc_without_mapping: EpicsIOC
+):
     get_input_record = mocker.patch("fastcs.backends.epics.ioc._get_input_record")
-    add_attr_pvi_info = mocker.patch("fastcs.backends.epics.ioc._add_attr_pvi_info")
     attr_is_enum = mocker.patch("fastcs.backends.epics.ioc.attr_is_enum")
+    mocker.patch("fastcs.backends.epics.ioc._add_pvi_info")
+    add_attr_pvi_info = mocker.patch(
+        "fastcs.backends.epics.ioc.EpicsIOC._add_attr_pvi_info"
+    )
     record = get_input_record.return_value
 
     attribute = mocker.MagicMock()
-
     attr_is_enum.return_value = False
-    _create_and_link_read_pv("PREFIX", "PV", "attr", attribute)
+
+    ioc_without_mapping._create_and_link_read_pv("PREFIX", "PV", "attr", attribute)
 
     get_input_record.assert_called_once_with("PREFIX:PV", attribute)
     add_attr_pvi_info.assert_called_once_with(record, "PREFIX", "attr", "r")
@@ -51,17 +61,21 @@ async def test_create_and_link_read_pv(mocker: MockerFixture):
 
 
 @pytest.mark.asyncio
-async def test_create_and_link_read_pv_enum(mocker: MockerFixture):
+async def test_create_and_link_read_pv_enum(
+    mocker: MockerFixture, ioc_without_mapping: EpicsIOC
+):
     get_input_record = mocker.patch("fastcs.backends.epics.ioc._get_input_record")
-    add_attr_pvi_info = mocker.patch("fastcs.backends.epics.ioc._add_attr_pvi_info")
+    add_attr_pvi_info = mocker.patch(
+        "fastcs.backends.epics.ioc.EpicsIOC._add_attr_pvi_info"
+    )
     attr_is_enum = mocker.patch("fastcs.backends.epics.ioc.attr_is_enum")
     record = get_input_record.return_value
     enum_value_to_index = mocker.patch("fastcs.backends.epics.ioc.enum_value_to_index")
 
     attribute = mocker.MagicMock()
 
     attr_is_enum.return_value = True
-    _create_and_link_read_pv("PREFIX", "PV", "attr", attribute)
+    ioc_without_mapping._create_and_link_read_pv("PREFIX", "PV", "attr", attribute)
 
     get_input_record.assert_called_once_with("PREFIX:PV", attribute)
     add_attr_pvi_info.assert_called_once_with(record, "PREFIX", "attr", "r")
@@ -108,17 +122,21 @@ def test_get_input_record_raises(mocker: MockerFixture):
 
 
 @pytest.mark.asyncio
-async def test_create_and_link_write_pv(mocker: MockerFixture):
+async def test_create_and_link_write_pv(
+    mocker: MockerFixture, ioc_without_mapping: EpicsIOC
+):
     get_output_record = mocker.patch("fastcs.backends.epics.ioc._get_output_record")
-    add_attr_pvi_info = mocker.patch("fastcs.backends.epics.ioc._add_attr_pvi_info")
+    add_attr_pvi_info = mocker.patch(
+        "fastcs.backends.epics.ioc.EpicsIOC._add_attr_pvi_info"
+    )
     attr_is_enum = mocker.patch("fastcs.backends.epics.ioc.attr_is_enum")
     record = get_output_record.return_value
 
     attribute = mocker.MagicMock()
     attribute.process_without_display_update = mocker.AsyncMock()
 
     attr_is_enum.return_value = False
-    _create_and_link_write_pv("PREFIX", "PV", "attr", attribute)
+    ioc_without_mapping._create_and_link_write_pv("PREFIX", "PV", "attr", attribute)
 
     get_output_record.assert_called_once_with(
         "PREFIX:PV", attribute, on_update=mocker.ANY
@@ -140,9 +158,13 @@ async def test_create_and_link_write_pv(mocker: MockerFixture):
 
 
 @pytest.mark.asyncio
-async def test_create_and_link_write_pv_enum(mocker: MockerFixture):
+async def test_create_and_link_write_pv_enum(
+    mocker: MockerFixture, ioc_without_mapping: EpicsIOC
+):
     get_output_record = mocker.patch("fastcs.backends.epics.ioc._get_output_record")
-    add_attr_pvi_info = mocker.patch("fastcs.backends.epics.ioc._add_attr_pvi_info")
+    add_attr_pvi_info = mocker.patch(
+        "fastcs.backends.epics.ioc.EpicsIOC._add_attr_pvi_info"
+    )
     attr_is_enum = mocker.patch("fastcs.backends.epics.ioc.attr_is_enum")
     enum_value_to_index = mocker.patch("fastcs.backends.epics.ioc.enum_value_to_index")
     enum_index_to_value = mocker.patch("fastcs.backends.epics.ioc.enum_index_to_value")
@@ -152,7 +174,7 @@ async def test_create_and_link_write_pv_enum(mocker: MockerFixture):
     attribute.process_without_display_update = mocker.AsyncMock()
 
     attr_is_enum.return_value = True
-    _create_and_link_write_pv("PREFIX", "PV", "attr", attribute)
+    ioc_without_mapping._create_and_link_write_pv("PREFIX", "PV", "attr", attribute)
 
     get_output_record.assert_called_once_with(
         "PREFIX:PV", attribute, on_update=mocker.ANY
@@ -215,22 +237,28 @@ def test_ioc(mocker: MockerFixture, mapping: Mapping):
     builder = mocker.patch("fastcs.backends.epics.ioc.builder")
     add_pvi_info = mocker.patch("fastcs.backends.epics.ioc._add_pvi_info")
     add_sub_controller_pvi_info = mocker.patch(
-        "fastcs.backends.epics.ioc._add_sub_controller_pvi_info"
+        "fastcs.backends.epics.ioc.EpicsIOC._add_sub_controller_pvi_info"
     )
 
     EpicsIOC(DEVICE, mapping)
 
     # Check records are created
     builder.boolIn.assert_called_once_with(f"{DEVICE}:ReadBool", ZNAM="OFF", ONAM="ON")
-    builder.longIn.assert_any_call(f"{DEVICE}:ReadInt")
-    builder.aIn.assert_called_once_with(f"{DEVICE}:ReadWriteFloat_RBV", PREC=2)
+    builder.longIn.assert_any_call(f"{DEVICE}:ReadInt", EGU=None)
+    builder.aIn.assert_called_once_with(
+        f"{DEVICE}:ReadWriteFloat_RBV", EGU=None, PREC=2
+    )
     builder.aOut.assert_any_call(
-        f"{DEVICE}:ReadWriteFloat", always_update=True, on_update=mocker.ANY, PREC=2
+        f"{DEVICE}:ReadWriteFloat",
+        always_update=True,
+        on_update=mocker.ANY,
+        EGU=None,
+        PREC=2,
     )
-    builder.longIn.assert_any_call(f"{DEVICE}:BigEnum")
-    builder.longIn.assert_any_call(f"{DEVICE}:ReadWriteInt_RBV")
+    builder.longIn.assert_any_call(f"{DEVICE}:BigEnum", EGU=None)
+    builder.longIn.assert_any_call(f"{DEVICE}:ReadWriteInt_RBV", EGU=None)
     builder.longOut.assert_called_with(
-        f"{DEVICE}:ReadWriteInt", always_update=True, on_update=mocker.ANY
+        f"{DEVICE}:ReadWriteInt", always_update=True, on_update=mocker.ANY, EGU=None
     )
     builder.mbbIn.assert_called_once_with(
         f"{DEVICE}:StringEnum_RBV", ZRST="red", ONST="green", TWST="blue"
@@ -323,25 +351,27 @@ def test_add_pvi_info_with_parent(mocker: MockerFixture):
     )
 
 
-def test_add_sub_controller_pvi_info(mocker: MockerFixture):
+def test_add_sub_controller_pvi_info(
+    mocker: MockerFixture, ioc_without_mapping: EpicsIOC
+):
     add_pvi_info = mocker.patch("fastcs.backends.epics.ioc._add_pvi_info")
     controller = mocker.MagicMock()
     controller.path = []
     child = mocker.MagicMock()
     child.path = ["Child"]
     controller.get_sub_controllers.return_value = {"d": child}
 
-    _add_sub_controller_pvi_info(DEVICE, controller)
+    ioc_without_mapping._add_sub_controller_pvi_info(DEVICE, controller)
 
     add_pvi_info.assert_called_once_with(
         f"{DEVICE}:Child:PVI", f"{DEVICE}:PVI", "child"
     )
 
 
-def test_add_attr_pvi_info(mocker: MockerFixture):
+def test_add_attr_pvi_info(mocker: MockerFixture, ioc_without_mapping: EpicsIOC):
     record = mocker.MagicMock()
 
-    _add_attr_pvi_info(record, DEVICE, "attr", "r")
+    ioc_without_mapping._add_attr_pvi_info(record, DEVICE, "attr", "r")
 
     record.add_info.assert_called_once_with(
         "Q:group",
@@ -387,13 +417,9 @@ def test_long_pv_names_discarded(mocker: MockerFixture):
 
     short_pv_name = "attr_rw_short_name".title().replace("_", "")
     builder.longOut.assert_called_once_with(
-        f"{DEVICE}:{short_pv_name}",
-        always_update=True,
-        on_update=mocker.ANY,
-    )
-    builder.longIn.assert_called_once_with(
-        f"{DEVICE}:{short_pv_name}_RBV",
+        f"{DEVICE}:{short_pv_name}", always_update=True, on_update=mocker.ANY, EGU=None
     )
+    builder.longIn.assert_called_once_with(f"{DEVICE}:{short_pv_name}_RBV", EGU=None)
 
     long_pv_name = long_attr_name.title().replace("_", "")
     with pytest.raises(AssertionError):

tests/test_backend.py

@@ -1,4 +1,4 @@
-from time import sleep
+import asyncio
 
 import pytest
 
@@ -16,7 +16,7 @@ async def init_task(self):
         self.init_task_called = True
 
     def _run(self):
-        pass
+        asyncio.run_coroutine_threadsafe(asyncio.sleep(0.3), self._loop)
 
 
 @pytest.mark.asyncio
@@ -41,5 +41,7 @@ async def test_backend(controller):
     # Scan tasks should be running
     for _ in range(3):
         count = controller.count
-        sleep(0.05)
+        await asyncio.sleep(0.1)
         assert controller.count > count
+
+    backend.stop_scan_tasks()