private void IterateWorkflow(WorkflowRun <TWfContext> run)
{
if (_finish.Exists(precondition => precondition.Met(run.FinishedTasks)))
{
WorkflowFinished?.Invoke(this, new WorkflowEventArgs <TWfContext>(run.RunId, run.Context));
return;
}
var tasksToExecute = _tasks.Where(kv => kv.Value.Met(run.FinishedTasks) && !run.HasFinished(kv.Key))
.Select(kv => kv.Key).ToList();
var anythingFinished = false;
foreach (var task in tasksToExecute)
{
task.Action(run.Context);
run.StartTask(task);
TaskStarted?.Invoke(this, new WorkflowTaskEventArgs <TWfContext>(run.RunId, task.TaskId, run.Context));
if (task.Autocomplete)
{
TaskFinished?.Invoke(this,
new WorkflowTaskEventArgs <TWfContext>(run.RunId, task.TaskId, run.Context));
run.FinishTask(task);
anythingFinished = true;
}
}
if (anythingFinished)
{
IterateWorkflow(run);
}
}
/// <summary>
/// 开始下载任务
/// </summary>
public void Start()
{
lock (_external_lock)
{
lock (_thread_flag_lock)
{
//clear error flag
_download_thread_flag = _download_thread_flag & ~_DOWNLOAD_THREAD_FLAG_ERROR;
if (((_download_thread_flag & 0xffffff) & (_DOWNLOAD_THREAD_FLAG_READY | _DOWNLOAD_THREAD_FLAG_PAUSED)) != 0)
{
//Tracer.GlobalTracer.TraceInfo("---STARTED---");
_download_thread_flag = (_download_thread_flag | _DOWNLOAD_THREAD_FLAG_START_REQUESTED) & ~_DOWNLOAD_THREAD_FLAG_READY;
_url_fail_to_fetch_count = 0;
//_api.GetAccount(_data.AccountID).GetLocateDownloadLinkAsync(_data.Path, _main_url_request_callback);
_url_expire_time = DateTime.Now;
_monitor_thread = new Thread(_monitor_thread_callback);
_monitor_thread.Name = "Download Monitor";
_monitor_thread.IsBackground = false;
_monitor_thread.Start();
}
}
}
try { TaskStarted?.Invoke(this, new EventArgs()); }
catch { }
}
private void SetCurrentTask(AIBackupUnitTask task)
{
currentTask = task;
currentTask.Finished += OnCurrentTaskFinished;
currentTask.Start();
TaskStarted?.Invoke(currentTask);
}
public void Update()
{
_searchItems.Clear();
var classNames = ClassNames.ToList();
var i = 0;
var n = classNames.Count;
var progress = new Progress <ProgressInfo>();
TaskStarted?.Invoke(progress);
var progressInterface = (IProgress <ProgressInfo>)progress;
_searchItems.AddRange(
classNames
.Select(
name => {
var subKey = _clsidKey.OpenSubKey(name);
var regClass = subKey != default ? CreateSearchItem(new RegistryClass(subKey)) : default;
progressInterface.Report(new ProgressInfo("Load Classes", ++i, n));
return(regClass);
}
)
);
OnPropertyChanged(nameof(Items));
}
public void Start()
{
lock (_external_lock)
{
lock (_thread_flag_lock)
{
//clearing attributed status
_upload_thread_flag = _upload_thread_flag & 0xffffff;
if ((_upload_thread_flag & (_UPLOAD_THREAD_FLAG_READY | _UPLOAD_THREAD_FLAG_PAUSED)) != 0)
{
if (_enable_slice_upload)
{
Tracer.GlobalTracer.TraceInfo("---STARTED---");
_upload_thread_flag = (_upload_thread_flag | _UPLOAD_THREAD_FLAG_START_REQUESTED) & ~_UPLOAD_THREAD_FLAG_READY;
//_monitor_thread = new Thread(_monitor_thread_callback);
//_monitor_thread.IsBackground = true;
//_monitor_thread.Name = "Upload monitor";
//_monitor_thread.Start();
ThreadPool.QueueUserWorkItem(new WaitCallback(_monitor_thread_callback), null);
}
else
{
throw new NotImplementedException();
}
}
else
{
return;
}
}
}
try { TaskStarted?.Invoke(this, new EventArgs()); } catch { }
}
public void OnTaskStarted(TaskDefinition task)
{
TaskStarted?.Invoke(new TaskStartedEvent
{
Task = task,
Timestamp = DateTimeUtils.Now
});
}
/// <summary>
/// Executes the task.
/// </summary>
/// <param name="task">The task.</param>
/// <exception cref="NotImplementedException"></exception>
public void ExecuteTask(IEngineTask task)
{
// Check if task can be executed
if (!task.CanBeExecuted())
{
task.AddMessage($"The task cannot be executed.", MessageSeverity.Error);
if (task.ParentJob.FailIfAnyTaskHasError)
{
throw new EngineException(logger, $"The task cannot be executed. This job was aborted.");
}
else
{
return;
}
}
// Execute task
if (TaskStarted != null)
{
TaskStarted.Invoke((Guid)task.EntityId, (Guid)task.InstanceID);
}
task.Start();
// Stop task
task.Stop();
if (task.HasErrors)
{
task.AddMessage($"The task (instance: {task.InstanceID}) was not executed cause one or more errors occurs.", MessageSeverity.Error);
if (task.ParentJob.FailIfAnyTaskHasError)
{
if (TaskFinished != null)
{
TaskFinished.Invoke((Guid)task.EntityId, (Guid)task.InstanceID, false);
}
throw new EngineException(logger, $"The task (instance: {task.InstanceID}) was not executed cause one or more errors occurs. This job was aborted.");
}
}
else if (task.HasWarnings)
{
task.AddMessage($"The task (instance: {task.InstanceID}) was executed but one or more warning occurs.", MessageSeverity.Warning);
if (task.ParentJob.FailIfAnyTaskHasWarning)
{
if (TaskFinished != null)
{
TaskFinished.Invoke((Guid)task.EntityId, (Guid)task.InstanceID, false);
}
throw new EngineException(logger, $"The task (instance: {task.InstanceID}) was executed but one or more warning occurs. This job was aborted.");
}
}
if (TaskFinished != null)
{
TaskFinished.Invoke((Guid)task.EntityId, (Guid)task.InstanceID, true);
}
}
/// <summary>
/// Raise one of the events that is appropriate for the type of the BuildEventArgs
/// </summary>
public void Dispatch(BuildEventArgs buildEvent)
{
if (buildEvent is BuildMessageEventArgs)
{
MessageRaised?.Invoke(null, (BuildMessageEventArgs)buildEvent);
}
else if (buildEvent is TaskStartedEventArgs)
{
TaskStarted?.Invoke(null, (TaskStartedEventArgs)buildEvent);
}
else if (buildEvent is TaskFinishedEventArgs)
{
TaskFinished?.Invoke(null, (TaskFinishedEventArgs)buildEvent);
}
else if (buildEvent is TargetStartedEventArgs)
{
TargetStarted?.Invoke(null, (TargetStartedEventArgs)buildEvent);
}
else if (buildEvent is TargetFinishedEventArgs)
{
TargetFinished?.Invoke(null, (TargetFinishedEventArgs)buildEvent);
}
else if (buildEvent is ProjectStartedEventArgs)
{
ProjectStarted?.Invoke(null, (ProjectStartedEventArgs)buildEvent);
}
else if (buildEvent is ProjectFinishedEventArgs)
{
ProjectFinished?.Invoke(null, (ProjectFinishedEventArgs)buildEvent);
}
else if (buildEvent is BuildStartedEventArgs)
{
BuildStarted?.Invoke(null, (BuildStartedEventArgs)buildEvent);
}
else if (buildEvent is BuildFinishedEventArgs)
{
BuildFinished?.Invoke(null, (BuildFinishedEventArgs)buildEvent);
}
else if (buildEvent is CustomBuildEventArgs)
{
CustomEventRaised?.Invoke(null, (CustomBuildEventArgs)buildEvent);
}
else if (buildEvent is BuildStatusEventArgs)
{
StatusEventRaised?.Invoke(null, (BuildStatusEventArgs)buildEvent);
}
else if (buildEvent is BuildWarningEventArgs)
{
WarningRaised?.Invoke(null, (BuildWarningEventArgs)buildEvent);
}
else if (buildEvent is BuildErrorEventArgs)
{
ErrorRaised?.Invoke(null, (BuildErrorEventArgs)buildEvent);
}
AnyEventRaised?.Invoke(null, buildEvent);
}
public void StartTask()
{
GameManager.currentProgressor = this;
Doozy.Engine.GameEventMessage.SendEvent(targetData.puzzleEventName);
evt_taskStarted.Invoke(this);
if (disablePlayerMovement)
{
GameManager.instance.EnablePlayerControl(false);
}
}
public void OnTaskStarted(EventArgs args)
{
groupBoxReadMode.Enabled = false;
groupBoxSettings.Enabled = false;
groupBoxTemp.Enabled = false;
buttonAbort.Enabled = true;
buttonPause.Enabled = true;
buttonSave.Enabled = false;
Paused.Set(); // set running/resumed
TaskStarted?.Invoke(this, args);
}
public void StartTask(BuildNode node)
{
_logger.LogDebug($"BuildProcess.StartTask: Node: \"{node.Name}\"");
var task = FindTask(node);
if (task != null)
{
_logger.LogDebug($"BuildProcess.StartTask: Task: {task.GetHashCode()}");
CurrentTasks.Add(task);
task.Start();
TaskStarted?.Invoke(task);
}
}
public async Task RunTaskAsync(string title, Action <CancellationToken, IProgress <int> > task, Action <int> progressUpdate, Action taskCompleted)
{
if (_task != null)
{
throw new Exception("A task is already running.");
}
cancellationTokenSource = new CancellationTokenSource();
cancellationToken = cancellationTokenSource.Token;
TaskStarted?.Invoke(this, null);
_progressDialog = new ProgressDialog(this, _owner, $"Task - {title}", Maximum, Interval);
_progressDialog.Show();
var progress = new Progress <int>(percent =>
{
progressUpdate(percent);
});
try
{
_task = Task.Run(() =>
{
task(cancellationToken, progress);
}, cancellationToken);
// wait for worker task to finish.
await _task;
}
catch (TaskCanceledException)
{
Console.WriteLine("Task cancelled.");
}
catch (Exception exception)
{
MessageBox.Show(exception.Message);
}
SystemSounds.Beep.Play();
taskCompleted();
_progressDialog.Close();
TaskCompleted?.Invoke(this, null);
_progressDialog = null;
_task = null;
}
/// <summary>
/// Starts new task in current session
/// </summary>
/// <param name="context">The task context to start</param>
private void StartNextTask(TimeTaskContext context)
{
// Set provided time
CurrentTimeLeft = context.SessionDynamicTime;
// Save it for progress calculations
mCurrentTask.SessionDynamicTime = CurrentTimeLeft;
// Start the timer
mSecondsTicker.Start();
// Inform subscribers
TaskStarted.Invoke();
}
public RepetitiveTask(Action action, int dueTime, int period)
{
State = RepeririveTaskState.Stopped;
DueTime = dueTime;
Period = period;
_action = action;
TaskStarted += (task) => State = RepeririveTaskState.TaskStarted;
TaskEnded += (task, status) => State = State != RepeririveTaskState.Stopped ? RepeririveTaskState.Waiting : State;
_timer = new Timer((sender) =>
{
TaskStarted?.Invoke(this);
Task.Factory.StartNew(action).ContinueWith((task) =>
{
TaskEnded?.Invoke(this, task.Status);
});
}, null, Timeout.Infinite, Timeout.Infinite);
}
private void StartTask(IScheduledTask scheduledTask)
{
Task task = null;
RunningTask runningTask = null;
lock (_lock)
{
if (!IsEnabled)
{
return;
}
Log.Debug($"Starting task {scheduledTask}");
runningTask = new RunningTask(scheduledTask, _timeService.CurrentDateTime);
#pragma warning disable 4014
// Note: don't await, we are a scheduler
task = TaskShim.Run(async() => await scheduledTask.InvokeAsync(), runningTask.CancellationTokenSource.Token);
task.ContinueWith(OnRunningTaskCompleted);
#pragma warning restore 4014
Log.Debug($"Started task {scheduledTask}");
}
if (!scheduledTask.ScheduleRecurringTaskAfterTaskExecutionHasCompleted)
{
// Schedule immediately, even though task is still running
RescheduleRecurringTask(runningTask);
}
var completed = task.IsCompleted;
if (completed)
{
// Shortcut mode
TaskStarted?.Invoke(this, new TaskEventArgs(runningTask));
OnRunningTaskCompleted(task);
}
else
{
_runningTasks.Add(new RunningTaskInfo(task, runningTask));
TaskStarted?.Invoke(this, new TaskEventArgs(runningTask));
}
}
public void Confirm()
{
Task.Factory.StartNew(() =>
{
try
{
TaskEx.Delay(5000, _cancellationTokenSource.Token).GetAwaiter().GetResult();
if (_cancellationTokenSource.IsCancellationRequested)
{
return;
}
}
catch (TaskCanceledException)
{
return;
}
TaskStarted?.Invoke(this, new DataEventArgs <CreatedNetworkTaskData>(_taskData));
});
}
/// <summary>
/// Checks the queue for new tasks and pops the next available task
/// </summary>
private void PopQueue()
{
if (!IsEnabled)
{
return;
}
lock (_taskQueue)
{
Task = null;
if (!_taskQueue.Any())
{
return;
}
Task = _taskQueue[0];
_taskQueue.RemoveAt(0);
}
// Start a thread to execute the task
_taskFactory.StartNew(() =>
{
// Reset values
IsAbortPending = false;
TaskStarted?.Invoke(this, new TaskEventArgs(Task));
ResetStatus();
Logger.Record($"Executing task {Task.Type} for {Task.ModID}");
// Execute task
bool result = ExecuteTask();
// Reset values
ResetStatus();
Logger.Record($"Task executed {(result ? "successfully" : "unsuccessfully")}");
TaskEnded?.Invoke(this, new TaskEndedEventArgs(Task, result));
// Pop queue again
PopQueue();
});
}
public void RunTask()
{
if (!readyToGo)
{
throw new ArgumentException("Not ready to go!");
}
else
{
if (TaskStarted != null)
{
TaskStarted.Invoke(this, new EventArgs());
}
}
Active = true;
Status = "Analyzing source";
var urlGen = SetupTask();
var urls = urlGen.Get(0, NumberToDownload);
using (repo = new Repository()) {
// pass on the events
repo.DownloadFileCompleted += OnSingleDownloadCompleted;
repo.DownloadProgressChanged += OnDownloadProgressChanged;
repo.MultipleDownloadsCompleted += OnMultipleDownloadsCompleted;
// set number downloaded to zero
NumberDownloaded = 0;
// begin (blocks)
repo.Download(urls);
// repo.Active is set and unset automatically
}
}
/// <summary>
/// 启动服务
/// </summary>
public async Task Start()
{
cts = new CancellationTokenSource();
await Task.Run(() =>
{
int times = 0;
TaskStarted?.Invoke(this, new TaskEventArgs(TaskName));
while (!cts.Token.IsCancellationRequested)
{
times++;
if (times *Interval >= TaskCheckInterval)
{
Log.Information($"{TaskName}正在运行");
times = 0;
}
Repository = new AppRepository();
lastTime = DateTime.Now;
try
{
Run();
}
catch (Exception ex)
{
Log.Error(ex, $"{TaskName}抛出异常");
}
try
{
Task.Delay(Interval).Wait(cts.Token);
}
catch (OperationCanceledException)
{
}
}
Log.Warning($"{TaskName}已取消");
TaskStopped?.Invoke(this, new TaskEventArgs(TaskName));
}, cts.Token);
}
private void OnTaskStarted()
{
TaskStarted?.Invoke(this, new ObservableTaskEventArgs(_task));
}
private void FireTaskStarted()
{
TaskStarted?.Invoke(this, EventArgs.Empty);
}
private View ConstructView()
{
var outerLayout = new LinearLayout(_context)
{
Orientation = Orientation.Vertical
};
outerLayout.SetPadding(20, 0, 20, 10);
var taskNameView = new TextView(_context);
taskNameView.SetTextSize(Android.Util.ComplexUnitType.Pt, 9);
if (TaskProgress != null)
{
if (TaskProgress.Status > Models.ProgressStatus.InProgress)
{
taskNameView.Text = "✔ ";
outerLayout.SetBackgroundColor(Color.LightGreen);
}
else
{
taskNameView.Text = "● ";
outerLayout.SetBackgroundColor(Color.LightYellow);
}
}
else
{
taskNameView.Text = "○ ";
}
taskNameView.Text += Task.Name;
var taskRegionLayout = new LinearLayout(_context)
{
Orientation = Orientation.Vertical,
Visibility = ViewStates.Gone
};
var taskDescTextView = new TextView(_context)
{
Text = Task.Description
};
taskDescTextView.SetTextSize(Android.Util.ComplexUnitType.Pt, 8);
taskRegionLayout.AddView(taskDescTextView);
if (ChallengeProgress?.Status == Models.ProgressStatus.InProgress)
{
if (TaskProgress == null)
{
var taskBtn = new Button(_context);
taskBtn.SetBackgroundColor(Color.Orange);
taskBtn.Text = "Začít plnit úkol!";
taskBtn.Click += (o, e) =>
{
TaskProgress = new TaskProgress
{
Id = Guid.NewGuid(),
TaskId = Task.Id,
LastModified = DateTime.UtcNow,
ChallengeProgressId = ChallengeProgress.Id,
Status = Models.ProgressStatus.InProgress
};
TaskStarted.Invoke(this, TaskProgress);
Invalidate();
};
taskRegionLayout.AddView(taskBtn);
}
else if (TaskProgress.Status == Models.ProgressStatus.InProgress)
{
var taskBtn = new Button(_context);
taskBtn.SetBackgroundColor(Color.LightGreen);
taskBtn.Text = "Zažádat o potvrzení úkolu!";
taskBtn.Click += (o, e) =>
{
TaskConfirmationRequested.Invoke(this, TaskProgress);
};
taskRegionLayout.AddView(taskBtn);
}
}
taskNameView.Click += (o, e) =>
{
if (taskRegionLayout.Visibility == ViewStates.Gone)
{
taskRegionLayout.Visibility = ViewStates.Visible;
}
else
{
taskRegionLayout.Visibility = ViewStates.Gone;
}
};
outerLayout.AddView(taskNameView);
outerLayout.AddView(taskRegionLayout);
return(outerLayout);
}
private void TaskRunner_TaskStarted(object sender, EventArgs e)
{
TaskStarted?.Invoke(sender, e);
}
// ReSharper disable once UnusedMember.Local
private void OnTaskStarted(TaskStartedEventArgs e)
{
TaskStarted?.Invoke(this, e);
}
private void RaiseTaskStarted(IBackgroundTask task, object state) => TaskStarted?.Invoke(task, state);
private void EventSourceOnTaskStarted(object sender, TaskStartedEventArgs e)
{
TaskStarted?.Invoke(sender, e);
}
private async Task TaskLoop(CancellationToken ct)
{
try
{
while (!ct.IsCancellationRequested)
{
State = NetworkServiceState.Finding;
var result = await _netService.WaitForOneConnection(ct);
var connection = result.Key;
var commingType = result.Value;
var writer = new BinaryWriter(connection.GetStream());
var reader = new BinaryReader(connection.GetStream());
if (commingType == ConnectionCommingType.FromListen)
{
var jsontask = reader.ReadString();
var task = JsonConvert.DeserializeObject <CreatedNetworkTaskData>(jsontask);
TaskCreated?.Invoke(this, new DataEventArgs <CreatedNetworkTaskData>(task));
}
else
{
//todo: generate task...
var task = new CreatedNetworkTaskData()
{
Frequency = 33100,
FrequencyNumber = new Random().Next(0, 10),
Id = Guid.NewGuid()
};
var jsontask = JsonConvert.SerializeObject(task);
writer.Write(jsontask);
writer.Flush();
TaskCreated?.Invoke(this, new DataEventArgs <CreatedNetworkTaskData>(task));
}
State = NetworkServiceState.RequestForConfirm;
var remoteConfirm = TaskEx.Run(() =>
{
var confirmationResult = reader.ReadString();
var isConfirmed = JsonConvert.DeserializeObject <ConfirmationResult>(confirmationResult);
return(isConfirmed);
});
var localConfirm = _completationConfirm.Task.ContinueWith(t =>
{
var cjs = JsonConvert.SerializeObject(t.Result);
writer.Write(cjs);
writer.Flush();
return(t.Result);
}, TaskContinuationOptions.NotOnFaulted | TaskContinuationOptions.NotOnCanceled);
var bothConfirmation = await TaskEx.WhenAll(remoteConfirm, localConfirm);
bool isBothConfimed = bothConfirmation.All(x => x.Result);
if (isBothConfimed)
{
TaskStarted?.Invoke(this, new DataEventArgs <CreatedNetworkTaskData>());
}
connection.Close();
}
}
catch (TaskCanceledException) { }
catch (Exception ex)
{
SimpleLogger.Log(ex);
}
}
//event callback
#region event callback
private void _on_task_started(object sender, EventArgs e)
{
try { TaskStarted?.Invoke(sender, e); }
catch { }
}
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);
}
protected virtual void OnTaskStarted()
{
TaskStarted?.Invoke(this, EventArgs.Empty);
}
