public void Stress_Tasks()
{
int maxThreadPool = 0;
int completionPortThreads = 0;
System.Threading.ThreadPool.GetMaxThreads(out maxThreadPool, out completionPortThreads);
System.Threading.ThreadPool.SetMaxThreads(10, 10);
var mre = new ManualResetEvent(false);
int taskCountCompleted = 0;
List <int> threadIdList = new List <int>();
for (int i = 0; i < 50; i++)
{
TasksHost.Enqueue <StressTask>(completed: (dic) =>
{
var threadId = (int)dic["ThreadId"];
if (!threadIdList.Any(t => t == threadId))
{
threadIdList.Add(threadId);
}
taskCountCompleted++;
if (taskCountCompleted == 50)
{
mre.Set();
}
});
}
mre.WaitOne();
System.Threading.ThreadPool.SetMaxThreads(maxThreadPool, completionPortThreads);
Check.That(threadIdList.Count).IsGreaterThan(0);
}
public void Enqueue_Multi_Task()
{
var chrono = new System.Diagnostics.Stopwatch();
chrono.Start();
TasksHost.Enqueue <LongTask>();
TasksHost.Enqueue <LongTask>();
TasksHost.Enqueue <LongTask>();
TasksHost.Enqueue <LongTask>();
TasksHost.Enqueue <LongTask>();
TasksHost.Enqueue <LongTask>();
TasksHost.Enqueue <LongTask>();
TasksHost.Enqueue <LongTask>();
TasksHost.Enqueue <LongTask>();
TasksHost.Enqueue <LongTask>();
while (true)
{
if (!TasksHost.IsRunning())
{
break;
}
System.Threading.Thread.Sleep(1000);
}
chrono.Stop();
Check.That(chrono.ElapsedMilliseconds).IsLessThan(10 * 10 * 1000);
}
public void Enqueue_And_Cancel()
{
var mre = new ManualResetEvent(false);
var key = Guid.NewGuid();
var parameter = new Dictionary <string, object>();
parameter.Add("count", 0);
TasksHost.Enqueue <LongTask>(key,
parameter,
completed: (dic) =>
{
mre.Set();
});
System.Threading.Thread.Sleep(2 * 1000);
TasksHost.Cancel(key);
mre.WaitOne();
var history = TasksHost.GetHistory(key);
Check.That(history.CanceledDate).IsNotNull();
var count = history.Parameters["count"];
Check.That((int)count).IsLessThan(10);
}
public void Get_Not_Exists_History()
{
var id = Guid.NewGuid();
var h = TasksHost.GetHistory(id);
Check.That(h).IsNull();
}
public void Stop_TasksHost()
{
TasksHost.Enqueue <MyTask>();
TasksHost.Enqueue <MyTask>();
TasksHost.Enqueue <MyTask>();
TasksHost.Enqueue <MyTask>();
TasksHost.Enqueue <StressTask>();
TasksHost.Stop();
}
public void Task_Is_Running()
{
var id = Guid.NewGuid();
var mre = new ManualResetEvent(false);
TasksHost.Enqueue <LongTask>(id, completed: (dic) => mre.Set());
System.Threading.Thread.Sleep(1 * 1000);
var result = TasksHost.IsRunning(id);
mre.WaitOne();
Check.That(result).IsTrue();
}
public void Cancel_Terminated_Task()
{
var id = Guid.NewGuid();
var mre = new ManualResetEvent(false);
TasksHost.Enqueue <MyTask>(id,
completed: (dic) =>
{
mre.Set();
});
mre.WaitOne();
TasksHost.Cancel(id);
}
public void Schedule_Fail_Task()
{
var task = Scheduler.CreateScheduledTask <FailedTask>("failTask")
.EveryMinute();
Scheduler.Add(task);
System.Threading.Thread.Sleep(2 * 1000);
var hList = TasksHost.GetHistory("failTask");
Check.That(hList).IsNotNull();
}
public void Scheduled_Task_Is_Running()
{
var id = Guid.NewGuid();
var task = Scheduler.CreateScheduledTask <LongTask>("runningTask")
.EverySecond(10);
Scheduler.Add(task);
System.Threading.Thread.Sleep(1 * 1000);
var result = TasksHost.IsRunning("runningTask");
System.Threading.Thread.Sleep(10 * 1000);
Check.That(result).IsTrue();
}
public void Task_Exists()
{
var id = Guid.NewGuid();
var mre = new ManualResetEvent(false);
TasksHost.Enqueue <MyTask>(id,
completed: (dic) =>
{
mre.Set();
});
mre.WaitOne();
var result = TasksHost.Exists(id);
Check.That(result).IsTrue();
}
public void Tasks_Cleanup()
{
var id = Guid.NewGuid();
var mre = new ManualResetEvent(false);
TasksHost.Enqueue <MyTask>(id,
completed: (dic) =>
{
mre.Set();
});
mre.WaitOne();
TasksHost.Cleanup();
var result = TasksHost.GetHistory(id);
Check.That(result).IsNull();
}
public void Enqueue_Fail_Task()
{
var id = Guid.NewGuid();
var mre = new ManualResetEvent(false);
TasksHost.Enqueue <FailedTask>(id
, completed: (dic) =>
{
mre.Set();
});
mre.WaitOne();
var histo = TasksHost.GetHistory(id);
Check.That(histo.Exception != null).IsTrue();
}
public void Enqueue_With_Parameter()
{
var id = Guid.NewGuid();
var mre = new ManualResetEvent(false);
TasksHost.Enqueue <ParameterizedTask>(id,
new Dictionary <string, object>()
{
{ "input", "test" }
}, completed: (dic) =>
{
var output = dic["output"];
Check.That(output).Equals("test");
mre.Set();
});
mre.WaitOne();
}
public static void Remove(string taskName)
{
lock (Current.ScheduledTaskList.SyncRoot)
{
var task = Current.ScheduledTaskList.SingleOrDefault(i => i.Name.Equals(taskName, StringComparison.InvariantCultureIgnoreCase));
if (task != null)
{
if (TasksHost.IsRunning(task.Name))
{
var h = TasksHost.GetHistory(task.Name).LastOrDefault();
if (h != null && h.Context != null)
{
h.Context.IsCancelRequested = true;
}
}
Current.ScheduledTaskList.Remove(task);
}
}
}
public void Enqueue_Task_With_Progress()
{
var tp = new MockTaskProgress();
TasksOnTime.Notification.NotificationService.SetTaskProgress(tp);
var mre = new ManualResetEvent(false);
var key = Guid.NewGuid();
TasksHost.Enqueue <ProgressTask>(key,
completed: (dic) =>
{
mre.Set();
});
mre.WaitOne();
Check.That(tp.NotificationList).IsNotNull();
Check.That(tp.NotificationList.Count).IsGreaterThan(0);
}
public void Enqueue_With_Delay()
{
var task = new MyTask();
var mre = new ManualResetEvent(false);
var chrono = new System.Diagnostics.Stopwatch();
chrono.Start();
TasksHost.Enqueue <MyTask>(
completed: (dic) =>
{
mre.Set();
},
delayInMillisecond: 5 * 1000);
mre.WaitOne();
chrono.Stop();
Check.That(chrono.ElapsedMilliseconds).IsGreaterThan(4 * 1000);
}
public void Non_Generic_Enqueue()
{
var mre = new ManualResetEvent(false);
var key = Guid.NewGuid();
TasksHost.Enqueue(key,
typeof(MyTask),
completed: (dic) =>
{
mre.Set();
});
mre.WaitOne();
var history = TasksHost.GetHistory(key);
Check.That(history).IsNotNull();
Check.That(history.TerminatedDate).IsNotNull();
Check.That(history.Context).IsNull();
}
public IQueryable <ScheduledTaskViewModel> GetList()
{
var taskList = Scheduler.GetList();
var result = new List <ScheduledTaskViewModel>();
foreach (var item in taskList)
{
var task = new ScheduledTaskViewModel()
{
Name = item.Name,
CreationDate = item.CreationDate,
NextRunningDate = item.NextRunningDate,
Period = item.Period,
StartedCount = item.StartedCount,
Enabled = item.Enabled,
Exception = item.Exception,
};
var historyList = TasksHost.GetHistory(item.Name);
var historyListVM = new List <TaskHistoryViewModel>();
foreach (var historyItem in historyList)
{
var historyVM = new TaskHistoryViewModel();
historyVM.CanceledDate = historyItem.CanceledDate;
historyVM.CreationDate = historyItem.CreationDate;
historyVM.Exception = historyItem.Exception;
historyVM.Id = historyItem.Id;
historyVM.Name = historyItem.Name;
historyVM.Parameters = historyItem.Parameters;
historyVM.StartedDate = historyItem.StartedDate;
historyVM.TerminatedDate = historyItem.TerminatedDate;
historyListVM.Add(historyVM);
}
task.HistoryList = historyListVM;
result.Add(task);
}
return(result.AsQueryable());
}
internal virtual void ProcessTask(ScheduledTask scheduledTask)
{
if (scheduledTask.IsQueued &&
!scheduledTask.AllowMultipleInstance)
{
GlobalConfiguration.Logger.Warn("scheduled task {0} is in queue and not allow multiple instance", scheduledTask.Name);
return;
}
if (!scheduledTask.AllowMultipleInstance)
{
if (TasksHost.IsRunning(scheduledTask.Name))
{
GlobalConfiguration.Logger.Warn("scheduled task {0} is already running and not allow multiple instance", scheduledTask.Name);
return;
}
}
var id = Guid.NewGuid();
scheduledTask.IsQueued = true;
TasksHost.Enqueue(
id
, scheduledTask.Name
, scheduledTask.TaskType
, scheduledTask.Parameters
, (dic) =>
{
GlobalConfiguration.Logger.Info("scheduled task {0} completed", scheduledTask.Name);
scheduledTask.IsQueued = false;
try
{
if (scheduledTask.Completed != null)
{
scheduledTask.Completed(dic);
}
}
catch (Exception ex)
{
GlobalConfiguration.Logger.Error(ex);
}
finally
{
scheduledTask.IsForced = false;
if (scheduledTask.NextRunningDateFactory != null)
{
try
{
scheduledTask.NextRunningDate = scheduledTask.NextRunningDateFactory.Invoke();
}
catch (Exception ex)
{
GlobalConfiguration.Logger.Error(ex);
}
}
}
}
, (ex) =>
{
scheduledTask.Exception = ex;
GlobalConfiguration.Logger.Error(ex);
if (TaskFailed != null)
{
try
{
TaskFailed.Invoke(scheduledTask.Name, ex);
}
catch { }
}
},
null,
() =>
{
GlobalConfiguration.Logger.Info("scheduled task {0} started", scheduledTask.Name);
scheduledTask.StartedCount += 1;
if (TaskStarted != null)
{
try
{
TaskStarted.Invoke(scheduledTask.Name);
}
catch { }
}
},
true,
scheduledTask.IsForced);
}
public void Enqueue_With_Task_Not_Implements_ITask()
{
TasksHost.Enqueue(typeof(BadTask));
}
public static void ClassCleanup()
{
TasksHost.Stop();
}
public void Cancel_Not_Existing_Task()
{
TasksHost.Cancel(Guid.NewGuid());
}
