python-engineio 4.10.1__tar.gz → 4.11.0__tar.gz

{python_engineio-4.10.1/src/python_engineio.egg-info → python_engineio-4.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-engineio
-Version: 4.10.1
+Version: 4.11.0
 Summary: Engine.IO server and client for Python
 Author-email: Miguel Grinberg <miguel.grinberg@gmail.com>
 Project-URL: Homepage, https://github.com/miguelgrinberg/python-engineio

{python_engineio-4.10.1 → python_engineio-4.11.0}/docs/client.rst

@@ -52,8 +52,8 @@ functions must be defined using the ``on`` decorator::
         print('I received a message!')
 
     @eio.on('disconnect')
-    def on_disconnect():
-        print('I'm disconnected!')
+    def on_disconnect(reason):
+        print('I'm disconnected! reason:', reason)
 
 For the ``asyncio`` server, event handlers can be regular functions as above,
 or can also be coroutines::
@@ -63,14 +63,25 @@ or can also be coroutines::
         print('I received a message!')
 
 The argument given to the ``on`` decorator is the event name. The events that
-are supported are ``connect``, ``message`` and ``disconnect``. Note that the
-``disconnect`` handler is invoked for application initiated disconnects,
-server initiated disconnects, or accidental disconnects, for example due to
-networking failures.
+are supported are ``connect``, ``message`` and ``disconnect``.
 
 The ``data`` argument passed to the ``'message'`` event handler contains
 application-specific data provided by the server with the event.
 
+The ``disconnect`` handler is invoked for client initiated disconnects, server
+initiated disconnects, or accidental disconnects, for example due to
+networking failures. The argument passed to this handler provides the
+disconnect reason. Example::
+
+    @eio.on('disconnect')
+    def on_disconnect(reason):
+        if reason == eio.reason.CLIENT_DISCONNECT:
+            print('client disconnection')
+        elif reason == eio.reason.SERVER_DISCONNECT:
+            print('the server kicked me out')
+        else:
+            print(f'disconnect reason: {reason}')
+
 Connecting to a Server
 ----------------------
 

{python_engineio-4.10.1 → python_engineio-4.11.0}/docs/conf.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 #
 # Configuration file for the Sphinx documentation builder.
 #

{python_engineio-4.10.1 → python_engineio-4.11.0}/docs/server.rst

@@ -161,8 +161,8 @@ functions must be defined using the ``on`` decorator::
         print('I received a message!')
 
     @eio.on('disconnect')
-    def on_disconnect(sid):
-        print('Client disconnected!')
+    def on_disconnect(sid, reason):
+        print('Client disconnected! reason:', reason)
 
 For the ``asyncio`` server, event handlers can be regular functions as above,
 or can also be coroutines::
@@ -172,10 +172,7 @@ or can also be coroutines::
         print('I received a message!')
 
 The argument given to the ``on`` decorator is the event name. The events that
-are supported are ``connect``, ``message`` and ``disconnect``. Note that the
-``disconnect`` handler is invoked for client initiated disconnects,
-server initiated disconnects, or accidental disconnects, for example due to
-networking failures.
+are supported are ``connect``, ``message`` and ``disconnect``.
 
 The ``sid`` argument passed into all the event handlers is a connection
 identifier for the client. All the events from a client will use the same
@@ -192,6 +189,20 @@ rejected. A rejected connection triggers a response with a 401 status code.
 The ``data`` argument passed to the ``'message'`` event handler contains
 application-specific data provided by the client with the event.
 
+The ``disconnect`` handler is invoked for client initiated disconnects,
+server initiated disconnects, or accidental disconnects, for example due to
+networking failures. The second argument passed to this handler provides the
+disconnect reason. Example::
+
+    @eio.on('disconnect')
+    def on_disconnect(sid, reason):
+        if reason == eio.reason.CLIENT_DISCONNECT:
+            print('the client went away')
+        elif reason == eio.reason.SERVER_DISCONNECT:
+            print('the client was kicked out')
+        else:
+            print(f'disconnect reason: {reason}')
+
 Sending Messages
 ----------------
 

{python_engineio-4.10.1 → python_engineio-4.11.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-engineio"
-version = "4.10.1"
+version = "4.11.0"
 authors = [{name = "Miguel Grinberg", email = "miguel.grinberg@gmail.com"}]
 description = "Engine.IO server and client for Python"
 classifiers = [
@@ -41,3 +41,7 @@ namespaces = false
 [build-system]
 requires = ["setuptools>=61.2"]
 build-backend = "setuptools.build_meta"
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "session"

{python_engineio-4.10.1 → python_engineio-4.11.0}/src/engineio/async_client.py

@@ -37,7 +37,7 @@ def async_signal_handler():
         for task in tasks:
             task.cancel()
         await asyncio.gather(*tasks, return_exceptions=True)
-        asyncio.get_event_loop().stop()
+        asyncio.get_running_loop().stop()
 
     asyncio.ensure_future(_handler())
 
@@ -75,6 +75,9 @@ class AsyncClient(base_client.BaseClient):
     :param websocket_extra_options: Dictionary containing additional keyword
                                     arguments passed to
                                     ``aiohttp.ws_connect()``.
+    :param timestamp_requests: If ``True`` a timestamp is added to the query
+                               string of Socket.IO requests as a cache-busting
+                               measure. Set to ``False`` to disable.
     """
     def is_asyncio_based(self):
         return True
@@ -106,7 +109,7 @@ class AsyncClient(base_client.BaseClient):
         if self.handle_sigint and not async_signal_handler_set and \
                 threading.current_thread() == threading.main_thread():
             try:
-                asyncio.get_event_loop().add_signal_handler(
+                asyncio.get_running_loop().add_signal_handler(
                     signal.SIGINT, async_signal_handler)
             except NotImplementedError:  # pragma: no cover
                 self.logger.warning('Signal handler is unsupported')
@@ -149,7 +152,7 @@ class AsyncClient(base_client.BaseClient):
         """
         await self._send_packet(packet.Packet(packet.MESSAGE, data=data))
 
-    async def disconnect(self, abort=False):
+    async def disconnect(self, abort=False, reason=None):
         """Disconnect from the server.
 
         :param abort: If set to ``True``, do not wait for background tasks
@@ -161,7 +164,9 @@ class AsyncClient(base_client.BaseClient):
             await self._send_packet(packet.Packet(packet.CLOSE))
             await self.queue.put(None)
             self.state = 'disconnecting'
-            await self._trigger_event('disconnect', run_async=False)
+            await self._trigger_event('disconnect',
+                                      reason or self.reason.CLIENT_DISCONNECT,
+                                      run_async=False)
             if self.current_transport == 'websocket':
                 await self.ws.close()
             if not abort:
@@ -409,7 +414,8 @@ class AsyncClient(base_client.BaseClient):
         elif pkt.packet_type == packet.PING:
             await self._send_packet(packet.Packet(packet.PONG, pkt.data))
         elif pkt.packet_type == packet.CLOSE:
-            await self.disconnect(abort=True)
+            await self.disconnect(abort=True,
+                                  reason=self.reason.SERVER_DISCONNECT)
         elif pkt.packet_type == packet.NOOP:
             pass
         else:
@@ -462,7 +468,17 @@ class AsyncClient(base_client.BaseClient):
                     return task
                 else:
                     try:
-                        ret = await self.handlers[event](*args)
+                        try:
+                            ret = await self.handlers[event](*args)
+                        except TypeError:
+                            print(args, len(args))
+                            if event == 'disconnect' and \
+                                    len(args) == 1:  # pragma: no branch
+                                # legacy disconnect events do not have a reason
+                                # argument
+                                return await self.handlers[event]()
+                            else:  # pragma: no cover
+                                raise
                     except asyncio.CancelledError:  # pragma: no cover
                         pass
                     except:
@@ -482,7 +498,17 @@ class AsyncClient(base_client.BaseClient):
                     return task
                 else:
                     try:
-                        ret = self.handlers[event](*args)
+                        try:
+                            ret = self.handlers[event](*args)
+                        except TypeError:
+                            print(args, len(args))
+                            if event == 'disconnect' and \
+                                    len(args) == 1:  # pragma: no branch
+                                # legacy disconnect events do not have a reason
+                                # argument
+                                ret = self.handlers[event]()
+                            else:  # pragma: no cover
+                                raise
                     except:
                         self.logger.exception(event + ' handler error')
                         if event == 'connect':
@@ -524,7 +550,8 @@ class AsyncClient(base_client.BaseClient):
             self.logger.info('Waiting for write loop task to end')
             await self.write_loop_task
         if self.state == 'connected':
-            await self._trigger_event('disconnect', run_async=False)
+            await self._trigger_event(
+                'disconnect', self.reason.TRANSPORT_ERROR, run_async=False)
             try:
                 base_client.connected_clients.remove(self)
             except ValueError:  # pragma: no cover
@@ -578,7 +605,8 @@ class AsyncClient(base_client.BaseClient):
             self.logger.info('Waiting for write loop task to end')
             await self.write_loop_task
         if self.state == 'connected':
-            await self._trigger_event('disconnect', run_async=False)
+            await self._trigger_event(
+                'disconnect', self.reason.TRANSPORT_ERROR, run_async=False)
             try:
                 base_client.connected_clients.remove(self)
             except ValueError:  # pragma: no cover

{python_engineio-4.10.1 → python_engineio-4.11.0}/src/engineio/async_drivers/_websocket_wsgi.py

@@ -25,7 +25,7 @@ class SimpleWebSocketWSGI:  # pragma: no cover
         try:
             return self.ws.send(message)
         except simple_websocket.ConnectionClosed:
-            raise IOError()
+            raise OSError()
 
     def wait(self):
         try:

{python_engineio-4.10.1 → python_engineio-4.11.0}/src/engineio/async_drivers/aiohttp.py

@@ -57,7 +57,7 @@ def translate_request(request):
 
         key = 'HTTP_%s' % hdr_name.replace('-', '_')
         if key in environ:
-            hdr_value = '%s,%s' % (environ[key], hdr_value)
+            hdr_value = f'{environ[key]},{hdr_value}'
 
         environ[key] = hdr_value
 
@@ -79,7 +79,7 @@ def make_response(status, headers, payload, environ):
                     headers=headers)
 
 
-class WebSocket(object):  # pragma: no cover
+class WebSocket:  # pragma: no cover
     """
     This wrapper class provides a aiohttp WebSocket interface that is
     somewhat compatible with eventlet's implementation.
@@ -114,7 +114,7 @@ class WebSocket(object):  # pragma: no cover
         msg = await self._sock.receive()
         if not isinstance(msg.data, bytes) and \
                 not isinstance(msg.data, str):
-            raise IOError()
+            raise OSError()
         return msg.data
 
 

{python_engineio-4.10.1 → python_engineio-4.11.0}/src/engineio/async_drivers/asgi.py

@@ -135,7 +135,7 @@ class ASGIApp:
 
 
 async def translate_request(scope, receive, send):
-    class AwaitablePayload(object):  # pragma: no cover
+    class AwaitablePayload:  # pragma: no cover
         def __init__(self, payload):
             self.payload = payload or b''
 
@@ -161,9 +161,15 @@ async def translate_request(scope, receive, send):
     else:
         return {}
 
-    raw_uri = scope['path'].encode('utf-8')
+    raw_uri = scope['path']
+    query_string = ''
     if 'query_string' in scope and scope['query_string']:
-        raw_uri += b'?' + scope['query_string']
+        try:
+            query_string = scope['query_string'].decode('utf-8')
+        except UnicodeDecodeError:
+            pass
+        else:
+            raw_uri += '?' + query_string
     environ = {
         'wsgi.input': AwaitablePayload(payload),
         'wsgi.errors': sys.stderr,
@@ -175,8 +181,8 @@ async def translate_request(scope, receive, send):
         'SERVER_SOFTWARE': 'asgi',
         'REQUEST_METHOD': scope.get('method', 'GET'),
         'PATH_INFO': scope['path'],
-        'QUERY_STRING': scope.get('query_string', b'').decode('utf-8'),
-        'RAW_URI': raw_uri.decode('utf-8'),
+        'QUERY_STRING': query_string,
+        'RAW_URI': raw_uri,
         'SCRIPT_NAME': '',
         'SERVER_PROTOCOL': 'HTTP/1.1',
         'REMOTE_ADDR': '127.0.0.1',
@@ -189,8 +195,12 @@ async def translate_request(scope, receive, send):
     }
 
     for hdr_name, hdr_value in scope['headers']:
-        hdr_name = hdr_name.upper().decode('utf-8')
-        hdr_value = hdr_value.decode('utf-8')
+        try:
+            hdr_name = hdr_name.upper().decode('utf-8')
+            hdr_value = hdr_value.decode('utf-8')
+        except UnicodeDecodeError:
+            # skip header if it cannot be decoded
+            continue
         if hdr_name == 'CONTENT-TYPE':
             environ['CONTENT_TYPE'] = hdr_value
             continue
@@ -200,7 +210,7 @@ async def translate_request(scope, receive, send):
 
         key = 'HTTP_%s' % hdr_name.replace('-', '_')
         if key in environ:
-            hdr_value = '%s,%s' % (environ[key], hdr_value)
+            hdr_value = f'{environ[key]},{hdr_value}'
 
         environ[key] = hdr_value
 
@@ -231,7 +241,7 @@ async def make_response(status, headers, payload, environ):
                                 'body': payload})
 
 
-class WebSocket(object):  # pragma: no cover
+class WebSocket:  # pragma: no cover
     """
     This wrapper class provides an asgi WebSocket interface that is
     somewhat compatible with eventlet's implementation.
@@ -269,7 +279,7 @@ class WebSocket(object):  # pragma: no cover
     async def wait(self):
         event = await self.asgi_receive()
         if event['type'] != 'websocket.receive':
-            raise IOError()
+            raise OSError()
         return event.get('bytes') or event.get('text')
 
 

{python_engineio-4.10.1 → python_engineio-4.11.0}/src/engineio/async_drivers/eventlet.py

@@ -1,5 +1,3 @@
-from __future__ import absolute_import
-
 from eventlet.green.threading import Event
 from eventlet import queue, sleep, spawn
 from eventlet.websocket import WebSocketWSGI as _WebSocketWSGI

{python_engineio-4.10.1 → python_engineio-4.11.0}/src/engineio/async_drivers/gevent_uwsgi.py

@@ -18,7 +18,7 @@ class Thread(gevent.Greenlet):  # pragma: no cover
         return self.run()
 
 
-class uWSGIWebSocket(object):  # pragma: no cover
+class uWSGIWebSocket:  # pragma: no cover
     """
     This wrapper class provides a uWSGI WebSocket interface that is
     compatible with eventlet's implementation.
@@ -115,7 +115,7 @@ class uWSGIWebSocket(object):  # pragma: no cover
             if self._req_ctx is not None:
                 try:
                     msg = uwsgi.websocket_recv(request_context=self._req_ctx)
-                except IOError:  # connection closed
+                except OSError:  # connection closed
                     self.close()
                     return None
                 return self._decode_received(msg)
@@ -138,7 +138,7 @@ class uWSGIWebSocket(object):  # pragma: no cover
                     for msg in msgs:
                         try:
                             self._send(msg)
-                        except IOError:
+                        except OSError:
                             self.close()
                             return None
                 # maybe there is something to receive, if not, at least
@@ -146,7 +146,7 @@ class uWSGIWebSocket(object):  # pragma: no cover
                 while True:
                     try:
                         msg = uwsgi.websocket_recv_nb()
-                    except IOError:  # connection closed
+                    except OSError:  # connection closed
                         self.close()
                         return None
                     if msg:  # message available

{python_engineio-4.10.1 → python_engineio-4.11.0}/src/engineio/async_drivers/sanic.py

@@ -33,7 +33,7 @@ def translate_request(request):  # pragma: no cover
     """This function takes the arguments passed to the request handler and
     uses them to generate a WSGI compatible environ dictionary.
     """
-    class AwaitablePayload(object):
+    class AwaitablePayload:
         def __init__(self, payload):
             self.payload = payload or b''
 
@@ -78,7 +78,7 @@ def translate_request(request):  # pragma: no cover
 
         key = 'HTTP_%s' % hdr_name.replace('-', '_')
         if key in environ:
-            hdr_value = '%s,%s' % (environ[key], hdr_value)
+            hdr_value = f'{environ[key]},{hdr_value}'
 
         environ[key] = hdr_value
 
@@ -107,7 +107,7 @@ def make_response(status, headers, payload, environ):  # pragma: no cover
                         status=int(status.split()[0]), headers=headers_dict)
 
 
-class WebSocket(object):  # pragma: no cover
+class WebSocket:  # pragma: no cover
     """
     This wrapper class provides a sanic WebSocket interface that is
     somewhat compatible with eventlet's implementation.
@@ -136,7 +136,7 @@ class WebSocket(object):  # pragma: no cover
         data = await self._sock.recv()
         if not isinstance(data, bytes) and \
                 not isinstance(data, str):
-            raise IOError()
+            raise OSError()
         return data
 
 

{python_engineio-4.10.1 → python_engineio-4.11.0}/src/engineio/async_drivers/tornado.py

@@ -64,7 +64,7 @@ def translate_request(handler):
     """This function takes the arguments passed to the request handler and
     uses them to generate a WSGI compatible environ dictionary.
     """
-    class AwaitablePayload(object):
+    class AwaitablePayload:
         def __init__(self, payload):
             self.payload = payload or b''
 
@@ -142,7 +142,7 @@ def make_response(status, headers, payload, environ):
     tornado_handler.finish()
 
 
-class WebSocket(object):  # pragma: no cover
+class WebSocket:  # pragma: no cover
     """
     This wrapper class provides a tornado WebSocket interface that is
     somewhat compatible with eventlet's implementation.
@@ -170,7 +170,7 @@ class WebSocket(object):  # pragma: no cover
         msg = await self.tornado_handler.get_next_message()
         if not isinstance(msg, bytes) and \
                 not isinstance(msg, str):
-            raise IOError()
+            raise OSError()
         return msg
 
 

{python_engineio-4.10.1 → python_engineio-4.11.0}/src/engineio/async_server.py

@@ -89,7 +89,7 @@ class AsyncServer(base_server.BaseServer):
     def attach(self, app, engineio_path='engine.io'):
         """Attach the Engine.IO server to an application."""
         engineio_path = engineio_path.strip('/')
-        self._async['create_route'](app, self, '/{}/'.format(engineio_path))
+        self._async['create_route'](app, self, f'/{engineio_path}/')
 
     async def send(self, sid, data):
         """Send a message to a client.
@@ -162,7 +162,7 @@ class AsyncServer(base_server.BaseServer):
                 async with eio.session(sid) as session:
                     print('received message from ', session['username'])
         """
-        class _session_context_manager(object):
+        class _session_context_manager:
             def __init__(self, server, sid):
                 self.server = server
                 self.sid = sid
@@ -192,12 +192,15 @@ class AsyncServer(base_server.BaseServer):
                 # the socket was already closed or gone
                 pass
             else:
-                await socket.close()
+                await socket.close(reason=self.reason.SERVER_DISCONNECT)
                 if sid in self.sockets:  # pragma: no cover
                     del self.sockets[sid]
         else:
-            await asyncio.wait([asyncio.create_task(client.close())
-                                for client in self.sockets.values()])
+            await asyncio.wait([
+                asyncio.create_task(client.close(
+                    reason=self.reason.SERVER_DISCONNECT))
+                for client in self.sockets.values()
+            ])
             self.sockets = {}
 
     async def handle_request(self, *args, **kwargs):
@@ -284,33 +287,41 @@ class AsyncServer(base_server.BaseServer):
                     r = self._bad_request('Invalid websocket upgrade')
             else:
                 if sid not in self.sockets:
-                    self._log_error_once('Invalid session ' + sid, 'bad-sid')
-                    r = self._bad_request('Invalid session ' + sid)
+                    self._log_error_once(f'Invalid session {sid}', 'bad-sid')
+                    r = self._bad_request(f'Invalid session {sid}')
                 else:
-                    socket = self._get_socket(sid)
-                    if self.transport(sid) != transport and \
-                            transport != upgrade_header:
-                        self._log_error_once(
-                            'Invalid transport for session ' + sid,
-                            'bad-transport')
-                        r = self._bad_request('Invalid transport')
+                    try:
+                        socket = self._get_socket(sid)
+                    except KeyError as e:  # pragma: no cover
+                        self._log_error_once(f'{e} {sid}', 'bad-sid')
+                        r = self._bad_request(f'{e} {sid}')
                     else:
-                        try:
-                            packets = await socket.handle_get_request(environ)
-                            if isinstance(packets, list):
-                                r = self._ok(packets, jsonp_index=jsonp_index)
-                            else:
-                                r = packets
-                        except exceptions.EngineIOError:
-                            if sid in self.sockets:  # pragma: no cover
-                                await self.disconnect(sid)
-                            r = self._bad_request()
-                        if sid in self.sockets and self.sockets[sid].closed:
-                            del self.sockets[sid]
+                        if self.transport(sid) != transport and \
+                                transport != upgrade_header:
+                            self._log_error_once(
+                                f'Invalid transport for session {sid}',
+                                'bad-transport')
+                            r = self._bad_request('Invalid transport')
+                        else:
+                            try:
+                                packets = await socket.handle_get_request(
+                                    environ)
+                                if isinstance(packets, list):
+                                    r = self._ok(packets,
+                                                 jsonp_index=jsonp_index)
+                                else:
+                                    r = packets
+                            except exceptions.EngineIOError:
+                                if sid in self.sockets:  # pragma: no cover
+                                    await self.disconnect(sid)
+                                r = self._bad_request()
+                            if sid in self.sockets and \
+                                    self.sockets[sid].closed:
+                                del self.sockets[sid]
         elif method == 'POST':
             if sid is None or sid not in self.sockets:
-                self._log_error_once('Invalid session ' + sid, 'bad-sid')
-                r = self._bad_request('Invalid session ' + sid)
+                self._log_error_once(f'Invalid session {sid}', 'bad-sid')
+                r = self._bad_request(f'Invalid session {sid}')
             else:
                 socket = self._get_socket(sid)
                 try:
@@ -440,11 +451,14 @@ class AsyncServer(base_server.BaseServer):
         s = async_socket.AsyncSocket(self, sid)
         self.sockets[sid] = s
 
-        pkt = packet.Packet(
-            packet.OPEN, {'sid': sid,
-                          'upgrades': self._upgrades(sid, transport),
-                          'pingTimeout': int(self.ping_timeout * 1000),
-                          'pingInterval': int(self.ping_interval * 1000)})
+        pkt = packet.Packet(packet.OPEN, {
+            'sid': sid,
+            'upgrades': self._upgrades(sid, transport),
+            'pingTimeout': int(self.ping_timeout * 1000),
+            'pingInterval': int(
+                self.ping_interval + self.ping_interval_grace_period) * 1000,
+            'maxPayload': self.max_http_buffer_size,
+        })
         await s.send(pkt)
         s.schedule_ping()
 
@@ -491,7 +505,16 @@ class AsyncServer(base_server.BaseServer):
             if asyncio.iscoroutinefunction(self.handlers[event]):
                 async def run_async_handler():
                     try:
-                        return await self.handlers[event](*args)
+                        try:
+                            return await self.handlers[event](*args)
+                        except TypeError:
+                            if event == 'disconnect' and \
+                                    len(args) == 2:  # pragma: no branch
+                                # legacy disconnect events do not have a reason
+                                # argument
+                                return await self.handlers[event](args[0])
+                            else:  # pragma: no cover
+                                raise
                     except asyncio.CancelledError:  # pragma: no cover
                         pass
                     except:
@@ -510,7 +533,16 @@ class AsyncServer(base_server.BaseServer):
             else:
                 async def run_sync_handler():
                     try:
-                        return self.handlers[event](*args)
+                        try:
+                            return self.handlers[event](*args)
+                        except TypeError:
+                            if event == 'disconnect' and \
+                                    len(args) == 2:  # pragma: no branch
+                                # legacy disconnect events do not have a reason
+                                # argument
+                                return self.handlers[event](args[0])
+                            else:  # pragma: no cover
+                                raise
                     except:
                         self.logger.exception(event + ' handler error')
                         if event == 'connect':
@@ -528,6 +560,7 @@ class AsyncServer(base_server.BaseServer):
 
     async def _service_task(self):  # pragma: no cover
         """Monitor connected clients and clean up those that time out."""
+        loop = asyncio.get_running_loop()
         self.service_task_event = self.create_event()
         while not self.service_task_event.is_set():
             if len(self.sockets) == 0:
@@ -569,7 +602,7 @@ class AsyncServer(base_server.BaseServer):
                 self.logger.info('service task canceled')
                 break
             except:
-                if asyncio.get_event_loop().is_closed():
+                if loop.is_closed():
                     self.logger.info('event loop is closed, exiting service '
                                      'task')
                     break