swapped back to using Futures

Author: evvaaaa

src/fastcs/backend.py

@@ -1,6 +1,8 @@
 import asyncio
+import time
 from collections import defaultdict
 from collections.abc import Callable
+from concurrent.futures import Future
 from types import MethodType
 
 from softioc.asyncio_dispatcher import AsyncioDispatcher
@@ -10,6 +12,8 @@
 from .exceptions import FastCSException
 from .mapping import Mapping, SingleMapping
 
+START_TIME = time.time()
+
 
 class Backend:
     def __init__(
@@ -19,8 +23,8 @@ def __init__(
         self._loop = self._dispatcher.loop
         self._controller = controller
 
-        self._initial_tasks = [controller.connect]
-        self._scan_tasks: list[asyncio.Task] = []
+        self._initial_coros = [controller.connect]
+        self._scan_futures: set[Future] = set()
 
         asyncio.run_coroutine_threadsafe(
             self._controller.initialise(), self._loop
@@ -41,25 +45,26 @@ def _link_process_tasks(self):
             _link_attribute_sender_class(single_mapping)
 
     def __del__(self):
-        self.stop_scan_tasks()
+        self.stop_scan_futures()
 
     def run(self):
-        self._run_initial_tasks()
-        self.start_scan_tasks()
+        self._run_initial_futures()
+        self.start_scan_futures()
         self._run()
 
-    def _run_initial_tasks(self):
-        for task in self._initial_tasks:
+    def _run_initial_futures(self):
+        for task in self._initial_coros:
             future = asyncio.run_coroutine_threadsafe(task(), self._loop)
             future.result()
 
-    def start_scan_tasks(self):
-        self._scan_tasks = [
-            self._loop.create_task(coro()) for coro in _get_scan_coros(self._mapping)
-        ]
+    def start_scan_futures(self):
+        self._scan_futures = {
+            asyncio.run_coroutine_threadsafe(coro(), self._loop)
+            for coro in _get_scan_coros(self._mapping)
+        }
 
-    def stop_scan_tasks(self):
-        for task in self._scan_tasks:
+    def stop_scan_futures(self):
+        for task in self._scan_futures:
             if not task.done():
                 try:
                     task.cancel()
@@ -163,7 +168,7 @@ def _get_periodic_scan_coros(scan_dict: dict[float, list[Callable]]) -> list[Cal
 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)
+            await asyncio.gather(*[method() for method in methods])
 
     return scan_coro

tests/test_backend.py

@@ -10,7 +10,7 @@ def __init__(self, controller):
         super().__init__(controller)
 
         self.init_task_called = False
-        self._initial_tasks.append(self.init_task)
+        self._initial_coros.append(self.init_task)
 
     async def init_task(self):
         self.init_task_called = True
@@ -44,4 +44,4 @@ async def test_backend(controller):
         await asyncio.sleep(0.1)
         assert controller.count > count
 
-    backend.stop_scan_tasks()
+    backend.stop_scan_futures()