Пример #1
0
        private async ValueTask publishTicker(STickers stk)
        {
            await Task.Delay(0);

            var _json_data = JsonConvert.SerializeObject(stk);

            __ticker.Write(this, GMConfig.DealerName, _json_data);
        }
Пример #2
0
        private async ValueTask publishTicker(STickers sbt)
        {
            await Task.Delay(0);

            if (sbt.result.Count > 0)
            {
                var _json_data = JsonConvert.SerializeObject(sbt);
                __ticker.Write(this, BNConfig.DealerName, _json_data);
            }
        }
Пример #3
0
        public async ValueTask BStart(CancellationToken cancelToken, string symbol)
        {
            BNLogger.SNG.WriteO(this, $"bpolling service start...");

            if (__bnconfig.UsePollingTicker == true)
            {
                PollingTasks.Add(Task.Run(async() =>
                {
                    var _client = CreateJsonClient(publicApi.publicClient.ApiUrl);

                    var _b_params              = new Dictionary <string, object>();
                    var _b_request             = CreateJsonRequest($"/ticker/bookTicker", _b_params);
                    var _last_limit_milli_secs = 0L;

                    while (true)
                    {
                        try
                        {
                            await Task.Delay(0);

                            var _waiting_milli_secs = (CUnixTime.NowMilli - __bnconfig.PollingPrevTime) / __bnconfig.PollingTermTime;
                            if (_waiting_milli_secs == _last_limit_milli_secs)
                            {
                                var _waiting = cancelToken.WaitHandle.WaitOne(0);
                                if (_waiting == true)
                                {
                                    break;
                                }

                                await Task.Delay(10);
                                continue;
                            }

                            _last_limit_milli_secs = _waiting_milli_secs;

                            // ticker
                            var _b_json_value = await RestExecuteAsync(_client, _b_request);
                            if (_b_json_value.IsSuccessful && _b_json_value.Content[0] == '[')
                            {
                                var _b_json_data = JsonConvert.DeserializeObject <List <BTickerItem> >(_b_json_value.Content);

                                var _tickers = new STickers
                                {
                                    exchange     = BNLogger.SNG.exchange_name,
                                    stream       = "ticker",
                                    sequentialId = _last_limit_milli_secs,
                                    result       = _b_json_data.Where(t => t.symbol == symbol).ToList <STickerItem>()
                                };

                                var _b_json_content = JsonConvert.SerializeObject(_tickers);
                                Processing.SendReceiveQ(new QMessage {
                                    command = "AP", payload = _b_json_content
                                });
                            }
                            else
                            {
                                var _http_status = (int)_b_json_value.StatusCode;
                                if (_http_status == 403 || _http_status == 418 || _http_status == 429)
                                {
                                    BNLogger.SNG.WriteQ(this, $"request-limit: https_status => {_http_status}");

                                    var _waiting = cancelToken.WaitHandle.WaitOne(0);
                                    if (_waiting == true)
                                    {
                                        break;
                                    }

                                    await Task.Delay(1000);     // waiting 1 second
                                }
                            }
                        }
                        catch (TaskCanceledException)
                        {
                        }
                        catch (Exception ex)
                        {
                            BNLogger.SNG.WriteX(this, ex.ToString());
                        }
                        //finally
                        {
                            if (cancelToken.IsCancellationRequested == true)
                            {
                                break;
                            }
                        }

                        var _cancelled = cancelToken.WaitHandle.WaitOne(0);
                        if (_cancelled == true)
                        {
                            break;
                        }
                    }
                },
                                          cancelToken
                                          ));
            }

            await Task.WhenAll(PollingTasks);

            BNLogger.SNG.WriteO(this, $"bpolling service stop...");
        }