Gracefuly check connection status with server PINGs

pydle/client.py

@@ -32,7 +32,7 @@ class BasicClient:
     Base IRC client class.
     This class on its own is not complete: in order to be able to run properly, _has_message, _parse_message and _create_message have to be overloaded.
     """
-    PING_TIMEOUT = 300
+    READ_TIMEOUT = 300
     RECONNECT_ON_ERROR = True
     RECONNECT_MAX_ATTEMPTS = 3
     RECONNECT_DELAYED = True
@@ -66,7 +66,6 @@ def _reset_attributes(self):
         self._receive_buffer = b''
         self._pending = {}
         self._handler_top_level = False
-        self._ping_checker_handle = None
 
         # Misc.
         self.logger = logging.getLogger(__name__)
@@ -115,10 +114,6 @@ async def connect(self, hostname=None, port=None, reconnect=False, **kwargs):
     async def disconnect(self, expected=True):
         """ Disconnect from server. """
         if self.connected:
-            # Unschedule ping checker.
-            if self._ping_checker_handle:
-                self._ping_checker_handle.cancel()
-
             # Schedule disconnect.
             await self._disconnect(expected)
 
@@ -159,21 +154,6 @@ def _reconnect_delay(self):
         else:
             return 0
 
-    async def _perform_ping_timeout(self, delay: int):
-        """ Handle timeout gracefully.
-
-        Args:
-            delay (int): delay before raising the timeout (in seconds)
-        """
-
-        # pause for delay seconds
-        await sleep(delay)
-        # then continue
-        error = TimeoutError(
-            'Ping timeout: no data received from server in {timeout} seconds.'.format(
-                timeout=self.PING_TIMEOUT))
-        await self.on_data_error(error)
-
     ## Internal database management.
 
     def _create_channel(self, channel):
@@ -365,7 +345,17 @@ async def _send(self, input):
     async def handle_forever(self):
         """ Handle data forever. """
         while self.connected:
-            data = await self.connection.recv()
+            try:
+                data = await self.connection.recv(timeout=self.READ_TIMEOUT)
+            except asyncio.TimeoutError:
+                self.logger.warning('>> Receive timeout reached, sending ping to check connection state...')
+
+                try:
+                    await self.rawmsg("PING", self.server_tag)
+                    data = await self.connection.recv(timeout=self.READ_TIMEOUT)
+                except asyncio.TimeoutError:
+                    data = None
+
             if not data:
                 if self.connected:
                     await self.disconnect(expected=False)
@@ -378,14 +368,6 @@ async def on_data(self, data):
         """ Handle received data. """
         self._receive_buffer += data
 
-        # Schedule new timeout event.
-        if self._ping_checker_handle:
-            self._ping_checker_handle.cancel()
-
-        # create a task for the ping checker
-        self._ping_checker_handle = self.eventloop.create_task(
-            self._perform_ping_timeout(self.PING_TIMEOUT))
-
         while self._has_message():
             message = self._parse_message()
             self.eventloop.create_task(self.on_raw(message))

pydle/connection.py

@@ -127,5 +127,5 @@ async def send(self, data):
         self.writer.write(data)
         await self.writer.drain()
 
-    async def recv(self):
-        return await self.reader.readline()
+    async def recv(self, *, timeout=None):
+        return await asyncio.wait_for(self.reader.readline(), timeout=timeout)

pydle/features/rfc1459/client.py

@@ -541,6 +541,9 @@ async def on_raw_error(self, message):
         error = protocol.ServerError(' '.join(message.params))
         await self.on_data_error(error)
 
+    async def on_raw_pong(self, message):
+        self.logger.debug('>> PONG received')
+
     async def on_raw_invite(self, message):
         """ INVITE command. """
         nick, metadata = self._parse_user(message.source)