private void UpdateRepairToRestoring(RepairTask task, RepairTaskResult result, string details)
{
string message = string.Format(
CultureInfo.InvariantCulture,
"Updating task {0} from {1} to {2}; result = {3}, details = {4}",
task.TaskId,
task.State,
RepairTaskState.Restoring,
result,
details);
if (result == RepairTaskResult.Succeeded || result == RepairTaskResult.Cancelled)
{
Trace.WriteInfo(TraceType, message);
}
else
{
Trace.WriteWarning(TraceType, message);
}
task.State = RepairTaskState.Restoring;
task.ResultStatus = result;
task.ResultDetails = details;
long commitVersion = this.repairManager.UpdateRepairExecutionStateAsync(task).Result;
Trace.WriteInfo(TraceType, "Committed version {0}", commitVersion);
}
public IAction NewMoveToCompletedAction(
IRepairTask repairTask,
RepairTaskResult repairTaskResult,
string resultDetails,
bool surpriseJob)
{
return(new MoveToCompletedAction(environment, repairManager, repairTask, repairTaskResult, resultDetails, surpriseJob));
}
private static WinFabricRepairTaskResult Convert(RepairTaskResult repairTaskResult)
{
if (!Enum.IsDefined(typeof(RepairTaskResult), repairTaskResult))
{
throw new ArgumentOutOfRangeException("Invalid RepairTaskResult value " + repairTaskResult, "repairTaskResult");
}
return((WinFabricRepairTaskResult)repairTaskResult);
}
public IAction NewMoveToRestoringAction(
IRepairTask repairTask,
RepairTaskResult repairTaskResult,
string resultDetails,
bool surpriseJob = false,
bool cancelRestoringHealthCheck = false,
bool processRemovedNodes = false)
{
return(new MoveToRestoringAction(environment, repairManager, repairTask, repairTaskResult, resultDetails, surpriseJob, cancelRestoringHealthCheck, processRemovedNodes));
}
/// <summary>
/// Updates the repair task for current node
/// </summary>
/// <param name="fc">Fabric client object used for carrying out service fabric client requests</param>
/// <param name="nodeName">Nodename against which repair task needs to be updated</param>
/// <param name="taskState">State of the repair task <see cref="RepairTaskState"/></param>
/// <param name="taskResultStatus">Result status for last completed operation by RE</param>
/// <param name="resultDetails">Result details for last completed operation by RE</param>
/// <param name="executorState">Substate of repair executor</param>
/// <param name="timeout">Timeout for the async operation</param>
/// <param name="cancellationToken">The cancellation token to cancel the async operation</param>
/// <returns>A Task representing the asnyc operation</returns>
internal static async Task <NodeAgentSfUtilityExitCodes> UpdateRepairTask(FabricClient fc, string nodeName,
RepairTaskState taskState,
RepairTaskResult taskResultStatus, string resultDetails, NodeAgentSfUtilityExitCodes executorState,
TimeSpan timeout,
CancellationToken cancellationToken)
{
return(await
UpdateRepairTask(fc, nodeName, taskState, taskResultStatus, resultDetails, executorState,
timeout,
cancellationToken, null));
}
public MoveToCompletedAction(
CoordinatorEnvironment environment,
IRepairManager repairManager,
IRepairTask repairTask,
RepairTaskResult repairTaskResult,
string repairTaskResultDetails,
bool surpriseJob)
: base(environment, ActionType.None)
{
this.repairManager = repairManager.Validate("repairManager");
this.repairTask = repairTask.Validate("repairTask");
this.repairTaskResult = repairTaskResult;
this.repairTaskResultDetails = repairTaskResultDetails;
this.surpriseJob = surpriseJob;
}
private void Update(RepairTask task, RepairTaskState state, RepairTaskResult result)
{
LogHelper.Log("[{0}]Repair task from state {1} to state {2} with result {3}.", Name, task.State.ToString(), state.ToString(), result.ToString());
task.State = state;
task.Executor = Name;
if (state == RepairTaskState.Preparing)
{
task.Impact = new NodeRepairImpactDescription(); //zero impact
}
if (state == RepairTaskState.Restoring || state == RepairTaskState.Completed)
{
task.ResultStatus = result;
}
task.ResultDetails = "Hooray!";
long committedVersion = _repairManager.UpdateRepairExecutionStateAsync(task).Result;
LogHelper.Log("...Done. Commit version: {0}.", committedVersion);
}
public MoveToRestoringAction(
CoordinatorEnvironment environment,
IRepairManager repairManager,
IRepairTask repairTask,
RepairTaskResult repairTaskResult,
string repairTaskResultDetails,
bool surpriseJob,
bool cancelRestoringHealthCheck,
bool processRemovedNodes)
: base(environment, ActionType.Restore)
{
this.repairManager = repairManager.Validate("repairManager");
this.repairTask = repairTask.Validate("repairTask");
this.repairTaskResult = repairTaskResult;
this.repairTaskResultDetails = repairTaskResultDetails;
this.surpriseJob = surpriseJob;
this.cancelRestoringHealthCheck = cancelRestoringHealthCheck;
this.processRemovedNodes = processRemovedNodes;
}
/// <summary>
/// Updates the repair task for current node
/// </summary>
/// <param name="fc">Fabric client object used for carrying out service fabric client requests</param>
/// <param name="task">Repair task which needs to be updated</param>
/// <param name="taskState">State of the repair task <see cref="RepairTaskState"/></param>
/// <param name="taskResultStatus">Result status for last completed operation by RE</param>
/// <param name="resultDetails">Result details for last completed operation by RE</param>
/// <param name="executorState">Substate of repair executor</param>
/// <param name="timeout">Timeout for the async operation</param>
/// <param name="cancellationToken">The cancellation token to cancel the async operation</param>
/// <returns>A Task representing the asnyc operation</returns>
private static async Task UpdateRepairTask(FabricClient fc, RepairTask task, RepairTaskState taskState,
RepairTaskResult taskResultStatus, string resultDetails, NodeAgentSfUtilityExitCodes executorState, TimeSpan timeout,
CancellationToken cancellationToken, DateTime?restartRequesteDateTime)
{
// Do the actual work before mark the task as Executing.
task.State = taskState;
task.ResultStatus = taskResultStatus;
task.ResultDetails = resultDetails;
ExecutorDataForRmTask executorData =
SerializationUtility.Deserialize <ExecutorDataForRmTask>(task.ExecutorData);
executorData.ExecutorSubState = executorState;
if (restartRequesteDateTime.HasValue)
{
executorData.RestartRequestedTime = restartRequesteDateTime.Value;
}
task.ExecutorData = SerializationUtility.Serialize(executorData);
await fc.RepairManager.UpdateRepairExecutionStateAsync(task, timeout, cancellationToken);
}
/// <summary>
/// Updates the repair task for current node
/// </summary>
/// <param name="fc">Fabric client object used for carrying out service fabric client requests</param>
/// <param name="nodeName">Nodename against which repair task needs to be updated</param>
/// <param name="taskState">State of the repair task <see cref="RepairTaskState"/></param>
/// <param name="taskResultStatus">Result status for last completed operation by RE</param>
/// <param name="resultDetails">Result details for last completed operation by RE</param>
/// <param name="executorState">Substate of repair executor</param>
/// <param name="timeout">Timeout for the async operation</param>
/// <param name="cancellationToken">The cancellation token to cancel the async operation</param>
/// <param name="restartRequesteDateTime">Timestamp at which restart was requested</param>
/// <returns>A Task representing the asnyc operation</returns>
internal static async Task <NodeAgentSfUtilityExitCodes> UpdateRepairTask(FabricClient fc, string nodeName,
RepairTaskState taskState,
RepairTaskResult taskResultStatus, string resultDetails, NodeAgentSfUtilityExitCodes executorState,
TimeSpan timeout,
CancellationToken cancellationToken, DateTime?restartRequesteDateTime)
{
try
{
var repairTask = await GetRepairTaskForNode(fc, nodeName, timeout, cancellationToken);
if (null != repairTask)
{
await
UpdateRepairTask(fc, repairTask, taskState, taskResultStatus, resultDetails, executorState,
timeout,
cancellationToken, restartRequesteDateTime);
return(NodeAgentSfUtilityExitCodes.Success);
}
else
{
// If repair task does not exist we're in a unknown state.
ServiceEventSource.Current.ErrorMessage(
String.Format("RepairManagerHelper.UpdateRepairTask failed. No repair task found for this node"));
return(NodeAgentSfUtilityExitCodes.RepairTaskInvalidState);
}
}
catch (Exception e)
{
ServiceEventSource.Current.ErrorMessage(
String.Format("RepairManagerHelper.UpdateRepairTask failed. Exception details {0}", e));
if (e is FabricTransientException)
{
return(NodeAgentSfUtilityExitCodes.RetryableException);
}
else
{
return(NodeAgentSfUtilityExitCodes.Failure);
}
}
}
