script/ dnet: add rpc module

script/dnet/rpc.py

@@ -0,0 +1,135 @@
+# This file is part of DarkFi (https://dark.fi)
+#
+# Copyright (C) 2020-2023 Dyne.org foundation
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as
+# published by the Free Software Foundation, either version 3 of the
+# License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+import asyncio, json, random, sys, time
+
+
+class JsonRpc:
+
+    async def start(self, server, port):
+        reader, writer = await asyncio.open_connection(server, port)
+        self.reader = reader
+        self.writer = writer
+
+    async def stop(self):
+        self.writer.close()
+        await self.writer.wait_closed()
+
+    async def _make_request(self, method, params):
+        ident = random.randint(0, 2**16)
+        print(ident)
+        request = {
+            "jsonrpc": "2.0",
+            "method": method,
+            "params": params,
+            "id": ident,
+        }
+
+        message = json.dumps(request) + "\n"
+        self.writer.write(message.encode())
+        await self.writer.drain()
+
+        data = await self.reader.readline()
+        message = data.decode().strip()
+        response = json.loads(message)
+        print(response)
+        return response
+
+    async def _subscribe(self, method, params):
+        ident = random.randint(0, 2**16)
+        request = {
+            "jsonrpc": "2.0",
+            "method": method,
+            "params": params,
+            "id": ident,
+        }
+
+        message = json.dumps(request) + "\n"
+        self.writer.write(message.encode())
+        await self.writer.drain()
+        print("Subscribed")
+
+    async def ping(self):
+        return await self._make_request("ping", [])
+
+    async def dnet_switch(self, state):
+        return await self._make_request("dnet.switch", [state])
+
+    async def dnet_subscribe_events(self):
+        return await self._subscribe("dnet.subscribe_events", [])
+
+
+#async def main(argv):
+#    rpc = JsonRpc()
+#    while True:
+#        try:
+#            await rpc.start("localhost", 26660)
+#            break
+#        except OSError:
+#            pass
+#    await rpc.dnet_switch(True)
+#    await rpc.dnet_subscribe_events()
+#
+#    while True:
+#        data = await rpc.reader.readline()
+#        #with open("rpclog", "a") as f:
+#        #    f.write(data.decode())
+#        data = json.loads(data)
+#
+#        params = data["params"][0]
+#        ev = params["event"]
+#        if ev in ["send", "recv"]:
+#            continue
+#        info = params["info"]
+#
+#        t = time.localtime()
+#        current_time = time.strftime("%H:%M:%S", t)
+#
+#        match ev:
+#            case "inbound_connected":
+#                addr = info["addr"]
+#                print(f"{current_time}  inbound (connect):    {addr}")
+#            case "inbound_disconnected":
+#                addr = info["addr"]
+#                print(f"{current_time}  inbound (disconnect): {addr}")
+#            case "outbound_slot_sleeping":
+#                slot = info["slot"]
+#                print(f"{current_time}  slot {slot}: sleeping")
+#            case "outbound_slot_connecting":
+#                slot = info["slot"]
+#                addr = info["addr"]
+#                print(f"{current_time}  slot {slot}: connecting   addr={addr}")
+#            case "outbound_slot_connected":
+#                slot = info["slot"]
+#                addr = info["addr"]
+#                channel_id = info["channel_id"]
+#                print(f"{current_time}  slot {slot}: connected    addr={addr}")
+#            case "outbound_slot_disconnected":
+#                slot = info["slot"]
+#                err = info["err"]
+#                print(f"{current_time}  slot {slot}: disconnected err='{err}'")
+#            case "outbound_peer_discovery":
+#                attempt = info["attempt"]
+#                state = info["state"]
+#                print(f"{current_time}  peer_discovery: {state} (attempt {attempt})")
+#        #print(data)
+#
+#    await rpc.dnet_switch(False)
+#    await rpc.stop()
+#
+#
+#asyncio.run(main(sys.argv))
+