示例#1
0
        private async Task RunAsync(CancellationToken stoppingToken)
        {
            try
            {
                var sleepTimeLimit = Options.EmptySleepTime * 1000;
                var sleepTime      = 0;

                var bucket = CreateBucket(Options.Speed);
                var batch  = (int)Options.Batch;

                while (!stoppingToken.IsCancellationRequested)
                {
                    var requests = (await _services.Scheduler.DequeueAsync(batch)).ToArray();

                    if (requests.Length > 0)
                    {
                        //重置
                        sleepTime = 0;

                        foreach (var request in requests)
                        {
                            while (bucket.ShouldThrottle(1, out var waitTimeMillis))
                            {
                                await Task.Delay(waitTimeMillis, default);
                            }

                            await PublishRequestMessagesAsync(request);
                        }
                    }
                    else
                    {
                        OnSchedulerEmpty?.Invoke();
                        sleepTime += 10;
                        // 等待空队列超时
                        if (!await WaitForContinueAsync(sleepTime, sleepTimeLimit))
                        {
                            break;
                        }
                    }
                }
            }
            catch (Exception e)
            {
                Logger.LogError($"{Id} exited by exception: {e}");
            }
            finally
            {
                Stop();
            }
        }
示例#2
0
        private async Task RunAsync(CancellationToken stoppingToken)
        {
            var tuple          = ComputeIntervalAndDequeueBatch(Options.Speed);
            var sleepTimeLimit = Options.EmptySleepTime * 1000;

            await Task.Factory.StartNew(async() =>
            {
                try
                {
                    var pausedTime = 0;
                    var sleepTime  = 0;
                    var printFlag  = 0;
                    while (!stoppingToken.IsCancellationRequested)
                    {
                        printFlag += tuple.Interval;
                        if (printFlag >= 5000)
                        {
                            printFlag = 0;

                            await _services.StatisticsClient.PrintAsync(Id);
                        }

                        if (_requestedQueue.Count > Options.RequestedQueueCount)
                        {
                            if (pausedTime > sleepTimeLimit)
                            {
                                Logger.LogInformation(
                                    $"{Id} paused too much time");
                                break;
                            }

                            pausedTime += tuple.Interval;
                            Logger.LogInformation(
                                $"{Id} too much requests enqueued");
                            await Task.Delay(tuple.Interval, default);
                            continue;
                        }

                        pausedTime          = 0;
                        var timeoutRequests = _requestedQueue.GetAllTimeoutList();
                        if (timeoutRequests.Length > 0)
                        {
                            foreach (var request in timeoutRequests)
                            {
                                Logger.LogWarning(
                                    $"{Id} request {request.RequestUri}, {request.Hash} timeout");
                            }

                            await AddRequestsAsync(timeoutRequests);

                            OnTimeout?.Invoke(timeoutRequests);
                        }
                        else
                        {
                            var requests = (await _services.Scheduler.DequeueAsync(tuple.Batch)).ToArray();

                            if (requests.Length > 0)
                            {
                                sleepTime = 0;
                            }
                            else
                            {
                                sleepTime += tuple.Interval;
                                if (sleepTime > sleepTimeLimit)
                                {
                                    Logger.LogError($"Exit by sleep too long: {sleepTime}");
                                    break;
                                }

                                OnSchedulerEmpty?.Invoke();
                            }

                            foreach (var request in requests)
                            {
                                ConfigureRequest(request);
                            }

                            if (!await PublishRequestMessagesAsync(requests))
                            {
                                Logger.LogError("Exit by publish request message failed");
                                break;
                            }
                        }

                        await Task.Delay(tuple.Interval, default);
                    }
                }
                catch (Exception e)
                {
                    Logger.LogError($"{Id} exited by exception: {e}");
                }
                finally
                {
                    await ExitAsync();
                }
            }, stoppingToken);
        }
示例#3
0
        private async Task RunAsync(CancellationToken stoppingToken)
        {
            try
            {
                var sleepTimeLimit = Options.EmptySleepTime * 1000;

                var bucket    = CreateBucket(Options.Speed);
                var sleepTime = 0;
                var batch     = (int)Options.Batch;
                var start     = DateTime.Now;
                var end       = start;

                PrintStatistics(stoppingToken);

                while (!stoppingToken.IsCancellationRequested)
                {
                    if (_requestedQueue.Count > Options.RequestedQueueCount)
                    {
                        sleepTime += 10;

                        if (await WaitForContinueAsync(sleepTime, sleepTimeLimit, (end - start).TotalSeconds,
                                                       $"{Id} too much requests enqueued"))
                        {
                            continue;
                        }
                        else
                        {
                            break;
                        }
                    }

                    if (await HandleTimeoutRequestAsync())
                    {
                        continue;
                    }

                    var requests = (await _services.Scheduler.DequeueAsync(batch)).ToArray();

                    if (requests.Length > 0)
                    {
                        sleepTime = 0;

                        foreach (var request in requests)
                        {
                            ConfigureRequest(request);

                            while (bucket.ShouldThrottle(1, out var waitTimeMillis))
                            {
                                await Task.Delay(waitTimeMillis, default);
                            }

                            if (!await PublishRequestMessagesAsync(request))
                            {
                                Logger.LogError("Exit by publish request message failed");
                                break;
                            }
                        }

                        end = DateTime.Now;
                    }
                    else
                    {
                        OnSchedulerEmpty?.Invoke();

                        sleepTime += 10;

                        if (!await WaitForContinueAsync(sleepTime, sleepTimeLimit, (end - start).TotalSeconds))
                        {
                            break;
                        }
                    }
                }
            }
            catch (Exception e)
            {
                Logger.LogError($"{Id} exited by exception: {e}");
            }
            finally
            {
                await ExitAsync();
            }
        }