public async Task <long> CancelRepairTaskAsync(Guid activityId, IRepairTask repairTask)
{
repairTask.Validate("repairTask");
//var startTime = DateTimeOffset.UtcNow;
//var oldState = repairTask.State;
//var duration = repairTask.GetTimeInCurrentState(startTime);
try
{
var commitVersion = await repairManager.CancelRepairTaskAsync(repairTask.TaskId, repairTask.Version, false).ConfigureAwait(false);
traceType.WriteInfo(
"Canceled repair task: {0}",
repairTask.ToJson());
//activityLogger.LogChangeState(activityId, repairTask, oldState, RepairTaskState.Invalid, duration, repairTask.ToString(), repairTask.TaskId);
//activityLogger.LogOperation(activityId, startTime, OperationResult.Success, null, repairTask.ToJson());
return(commitVersion);
}
catch (Exception ex)
{
traceType.WriteWarning(
"Unable to cancel repair task. Continuing. Repair task: {0}{1}Errors: {2}",
repairTask.ToJson(), Environment.NewLine, ex);
//activityLogger.LogOperation(activityId, startTime, OperationResult.Failure, ex, repairTask.ToJson());
throw;
}
}
public async Task <long> UpdateRepairTaskHealthPolicyAsync(
Guid activityId,
IRepairTask repairTask,
bool?performPreparingHealthCheck,
bool?performRestoringHealthCheck)
{
repairTask.Validate("repairTask");
//var startTime = DateTimeOffset.UtcNow;
//var preparingOldState = repairTask.PerformPreparingHealthCheck;
//var restoringOldState = repairTask.PerformRestoringHealthCheck;
//var duration = repairTask.GetTimeInCurrentState(startTime);
try
{
var commitVersion = await repairManager.UpdateRepairTaskHealthPolicyAsync(
repairTask.TaskId,
repairTask.Version,
performPreparingHealthCheck,
performRestoringHealthCheck).ConfigureAwait(false);
traceType.WriteInfo(
"Updated repair task health policy: {0}",
repairTask.ToJson());
//if (performPreparingHealthCheck.HasValue && preparingOldState != performPreparingHealthCheck.Value)
//{
// activityLogger.LogChangeState(activityId, repairTask, preparingOldState, performPreparingHealthCheck.Value, duration, repairTask.ToString(), repairTask.TaskId);
//}
//if (performRestoringHealthCheck.HasValue && restoringOldState != performRestoringHealthCheck.Value)
//{
// activityLogger.LogChangeState(activityId, repairTask, restoringOldState, performRestoringHealthCheck.Value, duration, repairTask.ToString(), repairTask.TaskId);
//}
//activityLogger.LogOperation(activityId, startTime, OperationResult.Success, null, repairTask.ToJson());
return(commitVersion);
}
catch (Exception ex)
{
traceType.WriteWarning(
"Unable to update repair task health policy. Continuing. Repair task: {0}{1}Errors: {2}",
repairTask.ToJson(), Environment.NewLine, ex);
//activityLogger.LogOperation(activityId, startTime, OperationResult.Failure, ex, repairTask.ToJson());
throw;
}
}
public static RepairTaskExecutorData GetExecutorData(this IRepairTask repairTask)
{
repairTask.Validate("repairTask");
if (string.IsNullOrWhiteSpace(repairTask.ExecutorData))
{
return(null);
}
try
{
var executorData = repairTask.ExecutorData.FromJson <RepairTaskExecutorData>();
return(executorData);
}
catch (Exception ex)
{
Constants.TraceType.WriteWarning(
"Error while getting executor data for repair task. Returning null. Repair task: {0}{1}Exception: {2}",
repairTask.ToJson(),
Environment.NewLine,
ex);
return(null);
}
}
public async Task <long> UpdateRepairExecutionStateAsync(Guid activityId, IRepairTask repairTask)
{
repairTask.Validate("repairTask");
//var startTime = DateTimeOffset.UtcNow;
try
{
var commitVersion = await repairManager.UpdateRepairExecutionStateAsync(Unwrap(repairTask)).ConfigureAwait(false);
traceType.WriteInfo(
"Successfully updated repair execution state. Commit version: {0}, repair task: {1}",
commitVersion,
repairTask.ToJson());
//activityLogger.LogOperation(activityId, startTime, OperationResult.Success, null, repairTask.ToJson());
return(commitVersion);
}
catch (Exception ex)
{
traceType.WriteWarning("Unable to update repair execution state: Error: {0}", ex);
//activityLogger.LogOperation(activityId, startTime, OperationResult.Failure, ex, repairTask.ToJson());
throw;
}
}
public async Task <long> CreateRepairTaskAsync(Guid activityId, IRepairTask repairTask)
{
repairTask.Validate("repairTask");
//var startTime = DateTimeOffset.UtcNow;
try
{
// TODO, using the overload without timeout and cancellation token for now since there is some max timeout limit
// being exercised somewhere. if timeout provided is more than that, repair task creation fails
long result = await repairManager.CreateRepairTaskAsync(Unwrap(repairTask)).ConfigureAwait(false);
traceType.WriteInfo(
"Created repair task. Result: {0}, repair task: {1}",
result,
repairTask.ToJson());
//activityLogger.LogChangeState(activityId, repairTask, RepairTaskState.Invalid, repairTask.State, TimeSpan.Zero, repairTask.ToJson(), repairTask.TaskId);
//activityLogger.LogOperation(activityId, startTime, OperationResult.Success, null, repairTask.ToJson());
return(result);
}
catch (Exception ex)
{
traceType.WriteWarning("Unable to create repair task. Errors: {0}", ex.GetMessage());
//activityLogger.LogOperation(activityId, startTime, OperationResult.Failure, ex, repairTask.ToJson());
throw;
}
}
private async Task <bool> CompleteRepairTaskAsync(Guid activityId, IRepairTask task)
{
traceType.WriteInfo(
"Cancelling repair task {0} in state {1}:{2}{3}",
task.TaskId,
task.State,
Environment.NewLine,
task.ToJson());
bool succeeded = true;
try
{
switch (task.State)
{
case RepairTaskState.Claimed:
case RepairTaskState.Preparing:
await repairManager.CancelRepairTaskAsync(activityId, task);
break;
case RepairTaskState.Approved:
case RepairTaskState.Executing:
task.State = RepairTaskState.Restoring;
task.ResultStatus = RepairTaskResult.Interrupted;
task.ResultDetails = "Repair task was cancelled because Azure coordination is disabled";
await repairManager.UpdateRepairExecutionStateAsync(activityId, task);
break;
case RepairTaskState.Restoring:
await repairManager.UpdateRepairTaskHealthPolicyAsync(activityId, task, null, performRestoringHealthCheck : false);
break;
}
}
catch (Exception e)
{
traceType.WriteWarning(
"Failed to cancel repair task {0} in state {1}: {2}",
task.TaskId,
task.State,
e);
succeeded = false;
}
return(succeeded);
}
public override async Task ExecuteAsync(Guid activityId)
{
repairTask.State = RepairTaskState.Completed;
repairTask.ResultStatus = repairTaskResult;
repairTask.ResultDetails = repairTaskResultDetails;
if (surpriseJob)
{
// TODO, add surprise in executordata
this.Environment.DefaultTraceType.WriteWarning("MoveToCompleted: job bypassed normal automated workflow for repair task '{0}'", repairTask.TaskId);
}
await repairManager.UpdateRepairExecutionStateAsync(activityId, repairTask).ConfigureAwait(false);
// assuming above call succeeds. Else exceptions are handled by caller and the tracing code below doesn't execute
Environment.DefaultTraceType.WriteAggregatedEvent(
"CompletedRepairTask",
repairTask.TaskId,
"{0}",
repairTask.ToJson());
}
public static string GetJobId(this IRepairTask repairTask)
{
repairTask.Validate("repairTask");
var executorData = repairTask.GetExecutorData();
if (executorData == null)
{
return(null);
}
Guid jobId;
// just a validation step here to return only guids
bool success = Guid.TryParse(executorData.JobId, out jobId);
if (!success)
{
Constants.TraceType.WriteWarning("Job Id could not be parsed from repair task: {0}", repairTask.ToJson());
return(null);
}
return(executorData.JobId);
}