async def _order_book_diff_router(self):
"""
Route the real-time order book diff messages to the correct order book.
"""
last_message_timestamp: float = time.time()
messages_queued: int = 0
messages_accepted: int = 0
messages_rejected: int = 0
address_token_map: Dict[
str, any] = await self._data_source.get_all_token_info()
while True:
try:
ob_message: BambooRelayOrderBookMessage = await self._order_book_diff_stream.get(
)
base_token_address: str = ob_message.content["event"][
"baseTokenAddress"]
quote_token_address: str = ob_message.content["event"][
"quoteTokenAddress"]
base_token_symbol: str = address_token_map[base_token_address][
"symbol"]
quote_token_symbol: str = address_token_map[
quote_token_address]['symbol']
trading_pair_symbol: str = f"{base_token_symbol}-{quote_token_symbol}"
if trading_pair_symbol not in self._tracking_message_queues:
messages_queued += 1
# Save diff messages received before snapshots are ready
self._saved_message_queues[trading_pair_symbol].append(
ob_message)
continue
message_queue: asyncio.Queue = self._tracking_message_queues[
trading_pair_symbol]
# Check the order book's initial update ID. If it's larger, don't bother.
order_book: BambooRelayOrderBook = self._order_books[
trading_pair_symbol]
if order_book.snapshot_uid > ob_message.update_id:
messages_rejected += 1
continue
await message_queue.put(ob_message)
if ob_message.content[
"action"] == "FILL": # put FILL messages to trade queue
trade_type = float(TradeType.BUY.value) if ob_message.content["type"] == "BUY" \
else float(TradeType.SELL.value)
self._order_book_trade_stream.put_nowait(
OrderBookMessage(OrderBookMessageType.TRADE, {
"symbol":
trading_pair_symbol,
"trade_type":
trade_type,
"trade_id":
ob_message.update_id,
"update_id":
ob_message.timestamp,
"price":
ob_message.content["order"]["price"],
"amount":
ob_message.content["order"]
["filledBaseTokenAmount"]
},
timestamp=ob_message.timestamp))
messages_accepted += 1
# Log some statistics.
now: float = time.time()
if int(now / 60.0) > int(last_message_timestamp / 60.0):
self.logger().debug(
"Diff messages processed: %d, rejected: %d, queued: %d",
messages_accepted, messages_rejected, messages_queued)
messages_accepted = 0
messages_rejected = 0
messages_queued = 0
last_message_timestamp = now
except asyncio.CancelledError:
raise
except Exception:
self.logger().network(
f"Unexpected error routing order book messages.",
exc_info=True,
app_warning_msg=
f"Unexpected error routing order book messages. Retrying after 5 seconds."
)
await asyncio.sleep(5.0)
async def _order_book_diff_router(self):
"""
Route the real-time order book diff messages to the correct order book.
"""
last_message_timestamp: float = time.time()
messages_queued: int = 0
messages_accepted: int = 0
messages_rejected: int = 0
while True:
try:
ob_message: IDEXOrderBookMessage = await self._order_book_diff_stream.get(
)
trading_pair: str = ob_message.trading_pair
if trading_pair not in self._tracking_message_queues:
messages_queued += 1
# Save diff messages received before snapshots are ready
self._saved_message_queues[trading_pair].append(ob_message)
continue
message_queue: asyncio.Queue = self._tracking_message_queues[
trading_pair]
# Check the order book's initial update ID. If it's larger, don't bother.
order_book: IDEXOrderBook = self._order_books[trading_pair]
if order_book.snapshot_uid > ob_message.update_id:
messages_rejected += 1
continue
await message_queue.put(ob_message)
if ob_message.content[
"event"] == "market_trades": # put trade messages to trade queue
trade_type = float(TradeType.BUY.value) if ob_message.content["type"].upper() == "BUY" \
else float(TradeType.SELL.value)
self._order_book_trade_stream.put_nowait(
OrderBookMessage(
OrderBookMessageType.TRADE, {
"trading_pair": ob_message.content["market"],
"trade_type": trade_type,
"trade_id": ob_message.content["tid"],
"update_id": ob_message.timestamp,
"price": ob_message.content["price"],
"amount": ob_message.content["amount"]
},
timestamp=ob_message.timestamp))
messages_accepted += 1
# Log some statistics.
now: float = time.time()
if int(now / 60.0) > int(last_message_timestamp / 60.0):
self.logger().debug(
"Diff messages processed: %d, rejected: %d, queued: %d",
messages_accepted, messages_rejected, messages_queued)
messages_accepted = 0
messages_rejected = 0
messages_queued = 0
last_message_timestamp = now
except asyncio.CancelledError:
raise
except Exception:
self.logger().network(
f"Unexpected error routing order book messages.",
exc_info=True,
app_warning_msg=
f"Unexpected error routing order book messages. Retrying after 5 seconds."
)
await asyncio.sleep(5.0)
async def _order_book_diff_router(self):
"""
Route the real-time order book diff messages to the correct order book.
"""
last_message_timestamp: float = time.time()
message_queued: int = 0
message_accepted: int = 0
message_rejected: int = 0
while True:
try:
ob_message: BittrexOrderBookMessage = await self._order_book_diff_stream.get(
)
trading_pair: str = ob_message.trading_pair
if trading_pair not in self._tracking_message_queues:
message_queued += 1
# Save diff messages received before snaphsots are ready
self._saved_message_queues[trading_pair].append(ob_message)
continue
message_queue: asyncio.Queue = self._tracking_message_queues[
trading_pair]
# Check the order book's initial update ID. If it's larger, don't bother.
order_book: BittrexOrderBook = self._order_books[trading_pair]
if order_book.snapshot_uid > ob_message.update_id:
message_rejected += 1
continue
await message_queue.put(ob_message)
message_accepted += 1
if len(ob_message.content["f"]) != 0:
for trade in ob_message.content["f"]:
trade_type = float(TradeType.SELL.value) if trade["OT"].upper() == "SELL" \
else float(TradeType.BUY.value)
self._order_book_trade_stream.put_nowait(
OrderBookMessage(OrderBookMessageType.TRADE, {
"trading_pair": ob_message.trading_pair,
"trade_type": trade_type,
"trade_id": trade["FI"],
"update_id": trade["T"],
"price": trade["R"],
"amount": trade["Q"]
},
timestamp=trade["T"]))
# Log some statistics
now: float = time.time()
if int(now / 60.0) > int(last_message_timestamp / 60.0):
self.logger().debug(f"Diff message processed: "
f"{message_accepted}, "
f"rejected: {message_rejected}, "
f"queued: {message_queue}")
message_accepted = 0
message_rejected = 0
message_queued = 0
last_message_timestamp = now
except asyncio.CancelledError:
raise
except Exception:
self.logger().network(
f"Unexpected error routing order book messages.",
exc_info=True,
app_warning_msg=
f"Unexpected error routing order book messages. Retrying after 5 seconds.",
)
await asyncio.sleep(5.0)
