public async Task Do_not_run_task_before_previous_completion() { // arrange var done = false; var slowTaskSource = new TaskCompletionSource <bool>(); Task SlowAsync(CancellationToken token) => slowTaskSource.Task; Task DoneAsync(CancellationToken token) { done = true; return(Task.CompletedTask); } // act using (var tasks = new TaskQueue(_logger)) { _ = tasks.Enqueue(SlowAsync); var doneTask = tasks.Enqueue(DoneAsync); // assert await Task.Delay(100); done.Should().BeFalse(); slowTaskSource.SetResult(true); await slowTaskSource.Task; await doneTask; done.Should().BeTrue(); await tasks.DrainOutAsync(); } }
private void KeepAlive(object state) { if (_connections.IsEmpty && _connections.Count == 0) { return; } _taskQueue.Enqueue(async() => { var sockets = GetAll(); var openSockets = sockets.Where(s => s.State == WebSocketState.Open).ToArray(); if (_logger.IsEnabled(LogLevel.Trace)) { _logger.LogTrace("Sending web socket keep alive to {OpenSocketsCount} open connections of {SocketCount} total connections", openSockets.Length, sockets.Count); } foreach (var socket in openSockets) { try { await socket.SendAsync(buffer: _keepAliveMessage, messageType: WebSocketMessageType.Text, endOfMessage: true, cancellationToken: CancellationToken.None); } catch (WebSocketException ex) when(ex.WebSocketErrorCode == WebSocketError.ConnectionClosedPrematurely) { // NOTE: This will not remove it from the ConnectionMappings. await RemoveWebSocketAsync(socket); } catch (Exception ex) { _logger.LogError(ex, "Error sending keep alive socket message: {Message}", ex.Message); } } }); }
public void TaskQueueMaxSizeTest() { var depth = 10; var taskQueue = new TaskQueue(); taskQueue.SetMaxQueueSize(depth); var wait = true; for (var i = 0; i < depth; i++) { taskQueue.Enqueue(t => Task.Run(() => { while (wait) Thread.Sleep(5); }), wait); } taskQueue.Size.Should().Be(depth); var newItem = taskQueue.Enqueue(t => Task.FromResult(0), wait); newItem.Should().BeNull("This should exceed the max and return a null task since it was not enqueued"); taskQueue.Size.Should().Be(depth); wait = false; Thread.Sleep(25); newItem = taskQueue.Enqueue(t => Task.FromResult(0), wait); newItem.Should().NotBeNull("Released the queue and it should have space again"); }
public void CanRunContinuously() { Log.MinimumLevel = LogLevel.Trace; int completed = 0; var countdown = new CountdownEvent(1); using (var queue = new TaskQueue(queueEmptyAction: () => { if (completed > 2) { countdown.Signal(); } }, loggerFactory: Log)) { queue.Enqueue(() => { Interlocked.Increment(ref completed); return(Task.CompletedTask); }); queue.Enqueue(() => { Interlocked.Increment(ref completed); return(Task.CompletedTask); }); queue.Enqueue(() => { Interlocked.Increment(ref completed); return(Task.CompletedTask); }); Assert.InRange(queue.Queued, 1, 3); countdown.Wait(TimeSpan.FromSeconds(2)); Assert.Equal(0, countdown.CurrentCount); Assert.Equal(0, queue.Queued); Assert.Equal(0, queue.Working); Assert.Equal(3, completed); } }
public void CanRunContinuously() { int completed = 0; var countdown = new CountdownEvent(1); using (var queue = new TaskQueue()) { queue.WaitWhenEmpty.ContinueWith(t => { if (completed > 2) { countdown.Signal(); } }); queue.Enqueue(() => { Interlocked.Increment(ref completed); return(Task.CompletedTask); }); queue.Enqueue(() => { Interlocked.Increment(ref completed); return(Task.CompletedTask); }); queue.Enqueue(() => { Interlocked.Increment(ref completed); return(Task.CompletedTask); }); //Assert.InRange(queue.Queued, 1, 3); countdown.Wait(TimeSpan.FromSeconds(2)); Assert.AreEqual(0, countdown.CurrentCount); Assert.AreEqual(0, queue.Queued); Assert.AreEqual(0, queue.Working); Assert.AreEqual(3, completed); } }
public void TaskQueueMaxSizeTest() { var depth = 10; var taskQueue = new TaskQueue(); taskQueue.SetMaxQueueSize(depth); var wait = true; for (var i = 0; i < depth; i++) { taskQueue.Enqueue(t => Task.Run(() => { while (wait) { Thread.Sleep(5); } }), wait); } taskQueue.Size.Should().Be(depth); var newItem = taskQueue.Enqueue(t => Task.FromResult(0), wait); newItem.Should().BeNull("This should exceed the max and return a null task since it was not enqueued"); taskQueue.Size.Should().Be(depth); wait = false; Thread.Sleep(25); newItem = taskQueue.Enqueue(t => Task.FromResult(0), wait); newItem.Should().NotBeNull("Released the queue and it should have space again"); }
public Task <ParseConfig> GetCurrentConfigAsync() { return(taskQueue.Enqueue(toAwait => toAwait.ContinueWith(_ => { if (currentConfig == null) { return storageController.LoadAsync().OnSuccess(t => { object tmp; t.Result.TryGetValue(CurrentConfigKey, out tmp); string propertiesString = tmp as string; if (propertiesString != null) { var dictionary = ParseClient.DeserializeJsonString(propertiesString); currentConfig = new ParseConfig(dictionary); } else { currentConfig = new ParseConfig(); } return currentConfig; }); } return Task.FromResult(currentConfig); }), CancellationToken.None).Unwrap()); }
private async void FtpServer_SentData(object sender, FtpSentDataEventArgs e) { IUpgradeTasksModel upgradeTaskDataModel = ServiceLocator.Current.GetInstance <IUpgradeTasksModel>(); await _upgradeTaskQueue.Enqueue(() => Task.Run(() => { //var task = upgradeTaskDataModel.Select( var task = upgradeTaskDataModel.Data.Where( t => t.Status == UpgradeStatus.InProgress && t.Device.ip == e.Remote.Address.ToString() //t => t.Device ).FirstOrDefault(); if (task != null) { task.LastUpdateTime = DateTime.Now; task.SentDataBytes = e.SentBytes; try { upgradeTaskDataModel.UpdateAsync( task, t => t.SentDataBytes, t => t.LastUpdateTime).Wait(); //DebugLog.TraceMessage(string.Format("Sent({0}) Total({1}) - {2} %)", e.SentBytes, e.FileSize, e.SentBytes * 100 / e.FileSize)); } catch (Exception) { } } } )); }
public void TaskQueueDrainTest() { var depth = 10; var taskQueue = new TaskQueue(); taskQueue.SetMaxQueueSize(depth); var wait = true; for (var i = 0; i < depth; i++) { taskQueue.Enqueue(t => Task.Run(() => { while (wait) { Thread.Sleep(10); } }), wait); } wait = false; taskQueue.Drain(); taskQueue.Size.Should().Be(0); var newItem = taskQueue.Enqueue(t => Task.FromResult(0), wait); newItem.Should().NotBeNull(); }
public Task MoveUpAsync(advertisement obj) { return(Task.Run(async() => { advertisement currentItem = obj; advertisement previousItem; lock (_lock) { int currentIndex = _data.IndexOf(currentItem); if (currentIndex == 0) { return; } previousItem = _data[currentIndex - 1]; int?tmp = currentItem.C_no; currentItem.C_no = previousItem.C_no; previousItem.C_no = tmp; _data[currentIndex - 1] = currentItem; _data[currentIndex] = previousItem; } List <advertisement> objs = new List <advertisement>(); objs.Add(currentItem); objs.Add(previousItem); await updateTasks.Enqueue(() => _dataService.UpdateAsync(objs)); //await updateTasks.Enqueue(() => _dataService.UpdateAsync(currentItem)).ConfigureAwait(false); //await updateTasks.Enqueue(() => _dataService.UpdateAsync(previousItem)).ConfigureAwait(false); })); }
public void ExceptionTest() { var queue = new TaskQueue(); AssertThrow<ArgumentNullException>( () => queue.Enqueue(null), () => queue.Enqueue((Func<Task<string>>)null)); }
private async Task Perform(MapDocumentOperation operation) { await _queue.Enqueue(async() => { var change = await operation.Operation.Perform(operation.Document); await SendChange(change); }); }
public async Task DrainingTaskQueueShutsQueueOff() { var queue = new TaskQueue(); await queue.Enqueue(() => Task.CompletedTask); await queue.Drain(); // This would throw if the task was queued successfully await queue.Enqueue(() => Task.FromException(new Exception())); }
public void FailedToEnqueueReturnsNull() { var queue = new TaskQueue(TaskAsyncHelper.Empty, 2); queue.Enqueue(() => Task.Delay(100)); queue.Enqueue(() => Task.Delay(100)); Task task = queue.Enqueue(() => Task.Delay(100)); Assert.Null(task); }
public void TaskQueueDoesNotQueueNewTasksIfPreviousTaskFaulted() { var queue = new TaskQueue(); queue.Enqueue(() => TaskAsyncHelper.FromError(new Exception())); Task task = queue.Enqueue(() => TaskAsyncHelper.Empty); Assert.True(task.IsCompleted); Assert.True(task.IsFaulted); }
private void BtnDelete_Click(object sender, RoutedEventArgs e) { if (_selectCharacterInfo != null) { _includeNicknames.Remove(_selectCharacterInfo.Nickname); this._characterList.Remove(this._selectCharacterInfo); _taskQueue.Enqueue(FileSave); Clear(); } }
/// <summary> /// Saves the file to the LeanCloud cloud. /// </summary> /// <param name="progress">The progress callback.</param> /// <param name="cancellationToken">The cancellation token.</param> public Task SaveAsync(IProgress <AVUploadProgressEventArgs> progress, CancellationToken cancellationToken) { return(taskQueue.Enqueue( toAwait => FileController.SaveAsync(state, dataStream, AVUser.CurrentSessionToken, progress, cancellationToken), cancellationToken) .OnSuccess(t => { state = t.Result; })); }
public void NotifiesMonitorWhenMultipleTasksStartsAndCompletes() { var mockMonitor = new Mock <ITaskMonitor>(); var queue = new TaskQueue(TaskAsyncHelper.Empty, mockMonitor.Object); queue.Enqueue(() => TaskAsyncHelper.Empty); queue.Enqueue(() => TaskAsyncHelper.Empty); mockMonitor.Verify(m => m.TaskStarted(), Times.Exactly(2)); mockMonitor.Verify(m => m.TaskCompleted(), Times.Exactly(2)); }
public Task <T> Enqueue <T>(Func <Task <T> > taskGenerator) { TaskCompletionSource <T> tcs = new TaskCompletionSource <T>(); var unused = queue.Enqueue(() => { tcs.Match(taskGenerator()); return(Task.Delay(TimeSpan.FromSeconds(1))); }); return(tcs.Task); }
public void DrainingTaskQueueShutsQueueOff() { var queue = new TaskQueue(); queue.Enqueue(() => TaskAsyncHelper.Empty); queue.Drain(); Task task = queue.Enqueue(() => TaskAsyncHelper.FromError(new Exception())); Assert.True(task.IsCompleted); Assert.False(task.IsFaulted); }
public void CanRespectMaxItems() { using (var queue = new TaskQueue(maxItems: 1, autoStart: false)) { queue.Enqueue(() => Task.CompletedTask); queue.Enqueue(() => Task.CompletedTask); Assert.AreEqual(1, queue.Queued); Assert.AreEqual(0, queue.Working); } }
public async Task TaskQueueDoesNotQueueNewTasksIfPreviousTaskFaulted() { var exception = new Exception(); var queue = new TaskQueue(); var ignore = queue.Enqueue(() => Task.FromException(exception)); var task = queue.Enqueue(() => Task.CompletedTask); var actual = await Assert.ThrowsAsync <Exception>(async() => await task); Assert.Same(exception, actual); }
public void CanRespectMaxItems() { Log.MinimumLevel = LogLevel.Trace; using (var queue = new TaskQueue(maxItems: 1, autoStart: false, loggerFactory: Log)) { queue.Enqueue(() => Task.CompletedTask); queue.Enqueue(() => Task.CompletedTask); Assert.Equal(1, queue.Queued); Assert.Equal(0, queue.Working); } }
public async Task TestCancellationTokenCancelled() { // Arrange var n = 0; var taskQueue = new TaskQueue(2); taskQueue.Enqueue(async() => { await Task.Delay(40); n++; }); taskQueue.Enqueue(async() => { await Task.Delay(50); n++; }); taskQueue.Enqueue(async() => { await Task.Delay(60); n++; }); taskQueue.Enqueue(async() => { await Task.Delay(70); n++; }); var cancellationTokenSource = new CancellationTokenSource(); // Act & Assert var t = taskQueue.WhenAll(cancellationTokenSource.Token); await Task.Delay(10); Assert.Equal(2, taskQueue.Waiting); Assert.Equal(2, taskQueue.Executing); Assert.Equal(0, taskQueue.Completed); cancellationTokenSource.Cancel(); await t; Assert.True(cancellationTokenSource.IsCancellationRequested); Assert.True(t.IsCompleted); Assert.Equal(2, taskQueue.Waiting); Assert.Equal(2, taskQueue.Executing); Assert.Equal(0, taskQueue.Completed); Assert.Equal(0, n); }
public void CanRunAndWait() { int completed = 0; var countdown = new CountdownEvent(1); using (var queue = new TaskQueue(autoStart: false)) { void Sub(int id) { queue.WaitWhenEmpty.ContinueWith(t => { if (queue.WaitWhenEmpty.Id != id) { Sub(queue.WaitWhenEmpty.Id); } return(countdown.Signal()); }); } Sub(queue.WaitWhenEmpty.Id); queue.Enqueue(() => { Interlocked.Increment(ref completed); return(Task.CompletedTask); }); Assert.AreEqual(1, queue.Queued); queue.Start(); countdown.Wait(TimeSpan.FromSeconds(2)); Assert.AreEqual(0, countdown.CurrentCount); Assert.AreEqual(0, queue.Queued); Assert.AreEqual(1, completed); Thread.Sleep(30); countdown.Reset(); queue.Enqueue(() => { Interlocked.Increment(ref completed); return(Task.CompletedTask); }); countdown.Wait(TimeSpan.FromSeconds(2)); Assert.AreEqual(0, countdown.CurrentCount); Assert.AreEqual(0, queue.Queued); Assert.AreEqual(2, completed); } }
public void Start() { if (IsRunning) { return; } //var looper = ServiceProvider.GetRequiredService<LoopingTyperRunner>(); //var patternRepeater = new PatternRepeater(); var patternRepeater = new ComplexPatternRepeater(); var soundService = new SoundService(); var backgroundTask = new BackgroundTaskRunner(async ct => { soundService.Play(SoundServiceSound.Start); await patternRepeater.RunAsync(ct); soundService.Play(SoundServiceSound.End); return(true); }); TaskQueue.Enqueue(backgroundTask); if (!IsRunning) { DoDequeueLoop().GetAwaiter(); } }
private void OnMessage(string key, byte[] data) { // The key is the stream id (channel) var message = RedisMessage.Deserialize(data); _publishQueue.Enqueue(() => OnReceived(key, (ulong)message.Id, message.Messages)); }
public void CanProcessInParrallelQuicklyWithRandomDelays() { const int NumberOfEnqueuedItems = 500; const int MaxDelayInMilliseconds = 10; const int MaxDegreeOfParallelism = 4; int completed = 0; var countdown = new CountdownEvent(1); using (var queue = new TaskQueue(maxDegreeOfParallelism: MaxDegreeOfParallelism, autoStart: false)) { queue.WaitWhenEmpty.ContinueWith(t => countdown.Signal()); for (int i = 0; i < NumberOfEnqueuedItems; i++) { queue.Enqueue(async() => { var delay = TimeSpan.FromMilliseconds(new Random().Next(0, MaxDelayInMilliseconds)); await Task.Delay(delay); Interlocked.Increment(ref completed); }); } Assert.AreEqual(NumberOfEnqueuedItems, queue.Queued); var sw = Stopwatch.StartNew(); queue.Start(); countdown.Wait(TimeSpan.FromSeconds(NumberOfEnqueuedItems * MaxDelayInMilliseconds)); Assert.AreEqual(0, countdown.CurrentCount); Assert.AreEqual(0, queue.Queued); Assert.AreEqual(0, queue.Working); Assert.AreEqual(NumberOfEnqueuedItems, completed); } }
public void CanProcessInParrallelQuickly() { const int NumberOfEnqueuedItems = 1000; const int MaxDegreeOfParallelism = 2; int completed = 0; var countdown = new CountdownEvent(1); using (var queue = new TaskQueue(maxDegreeOfParallelism: MaxDegreeOfParallelism, autoStart: false)) { queue.WaitWhenEmpty.ContinueWith(t => countdown.Signal()); for (int i = 0; i < NumberOfEnqueuedItems; i++) { queue.Enqueue(() => { Interlocked.Increment(ref completed); return(Task.CompletedTask); }); } Assert.AreEqual(NumberOfEnqueuedItems, queue.Queued); var sw = Stopwatch.StartNew(); queue.Start(); countdown.Wait(TimeSpan.FromSeconds(5)); //Assert.InRange(countdown.CurrentCount, -1, 0); // TODO: There is a possibility where on completed could be called twice. Assert.AreEqual(0, queue.Queued); Assert.AreEqual(0, queue.Working); Assert.AreEqual(NumberOfEnqueuedItems, completed); } }
public void CanProcessQuickly() { const int NumberOfEnqueuedItems = 1000; int completed = 0; var countdown = new CountdownEvent(1); using (var queue = new TaskQueue(autoStart: false)) { queue.WaitWhenEmpty.ContinueWith(t => countdown.Signal()); for (int i = 0; i < NumberOfEnqueuedItems; i++) { queue.Enqueue(() => { Interlocked.Increment(ref completed); return(Task.CompletedTask); }); } Assert.AreEqual(NumberOfEnqueuedItems, queue.Queued); var sw = Stopwatch.StartNew(); queue.Start(); countdown.Wait(TimeSpan.FromSeconds(5)); Assert.AreEqual(0, countdown.CurrentCount); Assert.AreEqual(0, queue.Queued); Assert.AreEqual(0, queue.Working); Assert.AreEqual(NumberOfEnqueuedItems, completed); } }
async Task IGangMember.HandleAsync(GangMessageTypes type, byte[] data, GangAudit audit) { await _sendQueue.Enqueue(async() => { try { await _webSocket.SendAsync( new[] { (byte)type }, WebSocketMessageType.Binary, data == null, CancellationToken.None); if (audit?.Version != null) { await _webSocket.SendAsync( BitConverter.GetBytes(audit.Version.Value), WebSocketMessageType.Binary, data == null, CancellationToken.None); } if (data != null) { await _webSocket.SendAsync( data, WebSocketMessageType.Binary, true, CancellationToken.None); } } catch (WebSocketException) { // ignore this } }); }
public void Reset(WaypointTask holdTask, WaypointTask approachTask, WaypointTask enterTask, WaypointTask closeTask, DockTask dockTask, MyTuple <IntelItemType, long> intelKey, MyGridProgram program, MyCubeSize dockSize, IMyTerminalBlock connector, IMyTerminalBlock indicator = null) { Reset(); if (indicator != null) { Indicator = indicator; Connector = connector; } EnterHoldingPattern = holdTask; WaitForClearance = new WaitTask(); ApproachEntrance = approachTask; ApproachDock = enterTask; FinalAdjustToDock = closeTask; DockTask = dockTask; IntelKey = intelKey; DockSize = dockSize; Program = program; closeTask.Destination.MaxSpeed = 0.5f; enterTask.Destination.MaxSpeed = 5; TaskQueue.Enqueue(EnterHoldingPattern); TaskQueue.Enqueue(WaitForClearance); TaskQueue.Enqueue(ApproachEntrance); TaskQueue.Enqueue(ApproachDock); TaskQueue.Enqueue(FinalAdjustToDock); TaskQueue.Enqueue(DockTask); }
public void MainTest() { AsyncPump.Run( async () => { var counter = 0; var queue = new TaskQueue(); queue.Enqueue( async () => { await Task.Delay(250); ++counter; }).Ignore(); Assert.AreEqual(2, await queue.Enqueue(() => Task.FromResult(++counter))); Assert.AreEqual(2, counter); }); }
public void TaskQueueDrainTest() { var depth = 10; var taskQueue = new TaskQueue(); taskQueue.SetMaxQueueSize(depth); var wait = true; for (var i = 0; i < depth; i++) { taskQueue.Enqueue(t => Task.Run(() => { while (wait) Thread.Sleep(10); }), wait); } wait = false; taskQueue.Drain(); taskQueue.Size.Should().Be(0); var newItem = taskQueue.Enqueue(t => Task.FromResult(0), wait); newItem.Should().NotBeNull(); }
public void TaskQueueSizeTest() { var depth = 10; var taskQueue = new TaskQueue(); var wait = true; for (var i = 0; i < depth; i++) { taskQueue.Enqueue(t => Task.Run(() => { while(wait) Thread.Sleep(5); }), wait); } taskQueue.Size.Should().Be(depth); wait = false; Thread.Sleep(25); taskQueue.Size.Should().Be(0); }
/// <summary> /// /// </summary> /// <param name="taskCollection"></param> private void DoTasks(TaskQueue tasks) { if (tasks.Count == 0) { return; } TaskCollection tempTasks = new TaskCollection(); while (tasks.Count > 0) { ITask headTask = tasks.Dequeue(); bool b = DoNotExecutingTask(headTask); if (b) { break; } else { tempTasks.Add(headTask); } } // // tasks.Enqueue(tempTasks); }