async def _create_authenticated_producers(self):
for updater in AUTHENTICATED_UPDATER_PRODUCERS:
if self._is_managed_by_websocket(updater.CHANNEL_NAME):
# websocket is handling this channel: initialize data if required
if self._is_websocket_feed_requiring_init(updater.CHANNEL_NAME):
try:
updater(get_chan(updater.CHANNEL_NAME, self.id)).trigger_single_update()
except Exception as e:
self._logger.exception(e, True, f"Error when initializing data for {updater.CHANNEL_NAME} "
f"channel required by websocket: {e}")
else:
# no websocket for this channel: start an updater
await updater(get_chan(updater.CHANNEL_NAME, self.id)).run()
async def stop_exchange_channels(self, should_warn=True):
try:
for channel_name in list(get_exchange_channels(self.id)):
channel = get_chan(channel_name, self.id)
await channel.stop()
for consumer in channel.consumers:
await channel.remove_consumer(consumer)
get_chan(channel_name, self.id).flush()
del_chan(channel_name, self.id)
del_exchange_channel_container(self.id)
except KeyError:
if should_warn:
self._logger.error(f"No exchange channel for this exchange (id: {self.id})")
async def stop_exchange_channels(self):
try:
chan_names = list(get_exchange_channels(self.id).keys())
for channel_name in chan_names:
channel = get_chan(channel_name, self.id)
await channel.stop()
for consumer in channel.consumers:
await channel.remove_consumer(consumer)
get_chan(channel_name, self.id).flush()
del_chan(channel_name, self.id)
del_exchange_channel_container(self.id)
except KeyError:
self._logger.error(f"No exchange channel for this exchange (id: {self.id})")
async def _create_exchange_producers(self):
# Real data producers
if not self.is_backtesting:
for updater in UNAUTHENTICATED_UPDATER_PRODUCERS:
if not self._is_managed_by_websocket(updater.CHANNEL_NAME):
await updater(get_chan(updater.CHANNEL_NAME, self.id)).run()
if self.exchange.is_authenticated and not (self.is_simulated or self.is_backtesting or self.is_collecting):
for updater in AUTHENTICATED_UPDATER_PRODUCERS:
if not self._is_managed_by_websocket(updater.CHANNEL_NAME):
await updater(get_chan(updater.CHANNEL_NAME, self.id)).run()
# Simulated producers
if (not self.exchange.is_authenticated or self.is_simulated or self.is_backtesting) and not self.is_collecting:
for updater in AUTHENTICATED_UPDATER_SIMULATOR_PRODUCERS:
await updater(get_chan(updater.CHANNEL_NAME, self.id)).run()
async def push_to_channel(self, channel_name, **kwargs):
try:
asyncio.run_coroutine_threadsafe(
get_chan(
channel_name,
self.exchange_id).get_internal_producer().push(**kwargs),
asyncio.get_event_loop())
except Exception as e:
self.logger.error(f"Push to {channel_name} failed : {e}")
async def _create_exchange_producers(self):
# Always init exchange user data first on real trading
if self.exchange.is_authenticated \
and self.trader and self.is_trading \
and not (self.is_simulated or self.is_backtesting or self.is_collecting):
await self._create_authenticated_producers()
# Real data producers
if not self.is_backtesting:
for updater in UNAUTHENTICATED_UPDATER_PRODUCERS:
if not self._is_managed_by_websocket(updater.CHANNEL_NAME):
await updater(get_chan(updater.CHANNEL_NAME, self.id)).run()
# Simulated producers
if (not self.exchange.is_authenticated or self.is_simulated or self.is_backtesting) \
and self.trader and self.is_trading \
and not self.is_collecting:
for updater in AUTHENTICATED_UPDATER_SIMULATOR_PRODUCERS:
await updater(get_chan(updater.CHANNEL_NAME, self.id)).run()
async def add_order_book_feed(self):
if self.is_feed_available(Feeds.L2_BOOK):
order_book_callback = OrderBookCallBack(self, get_chan(ORDER_BOOK_CHANNEL,
self.exchange_manager.id))
self.__add_feed_and_run_if_required(Feeds.L2_BOOK, BookCallback(order_book_callback.l2_order_book_callback))
await order_book_callback.run()
self.is_handling_order_book = True
else:
self.logger.warning(f"{self.exchange_manager.exchange_class_string.title()}'s "
f"websocket is not handling order book")
async def add_tickers_feed(self):
if self.is_feed_available(Feeds.TICKER):
tickers_callback = TickersCallBack(self, get_chan(TICKER_CHANNEL, self.exchange_manager.id))
self.__add_feed_and_run_if_required(Feeds.TICKER, TickerCallback(tickers_callback.tickers_callback))
await tickers_callback.run()
self.is_handling_price_ticker = True
else:
self.logger.warning(f"{self.exchange_manager.exchange_name}'s "
f"websocket is not handling tickers")
async def add_recent_trade_feed(self):
if self.is_feed_available(Feeds.TRADES):
recent_trade_callback = RecentTradesCallBack(self,
get_chan(RECENT_TRADES_CHANNEL,
self.exchange_manager.id))
self.__add_feed_and_run_if_required(Feeds.TRADES,
TradeCallback(recent_trade_callback.recent_trades_callback))
await recent_trade_callback.run()
self.is_handling_recent_trades = True
else:
self.logger.warning(f"{self.exchange_manager.exchange_class_string.title()}'s "
f"websocket is not handling recent trades")
async def subscribe_to_order_channels(callback):
order_channel_name = OrdersChannel.get_name()
for exchange_id in get_exchange_ids():
channel = get_chan(order_channel_name, exchange_id)
await channel.new_consumer(callback)
async def subscribe_to_trades_channel(callback):
trades_channel_name = TradesChannel.get_name()
for exchange_id in get_exchange_ids():
channel = get_chan(trades_channel_name, exchange_id)
await channel.new_consumer(callback)
async def _subscribe_to_channel(callback, exchange_id, channel):
channel = get_chan(channel.get_name(), exchange_id)
await channel.new_consumer(callback)
async def subscribe_to_order_channel(callback, exchange_id):
order_channel_name = OrdersChannel.get_name()
channel = get_chan(order_channel_name, exchange_id)
await channel.new_consumer(callback)
