public void TestSingleParamById()
{
using (var manager = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
{
var guid = "0FE51C65-C0F7-4BC0-9CD1-9BF8CC98AB3D";
manager.RegisterTaskType(typeof(MyTask2), new TaskSettings(guid));
manager.EnqueueSingleTask <Task2Parameter>(new Guid(guid), new Task2Parameter()
{
Value = 456
});
MyTask2.ParamValue = 0;
int tickCount = 0;
manager.SubscribeToListener(() => { if (tickCount++ > 1)
{
manager.StopListener();
}
});
manager.StartListener();
manager.WaitTillListenerStops();
Assert.True(MyTask2.ParamValue == 456);
Assert.True(manager.LatestListenerException == null);
}
}
public void TestRecurrentTask()
{
using (var manager = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
{
manager.RegisterTaskType(typeof(MyTaskRecurrent1), new TaskSettings("C4A0CCD2-A04D-4E59-8346-2A8AA4E2EA0E"));
MyTaskRecurrent1.TaskExecuted = 0;
var recurrentId = manager.EnqueueRecurrentTask <MyTaskRecurrent1>(1000);
int count = 0;
manager.SubscribeToListener(() =>
{
count++;
if (count > 3)
{
manager.StopListener();
}
else
{
Thread.Sleep(1000);
}
});
manager.StartListener();
manager.WaitTillListenerStops();
Assert.True(MyTaskRecurrent1.TaskExecuted > 1, $"Task should've executed more than once: {MyTaskRecurrent1.TaskExecuted}");
Assert.True(manager.LatestListenerException == null, "No exception exptected");
}
}
public void TestSingleParam()
{
using (var manager = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
{
manager.RegisterTaskType(typeof(MyTask2), new TaskSettings("8DCB87AA-FAE8-4E03-9A66-533705C4803C"));
manager.EnqueueSingleTask <MyTask2, Task2Parameter>(new Task2Parameter()
{
Value = 456
});
MyTask2.ParamValue = 0;
int tickCount = 0;
manager.SubscribeToListener(() => { if (tickCount++ > 1)
{
manager.StopListener();
}
});
manager.StartListener();
manager.WaitTillListenerStops();
Assert.True(MyTask2.ParamValue == 456);
Assert.True(manager.LatestListenerException == null);
}
}
public void RenewLock()
{
//*** TIME-SENSITIVE TEST, don't use debug-mode
var manager = LockManagerFactory.Create(() => TestDbContext.Create());
var resource1 = new Guid("CB2A9AD3-79F5-4FAA-A37E-FD21A1C688EB");
LockInfo lockInfo1, lockInfo2;
manager.TryLock(resource1, new TimeSpan(TimeSpan.TicksPerSecond), out lockInfo1);
Assert.True(lockInfo1.HasLock);
Thread.Sleep(500);
manager.TryRenewLock(lockInfo1); // 1 sec renew
Thread.Sleep(700);
Assert.True(lockInfo1.HasLock);
Thread.Sleep(500);
Assert.False(lockInfo1.HasLock);
manager.TryLock(resource1, new TimeSpan(TimeSpan.TicksPerSecond), out lockInfo2);
Assert.True(lockInfo2.HasLock);
manager.Release(lockInfo1);
manager.Release(lockInfo2);
}
public void TestSingleById()
{
using (var manager = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
{
var guid = "139E764E-AA4D-4B99-9FF1-603C743ECC32";
manager.RegisterTaskType(typeof(MyTask1), new TaskSettings(guid));
MyTask1.TaskExecuted = 0;
manager.EnqueueSingleTask(new Guid(guid));
int tickCount = 0;
manager.SubscribeToListener(() => { if (tickCount++ > 1)
{
manager.StopListener();
}
});
TaskHelper.WaitSafeSync(() => manager.StartListener(delay: 100));
manager.WaitTillListenerStops();
Assert.True(manager.LatestListenerException == null);
Assert.True(MyTask1.TaskExecuted == 1);
}
}
public void TestSingle()
{
using (var manager = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
{
manager.RegisterTaskType(typeof(MyTask1), new TaskSettings("D591C9C1-F034-4151-993D-AB2A76374994"));
MyTask1.TaskExecuted = 0;
var taskId = manager.EnqueueSingleTask <MyTask1>();
int tickCount = 0;
manager.SubscribeToListener(() => { if (tickCount++ > 1)
{
manager.StopListener();
}
});
TaskHelper.WaitSafeSync(() => manager.StartListener(delay: 100));
manager.WaitTillListenerStops();
Assert.False(manager.IsListenning);
Assert.True(manager.LatestListenerException == null);
Assert.True(MyTask1.TaskExecuted == 1);
using (var db = TestDbContext.Create())
{
var task = db.SingleTasks.Where(t => t.Id == taskId).FirstOrDefault();
Assert.True(task.Status == SingleTaskStatus.Completed);
}
}
}
public void TestSingleException()
{
using (var manager = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
{
manager.RegisterTaskType(typeof(MyTaskException), new TaskSettings("FEB9BB14-1BE7-42A7-8E02-D2175F2BD51F"));
MyTaskException.TaskExecuted = 0;
var taskId = manager.EnqueueSingleTask <MyTaskException>();
int tickCount = 0;
manager.SubscribeToListener(() => { if (tickCount++ > 1)
{
manager.StopListener();
}
});
manager.StartListener();
manager.WaitTillListenerStops();
Assert.False(manager.IsListenning);
Assert.True(manager.LatestListenerException == null);
Assert.True(MyTaskException.TaskExecuted == 1);
using (var db = TestDbContext.Create())
{
var task = db.SingleTasks.Where(t => t.Id == taskId).FirstOrDefault();
Assert.True(task.Status == SingleTaskStatus.Completed);
}
}
}
public void TestSingleAndRecurrent()
{
using (var manager = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
{
manager.RegisterTaskType(typeof(MyTaskRecurrent1), new TaskSettings("BF168DA8-3D80-429E-93AF-0958E80128A1"));
manager.EnqueueRecurrentTask <MyTaskRecurrent1>(1000);
manager.EnqueueSingleTask <MyTaskRecurrent1>();
MyTaskRecurrent1.TaskExecuted = 0;
int tickCount = 0;
manager.SubscribeToListener(() => { if (tickCount++ > 1)
{
manager.StopListener();
}
});
manager.StartListener();
manager.WaitTillListenerStops();
Assert.True(MyTaskRecurrent1.TaskExecuted > 0);
Assert.True(manager.LatestListenerException == null);
}
}
public void TestTypeNotRegisteredWithManager()
{
using (var manager = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
using (var otherManager = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
{
manager.StartListener();
otherManager.RegisterTaskType(typeof(MyTask1), new TaskSettings("41CE95B5-A7DC-4A9B-A0C2-CA441639BF5E"));
var taskId = otherManager.EnqueueSingleTask <MyTask1>();
//The second manager is not listenning yet.
//Waits for the first manager to pick up a non-registered task.
Thread.Sleep(3000);
Assert.True(manager.IsListenning);
manager.StopListener();
otherManager.StopListener();
Assert.True(manager.RemoveSingleTask(taskId));
Assert.True(manager.LatestListenerException == null);
Assert.True(otherManager.LatestListenerException == null);
}
}
public void DoubleLock()
{
var manager = LockManagerFactory.Create(() => TestDbContext.Create());
var resource1 = new Guid("ACC9D515-1529-49BD-AECE-E163D9200E0F");
var resource2 = new Guid("A7FE17DA-BE0F-40FD-8AE6-7F1F7C615C72");
LockInfo lockInfo1, lockInfo2, lockInfo3;
var firstLock = manager.TryLock(resource1, new TimeSpan(TimeSpan.TicksPerMinute * 2), out lockInfo1);
manager.TryLock(resource1, new TimeSpan(TimeSpan.TicksPerMinute), out lockInfo2);
manager.TryLock(resource2, new TimeSpan(TimeSpan.TicksPerMinute), out lockInfo3);
Assert.True(firstLock && lockInfo1.HasLock);
Assert.False(lockInfo2.HasLock);
Assert.True(lockInfo3.HasLock);
manager.Release(lockInfo1);
manager.Release(lockInfo3);
manager.TryLock(resource1, new TimeSpan(TimeSpan.TicksPerMinute), out lockInfo2);
Assert.True(lockInfo2.HasLock);
manager.Release(lockInfo2);
Assert.False(lockInfo1.HasLock);
Assert.False(lockInfo2.HasLock);
Assert.False(lockInfo3.HasLock);
}
public async Task TestWaitForLockTimeoutAsync()
{
using (var manager = LockManagerFactory.Create(() => TestDbContext.Create()))
{
var resource = new Guid("3767EF33-8296-4363-95CE-120E0453E3D0");
LockInfo lockInfo = await manager.TryLockAsync(resource, TimeSpan.FromMinutes(5));
Assert.True(lockInfo.AsImmutable().HasLock());
LockInfo lockInfo2 = await manager.WaitForLockAsync(resource, TimeSpan.FromMinutes(1), TimeSpan.FromMilliseconds(50));
Assert.False(lockInfo2.AsImmutable().HasLock());
//Already cancelled token
LockInfo lockInfo3 = await manager.WaitForLockAsync(resource, TimeSpan.FromMinutes(1), TimeSpan.Zero);
Assert.False(lockInfo3.AsImmutable().HasLock());
await manager.ReleaseAsync(lockInfo);
await manager.ReleaseAsync(lockInfo2);
await manager.ReleaseAsync(lockInfo3);
}
}
public void TestAbandonedTask()
{
using (var manager = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
using (var manager2 = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
{
manager.RegisterTaskType(typeof(MyTaskLongTask),
new TaskSettings("7EBA6938-15A7-4C9F-9CA2-5DC3C5EFE6EA")
{
AliveCycle = new TimeSpan(Convert.ToInt64(TimeSpan.TicksPerSecond * 2.5))
});
var taskId = manager.EnqueueSingleTask <MyTaskLongTask>();
int tickCount = 0;
manager.SubscribeToListener(() => { if (tickCount++ > 0)
{
manager.StopListener();
}
});
manager.StartListener();
manager.WaitTillListenerStops();
using (var db = TestDbContext.Create())
{
var task = db.SingleTasks.Where(t => t.Id == taskId).FirstOrDefault();
Assert.True(task.Status == SingleTaskStatus.CompletedAborted, "Status should be CompletedAborted");
//Fake running status
task.SetStatus(SingleTaskStatus.Running);
task.LockedUntil = DateTime.UtcNow.AddDays(-1); // Ideally should use database-based clock
db.SaveChanges();
}
tickCount = 0;
manager2.SubscribeToListener(() => { if (tickCount++ > 0)
{
manager2.StopListener();
}
});
manager2.StartListener();
manager2.WaitTillListenerStops();
using (var db = TestDbContext.Create())
{
var task = db.SingleTasks.Where(t => t.Id == taskId).FirstOrDefault();
Assert.True(task.Status == SingleTaskStatus.CompletedAbandoned, "Status should be CompletedAbandoned");
}
}
}
public void CleanUp()
{
using (var context = TestDbContext.Create())
{
context.Database.ExecuteSqlCommand("DELETE FROM SingleTasks");
context.Database.ExecuteSqlCommand("DELETE FROM RecurrentTasks");
context.Database.ExecuteSqlCommand("DELETE FROM DistributedLocks");
context.SaveChanges();
}
}
public async Task BasicTestAsync()
{
ILockManagerAsync manager = LockManagerFactory.Create(() => TestDbContext.Create());
var resource1 = new Guid("B5FF501B-383A-49DD-BD84-74511F70FCE9");
var lockInfo1 = await manager.TryLockAsync(resource1, new TimeSpan(TimeSpan.TicksPerMinute));
Assert.True(lockInfo1 != null && lockInfo1.HasLock);
await manager.ReleaseAsync(lockInfo1);
Assert.False(lockInfo1.HasLock);
}
public LockManagerTests(ITestOutputHelper output)
{
_output = output;
using (var context = TestDbContext.Create())
{
Database.SetInitializer(new MigrateDatabaseToLatestVersion <TestDbContext, TestDbConfiguration>());
context.Database.Initialize(true);
context.Database.ExecuteSqlCommand("DELETE FROM DistributedLocks");
context.SaveChanges();
}
}
public void BasicTest()
{
var manager = LockManagerFactory.Create(() => TestDbContext.Create());
var resource1 = new Guid("B5FF501B-383A-49DD-BD84-74511F70FCE9");
LockInfo lockInfo1;
var firstLock = manager.TryLock(resource1, new TimeSpan(TimeSpan.TicksPerMinute), out lockInfo1);
Assert.True(firstLock && lockInfo1.HasLock);
manager.Release(lockInfo1);
Assert.False(lockInfo1.HasLock);
}
public DistributedInitializer()
{
var log = new LoggerConfiguration().CreateLogger();
GlobalConfiguration.Instance.SetLogger(log);
using (var context = TestDbContext.Create())
{
Database.SetInitializer(new MigrateDatabaseToLatestVersion <TestDbContext, TestDbConfiguration>());
context.Database.Initialize(true);
}
this.CleanUp();
}
public async Task RunWithLockTimeoutAsync()
{
using (var manager = LockManagerFactory.Create(() => TestDbContext.Create()))
{
var resource = new Guid("B10F8164-6D72-4997-8CFC-60A0494A6818");
bool firstLockRun = false;
await manager.RunWithLockAsync(resource, TimeSpan.FromMinutes(5), TimeSpan.FromMinutes(1), async (_lock) =>
{
firstLockRun = true;
Exception ex = null;
bool run = false;
try
{
await manager.RunWithLockAsync(resource, TimeSpan.FromMinutes(1), TimeSpan.FromMilliseconds(50),
async(_lock2) =>
{
run = true;
});
}
catch (Exception exc)
{
ex = exc;
}
Assert.True(ex != null, "Exception was expected");
Assert.False(run);
try
{
await manager.RunWithLockAsync(resource, TimeSpan.FromMinutes(1), TimeSpan.Zero,
async(_lock3) =>
{
run = true;
});
}
catch (Exception exc)
{
ex = exc;
}
Assert.True(ex != null, "Exception was expected");
Assert.False(run);
});
Assert.True(firstLockRun);
}
}
public void RunWithLockTimeout()
{
using (var manager = LockManagerFactory.Create(() => TestDbContext.Create()))
{
var resource = new Guid("D295C57E-BFBD-4760-8424-950875A594F7");
bool firstLockRun = false;
manager.RunWithLock(resource, TimeSpan.FromMinutes(5), TimeSpan.FromMinutes(1), (_lock) =>
{
firstLockRun = true;
Exception ex = null;
bool run = false;
try
{
manager.RunWithLock(resource, TimeSpan.FromMinutes(1), TimeSpan.FromMilliseconds(50),
(_lock2) =>
{
run = true;
});
}
catch (Exception exc)
{
ex = exc;
}
Assert.True(ex != null, "Exception was expected");
Assert.False(run);
try
{
manager.RunWithLock(resource, TimeSpan.FromMinutes(1), TimeSpan.Zero,
(_lock3) =>
{
run = true;
});
}
catch (Exception exc)
{
ex = exc;
}
Assert.True(ex != null, "Exception was expected");
Assert.False(run);
});
Assert.True(firstLockRun);
}
}
public void TestForceCancelTaskAndRecovery()
{
// MyTaskAutoCancelTask
// AliveCycle = 1 sec
// LockCycle - 2 secs
// Runs for - 1 hours (till force cancelled)
var options = new TaskManagerOptions()
{
MainLoopWait = 100, MaxWorkerThreads = 1
};
using (var manager = TaskManagerFactory.Create(() => TestDbContext.Create(), options))
{
manager.RegisterTaskType(typeof(MyTaskLongTask),
new TaskSettings("CBC68EFE-532D-44C7-87D8-3443636F6425")
{
AliveCycle = new TimeSpan(TimeSpan.TicksPerSecond)
});
var longTaskId = manager.EnqueueSingleTask <MyTaskLongTask>();
manager.StartListener();
Thread.Sleep(500);
manager.RegisterTaskType(typeof(MyTask), new TaskSettings("BC54E6F5-9EDF-48C2-8765-269BCC472DDF"));
var taskId = manager.EnqueueSingleTask <MyTask>();
int tickCount = 0;
manager.SubscribeToListener(() => { if (tickCount++ > 2)
{
manager.StopListener();
}
});
manager.WaitTillListenerStops();
Assert.True(manager.LatestListenerException == null);
using (var db = TestDbContext.Create())
{
var longTask = db.SingleTasks.Where(t => t.Id == longTaskId).FirstOrDefault();
Assert.True(longTask.Status == SingleTaskStatus.CompletedAborted);
var task = db.SingleTasks.Where(t => t.Id == taskId).FirstOrDefault();
Assert.True(task.Status == SingleTaskStatus.Completed);
}
}
}
public void TestAutoRenewLock()
{
// MyTaskAutoRenewLock
// AliveCycle - 1 sec
// LockCycle - 2 secs
// Runs for - 3 secs
// Task Lock auto-renewed every 1 seconds
using (var manager = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
{
manager.RegisterTaskType(typeof(MyTaskAutoRenewLock),
new TaskSettings("1BE679EB-D6D6-4239-90FB-5116C031762F")
{
AliveCycle = new TimeSpan(TimeSpan.TicksPerSecond)
});
var taskId = manager.EnqueueSingleTask <MyTaskAutoRenewLock>();
MyTaskAutoRenewLock.TaskStarted = false;
MyTaskAutoRenewLock.CancelationRequested = false;
MyTaskAutoRenewLock.ProcessedAllRecords = false;
int tickCount = 0;
manager.SubscribeToListener(() => { if (tickCount++ > 3)
{
manager.StopListener();
}
});
manager.StartListener();
manager.WaitTillListenerStops();
Assert.True(MyTaskAutoRenewLock.TaskStarted, "TaskStarted should be true");
Assert.False(MyTaskAutoRenewLock.CancelationRequested, "CancelationRequested should be false");
using (var db = TestDbContext.Create())
{
var task = db.SingleTasks.Where(t => t.Id == taskId).FirstOrDefault();
Assert.Equal(SingleTaskStatus.Completed, task.Status);
}
Assert.True(MyTaskAutoRenewLock.ProcessedAllRecords, "ProcessedAllRecords should be true");
Assert.True(manager.LatestListenerException == null, "LatestListenerException should be null");
}
}
public void ConcurrentLock_Start()
{
var manager = LockManagerFactory.Create(() => TestDbContext.Create());
var resource = new Guid("65917ECA-4A6B-451B-AE90-33236023E822");
LockInfo lockInfo = null;
_ThreadStartSignal.Set();
//Waits until all threads are initialized, then fire them together.
_signal.WaitOne();
for (int i = 0; i < _loopCount;)
{
try
{
if (_waitForLock)
{
manager.RunWithLock(resource, OneMinute, OneMinute, (_lock) =>
{
IncreaseCounter();
i++;
});
}
else
{
var lockAcquired = manager.TryLock(resource, OneMinute, out lockInfo);
if (lockAcquired)
//if (true) //** uncoment this line and comment lockAcquired to ignore lock and debug that the test is properly implemented.
{
IncreaseCounter();
i++; // increase loop counter only when acquired lock.
}
}
}
finally
{
manager.Release(lockInfo);
}
//Allows the execution of other threads.
Thread.Sleep(1);
}
}
public void TestWaitForLockTimeout()
{
using (var manager = LockManagerFactory.Create(() => TestDbContext.Create()))
{
var resource = new Guid("F4139466-2A16-47CC-8359-D53521C2C5EC");
LockInfo lockInfo = null;
LockInfo lockInfo2 = null;
LockInfo lockInfo3 = null;
Assert.True(manager.TryLock(resource, TimeSpan.FromMinutes(5), out lockInfo));
Assert.False(manager.WaitForLock(resource, TimeSpan.FromMinutes(1), TimeSpan.FromMilliseconds(50), out lockInfo2));
Assert.False(manager.WaitForLock(resource, TimeSpan.FromMinutes(1), TimeSpan.Zero, out lockInfo3));
manager.Release(lockInfo);
manager.Release(lockInfo2);
manager.Release(lockInfo3);
}
}
public void RenewLock2()
{
//*** TIME-SENSITIVE TEST, don't use debug-mode
var manager = LockManagerFactory.Create(() => TestDbContext.Create());
var resource1 = new Guid("AFE160D8-0172-4F0B-8A83-E44489080541");
LockInfo lockInfo1;
manager.TryLock(resource1, new TimeSpan(TimeSpan.TicksPerSecond), out lockInfo1);
Assert.True(lockInfo1.HasLock);
Thread.Sleep(1100);
Assert.False(lockInfo1.HasLock);
manager.TryRenewLock(lockInfo1, retryLock: false);
Assert.False(lockInfo1.HasLock);
manager.TryRenewLock(lockInfo1, retryLock: true);
Assert.True(lockInfo1.HasLock);
manager.Release(lockInfo1);
}
public void LockReferenceOverflow()
{
var manager = LockManagerFactory.Create(() => TestDbContext.Create());
var resource1 = new Guid("555279D1-8E95-483F-93ED-012DCE98EE73");
LockInfo lockInfo1;
manager.TryLock(resource1, new TimeSpan(TimeSpan.TicksPerSecond), out lockInfo1);
Thread.Sleep(1050);
Assert.False(lockInfo1.HasLock);
using (var context = TestDbContext.Create())
{
var maxReference = new SqlParameter("lockReference", int.MaxValue);
var resource = new SqlParameter("resource", lockInfo1.Resource);
context.Database.ExecuteSqlCommand("UPDATE DistributedLocks Set LockReference = @lockReference where Resource = @resource", maxReference, resource);
}
manager.TryLock(resource1, new TimeSpan(TimeSpan.TicksPerMinute), out lockInfo1);
Assert.True(lockInfo1.HasLock);
manager.Release(lockInfo1);
}
public void TestAutoCancelTask()
{
// MyTaskAutoCancelTask
// AliveCycle = 1 sec
// LockCycle - 2 secs
// Runs for - 3 secs
using (var manager = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
{
manager.RegisterTaskType(typeof(MyTaskAutoCancelTask),
new TaskSettings("73793DDA-CE7A-4B16-A751-4F90B5799AFA")
{
AliveCycle = new TimeSpan(TimeSpan.TicksPerSecond)
});
manager.EnqueueSingleTask <MyTaskAutoCancelTask>();
MyTaskAutoCancelTask.CancelationRequested = false;
MyTaskAutoCancelTask.ProcessedAllRecords = null;
int tickCount = 0;
manager.SubscribeToListener(() => { if (tickCount++ > 1)
{
manager.StopListener();
}
});
manager.StartListener();
manager.WaitTillListenerStops();
Assert.True(MyTaskAutoCancelTask.CancelationRequested == true);
Assert.True(MyTaskAutoCancelTask.ProcessedAllRecords == false);
Assert.True(manager.LatestListenerException == null);
}
}
public void TestForceCancelTask()
{
// MyTaskAutoCancelTask
// AliveCycle = 1 sec
// LockCycle - 2 secs
// Runs for - 1 hours (till force cancelled)
using (var manager = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
{
manager.RegisterTaskType(typeof(MyTaskForceCancelTask),
new TaskSettings("52BB4E12-3237-4B89-885E-ECEC41C56DE5")
{
AliveCycle = new TimeSpan(TimeSpan.TicksPerSecond)
});
manager.EnqueueSingleTask <MyTaskForceCancelTask>();
MyTaskForceCancelTask.ExecutedTillEnd = null;
MyTaskForceCancelTask.CancelationRequested = false;
int tickCount = 0;
manager.SubscribeToListener(() => { if (tickCount++ > 1)
{
manager.StopListener();
}
});
manager.StartListener();
manager.WaitTillListenerStops();
Assert.True(MyTaskForceCancelTask.CancelationRequested == true);
Assert.True(MyTaskForceCancelTask.ExecutedTillEnd == false);
Assert.True(manager.LatestListenerException == null);
}
}
public void TestRecurrentTaskById()
{
using (var manager = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
{
var guid = "FDC1CFA0-197B-4548-A5D6-2A1183472C37";
manager.RegisterTaskType(typeof(MyTaskRecurrent1), new TaskSettings(guid));
MyTaskRecurrent1.TaskExecuted = 0;
var recurrentId = manager.EnqueueRecurrentTask(new Guid(guid), 1000);
int count = 0;
manager.SubscribeToListener(() =>
{
count++;
if (count > 3)
{
manager.StopListener();
}
else
{
Thread.Sleep(1000);
}
});
manager.StartListener();
manager.WaitTillListenerStops();
Console.AppendLine($"Recurrent Task executed {MyTaskRecurrent1.TaskExecuted} times.");
Assert.True(MyTaskRecurrent1.TaskExecuted > 1, "Task should've executed more than once");
Assert.True(manager.LatestListenerException == null, "No exception exptected");
}
}
public void LockSpeed()
{
var manager = LockManagerFactory.Create(() => TestDbContext.Create());
var resource1 = new Guid("315A4649-12FE-44B2-8402-BE7DB8F2ADB6");
LockInfo lockInfo1;
var watch = new Stopwatch();
//ignores first lock speed;
manager.TryLock(resource1, new TimeSpan(TimeSpan.TicksPerSecond), out lockInfo1);
watch.Start();
for (int i = 0; i < 1000; i++)
{
manager.TryLock(resource1, new TimeSpan(TimeSpan.TicksPerSecond), out lockInfo1);
manager.Release(lockInfo1);
}
watch.Stop();
Console.AppendLine("Elapsed (ms): " + watch.ElapsedMilliseconds);
Assert.True(watch.ElapsedTicks < TimeSpan.TicksPerSecond * 5);
}
public void MultipleManagers()
{
using (var manager = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
using (var manager2 = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
using (var manager3 = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
{
var TOTAL_TASK_COUNT = 80;
manager.StartListener();
manager2.StartListener();
manager3.StartListener();
Thread.Sleep(300);
var guid = "2A71134F-AED4-47D5-AB3C-69B3EBC87C00";
manager.RegisterTaskType(typeof(MyTask), new TaskSettings(guid));
manager2.RegisterTaskType(typeof(MyTask), new TaskSettings(guid));
manager3.RegisterTaskType(typeof(MyTask), new TaskSettings(guid));
MyTask.TaskExecuted = 0;
MyTask.elements = new List <int?>();
MyTask.duplicate = new List <int?>();
var taskIds = new List <int>();
for (int i = 0; i < TOTAL_TASK_COUNT; i++)
{
taskIds.Add(manager.EnqueueSingleTask <MyTask, int?>(i));
}
using (var db = TestDbContext.Create())
{
while (db.SingleTasks.Where(t => taskIds.Contains(t.Id)).Count(t => t.Status == SingleTaskStatus.Scheduled) > 0)
{
Thread.Sleep(333);
}
}
Assert.True(manager.IsListenning);
Assert.True(manager2.IsListenning);
Assert.True(manager3.IsListenning);
manager.StopListener(true);
manager2.StopListener(true);
manager3.StopListener(true);
Assert.True(MyTask.TaskExecuted == TOTAL_TASK_COUNT);
Assert.True(MyTask.elements.Count() == TOTAL_TASK_COUNT);
Assert.True(MyTask.duplicate.Count() == 0);
Assert.True(manager.TasksExecutedCount > 0);
Assert.True(manager2.TasksExecutedCount > 0);
Assert.True(manager3.TasksExecutedCount > 0);
Console.AppendLine($"manager 1: {manager.TasksExecutedCount}");
Console.AppendLine($"manager 2: {manager2.TasksExecutedCount}");
Console.AppendLine($"manager 3: {manager3.TasksExecutedCount}");
Assert.Equal(TOTAL_TASK_COUNT, manager.TasksExecutedCount + manager2.TasksExecutedCount + manager3.TasksExecutedCount);
}
}
