def handle_write_event(self):
log.debug( "handle_write_event")
if self._ssl_accepting:
self._do_ssl_handshake()
elif self._ssl_closing:
self._do_ssl_shutdown()
else:
asyncore.dispatcher.handle_write_event(self)
def close(self):
log.debug(traceback.format_stack())
log.debug("close")
if (isinstance(self.socket, ssl.SSLSocket) and
self.socket._sslobj is not None):
self._do_ssl_shutdown()
else:
asyncore.dispatcher.close(self)
def send(self, data):
log.debug("send")
try:
return asyncore.dispatcher.send(self,data)
except ssl.SSLError as err:
if err.args[0] in (ssl.SSL_ERROR_EOF, ssl.SSL_ERROR_ZERO_RETURN,
ssl.SSL_ERROR_WANT_READ,
ssl.SSL_ERROR_WANT_WRITE):
return 0
raise
def on_json_message(self, event):
message = json.loads(event.data)
if 'private' in message:
private = message['private'] #ticker, trade, depth
if private=='trade':
self.EVENT_TRADE.fire(message=message)
elif private=='ticker':
self.EVENT_TICKER_USD.fire(message=message)
elif private=='depth':
self.EVENT_DEPTH_USD.fire(message=message)
log.debug(event.endpoint + " " + str(message))
def on_frame(self, event):
msg_type, msg_id, msg_endpoint, msg_data = re.match("([0-9]):([^:]*):([^:]*):?(.*)", event.frame).groups()
if msg_type == SocketIO.MSG_CONNECTED:
if msg_endpoint == "":
self.state = SocketIO.CONNECTED
self.EVENT_CONNECTED_SOCKETIO.fire()
else:
self.EVENT_CONNECTED_ENDPOINT.fire(endpoint=msg_endpoint, data=msg_data)
elif msg_type == SocketIO.MSG_JSON_MESSAGE:
self.EVENT_JSON_MESSAGE.fire(data=msg_data, endpoint=msg_endpoint)
else:
log.debug("Unhandled message %s %s" % (msg_type, msg_data))
def recv(self, buffer_size):
log.debug("recv")
try:
return asyncore.dispatcher.recv(self, buffer_size)
except ssl.SSLError as err:
if err.args[0] in (ssl.SSL_ERROR_WANT_READ,
ssl.SSL_ERROR_WANT_WRITE):
return b''
if err.args[0] in (ssl.SSL_ERROR_EOF, ssl.SSL_ERROR_ZERO_RETURN):
self.handle_close()
return b''
raise
def make_key12(self):
nspaces = random.randint(1, 12)
max_n = WEBSOCKET_KEY_MAXINT / nspaces
number_n = random.randint(0, max_n)
product_n = number_n * nspaces
log.debug("websocket key: %d %d" % (number_n, product_n))
key_n = str(product_n)
for i in range(random.randint(1, 12)):
c = random.choice(AVAILABLE_KEY_CHARS)
pos = random.randint(0, len(key_n))
key_n = key_n[0:pos] + chr(c) + key_n[pos:]
for i in range(nspaces):
pos = random.randint(1, len(key_n)-1)
key_n = key_n[0:pos] + " " + key_n[pos:]
return number_n, key_n
def _do_ssl_handshake(self):
log.debug( "_do_ssl_handshake")
try:
self.socket.do_handshake()
except ssl.SSLError as err:
if err.args[0] in (ssl.SSL_ERROR_WANT_READ,
ssl.SSL_ERROR_WANT_WRITE):
return
elif err.args[0] == ssl.SSL_ERROR_EOF:
return self.handle_close()
raise
except socket.error as err:
if err.args[0] == errno.ECONNABORTED:
return self.handle_close()
else:
self._ssl_accepting = False
def _do_ssl_shutdown(self):
log.debug( "_do_ssl_shutdown")
self._ssl_closing = True
try:
self.socket = self.socket.unwrap()
except ssl.SSLError as err:
if err.args[0] in (ssl.SSL_ERROR_WANT_READ,
ssl.SSL_ERROR_WANT_WRITE):
return
except socket.error as err:
# Any "socket error" corresponds to a SSL_ERROR_SYSCALL return
# from OpenSSL's SSL_shutdown(), corresponding to a
# closed socket condition. See also:
# http://www.mail-archive.com/[email protected]/msg60710.html
pass
self._ssl_closing = False
asyncore.dispatcher.close(self)
def keep_alive(self):
next_heartbeat = time.time()
try:
while not self.shuttingdown:
t = time.time()
if self.state == SocketIO.DISCONNECTED:
try:
self.state = SocketIO.CONNECTING
self.connect_socketio()
except Exception as e:
self.state = SocketIO.DISCONNECTED
log.debug(traceback.format_exc())
log.warning("Error connecting : " + str(e))
time.sleep(SocketIO.RECONNECT_INTERVAL)
if self.state == SocketIO.CONNECTED and t >= next_heartbeat:
# Send heartbeat
log.debug("Send heartbeat")
self.websocket.send_message('2::')
next_heartbeat = t + self.heartbeat_interval - 10
time.sleep(1)
except:
traceback.print_exc()
def handle_close(self):
log.debug("handle_close2")
self.EVENT_DISCONNECTED.fire()
self.close()
def send_message(self, data):
log.debug("send_message" + data)
self.send('\x00' + data + '\xff')
def on_disconnected(self, event):
self.EVENT_DISCONNECTED_SOCKETIO.fire()
log.debug("disconnected!")
self.state = SocketIO.DISCONNECTED
def handle_error(self):
log.debug("handle_error")
traceback.print_exc()
