public static bool IsRunning(Guid key) { TaskHistory task = Current.TaskHistoryList.RetryGetValue(key); if (task != null) { return(task.StartedDate.HasValue && !task.TerminatedDate.HasValue); } return(false); }
public static void Cleanup() { var removeList = new ConcurrentBag <Guid>(); foreach (var key in Current.TaskHistoryList.Keys) { var item = Current.TaskHistoryList.RetryGetValue(key); if (item == null) { continue; } if (item.TerminatedDate.HasValue && item.TerminatedDate.Value.AddSeconds(GlobalConfiguration.Settings.CleanupTimeoutInSeconds) > DateTime.Now) { removeList.Add(key); } } foreach (var key in removeList) { TaskHistory item = null; Current.TaskHistoryList.TryRemove(key, out item); } }
internal static void Enqueue(Guid key, string name, Type taskType, Dictionary <string, object> inputParameters = null, Action <Dictionary <string, object> > completed = null, Action <Exception> failed = null, int?delayInMillisecond = null, Action started = null, bool IsScheduled = false, bool IsForced = false) { if (key == Guid.Empty) { throw new ArgumentNullException("key parameter required"); } if (!taskType.GetInterfaces().Contains(typeof(ITask))) { throw new Exception("task must implement ITask"); } if (delayInMillisecond.HasValue && delayInMillisecond.Value < 0) { delayInMillisecond = 0; } var context = ExecutionContext.Create(); context.Id = key; context.Completed = completed ?? context.Completed; context.Failed = failed ?? context.Failed; context.Started = started; context.TaskType = taskType; context.Parameters = inputParameters ?? context.Parameters; context.Force = IsForced; var history = new TaskHistory(); history.Context = context; history.Id = context.Id; history.IsScheduled = IsScheduled; history.Name = name ?? taskType.FullName; var loop = 0; while (true) { if (loop > 5) { break; } if (!Current.TaskHistoryList.TryAdd(context.Id, history)) { loop++; System.Threading.Thread.Sleep(500); continue; } break; } Action <object> executeTask = (state) => { var ctx = (ExecutionContext)state; TaskHistory h = Current.TaskHistoryList.RetryGetValue(ctx.Id) ?? new TaskHistory(); if (ctx.Started != null) { ctx.Started.Invoke(); } if (TaskStarted != null) { try { TaskStarted(state, ctx.Id); } catch (Exception ex) { GlobalConfiguration.Logger.Error(ex); } } ITask taskInstance = null; try { if (ctx.TaskType != null) { taskInstance = (ITask)GlobalConfiguration.DependencyResolver.GetService(ctx.TaskType); } } catch (Exception ex) { GlobalConfiguration.Logger.Error(ex); } if (taskInstance == null) { return; } try { h.StartedDate = DateTime.Now; taskInstance.Execute(ctx); if (ctx.IsCancelRequested) { h.CanceledDate = DateTime.Now; } } catch (Exception ex) { ctx.Exception = ex; h.Exception = ex; if (ctx.Failed != null) { try { ctx.Failed(ex); } catch { } if (TaskFailed != null) { try { TaskFailed(state, ctx.Id); } catch (Exception gex) { GlobalConfiguration.Logger.Error(gex); } } } GlobalConfiguration.Logger.Error(ex); } finally { if (ctx.Completed != null) { try { ctx.Completed(ctx.Parameters); h.Parameters = ctx.Parameters; } catch { } } if (TaskTerminated != null) { try { TaskTerminated(state, ctx.Id); } catch (Exception ex) { GlobalConfiguration.Logger.Error(ex); } } h.TerminatedDate = DateTime.Now; h.Context = null; try { ctx.Dispose(); if (taskInstance is IDisposable) { ((IDisposable)taskInstance).Dispose(); } } catch { } } }; if (!delayInMillisecond.HasValue) { System.Threading.ThreadPool.QueueUserWorkItem( new System.Threading.WaitCallback(executeTask), context); } else { Action <object, bool> timeoutCallback = (state, timeout) => { executeTask.Invoke(context); }; System.Threading.ThreadPool.RegisterWaitForSingleObject( new System.Threading.AutoResetEvent(false), new System.Threading.WaitOrTimerCallback(timeoutCallback), context, delayInMillisecond.Value, true); } }