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 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, 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 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 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 __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_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, 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 })