def connect(self, apiKey, secretKey, trace=False):
        self.host = OKEX_USD_CONTRACT
        self.apiKey = apiKey
        self.secretKey = secretKey
        self.trace = trace

        websocket.enableTrace(trace)

        self.ws = websocket.WebSocketApp(self.host,
                                         on_message=self.onMessage,
                                         on_error=self.onError,
                                         on_close=self.onClose,
                                         on_open=self.onOpen)

        self.thread = Thread(target=self.ws.run_forever, args=(None, None, 60, 30))
        self.thread.start()

    # ---------------------------------------------------------------------- 

def connect_Subpot(self, apiKey , secretKey , trace = False):
        self.host = GATEIO_SOCKET_URL
        self.apiKey = apiKey
        self.secretKey = secretKey
        self.trace = trace

        websocket.enableTrace(trace)

        self.ws = websocket.WebSocketApp(self.host, 
                                             on_message=self.onMessage,
                                             on_error=self.onError,
                                             on_close=self.onClose,
                                             on_open=self.onOpen)        
            
        self.thread = Thread(target = self.ws.run_forever , args = (None , None , 60, 30))
        # self.thread_heart = Thread(target = self.run_forever_heart)

        self.thread.start()
        # self.thread_heart.start()

    #---------------------------------------------------------------------- 

def run_subscription_batch_jobs(self):
        """
        请求 KLine 实时数据
        """
        websocket.enableTrace(False)
        self.__ws = websocket.WebSocketApp(
            self.HUOBIPRO_WEBSOCKET_URL,
            on_message=self.on_message,
            on_open=self.on_open,
            on_error=self.on_error,
            on_close=self.on_close
        )
        self.__locked = True

        # 如果意外退出，等待10秒重新运行
        while (True):
            self.__ws.run_forever()
            QA_util_log_expection("FTW! it quit! Retry 10 seconds later...")
            time.sleep(10) 

def _websocketThread(self, evtThreadEnded):
        try:
            websocket.enableTrace(False)
            self._ws = websocket.WebSocketApp(self._REST_URLS['websocket'] + self.access_token,
                                              on_open=self._on_open,
                                              on_message=self._on_message,
                                              on_close=self._on_close,
                                              on_error=self._on_error)

            # ping_timeout is for no blocking call
            self._ws.run_forever(ping_interval=self.ping_timeout/2, ping_timeout=self.ping_timeout)

        except AttributeError:
            self._on_error(websocket, 'No internet connection!')
        except Exception as ex:
            self._on_error(websocket, ex)
        finally:
            evtThreadEnded.set() 

def connect(self, host, apiKey, secretKey, trace=False):
        """连接服务器"""
        self.host = host
        self.apiKey = apiKey
        self.secretKey = secretKey
        
        if self.host == OKCOIN_CNY:
            self.currency = CURRENCY_CNY
        else:
            self.currency = CURRENCY_USD
            
        websocket.enableTrace(trace)
        
        self.ws = websocket.WebSocketApp(host, 
                                         on_message=self.onMessage,
                                         on_error=self.onError,
                                         on_close=self.onClose,
                                         on_open=self.onOpen)        
        
        self.thread = Thread(target=self.ws.run_forever)
        self.thread.start()
        
    #---------------------------------------------------------------------- 

def connect(self, host, apiKey, secretKey, trace=False):
        """连接服务器"""
        self.host = host
        self.apiKey = apiKey
        self.secretKey = secretKey
        
        if self.host == OKCOIN_CNY:
            self.currency = CURRENCY_CNY
        else:
            self.currency = CURRENCY_USD
            
        websocket.enableTrace(trace)
        
        self.ws = websocket.WebSocketApp(host, 
                                         on_message=self.onMessage,
                                         on_error=self.onError,
                                         on_close=self.onClose,
                                         on_open=self.onOpen)        
        
        self.thread = Thread(target=self.ws.run_forever)
        self.thread.start()
        
    #---------------------------------------------------------------------- 

