/// <summary>
/// Try to restart the task.
/// </summary>
/// <param name="taskStateModel">The <see cref="TaskStateModel"/> instance.</param>
/// <param name="timeShift">Time shift.</param>
/// <param name="repeatCrashCount">Count of attempts that will be used for reruning this task after its crashed.</param>
/// <param name="msg">Message that explains the restart.</param>
/// <param name="exception">Exception that explains the restart.</param>
public void RestartTask(TaskStateModel taskStateModel, TimeSpan timeShift, int repeatCrashCount, string msg, Exception exception)
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.AppendFormat("UPDATE {0}.{1} ", sqlSettings.WiseQueueDefaultSchema, taskTableName);
if (repeatCrashCount <= 0)
{
stringBuilder.AppendFormat("SET [ExecuteAt]=GETUTCDATE(), [RepeatCrashCount]=0, [State] = {0}", (short)TaskStates.Failed);
}
else
{
stringBuilder.AppendFormat("SET [ExecuteAt]=GETUTCDATE() +'{0}', [RepeatCrashCount]={1}, [ServerId] = NULL, [State] = {2}", timeShift, repeatCrashCount, (short)TaskStates.New);
}
stringBuilder.AppendFormat("WHERE [Id] = {0} AND [QueueId] = {1} AND [ServerId] = {2}", taskStateModel.Id, taskStateModel.QueueId, taskStateModel.ServerId);
string sqlCommand = stringBuilder.ToString();
using (IDbConnection connection = connectionFactory.CreateConnection())
{
//TODO: Transaction ???
using (IDbTransaction transaction = connection.BeginTransaction(IsolationLevel.Serializable))
{
using (IDbCommand command = connectionFactory.CreateCommand(connection))
{
command.CommandText = sqlCommand;
command.ExecuteNonQuery();
transaction.Commit();
}
}
}
}
public async Task <ActionResult <TaskStateModel> > PostTaskStateModel(TaskStateModel taskStateModel)
{
var allStates = await _context.TaskStateModels.ToListAsync();
for (int i = 0; i <= allStates.Count() - 2; i++)
{
if (allStates[i].OrderNr == taskStateModel.OrderNr)
{
allStates[i].OrderNr++;
}
if (allStates[i].OrderNr == allStates[i + 1].OrderNr)
{
allStates[i + 1].OrderNr++;
}
}
//foreach(TaskStateModel t in allStates)
//{
// if(t.OrderNr == taskStateModel.OrderNr)
// {
// t.OrderNr++;
// }
//}
_context.TaskStateModels.Add(taskStateModel);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetTaskStateModel", new { id = taskStateModel.TaskStateID }, taskStateModel));
}
private void RestartTask(TaskModel taskModel, string msg, Exception ex)
{
int repeatCrashCount = taskModel.ScheduleInformation.RepeatCrashCount - 1;
//if (repeatCrashCount <= 1)
//{
// logger.WriteTrace("All restart attempts have been expired. Task will be mark as failed.");
// //TODO: Set RepeatCrashCount to 0
// //TODO: Add message why task has been failed.
// TaskStateModel taskStateModel = new TaskStateModel(taskModel.Id, taskModel.QueueId, taskModel.ServerId, TaskStates.Failed);
// taskDataContext.SetTaskState(taskStateModel);
//}
//else
//{
TaskStateModel taskStateModel;
if (repeatCrashCount > 0)
{
logger.WriteTrace("Task will be restarted.");
taskStateModel = new TaskStateModel(taskModel.Id, taskModel.QueueId, taskModel.ServerId, TaskStates.New);
}
else
{
logger.WriteTrace("Task will be failed.");
taskStateModel = new TaskStateModel(taskModel.Id, taskModel.QueueId, taskModel.ServerId, TaskStates.Failed);
}
taskDataContext.RestartTask(taskStateModel, timeShiftAfterCrash, repeatCrashCount, msg, ex);
//}
}
public async Task <IActionResult> PutTaskStateModel(int id, TaskStateModel taskStateModel)
{
if (id != taskStateModel.TaskStateID)
{
return(BadRequest());
}
_context.Entry(taskStateModel).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TaskStateModelExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <bool> UpdateTaskState(TaskStateModel taskStateModel)
{
await loadAuthTask;
var content = JsonSerializer.Serialize(taskStateModel);
var response = await _httpClient.PutAsync($"api/TaskState", new StringContent(content, Encoding.UTF8, "application/json"));
return(response.IsSuccessStatusCode);
}
private TaskStateModel ParseTaskStates(MySqlDataReader reader)
{
var states = new TaskStateModel();
states.id = (int)reader["id"];
states.state = (string)reader["state"];
return(states);
}
public async Task <IActionResult> Update([FromBody] TaskStateModel taskStateModel)
{
var rowsAffected = await _taskRepository.UpdateTaskState(taskStateModel);
if (rowsAffected == 0)
{
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> Update([FromBody] TaskStateModel solve, int id)
{
var data = taskService.GetTaskAsync(id);
if (data == null)
{
return(NotFound());
}
taskService.UpdateTaskAsync(solve.State, id);
var todoList = await taskService.GetAllTaskAsync();
return(Ok(todoList));
}
private void OnCompletedEventHandler(object sender, RunningTaskEventArg eventArg)
{
IRunningTask currentTask = (IRunningTask)sender;
currentTask.OnCompletedEventHandler -= OnCompletedEventHandler;
TaskStates taskState;
Int64 taskId = currentTask.TaskModel.Id;
switch (eventArg)
{
case RunningTaskEventArg.Completed:
logger.WriteTrace("The task has been completed: {0}", taskId);
taskState = TaskStates.Successed;
break;
case RunningTaskEventArg.Cancelled:
logger.WriteTrace("The task has been canceled: {0}", taskId);
taskState = TaskStates.Cancelled;
break;
case RunningTaskEventArg.Failed:
logger.WriteTrace("The task has been failed: {0}", taskId);
taskState = TaskStates.Failed;
break;
default:
throw new NotImplementedException();
}
if (taskState == TaskStates.Successed || taskState == TaskStates.Cancelled)
{
lock (activeTasks)
{
if (activeTasks.ContainsKey(taskId) == false)
{
return;
}
activeTasks.Remove(taskId);
}
TaskStateModel taskStateModel = new TaskStateModel(taskId, currentTask.TaskModel.QueueId, currentTask.TaskModel.ServerId, taskState);
taskDataContext.SetTaskState(taskStateModel);
}
else
{
//TODO: correct message and details.
RestartTask(currentTask.TaskModel, "Exception inside", new Exception("TODO"));
}
}
public async Task <int> UpdateTaskState(TaskStateModel model)
{
int rows;
using (var cnn = DbConnection)
{
var procedure = "[RemoveTaskState]";
var values = new
{
model.ID,
model.NewTaskState,
model.DateTime,
model.Editor
};
rows = await cnn.ExecuteAsync(procedure, values, commandType : CommandType.StoredProcedure);
}
return(rows);
}
public List <TaskStateModel> GetStates()
{
List <TaskState> deserialized = new List <TaskState>();
string baseUrl = ConfigurationManager.ConnectionStrings["ManagementServerName"].ConnectionString;
string url = baseUrl + DestinationNames.GetStates;
deserialized = Utils.Functionals.Communicator.GetEntities <TaskState>(url);
List <TaskStateModel> states = new List <TaskStateModel>();
foreach (var item in deserialized)
{
TaskStateModel state = new TaskStateModel();
state.Id = item.Id;
state.Name = item.Name;
states.Add(state);
}
return(states);
}
/// <summary>
/// Set task's state.
/// </summary>
/// <param name="taskStateModel">The <see cref="WiseQueue.Core.Common.Models.Tasks.TaskStateModel"/> instance.</param>
public void SetTaskState(TaskStateModel taskStateModel)
{
const string updateStatement = "UPDATE {0}.{1} SET [State]={2}, [CompletedAt]=GETUTCDATE() WHERE [Id] = {3} AND [QueueId] = {4} AND [ServerId] = {5}";
string sqlCommand = string.Format(updateStatement, sqlSettings.WiseQueueDefaultSchema, taskTableName, (short)taskStateModel.TaskState, taskStateModel.Id, taskStateModel.QueueId, taskStateModel.ServerId);
using (IDbConnection connection = connectionFactory.CreateConnection())
{
//TODO: Transaction ???
using (IDbTransaction transaction = connection.BeginTransaction(IsolationLevel.Serializable))
{
using (IDbCommand command = connectionFactory.CreateCommand(connection))
{
command.CommandText = sqlCommand;
command.ExecuteNonQuery();
transaction.Commit();
}
}
}
}
