From 6d24f0892400e0238ce970d6951f9b3a4c6adca1 Mon Sep 17 00:00:00 2001 From: Joscha Date: Mon, 9 May 2016 21:16:54 +0200 Subject: [PATCH] Make adding callbacks for message replies easier --- yaboli/connection.py | 121 ++++++++++++++++++++++--------------------- 1 file changed, 61 insertions(+), 60 deletions(-) diff --git a/yaboli/connection.py b/yaboli/connection.py index bde33cc..a726e69 100644 --- a/yaboli/connection.py +++ b/yaboli/connection.py @@ -31,14 +31,15 @@ class Connection(): self.room = room - self.stopping = False + self._stopping = False - self.ws = None - self.send_id = 0 - self.callbacks = callbacks.Callbacks() - self.id_callbacks = callbacks.Callbacks() + self._ws = None + self._thread = None + self._send_id = 0 + self._callbacks = callbacks.Callbacks() + self._id_callbacks = callbacks.Callbacks() - def connect(self, tries=-1, delay=10): + def _connect(self, tries=-1, delay=10): """ _connect(tries, delay) -> bool @@ -52,12 +53,12 @@ class Connection(): while tries != 0: try: - self.ws = websocket.create_connection( + self._ws = websocket.create_connection( ROOM_FORMAT.format(self.room), enable_multithread=True ) - self.call_callback("connect") + self._callbacks.call("connect") return True except WSException: @@ -67,19 +68,19 @@ class Connection(): time.sleep(delay) return False - def disconnect(self): + def _disconnect(self): """ - disconnect() -> None + _disconnect() -> None Reconnect to the room. WARNING: To completely disconnect, use stop(). """ - if self.ws: - self.ws.close() - self.ws = None + if self._ws: + self._ws.close() + self._ws = None - self.call_callback("disconnect") + self._callbacks.call("disconnect") def launch(self): """ @@ -88,27 +89,27 @@ class Connection(): Connect to the room and spawn a new thread running run. """ - if self.connect(tries=1): - self.thread = threading.Thread(target=self.run, name=self.room) - self.thread.start() - return self.thread + if self._connect(tries=1): + self._thread = threading.Thread(target=self._run, name=self.room) + self._thread.start() + return self._thread else: self.stop() - def run(self): + def _run(self): """ - run() -> None + _run() -> None Receive messages. """ - while not self.stopping: + while not self._stopping: try: - self.handle_json(self.ws.recv()) + self._handle_json(self._ws.recv()) except (WSException, OSError, ValueError): - if not self.stopping: - self.disconnect() - self.connect() + if not self._stopping: + self._disconnect() + self._connect() def stop(self): """ @@ -117,10 +118,10 @@ class Connection(): Close the connection to the room. """ - self.stopping = True - self.disconnect() + self._stopping = True + self._disconnect() - self.call_callback("stop") + self._callbacks.call("stop") def join(self): """ @@ -129,8 +130,17 @@ class Connection(): Join the thread spawned by launch. """ - if self.thread: - self.thread.join() + if self._thread: + self._thread.join() + + def next_id(self): + """ + next_id() -> id + + Returns the id that will be used for the next package. + """ + + return str(self._send_id) def add_callback(self, ptype, callback, *args, **kwargs): """ @@ -139,7 +149,7 @@ class Connection(): Add a function to be called when a packet of type ptype is received. """ - self.callbacks.add(ptype, callback, *args, **kwargs) + self._callbacks.add(ptype, callback, *args, **kwargs) def add_id_callback(self, pid, callback, *args, **kwargs): """ @@ -148,28 +158,18 @@ class Connection(): Add a function to be called when a packet with id pid is received. """ - self.id_callbacks.add(pid, callback, *args, **kwargs) + self._id_callbacks.add(pid, callback, *args, **kwargs) - def call_callback(self, event, *args): + def add_next_callback(self, callback, *args, **kwargs): """ - call_callback(event) -> None + add_next_callback(callback, *args, **kwargs) -> None - Call all callbacks subscribed to the event with *args. + Add a function to be called when the answer to the next message sent is received. """ - self.callbacks.call(event, *args) + self._id_callbacks.add(self.next_id(), callback, *args, **kwargs) - def call_id_callback(self, pid, *args): - """ - call_callback(pid) -> None - - Call all callbacks subscribed to the pid with *args. - """ - - self.id_callbacks.call(pid, *args) - self.id_callbacks.remove(pid) - - def handle_json(self, data): + def _handle_json(self, data): """ handle_json(data) -> None @@ -177,11 +177,11 @@ class Connection(): """ packet = json.loads(data) - self.handle_packet(packet) + self._handle_packet(packet) - def handle_packet(self, packet): + def _handle_packet(self, packet): """ - handle_packet(ptype, data) -> None + _handle_packet(ptype, data) -> None Handle incoming packets """ @@ -191,23 +191,24 @@ class Connection(): else: data = None - self.call_callback(packet["type"], data) + self._callbacks.call(packet["type"], data) if "id" in packet: - self.call_id_callback(packet["id"], data) + self._id_callbacks.call(packet["id"], data) + self._id_callbacks.remove(packet["id"]) - def send_json(self, data): + def _send_json(self, data): """ - send_json(data) -> None + _send_json(data) -> None Send 'raw' json. """ - if self.ws: + if self._ws: try: - self.ws.send(json.dumps(data)) + self._ws.send(json.dumps(data)) except WSException: - self.disconnect() + self._disconnect() def send_packet(self, ptype, **kwargs): """ @@ -219,7 +220,7 @@ class Connection(): packet = { "type": ptype, "data": kwargs or None, - "id": str(self.send_id) + "id": str(self._send_id) } - self.send_id += 1 - self.send_json(packet) + self._send_id += 1 + self._send_json(packet)