def __on_error(self, error):
'''Called on fatal websocket errors. We exit on these.'''
if not self.exited:
self.logger.error("Error : %s" % error)
raise websocket.WebSocketException(error)
def __on_close(self):
'''Called on websocket close.'''
# self.emit('close', [])
self.logger.info('Websocket Closed')
raise websocket.WebSocketException('Websocket Closed')
def on_error(e):
print('$')
logging.warn(e)
raise websocket.WebSocketException(e)
def receive(self):
"""
Receive x bytes from the websocket.
:rtype: bytes
"""
while True:
try:
_LOGGER.debug("websocket: rx")
data = self.ws.recv()
_LOGGER.debug("websocket: rxed")
if type(data) == str:
return str.encode(data)
return data
except websocket.WebSocketConnectionClosedException:
_LOGGER.error("websocket: connection closed!")
self.connected = False
raise exception.ConnectionClosedException()
except socket.error as e:
time.sleep(5)
_LOGGER.error("websocket: reconnecting! not really...")
raise exception.ConnectionClosedException()
# self.attempt_connection()
# continoue
try:
frame = self.ws.recv_frame()
except websocket.WebSocketException:
_LOGGER.error("websocket.WebSocketException")
raise exception.ConnectionClosedException()
# raise
# return websocket.ABNF.OPCODE_CLOSE, None
if not frame:
_LOGGER.error(
"websocket.WebSocketException, not a valid frame: %s" % frame)
raise websocket.WebSocketException(
"websocket: Not a valid frame: %s" % frame)
elif frame.opcode in OPCODE_DATA:
_LOGGER.error("websocket got OPCODE_DATA")
if type(frame.data) == str:
return str.encode(frame.data)
return frame.data
# return str(frame.data)
elif frame.opcode in OPCODE_TEXT:
_LOGGER.error("websocket got OPCODE_TEXT")
if type(frame.data) == str:
return str.encode(frame.data)
return frame.data
# return str(frame.data, "utf-8")
elif frame.opcode == websocket.ABNF.OPCODE_CLOSE:
_LOGGER.error("websocket got OPCODE_CLOSE")
self.ws.send_close()
raise exception.ConnectFailedException()
# return None
elif frame.opcode == websocket.ABNF.OPCODE_PING:
_LOGGER.error("websocket got OPCODE_PING")
self.ws.pong(frame.data)
return None
if type(frame.data) == str:
return str.encode(frame.data)
return frame.data
def _on_error(self, error):
if not self.exited:
logging.error(f'Error during websocket listening {error}')
raise websocket.WebSocketException(error)
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 __on_error(self, ws, error):
"""Called on fatal websocket errors. We exit on these."""
if not self.exited:
logger.error("Error : %s" % error)
raise websocket.WebSocketException(error)
