WIP

src/fastcs/launch.py

@@ -16,9 +16,9 @@
 from .transport.adapter import TransportAdapter
 from .transport.epics.options import EpicsOptions
 from .transport.graphQL.options import GraphQLOptions
+from .transport.p4p.options import P4POptions
 from .transport.rest.options import RestOptions
 from .transport.tango.options import TangoOptions
-from .transport.p4p_server.options import P4POptions
 
 # Define a type alias for transport options
 TransportOptions: TypeAlias = list[
@@ -69,11 +69,10 @@ def __init__(
                         option,
                     )
                 case P4POptions():
-                    from .transport.p4p_server.adapter import P4PTransport
+                    from .transport.p4p.adapter import P4PTransport
 
                     transport = P4PTransport(
                         controller,
-                        self._loop,
                         option,
                     )
             self._transports.append(transport)
@@ -89,13 +88,11 @@ def create_gui(self) -> None:
                 transport.create_gui()
 
     def run(self):
-        self._loop.run_until_complete(
-            self.serve(),
-        )
+        self._loop.run_until_complete(self.serve())
 
     async def serve(self) -> None:
-        coros = [self._backend.serve()]
-        coros.extend([transport.serve() for transport in self._transports])
+        # coros = [self._backend.serve()]
+        coros = [transport.serve() for transport in self._transports]
         await asyncio.gather(*coros)
 
 

src/fastcs/transport/p4p_server/adapter.py → src/fastcs/transport/p4p/adapter.py

@@ -3,28 +3,30 @@
 from fastcs.controller import Controller
 from fastcs.transport.adapter import TransportAdapter
 
-from fastcs.transport.p4p_server.ioc import P4PServer
-from fastcs.transport.p4p_server.options import P4POptions
+from .ioc import P4PIOC
+from .options import P4POptions
 
 
 class P4PTransport(TransportAdapter):
     def __init__(
         self,
         controller: Controller,
-        loop: asyncio.AbstractEventLoop,
         options: P4POptions | None = None,
     ) -> None:
         self._controller = controller
-        self._loop = loop
         self._options = options or P4POptions()
         self._pv_prefix = self.options.ioc.pv_prefix
-        self._ioc = P4PServer(self.options.ioc.pv_prefix, controller, self._loop)
+        self._ioc = P4PIOC(self.options.ioc.pv_prefix, controller)
 
     @property
     def options(self) -> P4POptions:
         return self._options
 
     async def serve(self) -> None:
-        self._ioc.run()
-        while True:
-            await asyncio.sleep(1)
+        await self._ioc.run()
+
+    def create_docs(self) -> None:
+        raise NotImplementedError
+
+    def create_gui(self) -> None:
+        raise NotImplementedError

src/fastcs/transport/p4p_server/ioc.py → src/fastcs/transport/p4p/ioc.py

@@ -1,12 +1,16 @@
 import asyncio
-from fastcs.attributes import AttrR, AttrRW, AttrW
+import signal
+import time
+
+from fastcs.attributes import AttrR, AttrW, AttrRW
 from fastcs.controller import Controller
-from p4p.server import Server, StaticProvider
 from fastcs.datatypes import T
-from fastcs.transport.p4p_server.util import get_nt_from_datatype
+from p4p.server import Server, StaticProvider
 from p4p.server.asyncio import SharedPV
-import signal
-import time
+
+from .util import get_nt_from_datatype
+
+_pvs = set()
 
 
 class AttrWHandler:
@@ -30,7 +34,6 @@ async def make_provider_from_controller(
 
     for single_mapping in controller.get_controller_mappings():
         path = single_mapping.controller.path
-        print("PATH", path)
         pv_prefix = ":".join([prefix_root] + path)
         provider = StaticProvider(pv_prefix)
         providers[pv_prefix] = provider
@@ -39,6 +42,8 @@ async def make_provider_from_controller(
             pv_name = f"{pv_prefix}:{attr_name.title().replace('_', '')}"
 
             match attribute:
+                case AttrRW():
+                    continue
                 case AttrW():
                     shared_pv = SharedPV(
                         handler=AttrWHandler(attribute),
@@ -51,17 +56,20 @@ async def make_provider_from_controller(
                         nt=get_nt_from_datatype(attribute.datatype),
                     )
 
+                    """
                     async def on_update(value: T):
                         shared_pv.post(value, timestamp=time.time())
 
                     attribute.set_update_callback(on_update)
+                    """
                 case _:
                     raise RuntimeError()
                 # case AttrRW():
                 #     _create_read_pv(_pv_prefix, f"{pv_name}_RBV", attr_name, attribute)
                 #     _create_write_pv(_pv_prefix, pv_name, attr_name, attribute)
 
-            print(pv_name)
+            print("Adding", pv_name)
+            _pvs.add(shared_pv)
             provider.add(pv_name, shared_pv)
     return providers
 
@@ -71,15 +79,11 @@ def __init__(
         self,
         pv_prefix: str,
         controller: Controller,
-        loop: asyncio.AbstractEventLoop,
     ):
         self._controller = controller
         self._pv_prefix = pv_prefix
-        self._loop = loop
         self._providers = {}
 
-        loop.run_until_complete(self.make_attribute_providers())
-
     async def make_attribute_providers(self):
         self._providers.update(
             await make_provider_from_controller(self._pv_prefix, self._controller)
@@ -90,23 +94,25 @@ def providers(self):
         return list(self._providers.values())
 
 
-class P4PServer:
+class P4PIOC:
     def __init__(
         self,
         pv_prefix: str,
         controller: Controller,
-        loop: asyncio.AbstractEventLoop | None = None,
+        loop: asyncio.AbstractEventLoop,
     ):
-        self.loop = loop or asyncio.get_event_loop()
-        self.providers_wrapper = ProvidersWrapper(pv_prefix, controller, self.loop)
-
-    def run(self):
-        try:
-            server = Server(self.providers_wrapper.providers)
-            with server:
-                done = asyncio.Event()
-                self.loop.add_signal_handler(signal.SIGINT, done.set)
-                self.loop.add_signal_handler(signal.SIGTERM, done.set)
-                self.loop.run_until_complete(done.wait())
-        finally:
-            self.loop.close()
+        self.pv_prefix = pv_prefix
+        self.controller = controller
+        self.loop = loop
+
+    async def run(self):
+        """To be ran in the same event loop as `self.loop`."""
+
+        self.providers_wrapper = ProvidersWrapper(self.pv_prefix, self.controller)
+        await self.providers_wrapper.make_attribute_providers()
+
+        server = Server(self.providers_wrapper.providers)
+        event = asyncio.Event()
+        with server:
+            await event.wait()
+        print("LEAVING")

src/fastcs/transport/p4p_server/util.py → src/fastcs/transport/p4p/util.py

@@ -1,4 +1,4 @@
-from fastcs.datatypes import DataType, Int, Float, String, Bool
+from fastcs.datatypes import Bool, DataType, Float, Int, String
 from p4p.nt import NTScalar
 
 

tests/benchmarking/test_benchmarking.py

@@ -5,6 +5,7 @@
 import pytest
 import requests
 import tango
+
 from p4p.client.thread import Context
 
 FASTCS_BENCHMARKING = os.getenv("FASTCS_BENCHMARKING") == "true"

tests/p4p.py → tests/p4p_ioc.py

@@ -2,7 +2,7 @@
 from fastcs.controller import Controller, SubController
 from fastcs.datatypes import Int
 from fastcs.launch import FastCS
-from fastcs.transport.p4p_server.options import P4POptions, P4PIOCOptions
+from fastcs.transport.p4p.options import P4PIOCOptions, P4POptions
 from fastcs.wrappers import command