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)