Merge pull request #128 from Shizmob/develop

Release 0.9.3

Author: theunkn0wn1

pydle/__init__.py

@@ -8,8 +8,8 @@
 from asyncio import coroutine, Future
 
 __name__ = 'pydle'
-__version__ = '0.9.2'
-__version_info__ = (0, 9, 2)
+__version__ = '0.9.3'
+__version_info__ = (0, 9, 3)
 __license__ = 'BSD'
 
 

pydle/client.py

@@ -5,6 +5,7 @@
 from asyncio import new_event_loop, gather, get_event_loop, sleep
 
 from . import connection, protocol
+import warnings
 
 __all__ = ['Error', 'AlreadyInChannel', 'NotInChannel', 'BasicClient', 'ClientPool']
 DEFAULT_NICKNAME = '<unregistered>'
@@ -32,12 +33,29 @@ 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
     RECONNECT_DELAYS = [5, 5, 10, 30, 120, 600]
 
+    @property
+    def PING_TIMEOUT(self):
+        warnings.warn(
+            "PING_TIMEOUT has been moved to READ_TIMEOUT and may be removed in a future version. "
+            "Please migrate to READ_TIMEOUT.",
+            DeprecationWarning
+        )
+        return self.READ_TIMEOUT
+
+    @PING_TIMEOUT.setter
+    def PING_TIMEOUT(self, value):
+        warnings.warn(
+            "PING_TIMEOUT has been moved to READ_TIMEOUT and may be removed in a future version",
+            DeprecationWarning
+        )
+        self.READ_TIMEOUT = value
+
     def __init__(self, nickname, fallback_nicknames=[], username=None, realname=None,
                  eventloop=None, **kwargs):
         """ Create a client. """
@@ -66,7 +84,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 +132,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 +172,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 +363,18 @@ 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,19 +387,10 @@ 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))
 
-
     async def on_data_error(self, exception):
         """ Handle error. """
         self.logger.error('Encountered error on socket.',

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)

setup.py

@@ -2,7 +2,7 @@
 
 setup(
     name='pydle',
-    version='0.9.2',
+    version='0.9.3',
     python_requires=">=3.5",
     packages=[
         'pydle',