Aiohttp: जब कनेक्शन अनपेक्षित रूप से बंद हो जाता है, तो वेबसोकेट रीडिंग मैसेज लूप निम्न-स्तरीय CanceledError उठाता है

को निर्मित 6 जुल॰ 2017 · 4टिप्पणियाँ · स्रोत: aio-libs/aiohttp

वास्तविक व्यवहार

संदेश लूप पढ़ना async for msg in ws: निम्न-स्तर concurrent.futures._base.CancelledError उठाता है जब कनेक्शन अप्रत्याशित रूप से बंद हो जाता है।

अपेक्षित व्यवहार

aiohtto.http_websocket.WSMsgType.ERROR प्रकार के साथ संदेश प्राप्त करने की उम्मीद है, या चुपचाप लूप को रोकें, या कम से कम aiohtto.http_websocket.WebSocketError ।

प्रजनन के चरण

निम्नलिखित दो स्क्रिप्ट server.py और client.py चलाएँ, फिर client.py को Ctrl+C रोकें।

सर्वर.py

import logging

from aiohttp import web


logger = logging.getLogger(__name__)


async def index(request):
    ws = web.WebSocketResponse()
    request.app['websockets'].add(ws)

    try:
        await ws.prepare(request)
        logger.debug('Connected')
        async for msg in ws:
            logger.info('Received: %r', msg.data)
    except Exception:
        logger.exception('Error')
    logger.debug('Disconnected')

    request.app['websockets'].discard(ws)
    return ws


async def on_shutdown(app):
    for ws in app['websockets']:
        await ws.close()
    app['websockets'].clear()


def main():
    logging.basicConfig(level=logging.DEBUG)

    app = web.Application()
    app['websockets'] = set()
    app.router.add_get('/', index)
    app.on_shutdown.append(on_shutdown)

    web.run_app(app, host='127.0.0.1', port=9000)


if __name__ == '__main__':
    main()

Client.py

import asyncio

import aiohttp


async def communicate(loop):
    async with aiohttp.ClientSession(loop=loop) as session:
        async with session.ws_connect('http://127.0.0.1:9000') as ws:
            while True:
                await ws.send_str('Hello')
                await asyncio.sleep(1, loop=loop)


def main():
    loop = asyncio.get_event_loop()
    loop.run_until_complete(communicate(loop))


if __name__ == '__main__':
    main()

`server.py` का लॉग आउटपुट

$ python server.py 
DEBUG:asyncio:Using selector: EpollSelector
======== Running on http://127.0.0.1:9000 ========
(Press CTRL+C to quit)
DEBUG:__main__:Connected
INFO:__main__:Received: 'Hello'
INFO:__main__:Received: 'Hello'
INFO:__main__:Received: 'Hello'
INFO:__main__:Received: 'Hello'
INFO:__main__:Received: 'Hello'
INFO:__main__:Received: 'Hello'
INFO:__main__:Received: 'Hello'
INFO:__main__:Received: 'Hello'
INFO:__main__:Received: 'Hello'
ERROR:__main__:Error
Traceback (most recent call last):
  File "server.py", line 16, in index
    async for msg in ws:
  File "/home/vagrant/project/workspace/pyenv_dev/lib64/python3.5/site-packages/aiohttp/web_ws.py", line 343, in __anext__
    msg = yield from self.receive()
  File "/home/vagrant/project/workspace/pyenv_dev/lib64/python3.5/site-packages/aiohttp/web_ws.py", line 273, in receive
    msg = yield from self._reader.read()
  File "/home/vagrant/project/workspace/pyenv_dev/lib64/python3.5/site-packages/aiohttp/streams.py", line 627, in read
    return (yield from super().read())
  File "/home/vagrant/project/workspace/pyenv_dev/lib64/python3.5/site-packages/aiohttp/streams.py", line 509, in read
    yield from self._waiter
  File "/usr/lib64/python3.5/asyncio/futures.py", line 380, in __iter__
    yield self  # This tells Task to wait for completion.
  File "/usr/lib64/python3.5/asyncio/tasks.py", line 304, in _wakeup
    future.result()
  File "/usr/lib64/python3.5/asyncio/futures.py", line 285, in result
    raise CancelledError
concurrent.futures._base.CancelledError
DEBUG:__main__:Disconnected
INFO:aiohttp.access:- - - [06/Jul/2017:11:41:25 +0000] "GET / HTTP/1.1" 101 0 "-" "Python/3.5 aiohttp/2.2.3"

आपका वातावरण

ओएस: सेंटोस लिनक्स 7
लिनक्स कर्नेल: 3.10.0-514.16.1.el7.x86_64
पायथन: 3.5.3
aiohttp: 2.2.3

स्रोत

kr41

👍2

सबसे उपयोगी टिप्पणी

हो सकता है कि एक अलग कनेक्शन बंद अपवाद पेश करना बेहतर हो, वैसे ही जैसे websockets लाइब्रेरी में किया गया था?

s-kostyuk 7 मई 2018

👍2

सभी 4 टिप्पणियाँ

