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 __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, 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, 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 __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, 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, 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, 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, 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 __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 __init__(self, *args, **kwargs): """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, *args, **kwargs) WebSocketBaseClient.__init__(self, self._uri)
def __init__(self, url, protocols=None, extensions=None, heartbeat_freq=None, ssl_options=None, headers=None, exclude_headers=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, heartbeat_freq, ssl_options=ssl_options, headers=headers, exclude_headers=exclude_headers) self._th = Greenlet(self.run) self.messages = Queue() """
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, 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 __init__(self, url, protocols=None, extensions=None, io_loop=None, ssl_options=None, headers=None, exclude_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, exclude_headers=exclude_headers) if self.scheme == "wss": self.sock = ssl.wrap_socket(self.sock, do_handshake_on_connect=False, **self.ssl_options) self._is_secure = True 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 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 __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, 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 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, 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 __init__(self, url, protocols=None, extensions=None, heartbeat_freq=None, ssl_context=None, headers=None, exclude_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_context, headers=headers, exclude_headers=exclude_headers) self._th = threading.Thread(target=self.run, name='WebSocketClient') self._th.daemon = True
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, job_id, input_params=None, msg_output_format="{job} {level} {msg}", msg_callback=None, print_job_info=True): self.job_id = job_id 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' 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, 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 __init__(self, dispatch, url): WebSocketBaseClient.__init__(self, url, protocols=['http-only', 'chat']) self.dispatch = dispatch self.keep_alive = None
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 })
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, version='8', io_loop=None): WebSocketBaseClient.__init__(self, url, protocols=protocols, version=version) self.io = iostream.IOStream(socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0), io_loop)
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, ws_uri, resource, *args, **kwargs): WebSocketBaseClient.__init__(self, ws_uri, *args, **kwargs) self.resource = resource
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, 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))
def __init__(self, dispatch, url): WebSocketBaseClient.__init__(self, url, protocols=['http-only', 'chat']) self.dispatch = dispatch self.keep_alive = None