def connect(self):
        self.logger.info("connect ws")
        websocket.enableTrace(True)
        self.ws = websocket.WebSocketApp("wss://www.deribit.com/ws/api/v1/",
                                  on_message = lambda ws,msg: self.on_message(ws, msg),
                                  on_error   = lambda ws,msg: self.on_error(ws, msg),
                                  on_open    = lambda ws:  self.on_open(ws),
                                  #on_open = self.on_open,                                  
                                  on_close = self.on_close)
        ssl_defaults = ssl.get_default_verify_paths()
        sslopt_ca_certs = {'ca_certs': ssl_defaults.cafile}
        self.wst = threading.Thread(target=lambda: self.ws.run_forever(sslopt=sslopt_ca_certs))
        self.wst.daemon = True
        self.wst.start()
        self.logger.info("Started thread")
        #TOOD subscribe later
        #self.ws.run_forever() 

def main():
    # Connect to websocket interfaces
    headers = {}
    userpass = ":".join(get_auth())
    headers["Authorization"] = "Basic " + base64.b64encode(
        userpass.encode()).decode()
    url = get_url()

    # If you really want to see everything going across the wire,
    # uncomment this. However realize the trace is going to also do
    # things like dump the binary sound packets in text in the
    # console.
    #
    # websocket.enableTrace(True)
    ws = websocket.WebSocketApp(url,
                                header=headers,
                                on_message=on_message,
                                on_error=on_error,
                                on_close=on_close)
    ws.on_open = on_open
    ws.args = parse_args()
    # This gives control over the WebSocketApp. This is a blocking
    # call, so it won't return until the ws.close() gets called (after
    # 6 seconds in the dedicated thread).
    ws.run_forever() 

def _init_publisher_ws(self):
        """
        Create a new web socket connection with proper headers.
        """
        logging.debug("Initializing new web socket connection.")

        url = ('wss://%s/v1/stream/messages/' % self.eventhub_client.host)

        headers = self._generate_publish_headers()

        logging.debug("URL=" + str(url))
        logging.debug("HEADERS=" + str(headers))

        websocket.enableTrace(False)
        self._ws = websocket.WebSocketApp(url,
                                          header=headers,
                                          on_message=self._on_ws_message,
                                          on_open=self._on_ws_open,
                                          on_close=self._on_ws_close)
        self._ws_thread = threading.Thread(target=self._ws.run_forever, kwargs={'ping_interval': 30})
        self._ws_thread.daemon = True
        self._ws_thread.start()
        time.sleep(1) 

def __init__(self, url, password):
        super().__init__()

        self._url = url
        self._password = password

        import websocket

        websocket.enableTrace(True)
        self._ws = websocket.WebSocket(skip_utf8_validation=True)
        self._ws.settimeout(10)
        self._ws.connect(self._url, timeout=5)
        prompt = self._ws.recv()
        if prompt != "Password: ":
            raise RuntimeError("Expected password prompt, got %r" % prompt)
        self._ws.send(self._password + "\r\n")

        self._reading_thread = threading.Thread(target=self._keep_reading, daemon=True)
        self._reading_thread.start() 

def receiveMsg_Start_Websocket(self, m, sender):
        if self.started: # already started
            return
        self.config = m
        self.started = True
        self.running = True

        # open the connection
        websocket.enableTrace(False)
        self.ws = websocket.create_connection(m.ws_addr)
        log.info("Websocket Connected")

        # set up the socket monitoring
        self.epoll = select.epoll()
        mask = select.EPOLLIN | select.EPOLLHUP | select.EPOLLERR
        self.epoll.register(self.ws.sock.fileno(), mask)

        # subscribe to the feed
        self.ws.send(m.start_msg)

        # start checking for data
        self.send(self.myAddress, WakeupMessage(None)) 

