././@PaxHeader0000000000000000000000000000003200000000000010210 xustar0026 mtime=1665997940.27312 python-socketio-5.7.2/0000755000076600000240000000000014323216164014566 5ustar00mgrinbergstaff././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1574018283.0 python-socketio-5.7.2/LICENSE0000644000076600000240000000207213564316353015603 0ustar00mgrinbergstaffThe MIT License (MIT) Copyright (c) 2015 Miguel Grinberg Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1574018283.0 python-socketio-5.7.2/MANIFEST.in0000644000076600000240000000003213564316353016326 0ustar00mgrinbergstaffinclude README.md LICENSE ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1665997940.2733362 python-socketio-5.7.2/PKG-INFO0000644000076600000240000000554314323216164015672 0ustar00mgrinbergstaffMetadata-Version: 2.1 Name: python-socketio Version: 5.7.2 Summary: Socket.IO server and client for Python Home-page: https://github.com/miguelgrinberg/python-socketio Author: Miguel Grinberg Author-email: miguel.grinberg@gmail.com Project-URL: Bug Tracker, https://github.com/miguelgrinberg/python-socketio/issues Classifier: Environment :: Web Environment Classifier: Intended Audience :: Developers Classifier: Programming Language :: Python :: 3 Classifier: License :: OSI Approved :: MIT License Classifier: Operating System :: OS Independent Requires-Python: >=3.6 Description-Content-Type: text/markdown Provides-Extra: client Provides-Extra: asyncio_client License-File: LICENSE python-socketio =============== [![Build status](https://github.com/miguelgrinberg/python-socketio/workflows/build/badge.svg)](https://github.com/miguelgrinberg/python-socketio/actions) [![codecov](https://codecov.io/gh/miguelgrinberg/python-socketio/branch/main/graph/badge.svg)](https://codecov.io/gh/miguelgrinberg/python-socketio) Python implementation of the `Socket.IO`_ realtime client and server. Sponsors -------- The following organizations are funding this project: ![Socket.IO](https://images.opencollective.com/socketio/050e5eb/logo/64.png)
[Socket.IO](https://socket.io) | [Add your company here!](https://github.com/sponsors/miguelgrinberg)| -|- Many individual sponsors also support this project through small ongoing contributions. Why not [join them](https://github.com/sponsors/miguelgrinberg)? Version compatibility --------------------- The Socket.IO protocol has been through a number of revisions, and some of these introduced backward incompatible changes, which means that the client and the server must use compatible versions for everything to work. If you are using the Python client and server, the easiest way to ensure compatibility is to use the same version of this package for the client and the server. If you are using this package with a different client or server, then you must ensure the versions are compatible. The version compatibility chart below maps versions of this package to versions of the JavaScript reference implementation and the versions of the Socket.IO and Engine.IO protocols. JavaScript Socket.IO version | Socket.IO protocol revision | Engine.IO protocol revision | python-socketio version -|-|-|- 0.9.x | 1, 2 | 1, 2 | Not supported 1.x and 2.x | 3, 4 | 3 | 4.x 3.x and 4.x | 5 | 4 | 5.x Resources --------- - [Documentation](http://python-socketio.readthedocs.io/en/latest/) - [PyPI](https://pypi.python.org/pypi/python-socketio) - [Change Log](https://github.com/miguelgrinberg/python-socketio/blob/main/CHANGES.md) - Questions? See the [questions](https://stackoverflow.com/questions/tagged/python-socketio) others have asked on Stack Overflow, or [ask](https://stackoverflow.com/questions/ask?tags=python+python-socketio) your own question. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1622746889.0 python-socketio-5.7.2/README.md0000644000076600000240000000426314056223411016046 0ustar00mgrinbergstaffpython-socketio =============== [![Build status](https://github.com/miguelgrinberg/python-socketio/workflows/build/badge.svg)](https://github.com/miguelgrinberg/python-socketio/actions) [![codecov](https://codecov.io/gh/miguelgrinberg/python-socketio/branch/main/graph/badge.svg)](https://codecov.io/gh/miguelgrinberg/python-socketio) Python implementation of the `Socket.IO`_ realtime client and server. Sponsors -------- The following organizations are funding this project: ![Socket.IO](https://images.opencollective.com/socketio/050e5eb/logo/64.png)
[Socket.IO](https://socket.io) | [Add your company here!](https://github.com/sponsors/miguelgrinberg)| -|- Many individual sponsors also support this project through small ongoing contributions. Why not [join them](https://github.com/sponsors/miguelgrinberg)? Version compatibility --------------------- The Socket.IO protocol has been through a number of revisions, and some of these introduced backward incompatible changes, which means that the client and the server must use compatible versions for everything to work. If you are using the Python client and server, the easiest way to ensure compatibility is to use the same version of this package for the client and the server. If you are using this package with a different client or server, then you must ensure the versions are compatible. The version compatibility chart below maps versions of this package to versions of the JavaScript reference implementation and the versions of the Socket.IO and Engine.IO protocols. JavaScript Socket.IO version | Socket.IO protocol revision | Engine.IO protocol revision | python-socketio version -|-|-|- 0.9.x | 1, 2 | 1, 2 | Not supported 1.x and 2.x | 3, 4 | 3 | 4.x 3.x and 4.x | 5 | 4 | 5.x Resources --------- - [Documentation](http://python-socketio.readthedocs.io/en/latest/) - [PyPI](https://pypi.python.org/pypi/python-socketio) - [Change Log](https://github.com/miguelgrinberg/python-socketio/blob/main/CHANGES.md) - Questions? See the [questions](https://stackoverflow.com/questions/tagged/python-socketio) others have asked on Stack Overflow, or [ask](https://stackoverflow.com/questions/ask?tags=python+python-socketio) your own question. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1623094287.0 python-socketio-5.7.2/pyproject.toml0000644000076600000240000000015014057472017017503 0ustar00mgrinbergstaff[build-system] requires = [ "setuptools>=42", "wheel" ] build-backend = "setuptools.build_meta" ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1665997940.2740817 python-socketio-5.7.2/setup.cfg0000644000076600000240000000170414323216164016411 0ustar00mgrinbergstaff[metadata] name = python-socketio version = 5.7.2 author = Miguel Grinberg author_email = miguel.grinberg@gmail.com description = Socket.IO server and client for Python long_description = file: README.md long_description_content_type = text/markdown url = https://github.com/miguelgrinberg/python-socketio project_urls = Bug Tracker = https://github.com/miguelgrinberg/python-socketio/issues classifiers = Environment :: Web Environment Intended Audience :: Developers Programming Language :: Python :: 3 License :: OSI Approved :: MIT License Operating System :: OS Independent [options] zip_safe = False include_package_data = True package_dir = = src packages = find: python_requires = >=3.6 install_requires = bidict >= 0.21.0 python-engineio >= 4.3.0 [options.packages.find] where = src [options.extras_require] client = requests >= 2.21.0 websocket-client >= 0.54.0 asyncio_client = aiohttp >= 3.4 [egg_info] tag_build = tag_date = 0 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1626168293.0 python-socketio-5.7.2/setup.py0000644000076600000240000000004614073255745016312 0ustar00mgrinbergstaffimport setuptools setuptools.setup() ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1665997940.2473385 python-socketio-5.7.2/src/0000755000076600000240000000000014323216164015355 5ustar00mgrinbergstaff././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1665997940.2529843 python-socketio-5.7.2/src/python_socketio.egg-info/0000755000076600000240000000000014323216164022270 5ustar00mgrinbergstaff././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1665997940.0 python-socketio-5.7.2/src/python_socketio.egg-info/PKG-INFO0000644000076600000240000000554314323216164023374 0ustar00mgrinbergstaffMetadata-Version: 2.1 Name: python-socketio Version: 5.7.2 Summary: Socket.IO server and client for Python Home-page: https://github.com/miguelgrinberg/python-socketio Author: Miguel Grinberg Author-email: miguel.grinberg@gmail.com Project-URL: Bug Tracker, https://github.com/miguelgrinberg/python-socketio/issues Classifier: Environment :: Web Environment Classifier: Intended Audience :: Developers Classifier: Programming Language :: Python :: 3 Classifier: License :: OSI Approved :: MIT License Classifier: Operating System :: OS Independent Requires-Python: >=3.6 Description-Content-Type: text/markdown Provides-Extra: client Provides-Extra: asyncio_client License-File: LICENSE python-socketio =============== [![Build status](https://github.com/miguelgrinberg/python-socketio/workflows/build/badge.svg)](https://github.com/miguelgrinberg/python-socketio/actions) [![codecov](https://codecov.io/gh/miguelgrinberg/python-socketio/branch/main/graph/badge.svg)](https://codecov.io/gh/miguelgrinberg/python-socketio) Python implementation of the `Socket.IO`_ realtime client and server. Sponsors -------- The following organizations are funding this project: ![Socket.IO](https://images.opencollective.com/socketio/050e5eb/logo/64.png)
[Socket.IO](https://socket.io) | [Add your company here!](https://github.com/sponsors/miguelgrinberg)| -|- Many individual sponsors also support this project through small ongoing contributions. Why not [join them](https://github.com/sponsors/miguelgrinberg)? Version compatibility --------------------- The Socket.IO protocol has been through a number of revisions, and some of these introduced backward incompatible changes, which means that the client and the server must use compatible versions for everything to work. If you are using the Python client and server, the easiest way to ensure compatibility is to use the same version of this package for the client and the server. If you are using this package with a different client or server, then you must ensure the versions are compatible. The version compatibility chart below maps versions of this package to versions of the JavaScript reference implementation and the versions of the Socket.IO and Engine.IO protocols. JavaScript Socket.IO version | Socket.IO protocol revision | Engine.IO protocol revision | python-socketio version -|-|-|- 0.9.x | 1, 2 | 1, 2 | Not supported 1.x and 2.x | 3, 4 | 3 | 4.x 3.x and 4.x | 5 | 4 | 5.x Resources --------- - [Documentation](http://python-socketio.readthedocs.io/en/latest/) - [PyPI](https://pypi.python.org/pypi/python-socketio) - [Change Log](https://github.com/miguelgrinberg/python-socketio/blob/main/CHANGES.md) - Questions? See the [questions](https://stackoverflow.com/questions/tagged/python-socketio) others have asked on Stack Overflow, or [ask](https://stackoverflow.com/questions/ask?tags=python+python-socketio) your own question. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1665997940.0 python-socketio-5.7.2/src/python_socketio.egg-info/SOURCES.txt0000644000076600000240000000174014323216164024156 0ustar00mgrinbergstaffLICENSE MANIFEST.in README.md pyproject.toml setup.cfg setup.py src/python_socketio.egg-info/PKG-INFO src/python_socketio.egg-info/SOURCES.txt src/python_socketio.egg-info/dependency_links.txt src/python_socketio.egg-info/not-zip-safe src/python_socketio.egg-info/requires.txt src/python_socketio.egg-info/top_level.txt src/socketio/__init__.py src/socketio/asgi.py src/socketio/asyncio_aiopika_manager.py src/socketio/asyncio_client.py src/socketio/asyncio_manager.py src/socketio/asyncio_namespace.py src/socketio/asyncio_pubsub_manager.py src/socketio/asyncio_redis_manager.py src/socketio/asyncio_server.py src/socketio/base_manager.py src/socketio/client.py src/socketio/exceptions.py src/socketio/kafka_manager.py src/socketio/kombu_manager.py src/socketio/middleware.py src/socketio/msgpack_packet.py src/socketio/namespace.py src/socketio/packet.py src/socketio/pubsub_manager.py src/socketio/redis_manager.py src/socketio/server.py src/socketio/tornado.py src/socketio/zmq_manager.py././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1665997940.0 python-socketio-5.7.2/src/python_socketio.egg-info/dependency_links.txt0000644000076600000240000000000114323216164026336 0ustar00mgrinbergstaff ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1623094576.0 python-socketio-5.7.2/src/python_socketio.egg-info/not-zip-safe0000644000076600000240000000000114057472460024525 0ustar00mgrinbergstaff ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1665997940.0 python-socketio-5.7.2/src/python_socketio.egg-info/requires.txt0000644000076600000240000000017114323216164024667 0ustar00mgrinbergstaffbidict>=0.21.0 python-engineio>=4.3.0 [asyncio_client] aiohttp>=3.4 [client] requests>=2.21.0 websocket-client>=0.54.0 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1665997940.0 python-socketio-5.7.2/src/python_socketio.egg-info/top_level.txt0000644000076600000240000000001114323216164025012 0ustar00mgrinbergstaffsocketio ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1665997940.2725046 python-socketio-5.7.2/src/socketio/0000755000076600000240000000000014323216164017175 5ustar00mgrinbergstaff././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1623094506.0 python-socketio-5.7.2/src/socketio/__init__.py0000644000076600000240000000272314057472352021321 0ustar00mgrinbergstaffimport sys from .client import Client from .base_manager import BaseManager from .pubsub_manager import PubSubManager from .kombu_manager import KombuManager from .redis_manager import RedisManager from .kafka_manager import KafkaManager from .zmq_manager import ZmqManager from .server import Server from .namespace import Namespace, ClientNamespace from .middleware import WSGIApp, Middleware from .tornado import get_tornado_handler if sys.version_info >= (3, 5): # pragma: no cover from .asyncio_client import AsyncClient from .asyncio_server import AsyncServer from .asyncio_manager import AsyncManager from .asyncio_namespace import AsyncNamespace, AsyncClientNamespace from .asyncio_redis_manager import AsyncRedisManager from .asyncio_aiopika_manager import AsyncAioPikaManager from .asgi import ASGIApp else: # pragma: no cover AsyncClient = None AsyncServer = None AsyncManager = None AsyncNamespace = None AsyncRedisManager = None AsyncAioPikaManager = None __all__ = ['Client', 'Server', 'BaseManager', 'PubSubManager', 'KombuManager', 'RedisManager', 'ZmqManager', 'KafkaManager', 'Namespace', 'ClientNamespace', 'WSGIApp', 'Middleware'] if AsyncServer is not None: # pragma: no cover __all__ += ['AsyncClient', 'AsyncServer', 'AsyncNamespace', 'AsyncClientNamespace', 'AsyncManager', 'AsyncRedisManager', 'ASGIApp', 'get_tornado_handler', 'AsyncAioPikaManager'] ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1588720246.0 python-socketio-5.7.2/src/socketio/asgi.py0000644000076600000240000000341713654371166020511 0ustar00mgrinbergstaffimport engineio class ASGIApp(engineio.ASGIApp): # pragma: no cover """ASGI application middleware for Socket.IO. This middleware dispatches traffic to an Socket.IO application. It can also serve a list of static files to the client, or forward unrelated HTTP traffic to another ASGI application. :param socketio_server: The Socket.IO server. Must be an instance of the ``socketio.AsyncServer`` class. :param static_files: A dictionary with static file mapping rules. See the documentation for details on this argument. :param other_asgi_app: A separate ASGI app that receives all other traffic. :param socketio_path: The endpoint where the Socket.IO application should be installed. The default value is appropriate for most cases. :param on_startup: function to be called on application startup; can be coroutine :param on_shutdown: function to be called on application shutdown; can be coroutine Example usage:: import socketio import uvicorn sio = socketio.AsyncServer() app = engineio.ASGIApp(sio, static_files={ '/': 'index.html', '/static': './public', }) uvicorn.run(app, host='127.0.0.1', port=5000) """ def __init__(self, socketio_server, other_asgi_app=None, static_files=None, socketio_path='socket.io', on_startup=None, on_shutdown=None): super().__init__(socketio_server, other_asgi_app, static_files=static_files, engineio_path=socketio_path, on_startup=on_startup, on_shutdown=on_shutdown) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1650727708.0 python-socketio-5.7.2/src/socketio/asyncio_aiopika_manager.py0000644000076600000240000001022014231015434024371 0ustar00mgrinbergstaffimport asyncio import pickle from socketio.asyncio_pubsub_manager import AsyncPubSubManager try: import aio_pika except ImportError: aio_pika = None class AsyncAioPikaManager(AsyncPubSubManager): # pragma: no cover """Client manager that uses aio_pika for inter-process messaging under asyncio. This class implements a client manager backend for event sharing across multiple processes, using RabbitMQ To use a aio_pika backend, initialize the :class:`Server` instance as follows:: url = 'amqp://user:password@hostname:port//' server = socketio.Server(client_manager=socketio.AsyncAioPikaManager( url)) :param url: The connection URL for the backend messaging queue. Example connection URLs are ``'amqp://guest:guest@localhost:5672//'`` for RabbitMQ. :param channel: The channel name on which the server sends and receives notifications. Must be the same in all the servers. With this manager, the channel name is the exchange name in rabbitmq :param write_only: If set to ``True``, only initialize to emit events. The default of ``False`` initializes the class for emitting and receiving. """ name = 'asyncaiopika' def __init__(self, url='amqp://guest:guest@localhost:5672//', channel='socketio', write_only=False, logger=None): if aio_pika is None: raise RuntimeError('aio_pika package is not installed ' '(Run "pip install aio_pika" in your ' 'virtualenv).') self.url = url self.listener_connection = None self.listener_channel = None self.listener_queue = None super().__init__(channel=channel, write_only=write_only, logger=logger) async def _connection(self): return await aio_pika.connect_robust(self.url) async def _channel(self, connection): return await connection.channel() async def _exchange(self, channel): return await channel.declare_exchange(self.channel, aio_pika.ExchangeType.FANOUT) async def _queue(self, channel, exchange): queue = await channel.declare_queue(durable=False, arguments={'x-expires': 300000}) await queue.bind(exchange) return queue async def _publish(self, data): connection = await self._connection() channel = await self._channel(connection) exchange = await self._exchange(channel) await exchange.publish( aio_pika.Message(body=pickle.dumps(data), delivery_mode=aio_pika.DeliveryMode.PERSISTENT), routing_key='*' ) async def _listen(self): retry_sleep = 1 while True: try: if self.listener_connection is None: self.listener_connection = await self._connection() self.listener_channel = await self._channel( self.listener_connection ) await self.listener_channel.set_qos(prefetch_count=1) exchange = await self._exchange(self.listener_channel) self.listener_queue = await self._queue( self.listener_channel, exchange ) retry_sleep = 1 async with self.listener_queue.iterator() as queue_iter: async for message in queue_iter: async with message.process(): yield pickle.loads(message.body) except Exception: self._get_logger().error('Cannot receive from rabbitmq... ' 'retrying in ' '{} secs'.format(retry_sleep)) self.listener_connection = None await asyncio.sleep(retry_sleep) retry_sleep *= 2 if retry_sleep > 60: retry_sleep = 60 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1656157883.0 python-socketio-5.7.2/src/socketio/asyncio_client.py0000644000076600000240000006121014255573273022565 0ustar00mgrinbergstaffimport asyncio import logging import random import engineio from . import client from . import exceptions from . import packet default_logger = logging.getLogger('socketio.client') class AsyncClient(client.Client): """A Socket.IO client for asyncio. This class implements a fully compliant Socket.IO web client with support for websocket and long-polling transports. :param reconnection: ``True`` if the client should automatically attempt to reconnect to the server after an interruption, or ``False`` to not reconnect. The default is ``True``. :param reconnection_attempts: How many reconnection attempts to issue before giving up, or 0 for infinite attempts. The default is 0. :param reconnection_delay: How long to wait in seconds before the first reconnection attempt. Each successive attempt doubles this delay. :param reconnection_delay_max: The maximum delay between reconnection attempts. :param randomization_factor: Randomization amount for each delay between reconnection attempts. The default is 0.5, which means that each delay is randomly adjusted by +/- 50%. :param logger: To enable logging set to ``True`` or pass a logger object to use. To disable logging set to ``False``. The default is ``False``. Note that fatal errors are logged even when ``logger`` is ``False``. :param json: An alternative json module to use for encoding and decoding packets. Custom json modules must have ``dumps`` and ``loads`` functions that are compatible with the standard library versions. :param handle_sigint: Set to ``True`` to automatically handle disconnection when the process is interrupted, or to ``False`` to leave interrupt handling to the calling application. Interrupt handling can only be enabled when the client instance is created in the main thread. The Engine.IO configuration supports the following settings: :param request_timeout: A timeout in seconds for requests. The default is 5 seconds. :param http_session: an initialized ``aiohttp.ClientSession`` object to be used when sending requests to the server. Use it if you need to add special client options such as proxy servers, SSL certificates, etc. :param ssl_verify: ``True`` to verify SSL certificates, or ``False`` to skip SSL certificate verification, allowing connections to servers with self signed certificates. The default is ``True``. :param engineio_logger: To enable Engine.IO logging set to ``True`` or pass a logger object to use. To disable logging set to ``False``. The default is ``False``. Note that fatal errors are logged even when ``engineio_logger`` is ``False``. """ def is_asyncio_based(self): return True async def connect(self, url, headers={}, auth=None, transports=None, namespaces=None, socketio_path='socket.io', wait=True, wait_timeout=1): """Connect to a Socket.IO server. :param url: The URL of the Socket.IO server. It can include custom query string parameters if required by the server. If a function is provided, the client will invoke it to obtain the URL each time a connection or reconnection is attempted. :param headers: A dictionary with custom headers to send with the connection request. If a function is provided, the client will invoke it to obtain the headers dictionary each time a connection or reconnection is attempted. :param auth: Authentication data passed to the server with the connection request, normally a dictionary with one or more string key/value pairs. If a function is provided, the client will invoke it to obtain the authentication data each time a connection or reconnection is attempted. :param transports: The list of allowed transports. Valid transports are ``'polling'`` and ``'websocket'``. If not given, the polling transport is connected first, then an upgrade to websocket is attempted. :param namespaces: The namespaces to connect as a string or list of strings. If not given, the namespaces that have registered event handlers are connected. :param socketio_path: The endpoint where the Socket.IO server is installed. The default value is appropriate for most cases. :param wait: if set to ``True`` (the default) the call only returns when all the namespaces are connected. If set to ``False``, the call returns as soon as the Engine.IO transport is connected, and the namespaces will connect in the background. :param wait_timeout: How long the client should wait for the connection. The default is 1 second. This argument is only considered when ``wait`` is set to ``True``. Note: this method is a coroutine. Example usage:: sio = socketio.AsyncClient() sio.connect('http://localhost:5000') """ if self.connected: raise exceptions.ConnectionError('Already connected') self.connection_url = url self.connection_headers = headers self.connection_auth = auth self.connection_transports = transports self.connection_namespaces = namespaces self.socketio_path = socketio_path if namespaces is None: namespaces = list(set(self.handlers.keys()).union( set(self.namespace_handlers.keys()))) if len(namespaces) == 0: namespaces = ['/'] elif isinstance(namespaces, str): namespaces = [namespaces] self.connection_namespaces = namespaces self.namespaces = {} if self._connect_event is None: self._connect_event = self.eio.create_event() else: self._connect_event.clear() real_url = await self._get_real_value(self.connection_url) real_headers = await self._get_real_value(self.connection_headers) try: await self.eio.connect(real_url, headers=real_headers, transports=transports, engineio_path=socketio_path) except engineio.exceptions.ConnectionError as exc: await self._trigger_event( 'connect_error', '/', exc.args[1] if len(exc.args) > 1 else exc.args[0]) raise exceptions.ConnectionError(exc.args[0]) from None if wait: try: while True: await asyncio.wait_for(self._connect_event.wait(), wait_timeout) self._connect_event.clear() if set(self.namespaces) == set(self.connection_namespaces): break except asyncio.TimeoutError: pass if set(self.namespaces) != set(self.connection_namespaces): await self.disconnect() raise exceptions.ConnectionError( 'One or more namespaces failed to connect') self.connected = True async def wait(self): """Wait until the connection with the server ends. Client applications can use this function to block the main thread during the life of the connection. Note: this method is a coroutine. """ while True: await self.eio.wait() await self.sleep(1) # give the reconnect task time to start up if not self._reconnect_task: break await self._reconnect_task if self.eio.state != 'connected': break async def emit(self, event, data=None, namespace=None, callback=None): """Emit a custom event to one or more connected clients. :param event: The event name. It can be any string. The event names ``'connect'``, ``'message'`` and ``'disconnect'`` are reserved and should not be used. :param data: The data to send to the server. Data can be of type ``str``, ``bytes``, ``list`` or ``dict``. To send multiple arguments, use a tuple where each element is of one of the types indicated above. :param namespace: The Socket.IO namespace for the event. If this argument is omitted the event is emitted to the default namespace. :param callback: If given, this function will be called to acknowledge the the server has received the message. The arguments that will be passed to the function are those provided by the server. Note: this method is not designed to be used concurrently. If multiple tasks are emitting at the same time on the same client connection, then messages composed of multiple packets may end up being sent in an incorrect sequence. Use standard concurrency solutions (such as a Lock object) to prevent this situation. Note 2: this method is a coroutine. """ namespace = namespace or '/' if namespace not in self.namespaces: raise exceptions.BadNamespaceError( namespace + ' is not a connected namespace.') self.logger.info('Emitting event "%s" [%s]', event, namespace) if callback is not None: id = self._generate_ack_id(namespace, callback) else: id = None # tuples are expanded to multiple arguments, everything else is sent # as a single argument if isinstance(data, tuple): data = list(data) elif data is not None: data = [data] else: data = [] await self._send_packet(self.packet_class( packet.EVENT, namespace=namespace, data=[event] + data, id=id)) async def send(self, data, namespace=None, callback=None): """Send a message to one or more connected clients. This function emits an event with the name ``'message'``. Use :func:`emit` to issue custom event names. :param data: The data to send to the server. Data can be of type ``str``, ``bytes``, ``list`` or ``dict``. To send multiple arguments, use a tuple where each element is of one of the types indicated above. :param namespace: The Socket.IO namespace for the event. If this argument is omitted the event is emitted to the default namespace. :param callback: If given, this function will be called to acknowledge the the server has received the message. The arguments that will be passed to the function are those provided by the server. Note: this method is a coroutine. """ await self.emit('message', data=data, namespace=namespace, callback=callback) async def call(self, event, data=None, namespace=None, timeout=60): """Emit a custom event to a client and wait for the response. This method issues an emit with a callback and waits for the callback to be invoked before returning. If the callback isn't invoked before the timeout, then a ``TimeoutError`` exception is raised. If the Socket.IO connection drops during the wait, this method still waits until the specified timeout. :param event: The event name. It can be any string. The event names ``'connect'``, ``'message'`` and ``'disconnect'`` are reserved and should not be used. :param data: The data to send to the server. Data can be of type ``str``, ``bytes``, ``list`` or ``dict``. To send multiple arguments, use a tuple where each element is of one of the types indicated above. :param namespace: The Socket.IO namespace for the event. If this argument is omitted the event is emitted to the default namespace. :param timeout: The waiting timeout. If the timeout is reached before the client acknowledges the event, then a ``TimeoutError`` exception is raised. Note: this method is not designed to be used concurrently. If multiple tasks are emitting at the same time on the same client connection, then messages composed of multiple packets may end up being sent in an incorrect sequence. Use standard concurrency solutions (such as a Lock object) to prevent this situation. Note 2: this method is a coroutine. """ callback_event = self.eio.create_event() callback_args = [] def event_callback(*args): callback_args.append(args) callback_event.set() await self.emit(event, data=data, namespace=namespace, callback=event_callback) try: await asyncio.wait_for(callback_event.wait(), timeout) except asyncio.TimeoutError: raise exceptions.TimeoutError() from None return callback_args[0] if len(callback_args[0]) > 1 \ else callback_args[0][0] if len(callback_args[0]) == 1 \ else None async def disconnect(self): """Disconnect from the server. Note: this method is a coroutine. """ # here we just request the disconnection # later in _handle_eio_disconnect we invoke the disconnect handler for n in self.namespaces: await self._send_packet(self.packet_class(packet.DISCONNECT, namespace=n)) await self.eio.disconnect(abort=True) def start_background_task(self, target, *args, **kwargs): """Start a background task using the appropriate async model. This is a utility function that applications can use to start a background task using the method that is compatible with the selected async mode. :param target: the target function to execute. :param args: arguments to pass to the function. :param kwargs: keyword arguments to pass to the function. The return value is a ``asyncio.Task`` object. """ return self.eio.start_background_task(target, *args, **kwargs) async def sleep(self, seconds=0): """Sleep for the requested amount of time using the appropriate async model. This is a utility function that applications can use to put a task to sleep without having to worry about using the correct call for the selected async mode. Note: this method is a coroutine. """ return await self.eio.sleep(seconds) async def _get_real_value(self, value): """Return the actual value, for parameters that can also be given as callables.""" if not callable(value): return value if asyncio.iscoroutinefunction(value): return await value() return value() async def _send_packet(self, pkt): """Send a Socket.IO packet to the server.""" encoded_packet = pkt.encode() if isinstance(encoded_packet, list): for ep in encoded_packet: await self.eio.send(ep) else: await self.eio.send(encoded_packet) async def _handle_connect(self, namespace, data): namespace = namespace or '/' if namespace not in self.namespaces: self.logger.info('Namespace {} is connected'.format(namespace)) self.namespaces[namespace] = (data or {}).get('sid', self.sid) await self._trigger_event('connect', namespace=namespace) self._connect_event.set() async def _handle_disconnect(self, namespace): if not self.connected: return namespace = namespace or '/' await self._trigger_event('disconnect', namespace=namespace) if namespace in self.namespaces: del self.namespaces[namespace] if not self.namespaces: self.connected = False await self.eio.disconnect(abort=True) async def _handle_event(self, namespace, id, data): namespace = namespace or '/' self.logger.info('Received event "%s" [%s]', data[0], namespace) r = await self._trigger_event(data[0], namespace, *data[1:]) if id is not None: # send ACK packet with the response returned by the handler # tuples are expanded as multiple arguments if r is None: data = [] elif isinstance(r, tuple): data = list(r) else: data = [r] await self._send_packet(self.packet_class( packet.ACK, namespace=namespace, id=id, data=data)) async def _handle_ack(self, namespace, id, data): namespace = namespace or '/' self.logger.info('Received ack [%s]', namespace) callback = None try: callback = self.callbacks[namespace][id] except KeyError: # if we get an unknown callback we just ignore it self.logger.warning('Unknown callback received, ignoring.') else: del self.callbacks[namespace][id] if callback is not None: if asyncio.iscoroutinefunction(callback): await callback(*data) else: callback(*data) async def _handle_error(self, namespace, data): namespace = namespace or '/' self.logger.info('Connection to namespace {} was rejected'.format( namespace)) if data is None: data = tuple() elif not isinstance(data, (tuple, list)): data = (data,) await self._trigger_event('connect_error', namespace, *data) self._connect_event.set() if namespace in self.namespaces: del self.namespaces[namespace] if namespace == '/': self.namespaces = {} self.connected = False async def _trigger_event(self, event, namespace, *args): """Invoke an application event handler.""" # first see if we have an explicit handler for the event if namespace in self.handlers: handler = None if event in self.handlers[namespace]: handler = self.handlers[namespace][event] elif event not in self.reserved_events and \ '*' in self.handlers[namespace]: handler = self.handlers[namespace]['*'] args = (event, *args) if handler: if asyncio.iscoroutinefunction(handler): try: ret = await handler(*args) except asyncio.CancelledError: # pragma: no cover ret = None else: ret = handler(*args) return ret # or else, forward the event to a namepsace handler if one exists elif namespace in self.namespace_handlers: return await self.namespace_handlers[namespace].trigger_event( event, *args) async def _handle_reconnect(self): if self._reconnect_abort is None: # pragma: no cover self._reconnect_abort = self.eio.create_event() self._reconnect_abort.clear() client.reconnecting_clients.append(self) attempt_count = 0 current_delay = self.reconnection_delay while True: delay = current_delay current_delay *= 2 if delay > self.reconnection_delay_max: delay = self.reconnection_delay_max delay += self.randomization_factor * (2 * random.random() - 1) self.logger.info( 'Connection failed, new attempt in {:.02f} seconds'.format( delay)) try: await asyncio.wait_for(self._reconnect_abort.wait(), delay) self.logger.info('Reconnect task aborted') break except (asyncio.TimeoutError, asyncio.CancelledError): pass attempt_count += 1 try: await self.connect(self.connection_url, headers=self.connection_headers, auth=self.connection_auth, transports=self.connection_transports, namespaces=self.connection_namespaces, socketio_path=self.socketio_path) except (exceptions.ConnectionError, ValueError): pass else: self.logger.info('Reconnection successful') self._reconnect_task = None break if self.reconnection_attempts and \ attempt_count >= self.reconnection_attempts: self.logger.info( 'Maximum reconnection attempts reached, giving up') break client.reconnecting_clients.remove(self) async def _handle_eio_connect(self): """Handle the Engine.IO connection event.""" self.logger.info('Engine.IO connection established') self.sid = self.eio.sid real_auth = await self._get_real_value(self.connection_auth) or {} for n in self.connection_namespaces: await self._send_packet(self.packet_class( packet.CONNECT, data=real_auth, namespace=n)) async def _handle_eio_message(self, data): """Dispatch Engine.IO messages.""" if self._binary_packet: pkt = self._binary_packet if pkt.add_attachment(data): self._binary_packet = None if pkt.packet_type == packet.BINARY_EVENT: await self._handle_event(pkt.namespace, pkt.id, pkt.data) else: await self._handle_ack(pkt.namespace, pkt.id, pkt.data) else: pkt = self.packet_class(encoded_packet=data) if pkt.packet_type == packet.CONNECT: await self._handle_connect(pkt.namespace, pkt.data) elif pkt.packet_type == packet.DISCONNECT: await self._handle_disconnect(pkt.namespace) elif pkt.packet_type == packet.EVENT: await self._handle_event(pkt.namespace, pkt.id, pkt.data) elif pkt.packet_type == packet.ACK: await self._handle_ack(pkt.namespace, pkt.id, pkt.data) elif pkt.packet_type == packet.BINARY_EVENT or \ pkt.packet_type == packet.BINARY_ACK: self._binary_packet = pkt elif pkt.packet_type == packet.CONNECT_ERROR: await self._handle_error(pkt.namespace, pkt.data) else: raise ValueError('Unknown packet type.') async def _handle_eio_disconnect(self): """Handle the Engine.IO disconnection event.""" self.logger.info('Engine.IO connection dropped') if self.connected: for n in self.namespaces: await self._trigger_event('disconnect', namespace=n) self.namespaces = {} self.connected = False self.callbacks = {} self._binary_packet = None self.sid = None if self.eio.state == 'connected' and self.reconnection: self._reconnect_task = self.start_background_task( self._handle_reconnect) def _engineio_client_class(self): return engineio.AsyncClient ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1660575712.0 python-socketio-5.7.2/src/socketio/asyncio_manager.py0000644000076600000240000000451114276457740022725 0ustar00mgrinbergstaffimport asyncio from .base_manager import BaseManager class AsyncManager(BaseManager): """Manage a client list for an asyncio server.""" async def can_disconnect(self, sid, namespace): return self.is_connected(sid, namespace) async def emit(self, event, data, namespace, room=None, skip_sid=None, callback=None, **kwargs): """Emit a message to a single client, a room, or all the clients connected to the namespace. Note: this method is a coroutine. """ if namespace not in self.rooms or room not in self.rooms[namespace]: return tasks = [] if not isinstance(skip_sid, list): skip_sid = [skip_sid] for sid, eio_sid in self.get_participants(namespace, room): if sid not in skip_sid: if callback is not None: id = self._generate_ack_id(sid, callback) else: id = None tasks.append(asyncio.create_task( self.server._emit_internal(eio_sid, event, data, namespace, id))) if tasks == []: # pragma: no cover return await asyncio.wait(tasks) async def disconnect(self, sid, namespace, **kwargs): """Disconnect a client. Note: this method is a coroutine. """ return super().disconnect(sid, namespace, **kwargs) async def close_room(self, room, namespace): """Remove all participants from a room. Note: this method is a coroutine. """ return super().close_room(room, namespace) async def trigger_callback(self, sid, id, data): """Invoke an application callback. Note: this method is a coroutine. """ callback = None try: callback = self.callbacks[sid][id] except KeyError: # if we get an unknown callback we just ignore it self._get_logger().warning('Unknown callback received, ignoring.') else: del self.callbacks[sid][id] if callback is not None: ret = callback(*data) if asyncio.iscoroutine(ret): try: await ret except asyncio.CancelledError: # pragma: no cover pass ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635102822.0 python-socketio-5.7.2/src/socketio/asyncio_namespace.py0000644000076600000240000002234214135330146023231 0ustar00mgrinbergstaffimport asyncio from socketio import namespace class AsyncNamespace(namespace.Namespace): """Base class for asyncio server-side class-based namespaces. A class-based namespace is a class that contains all the event handlers for a Socket.IO namespace. The event handlers are methods of the class with the prefix ``on_``, such as ``on_connect``, ``on_disconnect``, ``on_message``, ``on_json``, and so on. These can be regular functions or coroutines. :param namespace: The Socket.IO namespace to be used with all the event handlers defined in this class. If this argument is omitted, the default namespace is used. """ def is_asyncio_based(self): return True async def trigger_event(self, event, *args): """Dispatch an event to the proper handler method. In the most common usage, this method is not overloaded by subclasses, as it performs the routing of events to methods. However, this method can be overridden if special dispatching rules are needed, or if having a single method that catches all events is desired. Note: this method is a coroutine. """ handler_name = 'on_' + event if hasattr(self, handler_name): handler = getattr(self, handler_name) if asyncio.iscoroutinefunction(handler) is True: try: ret = await handler(*args) except asyncio.CancelledError: # pragma: no cover ret = None else: ret = handler(*args) return ret async def emit(self, event, data=None, to=None, room=None, skip_sid=None, namespace=None, callback=None): """Emit a custom event to one or more connected clients. The only difference with the :func:`socketio.Server.emit` method is that when the ``namespace`` argument is not given the namespace associated with the class is used. Note: this method is a coroutine. """ return await self.server.emit(event, data=data, to=to, room=room, skip_sid=skip_sid, namespace=namespace or self.namespace, callback=callback) async def send(self, data, to=None, room=None, skip_sid=None, namespace=None, callback=None): """Send a message to one or more connected clients. The only difference with the :func:`socketio.Server.send` method is that when the ``namespace`` argument is not given the namespace associated with the class is used. Note: this method is a coroutine. """ return await self.server.send(data, to=to, room=room, skip_sid=skip_sid, namespace=namespace or self.namespace, callback=callback) async def call(self, event, data=None, to=None, sid=None, namespace=None, timeout=None): """Emit a custom event to a client and wait for the response. The only difference with the :func:`socketio.Server.call` method is that when the ``namespace`` argument is not given the namespace associated with the class is used. """ return await self.server.call(event, data=data, to=to, sid=sid, namespace=namespace or self.namespace, timeout=timeout) async def close_room(self, room, namespace=None): """Close a room. The only difference with the :func:`socketio.Server.close_room` method is that when the ``namespace`` argument is not given the namespace associated with the class is used. Note: this method is a coroutine. """ return await self.server.close_room( room, namespace=namespace or self.namespace) async def get_session(self, sid, namespace=None): """Return the user session for a client. The only difference with the :func:`socketio.Server.get_session` method is that when the ``namespace`` argument is not given the namespace associated with the class is used. Note: this method is a coroutine. """ return await self.server.get_session( sid, namespace=namespace or self.namespace) async def save_session(self, sid, session, namespace=None): """Store the user session for a client. The only difference with the :func:`socketio.Server.save_session` method is that when the ``namespace`` argument is not given the namespace associated with the class is used. Note: this method is a coroutine. """ return await self.server.save_session( sid, session, namespace=namespace or self.namespace) def session(self, sid, namespace=None): """Return the user session for a client with context manager syntax. The only difference with the :func:`socketio.Server.session` method is that when the ``namespace`` argument is not given the namespace associated with the class is used. """ return self.server.session(sid, namespace=namespace or self.namespace) async def disconnect(self, sid, namespace=None): """Disconnect a client. The only difference with the :func:`socketio.Server.disconnect` method is that when the ``namespace`` argument is not given the namespace associated with the class is used. Note: this method is a coroutine. """ return await self.server.disconnect( sid, namespace=namespace or self.namespace) class AsyncClientNamespace(namespace.ClientNamespace): """Base class for asyncio client-side class-based namespaces. A class-based namespace is a class that contains all the event handlers for a Socket.IO namespace. The event handlers are methods of the class with the prefix ``on_``, such as ``on_connect``, ``on_disconnect``, ``on_message``, ``on_json``, and so on. These can be regular functions or coroutines. :param namespace: The Socket.IO namespace to be used with all the event handlers defined in this class. If this argument is omitted, the default namespace is used. """ def is_asyncio_based(self): return True async def trigger_event(self, event, *args): """Dispatch an event to the proper handler method. In the most common usage, this method is not overloaded by subclasses, as it performs the routing of events to methods. However, this method can be overridden if special dispatching rules are needed, or if having a single method that catches all events is desired. Note: this method is a coroutine. """ handler_name = 'on_' + event if hasattr(self, handler_name): handler = getattr(self, handler_name) if asyncio.iscoroutinefunction(handler) is True: try: ret = await handler(*args) except asyncio.CancelledError: # pragma: no cover ret = None else: ret = handler(*args) return ret async def emit(self, event, data=None, namespace=None, callback=None): """Emit a custom event to the server. The only difference with the :func:`socketio.Client.emit` method is that when the ``namespace`` argument is not given the namespace associated with the class is used. Note: this method is a coroutine. """ return await self.client.emit(event, data=data, namespace=namespace or self.namespace, callback=callback) async def send(self, data, namespace=None, callback=None): """Send a message to the server. The only difference with the :func:`socketio.Client.send` method is that when the ``namespace`` argument is not given the namespace associated with the class is used. Note: this method is a coroutine. """ return await self.client.send(data, namespace=namespace or self.namespace, callback=callback) async def call(self, event, data=None, namespace=None, timeout=None): """Emit a custom event to the server and wait for the response. The only difference with the :func:`socketio.Client.call` method is that when the ``namespace`` argument is not given the namespace associated with the class is used. """ return await self.client.call(event, data=data, namespace=namespace or self.namespace, timeout=timeout) async def disconnect(self): """Disconnect a client. The only difference with the :func:`socketio.Client.disconnect` method is that when the ``namespace`` argument is not given the namespace associated with the class is used. Note: this method is a coroutine. """ return await self.client.disconnect() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1660575712.0 python-socketio-5.7.2/src/socketio/asyncio_pubsub_manager.py0000644000076600000240000002041514276457740024306 0ustar00mgrinbergstaffimport asyncio from functools import partial import uuid from engineio import json import pickle from .asyncio_manager import AsyncManager class AsyncPubSubManager(AsyncManager): """Manage a client list attached to a pub/sub backend under asyncio. This is a base class that enables multiple servers to share the list of clients, with the servers communicating events through a pub/sub backend. The use of a pub/sub backend also allows any client connected to the backend to emit events addressed to Socket.IO clients. The actual backends must be implemented by subclasses, this class only provides a pub/sub generic framework for asyncio applications. :param channel: The channel name on which the server sends and receives notifications. """ name = 'asyncpubsub' def __init__(self, channel='socketio', write_only=False, logger=None): super().__init__() self.channel = channel self.write_only = write_only self.host_id = uuid.uuid4().hex self.logger = logger def initialize(self): super().initialize() if not self.write_only: self.thread = self.server.start_background_task(self._thread) self._get_logger().info(self.name + ' backend initialized.') async def emit(self, event, data, namespace=None, room=None, skip_sid=None, callback=None, **kwargs): """Emit a message to a single client, a room, or all the clients connected to the namespace. This method takes care or propagating the message to all the servers that are connected through the message queue. The parameters are the same as in :meth:`.Server.emit`. Note: this method is a coroutine. """ if kwargs.get('ignore_queue'): return await super().emit( event, data, namespace=namespace, room=room, skip_sid=skip_sid, callback=callback) namespace = namespace or '/' if callback is not None: if self.server is None: raise RuntimeError('Callbacks can only be issued from the ' 'context of a server.') if room is None: raise ValueError('Cannot use callback without a room set.') id = self._generate_ack_id(room, callback) callback = (room, namespace, id) else: callback = None await self._publish({'method': 'emit', 'event': event, 'data': data, 'namespace': namespace, 'room': room, 'skip_sid': skip_sid, 'callback': callback, 'host_id': self.host_id}) async def can_disconnect(self, sid, namespace): if self.is_connected(sid, namespace): # client is in this server, so we can disconnect directly return await super().can_disconnect(sid, namespace) else: # client is in another server, so we post request to the queue await self._publish({'method': 'disconnect', 'sid': sid, 'namespace': namespace or '/'}) async def disconnect(self, sid, namespace, **kwargs): if kwargs.get('ignore_queue'): return await super(AsyncPubSubManager, self).disconnect( sid, namespace=namespace) await self._publish({'method': 'disconnect', 'sid': sid, 'namespace': namespace or '/'}) async def close_room(self, room, namespace=None): await self._publish({'method': 'close_room', 'room': room, 'namespace': namespace or '/'}) async def _publish(self, data): """Publish a message on the Socket.IO channel. This method needs to be implemented by the different subclasses that support pub/sub backends. """ raise NotImplementedError('This method must be implemented in a ' 'subclass.') # pragma: no cover async def _listen(self): """Return the next message published on the Socket.IO channel, blocking until a message is available. This method needs to be implemented by the different subclasses that support pub/sub backends. """ raise NotImplementedError('This method must be implemented in a ' 'subclass.') # pragma: no cover async def _handle_emit(self, message): # Events with callbacks are very tricky to handle across hosts # Here in the receiving end we set up a local callback that preserves # the callback host and id from the sender remote_callback = message.get('callback') remote_host_id = message.get('host_id') if remote_callback is not None and len(remote_callback) == 3: callback = partial(self._return_callback, remote_host_id, *remote_callback) else: callback = None await super().emit(message['event'], message['data'], namespace=message.get('namespace'), room=message.get('room'), skip_sid=message.get('skip_sid'), callback=callback) async def _handle_callback(self, message): if self.host_id == message.get('host_id'): try: sid = message['sid'] id = message['id'] args = message['args'] except KeyError: return await self.trigger_callback(sid, id, args) async def _return_callback(self, host_id, sid, namespace, callback_id, *args): # When an event callback is received, the callback is returned back # the sender, which is identified by the host_id await self._publish({'method': 'callback', 'host_id': host_id, 'sid': sid, 'namespace': namespace, 'id': callback_id, 'args': args}) async def _handle_disconnect(self, message): await self.server.disconnect(sid=message.get('sid'), namespace=message.get('namespace'), ignore_queue=True) async def _handle_close_room(self, message): await super().close_room( room=message.get('room'), namespace=message.get('namespace')) async def _thread(self): while True: try: async for message in self._listen(): # pragma: no branch data = None if isinstance(message, dict): data = message else: if isinstance(message, bytes): # pragma: no cover try: data = pickle.loads(message) except: pass if data is None: try: data = json.loads(message) except: pass if data and 'method' in data: self._get_logger().info('pubsub message: {}'.format( data['method'])) try: if data['method'] == 'emit': await self._handle_emit(data) elif data['method'] == 'callback': await self._handle_callback(data) elif data['method'] == 'disconnect': await self._handle_disconnect(data) elif data['method'] == 'close_room': await self._handle_close_room(data) except asyncio.CancelledError: raise # let the outer try/except handle it except: self.server.logger.exception( 'Unknown error in pubsub listening task') except asyncio.CancelledError: # pragma: no cover break except: # pragma: no cover import traceback traceback.print_exc() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1651416633.0 python-socketio-5.7.2/src/socketio/asyncio_redis_manager.py0000644000076600000240000001031514233517071024075 0ustar00mgrinbergstaffimport asyncio import pickle try: # pragma: no cover from redis import asyncio as aioredis from redis.exceptions import RedisError except ImportError: # pragma: no cover try: import aioredis from aioredis.exceptions import RedisError except ImportError: aioredis = None RedisError = None from .asyncio_pubsub_manager import AsyncPubSubManager class AsyncRedisManager(AsyncPubSubManager): # pragma: no cover """Redis based client manager for asyncio servers. This class implements a Redis backend for event sharing across multiple processes. To use a Redis backend, initialize the :class:`AsyncServer` instance as follows:: url = 'redis://hostname:port/0' server = socketio.AsyncServer( client_manager=socketio.AsyncRedisManager(url)) :param url: The connection URL for the Redis server. For a default Redis store running on the same host, use ``redis://``. To use an SSL connection, use ``rediss://``. :param channel: The channel name on which the server sends and receives notifications. Must be the same in all the servers. :param write_only: If set to ``True``, only initialize to emit events. The default of ``False`` initializes the class for emitting and receiving. :param redis_options: additional keyword arguments to be passed to ``aioredis.from_url()``. """ name = 'aioredis' def __init__(self, url='redis://localhost:6379/0', channel='socketio', write_only=False, logger=None, redis_options=None): if aioredis is None: raise RuntimeError('Redis package is not installed ' '(Run "pip install redis" in your virtualenv).') if not hasattr(aioredis.Redis, 'from_url'): raise RuntimeError('Version 2 of aioredis package is required.') self.redis_url = url self.redis_options = redis_options or {} self._redis_connect() super().__init__(channel=channel, write_only=write_only, logger=logger) def _redis_connect(self): self.redis = aioredis.Redis.from_url(self.redis_url, **self.redis_options) self.pubsub = self.redis.pubsub(ignore_subscribe_messages=True) async def _publish(self, data): retry = True while True: try: if not retry: self._redis_connect() return await self.redis.publish( self.channel, pickle.dumps(data)) except RedisError: if retry: self._get_logger().error('Cannot publish to redis... ' 'retrying') retry = False else: self._get_logger().error('Cannot publish to redis... ' 'giving up') break async def _redis_listen_with_retries(self): retry_sleep = 1 connect = False while True: try: if connect: self._redis_connect() await self.pubsub.subscribe(self.channel) retry_sleep = 1 async for message in self.pubsub.listen(): yield message except RedisError: self._get_logger().error('Cannot receive from redis... ' 'retrying in ' '{} secs'.format(retry_sleep)) connect = True await asyncio.sleep(retry_sleep) retry_sleep *= 2 if retry_sleep > 60: retry_sleep = 60 async def _listen(self): channel = self.channel.encode('utf-8') await self.pubsub.subscribe(self.channel) async for message in self._redis_listen_with_retries(): if message['channel'] == channel and \ message['type'] == 'message' and 'data' in message: yield message['data'] await self.pubsub.unsubscribe(self.channel) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1660575712.0 python-socketio-5.7.2/src/socketio/asyncio_server.py0000644000076600000240000007513714276457740022635 0ustar00mgrinbergstaffimport asyncio import engineio from . import asyncio_manager from . import exceptions from . import packet from . import server class AsyncServer(server.Server): """A Socket.IO server for asyncio. This class implements a fully compliant Socket.IO web server with support for websocket and long-polling transports, compatible with the asyncio framework. :param client_manager: The client manager instance that will manage the client list. When this is omitted, the client list is stored in an in-memory structure, so the use of multiple connected servers is not possible. :param logger: To enable logging set to ``True`` or pass a logger object to use. To disable logging set to ``False``. Note that fatal errors are logged even when ``logger`` is ``False``. :param json: An alternative json module to use for encoding and decoding packets. Custom json modules must have ``dumps`` and ``loads`` functions that are compatible with the standard library versions. :param async_handlers: If set to ``True``, event handlers for a client are executed in separate threads. To run handlers for a client synchronously, set to ``False``. The default is ``True``. :param always_connect: When set to ``False``, new connections are provisory until the connect handler returns something other than ``False``, at which point they are accepted. When set to ``True``, connections are immediately accepted, and then if the connect handler returns ``False`` a disconnect is issued. Set to ``True`` if you need to emit events from the connect handler and your client is confused when it receives events before the connection acceptance. In any other case use the default of ``False``. :param namespaces: a list of namespaces that are accepted, in addition to any namespaces for which handlers have been defined. The default is `['/']`, which always accepts connections to the default namespace. Set to `'*'` to accept all namespaces. :param kwargs: Connection parameters for the underlying Engine.IO server. The Engine.IO configuration supports the following settings: :param async_mode: The asynchronous model to use. See the Deployment section in the documentation for a description of the available options. Valid async modes are "aiohttp", "sanic", "tornado" and "asgi". If this argument is not given, "aiohttp" is tried first, followed by "sanic", "tornado", and finally "asgi". The first async mode that has all its dependencies installed is the one that is chosen. :param ping_interval: The interval in seconds at which the server pings the client. The default is 25 seconds. For advanced control, a two element tuple can be given, where the first number is the ping interval and the second is a grace period added by the server. :param ping_timeout: The time in seconds that the client waits for the server to respond before disconnecting. The default is 5 seconds. :param max_http_buffer_size: The maximum size of a message when using the polling transport. The default is 1,000,000 bytes. :param allow_upgrades: Whether to allow transport upgrades or not. The default is ``True``. :param http_compression: Whether to compress packages when using the polling transport. The default is ``True``. :param compression_threshold: Only compress messages when their byte size is greater than this value. The default is 1024 bytes. :param cookie: If set to a string, it is the name of the HTTP cookie the server sends back tot he client containing the client session id. If set to a dictionary, the ``'name'`` key contains the cookie name and other keys define cookie attributes, where the value of each attribute can be a string, a callable with no arguments, or a boolean. If set to ``None`` (the default), a cookie is not sent to the client. :param cors_allowed_origins: Origin or list of origins that are allowed to connect to this server. Only the same origin is allowed by default. Set this argument to ``'*'`` to allow all origins, or to ``[]`` to disable CORS handling. :param cors_credentials: Whether credentials (cookies, authentication) are allowed in requests to this server. The default is ``True``. :param monitor_clients: If set to ``True``, a background task will ensure inactive clients are closed. Set to ``False`` to disable the monitoring task (not recommended). The default is ``True``. :param engineio_logger: To enable Engine.IO logging set to ``True`` or pass a logger object to use. To disable logging set to ``False``. The default is ``False``. Note that fatal errors are logged even when ``engineio_logger`` is ``False``. """ def __init__(self, client_manager=None, logger=False, json=None, async_handlers=True, namespaces=None, **kwargs): if client_manager is None: client_manager = asyncio_manager.AsyncManager() super().__init__(client_manager=client_manager, logger=logger, json=json, async_handlers=async_handlers, namespaces=namespaces, **kwargs) def is_asyncio_based(self): return True def attach(self, app, socketio_path='socket.io'): """Attach the Socket.IO server to an application.""" self.eio.attach(app, socketio_path) async def emit(self, event, data=None, to=None, room=None, skip_sid=None, namespace=None, callback=None, **kwargs): """Emit a custom event to one or more connected clients. :param event: The event name. It can be any string. The event names ``'connect'``, ``'message'`` and ``'disconnect'`` are reserved and should not be used. :param data: The data to send to the client or clients. Data can be of type ``str``, ``bytes``, ``list`` or ``dict``. To send multiple arguments, use a tuple where each element is of one of the types indicated above. :param to: The recipient of the message. This can be set to the session ID of a client to address only that client, to any any custom room created by the application to address all the clients in that room, or to a list of custom room names. If this argument is omitted the event is broadcasted to all connected clients. :param room: Alias for the ``to`` parameter. :param skip_sid: The session ID of a client to skip when broadcasting to a room or to all clients. This can be used to prevent a message from being sent to the sender. :param namespace: The Socket.IO namespace for the event. If this argument is omitted the event is emitted to the default namespace. :param callback: If given, this function will be called to acknowledge the the client has received the message. The arguments that will be passed to the function are those provided by the client. Callback functions can only be used when addressing an individual client. :param ignore_queue: Only used when a message queue is configured. If set to ``True``, the event is emitted to the clients directly, without going through the queue. This is more efficient, but only works when a single server process is used. It is recommended to always leave this parameter with its default value of ``False``. Note: this method is not designed to be used concurrently. If multiple tasks are emitting at the same time to the same client connection, then messages composed of multiple packets may end up being sent in an incorrect sequence. Use standard concurrency solutions (such as a Lock object) to prevent this situation. Note 2: this method is a coroutine. """ namespace = namespace or '/' room = to or room self.logger.info('emitting event "%s" to %s [%s]', event, room or 'all', namespace) await self.manager.emit(event, data, namespace, room=room, skip_sid=skip_sid, callback=callback, **kwargs) async def send(self, data, to=None, room=None, skip_sid=None, namespace=None, callback=None, **kwargs): """Send a message to one or more connected clients. This function emits an event with the name ``'message'``. Use :func:`emit` to issue custom event names. :param data: The data to send to the client or clients. Data can be of type ``str``, ``bytes``, ``list`` or ``dict``. To send multiple arguments, use a tuple where each element is of one of the types indicated above. :param to: The recipient of the message. This can be set to the session ID of a client to address only that client, to any any custom room created by the application to address all the clients in that room, or to a list of custom room names. If this argument is omitted the event is broadcasted to all connected clients. :param room: Alias for the ``to`` parameter. :param skip_sid: The session ID of a client to skip when broadcasting to a room or to all clients. This can be used to prevent a message from being sent to the sender. :param namespace: The Socket.IO namespace for the event. If this argument is omitted the event is emitted to the default namespace. :param callback: If given, this function will be called to acknowledge the the client has received the message. The arguments that will be passed to the function are those provided by the client. Callback functions can only be used when addressing an individual client. :param ignore_queue: Only used when a message queue is configured. If set to ``True``, the event is emitted to the clients directly, without going through the queue. This is more efficient, but only works when a single server process is used. It is recommended to always leave this parameter with its default value of ``False``. Note: this method is a coroutine. """ await self.emit('message', data=data, to=to, room=room, skip_sid=skip_sid, namespace=namespace, callback=callback, **kwargs) async def call(self, event, data=None, to=None, sid=None, namespace=None, timeout=60, **kwargs): """Emit a custom event to a client and wait for the response. This method issues an emit with a callback and waits for the callback to be invoked before returning. If the callback isn't invoked before the timeout, then a ``TimeoutError`` exception is raised. If the Socket.IO connection drops during the wait, this method still waits until the specified timeout. :param event: The event name. It can be any string. The event names ``'connect'``, ``'message'`` and ``'disconnect'`` are reserved and should not be used. :param data: The data to send to the client or clients. Data can be of type ``str``, ``bytes``, ``list`` or ``dict``. To send multiple arguments, use a tuple where each element is of one of the types indicated above. :param to: The session ID of the recipient client. :param sid: Alias for the ``to`` parameter. :param namespace: The Socket.IO namespace for the event. If this argument is omitted the event is emitted to the default namespace. :param timeout: The waiting timeout. If the timeout is reached before the client acknowledges the event, then a ``TimeoutError`` exception is raised. :param ignore_queue: Only used when a message queue is configured. If set to ``True``, the event is emitted to the client directly, without going through the queue. This is more efficient, but only works when a single server process is used. It is recommended to always leave this parameter with its default value of ``False``. Note: this method is not designed to be used concurrently. If multiple tasks are emitting at the same time to the same client connection, then messages composed of multiple packets may end up being sent in an incorrect sequence. Use standard concurrency solutions (such as a Lock object) to prevent this situation. Note 2: this method is a coroutine. """ if to is None and sid is None: raise ValueError('Cannot use call() to broadcast.') if not self.async_handlers: raise RuntimeError( 'Cannot use call() when async_handlers is False.') callback_event = self.eio.create_event() callback_args = [] def event_callback(*args): callback_args.append(args) callback_event.set() await self.emit(event, data=data, room=to or sid, namespace=namespace, callback=event_callback, **kwargs) try: await asyncio.wait_for(callback_event.wait(), timeout) except asyncio.TimeoutError: raise exceptions.TimeoutError() from None return callback_args[0] if len(callback_args[0]) > 1 \ else callback_args[0][0] if len(callback_args[0]) == 1 \ else None async def close_room(self, room, namespace=None): """Close a room. This function removes all the clients from the given room. :param room: Room name. :param namespace: The Socket.IO namespace for the event. If this argument is omitted the default namespace is used. Note: this method is a coroutine. """ namespace = namespace or '/' self.logger.info('room %s is closing [%s]', room, namespace) await self.manager.close_room(room, namespace) async def get_session(self, sid, namespace=None): """Return the user session for a client. :param sid: The session id of the client. :param namespace: The Socket.IO namespace. If this argument is omitted the default namespace is used. The return value is a dictionary. Modifications made to this dictionary are not guaranteed to be preserved. If you want to modify the user session, use the ``session`` context manager instead. """ namespace = namespace or '/' eio_sid = self.manager.eio_sid_from_sid(sid, namespace) eio_session = await self.eio.get_session(eio_sid) return eio_session.setdefault(namespace, {}) async def save_session(self, sid, session, namespace=None): """Store the user session for a client. :param sid: The session id of the client. :param session: The session dictionary. :param namespace: The Socket.IO namespace. If this argument is omitted the default namespace is used. """ namespace = namespace or '/' eio_sid = self.manager.eio_sid_from_sid(sid, namespace) eio_session = await self.eio.get_session(eio_sid) eio_session[namespace] = session def session(self, sid, namespace=None): """Return the user session for a client with context manager syntax. :param sid: The session id of the client. This is a context manager that returns the user session dictionary for the client. Any changes that are made to this dictionary inside the context manager block are saved back to the session. Example usage:: @eio.on('connect') def on_connect(sid, environ): username = authenticate_user(environ) if not username: return False with eio.session(sid) as session: session['username'] = username @eio.on('message') def on_message(sid, msg): async with eio.session(sid) as session: print('received message from ', session['username']) """ class _session_context_manager(object): def __init__(self, server, sid, namespace): self.server = server self.sid = sid self.namespace = namespace self.session = None async def __aenter__(self): self.session = await self.server.get_session( sid, namespace=self.namespace) return self.session async def __aexit__(self, *args): await self.server.save_session(sid, self.session, namespace=self.namespace) return _session_context_manager(self, sid, namespace) async def disconnect(self, sid, namespace=None, ignore_queue=False): """Disconnect a client. :param sid: Session ID of the client. :param namespace: The Socket.IO namespace to disconnect. If this argument is omitted the default namespace is used. :param ignore_queue: Only used when a message queue is configured. If set to ``True``, the disconnect is processed locally, without broadcasting on the queue. It is recommended to always leave this parameter with its default value of ``False``. Note: this method is a coroutine. """ namespace = namespace or '/' if ignore_queue: delete_it = self.manager.is_connected(sid, namespace) else: delete_it = await self.manager.can_disconnect(sid, namespace) if delete_it: self.logger.info('Disconnecting %s [%s]', sid, namespace) eio_sid = self.manager.pre_disconnect(sid, namespace=namespace) await self._send_packet(eio_sid, self.packet_class( packet.DISCONNECT, namespace=namespace)) await self._trigger_event('disconnect', namespace, sid) await self.manager.disconnect(sid, namespace=namespace, ignore_queue=True) async def handle_request(self, *args, **kwargs): """Handle an HTTP request from the client. This is the entry point of the Socket.IO application. This function returns the HTTP response body to deliver to the client. Note: this method is a coroutine. """ return await self.eio.handle_request(*args, **kwargs) def start_background_task(self, target, *args, **kwargs): """Start a background task using the appropriate async model. This is a utility function that applications can use to start a background task using the method that is compatible with the selected async mode. :param target: the target function to execute. Must be a coroutine. :param args: arguments to pass to the function. :param kwargs: keyword arguments to pass to the function. The return value is a ``asyncio.Task`` object. """ return self.eio.start_background_task(target, *args, **kwargs) async def sleep(self, seconds=0): """Sleep for the requested amount of time using the appropriate async model. This is a utility function that applications can use to put a task to sleep without having to worry about using the correct call for the selected async mode. Note: this method is a coroutine. """ return await self.eio.sleep(seconds) async def _emit_internal(self, sid, event, data, namespace=None, id=None): """Send a message to a client.""" # tuples are expanded to multiple arguments, everything else is sent # as a single argument if isinstance(data, tuple): data = list(data) elif data is not None: data = [data] else: data = [] await self._send_packet(sid, self.packet_class( packet.EVENT, namespace=namespace, data=[event] + data, id=id)) async def _send_packet(self, eio_sid, pkt): """Send a Socket.IO packet to a client.""" encoded_packet = pkt.encode() if isinstance(encoded_packet, list): for ep in encoded_packet: await self.eio.send(eio_sid, ep) else: await self.eio.send(eio_sid, encoded_packet) async def _handle_connect(self, eio_sid, namespace, data): """Handle a client connection request.""" namespace = namespace or '/' sid = None if namespace in self.handlers or namespace in self.namespace_handlers \ or self.namespaces == '*' or namespace in self.namespaces: sid = self.manager.connect(eio_sid, namespace) if sid is None: await self._send_packet(eio_sid, self.packet_class( packet.CONNECT_ERROR, data='Unable to connect', namespace=namespace)) return if self.always_connect: await self._send_packet(eio_sid, self.packet_class( packet.CONNECT, {'sid': sid}, namespace=namespace)) fail_reason = exceptions.ConnectionRefusedError().error_args try: if data: success = await self._trigger_event( 'connect', namespace, sid, self.environ[eio_sid], data) else: try: success = await self._trigger_event( 'connect', namespace, sid, self.environ[eio_sid]) except TypeError: success = await self._trigger_event( 'connect', namespace, sid, self.environ[eio_sid], None) except exceptions.ConnectionRefusedError as exc: fail_reason = exc.error_args success = False if success is False: if self.always_connect: self.manager.pre_disconnect(sid, namespace) await self._send_packet(eio_sid, self.packet_class( packet.DISCONNECT, data=fail_reason, namespace=namespace)) else: await self._send_packet(eio_sid, self.packet_class( packet.CONNECT_ERROR, data=fail_reason, namespace=namespace)) await self.manager.disconnect(sid, namespace, ignore_queue=True) elif not self.always_connect: await self._send_packet(eio_sid, self.packet_class( packet.CONNECT, {'sid': sid}, namespace=namespace)) async def _handle_disconnect(self, eio_sid, namespace): """Handle a client disconnect.""" namespace = namespace or '/' sid = self.manager.sid_from_eio_sid(eio_sid, namespace) if not self.manager.is_connected(sid, namespace): # pragma: no cover return self.manager.pre_disconnect(sid, namespace=namespace) await self._trigger_event('disconnect', namespace, sid) await self.manager.disconnect(sid, namespace, ignore_queue=True) async def _handle_event(self, eio_sid, namespace, id, data): """Handle an incoming client event.""" namespace = namespace or '/' sid = self.manager.sid_from_eio_sid(eio_sid, namespace) self.logger.info('received event "%s" from %s [%s]', data[0], sid, namespace) if not self.manager.is_connected(sid, namespace): self.logger.warning('%s is not connected to namespace %s', sid, namespace) return if self.async_handlers: self.start_background_task(self._handle_event_internal, self, sid, eio_sid, data, namespace, id) else: await self._handle_event_internal(self, sid, eio_sid, data, namespace, id) async def _handle_event_internal(self, server, sid, eio_sid, data, namespace, id): r = await server._trigger_event(data[0], namespace, sid, *data[1:]) if r != self.not_handled and id is not None: # send ACK packet with the response returned by the handler # tuples are expanded as multiple arguments if r is None: data = [] elif isinstance(r, tuple): data = list(r) else: data = [r] await server._send_packet(eio_sid, self.packet_class( packet.ACK, namespace=namespace, id=id, data=data)) async def _handle_ack(self, eio_sid, namespace, id, data): """Handle ACK packets from the client.""" namespace = namespace or '/' sid = self.manager.sid_from_eio_sid(eio_sid, namespace) self.logger.info('received ack from %s [%s]', sid, namespace) await self.manager.trigger_callback(sid, id, data) async def _trigger_event(self, event, namespace, *args): """Invoke an application event handler.""" # first see if we have an explicit handler for the event if namespace in self.handlers: handler = None if event in self.handlers[namespace]: handler = self.handlers[namespace][event] elif event not in self.reserved_events and \ '*' in self.handlers[namespace]: handler = self.handlers[namespace]['*'] args = (event, *args) if handler: if asyncio.iscoroutinefunction(handler): try: ret = await handler(*args) except asyncio.CancelledError: # pragma: no cover ret = None else: ret = handler(*args) return ret else: return self.not_handled # or else, forward the event to a namepsace handler if one exists elif namespace in self.namespace_handlers: # pragma: no branch return await self.namespace_handlers[namespace].trigger_event( event, *args) async def _handle_eio_connect(self, eio_sid, environ): """Handle the Engine.IO connection event.""" if not self.manager_initialized: self.manager_initialized = True self.manager.initialize() self.environ[eio_sid] = environ async def _handle_eio_message(self, eio_sid, data): """Dispatch Engine.IO messages.""" if eio_sid in self._binary_packet: pkt = self._binary_packet[eio_sid] if pkt.add_attachment(data): del self._binary_packet[eio_sid] if pkt.packet_type == packet.BINARY_EVENT: await self._handle_event(eio_sid, pkt.namespace, pkt.id, pkt.data) else: await self._handle_ack(eio_sid, pkt.namespace, pkt.id, pkt.data) else: pkt = self.packet_class(encoded_packet=data) if pkt.packet_type == packet.CONNECT: await self._handle_connect(eio_sid, pkt.namespace, pkt.data) elif pkt.packet_type == packet.DISCONNECT: await self._handle_disconnect(eio_sid, pkt.namespace) elif pkt.packet_type == packet.EVENT: await self._handle_event(eio_sid, pkt.namespace, pkt.id, pkt.data) elif pkt.packet_type == packet.ACK: await self._handle_ack(eio_sid, pkt.namespace, pkt.id, pkt.data) elif pkt.packet_type == packet.BINARY_EVENT or \ pkt.packet_type == packet.BINARY_ACK: self._binary_packet[eio_sid] = pkt elif pkt.packet_type == packet.CONNECT_ERROR: raise ValueError('Unexpected CONNECT_ERROR packet.') else: raise ValueError('Unknown packet type.') async def _handle_eio_disconnect(self, eio_sid): """Handle Engine.IO disconnect event.""" for n in list(self.manager.get_namespaces()).copy(): await self._handle_disconnect(eio_sid, n) if eio_sid in self.environ: del self.environ[eio_sid] def _engineio_server_class(self): return engineio.AsyncServer ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1660576297.0 python-socketio-5.7.2/src/socketio/base_manager.py0000644000076600000240000001652014276461051022163 0ustar00mgrinbergstaffimport itertools import logging from bidict import bidict, ValueDuplicationError default_logger = logging.getLogger('socketio') class BaseManager(object): """Manage client connections. This class keeps track of all the clients and the rooms they are in, to support the broadcasting of messages. The data used by this class is stored in a memory structure, making it appropriate only for single process services. More sophisticated storage backends can be implemented by subclasses. """ def __init__(self): self.logger = None self.server = None self.rooms = {} # self.rooms[namespace][room][sio_sid] = eio_sid self.eio_to_sid = {} self.callbacks = {} self.pending_disconnect = {} def set_server(self, server): self.server = server def initialize(self): """Invoked before the first request is received. Subclasses can add their initialization code here. """ pass def get_namespaces(self): """Return an iterable with the active namespace names.""" return self.rooms.keys() def get_participants(self, namespace, room): """Return an iterable with the active participants in a room.""" ns = self.rooms[namespace] if hasattr(room, '__len__') and not isinstance(room, str): participants = ns[room[0]]._fwdm.copy() if room[0] in ns else {} for r in room[1:]: participants.update(ns[r]._fwdm if r in ns else {}) else: participants = ns[room]._fwdm.copy() if room in ns else {} for sid, eio_sid in participants.items(): yield sid, eio_sid def connect(self, eio_sid, namespace): """Register a client connection to a namespace.""" sid = self.server.eio.generate_id() try: self.enter_room(sid, namespace, None, eio_sid=eio_sid) except ValueDuplicationError: # already connected return None self.enter_room(sid, namespace, sid, eio_sid=eio_sid) return sid def is_connected(self, sid, namespace): if namespace in self.pending_disconnect and \ sid in self.pending_disconnect[namespace]: # the client is in the process of being disconnected return False try: return self.rooms[namespace][None][sid] is not None except KeyError: pass return False def sid_from_eio_sid(self, eio_sid, namespace): try: return self.rooms[namespace][None]._invm[eio_sid] except KeyError: pass def eio_sid_from_sid(self, sid, namespace): if namespace in self.rooms: return self.rooms[namespace][None].get(sid) def can_disconnect(self, sid, namespace): return self.is_connected(sid, namespace) def pre_disconnect(self, sid, namespace): """Put the client in the to-be-disconnected list. This allows the client data structures to be present while the disconnect handler is invoked, but still recognize the fact that the client is soon going away. """ if namespace not in self.pending_disconnect: self.pending_disconnect[namespace] = [] self.pending_disconnect[namespace].append(sid) return self.rooms[namespace][None].get(sid) def disconnect(self, sid, namespace, **kwargs): """Register a client disconnect from a namespace.""" if namespace not in self.rooms: return rooms = [] for room_name, room in self.rooms[namespace].copy().items(): if sid in room: rooms.append(room_name) for room in rooms: self.leave_room(sid, namespace, room) if sid in self.callbacks: del self.callbacks[sid] if namespace in self.pending_disconnect and \ sid in self.pending_disconnect[namespace]: self.pending_disconnect[namespace].remove(sid) if len(self.pending_disconnect[namespace]) == 0: del self.pending_disconnect[namespace] def enter_room(self, sid, namespace, room, eio_sid=None): """Add a client to a room.""" if eio_sid is None and namespace not in self.rooms: raise ValueError('sid is not connected to requested namespace') if namespace not in self.rooms: self.rooms[namespace] = {} if room not in self.rooms[namespace]: self.rooms[namespace][room] = bidict() if eio_sid is None: eio_sid = self.rooms[namespace][None][sid] self.rooms[namespace][room][sid] = eio_sid def leave_room(self, sid, namespace, room): """Remove a client from a room.""" try: del self.rooms[namespace][room][sid] if len(self.rooms[namespace][room]) == 0: del self.rooms[namespace][room] if len(self.rooms[namespace]) == 0: del self.rooms[namespace] except KeyError: pass def close_room(self, room, namespace): """Remove all participants from a room.""" try: for sid, _ in self.get_participants(namespace, room): self.leave_room(sid, namespace, room) except KeyError: pass def get_rooms(self, sid, namespace): """Return the rooms a client is in.""" r = [] try: for room_name, room in self.rooms[namespace].items(): if room_name is not None and sid in room: r.append(room_name) except KeyError: pass return r def emit(self, event, data, namespace, room=None, skip_sid=None, callback=None, **kwargs): """Emit a message to a single client, a room, or all the clients connected to the namespace.""" if namespace not in self.rooms: return if not isinstance(skip_sid, list): skip_sid = [skip_sid] for sid, eio_sid in self.get_participants(namespace, room): if sid not in skip_sid: if callback is not None: id = self._generate_ack_id(sid, callback) else: id = None self.server._emit_internal(eio_sid, event, data, namespace, id) def trigger_callback(self, sid, id, data): """Invoke an application callback.""" callback = None try: callback = self.callbacks[sid][id] except KeyError: # if we get an unknown callback we just ignore it self._get_logger().warning('Unknown callback received, ignoring.') else: del self.callbacks[sid][id] if callback is not None: callback(*data) def _generate_ack_id(self, sid, callback): """Generate a unique identifier for an ACK packet.""" if sid not in self.callbacks: self.callbacks[sid] = {0: itertools.count(1)} id = next(self.callbacks[sid][0]) self.callbacks[sid][id] = callback return id def _get_logger(self): """Get the appropriate logger Prevents uninitialized servers in write-only mode from failing. """ if self.logger: return self.logger elif self.server: return self.server.logger else: return default_logger ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1643458093.0 python-socketio-5.7.2/src/socketio/client.py0000644000076600000240000007744714175227055021056 0ustar00mgrinbergstaffimport itertools import logging import random import signal import threading import engineio from . import exceptions from . import namespace from . import packet default_logger = logging.getLogger('socketio.client') reconnecting_clients = [] def signal_handler(sig, frame): # pragma: no cover """SIGINT handler. Notify any clients that are in a reconnect loop to abort. Other disconnection tasks are handled at the engine.io level. """ for client in reconnecting_clients[:]: client._reconnect_abort.set() if callable(original_signal_handler): return original_signal_handler(sig, frame) else: # pragma: no cover # Handle case where no original SIGINT handler was present. return signal.default_int_handler(sig, frame) original_signal_handler = None class Client(object): """A Socket.IO client. This class implements a fully compliant Socket.IO web client with support for websocket and long-polling transports. :param reconnection: ``True`` if the client should automatically attempt to reconnect to the server after an interruption, or ``False`` to not reconnect. The default is ``True``. :param reconnection_attempts: How many reconnection attempts to issue before giving up, or 0 for infinite attempts. The default is 0. :param reconnection_delay: How long to wait in seconds before the first reconnection attempt. Each successive attempt doubles this delay. :param reconnection_delay_max: The maximum delay between reconnection attempts. :param randomization_factor: Randomization amount for each delay between reconnection attempts. The default is 0.5, which means that each delay is randomly adjusted by +/- 50%. :param logger: To enable logging set to ``True`` or pass a logger object to use. To disable logging set to ``False``. The default is ``False``. Note that fatal errors are logged even when ``logger`` is ``False``. :param serializer: The serialization method to use when transmitting packets. Valid values are ``'default'``, ``'pickle'``, ``'msgpack'`` and ``'cbor'``. Alternatively, a subclass of the :class:`Packet` class with custom implementations of the ``encode()`` and ``decode()`` methods can be provided. Client and server must use compatible serializers. :param json: An alternative json module to use for encoding and decoding packets. Custom json modules must have ``dumps`` and ``loads`` functions that are compatible with the standard library versions. :param handle_sigint: Set to ``True`` to automatically handle disconnection when the process is interrupted, or to ``False`` to leave interrupt handling to the calling application. Interrupt handling can only be enabled when the client instance is created in the main thread. The Engine.IO configuration supports the following settings: :param request_timeout: A timeout in seconds for requests. The default is 5 seconds. :param http_session: an initialized ``requests.Session`` object to be used when sending requests to the server. Use it if you need to add special client options such as proxy servers, SSL certificates, etc. :param ssl_verify: ``True`` to verify SSL certificates, or ``False`` to skip SSL certificate verification, allowing connections to servers with self signed certificates. The default is ``True``. :param engineio_logger: To enable Engine.IO logging set to ``True`` or pass a logger object to use. To disable logging set to ``False``. The default is ``False``. Note that fatal errors are logged even when ``engineio_logger`` is ``False``. """ reserved_events = ['connect', 'connect_error', 'disconnect'] def __init__(self, reconnection=True, reconnection_attempts=0, reconnection_delay=1, reconnection_delay_max=5, randomization_factor=0.5, logger=False, serializer='default', json=None, handle_sigint=True, **kwargs): global original_signal_handler if handle_sigint and original_signal_handler is None and \ threading.current_thread() == threading.main_thread(): original_signal_handler = signal.signal(signal.SIGINT, signal_handler) self.reconnection = reconnection self.reconnection_attempts = reconnection_attempts self.reconnection_delay = reconnection_delay self.reconnection_delay_max = reconnection_delay_max self.randomization_factor = randomization_factor self.handle_sigint = handle_sigint engineio_options = kwargs engineio_options['handle_sigint'] = handle_sigint engineio_logger = engineio_options.pop('engineio_logger', None) if engineio_logger is not None: engineio_options['logger'] = engineio_logger if serializer == 'default': self.packet_class = packet.Packet elif serializer == 'msgpack': from . import msgpack_packet self.packet_class = msgpack_packet.MsgPackPacket else: self.packet_class = serializer if json is not None: self.packet_class.json = json engineio_options['json'] = json self.eio = self._engineio_client_class()(**engineio_options) self.eio.on('connect', self._handle_eio_connect) self.eio.on('message', self._handle_eio_message) self.eio.on('disconnect', self._handle_eio_disconnect) if not isinstance(logger, bool): self.logger = logger else: self.logger = default_logger if self.logger.level == logging.NOTSET: if logger: self.logger.setLevel(logging.INFO) else: self.logger.setLevel(logging.ERROR) self.logger.addHandler(logging.StreamHandler()) self.connection_url = None self.connection_headers = None self.connection_auth = None self.connection_transports = None self.connection_namespaces = [] self.socketio_path = None self.sid = None self.connected = False #: Indicates if the client is connected or not. self.namespaces = {} #: set of connected namespaces. self.handlers = {} self.namespace_handlers = {} self.callbacks = {} self._binary_packet = None self._connect_event = None self._reconnect_task = None self._reconnect_abort = None def is_asyncio_based(self): return False def on(self, event, handler=None, namespace=None): """Register an event handler. :param event: The event name. It can be any string. The event names ``'connect'``, ``'message'`` and ``'disconnect'`` are reserved and should not be used. :param handler: The function that should be invoked to handle the event. When this parameter is not given, the method acts as a decorator for the handler function. :param namespace: The Socket.IO namespace for the event. If this argument is omitted the handler is associated with the default namespace. Example usage:: # as a decorator: @sio.on('connect') def connect_handler(): print('Connected!') # as a method: def message_handler(msg): print('Received message: ', msg) sio.send( 'response') sio.on('message', message_handler) The ``'connect'`` event handler receives no arguments. The ``'message'`` handler and handlers for custom event names receive the message payload as only argument. Any values returned from a message handler will be passed to the client's acknowledgement callback function if it exists. The ``'disconnect'`` handler does not take arguments. """ namespace = namespace or '/' def set_handler(handler): if namespace not in self.handlers: self.handlers[namespace] = {} self.handlers[namespace][event] = handler return handler if handler is None: return set_handler set_handler(handler) def event(self, *args, **kwargs): """Decorator to register an event handler. This is a simplified version of the ``on()`` method that takes the event name from the decorated function. Example usage:: @sio.event def my_event(data): print('Received data: ', data) The above example is equivalent to:: @sio.on('my_event') def my_event(data): print('Received data: ', data) A custom namespace can be given as an argument to the decorator:: @sio.event(namespace='/test') def my_event(data): print('Received data: ', data) """ if len(args) == 1 and len(kwargs) == 0 and callable(args[0]): # the decorator was invoked without arguments # args[0] is the decorated function return self.on(args[0].__name__)(args[0]) else: # the decorator was invoked with arguments def set_handler(handler): return self.on(handler.__name__, *args, **kwargs)(handler) return set_handler def register_namespace(self, namespace_handler): """Register a namespace handler object. :param namespace_handler: An instance of a :class:`Namespace` subclass that handles all the event traffic for a namespace. """ if not isinstance(namespace_handler, namespace.ClientNamespace): raise ValueError('Not a namespace instance') if self.is_asyncio_based() != namespace_handler.is_asyncio_based(): raise ValueError('Not a valid namespace class for this client') namespace_handler._set_client(self) self.namespace_handlers[namespace_handler.namespace] = \ namespace_handler def connect(self, url, headers={}, auth=None, transports=None, namespaces=None, socketio_path='socket.io', wait=True, wait_timeout=1): """Connect to a Socket.IO server. :param url: The URL of the Socket.IO server. It can include custom query string parameters if required by the server. If a function is provided, the client will invoke it to obtain the URL each time a connection or reconnection is attempted. :param headers: A dictionary with custom headers to send with the connection request. If a function is provided, the client will invoke it to obtain the headers dictionary each time a connection or reconnection is attempted. :param auth: Authentication data passed to the server with the connection request, normally a dictionary with one or more string key/value pairs. If a function is provided, the client will invoke it to obtain the authentication data each time a connection or reconnection is attempted. :param transports: The list of allowed transports. Valid transports are ``'polling'`` and ``'websocket'``. If not given, the polling transport is connected first, then an upgrade to websocket is attempted. :param namespaces: The namespaces to connect as a string or list of strings. If not given, the namespaces that have registered event handlers are connected. :param socketio_path: The endpoint where the Socket.IO server is installed. The default value is appropriate for most cases. :param wait: if set to ``True`` (the default) the call only returns when all the namespaces are connected. If set to ``False``, the call returns as soon as the Engine.IO transport is connected, and the namespaces will connect in the background. :param wait_timeout: How long the client should wait for the connection. The default is 1 second. This argument is only considered when ``wait`` is set to ``True``. Example usage:: sio = socketio.Client() sio.connect('http://localhost:5000') """ if self.connected: raise exceptions.ConnectionError('Already connected') self.connection_url = url self.connection_headers = headers self.connection_auth = auth self.connection_transports = transports self.connection_namespaces = namespaces self.socketio_path = socketio_path if namespaces is None: namespaces = list(set(self.handlers.keys()).union( set(self.namespace_handlers.keys()))) if len(namespaces) == 0: namespaces = ['/'] elif isinstance(namespaces, str): namespaces = [namespaces] self.connection_namespaces = namespaces self.namespaces = {} if self._connect_event is None: self._connect_event = self.eio.create_event() else: self._connect_event.clear() real_url = self._get_real_value(self.connection_url) real_headers = self._get_real_value(self.connection_headers) try: self.eio.connect(real_url, headers=real_headers, transports=transports, engineio_path=socketio_path) except engineio.exceptions.ConnectionError as exc: self._trigger_event( 'connect_error', '/', exc.args[1] if len(exc.args) > 1 else exc.args[0]) raise exceptions.ConnectionError(exc.args[0]) from None if wait: while self._connect_event.wait(timeout=wait_timeout): self._connect_event.clear() if set(self.namespaces) == set(self.connection_namespaces): break if set(self.namespaces) != set(self.connection_namespaces): self.disconnect() raise exceptions.ConnectionError( 'One or more namespaces failed to connect') self.connected = True def wait(self): """Wait until the connection with the server ends. Client applications can use this function to block the main thread during the life of the connection. """ while True: self.eio.wait() self.sleep(1) # give the reconnect task time to start up if not self._reconnect_task: break self._reconnect_task.join() if self.eio.state != 'connected': break def emit(self, event, data=None, namespace=None, callback=None): """Emit a custom event to one or more connected clients. :param event: The event name. It can be any string. The event names ``'connect'``, ``'message'`` and ``'disconnect'`` are reserved and should not be used. :param data: The data to send to the server. Data can be of type ``str``, ``bytes``, ``list`` or ``dict``. To send multiple arguments, use a tuple where each element is of one of the types indicated above. :param namespace: The Socket.IO namespace for the event. If this argument is omitted the event is emitted to the default namespace. :param callback: If given, this function will be called to acknowledge the the server has received the message. The arguments that will be passed to the function are those provided by the server. Note: this method is not thread safe. If multiple threads are emitting at the same time on the same client connection, messages composed of multiple packets may end up being sent in an incorrect sequence. Use standard concurrency solutions (such as a Lock object) to prevent this situation. """ namespace = namespace or '/' if namespace not in self.namespaces: raise exceptions.BadNamespaceError( namespace + ' is not a connected namespace.') self.logger.info('Emitting event "%s" [%s]', event, namespace) if callback is not None: id = self._generate_ack_id(namespace, callback) else: id = None # tuples are expanded to multiple arguments, everything else is sent # as a single argument if isinstance(data, tuple): data = list(data) elif data is not None: data = [data] else: data = [] self._send_packet(self.packet_class(packet.EVENT, namespace=namespace, data=[event] + data, id=id)) def send(self, data, namespace=None, callback=None): """Send a message to one or more connected clients. This function emits an event with the name ``'message'``. Use :func:`emit` to issue custom event names. :param data: The data to send to the server. Data can be of type ``str``, ``bytes``, ``list`` or ``dict``. To send multiple arguments, use a tuple where each element is of one of the types indicated above. :param namespace: The Socket.IO namespace for the event. If this argument is omitted the event is emitted to the default namespace. :param callback: If given, this function will be called to acknowledge the the server has received the message. The arguments that will be passed to the function are those provided by the server. """ self.emit('message', data=data, namespace=namespace, callback=callback) def call(self, event, data=None, namespace=None, timeout=60): """Emit a custom event to a client and wait for the response. This method issues an emit with a callback and waits for the callback to be invoked before returning. If the callback isn't invoked before the timeout, then a ``TimeoutError`` exception is raised. If the Socket.IO connection drops during the wait, this method still waits until the specified timeout. :param event: The event name. It can be any string. The event names ``'connect'``, ``'message'`` and ``'disconnect'`` are reserved and should not be used. :param data: The data to send to the server. Data can be of type ``str``, ``bytes``, ``list`` or ``dict``. To send multiple arguments, use a tuple where each element is of one of the types indicated above. :param namespace: The Socket.IO namespace for the event. If this argument is omitted the event is emitted to the default namespace. :param timeout: The waiting timeout. If the timeout is reached before the client acknowledges the event, then a ``TimeoutError`` exception is raised. Note: this method is not thread safe. If multiple threads are emitting at the same time on the same client connection, messages composed of multiple packets may end up being sent in an incorrect sequence. Use standard concurrency solutions (such as a Lock object) to prevent this situation. """ callback_event = self.eio.create_event() callback_args = [] def event_callback(*args): callback_args.append(args) callback_event.set() self.emit(event, data=data, namespace=namespace, callback=event_callback) if not callback_event.wait(timeout=timeout): raise exceptions.TimeoutError() return callback_args[0] if len(callback_args[0]) > 1 \ else callback_args[0][0] if len(callback_args[0]) == 1 \ else None def disconnect(self): """Disconnect from the server.""" # here we just request the disconnection # later in _handle_eio_disconnect we invoke the disconnect handler for n in self.namespaces: self._send_packet(self.packet_class( packet.DISCONNECT, namespace=n)) self.eio.disconnect(abort=True) def get_sid(self, namespace=None): """Return the ``sid`` associated with a connection. :param namespace: The Socket.IO namespace. If this argument is omitted the handler is associated with the default namespace. Note that unlike previous versions, the current version of the Socket.IO protocol uses different ``sid`` values per namespace. This method returns the ``sid`` for the requested namespace as a string. """ return self.namespaces.get(namespace or '/') def transport(self): """Return the name of the transport used by the client. The two possible values returned by this function are ``'polling'`` and ``'websocket'``. """ return self.eio.transport() def start_background_task(self, target, *args, **kwargs): """Start a background task using the appropriate async model. This is a utility function that applications can use to start a background task using the method that is compatible with the selected async mode. :param target: the target function to execute. :param args: arguments to pass to the function. :param kwargs: keyword arguments to pass to the function. This function returns an object that represents the background task, on which the ``join()`` methond can be invoked to wait for the task to complete. """ return self.eio.start_background_task(target, *args, **kwargs) def sleep(self, seconds=0): """Sleep for the requested amount of time using the appropriate async model. This is a utility function that applications can use to put a task to sleep without having to worry about using the correct call for the selected async mode. """ return self.eio.sleep(seconds) def _get_real_value(self, value): """Return the actual value, for parameters that can also be given as callables.""" if not callable(value): return value return value() def _send_packet(self, pkt): """Send a Socket.IO packet to the server.""" encoded_packet = pkt.encode() if isinstance(encoded_packet, list): for ep in encoded_packet: self.eio.send(ep) else: self.eio.send(encoded_packet) def _generate_ack_id(self, namespace, callback): """Generate a unique identifier for an ACK packet.""" namespace = namespace or '/' if namespace not in self.callbacks: self.callbacks[namespace] = {0: itertools.count(1)} id = next(self.callbacks[namespace][0]) self.callbacks[namespace][id] = callback return id def _handle_connect(self, namespace, data): namespace = namespace or '/' if namespace not in self.namespaces: self.logger.info('Namespace {} is connected'.format(namespace)) self.namespaces[namespace] = (data or {}).get('sid', self.sid) self._trigger_event('connect', namespace=namespace) self._connect_event.set() def _handle_disconnect(self, namespace): if not self.connected: return namespace = namespace or '/' self._trigger_event('disconnect', namespace=namespace) if namespace in self.namespaces: del self.namespaces[namespace] if not self.namespaces: self.connected = False self.eio.disconnect(abort=True) def _handle_event(self, namespace, id, data): namespace = namespace or '/' self.logger.info('Received event "%s" [%s]', data[0], namespace) r = self._trigger_event(data[0], namespace, *data[1:]) if id is not None: # send ACK packet with the response returned by the handler # tuples are expanded as multiple arguments if r is None: data = [] elif isinstance(r, tuple): data = list(r) else: data = [r] self._send_packet(self.packet_class( packet.ACK, namespace=namespace, id=id, data=data)) def _handle_ack(self, namespace, id, data): namespace = namespace or '/' self.logger.info('Received ack [%s]', namespace) callback = None try: callback = self.callbacks[namespace][id] except KeyError: # if we get an unknown callback we just ignore it self.logger.warning('Unknown callback received, ignoring.') else: del self.callbacks[namespace][id] if callback is not None: callback(*data) def _handle_error(self, namespace, data): namespace = namespace or '/' self.logger.info('Connection to namespace {} was rejected'.format( namespace)) if data is None: data = tuple() elif not isinstance(data, (tuple, list)): data = (data,) self._trigger_event('connect_error', namespace, *data) self._connect_event.set() if namespace in self.namespaces: del self.namespaces[namespace] if namespace == '/': self.namespaces = {} self.connected = False def _trigger_event(self, event, namespace, *args): """Invoke an application event handler.""" # first see if we have an explicit handler for the event if namespace in self.handlers: if event in self.handlers[namespace]: return self.handlers[namespace][event](*args) elif event not in self.reserved_events and \ '*' in self.handlers[namespace]: return self.handlers[namespace]['*'](event, *args) # or else, forward the event to a namespace handler if one exists elif namespace in self.namespace_handlers: return self.namespace_handlers[namespace].trigger_event( event, *args) def _handle_reconnect(self): if self._reconnect_abort is None: # pragma: no cover self._reconnect_abort = self.eio.create_event() self._reconnect_abort.clear() reconnecting_clients.append(self) attempt_count = 0 current_delay = self.reconnection_delay while True: delay = current_delay current_delay *= 2 if delay > self.reconnection_delay_max: delay = self.reconnection_delay_max delay += self.randomization_factor * (2 * random.random() - 1) self.logger.info( 'Connection failed, new attempt in {:.02f} seconds'.format( delay)) if self._reconnect_abort.wait(delay): self.logger.info('Reconnect task aborted') break attempt_count += 1 try: self.connect(self.connection_url, headers=self.connection_headers, auth=self.connection_auth, transports=self.connection_transports, namespaces=self.connection_namespaces, socketio_path=self.socketio_path) except (exceptions.ConnectionError, ValueError): pass else: self.logger.info('Reconnection successful') self._reconnect_task = None break if self.reconnection_attempts and \ attempt_count >= self.reconnection_attempts: self.logger.info( 'Maximum reconnection attempts reached, giving up') break reconnecting_clients.remove(self) def _handle_eio_connect(self): """Handle the Engine.IO connection event.""" self.logger.info('Engine.IO connection established') self.sid = self.eio.sid real_auth = self._get_real_value(self.connection_auth) or {} for n in self.connection_namespaces: self._send_packet(self.packet_class( packet.CONNECT, data=real_auth, namespace=n)) def _handle_eio_message(self, data): """Dispatch Engine.IO messages.""" if self._binary_packet: pkt = self._binary_packet if pkt.add_attachment(data): self._binary_packet = None if pkt.packet_type == packet.BINARY_EVENT: self._handle_event(pkt.namespace, pkt.id, pkt.data) else: self._handle_ack(pkt.namespace, pkt.id, pkt.data) else: pkt = self.packet_class(encoded_packet=data) if pkt.packet_type == packet.CONNECT: self._handle_connect(pkt.namespace, pkt.data) elif pkt.packet_type == packet.DISCONNECT: self._handle_disconnect(pkt.namespace) elif pkt.packet_type == packet.EVENT: self._handle_event(pkt.namespace, pkt.id, pkt.data) elif pkt.packet_type == packet.ACK: self._handle_ack(pkt.namespace, pkt.id, pkt.data) elif pkt.packet_type == packet.BINARY_EVENT or \ pkt.packet_type == packet.BINARY_ACK: self._binary_packet = pkt elif pkt.packet_type == packet.CONNECT_ERROR: self._handle_error(pkt.namespace, pkt.data) else: raise ValueError('Unknown packet type.') def _handle_eio_disconnect(self): """Handle the Engine.IO disconnection event.""" self.logger.info('Engine.IO connection dropped') if self.connected: for n in self.namespaces: self._trigger_event('disconnect', namespace=n) self.namespaces = {} self.connected = False self.callbacks = {} self._binary_packet = None self.sid = None if self.eio.state == 'connected' and self.reconnection: self._reconnect_task = self.start_background_task( self._handle_reconnect) def _engineio_client_class(self): return engineio.Client ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1613953058.0 python-socketio-5.7.2/src/socketio/exceptions.py0000644000076600000240000000163414014574042021733 0ustar00mgrinbergstaffclass SocketIOError(Exception): pass class ConnectionError(SocketIOError): pass class ConnectionRefusedError(ConnectionError): """Connection refused exception. This exception can be raised from a connect handler when the connection is not accepted. The positional arguments provided with the exception are returned with the error packet to the client. """ def __init__(self, *args): if len(args) == 0: self.error_args = {'message': 'Connection rejected by server'} elif len(args) == 1: self.error_args = {'message': str(args[0])} else: self.error_args = {'message': str(args[0])} if len(args) == 2: self.error_args['data'] = args[1] else: self.error_args['data'] = args[1:] class TimeoutError(SocketIOError): pass class BadNamespaceError(SocketIOError): pass ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1641424526.0 python-socketio-5.7.2/src/socketio/kafka_manager.py0000644000076600000240000000466014165423216022326 0ustar00mgrinbergstaffimport logging import pickle try: import kafka except ImportError: kafka = None from .pubsub_manager import PubSubManager logger = logging.getLogger('socketio') class KafkaManager(PubSubManager): # pragma: no cover """Kafka based client manager. This class implements a Kafka backend for event sharing across multiple processes. To use a Kafka backend, initialize the :class:`Server` instance as follows:: url = 'kafka://hostname:port' server = socketio.Server(client_manager=socketio.KafkaManager(url)) :param url: The connection URL for the Kafka server. For a default Kafka store running on the same host, use ``kafka://``. For a highly available deployment of Kafka, pass a list with all the connection URLs available in your cluster. :param channel: The channel name (topic) on which the server sends and receives notifications. Must be the same in all the servers. :param write_only: If set to ``True``, only initialize to emit events. The default of ``False`` initializes the class for emitting and receiving. """ name = 'kafka' def __init__(self, url='kafka://localhost:9092', channel='socketio', write_only=False): if kafka is None: raise RuntimeError('kafka-python package is not installed ' '(Run "pip install kafka-python" in your ' 'virtualenv).') super(KafkaManager, self).__init__(channel=channel, write_only=write_only) urls = [url] if isinstance(url, str) else url self.kafka_urls = [url[8:] if url != 'kafka://' else 'localhost:9092' for url in urls] self.producer = kafka.KafkaProducer(bootstrap_servers=self.kafka_urls) self.consumer = kafka.KafkaConsumer(self.channel, bootstrap_servers=self.kafka_urls) def _publish(self, data): self.producer.send(self.channel, value=pickle.dumps(data)) self.producer.flush() def _kafka_listen(self): for message in self.consumer: yield message def _listen(self): for message in self._kafka_listen(): if message.topic == self.channel: yield pickle.loads(message.value) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1613953058.0 python-socketio-5.7.2/src/socketio/kombu_manager.py0000644000076600000240000001226214014574042022360 0ustar00mgrinbergstaffimport pickle import uuid try: import kombu except ImportError: kombu = None from .pubsub_manager import PubSubManager class KombuManager(PubSubManager): # pragma: no cover """Client manager that uses kombu for inter-process messaging. This class implements a client manager backend for event sharing across multiple processes, using RabbitMQ, Redis or any other messaging mechanism supported by `kombu `_. To use a kombu backend, initialize the :class:`Server` instance as follows:: url = 'amqp://user:password@hostname:port//' server = socketio.Server(client_manager=socketio.KombuManager(url)) :param url: The connection URL for the backend messaging queue. Example connection URLs are ``'amqp://guest:guest@localhost:5672//'`` and ``'redis://localhost:6379/'`` for RabbitMQ and Redis respectively. Consult the `kombu documentation `_ for more on how to construct connection URLs. :param channel: The channel name on which the server sends and receives notifications. Must be the same in all the servers. :param write_only: If set to ``True``, only initialize to emit events. The default of ``False`` initializes the class for emitting and receiving. :param connection_options: additional keyword arguments to be passed to ``kombu.Connection()``. :param exchange_options: additional keyword arguments to be passed to ``kombu.Exchange()``. :param queue_options: additional keyword arguments to be passed to ``kombu.Queue()``. :param producer_options: additional keyword arguments to be passed to ``kombu.Producer()``. """ name = 'kombu' def __init__(self, url='amqp://guest:guest@localhost:5672//', channel='socketio', write_only=False, logger=None, connection_options=None, exchange_options=None, queue_options=None, producer_options=None): if kombu is None: raise RuntimeError('Kombu package is not installed ' '(Run "pip install kombu" in your ' 'virtualenv).') super(KombuManager, self).__init__(channel=channel, write_only=write_only, logger=logger) self.url = url self.connection_options = connection_options or {} self.exchange_options = exchange_options or {} self.queue_options = queue_options or {} self.producer_options = producer_options or {} self.producer = self._producer() def initialize(self): super(KombuManager, self).initialize() monkey_patched = True if self.server.async_mode == 'eventlet': from eventlet.patcher import is_monkey_patched monkey_patched = is_monkey_patched('socket') elif 'gevent' in self.server.async_mode: from gevent.monkey import is_module_patched monkey_patched = is_module_patched('socket') if not monkey_patched: raise RuntimeError( 'Kombu requires a monkey patched socket library to work ' 'with ' + self.server.async_mode) def _connection(self): return kombu.Connection(self.url, **self.connection_options) def _exchange(self): options = {'type': 'fanout', 'durable': False} options.update(self.exchange_options) return kombu.Exchange(self.channel, **options) def _queue(self): queue_name = 'flask-socketio.' + str(uuid.uuid4()) options = {'durable': False, 'queue_arguments': {'x-expires': 300000}} options.update(self.queue_options) return kombu.Queue(queue_name, self._exchange(), **options) def _producer(self): return self._connection().Producer(exchange=self._exchange(), **self.producer_options) def __error_callback(self, exception, interval): self._get_logger().exception('Sleeping {}s'.format(interval)) def _publish(self, data): connection = self._connection() publish = connection.ensure(self.producer, self.producer.publish, errback=self.__error_callback) publish(pickle.dumps(data)) def _listen(self): reader_queue = self._queue() while True: connection = self._connection().ensure_connection( errback=self.__error_callback) try: with connection.SimpleQueue(reader_queue) as queue: while True: message = queue.get(block=True) message.ack() yield message.payload except connection.connection_errors: self._get_logger().exception("Connection error " "while reading from queue") ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1606905134.0 python-socketio-5.7.2/src/socketio/middleware.py0000644000076600000240000000326013761666456021707 0ustar00mgrinbergstaffimport engineio class WSGIApp(engineio.WSGIApp): """WSGI middleware for Socket.IO. This middleware dispatches traffic to a Socket.IO application. It can also serve a list of static files to the client, or forward unrelated HTTP traffic to another WSGI application. :param socketio_app: The Socket.IO server. Must be an instance of the ``socketio.Server`` class. :param wsgi_app: The WSGI app that receives all other traffic. :param static_files: A dictionary with static file mapping rules. See the documentation for details on this argument. :param socketio_path: The endpoint where the Socket.IO application should be installed. The default value is appropriate for most cases. Example usage:: import socketio import eventlet from . import wsgi_app sio = socketio.Server() app = socketio.WSGIApp(sio, wsgi_app) eventlet.wsgi.server(eventlet.listen(('', 8000)), app) """ def __init__(self, socketio_app, wsgi_app=None, static_files=None, socketio_path='socket.io'): super(WSGIApp, self).__init__(socketio_app, wsgi_app, static_files=static_files, engineio_path=socketio_path) class Middleware(WSGIApp): """This class has been renamed to WSGIApp and is now deprecated.""" def __init__(self, socketio_app, wsgi_app=None, socketio_path='socket.io'): super(Middleware, self).__init__(socketio_app, wsgi_app, socketio_path=socketio_path) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1660575712.0 python-socketio-5.7.2/src/socketio/msgpack_packet.py0000644000076600000240000000100214276457740022532 0ustar00mgrinbergstaffimport msgpack from . import packet class MsgPackPacket(packet.Packet): uses_binary_events = False def encode(self): """Encode the packet for transmission.""" return msgpack.dumps(self._to_dict()) def decode(self, encoded_packet): """Decode a transmitted package.""" decoded = msgpack.loads(encoded_packet) self.packet_type = decoded['type'] self.data = decoded.get('data') self.id = decoded.get('id') self.namespace = decoded['nsp'] ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635102846.0 python-socketio-5.7.2/src/socketio/namespace.py0000644000076600000240000002152214135330176021506 0ustar00mgrinbergstaffclass BaseNamespace(object): def __init__(self, namespace=None): self.namespace = namespace or '/' def is_asyncio_based(self): return False def trigger_event(self, event, *args): """Dispatch an event to the proper handler method. In the most common usage, this method is not overloaded by subclasses, as it performs the routing of events to methods. However, this method can be overridden if special dispatching rules are needed, or if having a single method that catches all events is desired. """ handler_name = 'on_' + event if hasattr(self, handler_name): return getattr(self, handler_name)(*args) class Namespace(BaseNamespace): """Base class for server-side class-based namespaces. A class-based namespace is a class that contains all the event handlers for a Socket.IO namespace. The event handlers are methods of the class with the prefix ``on_``, such as ``on_connect``, ``on_disconnect``, ``on_message``, ``on_json``, and so on. :param namespace: The Socket.IO namespace to be used with all the event handlers defined in this class. If this argument is omitted, the default namespace is used. """ def __init__(self, namespace=None): super(Namespace, self).__init__(namespace=namespace) self.server = None def _set_server(self, server): self.server = server def emit(self, event, data=None, to=None, room=None, skip_sid=None, namespace=None, callback=None): """Emit a custom event to one or more connected clients. The only difference with the :func:`socketio.Server.emit` method is that when the ``namespace`` argument is not given the namespace associated with the class is used. """ return self.server.emit(event, data=data, to=to, room=room, skip_sid=skip_sid, namespace=namespace or self.namespace, callback=callback) def send(self, data, to=None, room=None, skip_sid=None, namespace=None, callback=None): """Send a message to one or more connected clients. The only difference with the :func:`socketio.Server.send` method is that when the ``namespace`` argument is not given the namespace associated with the class is used. """ return self.server.send(data, to=to, room=room, skip_sid=skip_sid, namespace=namespace or self.namespace, callback=callback) def call(self, event, data=None, to=None, sid=None, namespace=None, timeout=None): """Emit a custom event to a client and wait for the response. The only difference with the :func:`socketio.Server.call` method is that when the ``namespace`` argument is not given the namespace associated with the class is used. """ return self.server.call(event, data=data, to=to, sid=sid, namespace=namespace or self.namespace, timeout=timeout) def enter_room(self, sid, room, namespace=None): """Enter a room. The only difference with the :func:`socketio.Server.enter_room` method is that when the ``namespace`` argument is not given the namespace associated with the class is used. """ return self.server.enter_room(sid, room, namespace=namespace or self.namespace) def leave_room(self, sid, room, namespace=None): """Leave a room. The only difference with the :func:`socketio.Server.leave_room` method is that when the ``namespace`` argument is not given the namespace associated with the class is used. """ return self.server.leave_room(sid, room, namespace=namespace or self.namespace) def close_room(self, room, namespace=None): """Close a room. The only difference with the :func:`socketio.Server.close_room` method is that when the ``namespace`` argument is not given the namespace associated with the class is used. """ return self.server.close_room(room, namespace=namespace or self.namespace) def rooms(self, sid, namespace=None): """Return the rooms a client is in. The only difference with the :func:`socketio.Server.rooms` method is that when the ``namespace`` argument is not given the namespace associated with the class is used. """ return self.server.rooms(sid, namespace=namespace or self.namespace) def get_session(self, sid, namespace=None): """Return the user session for a client. The only difference with the :func:`socketio.Server.get_session` method is that when the ``namespace`` argument is not given the namespace associated with the class is used. """ return self.server.get_session( sid, namespace=namespace or self.namespace) def save_session(self, sid, session, namespace=None): """Store the user session for a client. The only difference with the :func:`socketio.Server.save_session` method is that when the ``namespace`` argument is not given the namespace associated with the class is used. """ return self.server.save_session( sid, session, namespace=namespace or self.namespace) def session(self, sid, namespace=None): """Return the user session for a client with context manager syntax. The only difference with the :func:`socketio.Server.session` method is that when the ``namespace`` argument is not given the namespace associated with the class is used. """ return self.server.session(sid, namespace=namespace or self.namespace) def disconnect(self, sid, namespace=None): """Disconnect a client. The only difference with the :func:`socketio.Server.disconnect` method is that when the ``namespace`` argument is not given the namespace associated with the class is used. """ return self.server.disconnect(sid, namespace=namespace or self.namespace) class ClientNamespace(BaseNamespace): """Base class for client-side class-based namespaces. A class-based namespace is a class that contains all the event handlers for a Socket.IO namespace. The event handlers are methods of the class with the prefix ``on_``, such as ``on_connect``, ``on_disconnect``, ``on_message``, ``on_json``, and so on. :param namespace: The Socket.IO namespace to be used with all the event handlers defined in this class. If this argument is omitted, the default namespace is used. """ def __init__(self, namespace=None): super(ClientNamespace, self).__init__(namespace=namespace) self.client = None def _set_client(self, client): self.client = client def emit(self, event, data=None, namespace=None, callback=None): """Emit a custom event to the server. The only difference with the :func:`socketio.Client.emit` method is that when the ``namespace`` argument is not given the namespace associated with the class is used. """ return self.client.emit(event, data=data, namespace=namespace or self.namespace, callback=callback) def send(self, data, room=None, namespace=None, callback=None): """Send a message to the server. The only difference with the :func:`socketio.Client.send` method is that when the ``namespace`` argument is not given the namespace associated with the class is used. """ return self.client.send(data, namespace=namespace or self.namespace, callback=callback) def call(self, event, data=None, namespace=None, timeout=None): """Emit a custom event to the server and wait for the response. The only difference with the :func:`socketio.Client.call` method is that when the ``namespace`` argument is not given the namespace associated with the class is used. """ return self.client.call(event, data=data, namespace=namespace or self.namespace, timeout=timeout) def disconnect(self): """Disconnect from the server. The only difference with the :func:`socketio.Client.disconnect` method is that when the ``namespace`` argument is not given the namespace associated with the class is used. """ return self.client.disconnect() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635377342.0 python-socketio-5.7.2/src/socketio/packet.py0000644000076600000240000001563114136360276021032 0ustar00mgrinbergstaffimport functools from engineio import json as _json (CONNECT, DISCONNECT, EVENT, ACK, CONNECT_ERROR, BINARY_EVENT, BINARY_ACK) = \ (0, 1, 2, 3, 4, 5, 6) packet_names = ['CONNECT', 'DISCONNECT', 'EVENT', 'ACK', 'CONNECT_ERROR', 'BINARY_EVENT', 'BINARY_ACK'] class Packet(object): """Socket.IO packet.""" # the format of the Socket.IO packet is as follows: # # packet type: 1 byte, values 0-6 # num_attachments: ASCII encoded, only if num_attachments != 0 # '-': only if num_attachments != 0 # namespace, followed by a ',': only if namespace != '/' # id: ASCII encoded, only if id is not None # data: JSON dump of data payload uses_binary_events = True json = _json def __init__(self, packet_type=EVENT, data=None, namespace=None, id=None, binary=None, encoded_packet=None): self.packet_type = packet_type self.data = data self.namespace = namespace self.id = id if self.uses_binary_events and \ (binary or (binary is None and self._data_is_binary( self.data))): if self.packet_type == EVENT: self.packet_type = BINARY_EVENT elif self.packet_type == ACK: self.packet_type = BINARY_ACK else: raise ValueError('Packet does not support binary payload.') self.attachment_count = 0 self.attachments = [] if encoded_packet: self.attachment_count = self.decode(encoded_packet) or 0 def encode(self): """Encode the packet for transmission. If the packet contains binary elements, this function returns a list of packets where the first is the original packet with placeholders for the binary components and the remaining ones the binary attachments. """ encoded_packet = str(self.packet_type) if self.packet_type == BINARY_EVENT or self.packet_type == BINARY_ACK: data, attachments = self._deconstruct_binary(self.data) encoded_packet += str(len(attachments)) + '-' else: data = self.data attachments = None if self.namespace is not None and self.namespace != '/': encoded_packet += self.namespace + ',' if self.id is not None: encoded_packet += str(self.id) if data is not None: encoded_packet += self.json.dumps(data, separators=(',', ':')) if attachments is not None: encoded_packet = [encoded_packet] + attachments return encoded_packet def decode(self, encoded_packet): """Decode a transmitted package. The return value indicates how many binary attachment packets are necessary to fully decode the packet. """ ep = encoded_packet try: self.packet_type = int(ep[0:1]) except TypeError: self.packet_type = ep ep = '' self.namespace = None self.data = None ep = ep[1:] dash = ep.find('-') attachment_count = 0 if dash > 0 and ep[0:dash].isdigit(): if dash > 10: raise ValueError('too many attachments') attachment_count = int(ep[0:dash]) ep = ep[dash + 1:] if ep and ep[0:1] == '/': sep = ep.find(',') if sep == -1: self.namespace = ep ep = '' else: self.namespace = ep[0:sep] ep = ep[sep + 1:] q = self.namespace.find('?') if q != -1: self.namespace = self.namespace[0:q] if ep and ep[0].isdigit(): i = 1 end = len(ep) while i < end: if not ep[i].isdigit() or i >= 100: break i += 1 self.id = int(ep[:i]) ep = ep[i:] if len(ep) > 0 and ep[0].isdigit(): raise ValueError('id field is too long') if ep: self.data = self.json.loads(ep) return attachment_count def add_attachment(self, attachment): if self.attachment_count <= len(self.attachments): raise ValueError('Unexpected binary attachment') self.attachments.append(attachment) if self.attachment_count == len(self.attachments): self.reconstruct_binary(self.attachments) return True return False def reconstruct_binary(self, attachments): """Reconstruct a decoded packet using the given list of binary attachments. """ self.data = self._reconstruct_binary_internal(self.data, self.attachments) def _reconstruct_binary_internal(self, data, attachments): if isinstance(data, list): return [self._reconstruct_binary_internal(item, attachments) for item in data] elif isinstance(data, dict): if data.get('_placeholder') and 'num' in data: return attachments[data['num']] else: return {key: self._reconstruct_binary_internal(value, attachments) for key, value in data.items()} else: return data def _deconstruct_binary(self, data): """Extract binary components in the packet.""" attachments = [] data = self._deconstruct_binary_internal(data, attachments) return data, attachments def _deconstruct_binary_internal(self, data, attachments): if isinstance(data, bytes): attachments.append(data) return {'_placeholder': True, 'num': len(attachments) - 1} elif isinstance(data, list): return [self._deconstruct_binary_internal(item, attachments) for item in data] elif isinstance(data, dict): return {key: self._deconstruct_binary_internal(value, attachments) for key, value in data.items()} else: return data def _data_is_binary(self, data): """Check if the data contains binary components.""" if isinstance(data, bytes): return True elif isinstance(data, list): return functools.reduce( lambda a, b: a or b, [self._data_is_binary(item) for item in data], False) elif isinstance(data, dict): return functools.reduce( lambda a, b: a or b, [self._data_is_binary(item) for item in data.values()], False) else: return False def _to_dict(self): d = { 'type': self.packet_type, 'data': self.data, 'nsp': self.namespace, } if self.id: d['id'] = self.id return d ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1660575712.0 python-socketio-5.7.2/src/socketio/pubsub_manager.py0000644000076600000240000001667114276457740022572 0ustar00mgrinbergstafffrom functools import partial import uuid from engineio import json import pickle from .base_manager import BaseManager class PubSubManager(BaseManager): """Manage a client list attached to a pub/sub backend. This is a base class that enables multiple servers to share the list of clients, with the servers communicating events through a pub/sub backend. The use of a pub/sub backend also allows any client connected to the backend to emit events addressed to Socket.IO clients. The actual backends must be implemented by subclasses, this class only provides a pub/sub generic framework. :param channel: The channel name on which the server sends and receives notifications. """ name = 'pubsub' def __init__(self, channel='socketio', write_only=False, logger=None): super(PubSubManager, self).__init__() self.channel = channel self.write_only = write_only self.host_id = uuid.uuid4().hex self.logger = logger def initialize(self): super(PubSubManager, self).initialize() if not self.write_only: self.thread = self.server.start_background_task(self._thread) self._get_logger().info(self.name + ' backend initialized.') def emit(self, event, data, namespace=None, room=None, skip_sid=None, callback=None, **kwargs): """Emit a message to a single client, a room, or all the clients connected to the namespace. This method takes care or propagating the message to all the servers that are connected through the message queue. The parameters are the same as in :meth:`.Server.emit`. """ if kwargs.get('ignore_queue'): return super(PubSubManager, self).emit( event, data, namespace=namespace, room=room, skip_sid=skip_sid, callback=callback) namespace = namespace or '/' if callback is not None: if self.server is None: raise RuntimeError('Callbacks can only be issued from the ' 'context of a server.') if room is None: raise ValueError('Cannot use callback without a room set.') id = self._generate_ack_id(room, callback) callback = (room, namespace, id) else: callback = None self._publish({'method': 'emit', 'event': event, 'data': data, 'namespace': namespace, 'room': room, 'skip_sid': skip_sid, 'callback': callback, 'host_id': self.host_id}) def can_disconnect(self, sid, namespace): if self.is_connected(sid, namespace): # client is in this server, so we can disconnect directly return super().can_disconnect(sid, namespace) else: # client is in another server, so we post request to the queue self._publish({'method': 'disconnect', 'sid': sid, 'namespace': namespace or '/'}) def disconnect(self, sid, namespace=None, **kwargs): if kwargs.get('ignore_queue'): return super(PubSubManager, self).disconnect( sid, namespace=namespace) self._publish({'method': 'disconnect', 'sid': sid, 'namespace': namespace or '/'}) def close_room(self, room, namespace=None): self._publish({'method': 'close_room', 'room': room, 'namespace': namespace or '/'}) def _publish(self, data): """Publish a message on the Socket.IO channel. This method needs to be implemented by the different subclasses that support pub/sub backends. """ raise NotImplementedError('This method must be implemented in a ' 'subclass.') # pragma: no cover def _listen(self): """Return the next message published on the Socket.IO channel, blocking until a message is available. This method needs to be implemented by the different subclasses that support pub/sub backends. """ raise NotImplementedError('This method must be implemented in a ' 'subclass.') # pragma: no cover def _handle_emit(self, message): # Events with callbacks are very tricky to handle across hosts # Here in the receiving end we set up a local callback that preserves # the callback host and id from the sender remote_callback = message.get('callback') remote_host_id = message.get('host_id') if remote_callback is not None and len(remote_callback) == 3: callback = partial(self._return_callback, remote_host_id, *remote_callback) else: callback = None super(PubSubManager, self).emit(message['event'], message['data'], namespace=message.get('namespace'), room=message.get('room'), skip_sid=message.get('skip_sid'), callback=callback) def _handle_callback(self, message): if self.host_id == message.get('host_id'): try: sid = message['sid'] id = message['id'] args = message['args'] except KeyError: return self.trigger_callback(sid, id, args) def _return_callback(self, host_id, sid, namespace, callback_id, *args): # When an event callback is received, the callback is returned back # to the sender, which is identified by the host_id self._publish({'method': 'callback', 'host_id': host_id, 'sid': sid, 'namespace': namespace, 'id': callback_id, 'args': args}) def _handle_disconnect(self, message): self.server.disconnect(sid=message.get('sid'), namespace=message.get('namespace'), ignore_queue=True) def _handle_close_room(self, message): super(PubSubManager, self).close_room( room=message.get('room'), namespace=message.get('namespace')) def _thread(self): for message in self._listen(): data = None if isinstance(message, dict): data = message else: if isinstance(message, bytes): # pragma: no cover try: data = pickle.loads(message) except: pass if data is None: try: data = json.loads(message) except: pass if data and 'method' in data: self._get_logger().info('pubsub message: {}'.format( data['method'])) try: if data['method'] == 'emit': self._handle_emit(data) elif data['method'] == 'callback': self._handle_callback(data) elif data['method'] == 'disconnect': self._handle_disconnect(data) elif data['method'] == 'close_room': self._handle_close_room(data) except: self.server.logger.exception( 'Unknown error in pubsub listening thread') ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1636895247.0 python-socketio-5.7.2/src/socketio/redis_manager.py0000644000076600000240000001072414144205017022347 0ustar00mgrinbergstaffimport logging import pickle import time try: import redis except ImportError: redis = None from .pubsub_manager import PubSubManager logger = logging.getLogger('socketio') class RedisManager(PubSubManager): # pragma: no cover """Redis based client manager. This class implements a Redis backend for event sharing across multiple processes. Only kept here as one more example of how to build a custom backend, since the kombu backend is perfectly adequate to support a Redis message queue. To use a Redis backend, initialize the :class:`Server` instance as follows:: url = 'redis://hostname:port/0' server = socketio.Server(client_manager=socketio.RedisManager(url)) :param url: The connection URL for the Redis server. For a default Redis store running on the same host, use ``redis://``. To use an SSL connection, use ``rediss://``. :param channel: The channel name on which the server sends and receives notifications. Must be the same in all the servers. :param write_only: If set to ``True``, only initialize to emit events. The default of ``False`` initializes the class for emitting and receiving. :param redis_options: additional keyword arguments to be passed to ``Redis.from_url()``. """ name = 'redis' def __init__(self, url='redis://localhost:6379/0', channel='socketio', write_only=False, logger=None, redis_options=None): if redis is None: raise RuntimeError('Redis package is not installed ' '(Run "pip install redis" in your ' 'virtualenv).') self.redis_url = url self.redis_options = redis_options or {} self._redis_connect() super(RedisManager, self).__init__(channel=channel, write_only=write_only, logger=logger) def initialize(self): super(RedisManager, self).initialize() monkey_patched = True if self.server.async_mode == 'eventlet': from eventlet.patcher import is_monkey_patched monkey_patched = is_monkey_patched('socket') elif 'gevent' in self.server.async_mode: from gevent.monkey import is_module_patched monkey_patched = is_module_patched('socket') if not monkey_patched: raise RuntimeError( 'Redis requires a monkey patched socket library to work ' 'with ' + self.server.async_mode) def _redis_connect(self): self.redis = redis.Redis.from_url(self.redis_url, **self.redis_options) self.pubsub = self.redis.pubsub(ignore_subscribe_messages=True) def _publish(self, data): retry = True while True: try: if not retry: self._redis_connect() return self.redis.publish(self.channel, pickle.dumps(data)) except redis.exceptions.RedisError: if retry: logger.error('Cannot publish to redis... retrying') retry = False else: logger.error('Cannot publish to redis... giving up') break def _redis_listen_with_retries(self): retry_sleep = 1 connect = False while True: try: if connect: self._redis_connect() self.pubsub.subscribe(self.channel) retry_sleep = 1 for message in self.pubsub.listen(): yield message except redis.exceptions.RedisError: logger.error('Cannot receive from redis... ' 'retrying in {} secs'.format(retry_sleep)) connect = True time.sleep(retry_sleep) retry_sleep *= 2 if retry_sleep > 60: retry_sleep = 60 def _listen(self): channel = self.channel.encode('utf-8') self.pubsub.subscribe(self.channel) for message in self._redis_listen_with_retries(): if message['channel'] == channel and \ message['type'] == 'message' and 'data' in message: yield message['data'] self.pubsub.unsubscribe(self.channel) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1660575712.0 python-socketio-5.7.2/src/socketio/server.py0000644000076600000240000011420414276457740021075 0ustar00mgrinbergstaffimport logging import engineio from . import base_manager from . import exceptions from . import namespace from . import packet default_logger = logging.getLogger('socketio.server') class Server(object): """A Socket.IO server. This class implements a fully compliant Socket.IO web server with support for websocket and long-polling transports. :param client_manager: The client manager instance that will manage the client list. When this is omitted, the client list is stored in an in-memory structure, so the use of multiple connected servers is not possible. :param logger: To enable logging set to ``True`` or pass a logger object to use. To disable logging set to ``False``. The default is ``False``. Note that fatal errors are logged even when ``logger`` is ``False``. :param serializer: The serialization method to use when transmitting packets. Valid values are ``'default'``, ``'pickle'``, ``'msgpack'`` and ``'cbor'``. Alternatively, a subclass of the :class:`Packet` class with custom implementations of the ``encode()`` and ``decode()`` methods can be provided. Client and server must use compatible serializers. :param json: An alternative json module to use for encoding and decoding packets. Custom json modules must have ``dumps`` and ``loads`` functions that are compatible with the standard library versions. :param async_handlers: If set to ``True``, event handlers for a client are executed in separate threads. To run handlers for a client synchronously, set to ``False``. The default is ``True``. :param always_connect: When set to ``False``, new connections are provisory until the connect handler returns something other than ``False``, at which point they are accepted. When set to ``True``, connections are immediately accepted, and then if the connect handler returns ``False`` a disconnect is issued. Set to ``True`` if you need to emit events from the connect handler and your client is confused when it receives events before the connection acceptance. In any other case use the default of ``False``. :param namespaces: a list of namespaces that are accepted, in addition to any namespaces for which handlers have been defined. The default is `['/']`, which always accepts connections to the default namespace. Set to `'*'` to accept all namespaces. :param kwargs: Connection parameters for the underlying Engine.IO server. The Engine.IO configuration supports the following settings: :param async_mode: The asynchronous model to use. See the Deployment section in the documentation for a description of the available options. Valid async modes are ``'threading'``, ``'eventlet'``, ``'gevent'`` and ``'gevent_uwsgi'``. If this argument is not given, ``'eventlet'`` is tried first, then ``'gevent_uwsgi'``, then ``'gevent'``, and finally ``'threading'``. The first async mode that has all its dependencies installed is then one that is chosen. :param ping_interval: The interval in seconds at which the server pings the client. The default is 25 seconds. For advanced control, a two element tuple can be given, where the first number is the ping interval and the second is a grace period added by the server. :param ping_timeout: The time in seconds that the client waits for the server to respond before disconnecting. The default is 5 seconds. :param max_http_buffer_size: The maximum size of a message when using the polling transport. The default is 1,000,000 bytes. :param allow_upgrades: Whether to allow transport upgrades or not. The default is ``True``. :param http_compression: Whether to compress packages when using the polling transport. The default is ``True``. :param compression_threshold: Only compress messages when their byte size is greater than this value. The default is 1024 bytes. :param cookie: If set to a string, it is the name of the HTTP cookie the server sends back tot he client containing the client session id. If set to a dictionary, the ``'name'`` key contains the cookie name and other keys define cookie attributes, where the value of each attribute can be a string, a callable with no arguments, or a boolean. If set to ``None`` (the default), a cookie is not sent to the client. :param cors_allowed_origins: Origin or list of origins that are allowed to connect to this server. Only the same origin is allowed by default. Set this argument to ``'*'`` to allow all origins, or to ``[]`` to disable CORS handling. :param cors_credentials: Whether credentials (cookies, authentication) are allowed in requests to this server. The default is ``True``. :param monitor_clients: If set to ``True``, a background task will ensure inactive clients are closed. Set to ``False`` to disable the monitoring task (not recommended). The default is ``True``. :param engineio_logger: To enable Engine.IO logging set to ``True`` or pass a logger object to use. To disable logging set to ``False``. The default is ``False``. Note that fatal errors are logged even when ``engineio_logger`` is ``False``. """ reserved_events = ['connect', 'disconnect'] def __init__(self, client_manager=None, logger=False, serializer='default', json=None, async_handlers=True, always_connect=False, namespaces=None, **kwargs): engineio_options = kwargs engineio_logger = engineio_options.pop('engineio_logger', None) if engineio_logger is not None: engineio_options['logger'] = engineio_logger if serializer == 'default': self.packet_class = packet.Packet elif serializer == 'msgpack': from . import msgpack_packet self.packet_class = msgpack_packet.MsgPackPacket else: self.packet_class = serializer if json is not None: self.packet_class.json = json engineio_options['json'] = json engineio_options['async_handlers'] = False self.eio = self._engineio_server_class()(**engineio_options) self.eio.on('connect', self._handle_eio_connect) self.eio.on('message', self._handle_eio_message) self.eio.on('disconnect', self._handle_eio_disconnect) self.environ = {} self.handlers = {} self.namespace_handlers = {} self.not_handled = object() self._binary_packet = {} if not isinstance(logger, bool): self.logger = logger else: self.logger = default_logger if self.logger.level == logging.NOTSET: if logger: self.logger.setLevel(logging.INFO) else: self.logger.setLevel(logging.ERROR) self.logger.addHandler(logging.StreamHandler()) if client_manager is None: client_manager = base_manager.BaseManager() self.manager = client_manager self.manager.set_server(self) self.manager_initialized = False self.async_handlers = async_handlers self.always_connect = always_connect self.namespaces = namespaces or ['/'] self.async_mode = self.eio.async_mode def is_asyncio_based(self): return False def on(self, event, handler=None, namespace=None): """Register an event handler. :param event: The event name. It can be any string. The event names ``'connect'``, ``'message'`` and ``'disconnect'`` are reserved and should not be used. :param handler: The function that should be invoked to handle the event. When this parameter is not given, the method acts as a decorator for the handler function. :param namespace: The Socket.IO namespace for the event. If this argument is omitted the handler is associated with the default namespace. Example usage:: # as a decorator: @socket_io.on('connect', namespace='/chat') def connect_handler(sid, environ): print('Connection request') if environ['REMOTE_ADDR'] in blacklisted: return False # reject # as a method: def message_handler(sid, msg): print('Received message: ', msg) eio.send(sid, 'response') socket_io.on('message', namespace='/chat', handler=message_handler) The handler function receives the ``sid`` (session ID) for the client as first argument. The ``'connect'`` event handler receives the WSGI environment as a second argument, and can return ``False`` to reject the connection. The ``'message'`` handler and handlers for custom event names receive the message payload as a second argument. Any values returned from a message handler will be passed to the client's acknowledgement callback function if it exists. The ``'disconnect'`` handler does not take a second argument. """ namespace = namespace or '/' def set_handler(handler): if namespace not in self.handlers: self.handlers[namespace] = {} self.handlers[namespace][event] = handler return handler if handler is None: return set_handler set_handler(handler) def event(self, *args, **kwargs): """Decorator to register an event handler. This is a simplified version of the ``on()`` method that takes the event name from the decorated function. Example usage:: @sio.event def my_event(data): print('Received data: ', data) The above example is equivalent to:: @sio.on('my_event') def my_event(data): print('Received data: ', data) A custom namespace can be given as an argument to the decorator:: @sio.event(namespace='/test') def my_event(data): print('Received data: ', data) """ if len(args) == 1 and len(kwargs) == 0 and callable(args[0]): # the decorator was invoked without arguments # args[0] is the decorated function return self.on(args[0].__name__)(args[0]) else: # the decorator was invoked with arguments def set_handler(handler): return self.on(handler.__name__, *args, **kwargs)(handler) return set_handler def register_namespace(self, namespace_handler): """Register a namespace handler object. :param namespace_handler: An instance of a :class:`Namespace` subclass that handles all the event traffic for a namespace. """ if not isinstance(namespace_handler, namespace.Namespace): raise ValueError('Not a namespace instance') if self.is_asyncio_based() != namespace_handler.is_asyncio_based(): raise ValueError('Not a valid namespace class for this server') namespace_handler._set_server(self) self.namespace_handlers[namespace_handler.namespace] = \ namespace_handler def emit(self, event, data=None, to=None, room=None, skip_sid=None, namespace=None, callback=None, **kwargs): """Emit a custom event to one or more connected clients. :param event: The event name. It can be any string. The event names ``'connect'``, ``'message'`` and ``'disconnect'`` are reserved and should not be used. :param data: The data to send to the client or clients. Data can be of type ``str``, ``bytes``, ``list`` or ``dict``. To send multiple arguments, use a tuple where each element is of one of the types indicated above. :param to: The recipient of the message. This can be set to the session ID of a client to address only that client, to any any custom room created by the application to address all the clients in that room, or to a list of custom room names. If this argument is omitted the event is broadcasted to all connected clients. :param room: Alias for the ``to`` parameter. :param skip_sid: The session ID of a client to skip when broadcasting to a room or to all clients. This can be used to prevent a message from being sent to the sender. To skip multiple sids, pass a list. :param namespace: The Socket.IO namespace for the event. If this argument is omitted the event is emitted to the default namespace. :param callback: If given, this function will be called to acknowledge the the client has received the message. The arguments that will be passed to the function are those provided by the client. Callback functions can only be used when addressing an individual client. :param ignore_queue: Only used when a message queue is configured. If set to ``True``, the event is emitted to the clients directly, without going through the queue. This is more efficient, but only works when a single server process is used. It is recommended to always leave this parameter with its default value of ``False``. Note: this method is not thread safe. If multiple threads are emitting at the same time to the same client, then messages composed of multiple packets may end up being sent in an incorrect sequence. Use standard concurrency solutions (such as a Lock object) to prevent this situation. """ namespace = namespace or '/' room = to or room self.logger.info('emitting event "%s" to %s [%s]', event, room or 'all', namespace) self.manager.emit(event, data, namespace, room=room, skip_sid=skip_sid, callback=callback, **kwargs) def send(self, data, to=None, room=None, skip_sid=None, namespace=None, callback=None, **kwargs): """Send a message to one or more connected clients. This function emits an event with the name ``'message'``. Use :func:`emit` to issue custom event names. :param data: The data to send to the client or clients. Data can be of type ``str``, ``bytes``, ``list`` or ``dict``. To send multiple arguments, use a tuple where each element is of one of the types indicated above. :param to: The recipient of the message. This can be set to the session ID of a client to address only that client, to any any custom room created by the application to address all the clients in that room, or to a list of custom room names. If this argument is omitted the event is broadcasted to all connected clients. :param room: Alias for the ``to`` parameter. :param skip_sid: The session ID of a client to skip when broadcasting to a room or to all clients. This can be used to prevent a message from being sent to the sender. To skip multiple sids, pass a list. :param namespace: The Socket.IO namespace for the event. If this argument is omitted the event is emitted to the default namespace. :param callback: If given, this function will be called to acknowledge the the client has received the message. The arguments that will be passed to the function are those provided by the client. Callback functions can only be used when addressing an individual client. :param ignore_queue: Only used when a message queue is configured. If set to ``True``, the event is emitted to the clients directly, without going through the queue. This is more efficient, but only works when a single server process is used. It is recommended to always leave this parameter with its default value of ``False``. """ self.emit('message', data=data, to=to, room=room, skip_sid=skip_sid, namespace=namespace, callback=callback, **kwargs) def call(self, event, data=None, to=None, sid=None, namespace=None, timeout=60, **kwargs): """Emit a custom event to a client and wait for the response. This method issues an emit with a callback and waits for the callback to be invoked before returning. If the callback isn't invoked before the timeout, then a ``TimeoutError`` exception is raised. If the Socket.IO connection drops during the wait, this method still waits until the specified timeout. :param event: The event name. It can be any string. The event names ``'connect'``, ``'message'`` and ``'disconnect'`` are reserved and should not be used. :param data: The data to send to the client or clients. Data can be of type ``str``, ``bytes``, ``list`` or ``dict``. To send multiple arguments, use a tuple where each element is of one of the types indicated above. :param to: The session ID of the recipient client. :param sid: Alias for the ``to`` parameter. :param namespace: The Socket.IO namespace for the event. If this argument is omitted the event is emitted to the default namespace. :param timeout: The waiting timeout. If the timeout is reached before the client acknowledges the event, then a ``TimeoutError`` exception is raised. :param ignore_queue: Only used when a message queue is configured. If set to ``True``, the event is emitted to the client directly, without going through the queue. This is more efficient, but only works when a single server process is used. It is recommended to always leave this parameter with its default value of ``False``. Note: this method is not thread safe. If multiple threads are emitting at the same time to the same client, then messages composed of multiple packets may end up being sent in an incorrect sequence. Use standard concurrency solutions (such as a Lock object) to prevent this situation. """ if to is None and sid is None: raise ValueError('Cannot use call() to broadcast.') if not self.async_handlers: raise RuntimeError( 'Cannot use call() when async_handlers is False.') callback_event = self.eio.create_event() callback_args = [] def event_callback(*args): callback_args.append(args) callback_event.set() self.emit(event, data=data, room=to or sid, namespace=namespace, callback=event_callback, **kwargs) if not callback_event.wait(timeout=timeout): raise exceptions.TimeoutError() return callback_args[0] if len(callback_args[0]) > 1 \ else callback_args[0][0] if len(callback_args[0]) == 1 \ else None def enter_room(self, sid, room, namespace=None): """Enter a room. This function adds the client to a room. The :func:`emit` and :func:`send` functions can optionally broadcast events to all the clients in a room. :param sid: Session ID of the client. :param room: Room name. If the room does not exist it is created. :param namespace: The Socket.IO namespace for the event. If this argument is omitted the default namespace is used. """ namespace = namespace or '/' self.logger.info('%s is entering room %s [%s]', sid, room, namespace) self.manager.enter_room(sid, namespace, room) def leave_room(self, sid, room, namespace=None): """Leave a room. This function removes the client from a room. :param sid: Session ID of the client. :param room: Room name. :param namespace: The Socket.IO namespace for the event. If this argument is omitted the default namespace is used. """ namespace = namespace or '/' self.logger.info('%s is leaving room %s [%s]', sid, room, namespace) self.manager.leave_room(sid, namespace, room) def close_room(self, room, namespace=None): """Close a room. This function removes all the clients from the given room. :param room: Room name. :param namespace: The Socket.IO namespace for the event. If this argument is omitted the default namespace is used. """ namespace = namespace or '/' self.logger.info('room %s is closing [%s]', room, namespace) self.manager.close_room(room, namespace) def rooms(self, sid, namespace=None): """Return the rooms a client is in. :param sid: Session ID of the client. :param namespace: The Socket.IO namespace for the event. If this argument is omitted the default namespace is used. """ namespace = namespace or '/' return self.manager.get_rooms(sid, namespace) def get_session(self, sid, namespace=None): """Return the user session for a client. :param sid: The session id of the client. :param namespace: The Socket.IO namespace. If this argument is omitted the default namespace is used. The return value is a dictionary. Modifications made to this dictionary are not guaranteed to be preserved unless ``save_session()`` is called, or when the ``session`` context manager is used. """ namespace = namespace or '/' eio_sid = self.manager.eio_sid_from_sid(sid, namespace) eio_session = self.eio.get_session(eio_sid) return eio_session.setdefault(namespace, {}) def save_session(self, sid, session, namespace=None): """Store the user session for a client. :param sid: The session id of the client. :param session: The session dictionary. :param namespace: The Socket.IO namespace. If this argument is omitted the default namespace is used. """ namespace = namespace or '/' eio_sid = self.manager.eio_sid_from_sid(sid, namespace) eio_session = self.eio.get_session(eio_sid) eio_session[namespace] = session def session(self, sid, namespace=None): """Return the user session for a client with context manager syntax. :param sid: The session id of the client. This is a context manager that returns the user session dictionary for the client. Any changes that are made to this dictionary inside the context manager block are saved back to the session. Example usage:: @sio.on('connect') def on_connect(sid, environ): username = authenticate_user(environ) if not username: return False with sio.session(sid) as session: session['username'] = username @sio.on('message') def on_message(sid, msg): with sio.session(sid) as session: print('received message from ', session['username']) """ class _session_context_manager(object): def __init__(self, server, sid, namespace): self.server = server self.sid = sid self.namespace = namespace self.session = None def __enter__(self): self.session = self.server.get_session(sid, namespace=namespace) return self.session def __exit__(self, *args): self.server.save_session(sid, self.session, namespace=namespace) return _session_context_manager(self, sid, namespace) def disconnect(self, sid, namespace=None, ignore_queue=False): """Disconnect a client. :param sid: Session ID of the client. :param namespace: The Socket.IO namespace to disconnect. If this argument is omitted the default namespace is used. :param ignore_queue: Only used when a message queue is configured. If set to ``True``, the disconnect is processed locally, without broadcasting on the queue. It is recommended to always leave this parameter with its default value of ``False``. """ namespace = namespace or '/' if ignore_queue: delete_it = self.manager.is_connected(sid, namespace) else: delete_it = self.manager.can_disconnect(sid, namespace) if delete_it: self.logger.info('Disconnecting %s [%s]', sid, namespace) eio_sid = self.manager.pre_disconnect(sid, namespace=namespace) self._send_packet(eio_sid, self.packet_class( packet.DISCONNECT, namespace=namespace)) self._trigger_event('disconnect', namespace, sid) self.manager.disconnect(sid, namespace=namespace, ignore_queue=True) def transport(self, sid): """Return the name of the transport used by the client. The two possible values returned by this function are ``'polling'`` and ``'websocket'``. :param sid: The session of the client. """ return self.eio.transport(sid) def get_environ(self, sid, namespace=None): """Return the WSGI environ dictionary for a client. :param sid: The session of the client. :param namespace: The Socket.IO namespace. If this argument is omitted the default namespace is used. """ eio_sid = self.manager.eio_sid_from_sid(sid, namespace or '/') return self.environ.get(eio_sid) def handle_request(self, environ, start_response): """Handle an HTTP request from the client. This is the entry point of the Socket.IO application, using the same interface as a WSGI application. For the typical usage, this function is invoked by the :class:`Middleware` instance, but it can be invoked directly when the middleware is not used. :param environ: The WSGI environment. :param start_response: The WSGI ``start_response`` function. This function returns the HTTP response body to deliver to the client as a byte sequence. """ return self.eio.handle_request(environ, start_response) def start_background_task(self, target, *args, **kwargs): """Start a background task using the appropriate async model. This is a utility function that applications can use to start a background task using the method that is compatible with the selected async mode. :param target: the target function to execute. :param args: arguments to pass to the function. :param kwargs: keyword arguments to pass to the function. This function returns an object that represents the background task, on which the ``join()`` methond can be invoked to wait for the task to complete. """ return self.eio.start_background_task(target, *args, **kwargs) def sleep(self, seconds=0): """Sleep for the requested amount of time using the appropriate async model. This is a utility function that applications can use to put a task to sleep without having to worry about using the correct call for the selected async mode. """ return self.eio.sleep(seconds) def _emit_internal(self, eio_sid, event, data, namespace=None, id=None): """Send a message to a client.""" # tuples are expanded to multiple arguments, everything else is sent # as a single argument if isinstance(data, tuple): data = list(data) elif data is not None: data = [data] else: data = [] self._send_packet(eio_sid, self.packet_class( packet.EVENT, namespace=namespace, data=[event] + data, id=id)) def _send_packet(self, eio_sid, pkt): """Send a Socket.IO packet to a client.""" encoded_packet = pkt.encode() if isinstance(encoded_packet, list): for ep in encoded_packet: self.eio.send(eio_sid, ep) else: self.eio.send(eio_sid, encoded_packet) def _handle_connect(self, eio_sid, namespace, data): """Handle a client connection request.""" namespace = namespace or '/' sid = None if namespace in self.handlers or namespace in self.namespace_handlers \ or self.namespaces == '*' or namespace in self.namespaces: sid = self.manager.connect(eio_sid, namespace) if sid is None: self._send_packet(eio_sid, self.packet_class( packet.CONNECT_ERROR, data='Unable to connect', namespace=namespace)) return if self.always_connect: self._send_packet(eio_sid, self.packet_class( packet.CONNECT, {'sid': sid}, namespace=namespace)) fail_reason = exceptions.ConnectionRefusedError().error_args try: if data: success = self._trigger_event( 'connect', namespace, sid, self.environ[eio_sid], data) else: try: success = self._trigger_event( 'connect', namespace, sid, self.environ[eio_sid]) except TypeError: success = self._trigger_event( 'connect', namespace, sid, self.environ[eio_sid], None) except exceptions.ConnectionRefusedError as exc: fail_reason = exc.error_args success = False if success is False: if self.always_connect: self.manager.pre_disconnect(sid, namespace) self._send_packet(eio_sid, self.packet_class( packet.DISCONNECT, data=fail_reason, namespace=namespace)) else: self._send_packet(eio_sid, self.packet_class( packet.CONNECT_ERROR, data=fail_reason, namespace=namespace)) self.manager.disconnect(sid, namespace, ignore_queue=True) elif not self.always_connect: self._send_packet(eio_sid, self.packet_class( packet.CONNECT, {'sid': sid}, namespace=namespace)) def _handle_disconnect(self, eio_sid, namespace): """Handle a client disconnect.""" namespace = namespace or '/' sid = self.manager.sid_from_eio_sid(eio_sid, namespace) if not self.manager.is_connected(sid, namespace): # pragma: no cover return self.manager.pre_disconnect(sid, namespace=namespace) self._trigger_event('disconnect', namespace, sid) self.manager.disconnect(sid, namespace, ignore_queue=True) def _handle_event(self, eio_sid, namespace, id, data): """Handle an incoming client event.""" namespace = namespace or '/' sid = self.manager.sid_from_eio_sid(eio_sid, namespace) self.logger.info('received event "%s" from %s [%s]', data[0], sid, namespace) if not self.manager.is_connected(sid, namespace): self.logger.warning('%s is not connected to namespace %s', sid, namespace) return if self.async_handlers: self.start_background_task(self._handle_event_internal, self, sid, eio_sid, data, namespace, id) else: self._handle_event_internal(self, sid, eio_sid, data, namespace, id) def _handle_event_internal(self, server, sid, eio_sid, data, namespace, id): r = server._trigger_event(data[0], namespace, sid, *data[1:]) if r != self.not_handled and id is not None: # send ACK packet with the response returned by the handler # tuples are expanded as multiple arguments if r is None: data = [] elif isinstance(r, tuple): data = list(r) else: data = [r] server._send_packet(eio_sid, self.packet_class( packet.ACK, namespace=namespace, id=id, data=data)) def _handle_ack(self, eio_sid, namespace, id, data): """Handle ACK packets from the client.""" namespace = namespace or '/' sid = self.manager.sid_from_eio_sid(eio_sid, namespace) self.logger.info('received ack from %s [%s]', sid, namespace) self.manager.trigger_callback(sid, id, data) def _trigger_event(self, event, namespace, *args): """Invoke an application event handler.""" # first see if we have an explicit handler for the event if namespace in self.handlers: if event in self.handlers[namespace]: return self.handlers[namespace][event](*args) elif event not in self.reserved_events and \ '*' in self.handlers[namespace]: return self.handlers[namespace]['*'](event, *args) else: return self.not_handled # or else, forward the event to a namespace handler if one exists elif namespace in self.namespace_handlers: # pragma: no branch return self.namespace_handlers[namespace].trigger_event( event, *args) def _handle_eio_connect(self, eio_sid, environ): """Handle the Engine.IO connection event.""" if not self.manager_initialized: self.manager_initialized = True self.manager.initialize() self.environ[eio_sid] = environ def _handle_eio_message(self, eio_sid, data): """Dispatch Engine.IO messages.""" if eio_sid in self._binary_packet: pkt = self._binary_packet[eio_sid] if pkt.add_attachment(data): del self._binary_packet[eio_sid] if pkt.packet_type == packet.BINARY_EVENT: self._handle_event(eio_sid, pkt.namespace, pkt.id, pkt.data) else: self._handle_ack(eio_sid, pkt.namespace, pkt.id, pkt.data) else: pkt = self.packet_class(encoded_packet=data) if pkt.packet_type == packet.CONNECT: self._handle_connect(eio_sid, pkt.namespace, pkt.data) elif pkt.packet_type == packet.DISCONNECT: self._handle_disconnect(eio_sid, pkt.namespace) elif pkt.packet_type == packet.EVENT: self._handle_event(eio_sid, pkt.namespace, pkt.id, pkt.data) elif pkt.packet_type == packet.ACK: self._handle_ack(eio_sid, pkt.namespace, pkt.id, pkt.data) elif pkt.packet_type == packet.BINARY_EVENT or \ pkt.packet_type == packet.BINARY_ACK: self._binary_packet[eio_sid] = pkt elif pkt.packet_type == packet.CONNECT_ERROR: raise ValueError('Unexpected CONNECT_ERROR packet.') else: raise ValueError('Unknown packet type.') def _handle_eio_disconnect(self, eio_sid): """Handle Engine.IO disconnect event.""" for n in list(self.manager.get_namespaces()).copy(): self._handle_disconnect(eio_sid, n) if eio_sid in self.environ: del self.environ[eio_sid] def _engineio_server_class(self): return engineio.Server ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1574018283.0 python-socketio-5.7.2/src/socketio/tornado.py0000644000076600000240000000054513564316353021230 0ustar00mgrinbergstaffimport sys if sys.version_info >= (3, 5): try: from engineio.async_drivers.tornado import get_tornado_handler as \ get_engineio_handler except ImportError: # pragma: no cover get_engineio_handler = None def get_tornado_handler(socketio_server): # pragma: no cover return get_engineio_handler(socketio_server.eio) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1613953058.0 python-socketio-5.7.2/src/socketio/zmq_manager.py0000644000076600000240000000711514014574042022053 0ustar00mgrinbergstaffimport pickle import re try: import eventlet.green.zmq as zmq except ImportError: zmq = None from .pubsub_manager import PubSubManager class ZmqManager(PubSubManager): # pragma: no cover """zmq based client manager. NOTE: this zmq implementation should be considered experimental at this time. At this time, eventlet is required to use zmq. This class implements a zmq backend for event sharing across multiple processes. To use a zmq backend, initialize the :class:`Server` instance as follows:: url = 'zmq+tcp://hostname:port1+port2' server = socketio.Server(client_manager=socketio.ZmqManager(url)) :param url: The connection URL for the zmq message broker, which will need to be provided and running. :param channel: The channel name on which the server sends and receives notifications. Must be the same in all the servers. :param write_only: If set to ``True``, only initialize to emit events. The default of ``False`` initializes the class for emitting and receiving. A zmq message broker must be running for the zmq_manager to work. you can write your own or adapt one from the following simple broker below:: import zmq receiver = zmq.Context().socket(zmq.PULL) receiver.bind("tcp://*:5555") publisher = zmq.Context().socket(zmq.PUB) publisher.bind("tcp://*:5556") while True: publisher.send(receiver.recv()) """ name = 'zmq' def __init__(self, url='zmq+tcp://localhost:5555+5556', channel='socketio', write_only=False, logger=None): if zmq is None: raise RuntimeError('zmq package is not installed ' '(Run "pip install pyzmq" in your ' 'virtualenv).') r = re.compile(r':\d+\+\d+$') if not (url.startswith('zmq+tcp://') and r.search(url)): raise RuntimeError('unexpected connection string: ' + url) url = url.replace('zmq+', '') (sink_url, sub_port) = url.split('+') sink_port = sink_url.split(':')[-1] sub_url = sink_url.replace(sink_port, sub_port) sink = zmq.Context().socket(zmq.PUSH) sink.connect(sink_url) sub = zmq.Context().socket(zmq.SUB) sub.setsockopt_string(zmq.SUBSCRIBE, u'') sub.connect(sub_url) self.sink = sink self.sub = sub self.channel = channel super(ZmqManager, self).__init__(channel=channel, write_only=write_only, logger=logger) def _publish(self, data): pickled_data = pickle.dumps( { 'type': 'message', 'channel': self.channel, 'data': data } ) return self.sink.send(pickled_data) def zmq_listen(self): while True: response = self.sub.recv() if response is not None: yield response def _listen(self): for message in self.zmq_listen(): if isinstance(message, bytes): try: message = pickle.loads(message) except Exception: pass if isinstance(message, dict) and \ message['type'] == 'message' and \ message['channel'] == self.channel and \ 'data' in message: yield message['data'] return