api rework

Author: jryannel

.vscode/settings.json

@@ -1,7 +1,3 @@
 {
-    "python.testing.pytestEnabled": true,
-    "python.testing.cwd": ".",
-    "python.analysis.logLevel": "Information",
-    "python.testing.nosetestsEnabled": false,
-    "python.testing.unittestEnabled": false,    
-}
+  "python.testing.pytestEnabled": true
+}

examples/app.py

@@ -9,7 +9,7 @@ class Counter(IObjectSink):
     count = 0
     client = None
     def __init__(self):
-        self.client = ClientNode.add_object_sink(self)
+        self.client = ClientNode.register_sink(self)
         print('client', self.client)
 
     def increment(self):

examples/server.py

@@ -21,7 +21,7 @@ class CounterAdapter(IObjectSource):
     node: RemoteNode = None
     def __init__(self, impl):
         self.impl = impl
-        RemoteNode.add_object_source(self)
+        RemoteNode.register_source(self)
 
     def olink_object_name(self):
         return 'demo.Counter'

src/olink/clientnode.py

@@ -16,18 +16,23 @@ def __init__(self, name: str, value: Any):
 
 class IObjectSink(ProtocolType):
     def olink_object_name() -> str:
+        # return object name
         raise NotImplementedError()
 
     def olink_on_signal(self, name: str, args: list[Any]) -> None:
+        # called on signal message
         raise NotImplementedError()
 
     def olink_on_property_changed(self, name: str, value: Any) -> None:
+        # called on property changed message
         raise NotImplementedError()
 
     def olink_on_init(self, name: str, props: object, node: "ClientNode"):
+        # called on init message
         raise NotImplementedError()
 
     def olink_on_release(self) -> None:
+        # called when sink is released
         raise NotImplementedError()
 
 class SinkToClientEntry:
@@ -39,72 +44,77 @@ def __init__(self, sink=None):
 
 
 class ClientRegistry(Base):
+    # client side registry to link sinks to nodes
     entries: dict[str, SinkToClientEntry] = {}
-    def attach_client_node(self, node: "ClientNode"):
-        pass
 
-    def detach_client_node(self, node: "ClientNode"):
+    def remove_node(self, node: "ClientNode"):
+        # remove node from all sinks
         for entry in self.entries.values():
             if entry.node is node:
                 entry.node = None
 
-    def link_client_node(self, name: str, node: "ClientNode"):        
-        self.entry(name).node = node
+    def add_node_to_sink(self, name: str, node: "ClientNode"):        
+        # add not to named sink
+        self._entry(name).node = node
 
-    def unlink_client_node(self, name: str, node: "ClientNode"):
+    def remove_node_from_sink(self, name: str, node: "ClientNode"):
+        # remove node from named sink
         resource = Name.resource_from_name(name)
         if resource in self.entries:
             if self.entries[resource].node is node:
                 self.entries[resource].node = None
             else:
                 self.emit_log(LogLevel.DEBUG, f"unlink node failed, not the same node: {resource}")
 
-    def add_object_sink(self, sink: IObjectSink) -> "ClientNode":
+    def register_sink(self, sink: IObjectSink) -> "ClientNode":
+        # register sink using object name
         name = sink.olink_object_name()
-        entry = self.entry(name)
+        entry = self._entry(name)
         entry.sink = sink
         return entry.node
 
-    def remove_object_sink(self, sink: IObjectSink):
+    def unregister_sink(self, sink: IObjectSink):
+        # unregister sink using object name
         name = sink.olink_object_name()
-        self.remove_entry(name)
+        self._remove_entry(name)
 
-    def get_object_sink(self, name: str) -> Optional[IObjectSink]:
-        return self.entry(name).sink
+    def get_sink(self, name: str) -> Optional[IObjectSink]:
+        # get sink using name
+        return self._entry(name).sink
 
-    def get_client_node(self, name: str) -> Optional["ClientNode"]:
-        return self.entry(name).node
+    def get_node(self, name: str) -> Optional["ClientNode"]:
+        # get node using name
+        return self._entry(name).node
 
-    def entry(self, name: str) -> SinkToClientEntry:
+    def _entry(self, name: str) -> SinkToClientEntry:
+        # get an entry by name
         resource = Name.resource_from_name(name)
         if not resource in self.entries:
             self.emit_log(LogLevel.DEBUG, f"add new resource: {resource}")
             self.entries[resource] = SinkToClientEntry()
         return self.entries[resource]
 
-    def remove_entry(self, name: str) -> None:
+    def _remove_entry(self, name: str) -> None:
+        # remove an entry by name
         resource = Name.resource_from_name(name)
         del self.entries[resource]
 
 
-    
-
+# global client registry
 _registry = ClientRegistry()
 
+def get_client_registry() -> ClientRegistry:
+    return _registry
 
 class ClientNode(BaseNode):
     invokes_pending: dict[int, InvokeReplyFunc] = {}
     requestId = 0
 
-    def __init__(self):
-        super().__init__()
-        self.registry().attach_client_node(self)
-
     def registry(self) -> ClientRegistry:
-        return _registry
+        return get_client_registry()
 
     def detach(self) -> None:
-        self.registry().detach_client_node(self)
+        self.registry().remove_node(self)
 
     def next_request_id(self) -> int:
         self.requestId += 1
