diff --git a/.travis.yml b/.travis.yml index b0bc004..1db3eb1 100644 --- a/.travis.yml +++ b/.travis.yml @@ -8,13 +8,12 @@ before_install: - sudo apt-get install nodejs install: - npm install -G socket.io - - npm install -G http-proxy + - npm install -G yargs - pip install -U requests - pip install -U six - pip install -U websocket-client - pip install -U coverage before_script: - DEBUG=* node socketIO_client/tests/serve.js & - - DEBUG=* node socketIO_client/tests/proxy.js & - sleep 3 script: nosetests diff --git a/CHANGES.rst b/CHANGES.rst index b7e7cb1..8970d11 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -1,7 +1,26 @@ +0.6.5 +----- +- Updated wait loop to be more responsive under websocket transport + +0.6.4 +----- +- Fixed support for Python 3 +- Fixed thread cleanup + +0.6.3 +----- +- Upgraded to socket.io protocol 1.x for websocket transport +- Added locks to fix concurrency issues with polling transport +- Fixed SSL support + 0.6.1 ----- - Upgraded to socket.io protocol 1.x thanks to Sean Arietta and Joe Palmer +0.5.6 +----- +- Backported to support requests 0.8.2 + 0.5.5 ----- - Fixed reconnection in the event of server restart diff --git a/LICENSE b/LICENSE index 4e68cea..dca6c1b 100644 --- a/LICENSE +++ b/LICENSE @@ -1,7 +1,19 @@ Copyright (c) 2013 Roy Hyunjin Han and contributors -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: +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 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. +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. diff --git a/README.rst b/README.rst index 7edc2c3..4f544b2 100644 --- a/README.rst +++ b/README.rst @@ -6,6 +6,8 @@ socketIO-client =============== Here is a `socket.io `_ client library for Python. You can use it to write test code for your socket.io server. +Please note that this version implements `socket.io protocol 1.x `_, which is not backwards compatible. If you want to communicate using `socket.io protocol 0.9 `_ (which is compatible with `gevent-socketio `_), please use `socketIO-client 0.5.6 `_. + Installation ------------ @@ -33,7 +35,8 @@ Activate isolated environment. :: Launch your socket.io server. :: # Get package folder - PACKAGE_FOLDER=`python -c "import os, socketIO_client; print(os.path.dirname(socketIO_client.__file__))"` + PACKAGE_FOLDER=`python -c "import os, socketIO_client;\ + print(os.path.dirname(socketIO_client.__file__))"` # Start socket.io server DEBUG=* node $PACKAGE_FOLDER/tests/serve.js # Start proxy server in a separate terminal on the same machine @@ -135,7 +138,8 @@ Specify params, headers, cookies, proxies thanks to the `requests `_ wrote the `socket.io specification `_. +- `Guillermo Rauch `_ wrote the `socket.io specification `_. - `Hiroki Ohtani `_ wrote `websocket-client `_. - `rod `_ wrote a `prototype for a Python client to a socket.io server `_. - `Alexandre Bourget `_ wrote `gevent-socketio `_, which is a socket.io server written in Python. - `Paul Kienzle `_, `Zac Lee `_, `Josh VanderLinden `_, `Ian Fitzpatrick `_, `Lucas Klein `_, `Rui Chicoria `_, `Travis Odom `_, `Patrick Huber `_, `Brad Campbell `_, `Daniel `_, `Sean Arietta `_ submitted code to expand support of the socket.io protocol. - `Bernard Pratz `_, `Francis Bull `_ wrote prototypes to support xhr-polling and jsonp-polling. -- `Eric Chen `_, `Denis Zinevich `_, `Thiago Hersan `_, `Nayef Copty `_, `Jörgen Karlsson `_, `Branden Ghena `_ suggested ways to make the connection more robust. +- `Eric Chen `_, `Denis Zinevich `_, `Thiago Hersan `_, `Nayef Copty `_, `Jörgen Karlsson `_, `Branden Ghena `_, `Tim Landscheidt `_, `Matt Porritt `_ suggested ways to make the connection more robust. - `Merlijn van Deen `_, `Frederic Sureau `_, `Marcus Cobden `_, `Drew Hutchison `_, `wuurrd `_, `Adam Kecer `_, `Alex Monk `_, `Vishal P R `_, `John Vandenberg `_, `Thomas Grainger `_ proposed changes that make the library more friendly and practical for you! diff --git a/TODO.goals b/TODO.goals index 9fced70..d72b083 100644 --- a/TODO.goals +++ b/TODO.goals @@ -1,9 +1,48 @@ -Add Websocket transport - Update proxy to include websocket depending on argument - Use prepared request to get headers from http_session - Include https://github.com/invisibleroads/socketIO-client/issues/68 -Add test for on_reconnect using sarietta's bash scripts -Consider logging packets sent and received -Implement rooms #65 -Implement binary event -Implement binary ack += Consider supporting both protocols in the same library + https://github.com/invisibleroads/socketIO-client/issues/95 +Add binary support + https://github.com/invisibleroads/socketIO-client/pull/85 + https://github.com/invisibleroads/socketIO-client/issues/70 + https://github.com/invisibleroads/socketIO-client/issues/71 + https://github.com/invisibleroads/socketIO-client/issues/91 +Check requests dependency + https://github.com/invisibleroads/socketIO-client/issues/92 + https://github.com/invisibleroads/socketIO-client/pull/93 + https://github.com/invisibleroads/socketIO-client/commit/b288d89c15d452a30bfeb00f38494f59f71f5a43 +Check SSL + https://github.com/invisibleroads/socketIO-client/issues/86 + https://github.com/invisibleroads/socketIO-client/pull/87 +Look into invalid namespace handling + https://github.com/invisibleroads/socketIO-client/issues/84 +Check unicode issues + https://github.com/invisibleroads/socketIO-client/issues/81 +Check python3 support for socketIO-client 0.5.6 + https://github.com/invisibleroads/socketIO-client/issues/83 +Check OK assertion + https://github.com/invisibleroads/socketIO-client/issues/99 + https://github.com/invisibleroads/socketIO-client/pull/103 +Check why connected=True after termination + https://github.com/invisibleroads/socketIO-client/issues/80 + https://github.com/invisibleroads/socketIO-client/issues/98 +Consider catching heartbeat thread exception + https://github.com/invisibleroads/socketIO-client/issues/100 +Check why it blocks when defining a namespace + https://github.com/invisibleroads/socketIO-client/issues/96 +Check why transports are not being set + https://github.com/invisibleroads/socketIO-client/issues/102 +Look at 404 not found error + https://github.com/invisibleroads/socketIO-client/issues/101 +Look at socketio off and socketio once + https://github.com/invisibleroads/socketIO-client/pull/94 +Implement rooms + https://github.com/invisibleroads/socketIO-client/issues/72 + https://github.com/invisibleroads/socketIO-client/pull/65 +Check tests + https://github.com/invisibleroads/socketIO-client/issues/90 +Check whether it works on Windows 8 + https://github.com/invisibleroads/socketIO-client/issues/97 +Add debian packaging support + https://github.com/invisibleroads/socketIO-client/pull/89 + ++ Review issues and pull requests ++ Order issues diff --git a/setup.py b/setup.py index 51ab595..a2a00e3 100644 --- a/setup.py +++ b/setup.py @@ -1,3 +1,4 @@ +import io from os.path import abspath, dirname, join from setuptools import find_packages, setup @@ -10,13 +11,14 @@ REQUIREMENTS = [ HERE = dirname(abspath(__file__)) -DESCRIPTION = '\n\n'.join(open(join(HERE, _)).read() for _ in [ +LOAD_TEXT = lambda name: io.open(join(HERE, name), encoding='UTF-8').read() +DESCRIPTION = '\n\n'.join(LOAD_TEXT(_) for _ in [ 'README.rst', 'CHANGES.rst', ]) setup( name='socketIO_client', - version='0.6.1', + version='0.6.5', description='A socket.io client library', long_description=DESCRIPTION, license='MIT', @@ -24,6 +26,7 @@ setup( 'Intended Audience :: Developers', 'Programming Language :: Python', 'License :: OSI Approved :: MIT License', + 'Development Status :: 5 - Production/Stable', ], keywords='socket.io node.js', author='Roy Hyunjin Han', diff --git a/socketIO_client/__init__.py b/socketIO_client/__init__.py index 7518384..fbf2c7d 100644 --- a/socketIO_client/__init__.py +++ b/socketIO_client/__init__.py @@ -9,11 +9,12 @@ from .parsers import ( format_socketIO_packet_data, parse_socketIO_packet_data, get_namespace_path) from .symmetries import get_character -from .transports import XHR_PollingTransport, prepare_http_session, TRANSPORTS +from .transports import ( + WebsocketTransport, XHR_PollingTransport, prepare_http_session, TRANSPORTS) __all__ = 'SocketIO', 'SocketIONamespace' -__version__ = '0.6.1' +__version__ = '0.6.3' BaseNamespace = SocketIONamespace LoggingNamespace = LoggingSocketIONamespace @@ -39,10 +40,12 @@ class EngineIO(LoggingMixin): self._wait_for_connection = wait_for_connection self._client_transports = transports self._hurry_interval_in_seconds = hurry_interval_in_seconds - self._kw = kw + self._http_session = prepare_http_session(kw) + self._log_name = self._url self._wants_to_close = False self._opened = False + if Namespace: self.define(Namespace) self._transport @@ -54,7 +57,7 @@ class EngineIO(LoggingMixin): if self._opened: return self._transport_instance self._engineIO_session = self._get_engineIO_session() - self._transport_instance = self._negotiate_transport() + self._negotiate_transport() self._connect_namespaces() self._opened = True self._reset_heartbeat() @@ -62,7 +65,6 @@ class EngineIO(LoggingMixin): def _get_engineIO_session(self): warning_screen = self._yield_warning_screen() - self._http_session = prepare_http_session(self._kw) for elapsed_time in warning_screen: transport = XHR_PollingTransport( self._http_session, self._is_secure, self._url) @@ -75,36 +77,58 @@ class EngineIO(LoggingMixin): raise warning = Exception('[waiting for connection] %s' % e) warning_screen.throw(warning) - assert engineIO_packet_type == 0 + assert engineIO_packet_type == 0 # engineIO_packet_type == open return parse_engineIO_session(engineIO_packet_data) def _negotiate_transport(self): - self._transport_name = 'xhr-polling' - return self._get_transport(self._transport_name) + self._transport_instance = self._get_transport('xhr-polling') + self.transport_name = 'xhr-polling' + is_ws_client = 'websocket' in self._client_transports + is_ws_server = 'websocket' in self._engineIO_session.transport_upgrades + if is_ws_client and is_ws_server: + try: + transport = self._get_transport('websocket') + transport.send_packet(2, 'probe') + for packet_type, packet_data in transport.recv_packet(): + if packet_type == 3 and packet_data == b'probe': + transport.send_packet(5, '') + self._transport_instance = transport + self.transport_name = 'websocket' + else: + self._warn('unexpected engine.io packet') + except Exception: + pass + self._debug('[transport selected] %s', self.transport_name) def _reset_heartbeat(self): try: self._heartbeat_thread.halt() + hurried = self._heartbeat_thread.hurried except AttributeError: - pass + hurried = False ping_interval = self._engineIO_session.ping_interval - if self._transport_name.endswith('-polling'): + if self.transport_name.endswith('-polling'): + # Use ping/pong to unblock recv for polling transport hurry_interval_in_seconds = self._hurry_interval_in_seconds else: + # Use timeout to unblock recv for websocket transport hurry_interval_in_seconds = ping_interval self._heartbeat_thread = HeartbeatThread( send_heartbeat=self._ping, relax_interval_in_seconds=ping_interval, hurry_interval_in_seconds=hurry_interval_in_seconds) self._heartbeat_thread.start() + if hurried: + self._heartbeat_thread.hurry() + self._debug('[heartbeat reset]') def _connect_namespaces(self): pass def _get_transport(self, transport_name): - self._debug('[transport selected] %s', transport_name) SelectedTransport = { 'xhr-polling': XHR_PollingTransport, + 'websocket': WebsocketTransport, }[transport_name] return SelectedTransport( self._http_session, self._is_secure, self._url, @@ -143,51 +167,62 @@ class EngineIO(LoggingMixin): def send(self, engineIO_packet_data): self._message(engineIO_packet_data) - @retry def _open(self): engineIO_packet_type = 0 - self._transport.send_packet(engineIO_packet_type, '') + self._transport_instance.send_packet(engineIO_packet_type) def _close(self): self._wants_to_close = True - self._heartbeat_thread.halt() + try: + self._heartbeat_thread.halt() + except AttributeError: + pass if not self._opened: return engineIO_packet_type = 1 - self._transport.send_packet(engineIO_packet_type, '') + try: + self._transport_instance.send_packet(engineIO_packet_type) + except (TimeoutError, ConnectionError): + pass self._opened = False - @retry def _ping(self, engineIO_packet_data=''): engineIO_packet_type = 2 - self._transport.send_packet(engineIO_packet_type, engineIO_packet_data) + self._transport_instance.send_packet( + engineIO_packet_type, engineIO_packet_data) - @retry def _pong(self, engineIO_packet_data=''): engineIO_packet_type = 3 - self._transport.send_packet(engineIO_packet_type, engineIO_packet_data) + self._transport_instance.send_packet( + engineIO_packet_type, engineIO_packet_data) @retry - def _message(self, engineIO_packet_data): + def _message(self, engineIO_packet_data, with_transport_instance=False): engineIO_packet_type = 4 - self._transport.send_packet(engineIO_packet_type, engineIO_packet_data) + if with_transport_instance: + transport = self._transport_instance + else: + transport = self._transport + transport.send_packet(engineIO_packet_type, engineIO_packet_data) self._debug('[socket.io packet sent] %s', engineIO_packet_data) - @retry def _upgrade(self): engineIO_packet_type = 5 - self._transport.send_packet(engineIO_packet_type, '') + self._transport_instance.send_packet(engineIO_packet_type) - @retry def _noop(self): engineIO_packet_type = 6 - self._transport.send_packet(engineIO_packet_type, '') + self._transport_instance.send_packet(engineIO_packet_type) # React def wait(self, seconds=None, **kw): 'Wait in a loop and react to events as defined in the namespaces' + # Use ping/pong to unblock recv for polling transport self._heartbeat_thread.hurry() + # Use timeout to unblock recv for websocket transport + self._transport.set_timeout(seconds=1) + # Listen warning_screen = self._yield_warning_screen(seconds) for elapsed_time in warning_screen: if self._should_stop_waiting(**kw): @@ -198,6 +233,7 @@ class EngineIO(LoggingMixin): except TimeoutError: pass except ConnectionError as e: + self._opened = False try: warning = Exception('[connection error] %s' % e) warning_screen.throw(warning) @@ -209,6 +245,7 @@ class EngineIO(LoggingMixin): except PacketError: pass self._heartbeat_thread.relax() + self._transport.set_timeout() def _should_stop_waiting(self): return self._wants_to_close @@ -237,31 +274,31 @@ class EngineIO(LoggingMixin): except KeyError: raise PacketError( 'unexpected engine.io packet type (%s)' % engineIO_packet_type) - delegate(engineIO_packet_data, namespace._find_packet_callback) + delegate(engineIO_packet_data, namespace) if engineIO_packet_type is 4: return engineIO_packet_data - def _on_open(self, data, find_packet_callback): - find_packet_callback('open')() + def _on_open(self, data, namespace): + namespace._find_packet_callback('open')() - def _on_close(self, data, find_packet_callback): - find_packet_callback('close')() + def _on_close(self, data, namespace): + namespace._find_packet_callback('close')() - def _on_ping(self, data, find_packet_callback): + def _on_ping(self, data, namespace): self._pong(data) - find_packet_callback('ping')(data) + namespace._find_packet_callback('ping')(data) - def _on_pong(self, data, find_packet_callback): - find_packet_callback('pong')(data) + def _on_pong(self, data, namespace): + namespace._find_packet_callback('pong')(data) - def _on_message(self, data, find_packet_callback): - find_packet_callback('message')(data) + def _on_message(self, data, namespace): + namespace._find_packet_callback('message')(data) - def _on_upgrade(self, data, find_packet_callback): - find_packet_callback('upgrade')() + def _on_upgrade(self, data, namespace): + namespace._find_packet_callback('upgrade')() - def _on_noop(self, data, find_packet_callback): - find_packet_callback('noop')() + def _on_noop(self, data, namespace): + namespace._find_packet_callback('noop')() class SocketIO(EngineIO): @@ -303,7 +340,7 @@ class SocketIO(EngineIO): for path, namespace in self._namespace_by_path.items(): namespace._transport = self._transport_instance if path: - self.connect(path) + self.connect(path, with_transport_instance=True) def __exit__(self, *exception_pack): self.disconnect() @@ -316,9 +353,10 @@ class SocketIO(EngineIO): # Define def define(self, Namespace, path=''): + self._namespace_by_path[path] = namespace = Namespace(self, path) if path: self.connect(path) - self._namespace_by_path[path] = namespace = Namespace(self, path) + self.wait(for_connect=True) return namespace def on(self, event, callback, path=''): @@ -336,20 +374,23 @@ class SocketIO(EngineIO): # Act - def connect(self, path): + def connect(self, path, with_transport_instance=False): socketIO_packet_type = 0 socketIO_packet_data = format_socketIO_packet_data(path) - self._message(str(socketIO_packet_type) + socketIO_packet_data) + self._message( + str(socketIO_packet_type) + socketIO_packet_data, + with_transport_instance) def disconnect(self, path=''): - if not self._opened: - return - if path: + if not path or not self._opened: + self._close() + elif path: socketIO_packet_type = 1 socketIO_packet_data = format_socketIO_packet_data(path) - self._message(str(socketIO_packet_type) + socketIO_packet_data) - else: - self._close() + try: + self._message(str(socketIO_packet_type) + socketIO_packet_data) + except (TimeoutError, ConnectionError): + pass try: namespace = self._namespace_by_path.pop(path) namespace.on_disconnect() @@ -379,13 +420,17 @@ class SocketIO(EngineIO): # React - def wait(self, seconds=None, for_callbacks=False): - super(SocketIO, self).wait(seconds, for_callbacks=for_callbacks) - def wait_for_callbacks(self, seconds=None): self.wait(seconds, for_callbacks=True) - def _should_stop_waiting(self, for_callbacks): + def _should_stop_waiting(self, for_connect=False, for_callbacks=False): + if for_connect: + for namespace in self._namespace_by_path.values(): + is_namespace_connected = getattr( + namespace, '_connected', False) + if not is_namespace_connected: + return False + return True if for_callbacks and not self._has_ack_callback: return True return super(SocketIO, self)._should_stop_waiting() @@ -413,16 +458,18 @@ class SocketIO(EngineIO): except KeyError: raise PacketError( 'unexpected socket.io packet type (%s)' % socketIO_packet_type) - delegate(socketIO_packet_data, namespace._find_packet_callback) + delegate(socketIO_packet_data, namespace) return socketIO_packet_data - def _on_connect(self, data, find_packet_callback): - find_packet_callback('connect')() + def _on_connect(self, data, namespace): + namespace._connected = True + namespace._find_packet_callback('connect')() - def _on_disconnect(self, data, find_packet_callback): - find_packet_callback('disconnect')() + def _on_disconnect(self, data, namespace): + namespace._connected = False + namespace._find_packet_callback('disconnect')() - def _on_event(self, data, find_packet_callback): + def _on_event(self, data, namespace): data_parsed = parse_socketIO_packet_data(data) args = data_parsed.args try: @@ -432,9 +479,9 @@ class SocketIO(EngineIO): if data_parsed.ack_id is not None: args.append(self._prepare_to_send_ack( data_parsed.path, data_parsed.ack_id)) - find_packet_callback(event)(*args) + namespace._find_packet_callback(event)(*args) - def _on_ack(self, data, find_packet_callback): + def _on_ack(self, data, namespace): data_parsed = parse_socketIO_packet_data(data) try: ack_callback = self._get_ack_callback(data_parsed.ack_id) @@ -442,13 +489,13 @@ class SocketIO(EngineIO): return ack_callback(*data_parsed.args) - def _on_error(self, data, find_packet_callback): - find_packet_callback('error')(data) + def _on_error(self, data, namespace): + namespace._find_packet_callback('error')(data) - def _on_binary_event(self, data, find_packet_callback): + def _on_binary_event(self, data, namespace): self._warn('[not implemented] binary event') - def _on_binary_ack(self, data, find_packet_callback): + def _on_binary_ack(self, data, namespace): self._warn('[not implemented] binary ack') def _prepare_to_send_ack(self, path, ack_id): diff --git a/socketIO_client/heartbeats.py b/socketIO_client/heartbeats.py index db2599d..f79c5ca 100644 --- a/socketIO_client/heartbeats.py +++ b/socketIO_client/heartbeats.py @@ -1,3 +1,4 @@ +import logging from threading import Thread, Event from .exceptions import ConnectionError, TimeoutError @@ -32,7 +33,7 @@ class HeartbeatThread(Thread): interval_in_seconds = self._relax_interval_in_seconds self._rest.wait(interval_in_seconds) except ConnectionError: - pass + logging.debug('[heartbeat connection error]') def relax(self): self._adrenaline.clear() @@ -42,6 +43,10 @@ class HeartbeatThread(Thread): self._rest.set() self._rest.clear() + @property + def hurried(self): + return self._adrenaline.is_set() + def halt(self): self._rest.set() self._halt.set() diff --git a/socketIO_client/logs.py b/socketIO_client/logs.py index ff37d19..32b5d54 100644 --- a/socketIO_client/logs.py +++ b/socketIO_client/logs.py @@ -33,6 +33,10 @@ def _yield_elapsed_time(seconds=None): start_time = time.time() if seconds is None: while True: - yield time.time() - start_time - while time.time() - start_time < seconds: - yield time.time() - start_time + yield _get_elapsed_time(start_time) + while _get_elapsed_time(start_time) < seconds: + yield _get_elapsed_time(start_time) + + +def _get_elapsed_time(start_time): + return time.time() - start_time diff --git a/socketIO_client/namespaces.py b/socketIO_client/namespaces.py index 84cd65c..e78529a 100644 --- a/socketIO_client/namespaces.py +++ b/socketIO_client/namespaces.py @@ -141,31 +141,31 @@ class SocketIONamespace(EngineIONamespace): class LoggingEngineIONamespace(EngineIONamespace): def on_open(self): - self._debug('[open]') + self._debug('[engine.io open]') super(LoggingEngineIONamespace, self).on_open() def on_close(self): - self._debug('[close]') + self._debug('[engine.io close]') super(LoggingEngineIONamespace, self).on_close() def on_ping(self, data): - self._debug('[ping] %s', data) + self._debug('[engine.io ping] %s', data) super(LoggingEngineIONamespace, self).on_ping(data) def on_pong(self, data): - self._debug('[pong] %s', data) + self._debug('[engine.io pong] %s', data) super(LoggingEngineIONamespace, self).on_pong(data) def on_message(self, data): - self._debug('[message] %s', data) + self._debug('[engine.io message] %s', data) super(LoggingEngineIONamespace, self).on_message(data) def on_upgrade(self): - self._debug('[upgrade]') + self._debug('[engine.io upgrade]') super(LoggingEngineIONamespace, self).on_upgrade() def on_noop(self): - self._debug('[noop]') + self._debug('[engine.io noop]') super(LoggingEngineIONamespace, self).on_noop() def on_event(self, event, *args): @@ -173,22 +173,25 @@ class LoggingEngineIONamespace(EngineIONamespace): arguments = [repr(_) for _ in args] if callback: arguments.append('callback(*args)') - self._info('[event] %s(%s)', event, ', '.join(arguments)) + self._info('[engine.io event] %s(%s)', event, ', '.join(arguments)) super(LoggingEngineIONamespace, self).on_event(event, *args) -class LoggingSocketIONamespace(SocketIONamespace): +class LoggingSocketIONamespace(SocketIONamespace, LoggingEngineIONamespace): def on_connect(self): - self._debug('%s[connect]', _make_logging_header(self.path)) + self._debug( + '%s[socket.io connect]', _make_logging_header(self.path)) super(LoggingSocketIONamespace, self).on_connect() def on_reconnect(self): - self._debug('%s[reconnect]', _make_logging_header(self.path)) + self._debug( + '%s[socket.io reconnect]', _make_logging_header(self.path)) super(LoggingSocketIONamespace, self).on_reconnect() def on_disconnect(self): - self._debug('%s[disconnect]', _make_logging_header(self.path)) + self._debug( + '%s[socket.io disconnect]', _make_logging_header(self.path)) super(LoggingSocketIONamespace, self).on_disconnect() def on_event(self, event, *args): @@ -197,12 +200,13 @@ class LoggingSocketIONamespace(SocketIONamespace): if callback: arguments.append('callback(*args)') self._info( - '%s[event] %s(%s)', _make_logging_header(self.path), event, - ', '.join(arguments)) + '%s[socket.io event] %s(%s)', _make_logging_header(self.path), + event, ', '.join(arguments)) super(LoggingSocketIONamespace, self).on_event(event, *args) def on_error(self, data): - self._debug('%s[error] %s', _make_logging_header(self.path), data) + self._debug( + '%s[socket.io error] %s', _make_logging_header(self.path), data) super(LoggingSocketIONamespace, self).on_error() diff --git a/socketIO_client/parsers.py b/socketIO_client/parsers.py index c962d77..8da8ee8 100644 --- a/socketIO_client/parsers.py +++ b/socketIO_client/parsers.py @@ -32,8 +32,8 @@ def parse_engineIO_session(engineIO_packet_data): def encode_engineIO_content(engineIO_packets): content = bytearray() for packet_type, packet_data in engineIO_packets: - packet_string = encode_string(str(packet_type) + packet_data) - content.extend(_make_packet_header(packet_string) + packet_string) + packet_text = format_packet_text(packet_type, packet_data) + content.extend(_make_packet_prefix(packet_text) + packet_text) return content @@ -46,10 +46,10 @@ def decode_engineIO_content(content): content, content_index) except IndexError: break - content_index, packet_string = _read_packet_string( + content_index, packet_text = _read_packet_text( content, content_index, packet_length) - engineIO_packet_type = int(get_character(packet_string, 0)) - engineIO_packet_data = packet_string[1:] + engineIO_packet_type, engineIO_packet_data = parse_packet_text( + packet_text) yield engineIO_packet_type, engineIO_packet_data @@ -85,6 +85,16 @@ def parse_socketIO_packet_data(socketIO_packet_data): return SocketIOData(path=path, ack_id=ack_id, args=args) +def format_packet_text(packet_type, packet_data): + return encode_string(str(packet_type) + packet_data) + + +def parse_packet_text(packet_text): + packet_type = int(get_character(packet_text, 0)) + packet_data = packet_text[1:] + return packet_type, packet_data + + def get_namespace_path(socketIO_packet_data): if not socketIO_packet_data.startswith(b'/'): return '' @@ -98,8 +108,8 @@ def get_namespace_path(socketIO_packet_data): return ''.join(parts) -def _make_packet_header(packet_string): - length_string = str(len(packet_string)) +def _make_packet_prefix(packet): + length_string = str(len(packet)) header_digits = bytearray([0]) for i in range(len(length_string)): header_digits.append(ord(length_string[i]) - 48) @@ -120,8 +130,8 @@ def _read_packet_length(content, content_index): return content_index, int(packet_length_string) -def _read_packet_string(content, content_index, packet_length): +def _read_packet_text(content, content_index, packet_length): while get_byte(content, content_index) == 255: content_index += 1 - packet_string = content[content_index:content_index + packet_length] - return content_index + packet_length, packet_string + packet_text = content[content_index:content_index + packet_length] + return content_index + packet_length, packet_text diff --git a/socketIO_client/symmetries.py b/socketIO_client/symmetries.py index b061a20..f100ec6 100644 --- a/socketIO_client/symmetries.py +++ b/socketIO_client/symmetries.py @@ -1,18 +1,26 @@ import six try: - from urllib.parse import urlparse as parse_url + from urllib import urlencode as format_query except ImportError: + from urllib.parse import urlencode as format_query +try: from urlparse import urlparse as parse_url +except ImportError: + from urllib.parse import urlparse as parse_url +try: + memoryview = memoryview +except NameError: + memoryview = buffer + + +def get_character(x, index): + return chr(get_byte(x, index)) def get_byte(x, index): return six.indexbytes(x, index) -def get_character(x, index): - return chr(six.indexbytes(x, index)) - - def encode_string(x): return x.encode('utf-8') diff --git a/socketIO_client/tests/__init__.py b/socketIO_client/tests/__init__.py index 2ce4856..bcfc00e 100644 --- a/socketIO_client/tests/__init__.py +++ b/socketIO_client/tests/__init__.py @@ -6,7 +6,7 @@ from .. import SocketIO, LoggingNamespace, find_callback HOST = 'localhost' -PORT = 8000 +PORT = 9000 DATA = 'xxx' PAYLOAD = {'xxx': 'yyy'} logging.basicConfig(level=logging.DEBUG) @@ -17,21 +17,18 @@ class BaseMixin(object): def setUp(self): super(BaseMixin, self).setUp() self.called_on_response = False + self.wait_time_in_seconds = 1 def tearDown(self): super(BaseMixin, self).tearDown() - del self.socketIO + self.socketIO.disconnect() def test_disconnect(self): 'Disconnect' + namespace = self.socketIO.define(Namespace) self.assertTrue(self.socketIO.connected) + self.assertFalse(namespace.called_on_disconnect) self.socketIO.disconnect() - self.assertFalse(self.socketIO.connected) - # Use context manager - with SocketIO(HOST, PORT, Namespace) as self.socketIO: - namespace = self.socketIO.get_namespace() - self.assertFalse(namespace.called_on_disconnect) - self.assertTrue(self.socketIO.connected) self.assertTrue(namespace.called_on_disconnect) self.assertFalse(self.socketIO.connected) @@ -116,7 +113,7 @@ class BaseMixin(object): def test_wait_with_disconnect(self): 'Exit loop when the client wants to disconnect' self.socketIO.define(Namespace) - self.socketIO.emit('wait_with_disconnect') + self.socketIO.disconnect() timeout_in_seconds = 5 start_time = time.time() self.socketIO.wait(timeout_in_seconds) @@ -159,8 +156,17 @@ class Test_XHR_PollingTransport(BaseMixin, TestCase): def setUp(self): super(Test_XHR_PollingTransport, self).setUp() self.socketIO = SocketIO(HOST, PORT, LoggingNamespace, transports=[ - 'xhr-polling']) - self.wait_time_in_seconds = 1 + 'xhr-polling'], verify=False) + self.assertEqual(self.socketIO.transport_name, 'xhr-polling') + + +class Test_WebsocketTransport(BaseMixin, TestCase): + + def setUp(self): + super(Test_WebsocketTransport, self).setUp() + self.socketIO = SocketIO(HOST, PORT, LoggingNamespace, transports=[ + 'xhr-polling', 'websocket'], verify=False) + self.assertEqual(self.socketIO.transport_name, 'websocket') class Namespace(LoggingNamespace): diff --git a/socketIO_client/tests/index.html b/socketIO_client/tests/index.html index df37df0..f3c03f5 100644 --- a/socketIO_client/tests/index.html +++ b/socketIO_client/tests/index.html @@ -1,6 +1,6 @@