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