def __init__(self,
job_id,
input_params={},
msg_output_format="{job} {level} {msg}",
msg_callback=None,
print_job_info=True):
self.job_id = job_id
self.seen_jobs = {}
self.last_seen_log_lines = defaultdict(dict)
self.skipped_messages = 0
self.input_params = input_params
self.msg_output_format = msg_output_format
self.msg_callback = msg_callback
self.print_job_info = print_job_info
self.closed_code, self.closed_reason = None, None
ws_proto = 'wss' if dxpy.APISERVER_PROTOCOL == 'https' else 'ws'
self.url = "{protocol}://{host}:{port}/{job_id}/getLog/websocket".format(
protocol=ws_proto,
host=dxpy.APISERVER_HOST,
port=dxpy.APISERVER_PORT,
job_id=job_id)
WebSocketBaseClient.__init__(self,
self.url,
protocols=None,
extensions=None)
def __init__(self, currency, apiKey, apiSecret):
currencies = [currency]
url = 'ws://websocket.mtgox.com/mtgox?Currency=%s' % (",".join(currencies))
WebSocketBaseClient.__init__(self, url)
self.__nonce = None
self.__apiKey = apiKey
self.__apiSecret = apiSecret
def __init__(self, url, protocols=None, version='8'):
WebSocketBaseClient.__init__(self,
url,
protocols=protocols,
version=version)
self.io = iostream.IOStream(
socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0))
def __init__(self, url, protocols=None, extensions=None,
io_loop=None, ssl_options=None, headers=None):
"""
.. code-block:: python
from tornado import ioloop
class MyClient(TornadoWebSocketClient):
def opened(self):
for i in range(0, 200, 25):
self.send("*" * i)
def received_message(self, m):
print((m, len(str(m))))
def closed(self, code, reason=None):
ioloop.IOLoop.instance().stop()
ws = MyClient('ws://localhost:9000/echo', protocols=['http-only', 'chat'])
ws.connect()
ioloop.IOLoop.instance().start()
"""
WebSocketBaseClient.__init__(self, url, protocols, extensions,
ssl_options=ssl_options, headers=headers)
self.ssl_options["do_handshake_on_connect"] = False
if self.scheme == "wss":
self.sock = ssl.wrap_socket(self.sock, **self.ssl_options)
self.io = iostream.SSLIOStream(self.sock, io_loop)
else:
self.io = iostream.IOStream(self.sock, io_loop)
self.io_loop = io_loop
def connect(self):
"""
Connects to the server.
"""
try:
WebSocketBaseClient.connect(self)
except OSError:
raise
except Exception as e:
log.error("could to connect {}: {}".format(self.url, e))
raise OSError("Websocket exception {}: {}".format(type(e), e))
# once connected, get the GNS3 server version (over classic HTTP)
url = "http://{host}:{port}/version".format(host=self.host, port=self.port)
content = urllib.request.urlopen(url).read()
try:
json_data = json.loads(content.decode("utf-8"))
self._version = json_data.get("version")
except ValueError as e:
log.error("could not get the server version: {}".format(e))
#FIXME: temporary version check
if (self._version != __version__):
self.close_connection()
raise OSError("GUI version {} differs with the server version {}".format(__version__, self._version))
def __init__(self, url, protocols=None, extensions=None, heartbeat_freq=None,
ssl_options=None, headers=None):
"""
.. code-block:: python
from ws4py.client.threadedclient import WebSocketClient
class EchoClient(WebSocketClient):
def opened(self):
for i in range(0, 200, 25):
self.send("*" * i)
def closed(self, code, reason):
print(("Closed down", code, reason))
def received_message(self, m):
print("=> %d %s" % (len(m), str(m)))
try:
ws = EchoClient('ws://localhost:9000/echo', protocols=['http-only', 'chat'])
ws.connect()
except KeyboardInterrupt:
ws.close()
"""
WebSocketBaseClient.__init__(self, url, protocols, extensions, heartbeat_freq,
ssl_options, headers=headers)
self._th = threading.Thread(target=self.run, name='WebSocketClient')
self._th.daemon = True
def test_connect_and_close(self, sock):
s = MagicMock()
sock.socket.return_value = s
sock.getaddrinfo.return_value = [(socket.AF_INET, socket.SOCK_STREAM, 0, "",
("127.0.0.1", 80, 0, 0))]
c = WebSocketBaseClient(url="ws://127.0.0.1/?token=value")
s.recv.return_value = b"\r\n".join([
b"HTTP/1.1 101 Switching Protocols",
b"Connection: Upgrade",
b"Sec-Websocket-Version: 13",
b"Content-Type: text/plain;charset=utf-8",
b"Sec-Websocket-Accept: " + b64encode(sha1(c.key + WS_KEY).digest()),
b"Upgrade: websocket",
b"Date: Sun, 26 Jul 2015 12:32:55 GMT",
b"Server: ws4py/test",
b"\r\n"
])
c.connect()
s.connect.assert_called_once_with(("127.0.0.1", 80))
s.reset_mock()
c.close(code=1006, reason="boom")
args = s.sendall.call_args_list[0]
f = Frame()
f.parser.send(args[0][0])
f.parser.close()
self.assertIn(b'boom', f.unmask(f.body))
def __init__(self, url, protocols=None, extensions=None, ssl_options=None):
"""
WebSocket client that executes the
:meth:`run() <ws4py.websocket.WebSocket.run>` into a gevent greenlet.
.. code-block:: python
ws = WebSocketClient('ws://localhost:9000/echo', protocols=['http-only', 'chat'])
ws.connect()
ws.send("Hello world")
def incoming():
while True:
m = ws.receive()
if m is not None:
print str(m)
else:
break
def outgoing():
for i in range(0, 40, 5):
ws.send("*" * i)
greenlets = [
gevent.spawn(incoming),
gevent.spawn(outgoing),
]
gevent.joinall(greenlets)
"""
WebSocketBaseClient.__init__(self, url, protocols, extensions, ssl_options=ssl_options)
self._th = Greenlet(self.run)
self.messages = Queue()
"""
def __init__(self,
url,
protocols=None,
extensions=None,
heartbeat_freq=None):
"""
.. code-block:: python
from ws4py.client.threadedclient import WebSocketClient
class EchoClient(WebSocketClient):
def opened(self):
for i in range(0, 200, 25):
self.send("*" * i)
def closed(self, code, reason):
print(("Closed down", code, reason))
def received_message(self, m):
print("=> %d %s" % (len(m), str(m)))
try:
ws = EchoClient('ws://localhost:9000/echo', protocols=['http-only', 'chat'])
ws.connect()
except KeyboardInterrupt:
ws.close()
"""
WebSocketBaseClient.__init__(self, url, protocols, extensions,
heartbeat_freq)
self._th = threading.Thread(target=self.run, name='WebSocketClient')
self._th.daemon = True
def reconnect(self):
# Instead of trying to reconnect in a retry loop with backoff, run an API call that will do the same
# and block while it retries.
time.sleep(1)
dxpy.describe(self.job_id)
WebSocketBaseClient.__init__(self, self.url, protocols=None, extensions=None)
self.connect()
def run(self):
# Run forever until event_stop tells us to stop
while not self.data_collection.event_stop.is_set():
# Initialize the websocket
WebSocketBaseClient.__init__(self, self.url, *self.init_args,
**self.init_kwargs)
self.sock.settimeout(
self.TIMEOUT
) # Set the socket timeout so if a host is unreachable it doesn't take 60s (default) to figure out
logger.notice("Connecting to '{}'...".format(self.url))
try:
self.connect() # Attempt to connect to the Arduino
except Exception as e:
logger.error(
"Unable to connect to '{}' (probably timed out). Reason: {}"
.format(self.url, e))
else: # If we were able to connect, then run the websocket (received_message will get called appropriately)
while self.once():
pass # self.once() will return False on error/close -> Only stop when the connection is lost or self.close() is called
self.terminate()
time.sleep(
2
) # Wait for a couple of seconds for Arduino to reboot/connect or just to avoid network overload
logger.success("Thread in charge of '{}' exited :)".format(self.url))
def connect(self):
"""
Connects to the server.
"""
try:
WebSocketBaseClient.connect(self)
except OSError:
raise
except Exception as e:
log.error("could to connect {}: {}".format(self.url, e))
raise OSError("Websocket exception {}: {}".format(type(e), e))
# once connected, get the GNS3 server version (over classic HTTP)
url = "http://{host}:{port}/version".format(host=self.host,
port=self.port)
content = urllib.request.urlopen(url).read()
try:
json_data = json.loads(content.decode("utf-8"))
self._version = json_data.get("version")
except ValueError as e:
log.error("could not get the server version: {}".format(e))
#FIXME: temporary version check
if (self._version != __version__):
self.close_connection()
raise OSError(
"GUI version {} differs with the server version {}".format(
__version__, self._version))
def __init__(self, url, protocols=None, extensions=None,
io_loop=None, ssl_options=None, headers=None):
"""
.. code-block:: python
from tornado import ioloop
class MyClient(TornadoWebSocketClient):
def opened(self):
for i in range(0, 200, 25):
self.send("*" * i)
def received_message(self, m):
print((m, len(str(m))))
def closed(self, code, reason=None):
ioloop.IOLoop.instance().stop()
ws = MyClient('ws://localhost:9000/echo', protocols=['http-only', 'chat'])
ws.connect()
ioloop.IOLoop.instance().start()
"""
WebSocketBaseClient.__init__(self, url, protocols, extensions,
ssl_options=ssl_options, headers=headers)
if self.scheme == "wss":
self.sock = ssl.wrap_socket(self.sock, do_handshake_on_connect=False, **self.ssl_options)
self.io = iostream.SSLIOStream(self.sock, io_loop, ssl_options=self.ssl_options)
else:
self.io = iostream.IOStream(self.sock, io_loop)
self.io_loop = io_loop
def __init__(self, user, ws_uri, console_path, control_path, *args, socket_suffix='console', **kwargs):
self.__shutdown_event = EventFD()
self.socket_path = path.join('/tmp', '{}-ws-{}.socket'.format(user, socket_suffix))
try:
os.unlink(self.socket_path)
except OSError:
if os.path.exists(self.socket_path):
raise
self.socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
self.socket.bind(self.socket_path)
self.socket.listen(1)
shutil.chown(self.socket_path, user=user)
os.chmod(self.socket_path, stat.S_IRWXU)
self.control = ConsoleControl(ws_uri, control_path)
self.control.connect()
WebSocketBaseClient.__init__(self, ws_uri, *args, **kwargs)
self.resource = console_path
self.socket_conn = None
self.run_thread = threading.Thread(target=self.run_read)
self.connect()
def close_connection(self):
"""
Closes the connection to the server and remove the monitoring by
the QSocketNotifier.
"""
self._connected = False
WebSocketBaseClient.close_connection(self)
self.fd_notifier.setEnabled(False)
def __init__(self, url, protocols=None, extensions=None, io_loop=None):
WebSocketBaseClient.__init__(self, url, protocols, extensions)
if self.scheme == "wss":
self.sock = ssl.wrap_socket(self.sock, do_handshake_on_connect=False)
self.io = iostream.SSLIOStream(self.sock, io_loop)
else:
self.io = iostream.IOStream(self.sock, io_loop)
self.sender = self.io.write
self.io_loop = io_loop
def reconnect(self):
# Instead of trying to reconnect in a retry loop with backoff, run an API call that will do the same
# and block while it retries.
time.sleep(1)
dxpy.describe(self.job_id)
WebSocketBaseClient.__init__(self,
self.url,
protocols=None,
extensions=None)
self.connect()
def connect(self):
"""
Connects to the server.
"""
try:
WebSocketBaseClient.connect(self)
except HandshakeError as e:
log.error("could to connect {}: {}".format(self.url, e))
raise OSError(str(e))
def __init__(self, url, protocols=None, extensions=None, io_loop=None):
WebSocketBaseClient.__init__(self, url, protocols, extensions)
if self.scheme == "wss":
self.sock = ssl.wrap_socket(self.sock,
do_handshake_on_connect=False)
self.io = iostream.SSLIOStream(self.sock, io_loop)
else:
self.io = iostream.IOStream(self.sock, io_loop)
self.sender = self.io.write
self.io_loop = io_loop
def __init__(self, url, sock=None, protocols=None, version='8'):
WebSocketBaseClient.__init__(self, url, protocols=protocols, version=version)
if not sock:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
sock.settimeout(3)
self.sock = sock
self.running = True
self._lock = threading.Lock()
self._th = threading.Thread(target=self._receive)
def __init__(self, url, protocols=None, extensions=None, io_loop=None,custom_headers=[]):
WebSocketBaseClient.__init__(self, url, protocols, extensions, custom_headers)
parts = urlsplit(self.url)
if parts.scheme == "wss":
self.sock = ssl.wrap_socket(self.sock,
do_handshake_on_connect=False)
self.io = iostream.SSLIOStream(self.sock, io_loop)
else:
self.io = iostream.IOStream(self.sock, io_loop)
self.sender = self.io.write
self.io_loop = io_loop
def __init__(self, ip="127.0.0.1", port=9090):
"""Constructor.
Warning: there is a know issue regarding resolving localhost to IPv6 address.
Args:
ip (str, optional): Rosbridge instance IPv4/Host address. Defaults to 'localhost'.
port (int, optional): Rosbridge instance listening port number. Defaults to 9090.
"""
ExecutorBase.__init__(self, ip=ip, port=port)
WebSocketBaseClient.__init__(self, self._uri)
def _connect(self):
"""
Connect to the server.
"""
try:
WebSocketBaseClient.connect(self)
except OSError:
raise
except Exception as e:
log.error("could to connect {}: {}".format(self.url, e))
raise OSError("Websocket exception {}: {}".format(type(e), e))
def __init__(self, ds_login, ds_api_key, bot_instance, sanity_checker):
self.username = ds_login
self.api_key = ds_api_key
self.bot_instance = bot_instance
self.sanity_checker = sanity_checker
url = "ws://%s/multi?username=%s&api_key=%s" % (
self.WEBSOCKET_BASE_URL, self.username, self.api_key)
WebSocketBaseClient.__init__(self, url, None, None)
self.dumper = getLogger('dumper')
def __init__(self, url, protocols=None, extensions=None, heartbeat_freq=None,
ssl_options=None, headers=None):
WebSocketBaseClient.__init__(self, url, protocols, extensions, heartbeat_freq,
ssl_options, headers=headers)
self.callbacks = {}
self._connected = False
# create an unique ID
self._id = WebSocketClient._instance_count
WebSocketClient._instance_count += 1
def close_connection(self):
"""
Closes the connection to the server and remove the monitoring by
the QSocketNotifier.
"""
self._connected = False
self._version = ""
WebSocketBaseClient.close_connection(self)
if self._fd_notifier:
self._fd_notifier.setEnabled(False)
self._fd_notifier = None
log.info("connection closed with server {}:{}".format(self.host, self.port))
def _connect(self):
"""
Connect to the server.
"""
try:
if self._local is True:
self.connection.settimeout(5)
WebSocketBaseClient.connect(self)
except OSError:
raise
except Exception as e:
log.error("could not to connect {}: {}".format(self.url, e))
raise OSError("Websocket exception {}: {}".format(type(e), e))
def close_connection(self):
"""
Closes the connection to the server and remove the monitoring by
the QSocketNotifier.
"""
self._connected = False
self._version = ""
WebSocketBaseClient.close_connection(self)
if self._fd_notifier:
self._fd_notifier.setEnabled(False)
self._fd_notifier = None
log.info("connection closed with server {}:{}".format(
self.host, self.port))
def __init__(self, job_id, input_params={}, msg_output_format="{job} {level} {msg}", msg_callback=None,
print_job_info=True):
self.seen_jobs = {}
self.input_params = input_params
self.msg_output_format = msg_output_format
self.msg_callback = msg_callback
self.print_job_info = print_job_info
self.closed_code, self.closed_reason = None, None
ws_proto = 'wss' if dxpy.APISERVER_PROTOCOL == 'https' else 'ws'
url = "{protocol}://{host}:{port}/{job_id}/streamLog/websocket".format(protocol=ws_proto,
host=dxpy.APISERVER_HOST,
port=dxpy.APISERVER_PORT,
job_id=job_id)
WebSocketBaseClient.__init__(self, url, protocols=None, extensions=None)
def __init__(self, url, sock=None, protocols=None, version='8'):
WebSocketBaseClient.__init__(self,
url,
protocols=protocols,
version=version)
if not sock:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
sock.settimeout(3)
self.sock = sock
self.running = True
self._lock = threading.Lock()
self._th = threading.Thread(target=self._receive)
def reconnect(self):
"""
Reconnects to the server.
"""
WebSocketBaseClient.__init__(self, self.url, self.protocols,
self.extensions, self.heartbeat_freq,
self.ssl_options, self.extra_headers)
if self._local:
# check the local host address is still valid
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
sock.bind((self.host, 0))
self.connect()
def terminate(self):
if self.stream and self.stream.closing and self.stream.closing.code == 1001 \
and self.stream.closing.reason == "Server restart, please reconnect later":
# Clean up state (this is a copy of WebSocket.terminate(), minus the part that calls closed())
try:
self.close_connection()
self.stream._cleanup()
except:
pass
self.stream = None
self.environ = None
logger.warn("Server restart, reconnecting...")
self.reconnect()
else:
WebSocketBaseClient.terminate(self)
def test_parse_wss_scheme_with_port(self):
c = WebSocketBaseClient(url="wss://127.0.0.1:9090")
self.assertEqual(c.scheme, "wss")
self.assertEqual(c.host, "127.0.0.1")
self.assertEqual(c.port, 9090)
self.assertEqual(c.resource, "/")
self.assertEqual(c.bind_addr, ("127.0.0.1", 9090))
def test_parse_wss_scheme_when_missing_resource(self):
c = WebSocketBaseClient(url="wss://127.0.0.1")
self.assertEqual(c.scheme, "wss")
self.assertEqual(c.host, "127.0.0.1")
self.assertEqual(c.port, 443)
self.assertEqual(c.resource, "/")
self.assertEqual(c.bind_addr, ("127.0.0.1", 443))
def test_parse_ws_scheme_with_query_string(self):
c = WebSocketBaseClient(url="ws://127.0.0.1/?token=value")
self.assertEqual(c.scheme, "ws")
self.assertEqual(c.host, "127.0.0.1")
self.assertEqual(c.port, 80)
self.assertEqual(c.resource, "/?token=value")
self.assertEqual(c.bind_addr, ("127.0.0.1", 80))
def test_parse_ws_scheme(self):
c = WebSocketBaseClient(url="ws://127.0.0.1/")
self.assertEqual(c.scheme, "ws")
self.assertEqual(c.host, "127.0.0.1")
self.assertEqual(c.port, 80)
self.assertEqual(c.resource, "/")
self.assertEqual(c.bind_addr, ("127.0.0.1", 80))
def test_parse_unix_schemes(self):
c = WebSocketBaseClient(url="ws+unix:///my.socket")
self.assertEqual(c.scheme, "ws+unix")
self.assertEqual(c.host, "localhost")
self.assertIsNone(c.port)
self.assertEqual(c.unix_socket_path, "/my.socket")
self.assertEqual(c.resource, "/")
self.assertEqual(c.bind_addr, "/my.socket")
c = WebSocketBaseClient(url="wss+unix:///my.socket")
self.assertEqual(c.scheme, "wss+unix")
self.assertEqual(c.host, "localhost")
self.assertIsNone(c.port)
self.assertEqual(c.unix_socket_path, "/my.socket")
self.assertEqual(c.resource, "/")
self.assertEqual(c.bind_addr, "/my.socket")
def __init__(self,
url,
protocols=None,
extensions=None,
heartbeat_freq=None,
ssl_options=None,
headers=None):
WebSocketBaseClient.__init__(self,
url,
protocols,
extensions,
heartbeat_freq,
ssl_options,
headers=headers)
self._th = threading.Thread(target=self.run, name='WebSocketClient')
self._th.daemon = True
def terminate(self):
if self.stream and self.stream.closing and self.stream.closing.code == 1001 \
and self.stream.closing.reason == "Server restart, please reconnect later":
# Clean up state (this is a copy of WebSocket.terminate(), minus the part that calls closed())
try:
self.close_connection()
self.stream._cleanup()
except:
pass
self.stream = None
self.environ = None
logger.warn("Server restart, reconnecting...")
self.reconnect()
else:
WebSocketBaseClient.terminate(self)
def test_invalid_response_headers(self, sock):
for key_header, invalid_value in ((b'upgrade', b'boom'),
(b'connection', b'bim')):
s = MagicMock()
sock.socket.return_value = s
sock.getaddrinfo.return_value = [
(socket.AF_INET, socket.SOCK_STREAM, 0, "", ("127.0.0.1", 80,
0, 0))
]
c = WebSocketBaseClient(url="ws://127.0.0.1/?token=value")
status_line = b"HTTP/1.1 101 Switching Protocols"
headers = {
b"connection": b"Upgrade",
b"Sec-Websocket-Version": b"13",
b"Content-Type": b"text/plain;charset=utf-8",
b"Sec-Websocket-Accept":
b64encode(sha1(c.key + WS_KEY).digest()),
b"upgrade": b"websocket",
b"Date": b"Sun, 26 Jul 2015 12:32:55 GMT",
b"Server": b"ws4py/test"
}
headers[key_header] = invalid_value
request = [status_line
] + [k + b" : " + v
for (k, v) in headers.items()] + [b'\r\n']
s.recv.return_value = b"\r\n".join(request)
self.assertRaises(HandshakeError, c.connect)
s.shutdown.assert_called_once_with(socket.SHUT_RDWR)
s.close.assert_called_once_with()
sock.reset_mock()
def reconnect(self):
"""
Reconnects to the server.
"""
WebSocketBaseClient.__init__(self,
self.url,
self.protocols,
self.extensions,
self.heartbeat_freq,
self.ssl_options,
self.extra_headers)
if self._local:
# check the local host address is still valid
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
sock.bind((self.host, 0))
self.connect()
def __init__(self,
url,
protocols=None,
extensions=None,
ssl_options=None,
headers=None):
"""WebSocket client that executes into a eventlet green thread."""
WebSocketBaseClient.__init__(
self,
url,
protocols,
extensions,
ssl_options=ssl_options,
headers=headers,
)
self._th = threading.Thread(target=self.run, name="WebSocketClient")
self._th.daemon = True
self.messages = queue.Queue()
def __init__(self,
url,
protocols=[],
extensions=None,
heartbeat_freq=None,
ssl_options=None,
headers=None,
inputQueue=None,
outputQueue=None):
WebSocketBaseClient.__init__(self,
url,
protocols,
extensions,
heartbeat_freq,
ssl_options,
headers=headers)
self.isClosed = False
self._input = inputQueue
self._output = outputQueue
def __init__(self, url, protocols=None, extensions=None, heartbeat_freq=None,
ssl_options=None, headers=None):
WebSocketBaseClient.__init__(self, url, protocols, extensions, heartbeat_freq,
ssl_options, headers=headers)
self.callbacks = {}
self._connected = False
self._local = False
self._version = ""
self._fd_notifier = None
# create an unique ID
self._id = WebSocketClient._instance_count
WebSocketClient._instance_count += 1
# set a default timeout of 10 seconds
# for connecting to a server
socket.setdefaulttimeout(10)
def open(self, address):
"""Open the socket on the given address"""
from cothread.cosocket import socket as cosocket
import socket
from ws4py.client import WebSocketBaseClient
_socket = socket.socket
socket.socket = cosocket
self.sock = WebSocketBaseClient(address)
self.sock.handshake_ok = lambda: None
socket.socket = _socket
self.sock.received_message = weak_method(self.received_message)
self.sock.connect()
def test_connect_and_close(self, sock):
s = MagicMock()
sock.socket.return_value = s
sock.getaddrinfo.return_value = [(socket.AF_INET, socket.SOCK_STREAM,
0, "", ("127.0.0.1", 80, 0, 0))]
c = WebSocketBaseClient(url="ws://127.0.0.1/?token=value")
s.recv.return_value = b"\r\n".join([
b"HTTP/1.1 101 Switching Protocols", b"Connection: Upgrade",
b"Sec-Websocket-Version: 13",
b"Content-Type: text/plain;charset=utf-8",
b"Sec-Websocket-Accept: " +
b64encode(sha1(c.key + WS_KEY).digest()), b"Upgrade: websocket",
b"Date: Sun, 26 Jul 2015 12:32:55 GMT", b"Server: ws4py/test",
b"\r\n"
])
c.connect()
s.connect.assert_called_once_with(("127.0.0.1", 80))
s.reset_mock()
c.close(code=1006, reason="boom")
args = s.sendall.call_args_list[0]
f = Frame()
f.parser.send(args[0][0])
f.parser.close()
self.assertIn(b'boom', f.unmask(f.body))
def test_empty_response(self, sock):
s = MagicMock()
sock.socket.return_value = s
sock.getaddrinfo.return_value = [(socket.AF_INET, socket.SOCK_STREAM,
0, "", ("127.0.0.1", 80, 0, 0))]
c = WebSocketBaseClient(url="ws://127.0.0.1/?token=value")
s.recv.return_value = b""
self.assertRaises(HandshakeError, c.connect)
s.shutdown.assert_called_once_with(socket.SHUT_RDWR)
s.close.assert_called_once_with()
def __init__(self, url, protocols=None, extensions=None,
heartbeat_freq=None, ssl_options=None, headers=None, instance_id=None):
WebSocketBaseClient.__init__(self, url,
protocols,
extensions,
heartbeat_freq,
ssl_options,
headers)
self.callbacks = {}
self._connected = False
self._local = False
self._cloud = False
self._version = ""
self._fd_notifier = None
self._heartbeat_timer = None
self._tunnel = None
self._instance_id = instance_id
# create an unique ID
self._id = WebSocketClient._instance_count
WebSocketClient._instance_count += 1
def __init__(self,
url,
protocols=None,
extensions=None,
heartbeat_freq=None,
ssl_options=None,
headers=None):
WebSocketBaseClient.__init__(self, url, protocols, extensions,
heartbeat_freq, ssl_options, headers)
self.callbacks = {}
self._connected = False
self._local = False
self._version = ""
self._fd_notifier = None
# create an unique ID
self._id = WebSocketClient._instance_count
WebSocketClient._instance_count += 1
# set a default timeout of 10 seconds
# for connecting to a server
socket.setdefaulttimeout(10)
def test_invdalid_response_code(self, sock):
s = MagicMock()
sock.socket.return_value = s
sock.getaddrinfo.return_value = [(socket.AF_INET, socket.SOCK_STREAM,
0, "", ("127.0.0.1", 80, 0, 0))]
c = WebSocketBaseClient(url="ws://127.0.0.1/?token=value")
s.recv.return_value = b"\r\n".join([
b"HTTP/1.1 200 Switching Protocols", b"Connection: Upgrade",
b"Sec-Websocket-Version: 13",
b"Content-Type: text/plain;charset=utf-8",
b"Sec-Websocket-Accept: " +
b64encode(sha1(c.key + WS_KEY).digest()), b"Upgrade: websocket",
b"Date: Sun, 26 Jul 2015 12:32:55 GMT", b"Server: ws4py/test",
b"\r\n"
])
self.assertRaises(HandshakeError, c.connect)
s.shutdown.assert_called_once_with(socket.SHUT_RDWR)
s.close.assert_called_once_with()
def __init__(self, dispatch, url):
WebSocketBaseClient.__init__(self, url,
protocols=['http-only', 'chat'])
self.dispatch = dispatch
self.keep_alive = None
def __init__(self, url, protocols=None, extensions=None, io_loop=None):
WebSocketBaseClient.__init__(self, url, protocols, extensions)
self.io = iostream.IOStream(self.sock, io_loop)
self.sender = self.io.write
def __init__(self, url, protocols=None, extensions=None):
WebSocketBaseClient.__init__(self, url, protocols, extensions)
self._th = Greenlet(self.run)
self.messages = Queue()
def __init__(self, url, protocols=None, extensions=None):
WebSocketBaseClient.__init__(self, url, protocols, extensions)
self._th = threading.Thread(target=self.run, name='WebSocketClient')
self._th.daemon = True
def __init__(self, url, protocols=None, version='8'):
WebSocketBaseClient.__init__(self, url, protocols=protocols, version=version)
self.io = iostream.IOStream(socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0))
class WsClientSocket(ClientSocket):
# TODO: this shares a lot with zmq...
def send(self, msg):
"""Send the message to the socket"""
self.sock.send(msg)
def received_message(self, msg):
assert self.msg is None, \
"Already got non-zero msg {}".format(self.msg)
self.msg = str(msg)
def recv(self, timeout=None):
"""Co-operatively block until received"""
start = time.time()
self.msg = None
if timeout is None:
timeout = self.timeout
while True:
if timeout:
t = start + timeout - time.time()
else:
t = None
self.sock.sock.settimeout(t)
if self.sock.once() is False:
# Failed
raise StopIteration
elif self.msg is not None:
# sys.stdout.write("Got message {}\n".format(self.msg))
# sys.stdout.flush()
return self.msg
def serialize(self, typ, kwargs):
"""Serialize the arguments to a string that can be sent to the socket
"""
_id = kwargs.pop("id")
assert type(_id) == int, "Need an integer ID, got {}".format(_id)
assert typ in SType, \
"Expected type in {}, got {}".format(list(SType.__members__), typ)
d = OrderedDict(type=typ.name)
d.update(id=_id)
if kwargs is not None:
d.update(kwargs)
s = presenter.serialize(d)
return s
def deserialize(self, msg):
"""Deserialize the string to
(typ, kwargs)"""
d = presenter.deserialize(msg)
typ = d.pop("type")
assert typ in SType.__members__, \
"Expected type in {}, got {}".format(list(SType.__members__), typ)
typ = SType.__members__[typ]
assert "id" in d, "No id in {}".format(d)
return typ, d
def open(self, address):
"""Open the socket on the given address"""
from cothread.cosocket import socket as cosocket
import socket
from ws4py.client import WebSocketBaseClient
_socket = socket.socket
socket.socket = cosocket
self.sock = WebSocketBaseClient(address)
self.sock.handshake_ok = lambda: None
socket.socket = _socket
self.sock.received_message = weak_method(self.received_message)
self.sock.connect()
def close(self):
"""Close the socket"""
self.sock.close()
def request(self, response, typ, kwargs):
"""Make a new request and send it out, storing a suitable id so that
any returns can be mapped to the response function using do_response"""
# lazily make request map
if not hasattr(self, "request_id"):
self.request_id = {}
self.last_id = -1
self.last_id += 1
assert self.last_id not in self.request_id, \
"Already have a request {} in {}".format(self.last_id,
self.request_id)
self.request_id[self.last_id] = response
self = weakref.proxy(self)
def do_request(typ, kwargs=None, _id=self.last_id):
if kwargs is None:
kwargs = OrderedDict()
kwargs.update(id=_id)
self.send(self.serialize(typ, kwargs))
do_request(typ, kwargs)
return do_request
def lookup_response(self, kwargs, remove_response=False):
"""Return the reponse function given the id stored in the args. If
remove, then remove it from the list"""
_id = kwargs.pop("id")
if remove_response:
return self.request_id.pop(_id)
else:
return self.request_id[_id]
def __init__(self, url, protocols=None, extensions=None): WebSocketBaseClient.__init__(self, url, protocols, extensions) self._th = threading.Thread(target=self.run, name='WebSocketClient') self._th.daemon = True
def __init__(self, url, mgr, ca_certs = None, keyfile = None, certfile = None):
self._mgr = mgr
WebSocketBaseClient.__init__(self, url, ssl_options = {
"ca_certs" : ca_certs,
"keyfile" : keyfile,
"certfile" : certfile })