def __init__(self, logger, symbols, channels, URL, api_key, api_secret):
        self.logger = logger
        self.symbols = symbols
        self.channels = channels
        self.URL = URL
        if api_key is not None and api_secret is None:
            raise ValueError('Enter both public and secret keys')
        if api_key is None and api_secret is not None:
            raise ValueError('Enter both public and secret API keys')
        self.api_key = api_key
        self.api_secret = api_secret
        self.data = {}
        self.keys = {}
        # websocket.enableTrace(True)

        # Data table size - approcimate tick/min capacity per symbol.
        self.MAX_SIZE = 15000 * len(symbols)
        self.RECONNECT_TIMEOUT = 10

        self.connect() 

def __init__(self, url, token, on_server_ws_msg):
        #websocket.enableTrace(True)

        def on_message(ws, msg):
            on_server_ws_msg(ws, msg)

        def on_error(ws, error):
            print(error)

        self.ws = websocket.WebSocketApp(url,
                                  on_message = on_message,
                                  on_error = on_error,
                                  header = ["Authorization: Bearer " + token],
                                  subprotocols=["binary", "base64"]) 

def _listen(self):
        self.sock.listen(100)
        index = 0
        basic_auth_string = self.create_basic_auth()
        while True:
            self.client, _address = self.sock.accept()
            self.client.settimeout(1800)
            host = 'wss://{}{}'.format(self.remote_addr, '.scm.azurewebsites.net/AppServiceTunnel/Tunnel.ashx')
            basic_auth_header = 'Authorization: Basic {}'.format(basic_auth_string)
            cli_logger = get_logger()  # get CLI logger which has the level set through command lines
            is_verbose = any(handler.level <= logs.INFO for handler in cli_logger.handlers)
            if is_verbose:
                logger.info('Websocket tracing enabled')
                websocket.enableTrace(True)
            else:
                logger.warning('Websocket tracing disabled, use --verbose flag to enable')
                websocket.enableTrace(False)
            self.ws = create_connection(host,
                                        sockopt=((socket.IPPROTO_TCP, socket.TCP_NODELAY, 1),),
                                        class_=TunnelWebSocket,
                                        header=[basic_auth_header],
                                        sslopt={'cert_reqs': ssl.CERT_NONE},
                                        enable_multithread=True)
            logger.info('Websocket, connected status: %s', self.ws.connected)
            index = index + 1
            logger.info('Got debugger connection... index: %s', index)
            debugger_thread = Thread(target=self._listen_to_client, args=(self.client, self.ws, index))
            web_socket_thread = Thread(target=self._listen_to_web_socket, args=(self.client, self.ws, index))
            debugger_thread.start()
            web_socket_thread.start()
            logger.info('Both debugger and websocket threads started...')
            logger.warning('Successfully connected to local server..')
            debugger_thread.join()
            web_socket_thread.join()
            logger.info('Both debugger and websocket threads stopped...')
            logger.warning('Stopped local server..') 

def setUp(self):
        ws.enableTrace(TRACEABLE) 

def setUp(self):
        ws.enableTrace(TRACEABLE)

        WebSocketAppTest.keep_running_open = WebSocketAppTest.NotSetYet()
        WebSocketAppTest.keep_running_close = WebSocketAppTest.NotSetYet()
        WebSocketAppTest.get_mask_key_id = WebSocketAppTest.NotSetYet() 

def connect(self, apiKey, secretKey, trace=False):
        """
        连接网关
        :param apiKey   : 申请的API key
        :param secretKey: 签名key
        :param trace    : 是否开启websocket的日志跟踪功能，输出到StreamHandler
        :return:
        """
        # 更新websocket服务器地址/API key/
        self.host = OKEX_USD_SPOT
        self.apiKey = apiKey
        self.secretKey = secretKey

        # 是否开启日志
        websocket.enableTrace(trace)

        # 创建websocket，绑定本地回调函数 onMessage/onError/onClose/onOpen
        self.ws = websocket.WebSocketApp(self.host,
                                             on_message=self.onMessage,
                                             on_error=self.onError,
                                             on_close=self.onClose,
                                             on_open=self.onOpen)

        self.thread = Thread(target=self.ws.run_forever)
        self.thread.start()

    #---------------------------------------------------------------------- 

