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