@@ -118,49 +128,60 @@ def invoke_remote(self, name: str, args: list[Any], func: Optional[InvokeReplyFu
         self.emit_write(Protocol.invoke_message(request_id, name, args))
 
     def set_remote_property(self, name: str, value: Any) -> None:
+        # send remote propertymessage
         self.emit_log(LogLevel.DEBUG, f"ClientNode.set_remote_property: {name} {value}")   
         self.emit_write(Protocol.set_property_message(name, value))
 
     def link_node(self, name: str):
-        self.registry().link_client_node(name, self)
+        # register this node to sink
+        self.registry().add_node_to_sink(name, self)
 
     def unlink_node(self, name: str) -> None:
-        self.registry().unlink_client_node(name, self)
+        # unregister this node from sink
+        self.registry().remove_node_from_sink(name, self)
 
     @staticmethod
-    def add_object_sink(sink: IObjectSink) -> Optional["ClientNode"]:
-        return _registry.add_object_sink(sink)
+    def register_sink(sink: IObjectSink) -> Optional["ClientNode"]:
+        # register sink to registry
+        return get_client_registry().register_sink(sink)
 
     @staticmethod
-    def remove_object_sink(sink: IObjectSink) -> None:
-        return _registry.remove_object_sink(sink)
+    def unregister_sink(sink: IObjectSink) -> None:
+        # unregister sink from registry
+        return get_client_registry().unregister_sink(sink)
 
-    def get_object_sink(self, name: str) -> Optional[IObjectSink]:
-        return self.registry().get_object_sink(name)
+    @staticmethod
+    def get_sink(name: str) -> Optional[IObjectSink]:
+        return get_client_registry().get_sink(name)
 
-    def link_remote(self, name: str):        
+    def link_remote(self, name: str):      
+        # register this node from sink and send a link message  
         self.emit_log(LogLevel.DEBUG, f"ClientNode.linkRemote: {name}")
-        self.registry().link_client_node(name, self)
+        self.registry().add_node_to_sink(name, self)
         self.emit_write(Protocol.link_message(name))
 
     def unlink_remote(self, name: str):
+        # unlink this node froom sink and send an unlink message
         self.emit_log(LogLevel.DEBUG, f"ClientNode.unlink_remote: {name}")
         self.emit_write(Protocol.unlink_message(name))
-        self.registry().unlink_client_node(name, self)
+        self.registry().remove_node_from_sink(name, self)
 
     def handle_init(self, name: str, props: object):
+        # handle init message from source
         self.emit_log(LogLevel.DEBUG, f"ClientNode.handle_init: {name}")
-        sink = self.get_object_sink(name)
+        sink = self.get_sink(name)
         if sink:
             sink.olink_on_init(name, props, self)
 
     def handle_property_change(self, name: str, value: Any) -> None:
+        # handle property change message from source
         self.emit_log(LogLevel.DEBUG, f"ClientNode.handle_property_change: {name}")
-        sink =self.get_object_sink(name)
+        sink =self.get_sink(name)
         if sink:
             sink.olink_on_property_changed(name, value)
 
     def handle_invoke_reply(self, id: int, name: str, value: Any) -> None:
+        # handle invoke reply message from source
         self.emit_log(LogLevel.DEBUG, f"ClientNode.handle_invoke_reply: {id} {name} {value}")
         if id in self.invokes_pending:
             func = self.invokes_pending[id]
@@ -172,12 +193,14 @@ def handle_invoke_reply(self, id: int, name: str, value: Any) -> None:
             self.emit_log(LogLevel.DEBUG, f"no pending invoke: {id} {name}")
 
     def handle_signal(self, name: str, args: list[Any]) -> None:
+        # handle signal message from source
         self.emit_log(LogLevel.DEBUG, f"ClientNode.handle_signal: {name} {args}")
-        sink = self.get_object_sink(name)
+        sink = self.get_sink(name)
         if sink:
             sink.olink_on_signal(name, args)
 
     def handle_error(self, msgType: MsgType, id: int, error: str):
+        # handle error message from source
         self.emit_log(LogLevel.DEBUG, f"ClientNode.handle_error: {msgType} {id} {error}")
 
 

src/olink/mocks/mocksink.py

@@ -9,7 +9,7 @@ class MockSink(IObjectSink):
     properties: dict[str, Any] = {}
     def __init__(self, name: str):
         self.name = name
-        self.node = ClientNode.add_object_sink(self)
+        self.node = ClientNode.register_sink(self)
 
     def invoke(self, name: str, args: list[Any]):
         if self.node:

src/olink/mocks/mocksource.py

@@ -10,15 +10,12 @@ class MockSource(IObjectSource):
 
     def __init__(self, name: str):
         self.name = name
-        RemoteNode.add_object_source(self)
 
     def set_property(self, name: str, value: Any):
-        if self.node:
-            self.node.notify_property_change(name, value)
+        RemoteNode.notify_property_change(name, value)
 
     def notify_signal(self, name: str, args: list[Any]):
-        if self.node:
-            self.node.notify_signal(name, args)
+        RemoteNode.notify_signal(name, args)
 
     def olink_object_name(self) -> str:
         return self.name
@@ -33,14 +30,12 @@ def olink_set_property(self, name: str, value: Any):
         if not path in self.properties:
             # assign new value
             self.properties[path] = value
-            if self.node:
-                self.node.notify_property_change(name, value)
+            RemoteNode.notify_property_change(name, value)
         else:
             # update existing value
             if not self.properties[path] == value:
                 self.properties[path] = value
-                if self.node:
-                    self.node.notify_property_change(name, value)
+                RemoteNode.notify_property_change(name, value)
 
     def olink_linked(self, name: str, node: RemoteNode):
         self.events.append({'type': 'linked', 'name': name})