def __init__(self, ip, password):

        ConBase.__init__(self)
        threading.Thread.__init__(self)

        self.daemon = True

        self.fifo = deque()
        self.fifo_lock = threading.Lock()

        # websocket.enableTrace(logging.root.getEffectiveLevel() < logging.INFO)
        self.ws = websocket.WebSocketApp(
            "ws://%s:8266" % ip,
            on_message=self.on_message,
            on_error=self.on_error,
            on_close=self.on_close,
        )

        self.start()

        self.timeout = 5.0

        if b"Password:" in self.read(10, blocking=False):
            self.ws.send(password + "\r")
            if b"WebREPL connected" not in self.read(25, blocking=False):
                raise ConError()
        else:
            raise ConError()

        self.timeout = 1.0

        logging.info("websocket connected to ws://%s:8266" % ip) 

def open_websocket(url):
    def on_message(ws, message):
        print("message:")
        print(json.dumps(json.loads(message), indent=4))

    def on_error(ws, error):
        print("error:")
        print(error)

    def on_close(ws):
        print("### connection closed ###")

    def on_open(ws):
        print("### connection established ###")

        def run(*args):
            while True:
                time.sleep(HEARTBEAT_INTERVAL)
                ws.send(json.dumps({"type": "heartbeat"}))

        thread.start_new_thread(run, ())

    # websocket.enableTrace(True)
    ws = websocket.WebSocketApp(
        url, on_message=on_message, on_error=on_error, on_close=on_close)
    ws.on_open = on_open
    ws.run_forever() 

def __init__(self, stream, timeout=None, **kwargs):
        StreamIO.__init__(self)
        self.stream = stream
        self.session = stream.session
        self.timeout = timeout if timeout else self.session.options.get("stream-timeout")
        self.buffer = None

        if logger.root.level <= logger.DEBUG:
            websocket.enableTrace(True, log) 

def run_forever(self, *args, **kwargs):
        """
        This method is used to run the websocket app continuously.

        It will execute callbacks as defined and try to stay connected with the provided
        APIs
        """
        cnt = 0
        while not self.run_event.is_set():
            cnt += 1
            self.url = next(self.urls)
            log.debug("Trying to connect to node %s" % self.url)
            try:
                # websocket.enableTrace(True)
                self.ws = websocket.WebSocketApp(
                    self.url,
                    on_message=self.on_message,
                    on_error=self.on_error,
                    on_close=self.on_close,
                    on_open=self.on_open,
                )
                self.ws.run_forever()
            except websocket.WebSocketException:
                if self.num_retries >= 0 and cnt > self.num_retries:
                    raise NumRetriesReached()

                sleeptime = (cnt - 1) * 2 if cnt < 10 else 10
                if sleeptime:
                    log.warning(
                        "Lost connection to node during wsconnect(): %s (%d/%d) "
                        % (self.url, cnt, self.num_retries)
                        + "Retrying in %d seconds" % sleeptime
                    )
                    time.sleep(sleeptime)

            except KeyboardInterrupt:
                self.ws.keep_running = False
                return

            except Exception as e:
                log.critical("{}\n\n{}".format(str(e), traceback.format_exc())) 

def setUp(self):
        ws.enableTrace(TRACEABLE) 

def setUp(self):
        ws.enableTrace(TRACEABLE)

        WebSocketAppTest.keep_running_open = WebSocketAppTest.NotSetYet()
        WebSocketAppTest.keep_running_close = WebSocketAppTest.NotSetYet()
        WebSocketAppTest.get_mask_key_id = WebSocketAppTest.NotSetYet() 

