public override async Task ExecuteAsync(Guid activityId)
{
if (surpriseJob)
{
// TODO, add surprise in executordata
this.Environment.DefaultTraceType.WriteWarning("MoveToPreparing: job bypassed normal automated workflow: [{0}]", tenantJob);
}
repairTask.State = RepairTaskState.Preparing;
repairTask.ExecutorData = args.ExecutorData.ToJson();
repairTask.Impact = args.Impact;
bool?prepareHc = args.PerformPreparingHealthCheck;
bool?restoreHc = args.PerformRestoringHealthCheck;
if (prepareHc == repairTask.PerformPreparingHealthCheck)
{
prepareHc = null;
}
if (restoreHc == repairTask.PerformRestoringHealthCheck)
{
restoreHc = null;
}
// since IS has claimed the task, it is free to update the health policy as it seems fit
if (prepareHc != null || restoreHc != null)
{
// TODO: See if this can be removed by allowing health policy updates via UpdateRepairExecutionStateAsync
// (currently those ignored for backward compatibility reasons)
repairTask.Version = await repairManager.UpdateRepairTaskHealthPolicyAsync(activityId, repairTask, prepareHc, restoreHc).ConfigureAwait(false);
}
await repairManager.UpdateRepairExecutionStateAsync(activityId, repairTask).ConfigureAwait(false);
}
public Task ExecuteAsync(IRepairManager repairManager)
{
this.repairTask.State = RepairTaskState.Restoring;
this.repairTask.ResultStatus = RepairTaskResult.Succeeded;
return(repairManager.UpdateRepairExecutionStateAsync(Guid.Empty, this.repairTask));
}
public override async Task ExecuteAsync(Guid activityId)
{
repairTask.State = RepairTaskState.Restoring;
repairTask.ResultStatus = repairTaskResult;
repairTask.ResultDetails = repairTaskResultDetails;
if (surpriseJob)
{
// TODO, add surprise in executordata
this.Environment.DefaultTraceType.WriteWarning("MoveToRestoring: job bypassed normal automated workflow for repair task '{0}'", repairTask.TaskId);
}
if (processRemovedNodes && this.Environment.Config.ReadConfigValue(Constants.ConfigKeys.ProcessRemovedNodes, true))
{
await ProcessRemovedNodesAsync(activityId);
}
if (cancelRestoringHealthCheck)
{
// TODO: this is not processed, consider calling UpdateRepairTaskHealthPolicyAsync instead
repairTask.PerformRestoringHealthCheck = false;
}
await repairManager.UpdateRepairExecutionStateAsync(activityId, repairTask);
}
public async Task ExecuteAsync(IRepairManager repairManager)
{
this.repairTask.State = RepairTaskState.Executing;
await repairManager.UpdateRepairExecutionStateAsync(Guid.Empty, this.repairTask);
this.record.IsApproved = true;
}
public override async Task ExecuteAsync(Guid activityId)
{
// TODO: Validate that state is already Executing; this action can have ActionType.None because
// of this assumption that this action isn't the one that moves from Approved to Executing.
repairTask.State = RepairTaskState.Executing;
await repairManager.UpdateRepairExecutionStateAsync(activityId, repairTask).ConfigureAwait(false);
approveJobAction(tenantJob.Id);
}
public override Task ExecuteAsync(Guid activityId)
{
repairTask.State = RepairTaskState.Executing;
if (warning != null)
{
this.Environment.DefaultTraceType.WriteWarning("{0}", warning);
}
return(repairManager.UpdateRepairExecutionStateAsync(activityId, repairTask));
}
public override async Task ExecuteAsync(Guid activityId)
{
if (repairTask.State != RepairTaskState.Created)
{
this.Environment.DefaultTraceType.WriteInfo("Repair task {0}: not claiming it since its state isn't {1}", repairTask.TaskId, RepairTaskState.Created);
return;
}
// Is this an action that this executor can process?
RepairActionTypeEnum?action = repairActionProvider.GetRepairAction(repairTask.Action);
if (action == null)
{
this.Environment.DefaultTraceType.WriteInfo("Repair task {0}: ignoring unknown action {1}", repairTask.TaskId, repairTask.Action);
return;
}
if (repairTask.Scope.Kind != RepairScopeIdentifierKind.Cluster)
{
this.Environment.DefaultTraceType.WriteInfo("Repair task {0}: ignoring unknown scope {1}", repairTask.TaskId, repairTask.Scope);
return;
}
// Ignore requests for anything other than a single node
IList <string> targetNodeNames = repairTask.GetTargetNodeNames();
if (targetNodeNames == null || targetNodeNames.Count != 1)
{
this.Environment.DefaultTraceType.WriteInfo("Repair task {0}: ignoring bad target description {1}", repairTask.TaskId, repairTask.Target);
return;
}
// Map Service Fabric node name to Azure role instance Id
string targetRoleInstance = targetNodeNames[0].TranslateNodeNameToRoleInstance();
// Is the target a valid role instance in this tenant?
if (!roleInstanceNames.Contains(targetRoleInstance, StringComparer.OrdinalIgnoreCase))
{
this.Environment.DefaultTraceType.WriteInfo("Repair task {0}: ignoring unknown role instance {1}", repairTask.TaskId, targetRoleInstance);
return;
}
// All checks passed; this executor can claim and execute this repair task
repairTask.Executor = this.Environment.ServiceName;
// Zero impact, because approval for actual execution will go through the
// existing infrastructure task mechanism (MR job queue)
repairTask.State = RepairTaskState.Claimed;
await repairManager.UpdateRepairExecutionStateAsync(activityId, repairTask).ConfigureAwait(false);
}
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());
}