तकनीकी रूप से aiohttp प्रति क्लाइंट अनुरोध पर एक कार्य बनाता है।
क्लाइंट डिस्कनेक्शन पर सिस्टम ASAP कार्य को रोक देता है।
इसे करने का एकमात्र तरीका कार्य रद्द करना है (मान लें कि वेब हैंडलर डीबी या अन्य सेवा से प्रतिक्रिया की प्रतीक्षा कर रहा है, हम इसे वेबसोकेट क्लाइंट से कनेक्शन पर स्पष्ट संचालन की प्रतीक्षा किए बिना भी रद्द करना चाहते हैं)।

Task.cancel() asyncio.CancelledError अपवाद भेजकर किया जाता है, अपवाद वर्ग मानक Exception । यह asyncio व्यवहार है, aiohttp के लिए विशिष्ट कुछ भी नहीं है।

केवल एक चीज जो मैं सुझा सकता था वह है CancelledError को आपके हैंडलर में स्पष्ट रूप से पकड़ना:

try:
    ...
except asyncio.CancelledError:
    pass
except Exception as exc:
    log(exc)

या आप Exception जैसे व्यापक प्रकार को नहीं पकड़ सके।

asvetlov 11 जुल॰ 2017

👍1

मुझे दो विकल्प दिखाई देते हैं:

कुछ भी न बदलें, CancelledError async दुनिया में सामान्य है।
CancelledError और closed संदेश लौटाएं। मुझे लगता है, यह वेबकेट हैंडलर के लिए बेहतर समाधान है।

fafhrd91 17 जुल॰ 2017

s-kostyuk 7 मई 2018

👍2

तकनीकी रूप से aiohttp प्रति क्लाइंट अनुरोध पर एक कार्य बनाता है।
क्लाइंट डिस्कनेक्शन पर सिस्टम ASAP कार्य को रोक देता है।
इसे करने का एकमात्र तरीका कार्य रद्द करना है (मान लें कि वेब हैंडलर डीबी या अन्य सेवा से प्रतिक्रिया की प्रतीक्षा कर रहा है, हम इसे वेबसोकेट क्लाइंट से कनेक्शन पर स्पष्ट संचालन की प्रतीक्षा किए बिना भी रद्द करना चाहते हैं)।

मुझे लगता है कि मुझे अभी इस व्यवहार से काट लिया गया है। मेरे पास कुछ ऐसा कोड था:

async def handler(request):
    ws = web.WebSocketResponse()
    await ws.prepare(request)

    async with contextlib.AsyncExitStack() as stack:
        # acquire_resource_X are async context managers
        await stack.enter_async_context(acquire_resource_1())
        await stack.enter_async_context(acquire_resource_2())
        await stack.enter_async_context(acquire_resource_3())

        async for msg in ws:
            # do stuff

    await ws.close()

    return ws

इसे उत्पादन में लगाने के बाद मैंने पाया कि acquire_resource_3() के बाहर निकलने वाले हिस्से को चुपचाप छोड़ दिया जाएगा। अधिक लॉगिंग से पता चला कि CancelledError अंदर एक acquire_resource_3 उठाया जा रहा था। यहाँ मुझे लगता है कि हुआ:

क्लाइंट वेबसॉकेट बंद कर देता है
async for msg in ws लूप बाहर निकलता है, AsyncExitStack खोलना शुरू होता है, acquire_resource_3 का निकास भाग निष्पादित होना शुरू होता है, एक await हिट करता है
aiohttp हैंडलर कार्य को रद्द करता है
CancelledError वर्तमान await handler पर acquire_resource_3 अंदर है, इसलिए acquire_resource_3 का शेष भाग छोड़ दिया गया है
acquire_resource_2 और acquire_resource_1 का निकास भाग अभी भी सामान्य रूप से निष्पादित होता है, क्योंकि उनके दृष्टिकोण से वे केवल एक अपवाद पर एक async संदर्भ से बाहर निकल रहे हैं

यह वास्तव में एक अजीब समस्या है, खासकर क्योंकि यह इस उम्मीद को कैसे तोड़ता है कि एक संदर्भ प्रबंधक का बाहर निकलने वाला हिस्सा हमेशा चलेगा। मुझे मूल रूप से सभी async संदर्भों को रद्द करने से बचाना था, जैसे:

async def handler(request):
    ws = web.WebSocketResponse()
    await ws.prepare(request)

    await asyncio.shield(asyncio.ensure_future(actually_do_stuff(ws)))

    return ws

async def actually_do_stuff(ws):
    async with contextlib.AsyncExitStack() as stack:
        # acquire_resource_X are async context managers
        await stack.enter_async_context(acquire_resource_1())
        await stack.enter_async_context(acquire_resource_2())
        await stack.enter_async_context(acquire_resource_3())

        async for msg in ws:
            # do stuff

    await ws.close()

क्या ऐसा करने के लिए इससे अच्छा तरीका है?

twisteroidambassador 13 फ़र॰ 2019

क्या यह पृष्ठ उपयोगी था?

0 / 5 - 0 रेटिंग्स