def connect(self):
        """connects with the initialized detail"""
        if self.ws and self.ws.connected:
            return self.ws
        else:
            websocket.enableTrace(self.enable_trace)
            if self.username:
                base64_creds = base64.b64encode("{}:{}".format(self.username, self.password))
                self.headers.update({"Authorization": "Basic {}".format(base64_creds)})
            self.ws = websocket.create_connection(self.url, header=self.headers)
            self.ws.settimeout(self.timeout) 

def websocket_debug():
    websocket.enableTrace(True) 

def connect(ping_timeout=20, ping_interval=70):
    if cryptowatch.api_key:
        DSN = "{}?apikey={}&format=binary".format(
            cryptowatch.ws_endpoint, cryptowatch.api_key
        )
    else:
        raise APIKeyError(
            "An API key is required to use the Cryptowatch Websocket API.\n"
            "You can create one at https://cryptowat.ch/account/api-access"
        )
    log("DSN used: {}".format(DSN), is_debug=True)
    websocket.enableTrace(False)
    global _ws
    _ws = websocket.WebSocketApp(
        DSN,
        on_message=on_market_update,
        on_error=_on_error,
        on_close=_on_close,
        on_open=_on_open,
    )
    wst = threading.Thread(
        target=_ws.run_forever,
        kwargs={"ping_timeout": ping_timeout, "ping_interval": ping_interval},
    )
    wst.daemon = False
    wst.start()
    log(
        "Ping timeout used: {}. Ping interval used: {}".format(
            ping_timeout, ping_interval
        ),
        is_debug=True,
    ) 

def prepareSocket(self):
   #time.sleep(1)   
   websocket.enableTrace(True)
   self.ws = websocket.create_connection("ws://192.168.1.2:8888/ws")
   self.ws.send('GET HTTP/1.1 200 OK\nContent-Type: text/html\n\n'.encode('utf-8'))
   print("Sending 'Hello, World'...")
   self.ws.send("Hello, World")
   print("Sent")
   print("Receiving...")
   result = self.ws.recv()
   print("Received '%s'" % result)
   self.ws.close() 

def main():
    client = RestClient(k, s)

    def on_message(ws, message):
        m = message
        n = m["notifications"]
        print (n[0]["message"])
        #print(message)

    def on_error(ws, error):
        print(error)

    def on_close(ws):
        print("### closed ###")

    def on_open(ws):
        data = {
            "id": 5533, 
            "action": "/api/v1/private/subscribe",  
            "arguments": {
                "instrument": ["all"],
                "event": ["order_book"] 
            }
        }
        data['sig'] = client.generate_signature(data['action'], data['arguments'])

        ws.send(json.dumps(data))

    websocket.enableTrace(True)
    ws = websocket.WebSocketApp("wss://www.deribit.com/ws/api/v1/",
                              on_message = on_message,
                              on_error = on_error,
                              on_close = on_close)
    ws.on_open = on_open
    ws.run_forever() 

def run(params):
  signal.signal(signal.SIGINT, signal_handler) #Assign the signal handler
  
  if(sdnpwn.checkArg(["-t", "--target"], params)):
    
    port = str(sdnpwn.getArg(["-p", "--port"], params, 8181))
    cookie = sdnpwn.getArg(["-c", "--cookie"], params, None)
    
    wsURL = "ws://" + sdnpwn.getArg(["-t", "--target"], params) + ":" + port + "/onos/ui/websock/core"
    #websocket.enableTrace(True)
    ws = websocket.WebSocketApp(wsURL)
    ws.on_open = onOpen
    ws.on_message = onMessage
    ws.on_error = onError
    ws.on_close = onClose
    ws.sdnpwn_params = params
    ws.sdnpwn_expected_events = 1 #Execting initial bootstrap event
    
    if(cookie is not None):
      ws.cookie = cookie
    
    sdnpwn.printNormal("Attempting connection to " + wsURL)
    
    ws.run_forever()

  else:
    print(usage()) 

def setUp(self):
        ws.enableTrace(TRACEABLE)