/// <summary> /// Остановить. /// </summary> public void Stop() { lock (_syncObject) { State = TaskStates.Stopping; _syncObject.Pulse(); } }
public ProgressUpdateEventArgs(string taskId, string filepath, int percentage, TaskStates state, DateTime[] timestamps = null) { TaskId = taskId; Filepath = filepath; Percentage = percentage; State = state; Timestamps = timestamps; }
private static void ApplyStatusFilter(NameValueCollection query, TaskStates statusFilter) { var statesToCheck = new[] { TaskStates.Queued, TaskStates.Running, TaskStates.Complete, TaskStates.Error, TaskStates.Cancelled, TaskStates.Killed, TaskStates.Timeout }; foreach (TaskStates state in statesToCheck.Where(x => statusFilter.HasFlag(x))) { query.Add(Convert.ToString(state).ToLower(), "1"); } }
/// <exception cref="ArgumentOutOfRangeException">The queue identifier should be great than 0.</exception> protected TaskStateModel(Int64 queueId) { if (queueId <= 0) { throw new ArgumentOutOfRangeException("queueId", "The queue identifier should be great than 0."); } Id = 0; QueueId = queueId; ServerId = 0; TaskState = TaskStates.New; }
/// <summary> /// Обработать ошибку. /// </summary> /// <param name="error">Ошибка.</param> protected void HandleError(Exception error) { this.AddErrorLog(error); if (Settings.MaxErrorCount == 0 || ++_currentErrorCount < Settings.MaxErrorCount) { return; } this.AddErrorLog(LocalizedStrings.Str2193); State = TaskStates.Stopping; }
private void handleStatusChanged(LogEntry entry) { TaskStates state = (TaskStates)int.Parse(entry.props[1]); foreach (ListViewItem item in lsvTasks.Items) { if (item.SubItems[0].Text == entry.props[0]) { item.SubItems[3].Text = state.ToString(); ganttChart.changeState(uint.Parse(entry.props[0]), state, state == TaskStates.RUNNING); break; } } }
public void changeState(uint index, TaskStates state, bool nextTick) { if (tasks[index].spans.Count == 0 || state != (tasks[index].spans.Last().type)) { tasks[index].spans.Add(new GanttSpan() { type = state, start = sliceCount }); } if (nextTick) { sliceCount++; } chart.Invalidate(); }
public void Save(ITaskState state) { if (state.ID == 0) { if (states.Count > 0) { state.ID = TaskStates.Max(s => s.ID) + 1; } else { state.ID = 1; } states.Add(state); } }
/// <summary> /// Set task's state. /// </summary> /// <param name="id">The task's identifier.</param> /// <param name="taskState">New task's state that we are going to set.</param> public void SetTaskState(Int64 id, TaskStates taskState) { //TODO: if [id] == null then task should be mark as cancelled. const string updateStatement = "UPDATE {0}.{1} SET [State]={2}, [CompletedAt]='{3}' WHERE [Id] = {4}"; string sqlCommand = string.Format(updateStatement, sqlSettings.WiseQueueDefaultSchema, taskTableName, (short)taskState, DateTime.UtcNow.ToString("s"), id); using (IDbConnection connection = connectionFactory.CreateConnection()) { using (IDbCommand command = connectionFactory.CreateCommand(connection)) { command.CommandText = sqlCommand; command.ExecuteNonQuery(); } } }
public TaskState Add(TaskState newParam) { using (var scope = _serviceProvider.CreateScope()) { var _ctx = scope.ServiceProvider.GetService(typeof(SQLHoshinCoreContext)) as SQLHoshinCoreContext; var taskState = new TaskStates(); taskState.Active = newParam.Active; taskState.Code = newParam.Code; taskState.Color = newParam.Color; taskState.Name = newParam.Name; _ctx.TaskStates.Add(taskState); _ctx.SaveChanges(); newParam.TaskStateID = taskState.TaskStateID; return(newParam); } }
public void Delete(ITaskState state) { ITaskState newState = TaskStates.FirstOrDefault(s => s.Flag == TaskStateFlag.Initial); foreach (ITask task in Tasks.Where(t => t.State == state).ToArray()) { if (newState != null) { task.State = newState; } else { tasks.Remove(task); } } states.Remove(state); }
public void SetNewState(TaskStates newState) { switch (newState) { case TaskStates.New: break; case TaskStates.Committed: break; case TaskStates.InProgress: break; case TaskStates.Done: break; default: break; } }
/// <summary> /// Constructor. /// </summary> /// <param name="queueId">The queue's identifier where the task will be put.</param> /// <param name="activationData">Task's activation data.</param> /// <param name="scheduleInformation"></param> /// <exception cref="ArgumentOutOfRangeException">The queue identifier should be greate than 0.</exception> /// <exception cref="ArgumentNullException"><paramref name="activationData"/> is <see langword="null" />.</exception> /// <remarks>This constructor should be used only for new tasks entities.</remarks> public TaskModel(long queueId, ActivationData activationData, ScheduleInformation scheduleInformation) { if (queueId <= 0) { throw new ArgumentOutOfRangeException("queueId", "The queue identifier should be greate than 0."); } if (activationData == null) { throw new ArgumentNullException("activationData"); } if (scheduleInformation == null) { throw new ArgumentNullException(nameof(scheduleInformation)); } this.queueId = queueId; ActivationData = activationData; ScheduleInformation = scheduleInformation; taskState = TaskStates.New; }
public void SetTaskStates(IEnumerable <ITaskState> taskStates) { if (TaskStates == null) { TaskStates = new ObservableCollection <ITaskState>(); } if (CheckableTaskStates == null) { CheckableTaskStates = new ObservableCollection <Checkable <ITaskState> >(); } if (taskStates != null) { TaskStates.Clear(); TaskStates.AddRange(taskStates); CheckableTaskStates.AddRange(Checkable.Create(taskStates, true)); } }
/// <summary> /// Constructor. /// </summary> /// <param name="taskId">Task's identifier.</param> /// <param name="queueId">The queue's identifier where the task will be put.</param> /// <param name="serverId">The server's identifier that is used for processing the task.</param> /// <param name="taskState">Task's state.</param> /// <exception cref="ArgumentOutOfRangeException">The task identifier should be great than 0.</exception> /// <exception cref="ArgumentOutOfRangeException">The queue identifier should be great than 0.</exception> /// <exception cref="ArgumentOutOfRangeException">The server identifier should be great than 0.</exception> public TaskStateModel(Int64 taskId, Int64 queueId, Int64 serverId, TaskStates taskState) { if (taskId <= 0) { throw new ArgumentOutOfRangeException("taskId", "The task identifier should be great than 0."); } if (queueId <= 0) { throw new ArgumentOutOfRangeException("queueId", "The queue identifier should be great than 0."); } if (serverId <= 0) { throw new ArgumentOutOfRangeException("serverId", "The server identifier should be great than 0."); } Id = taskId; QueueId = queueId; ServerId = serverId; TaskState = taskState; }
private static String FormatMessage(TaskStates current, params TaskStates[] expected) { Contracts.Require.AtLeastOneParam<TaskStates>("expected", expected); String sexp = expected[0].ToString(); for (int i = 0; i < expected.Length; ++i) { if (i == expected.Length - 1) sexp += "or " + expected[i].ToString(); else sexp += ", " + expected[i].ToString(); } return String.Format(Properties.Resources.Error_TaskStateInvalidExpect, sexp, current); }
/// <summary> /// Вызвать событие <see cref="Started"/>. /// </summary> protected void RaiseStarted() { State = TaskStates.Started; Started.SafeInvoke(this); }
public ActionResult List(TaskStates state) { var workers = Scheduler.LoadWorkers().Where(w => w.State.Equals(state)); ViewBag.TaskState = state; return PartialView(workers); }
/// <summary> /// Запустить. /// </summary> public void Start() { if (State != TaskStates.Stopped) { return; } _currentErrorCount = 0; ThreadingHelper.Thread(() => { try { WaitIfNecessary(TimeSpan.Zero); State = TaskStates.Starting; OnStarting(); var attempts = 60; while (State == TaskStates.Starting && attempts-- > 0) { WaitIfNecessary(TimeSpan.FromSeconds(1)); } if (State == TaskStates.Starting) { this.AddErrorLog(LocalizedStrings.Str2191); } while (State == TaskStates.Started) { try { var interval = OnProcess(); if (interval == TimeSpan.MaxValue) { Stop(); break; } // сбрасываем счетчик при успешной итерации _currentErrorCount = 0; WaitIfNecessary(interval); } catch (Exception ex) { HandleError(ex); WaitIfNecessary(TimeSpan.FromSeconds(5)); } } } catch (Exception ex) { this.AddErrorLog(ex); this.AddErrorLog(LocalizedStrings.Str2192); } finally { try { OnStopped(); } catch (Exception ex) { this.AddErrorLog(ex); } Stopped.SafeInvoke(this); State = TaskStates.Stopped; } }) .Name("{0} Task thread".Put(Name)) .Launch(); }
/// <summary> /// Enables retry policy to process. /// </summary> /// <param name="cancellationToken">The optional cancellation token.</param> /// <returns>The processing retry result.</returns> public async Task <RetryResult> ProcessAsync(CancellationToken cancellationToken = default) { State = TaskStates.Initializing; var result = new RetryResult(); var retry = RetryPolicy?.CreateInstance() ?? new InternalRetryInstance(); State = TaskStates.Working; while (true) { try { cancellationToken.ThrowIfCancellationRequested(); } catch (OperationCanceledException) { State = TaskStates.Canceled; throw; } catch (ObjectDisposedException) { State = TaskStates.Canceled; throw; } try { await OnProcessAsync(cancellationToken); Processing?.Invoke(this, new RetryEventArgs(retry.ProcessTime)); State = TaskStates.Done; result.Success(); return(result); } catch (Exception ex) { State = TaskStates.WaitingToRetry; result.Fail(ex); try { ex = ExceptionHandler.GetException(ex); } catch (Exception) { State = TaskStates.Faulted; throw; } if (ex != null) { State = TaskStates.Faulted; throw ex; } } var span = retry.Next(); if (!span.HasValue) { State = TaskStates.Faulted; result.End(); return(result); } await Task.Delay(span.Value, cancellationToken); State = TaskStates.Retrying; } }
/// <summary> /// Get next execution time. /// </summary> /// <param name="currentExecutionTime">The date and time when this task has been executed.</param> /// <param name="taskState">Current task state</param> /// <returns>The datetime when task should be executed.</returns> public DateTime GetNextExecutionTime(DateTime currentExecutionTime, TaskStates taskState) { return(executeAt); }
/// <summary> /// Gets a value indicating whether the task is end. /// </summary> /// <param name="state">The task state.</param> /// <returns>true if the task is end; otherwise, false.</returns> public static bool IsEnd(TaskStates state) => state == TaskStates.Done || state == TaskStates.Canceled || state == TaskStates.RolledBack || state == TaskStates.Faulted;
private static void ApplyStatusFilter(NameValueCollection query, TaskStates statusFilter) { var statesToCheck = new[] {TaskStates.Queued, TaskStates.Running, TaskStates.Complete, TaskStates.Error, TaskStates.Cancelled, TaskStates.Killed, TaskStates.Timeout}; foreach (TaskStates state in statesToCheck.Where(x => statusFilter.HasFlag(x))) { query.Add(Convert.ToString(state).ToLower(), "1"); } }
public void StartTask(int arg) { id = arg; InitDefault(id); state = TaskStates.NEW; clearPlayerPrefs(); }
/// <summary> /// Read properties from specified url. /// </summary> /// <param name="url"></param> public void Read(string url) { var xmlDoc = XDocument.Load(url); var ns = xmlDoc.Root.GetDefaultNamespace(); DateTime startAt = DateTime.MinValue; DateTime nextStart = DateTime.MinValue; var root = xmlDoc.Root; CommandData = new Dictionary<string, object>(); DateTime.TryParse(root.Element(ns + "startAt").Value, out startAt); DateTime.TryParse(root.Element(ns + "nextStart").Value, out nextStart); var fstr = root.Element(ns + "recurs").StrAttr("frequency"); if (string.IsNullOrEmpty(this.Name)) this.Name= System.IO.Path.GetFileNameWithoutExtension(url); this.Frequency = !string.IsNullOrEmpty(fstr) ? (Frequencies)Enum.Parse(typeof(Frequencies), fstr) : Frequencies.Minutely; this.JobType = Type.GetType(root.Element(ns + "command").StrAttr("type")); this.Recurs = root.Element(ns + "recurs").IntAttr("value"); if (root.Element(ns + "title") != null) this.Title = root.Element(ns + "title").Value; if (root.Element(ns + "desc") != null) this.Description = root.Element(ns + "desc").Value; if (root.Element(ns + "state") != null) { var stateStr = root.Element(ns + "state").Value; if (!string.IsNullOrEmpty(stateStr)) { this.State = (TaskStates)Enum.Parse(typeof(TaskStates), stateStr); } } var recurringDaysOfWeek = root.Element(ns + "recurs").StrAttr("daysOfWeek"); var recurringDaysOfMonth = root.Element(ns + "recurs").StrAttr("daysOfMonth"); var recurringMonths = root.Element(ns + "recurs").StrAttr("months"); if (!string.IsNullOrEmpty(recurringDaysOfWeek)) this.RecurringDaysOfWeek = recurringDaysOfWeek.Split(',').Select(a => Convert.ToInt32(a)).ToArray(); if (!string.IsNullOrEmpty(recurringDaysOfMonth)) this.RecurringDaysOfWeek = recurringDaysOfMonth.Split(',').Select(a => Convert.ToInt32(a)).ToArray(); if (!string.IsNullOrEmpty(recurringMonths)) this.RecurringMonths = recurringMonths.Split(',').Select(a => Convert.ToInt32(a)).ToArray(); foreach (var param in root.Element(ns + "command").Elements()) CommandData.Add(param.StrAttr("name"), param.Value); this.StartAt = startAt; this.NextStart = nextStart; this.File = url; }
public void CheckTasks() { if(tasksBuffer != null) { tasksBuffer.Clear(); } else { tasksBuffer = new ArrayList(); } state = TaskStates.IN_PROCESS; if(activeTasks != null) { int activeTasksCount = 0; foreach(Task task in activeTasks) { if(!task.Check(fishesInfo)) { tasksBuffer.Add(task.getTitle(fishesInfo)); activeTasksCount++; } } if(activeTasksCount <= 0) { state = TaskStates.COMPLETE; } } else { state = TaskStates.NONE; } }
/// <summary> /// Put the work item to work. /// </summary> public void Run() { this.State = TaskStates.Running; if (job == null) job = GetJob(); try { job.Execute(); this.LastRunTime = DateTime.Now; } catch (Exception e) { this.State = TaskStates.Stop; //Fail and retry ? Should we need to handle the retry ? job.OnError(e); Logger.Error(e); } //Counter++; if (Frequency == Frequencies.OneTime) this.State = TaskStates.Completed; else { StartAt = NextStart; this.State = TaskStates.Ready; NextStart = GetNextStart(StartAt); } this.Save(); }
/// <summary> /// Gets a value indicating whether the task is not finished. /// </summary> /// <param name="state">The task state.</param> /// <returns>true if the task is not finished; otherwise, false.</returns> public static bool IsPendingOrWorking(TaskStates state) => !IsEnd(state);
public TaskStateInvalidException(TaskStates current, params TaskStates[] expected) : base(TaskStateInvalidException.FormatMessage(current, expected)) { }
private void ErrorHandle(TaskStates state, Exception ex) { State = state; exception = ex; Finished?.Invoke(this, new ResultEventArgs <T>(ex, state)); }
/// <summary> /// Get available task from the storage. /// </summary> /// <param name="specification">The <see cref="TaskRequestSpecification"/> instance.</param> /// <param name="taskModels">List of <see cref="WiseQueue.Core.Common.Models.Tasks.TaskStateModel"/> instances if it has been found</param> /// <returns>True if the list of TaskModel instances has been populated. Otherwise, false.</returns> public bool TryGetAvailableTask(TaskRequestSpecification specification, out List <TaskModel> taskModels) { if (specification == null) { throw new ArgumentNullException("specification"); } StringBuilder stringBuilder = new StringBuilder(); stringBuilder.Append("Declare @TempTable table ([Id] [bigint], "); stringBuilder.Append("[QueueId] [bigint], "); stringBuilder.Append("[ServerId] [bigint] NULL, "); stringBuilder.Append("[State] [smallint], "); stringBuilder.Append("[CompletedAt] [datetime] NULL, "); stringBuilder.Append("[ExecuteAt] [datetime] NOT NULL, "); stringBuilder.Append("[RepeatCrashCount] [int] NOT NULL, "); stringBuilder.Append("[InstanceType] [nvarchar](4000), "); stringBuilder.Append("[Method] [nvarchar](4000), "); stringBuilder.Append("[ParametersTypes] [nvarchar](4000), "); stringBuilder.AppendLine("[Arguments] [nvarchar](4000)); "); stringBuilder.AppendFormat("UPDATE TOP ({0}) {1}.{2} ", specification.MaxTasks, sqlSettings.WiseQueueDefaultSchema, taskTableName); stringBuilder.AppendFormat("SET State = {0}, ", (short)TaskStates.Pending); stringBuilder.AppendFormat("ServerId = {0} ", specification.ServerId); //stringBuilder.Append("RepeatCount = RepeatCount - 1 "); stringBuilder.Append("OUTPUT inserted.* INTO @TempTable "); stringBuilder.AppendFormat("Where (State = {0} ", (short)TaskStates.New); stringBuilder.AppendFormat("OR ( (State = {0} OR State = {1}) AND [ServerId] IS NULL)) ", (short)TaskStates.Pending, (short)TaskStates.Running); stringBuilder.AppendFormat("AND (QueueId = {0}) AND ([ExecuteAt] <= GETUTCDATE()) AND [RepeatCrashCount] > 0;", specification.QueueId); stringBuilder.AppendLine(); stringBuilder.AppendLine("SELECT * FROM @TempTable"); using (IDbConnection connection = connectionFactory.CreateConnection()) { using (IDbTransaction transaction = connection.BeginTransaction(IsolationLevel.Serializable)) { using (IDbCommand command = connectionFactory.CreateCommand(connection, transaction)) { command.CommandText = stringBuilder.ToString(); using (IDataReader rdr = command.ExecuteReader()) { taskModels = new List <TaskModel>(); while (rdr.Read()) { Int64 id = (Int64)rdr["Id"]; Int64 queueId = (Int64)rdr["QueueId"]; Int64 serverId = (Int64)rdr["ServerId"]; TaskStates taskState = (TaskStates)(short)rdr["State"]; int repeatCrashCount = (int)rdr["RepeatCrashCount"]; string typeDetails = (string)rdr["InstanceType"]; string methodDetails = (string)rdr["Method"]; string parameterDetails = (string)rdr["ParametersTypes"]; string argumentDetails = (string)rdr["Arguments"]; TaskEntity taskEntity = new TaskEntity { Id = id, QueueId = queueId, ServerId = serverId, TaskState = taskState, InstanceType = typeDetails, Method = methodDetails, ParametersTypes = parameterDetails, Arguments = argumentDetails, RepeatCrashCount = repeatCrashCount }; TaskModel taskModel = taskConverter.Convert(taskEntity); taskModels.Add(taskModel); } } } if (taskModels.Count > 0) { transaction.Commit(); return(true); } } return(false); } }
/// <summary> /// Gets a value indicating whether the task is pending to process. /// </summary> /// <param name="state">The task state.</param> /// <returns>true if the task is pending to process; otherwise, false.</returns> public static bool IsPending(TaskStates state) => state == TaskStates.Pending;
private void updateDisplay(byte[] s) { LogEntry entry = new LogEntry(); entry.msg = (LogMsg)s[0]; if (entry.msg == LogMsg.LOG_START) { phils = new List <Philosopher>(); } else { if (phils == null) { return; } Philosopher p; entry.props = Encoding.ASCII.GetString(s, 5, s.Length - 5).Split(';'); switch (entry.msg) { case LogMsg.LOG_NEW_TASK: p = new Philosopher(); p.tid = uint.Parse(entry.props[0]); if (p.tid == 0) { return; } p.name = entry.props[1]; phils.Add(p); break; case LogMsg.LOG_TASK_STATUS_CHANGE: TaskStates state = (TaskStates)int.Parse(entry.props[1]); uint tid = uint.Parse(entry.props[0]); if (tid == 0) { return; } p = (from temp in phils where temp.tid == tid select temp).First(); switch (state) { case TaskStates.READY: p.state = PhilStates.EATING; break; case TaskStates.SUSPENDED: p.state = PhilStates.WAITING; break; case TaskStates.SLEEPING: p.state = PhilStates.THINKING; break; case TaskStates.RUNNING: p.state = PhilStates.EATING; break; } break; } Refresh(); } }
/// <summary> /// Gets a value indicating whether the task is processing. /// </summary> /// <param name="state">The task state.</param> /// <returns>true if the task is processing; otherwise, false.</returns> public static bool IsWorking(TaskStates state) => state == TaskStates.Working || state == TaskStates.WaitingToRetry || state == TaskStates.Retrying;
/// <summary> /// Gets a value indicating whether the task is pending to process. /// </summary> /// <param name="state">The task state.</param> /// <returns>true if the task is pending to process; otherwise, false.</returns> public static bool IsWaiting(TaskStates state) => state == TaskStates.Pending || state == TaskStates.Initializing || state == TaskStates.WaitingToRetry || state == TaskStates.Pausing || state == TaskStates.Paused || state == TaskStates.Resuming;
/// <summary> /// Performs a state transition on the task. /// </summary> /// <param name="state">The task's new state.</param> /// <exception cref="TaskStateInvalidException"> /// thrown if the task is in a state that makes the state transition /// invalid.</exception> protected void SetTaskState(TaskStates state) { switch (state) { case TaskStates.Pending: AssertState(TaskStates.Idle); break; case TaskStates.PendingScheduled: AssertState(TaskStates.Idle); break; case TaskStates.PendingCancel: case TaskStates.Executing: AssertState(TaskStates.Pending, TaskStates.PendingScheduled); break; case TaskStates.Yielding: case TaskStates.Completed: case TaskStates.CompletedSuccess: AssertState(TaskStates.Executing); break; case TaskStates.CompletedWithError: AssertState(TaskStates.PendingScheduled, TaskStates.Yielding, TaskStates.Executing); break; case TaskStates.CompletedCanceled: AssertState(TaskStates.PendingCancel); break; case TaskStates.Idle: default: throw new ArgumentOutOfRangeException(); } _taskState.SetState(state); }
public Tasks(int arg_id, GameObject arg_go) { id = arg_id; if(arg_go != null) { tasksText = (GUIText)arg_go.GetComponent(typeof(GUIText)); } InitTasks(); InitDefault(id); state = TaskStates.NONE; }
/// <summary> /// Gets a value indicating whether the task is cancelled. /// </summary> /// <param name="state">The task state.</param> /// <returns>true if the task is cancelled; otherwise, false.</returns> public static bool IsCanceled(TaskStates state) => state == TaskStates.Canceled;
public void setStarted() { state = TaskStates.IN_PROCESS; }
/// <summary> /// Gets a value indicating whether the task is done. /// </summary> /// <param name="state">The task state.</param> /// <returns>true if the task is done; otherwise, false.</returns> public static bool IsDone(TaskStates state) => state == TaskStates.Done;
public TaskStates Update(float arg) { string result = ""; if(activeTasks != null && tasksText != null) { timer += arg; result += "Time : " + (int)(taskTime - timer) + "\n"; foreach(string task in tasksBuffer) { result += task + "\n"; } tasksText.text = result; } if(timer > taskTime) { state = TaskStates.FAIL; } return state; }
/// <summary> /// Gets a value indicating whether the task is failed. /// </summary> /// <param name="state">The task state.</param> /// <returns>true if the task is failed; otherwise, false.</returns> public static bool IsFailed(TaskStates state) => state == TaskStates.Faulted;