async def do():
loop = asyncio.get_event_loop()
client = Client(["localhost:8081"], loop=loop)
doer = client.get_doer()
while True:
logger.debug("doing.... ")
try:
result = await doer.do({
"type": 'get_candles',
"value": {
"signatures": {
"default": "candle",
},
"topic": {
"exchange": "huobi",
"quote_currency": "usdt",
"base_currency": "btc",
"timeframe": "1m",
},
"start_ts": 1545293880,
"end_ts": 1545295020
}
})
logger.debug("result: %s", result)
except Exception:
logger.error("Failed to check: %s", traceback.format_exc())
await asyncio.sleep(5)
async def __check(self):
try:
if not self.__is_alive():
await self.__disconnect()
await self.__connect()
except Exception:
logger.error("Failed to check: %s", traceback.format_exc())
async def __ensure_frontend_resolved(self):
while True:
try:
return await self.__master.resolve_frontend(False)
except Exception:
logger.error("Failed to resolve frontend: %s",
traceback.format_exc())
await asyncio.sleep(1)
continue
async def __ensure_watched(self, action_type):
while True:
try:
await self.__request(self.__build_watch_req(action_type))
logger.info("Watched action_type: %s", action_type)
break
except Exception:
logger.error("Failed to watch: %s", traceback.format_exc())
await asyncio.sleep(1)
def notify(self, event, result=None):
callbacks = self.__listeners.get(event, [])
for callback in callbacks:
try:
if result != None:
callback(result)
else:
callback()
except Exception:
logger.error("Failed to notify: %s", traceback.format_exc())
def __on_action(self, action):
if action.__class__ != protocol_types.do_req_t:
logger.error("Ignored action: %s", action)
return
callback = self.__watch_callbacks.get(action.type)
if callback != None:
try:
callback(Action(action, self.__connection, self.__loop))
except Exception:
logger.error("Failed to notify: %s", traceback.format_exc())
async def __disconnect(self):
try:
if self.__websocket is not None:
self.__on_disconnecting()
await self.__websocket.close()
self.__on_disconnected()
except Exception:
logger.error("Failed to disconnect: %s", traceback.format_exc())
self.__on_error(Code.FAILED_TO_DISCONNECT)
finally:
self.__open_event.clear()
self.__closed_event.set()
async def destroy_table():
loop = asyncio.get_event_loop()
client = Client("localhost:8888", loop=loop)
while True:
try:
table = "huobi.btc.usdt.1m"
await client.destroy_table(table)
except Exception:
logger.error("Failed to check: %s", traceback.format_exc())
await asyncio.sleep(1)
async def get_tables():
loop = asyncio.get_event_loop()
client = Client("localhost:8888", loop=loop)
while True:
try:
names, ids = await client.get_tables()
logger.info("Received names: %s, ids: %s", names, ids)
except Exception:
logger.error("Failed to check: %s", traceback.format_exc())
await asyncio.sleep(1)
async def __send(self, msg):
encoded_msg = None
try:
encoded_msg = protocol.encode_msg(msg)
except Exception:
logger.error("Failed to encode: %s", traceback.format_exc())
self.__on_error(Code.FAILED_TO_ENCODE)
try:
if encoded_msg:
await self.__websocket.send(encoded_msg)
except Exception:
logger.error("Failed to send: %s", traceback.format_exc())
self.__on_error(Code.FAILED_TO_SEND)
async def __disconnect(self):
try:
if self.__websocket != None:
self.__on_disconnecting()
await self.__websocket.close()
self.__on_disconnected()
self.__delete_repeat_ping_task()
self.__delete_repeat_receive_task()
except Exception:
logger.error("Failed to disconnect: %s", traceback.format_exc())
self.__on_error(Code.FAILED_TO_DISCONNECT)
finally:
self.__open_event.clear()
async def set_rows():
loop = asyncio.get_event_loop()
client = Client("localhost:8888", loop=loop)
global count
while True:
try:
keys, values = build_rows()
await client.set_rows("huobi.btc.usdt.1m", keys, values)
count += 1
if count % 1000 == 0:
logger.info("count: %s", count)
except Exception:
logger.error("Failed to check: %s", traceback.format_exc())
async def repeat_publish():
client = Client(["localhost:8081", "localhost:8082"], loop=loop)
publisher = client.get_publisher()
while True:
value = int(time.time())
logger.debug("************Publish msg: %s", value)
try:
await publisher.publish("topic_3",
value.to_bytes(8, byteorder='little'))
except Exception:
logger.error("Failed to encode: %s", traceback.format_exc())
await asyncio.sleep(1)
async def __connect(self):
try:
self.__on_connecting()
self.__websocket = await websockets.connect(uri=self.__build_url(
self.__endpoint),
ping_interval=None)
self.__open_event.set()
self.__on_connected()
self.__delete_repeat_ping_task()
self.__add_repeat_ping_task()
self.__delete_repeat_receive_task()
self.__add_repeat_receive_task()
except Exception:
logger.error("Failed to connect: %s", traceback.format_exc())
self.__on_error(Code.FAILED_TO_CONNECT)
async def __connect(self):
try:
self.__on_connecting()
self.__websocket = await websockets.connect(uri=self.__build_url(
self.__endpoint),
ping_interval=None,
max_size=None)
self.__open_event.set()
self.__closed_event.clear()
self.__on_connected()
except Exception:
logger.error("Failed to connect: %s", traceback.format_exc())
self.__on_error(Code.FAILED_TO_CONNECT)
if self.__should_run:
await asyncio.sleep(self.__options.get("reconnect_delay"))
await self.__connect()
async def get_boundary_rows():
loop = asyncio.get_event_loop()
client = Client("localhost:8888", loop=loop)
global count
while True:
try:
table = "huobi.btc.usdt.1m"
rows = await client.get_boundary_rows(table)
logger.info("Received rows: %s", rows)
count += 1
if count % 1000 == 0:
logger.info("count: %s", count)
except Exception:
logger.error("Failed to check: %s", traceback.format_exc())
await asyncio.sleep(1)
async def get_nth_last_value():
loop = asyncio.get_event_loop()
client = Client("localhost:8888", loop=loop)
global count
while True:
try:
table = "huobi.btc.usdt.1m"
value = await client.get_nth_last_value(table, 0)
logger.info("Received value: %s", value)
count += 1
if count % 1000 == 0:
logger.info("count: %s", count)
except Exception:
logger.error("Failed to check: %s", traceback.format_exc())
await asyncio.sleep(1)
async def delete_rows_since():
loop = asyncio.get_event_loop()
client = Client("localhost:8888", loop=loop)
global count
while True:
try:
table = "huobi.btc.usdt.1m"
key = struct.pack('>I', 2)
await client.delete_rows_since(table, key, 2)
break
count += 1
if count % 1000 == 0:
logger.info("count: %s", count)
except Exception:
logger.error("Failed to check: %s", traceback.format_exc())
await asyncio.sleep(1)
async def get_values_until():
loop = asyncio.get_event_loop()
client = Client("localhost:8888", loop=loop)
global count
while True:
try:
table = "huobi.btc.usdt.1m"
key = struct.pack('>I', 3)
values = await client.get_values_until(table, key, 10)
logger.info("Received values: %s", values)
count += 1
if count % 1000 == 0:
logger.info("count: %s", count)
except Exception:
logger.error("Failed to check: %s", traceback.format_exc())
await asyncio.sleep(1)
async def get_rows_between():
loop = asyncio.get_event_loop()
client = Client("localhost:8888", loop=loop)
global count
while True:
try:
table = "huobi.btc.usdt.1m"
begin_key = struct.pack('>I', 3)
end_key = struct.pack('>I', 11)
keys, values = await client.get_rows_between(
table, begin_key, end_key, 3)
logger.info("Received keys: %s, values: %s", keys, values)
count += 1
if count % 1000 == 0:
logger.info("count: %s", count)
except Exception:
logger.error("Failed to check: %s", traceback.format_exc())
await asyncio.sleep(1)
async def __pull(self, topic):
msg_queue = self.__msg_queue_mgr.get(topic)
event = self.__events.get(topic)
callback = self.__subscribe_callbacks.get(topic)
offset = self.__subscription_mgr.get_doing(topic)
pull_rep = await self.__request(self.__build_pull_req(topic, offset))
msg_queue.put(pull_rep.msgs)
self.__subscription_mgr.to_doing(topic, msg_queue.last_offset() + 1)
try:
callback(topic)
except Exception:
logger.error("Failed to notify: %s", traceback.format_exc())
if msg_queue.is_full():
logger.info(
"Msg queue is full, waiting for consuming: "
"topic: %s, last offset: %s", topic, msg_queue.last_offset())
event.clear()
await event.wait()
async def __recv(self):
try:
encoded_msg = await self.__websocket.recv()
except websockets.ConnectionClosed:
logger.warning("Connection closed: endpoint: %s", self.__endpoint)
self.__open_event.clear()
self.__closed_event.set()
return
except Exception as e:
logger.error("Failed to recv: %s", traceback.format_exc())
self.__on_error(Code.FAILED_TO_RECEIVE)
return
try:
msg = protocol.decode_msg(encoded_msg)
if msg.__class__ != protocol_types.ping_rep_t:
self.__on_msg(msg)
except Exception:
logger.error("Failed to decode: %s", traceback.format_exc())
self.__on_error(Code.FAILED_TO_DECODE)
async def __recv(self):
encoded_msg = None
try:
encoded_msg = await self.__websocket.recv()
except Exception as e:
logger.error("Failed to recv: %s", traceback.format_exc())
self.__on_error(Code.FAILED_TO_RECEIVE)
if isinstance(e, websockets.exceptions.ConnectionClosed):
return False
self.__activate()
try:
if encoded_msg:
msg = protocol_ext.decode_msg(encoded_msg)
if msg.__class__ != protocol_types.PingRep:
self.__on_msg(msg)
except Exception:
logger.error("Failed to decode: %s", traceback.format_exc())
self.__on_error(Code.FAILED_TO_DECODE)
return True
def __on_msg(self, msg):
msg_type = msg.__class__
if msg_type == protocol_types.do_req_t:
self.notify(Event.ON_MESSAGE, msg)
return
if msg_type == protocol_types.do_rep_t \
or msg_type == protocol_types.ok2_rep_t \
or msg_type == protocol_types.error2_rep_t:
ref = msg.traces[0].ref
else:
ref = msg.ref
event = self.__arrived_events.get(ref)
if event == None:
logger.error("Failed to find event: msg: %s", msg)
return
if msg_type == protocol_types.error_rep_t \
or msg_type == protocol_types.error2_rep_t:
self.__msgs[ref] = (msg.code, msg.desc)
else:
self.__msgs[ref] = (Code.OK, msg)
event.set()
