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);
}
