public void CancelTask() { try { if (repo.Active) { repo.CancelDownloads(); Active = false; Status = "Task cancelled"; ComicConvert.ImgsToCbz(repo.Location, OutputFileName); if (TaskCancelled != null) { TaskCancelled.Invoke(this, new EventArgs()); } } } catch (Exception ex) { Console.WriteLine(ex.Message); } Active = false; Status = "Task cancelled"; if (TaskCancelled != null) { TaskCancelled.Invoke(this, new EventArgs()); } }
/// <summary> /// 取消下载任务 /// </summary> public void Cancel() { lock (_external_lock) { lock (_thread_flag_lock) { //Tracer.GlobalTracer.TraceInfo("---CANCELLED---"); if (((_download_thread_flag & 0xffffff) & (_DOWNLOAD_THREAD_FLAG_STOPPED | _DOWNLOAD_THREAD_FLAG_FINISHED)) != 0) { return; } if ((_download_thread_flag & 0xffffff) == _DOWNLOAD_THREAD_FLAG_READY) { _download_thread_flag = (_download_thread_flag | _DOWNLOAD_THREAD_FLAG_STOPPED) & ~_DOWNLOAD_THREAD_FLAG_READY; return; } else if ((_download_thread_flag & 0xffffff) == _DOWNLOAD_THREAD_FLAG_PAUSED) { _download_thread_flag = (_download_thread_flag | _DOWNLOAD_THREAD_FLAG_STOPPED) & ~_DOWNLOAD_THREAD_FLAG_PAUSED; return; } else if (((_download_thread_flag & 0xffffff) & (_DOWNLOAD_THREAD_FLAG_STARTED | _DOWNLOAD_THREAD_FLAG_START_REQUESTED)) != 0) { _download_thread_flag |= _DOWNLOAD_THREAD_FLAG_STOP_REQUESTED; } } _monitor_thread_created.Wait(); _monitor_thread.Join(); _monitor_thread_created.Reset(); Dispose(); } try { TaskCancelled?.Invoke(this, new EventArgs()); } catch { } }
private void Handle(TaskCancelled message) { RequireActivation(true); if (message.ParentTaskInstanceId != this.InstanceId) { throw new Exception(); } TransitionInfo ti = GetTransition(message.FromTaskInstanceId); if (ti == null) { throw new Exception(); } lock (this) { log.Info("Child task {0} has been cancelled", ti.InstanceId); if (ti.Status == TransitionStatus.Cancelled) { return; } if (!ti.IsTransitionActive) { log.Warn("Transition {0} ({1}) is not active: {2}", ti.InstanceId, ti.TaskId, ti.Status); return; } ti.Status = TransitionStatus.Cancelled; OnTransitionStatusChanged(ti.InstanceId); return; } }
public void Handle(TaskCancelled @event) { if (@event.QueueId != queueId) { return; } timer.Stop(); }
/// <summary> /// Add a <see cref="TaskCancelled"/> callback /// </summary> /// <param name="callback"><see cref="TaskCancelled"/> callback to add</param> /// <returns>The <see cref="TaskContext"/></returns> public TaskContext Cancelled(TaskCancelled callback) { if (IsCancelled) { callback(this); } _cancelled += callback; return(this); }
public void Cancel() { lock (_external_lock) { lock (_thread_flag_lock) { //cancelled state if ((_upload_thread_flag & (_UPLOAD_THREAD_FLAG_CANCELLED | _UPLOAD_THREAD_FLAG_FINISHED)) != 0) { return; } //ready state if ((_upload_thread_flag & _UPLOAD_THREAD_FLAG_READY) != 0) { _upload_thread_flag = (_upload_thread_flag | _UPLOAD_THREAD_FLAG_CANCELLED) & ~_UPLOAD_THREAD_FLAG_READY; return; } //paused state if ((_upload_thread_flag & _UPLOAD_THREAD_FLAG_PAUSED) != 0) { _upload_thread_flag = (_upload_thread_flag | _UPLOAD_THREAD_FLAG_CANCELLED) & ~_UPLOAD_THREAD_FLAG_PAUSED; return; } if ((_upload_thread_flag & (_UPLOAD_THREAD_FLAG_STARTED | _UPLOAD_THREAD_FLAG_START_REQUESTED)) != 0) { Tracer.GlobalTracer.TraceInfo("---CANCELLED---"); _upload_thread_flag |= _UPLOAD_THREAD_FLAG_CANCEL_REQUESTED; } _monitor_thread_created.Wait(); _monitor_thread_exited.Wait(); _monitor_thread_exited.Reset(); _monitor_thread_created.Reset(); Dispose(); } } try { TaskCancelled?.Invoke(this, new EventArgs()); } catch { } }
public void RaiseTaskCancelled(Task task, [CallerMemberName] string taskName = default) { var status = $"[Cancelled] Task: {taskName}. status: {task.Status}".AppendMainThreadAlert(); TaskCancelled?.Invoke(this, new TaskStatusChangedEventArgs(task, status)); }
/// <summary> /// Add a <see cref="TaskCancelled"/> callback /// </summary> /// <param name="callback"><see cref="TaskCancelled"/> callback to add</param> /// <returns>The <see cref="TaskContext"/></returns> public TaskContext Cancelled(TaskCancelled callback) { if (IsCancelled) callback(this); _cancelled += callback; return this; }
/// <summary> /// Handle notification about child task been cancelled. /// What should happen then? /// Transition info should be updated to reflect the fact that child task /// has been cancelled. However, no tokens should be returned to task's input places, /// because it would re-enable the task, and that's not what we want. /// If all tasks are cancelled and there will be no more tokens, composite task /// will complete. If it cannot complete due to missing output data, it will fail. /// </summary> /// <param name="tce"></param> private void HandleChildTaskCancelled(TaskCancelled tce) { if (tce.ParentTaskInstanceId != this.InstanceId) throw new Exception("Parent task correlation id is incorrect"); TransitionInfo ti = GetTransitionInfo(tce.FromTaskInstanceId); if (ti == null) throw new Exception("Child task not found"); log.Debug("Child task {0} cancelled. Current transition status: {1}", tce.FromTaskInstanceId, ti.Status); if (ti.Status == TransitionStatus.Enabling) { ti.Status = TransitionStatus.Enabled; } if (ti.Status == TransitionStatus.Cancelled) { return; //nothing tbd } else if (ti.Status == TransitionStatus.Started || ti.Status == TransitionStatus.FailedActive) { ti.Status = TransitionStatus.Cancelled; //do nothing more, the task has consumed the tokens already } else if (ti.Status == TransitionStatus.Enabled) { ConsumeTaskInputTokens(ti.InstanceId); Debug.Assert(ti.Status == TransitionStatus.Started); } else if (ti.Status == TransitionStatus.Cancelling) { //everyth. ok. } else { log.Warn("Child task {0} ({1}) cancelled, but current transition status is {2}. Ignoring the notification - status inconsistent", tce.FromTaskInstanceId, ti.TaskId, ti.Status); return; } ti.Status = TransitionStatus.Cancelled; if (Status == TaskStatus.Enabled || Status == TaskStatus.Selected) { ProduceTaskOutputTokens(ti.InstanceId); } ContinueTaskExecution(); //OnInternalStatusChanged(); //DetectTaskCompletion(); }
private void Handle(TaskCancelled message) { HandleChildTaskCancelled(message); }
private void _on_task_cancelled(object sender, EventArgs e) { try { TaskCancelled?.Invoke(sender, e); } catch { } }
private void OnTaskCancelled() { TaskCancelled?.Invoke(this, EventArgs.Empty); }
private void Handle(TaskCancelled message) { RequireActivation(true); if (message.ParentTaskInstanceId != this.InstanceId) throw new Exception(); TransitionInfo ti = GetTransition(message.FromTaskInstanceId); if (ti == null) throw new Exception(); lock (this) { log.Info("Child task {0} has been cancelled", ti.InstanceId); if (ti.Status == TransitionStatus.Cancelled) return; if (!ti.IsTransitionActive) { log.Warn("Transition {0} ({1}) is not active: {2}", ti.InstanceId, ti.TaskId, ti.Status); return; } ti.Status = TransitionStatus.Cancelled; OnTransitionStatusChanged(ti.InstanceId); return; } }