Implement per-adapter caching of parameter trees

Author: timcnicholls

src/fastcs_odin/controllers/odin_controller.py

@@ -1,6 +1,7 @@
 from fastcs.attributes import AttributeIO
 from fastcs.connections.ip_connection import IPConnectionSettings
 from fastcs.controllers import BaseController, Controller
+from fastcs.util import snake_to_pascal
 
 from fastcs_odin.controllers.odin_data.frame_processor import (
     FrameProcessorAdapterController,
@@ -17,19 +18,12 @@
     StatusSummaryAttributeIO,
     initialise_summary_attributes,
 )
-from fastcs_odin.util import (
-    REQUEST_METADATA_HEADER,
-    AdapterType,
-    OdinParameter,
-    create_odin_parameters,
-)
+from fastcs_odin.util import AdapterType, OdinParameter, create_odin_parameters
 
 
 class OdinController(Controller):
     """A root ``Controller`` for an odin control server."""
 
-    API_PREFIX = "api/0.1"
-
     def __init__(self, settings: IPConnectionSettings) -> None:
         self.connection = HTTPConnection(settings.ip, settings.port)
         self._ios: list[AttributeIO] = [
@@ -43,7 +37,7 @@ def __init__(self, settings: IPConnectionSettings) -> None:
     async def initialise(self) -> None:
         self.connection.open()
 
-        adapters_response = await self.connection.get(f"{self.API_PREFIX}/adapters")
+        adapters_response = await self.connection.get_adapters()
         match adapters_response:
             case {"adapters": [*adapter_list]}:
                 adapters = tuple(a for a in adapter_list if isinstance(a, str))
@@ -57,9 +51,7 @@ async def initialise(self) -> None:
         for adapter in adapters:
             # Get full parameter tree and split into parameters at the root and under
             # an index where there are N identical trees for each underlying process
-            response = await self.connection.get(
-                f"{self.API_PREFIX}/{adapter}", headers=REQUEST_METADATA_HEADER
-            )
+            response = await self.connection.get(adapter, with_metadata=True)
             # Extract the module name of the adapter
             match response:
                 case {"module": {"value": str() as module}}:
@@ -70,7 +62,9 @@ async def initialise(self) -> None:
             adapter_controller = self._create_adapter_controller(
                 self.connection, create_odin_parameters(response), adapter, module
             )
-            self.add_sub_controller(adapter.upper(), adapter_controller)
+            self.add_sub_controller(
+                snake_to_pascal(adapter).upper(), adapter_controller
+            )
             await adapter_controller.initialise()
 
         initialise_summary_attributes(self)
@@ -87,17 +81,29 @@ def _create_adapter_controller(
         match module:
             case AdapterType.FRAME_PROCESSOR:
                 return FrameProcessorAdapterController(
-                    connection, parameters, f"{self.API_PREFIX}/{adapter}", self._ios
+                    connection, parameters, adapter, self._ios
                 )
             case AdapterType.FRAME_RECEIVER:
                 return FrameReceiverAdapterController(
-                    connection, parameters, f"{self.API_PREFIX}/{adapter}", self._ios
+                    connection, parameters, adapter, self._ios
                 )
             case AdapterType.META_WRITER:
                 return MetaWriterAdapterController(
-                    connection, parameters, f"{self.API_PREFIX}/{adapter}", self._ios
+                    connection, parameters, adapter, self._ios
                 )
             case _:
-                return OdinSubController(
-                    connection, parameters, f"{self.API_PREFIX}/{adapter}", self._ios
-                )
+                return OdinSubController(connection, parameters, adapter, self._ios)
+
+    def enable_request_timers(self) -> None:
+        """Enable request timers on all parameter tree caches."""
+        for io in self._ios:
+            match io:
+                case ParameterTreeAttributeIO() as ptio:
+                    ptio.enable_request_timers()
+
+    def disable_request_timers(self) -> None:
+        """Disable request timers on all parameter tree caches."""
+        for io in self._ios:
+            match io:
+                case ParameterTreeAttributeIO() as ptio:
+                    ptio.disable_request_timers()

src/fastcs_odin/controllers/odin_data/frame_processor.py

@@ -33,7 +33,7 @@ class FrameProcessorController(OdinSubController):
 
     async def initialise(self):
         plugins_response = await self.connection.get(
-            f"{self._api_prefix}/status/plugins/names"
+            f"{self._adapter}/status/plugins/names"
         )
         match plugins_response:
             case {"names": [*plugin_list]}:
@@ -57,7 +57,7 @@ async def initialise(self):
         for parameter in self.parameters:
             self.add_attribute(
                 parameter.name,
-                create_attribute(parameter=parameter, api_prefix=self._api_prefix),
+                create_attribute(parameter=parameter, adapter=self._adapter),
             )
 
     async def _create_plugin_sub_controllers(self, plugins: Sequence[str]):
@@ -74,7 +74,7 @@ def __parameter_in_plugin(
             plugin_controller = FrameProcessorPluginController(
                 self.connection,
                 plugin_parameters,
-                f"{self._api_prefix}",
+                f"{self._adapter}",
                 self._ios,
             )
             self.add_sub_controller(plugin.upper(), plugin_controller)
@@ -171,13 +171,13 @@ async def initialise(self):
                 parameter.set_path(["current_acquisition_id"])
             self.add_attribute(
                 parameter.name,
-                create_attribute(parameter=parameter, api_prefix=self._api_prefix),
+                create_attribute(parameter=parameter, adapter=self._adapter),
             )
 
     async def _create_commands(self):
         plugin_name = self.path[-1].lower()
         command_response = await self.connection.get(
-            f"{self._api_prefix}/command/{plugin_name}/allowed"
+            f"{self._adapter}/command/{plugin_name}/allowed"
         )
 
         try:
@@ -200,7 +200,7 @@ def __dataset_parameter(param: OdinParameter):
                 dataset_controller = FrameProcessorDatasetController(
                     self.connection,
                     dataset_parameters,
-                    f"{self._api_prefix}",
+                    f"{self._adapter}",
                     self._ios,
                 )
                 self.add_sub_controller("DS", dataset_controller)
@@ -210,7 +210,7 @@ def _construct_command(self, command_name, plugin_name):
         async def submit_command() -> None:
             logger.info("Executing command", plugin=plugin_name, command=command_name)
             await self.connection.put(
-                f"{self._api_prefix}/command/{plugin_name}/execute", command_name
+                f"{self._adapter}/command/{plugin_name}/execute", command_name
             )
 
         setattr(self, command_name, Command(submit_command))
@@ -224,5 +224,5 @@ async def initialise(self):
             parameter.set_path(parameter.uri[3:])
             self.add_attribute(
                 parameter.name,
-                create_attribute(parameter=parameter, api_prefix=self._api_prefix),
+                create_attribute(parameter=parameter, adapter=self._adapter),
             )

src/fastcs_odin/controllers/odin_data/frame_receiver.py

@@ -23,7 +23,7 @@ async def initialise(self):
 
             self.add_attribute(
                 parameter.name,
-                create_attribute(parameter=parameter, api_prefix=self._api_prefix),
+                create_attribute(parameter=parameter, adapter=self._adapter),
             )
 
 

src/fastcs_odin/controllers/odin_data/meta_writer.py

@@ -17,25 +17,21 @@ async def initialise(self):
                     parameter.set_path(parameter.path[2:])
             self.add_attribute(
                 parameter.name,
-                create_attribute(parameter=parameter, api_prefix=self._api_prefix),
+                create_attribute(parameter=parameter, adapter=self._adapter),
             )
 
     acquisition_id = AttrRW(
-        String(), io_ref=ParameterTreeAttributeIORef("api/0.1/mw/config/acquisition_id")
+        String(), io_ref=ParameterTreeAttributeIORef("mw", "config/acquisition_id")
     )
     directory = AttrRW(
-        String(), io_ref=ParameterTreeAttributeIORef("api/0.1/mw/config/directory")
+        String(), io_ref=ParameterTreeAttributeIORef("mw", "config/directory")
     )
     file_prefix = AttrRW(
-        String(), io_ref=ParameterTreeAttributeIORef("api/0.1/mw/config/file_prefix")
-    )
-    writing = AttrR(
-        Bool(), io_ref=ParameterTreeAttributeIORef("api/0.1/mw/status/writing")
-    )
-    written = AttrR(
-        Int(), io_ref=ParameterTreeAttributeIORef("api/0.1/mw/status/written")
+        String(), io_ref=ParameterTreeAttributeIORef("mw", "config/file_prefix")
     )
+    writing = AttrR(Bool(), io_ref=ParameterTreeAttributeIORef("mw", "status/writing"))
+    written = AttrR(Int(), io_ref=ParameterTreeAttributeIORef("mw", "status/written"))
 
     @command()
     async def stop(self):
-        await self.connection.put("api/0.1/mw/config/stop", True)
+        await self.connection.put("mw/config/stop", True)

src/fastcs_odin/controllers/odin_data/odin_data_adapter.py

@@ -27,21 +27,21 @@ def __init__(
         self,
         connection: HTTPConnection,
         parameters: list[OdinParameter],
-        api_prefix: str,
+        adapter: str,
         ios: Sequence[AttributeIO[DType_T, AttributeIORefT]],
     ):
         """
         Args:
             connection: HTTP connection to communicate with odin server
             parameters: The parameters in the adapter
-            api_prefix: The base URL of this adapter in the odin server API
+            adapter: The base URL of this adapter in the odin server API
 
         """
         super().__init__(ios=ios, children={})
 
         self.connection = connection
         self.parameters = parameters
-        self._api_prefix = api_prefix
+        self._adapter = adapter
         self._ios = ios
 
     async def initialise(self):
@@ -58,7 +58,7 @@ async def initialise(self):
             adapter_controller = self._subcontroller_cls(
                 self.connection,
                 fp_parameters,
-                f"{self._api_prefix}/{idx}",
+                f"{self._adapter}/{idx}",
                 self._ios,
             )
             self[int(idx)] = adapter_controller
@@ -67,7 +67,7 @@ async def initialise(self):
         for parameter in self.parameters:
             self.add_attribute(
                 parameter.name,
-                create_attribute(parameter=parameter, api_prefix=self._api_prefix),
+                create_attribute(parameter=parameter, adapter=self._adapter),
             )
         self._create_config_fan_attributes()
         initialise_summary_attributes(self)

src/fastcs_odin/controllers/odin_subcontroller.py

@@ -15,26 +15,26 @@ def __init__(
         self,
         connection: HTTPConnection,
         parameters: list[OdinParameter],
-        api_prefix: str,
+        adapter: str,
         ios: Sequence[AttributeIO[DType_T, AttributeIORefT]],
     ):
         """
         Args:
             connection: HTTP connection to communicate with odin server
             parameters: The parameters in the adapter
-            api_prefix: The base URL of this adapter in the odin server API
+            adapter: The base URL of this adapter in the odin server API
 
         """
         super().__init__(ios=ios)
 
         self.connection = connection
         self.parameters = parameters
-        self._api_prefix = api_prefix
+        self._adapter = adapter
         self._ios = ios
 
     async def initialise(self):
         for parameter in self.parameters:
             self.add_attribute(
                 parameter.name,
-                create_attribute(parameter=parameter, api_prefix=self._api_prefix),
+                create_attribute(parameter=parameter, adapter=self._adapter),
             )

src/fastcs_odin/http_connection.py

@@ -8,10 +8,14 @@
 
 
 class HTTPConnection:
-    def __init__(self, ip: str, port: int):
+    DEFAULT_API_PREFIX = "api/0.1"
+    REQUEST_METADATA_HEADER = {"Accept": "application/json;metadata=true"}
+
+    def __init__(self, ip: str, port: int, api_prefix: str = DEFAULT_API_PREFIX):
         self._session: ClientSession | None = None
         self._ip = ip
         self._port = port
+        self._api_prefix = api_prefix
 
     def full_url(self, uri: str) -> str:
         """Expand IP address, port and URI into full URL.
@@ -20,7 +24,7 @@ def full_url(self, uri: str) -> str:
             uri: Identifier for a resource for the current connection
 
         """
-        return f"http://{self._ip}:{self._port}/{uri}"
+        return f"http://{self._ip}:{self._port}/{self._api_prefix}/{uri}"
 
     def open(self):
         """Create the underlying aiohttp ClientSession.
@@ -44,7 +48,15 @@ def get_session(self) -> ClientSession:
 
         raise ConnectionRefusedError("Session is not open")
 
-    async def get(self, uri: str, headers: dict | None = None) -> dict[str, JsonType]:
+    async def get_adapters(self) -> dict[str, JsonType]:
+        """Get a list of adapters from the server.
+
+        Returns: Response payload as JSON
+
+        """
+        return await self.get("adapters")
+
+    async def get(self, uri: str, with_metadata: bool = False) -> dict[str, JsonType]:
         """Perform HTTP GET request and return response content as JSON.
 
         Args:
@@ -54,6 +66,9 @@ async def get(self, uri: str, headers: dict | None = None) -> dict[str, JsonType
 
         """
         session = self.get_session()
+
+        headers = self.REQUEST_METADATA_HEADER if with_metadata else None
+
         async with session.get(self.full_url(uri), headers=headers) as response:
             match await response.json():
                 case dict() as d: