public void Start(IExchangeWorker exchangeWorker, int pageSize)
        {
            ExchangeWorker = exchangeWorker;

            foreach (var symbolCode in ExchangeWorker.Configuration.Symbol)
            {
                var symbol = SymbolFactory.Get(symbolCode);

                if (symbol.Tradable)
                {
                    AggregateTrades(symbol, pageSize);
                }
            }
        }
        public void Start(IExchangeWorker exchangeWorker, int limit)
        {
            ExchangeWorker = exchangeWorker;

            HttpClient = Exchange.GetHttpClient();

            Logger = LoggerFactory.CreateLogger($"Historian.{Exchange.Name}.Worker.TradeCatchup");

            using (Logger.BeginExchangeScope(Exchange.Name))
            {
                EnsureHistoricalTrades();

                BeginTradeCatchupWorker(limit);
            }
        }
Esempio n. 3
0
        public void Start(IExchangeWorker exchangeWorker) => Task.Run(async() =>
        {
            ExchangeWorker = exchangeWorker;

            if (Exchange.SupportedStatKeys == null)
            {
                return;
            }

            Logger = LoggerFactory.CreateLogger($"Historian.{Exchange.Name}.Worker.TradeStats");

            HttpClient = Exchange.GetHttpClient();

            using (Logger.BeginExchangeScope(Exchange.Name))
            {
                using (Logger.BeginProtocolScope("Https"))
                {
                    while (true)
                    {
                        if (!ExchangeWorker.Online)
                        {
                            await Task.Delay(1000);

                            continue;
                        }

                        var symbols = ExchangeWorker.Configuration.Symbol.Select(symbolCode => SymbolFactory.Get(symbolCode)).Where(s => s.Tradable);

                        foreach (var symbol in symbols)
                        {
                            using (Logger.BeginSymbolScope(symbol.Code))
                            {
                                foreach (var statsKey in Exchange.SupportedStatKeys)
                                {
                                    using (Logger.BeginExchangeStatsScope(statsKey))
                                    {
                                        await ReceiveTradeStatsHttp(symbol, statsKey);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        });
Esempio n. 4
0
        public void Start(IExchangeWorker exchangeWorker, int pageSize)
        {
            ExchangeWorker = exchangeWorker;

            if (Exchange.SupportedStatKeys == null)
            {
                return;
            }

            foreach (var symbolCode in ExchangeWorker.Configuration.Symbol)
            {
                var symbol = SymbolFactory.Get(symbolCode);

                if (symbol.Tradable)
                {
                    foreach (var statsKey in Exchange.SupportedStatKeys)
                    {
                        AggregateTradeStats(symbol, statsKey, pageSize);
                    }
                }
            }
        }
        public void Start(IExchangeWorker exchangeWorker, int limit)
        {
            ExchangeWorker = exchangeWorker;
            Limit          = limit;

            HttpClient      = Exchange.GetHttpClient();
            WebSocketClient = Exchange.GetWebSocketClient();

            Logger = LoggerFactory.CreateLogger($"Historian.{Exchange.Name}.Worker.Trades");

            using (Logger.BeginExchangeScope(Exchange.Name))
            {
                if (WebSocketClient != null && exchangeWorker.Configuration.UseWebSocket)
                {
                    BeginReceiveTradesWebSocket();
                }
                else
                {
                    BeginReceiveTradesHttp();
                }
            }
        }