public void Should_enqueue_given_task_and_run_into_free_worker() { var startSignal = new CountdownEvent(1); workersPool.PushTask(WorkerTasks.Task("task 1", startSignal: startSignal)); startSignal.Wait(); workersPool.TasksQueueSize.Should().Be(0); }
public void Should_enqueue_tasks_more_than_workers_count() { workersPool.PushTask(WorkerTasks.UnfinishedTask("task 1")); workersPool.PushTask(WorkerTasks.UnfinishedTask("task 2")); workersPool.PushTask(WorkerTasks.UnfinishedTask("task 3")); workersPool.PushTask(WorkerTasks.UnfinishedTask("task 4")); workersPool.PushTask(WorkerTasks.UnfinishedTask("task 5")); workersPool.PushTask(WorkerTasks.UnfinishedTask("task 6")); workersPool.PushTask(WorkerTasks.UnfinishedTask("task 7")); workersPool.TasksQueueSize.Should().BeInRange(4, 7); }
public void Should_reset_in_progress_tasks_when_they_completed() { var finishSignal = new CountdownEvent(3); workersPool.PushTask(WorkerTasks.Task("task 1", finishSignal: finishSignal)); workersPool.PushTask(WorkerTasks.Task("task 2", finishSignal: finishSignal)); workersPool.PushTask(WorkerTasks.Task("task 3", finishSignal: finishSignal)); finishSignal.Wait(); Thread.Sleep(100); workersPool.TaskInProgress.Should().Be(0); }
protected override void SetupAttributes() { Name = "Drone"; elevation = 0.5f; baseSpeed = 7f; baseTurnSpeed = 15f; task = WorkerTasks.Gather; state = DroneStates.Idle; Friendly = true; // TODO set somewhere else (on spawn) UnitActive = true; }
private void Sync(WorkerTasks task, bool interactive = true) { // don't do nothin' if we're already syncing if (Worker.IsBusy) { if (interactive) { Notifications.ShowBalloonTip((int)BalloonTimeout.TotalMilliseconds, Text, Resources.SettingsForm_WorkerIsBusy, ToolTipIcon.Info); } return; } // ensure the settings aren't dirty if (Settings.Default.IsDirty) { if (interactive) { // activate the form and the most appropriate button and show a message to the user Activate(); if (Save.Enabled) { Save.Focus(); } else { Cancel.Focus(); } Notifications.ShowBalloonTip((int)BalloonTimeout.TotalMilliseconds, Text, Resources.SettingsForm_UnsavedSettings, ToolTipIcon.Info); } return; } // only continue if a user name was provided if (string.IsNullOrEmpty(Settings.Default.UserName)) { if (interactive) { // show and activate the form, focus the user name input and show a message to the user Show(); Activate(); UserName.Focus(); Notifications.ShowBalloonTip((int)BalloonTimeout.TotalMilliseconds, Text, Resources.SettingsForm_SettingsIncomplete, ToolTipIcon.Info); } return; } // start the worker and update the UI Worker.RunWorkerAsync(new SyncContext(Settings.Default, task, interactive)); UpdateWorkerStatus(); }
public bool TryAddWorkerTask(string casePlanInstanceElementId) { var workerTask = WorkerTasks.FirstOrDefault(_ => _.CasePlanElementInstanceId == casePlanInstanceElementId); if (workerTask != null) { return(false); } var evt = new CaseInstanceWorkerTaskAddedEvent(Guid.NewGuid().ToString(), AggregateId, Version + 1, casePlanInstanceElementId, DateTime.UtcNow, CaseOwnerRole); Handle(evt); DomainEvents.Add(evt); return(true); }
public void Should_set_in_progress_tasks_count_while_they_are_executing() { var startSignal = new CountdownEvent(3); workersPool.PushTask(WorkerTasks.UnfinishedTask("task 1", startSignal)); workersPool.PushTask(WorkerTasks.UnfinishedTask("task 2", startSignal)); workersPool.PushTask(WorkerTasks.UnfinishedTask("task 3", startSignal)); startSignal.Wait(); Thread.Sleep(100); var actual = workersPool.TaskInProgress; actual.Should().Be(3); }
private void Handle(CaseInstanceWorkerTaskRemovedEvent evt) { var workertask = WorkerTasks.FirstOrDefault(_ => _.CasePlanElementInstanceId == evt.CasePlanInstanceElementId); if (workertask == null) { throw new AggregateValidationException(new List <KeyValuePair <string, string> > { new KeyValuePair <string, string>("validation", $"case worker task doesn't exist '{workertask.CasePlanElementInstanceId}'") }); } WorkerTasks.Remove(workertask); Version = evt.Version; UpdateDateTime = evt.ExecutionDateTime; }
public SyncContext(Settings settings, WorkerTasks task, bool interactive) { // check the arguments and store the values if (settings == null) { throw new ArgumentNullException("settings"); } if (settings.IsFirstSync) { task |= WorkerTasks.ResetMatches; } Tasks = task; UserName = settings.UserName; Password = settings.Password; Mode = settings.SyncMode; Interactive = interactive; }
private void Handle(CaseInstanceWorkerTaskAddedEvent evt) { var child = GetCasePlanItem(evt.CasePlanInstanceElementId); if (child == null) { throw new AggregateValidationException(new List <KeyValuePair <string, string> > { new KeyValuePair <string, string>("validation", $"unknown child '{evt.CasePlanInstanceElementId}'") }); } WorkerTasks.Add(new CasePlanInstanceWorkerTask { CasePlanElementInstanceId = evt.CasePlanInstanceElementId, CreateDateTime = evt.CreateDateTime }); UpdateDateTime = evt.CreateDateTime; Version = evt.Version; }
public override object Clone() { var result = new CasePlanInstanceAggregate { CasePlanId = CasePlanId, AggregateId = AggregateId, CreateDateTime = CreateDateTime, Version = Version, Name = Name, State = State, UpdateDateTime = UpdateDateTime, CaseOwner = CaseOwner, Files = new ConcurrentBag <CasePlanInstanceFileItem>(Files.Select(_ => (CasePlanInstanceFileItem)_.Clone()).ToList()), Roles = Roles.Select(_ => (CasePlanInstanceRole)_.Clone()).ToList(), WorkerTasks = new ConcurrentBag <CasePlanInstanceWorkerTask>(WorkerTasks.Select(_ => (CasePlanInstanceWorkerTask)_.Clone()).ToArray()), ExecutionContext = (CasePlanInstanceExecutionContext)ExecutionContext.Clone(), Children = new ConcurrentBag <BaseCaseEltInstance>(Children.Select(_ => (BaseCaseEltInstance)_.Clone())) }; result.ExecutionContext.CasePlanInstance = result; return(result); }
public void MakeTransition(BaseCaseEltInstance element, CMMNTransitions transition, bool isEvtPropagate = true) { var evt = new CaseElementTransitionRaisedEvent(Guid.NewGuid().ToString(), AggregateId, Version + 1, element.Id, transition, DateTime.UtcNow); Handle(evt); DomainEvents.Add(evt); var caseWorkerTask = WorkerTasks.FirstOrDefault(_ => _.CasePlanElementInstanceId == element.Id); if (caseWorkerTask != null && (transition == CMMNTransitions.Complete || transition == CMMNTransitions.Terminate || transition == CMMNTransitions.ParentTerminate)) { var removeCWT = new CaseInstanceWorkerTaskRemovedEvent(Guid.NewGuid().ToString(), AggregateId, Version + 1, element.Id, DateTime.UtcNow); Handle(removeCWT); DomainEvents.Add(removeCWT); } if (isEvtPropagate) { PropagateTransition(element, transition); } }
public override object Clone() { var result = new CasePlanInstanceAggregate { CasePlanId = CasePlanId, CaseFileId = CaseFileId, AggregateId = AggregateId, CreateDateTime = CreateDateTime, Version = Version, Name = Name, State = State, UpdateDateTime = UpdateDateTime, NameIdentifier = NameIdentifier, Files = Files.Select(_ => (CasePlanInstanceFileItem)_.Clone()).ToList(), Roles = Roles.Select(_ => (CasePlanInstanceRole)_.Clone()).ToList(), WorkerTasks = WorkerTasks.Select(_ => (CasePlanInstanceWorkerTask)_.Clone()).ToList(), ExecutionContextVariables = ExecutionContextVariables.ToDictionary(c => c.Key, c => c.Value), Children = Children.Select(_ => (CaseEltInstance)_.Clone()).ToList() }; return(result); }
public void Should_execute_all_tasks_after_many_iterations(int tasksCount, int workersCount) { using (var newWorkersPool = new WorkersPool.WorkersPool(workersCount, new TestLog(output))) { var expectedResults = Enumerable.Range(0, tasksCount).ToList(); var actualResults = new int[tasksCount]; var startSignals = Enumerable.Range(0, tasksCount).Select(_ => new CountdownEvent(1)).ToArray(); var stopwatch = new Stopwatch(); using (new Disposables(startSignals)) using (var finishSignal = new CountdownEvent(tasksCount)) { var workerTasks = Enumerable.Range(0, tasksCount) .Select( id => WorkerTasks.Task( "task " + id, startSignal: startSignals[id], finishSignal: finishSignal, action: () => actualResults[id] = id ) ) .ToList(); stopwatch.Start(); for (var i = 0; i < workerTasks.Count; i++) { newWorkersPool.PushTask(workerTasks[i]); startSignals[i].Wait(); } finishSignal.Wait(5.Seconds()); stopwatch.Stop(); } actualResults.Should().BeEquivalentTo(expectedResults); output.WriteLine("Task finished for " + stopwatch.Elapsed); } }
public void Should_decrease_when_one_of_task_finished() { var task2FinishSignal = new CountdownEvent(1); var startSignal = new CountdownEvent(3); var task2BlockSignal = new SemaphoreSlim(0); workersPool.PushTask(WorkerTasks.UnfinishedTask("task 1", startSignal)); workersPool.PushTask(WorkerTasks.Task("task 2", task2BlockSignal, startSignal, task2FinishSignal)); workersPool.PushTask(WorkerTasks.UnfinishedTask("task 3", startSignal)); startSignal.Wait(); output.WriteLine("All task started"); var beforeOneFinish = workersPool.TaskInProgress; task2BlockSignal.Release(); task2FinishSignal.Wait(); Thread.Sleep(100); output.WriteLine("Task 2 finished"); beforeOneFinish.Should().Be(3); workersPool.TaskInProgress.Should().Be(2); }
public override void SetTask(int taskId) { task = GetEnumFromId <WorkerTasks>(taskId); }
public bool WorkerTaskExists(string casePlanInstanceElementId) { return(WorkerTasks.Any(_ => _.CasePlanElementInstanceId == casePlanInstanceElementId)); }
public async Task <TRet> PerformWorkerOperationAsync <TRet>(Func <INode <TState, TCost>, Task <TRet> > acquiredoperations) { //System.Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId}: Getting node."); INode <TState, TCost> myitem; await ConsumerLock.WaitAsync(); bool hasconsumerlock = true; try { Monitor.Enter(ProducerLock); while (Nodes.Count <= 0) { Monitor.Exit(ProducerLock); List <Task> MonitoredTasks = new List <Task>(WorkerTasks); if (MonitoredTasks.Count == 0) { throw new QueueExhaustedException(); } ConsumerLock.Release(); hasconsumerlock = false; await Task.WhenAny(MonitoredTasks); await ConsumerLock.WaitAsync(); hasconsumerlock = true; Monitor.Enter(ProducerLock); } myitem = Nodes[0]; Nodes.RemoveAt(0); VisitedStates.Add(myitem.State, myitem.AccumulatedCost); Monitor.Exit(ProducerLock); } catch (Exception) { if (hasconsumerlock) { ConsumerLock.Release(); } throw; } //Still has consumerlock TaskCompletionSource <int> holder = new TaskCompletionSource <int>(); async Task <TRet> Worker(INode <TState, TCost> n) { await holder.Task; return(await acquiredoperations(n)); } var t = Worker(myitem); var cleanuptask = t.ContinueWith(async x => { await ConsumerLock.WaitAsync(); WorkerTasks.Remove(x); ConsumerLock.Release(); }); WorkerTasks.Add(t); ConsumerLock.Release(); holder.SetResult(0); //release hold await cleanuptask; return(await t); }