def __connect(self, wsURL): """Connect to the websocket in a thread.""" logger.debug('Starting thread') self.ws = websocket.WebSocketApp(wsURL, on_message=self.__on_message, on_close=self.__on_close, on_open=self.__on_open, on_error=self.__on_error ) self.wst = threading.Thread(target=lambda: self.ws.run_forever()) self.wst.daemon = True self.wst.start() logger.debug('Started thread') # Wait for connect before continuing conn_timeout = 5 while not self.ws.sock or not self.ws.sock.connected and conn_timeout: sleep(1) conn_timeout -= 1 if not conn_timeout: logger.error('Couldnt connect to WS! Exiting.') self.exit() raise websocket.WebSocketTimeoutException('Couldnt connect to WS! Exiting.')
def __connect(self, wsURL, symbol): '''Connect to the websocket in a thread.''' self.logger.debug("Starting thread") self.ws = websocket.WebSocketApp(wsURL, on_message=self.__on_message, on_close=self.__on_close, on_open=self.__on_open, on_error=self.__on_error, header=self.__get_auth()) self.wst = threading.Thread(target=lambda: self.ws.run_forever()) self.wst.daemon = True self.wst.start() self.logger.debug("Started thread") # Wait for connect before continuing conn_timeout = 5 while not self.ws.sock or not self.ws.sock.connected and conn_timeout: time.sleep(1) conn_timeout -= 1 if not conn_timeout: self.logger.error("Couldn't connect to WS! Exiting.") self.exit() raise websocket.WebSocketTimeoutException( 'Couldn\'t connect to WS! Exiting.')
def __connect(self, endpoint): '''Connect to the websocket in a thread.''' self.logger.debug("Starting thread") options = {"ping_interval": 45, "ping_timeout": self.socket_timeout} if self.insecure_ssl: options["sslopt"] = {"cert_reqs": ssl.CERT_NONE} self.ws = websocket.WebSocketApp(endpoint, on_message=self.__on_message, on_close=self.__on_close, on_open=self.__on_open, on_error=self.__on_error) self.wst = threading.Thread( target=lambda: self.ws.run_forever(**options)) self.wst.daemon = True self.wst.start() self.logger.debug("Started thread") # Wait for connect before continuing conn_timeout = 5 while (not self.ws.sock or not self.ws.sock.connected) and conn_timeout: sleep(1) conn_timeout -= 1 if not conn_timeout: self.logger.error("Couldn't connect to WS! Exiting.") self.exit() raise websocket.WebSocketTimeoutException( 'Couldn\'t connect to WS! Exiting.')
def __connect(self, wsURL): '''Connect to the websocket in a thread.''' self.logger.debug("Starting thread") self.ws = websocket.WebSocketApp(wsURL, on_message=self.__on_message, on_close=self.__on_close, on_open=self.__on_open, on_error=self.__on_error, header=self.__get_auth(), on_ping=self.__on_ping, on_pong=self.__on_pong) ws_run_args = {'ping_timeout': 20, 'ping_interval': 60} self.wst = threading.Thread(target=self.ws.run_forever, kwargs=ws_run_args) self.wst.daemon = True self.wst.start() self.logger.debug("Started thread") # Wait for connect before continuing conn_timeout = 5 while not self.ws.sock or not self.ws.sock.connected and conn_timeout: sleep(1) conn_timeout -= 1 if not conn_timeout: self.logger.error("Couldn't connect to WS! Exiting.") self.exit() raise websocket.WebSocketTimeoutException( 'Couldn\'t connect to WS! Exiting.')
def connect(self, ws_url): """Connect to the websocket in a thread.""" self.logger.debug("Starting websocket thread.") self.ws = websocket.WebSocketApp( ws_url, on_message=self.on_message, on_close=self.on_close, on_open=self.on_open, on_error=self.on_error, ) self.wst = threading.Thread(target=lambda: self.ws.run_forever()) self.wst.daemon = True self.wst.start() self.logger.debug("Started websocket thread.") # Wait for connect before continuing conn_timeout = 5 while (not self.ws.sock or not self.ws.sock.connected) and conn_timeout: time.sleep(1) conn_timeout -= 1 if not conn_timeout: self.logger.error("Couldn't connect to websocket! Exiting.") self.exit() raise websocket.WebSocketTimeoutException( "Couldn't connect to websocket! Exiting.") self.exited = False
def __connect(self, wsURL, symbol): '''Connect to the websocket in a thread.''' '''*********NEED TO CHANGE THIS PART WHENT PUT ON CLOUD!!!*********''' self.logger.debug("Starting thread") self.ws = websocket.WebSocketApp(wsURL, on_message=self.__on_message, on_close=self.__on_close, on_open=self.__on_open, on_error=self.__on_error, header=self.__get_auth()) # self.wst = threading.Thread(target=lambda: self.ws.run_forever()) self.wst = threading.Thread(target=lambda :self.ws.run_forever(http_proxy_host="127.0.0.1", http_proxy_port=7890)) self.wst.daemon = True self.wst.start() self.logger.debug("Started thread") # Wait for connect before continuing conn_timeout = 5 while not self.ws.sock or not self.ws.sock.connected and conn_timeout: sleep(1) conn_timeout -= 1 if not conn_timeout: self.logger.error("Couldn't connect to WS! Exiting.") self.exit() raise websocket.WebSocketTimeoutException("Couldn't connect to WS! Exiting.")
def start(self): ''' This is used to start the socket. ''' if not(self.socketRunning): logging.info('SOCKET: Setting up socket connection.') self.create_socket() logging.info('SOCKET: Setup socket.') ## -------------------------------------------------------------- ## # This block is used to test connectivity to the socket. conn_timeout = 5 while not self.ws.sock or not self.ws.sock.connected and conn_timeout: time.sleep(1) conn_timeout -= 1 if not conn_timeout: # If the timeout limit is reached then the websocket is force closed. self.ws.close() raise websocket.WebSocketTimeoutException('Couldn\'t connect to WS! Exiting.') ## -------------------------------------------------------------- ## self.socketRunning = True logging.info('SOCKET: Sucessfully created socket connection.') logging.info('SOCKET: Sucessfully started socket.')
def start(self): ''' This is used to start the socket. ''' if self.socketRunning: return('SOCKET_STILL_RUNNING_PLEASE_RESTART') ## -------------------------------------------------------------- ## ## Here the sockets URL is set so it can be connected to.NO_STREAMS_SET logging.debug('[SOCKET_MASTER] Setting up socket stream URL.') if self.query == '': if self.build_query() == 'NO_STREAMS_SET': return('UNABLE_TO_START_NO_STREAMS_SET') self.destURL = self.query ## -------------------------------------------------------------- ## ## Here the 'create_socket' function is called to attempt a connection to the socket. logging.debug('[SOCKET_MASTER] Setting up socket connection.') self._create_socket() ## -------------------------------------------------------------- ## # This block is used to test connectivity to the socket. conn_timeout = 5 while not self.ws.sock or not self.ws.sock.connected and conn_timeout: time.sleep(5) conn_timeout -= 1 if not conn_timeout: ## If the timeout limit is reached then the websocket is force closed. self.ws.close() raise websocket.WebSocketTimeoutException('Couldn\'t connect to WS! Exiting.') self.socketRunning = True logging.info('[SOCKET_MASTER] Sucessfully established the socket.')
def __connect(self, wsURL): '''Connect to the websocket in a thread.''' self.logger.debug("Starting thread") self.ws = websocket.WebSocketApp(wsURL, on_message=self.__on_message, on_close=self.__on_close, on_open=self.__on_open, on_error=self.__on_error, keep_running=True) self.wst = threading.Thread(target=lambda: self.ws.run_forever()) self.wst.daemon = True self.wst.start() self.logger.debug("Started thread") # Wait for connect before continuing retry_times = 5 while not self.ws.sock or not self.ws.sock.connected and retry_times: sleep(1) retry_times -= 1 if retry_times == 0 and not self.ws.sock.connected: self.logger.error("Couldn't connect to WebSocket! Exiting.") self.exit() raise websocket.WebSocketTimeoutException( 'Error!Couldn not connect to WebSocket!.') if self.api_key and self.api_secret: self.__do_auth()
def __connect(self): """Connect to the websocket in a thread.""" self.lastUsedUrlIdx +=1 if self.lastUsedUrlIdx >= len(self.wsURLs): self.lastUsedUrlIdx= 0 usedUrl= self.wsURLs[self.lastUsedUrlIdx] self.logger.info("Connecting to %s" % usedUrl) self.logger.debug("Starting thread") self.exited = False self.auth = False self.ws = websocket.WebSocketApp(usedUrl, on_message=self.on_message, on_close=self.__on_close, on_open=self.__on_open, on_error=self.on_error, keep_running=True) self.wst = threading.Thread(target=lambda: self.ws.run_forever(ping_interval=5)) self.wst.daemon = True self.wst.start() self.logger.debug("Started thread") # Wait for connect before continuing retry_times = 5 while (self.ws.sock is None or not self.ws.sock.connected) and retry_times > 0: sleep(1) retry_times -= 1 if retry_times == 0 and (self.ws.sock is None or not self.ws.sock.connected): self.logger.error("Couldn't connect to WebSocket! Exiting.") self.exit() raise websocket.WebSocketTimeoutException('Error!Couldnt not connect to WebSocket!.') if self.api_key and self.api_secret: self.do_auth()
def _connect(self): """ Connect to the L2 Orderbook of XBTUSD from Bitmex. Callbacks are defined and the websocket is opened. """ self.logger.debug("Starting thread") self.ws = websocket.WebSocketApp('wss://www.bitmex.com/realtime', on_message=self._on_message, on_close=self._on_close, on_open=self._on_open, on_error=self._on_error) self.wst = threading.Thread(target=lambda: self.ws.run_forever()) self.wst.setDaemon(True) self.wst.start() self.logger.debug("Started thread") conn_timeout = 5 while not self.ws.sock or not self.ws.sock.connected and conn_timeout: sleep(1) conn_timeout -= 1 if not conn_timeout: self.logger.error("Couldn't connect to WS! Exiting.") self.exit() raise websocket.WebSocketTimeoutException( 'Couldn\'t connect to WS! Exiting.')
def close(self): """ Closes the WebSocket connection """ self.logger.info("Closing WebSocket Connection") self._wss.close() self._isOpen = False if not self._close_event.wait(10) and self._wss.sock.connected: raise websocket.WebSocketTimeoutException( "Failed to received Websocket Close event")
def validate_socket(self, ws): # Wait for connect before continuing conn_timeout = 5 while not ws.sock or not ws.sock.connected and conn_timeout: sleep(1) conn_timeout -= 1 if not conn_timeout: logger.error("Couldn't connect to WS! Exiting.") self.exit(ws) raise websocket.WebSocketTimeoutException( 'Couldn\'t connect to WS! Exiting.')
def _wait_for_ws_connect(self): conn_timeout = 5 while ( (not self.ws.sock or not self.ws.sock.connected) and conn_timeout and not self._error ): time.sleep(1) conn_timeout -= 1 if not conn_timeout: # i.e. if conn_timeout = 0 logging.error("Couldn't connect to websocket! Exiting.") raise webs.WebSocketTimeoutException( "Couldn't connect to websocket! Exiting." )
def start(self, markets, query): ''' This is used to start the socket. ''' if self.ws != None and self.socketRunning: self.stop() ## -------------------------------------------------------------- ## ## Here the socket buffer is setup to store the data for each symbol. logging.debug('SOCKET: Setting up buffer.') socketBuffer = {} for market in markets: socketBuffer.update( {market: { 'depth': { 'bids': [], 'asks': [] }, 'candle': {} }}) self.socketBuffer = socketBuffer ## -------------------------------------------------------------- ## ## Here the sockets URL is set so it can be connected to. logging.debug('SOCKET: Setting up socket stream URL.') if query[-1] == '/': query = query[:-1] self.destURL = '{0}/stream?streams={1}'.format(SOCKET_BASE, query) ## -------------------------------------------------------------- ## ## Here the 'create_socket' function is called to attempt a connection to the socket. logging.debug('SOCKET: Setting up socket connection.') self.create_socket() ## -------------------------------------------------------------- ## # This block is used to test connectivity to the socket. conn_timeout = 5 while not self.ws.sock or not self.ws.sock.connected and conn_timeout: time.sleep(5) conn_timeout -= 1 if not conn_timeout: ## If the timeout limit is reached then the websocket is force closed. self.ws.close() raise websocket.WebSocketTimeoutException( 'Couldn\'t connect to WS! Exiting.') self.socketRunning = True logging.info('SOCKET: Sucessfully established the socket.')
def _wait_for_authentication(self): """Waits until we have received message confirming authentication""" timeout = 50 while not self.authenticated and timeout: time.sleep(0.1) timeout -= 1 if not timeout: logging.error("Couldn't authenticate connection! Exiting.") raise webs.WebSocketTimeoutException( "Couldn't authenticate connection! Exiting." ) logging.info("Successfully authenticated")
def _thread_connect(self): self.close(reset_symbol=False) print('websocket connecting to %s...' % self.url) self.ws = websocket.WebSocketApp(self.url, on_message=self.on_message, on_error=self.on_error) self.thread_io = Thread(target=self.ws.run_forever) self.thread_io.daemon = True self.thread_io.start() for _ in range(100): if self.ws.sock and self.ws.sock.connected: break sleep(0.1) else: self.close() raise websocket.WebSocketTimeoutException('websocket connection failed') self.subscribe(self.symbol, self.interval) print('websocket connected')
def _connect_websocket(self): self.ws = WebSocketApp(url=self.ws_url, on_open=self.__on_open, on_message=self.__on_message, on_close=self.__on_close) self.wst = threading.Thread(target=lambda: self.ws.run_forever()) self.wst.daemon = True self.wst.start() self.wst.join() conn_timeout = 10 while not self.ws.sock or not self.ws.sock.connected and conn_timeout: time.sleep(1) conn_timeout -= 1 if not conn_timeout: raise websocket.WebSocketTimeoutException( "Couldn't connect to WS! Exiting. Please check your host settings. ")
def __connect(self, wsURL, symbol): self.ws = websocket.WebSocketApp(wsURL, on_message=self.__on_message, on_close=self.__on_close, on_open=self.__on_open, on_error=self.__on_error, ) self.wst = threading.Thread(target=lambda: self.ws.run_forever(ping_interval=10)) # 线程保护 self.wst.daemon = True self.wst.start() print("Started thread") conn_timeout = 5 while not self.ws.sock or not self.ws.sock.connected and conn_timeout: sleep(1) conn_timeout -= 1 if not conn_timeout: print("无法连接到bitmex.") self.exit() raise websocket.WebSocketTimeoutException('Couldn\'t connect to WS! Exiting.')
def _connect(self, wsURL): self.ws = websocket.WebSocketApp(wsURL, on_message=self._on_message, on_close=self._on_close, on_open=self._on_open, on_error=self._on_error, header=self._get_auth()) self.wst = threading.Thread(target=lambda: self.ws.run_forever()) self.wst.daemon = True self.wst.start() conn_timeout = 10 while not self.ws.sock or not self.ws.sock.connected and conn_timeout: sleep(1) conn_timeout -= 1 if not conn_timeout: self.exit() raise websocket.WebSocketTimeoutException('Couldn\'t connect to WS! Exiting.') return True
local_date = datetime.utcnow() delta = local_date - remote_date delta_seconds = delta.total_seconds() if delta_seconds < self.min_diff: self.min_diff = delta_seconds # print(data[-1]["timestamp"]) # self.write(data) tt = TimeTester() url = "wss://www.bitmex.com/realtime?subscribe=trade:XBTUSD" ws = websocket.WebSocketApp(url, on_message=tt.receive) wst = threading.Thread(target=lambda: ws.run_forever()) wst.daemon = True wst.start() sleep(3) if not ws.sock or not ws.sock.connected: raise websocket.WebSocketTimeoutException() for i in range(1, 90): print tt.min_diff sleep(10) print "done"
def run_forever(self, sockopt=None, sslopt=None, ping_interval=0, ping_timeout=None, http_proxy_host=None, http_proxy_port=None, http_no_proxy=None, http_proxy_auth=None, skip_utf8_validation=False, host=None, origin=None): """ Patched version which handles more exceptions compared to original """ if not ping_timeout or ping_timeout <= 0: ping_timeout = None if sockopt is None: sockopt = [] if sslopt is None: sslopt = {} if self.sock: raise websocket.WebSocketException("socket is already opened") thread = None close_frame = None try: self.sock = websocket.WebSocket( self.get_mask_key, sockopt=sockopt, sslopt=sslopt, fire_cont_frame=self.on_cont_message and True or False, skip_utf8_validation=skip_utf8_validation) self.sock.settimeout(websocket.getdefaulttimeout()) self.sock.connect(self.url, header=self.header, cookie=self.cookie, http_proxy_host=http_proxy_host, http_proxy_port=http_proxy_port, http_no_proxy=http_no_proxy, http_proxy_auth=http_proxy_auth, subprotocols=self.subprotocols, host=host, origin=origin) self._callback(self.on_open) if ping_interval: event = threading.Event() thread = threading.Thread(target=self._send_ping, args=(ping_interval, event)) thread.setDaemon(True) thread.start() while self.sock.connected: r, w, e = select.select((self.sock.sock, ), (), (), ping_timeout) if not self.keep_running: break if ping_timeout and self.last_ping_tm and time.time( ) - self.last_ping_tm > ping_timeout: self.last_ping_tm = 0 raise websocket.WebSocketTimeoutException("ping timed out") if r: op_code, frame = self.sock.recv_data_frame(True) if op_code == websocket.ABNF.OPCODE_CLOSE: close_frame = frame break elif op_code == websocket.ABNF.OPCODE_PING: self._callback(self.on_ping, frame.data) elif op_code == websocket.ABNF.OPCODE_PONG: self._callback(self.on_pong, frame.data) elif op_code == websocket.ABNF.OPCODE_CONT and self.on_cont_message: self._callback(self.on_data, data, frame.opcode, frame.fin) self._callback(self.on_cont_message, frame.data, frame.fin) else: data = frame.data if six.PY3 and frame.opcode == websocket.ABNF.OPCODE_TEXT: data = data.decode("utf-8") self._callback(self.on_data, data, frame.opcode, True) self._callback(self.on_message, data) except (Exception, KeyboardInterrupt, SystemExit) as e: self._callback(self.on_error, e) if isinstance(e, SystemExit): # propagate SystemExit further raise finally: if thread: event.set() thread.join() self.keep_running = False self.sock.close() self._callback( self.on_close, *self._get_close_args( close_frame.data if close_frame else None)) self.sock = None
def open(self, open_socket_time_out=30): """ Opens a WebSocket connection Note: There is a sub-protocol, that needs to be passed known as 'Gabbo' protocol :param open_socket_time_out: How long to wait, in s, for opening the connection to take :return: None """ self._open_event.clear() self._close_event.clear() self.logger.debug( "Opening Web Socket connection to the device with IP: %s", self._ip_address) self._jsonIn[:] = [] _clientName = datetime.datetime.now().isoformat() if self._ip_address not in ['127.0.0.1', 'localhost']: tflag = self.check_before_open() self.logger.info("The value of tflag: %s", tflag) if not tflag: raise websocket.WebSocketTimeoutException( "FrontDoor not Listening on port 8082") if int(self._port) == 8082: self.fd_url = "wss://" + self._ip_address + ":" + str( self._port) + "/?product=EddieTest" + _clientName self.logger.info("The websocket url is: {}".format( self.fd_url)) self._wss = websocket.WebSocketApp(self.fd_url, subprotocols=['eco2'], on_message=self._onMessage, on_error=self._onError, on_close=self._onClose) if int(self._port) == 8086: self.fd_url = "ws://" + self._ip_address + ":" + str( self._port) + "/?product=EddieTest" + _clientName self.logger.info("The websocket url is: {}".format( self.fd_url)) self._wss = websocket.WebSocketApp(self.fd_url, subprotocols=['eco2'], on_message=self._onMessage, on_error=self._onError, on_close=self._onClose) else: self._wss = websocket.WebSocketApp("ws://127.0.0.1:" + str(self._port), on_message=self._onMessage, on_error=self._onError, on_close=self._onClose) self.json_in_event = threading.Event() self.json_in_event.clear() self._wss.on_open = self._onOpen self._run() open_socket_start_time = time.time() self.logger.debug( "Waiting for WebSocket connection to be established.") while not self._wss.sock: if (time.time() - open_socket_start_time) > open_socket_time_out: raise websocket.WebSocketTimeoutException( 'Failed to acquire a socket after {}s'.format( open_socket_time_out)) self.logger.debug("Connecting to WebSocket Object: %s", self._wss.sock) connected_start_time = time.time() while not self._wss.sock.connected: if (time.time() - connected_start_time) > self._web_socket_timeout: # It's taking too long, better close the connection self.logger.error("WebSocket Timeout - No Route to host") self._wss.close() break if not self._open_event.wait(10): raise websocket.WebSocketTimeoutException( "Failed to received Websocket Open event") total_open_time = time.time() - open_socket_start_time self.logger.debug( "Total time for connection to WebSocket: {:.3f}".format( total_open_time)) self.logger.info("Is the WebSocket connection established? %s", self._wss.sock.connected)