Updated script that can be controled by Nodejs web app

lib/python3.13/site-packages/socketio/tests/performance_test.py

@@ -0,0 +1,161 @@
+import asyncio
+import logging
+import os
+import random
+import string
+import threading
+import time
+
+from socketio.server import SocketServer
+from socketio.client import SocketClient
+
+
+class PerformanceTest:
+
+    def __init__(self):
+        self.terminate = False
+        self._server = None
+        self._socket_client = None
+        self.received_messages = 0
+        self.sended_messages = 0
+        self.conditions = []
+        self.cps = {"miatel": 7, "comlink": 7, "spacetel": 7}
+        operators = {"miatel": 14, "comlink": 10, "spacetel": 4}
+        self.resources = {}
+        self.call_delays = {}
+        self.last_call_at = {}
+        self.call_locks = {}
+        for key, value in self.cps.items():
+            self.call_delays[key] = 1.0 / float(value)
+            self.last_call_at[key] = time.time()
+            self.call_locks[key] = asyncio.Lock()
+        i = 0
+        k = 0
+        while i < 15:
+            i += 1
+            for operator, cnt in operators.items():
+                j = 0
+                while j < cnt:
+                    j += 1
+                    k += 1
+                    self.resources[k] = {"conditions": [], "is_busy": 0, "cs": threading.Lock(), "operator": operator}
+        self.timings = []
+
+    @asyncio.coroutine
+    def run(self):
+        while not self.terminate:
+            yield from asyncio.sleep(1)
+
+    def create_server(self):
+        loop = asyncio.get_event_loop()
+        path = os.path.dirname(os.path.abspath(__file__))
+        self._server = SocketServer({"test": self.test_server, "test_waiting": self.test_waiting}, path + '/configs/socket_server.ini')
+        loop.run_until_complete(self.run())
+
+    def create_client(self):
+        loop = asyncio.get_event_loop()
+        self._socket_client = SocketClient(["127.0.0.1", "54445"],
+                                           {"test": self.test_client, "action1": self.action1})
+        loop.create_task(self._socket_client.connector())
+        loop.run_until_complete(self.run())
+
+    def take_resource(self):
+        timed_out = False
+        message_showed = False
+        time_out = 300
+        while not timed_out:
+            for resource_id, resource in self.resources.items():
+                resource["cs"].acquire()
+                if not resource["is_busy"]:
+                    resource["is_busy"] = 1
+                    resource["cs"].release()
+                    return resource_id, resource["operator"]
+                resource["cs"].release()
+            if not message_showed:
+                print("all resources as busy, wait")
+                message_showed = True
+            condition = threading.Condition()
+            with condition:
+                self.conditions.append(condition)
+                timed_out = not condition.wait(time_out)
+        raise Exception("failed to take resource")
+
+    def release_resource(self, resource_id):
+        resource = self.resources[resource_id]
+        resource["is_busy"] = 0
+        if len(self.conditions) > 0:
+            condition = self.conditions.pop(0)
+            with condition:
+                condition.notify()
+        resource["conditions"] = []
+
+    def sending_as_client(self, message, count=1, length=16, timeout=0.1, with_wait=False):
+        if self._socket_client is not None:
+            counter = 0
+            while counter < count:
+                counter += 1
+                self.sended_messages += 1
+                if with_wait:
+                    print("start waiting for response")
+                    time1 = time.time()
+                    self._socket_client.append_message({"action": "test_waiting", "test": message, "time": time.time()}, True)
+                    print("waiting response time: %f" % (time.time() - time1))
+                    time.sleep(timeout)
+                else:
+                    resource_id, operator = self.take_resource()
+                    self._socket_client.append_message({"action": "test", "test": message, "time": time.time(),
+                                                        "resource_id": resource_id, "operator": operator})
+                    time.sleep(timeout)
+        else:
+            print("ERROR! no client exists!")
+
+    def server_worker(self, message):
+        repeat_cnt = random.choice([0, 1, 2, 3])
+        i = 0
+        while i < repeat_cnt:
+            i += 1
+            sleep_time = random.choice([1, 2, 0, 1, 1, 4, 1, 3, 2, 5, 10])
+            time.sleep(sleep_time)
+            self._server.broadcast_message({"action": "action1", "test": message["test"]})
+        sleep_time = random.choice([1, 2, 0, 1, 1, 4, 1, 3, 2, 5])
+        time.sleep(sleep_time)
+        self._server.broadcast_message(message)
+
+    @asyncio.coroutine
+    def test_server(self, message):
+        print("receiving time: %f" % (time.time() - message["time"]))
+        self.timings.append(time.time() - message["time"])
+        self.received_messages += 1
+        with (yield from self.call_locks[message["operator"]]):
+            current_delay = time.time() - self.last_call_at[message["operator"]]
+            if current_delay < self.call_delays[message["operator"]]:
+                yield from asyncio.sleep(self.call_delays[message["operator"]] - current_delay)
+            self.last_call_at[message["operator"]] = time.time()
+        worker_thread = threading.Thread(target=self.server_worker,
+                                         args=(message,))
+        worker_thread.daemon = True
+        worker_thread.start()
+
+    @asyncio.coroutine
+    def test_waiting(self, message):
+        print("receive waiting time: %f" % (time.time() - message["time"]))
+        self.timings.append(time.time() - message["time"])
+        self.received_messages += 1
+        time.sleep(5)
+        return {"action": "test_waiting", "response": "success"}
+
+    @asyncio.coroutine
+    def test_client(self, message):
+        self.timings.append(time.time() - message["time"])
+        self.received_messages += 1
+        self.release_resource(message["resource_id"])
+
+    @asyncio.coroutine
+    def action1(self, message):
+        action_tread = threading.Thread(target=self._action_worker)
+        action_tread.daemon = True
+        action_tread.start()
+
+    def _action_worker(self):
+        sleep_time = random.choice([1, 2, 0, 1, 1, 4, 12, 8, 3, 5])
+        time.sleep(sleep_time)