add working example for app, server

Author: jryannel

examples/app.py

@@ -0,0 +1,96 @@
+from asyncio.queues import Queue
+from typing import Any
+from olink.core.types import Name
+from olink.clientnode import IObjectSink, ClientNode
+import asyncio
+import websockets
+
+class Counter(IObjectSink):
+    count = 0
+    client = None
+    def __init__(self):
+        self.client = ClientNode.add_object_sink(self)
+        print('client', self.client)
+
+    def increment(self):
+        if self.client:
+            self.client.invoke_remote('demo.Counter/increment', [], None)
+
+    def olink_object_name(self):
+        return 'demo.Counter'
+
+    def olink_on_signal(self, name: str, args: list[Any]):
+        path = Name.path_from_name(name)
+        print('on signal: %s: %s' % (path, args))
+
+    def olink_on_property_changed(self, name: str, value: Any) -> None:
+        path = Name.path_from_name(name)
+        print('on property changed: %s: %s' % (path, value))
+
+    def olink_on_init(self, name: str, props: object, node: ClientNode):
+        print('on init: %s: %s' % (name, props))
+        self.client = node
+        
+    def olink_on_release(self):
+        print('on release')
+    
+
+async def sender(ws, q):
+    while True:
+        data = await q.get()
+        await ws.send_text(data)
+        q.task_done()
+
+
+async def connect(address: str):
+    node = ClientNode()
+    queue = Queue()
+    async with websockets.connect(address) as ws:
+        def writer(msg: str):
+            queue.put_nowait(msg)
+        node.on_write(writer)
+        while True:
+            data = await ws.recv()
+            node.handle_message(data)
+
+class Client:
+    queue = Queue()
+    node = None
+    def __init__(self, node):
+        self.node = node
+        self.node.on_write(self.writer)
+
+    def writer(self, data):
+        print('writer, data')
+        self.queue.put_nowait(data)
+
+    async def _reader(self, ws):
+        while True:
+            data = await ws.recv()
+            self.node.handle_message(data)
+    
+    async def _sender(self, ws):
+        while True:
+            data = await self.queue.get()
+            await ws.send(data)
+            self.queue.task_done()
+
+    async def connect(self, address: str):
+        async with websockets.connect(address) as ws:
+            print('connected')
+            sender_task = asyncio.create_task(self._sender(ws))
+            reader_task = asyncio.create_task(self._reader(ws))
+            await asyncio.gather(sender_task, reader_task)
+            await self.queue.join()
+
+
+
+address = 'ws://localhost:8282/ws'
+node = ClientNode()
+node.link_node('demo.Counter')
+client = Client(node)
+
+counter = Counter()
+node.link_remote('demo.Counter')
+counter.increment()
+asyncio.get_event_loop().run_until_complete(client.connect(address))

examples/server.py

@@ -0,0 +1,91 @@
+import asyncio
+from typing import Any
+from asyncio.queues import Queue
+from starlette.applications import Starlette
+from starlette.endpoints import WebSocketEndpoint
+from starlette.routing import WebSocketRoute
+from starlette.websockets import WebSocket
+
+from olink.core.types import Name
+from olink.net.server import RemoteEndpoint
+from olink.remotenode import IObjectSource, RemoteNode
+
+
+class Counter:
+    count = 0
+    _node: RemoteNode
+    def increment(self):
+        self.count += 1
+        self._node.notify_property_change('demo.Counter/count', self.count)
+
+class CounterAdapter(IObjectSource):
+    node: RemoteNode = None
+    def __init__(self, impl):
+        self.impl = impl
+        RemoteNode.add_object_source(self)
+
+    def olink_object_name(self):
+        return 'demo.Counter'
+
+    def olink_invoke(self, name: str, args: list[Any]) -> Any:
+        path = Name.path_from_name(name)
+        func = getattr(self.impl, path)
+        func()
+
+    def olink_set_property(self, name: str, value: Any):
+        path = Name.path_from_name(name)
+        setattr(self, self.impl, value)
+
+    def olink_linked(self, name: str, node: "RemoteNode"):
+        self.impl._node = node
+
+    def olink_collect_properties(self) -> object:
+        return {k: getattr(self.impl, k) for k in ['count']}
+
+counter = Counter()
+adapter = CounterAdapter(counter)
+
+
+
+
+class RemoteEndpoint(WebSocketEndpoint):
+    encoding = "text"
+    node = RemoteNode()
+    queue = Queue()
+
+    async def sender(self, ws):
+        print('start sender')
+        while True:
+            print('001')
+            msg = await self.queue.get()
+            print('send', msg)
+            await ws.send_text(msg)
+            self.queue.task_done()        
+
+    async def on_connect(self, ws: WebSocket):
+        print('on_connect')
+        asyncio.create_task(self.sender(ws))
+
+        def writer(msg: str):
+            print('writer', msg)
+            self.queue.put_nowait(msg)
+        self.node.on_write(writer)
+        await super().on_connect(ws)
+
+
+    async def on_receive(self, ws: WebSocket, data: Any) -> None:
+        print('on_receive', data)
+        self.node.handle_message(data)
+
+    async def on_disconnect(self, websocket: WebSocket, close_code: int) -> None:
+        await super().on_disconnect(websocket, close_code)
+        self.node.on_write(None)
+        await self.queue.join()
+
+
+
+routes = [
+    WebSocketRoute("/ws", RemoteEndpoint)
+]
+
+app = Starlette(routes=routes)

olink/clientnode.py

@@ -48,7 +48,7 @@ def detach_client_node(self, node: "ClientNode"):
             if entry.node is node:
                 entry.node = None
 
-    def link_client_node(self, name: str, node: "ClientNode"):
+    def link_client_node(self, name: str, node: "ClientNode"):        
         self.entry(name).node = node
 
     def unlink_client_node(self, name: str, node: "ClientNode"):
@@ -61,7 +61,9 @@ def unlink_client_node(self, name: str, node: "ClientNode"):
 
     def add_object_sink(self, sink: IObjectSink) -> "ClientNode":
         name = sink.olink_object_name()
-        self.entry(name).sink = sink
+        entry = self.entry(name)
+        entry.sink = sink
+        return entry.node
 
     def remove_object_sink(self, sink: IObjectSink):
         name = sink.olink_object_name()

olink/core/node.py

@@ -21,6 +21,7 @@ def emit_write(self, msg: list[Any]) -> None:
             self.write_func(data)
         else:
             self.emit_log(LogLevel.DEBUG, f"write not set on protocol: {msg}")
+
     def handle_message(self, data: str) -> None:
         msg = self.converter.from_string(data)
         self.protocol.handle_message(msg)