/// <summary>
/// Updates repair task based on its current state.
/// </summary>
/// <param name="task"><see cref="RepairTask"/> to be updated</param>
/// <param name="nodeName">Node name of the repair task.</param>
/// <param name="finalState">Required Final state of the repair task.</param>
/// <param name="executorTimeoutInMinutes">executorTimeoutInMinutes</param>
/// <param name="cancellationToken">CancellationToken</param>
/// <returns></returns>
private async Task UpdateRepairTaskState(RepairTask task, string nodeName, RepairTaskState finalState, int executorTimeoutInMinutes, CancellationToken cancellationToken, bool nodeExists = true)
{
task.State = finalState;
task.ResultStatus = RepairTaskResult.Cancelled;
if (nodeExists)
{
ServiceEventSource.Current.ErrorMessage(
"Installation timeout {0} minutes alloted to task {1}, node {2} is over. Moving the repair task to {3} state to unblock installation on other nodes",
executorTimeoutInMinutes,
task.TaskId,
nodeName,
finalState.ToString());
}
else
{
ServiceEventSource.Current.ErrorMessage(
"Installation timeout {0} minutes alloted to task {1} and node {2} does not exist in the cluster. So, Moving the repair task to {3} state ",
executorTimeoutInMinutes,
task.TaskId,
nodeName,
finalState.ToString());
}
await this.fabricClient.RepairManager.UpdateRepairExecutionStateAsync(task, this.DefaultTimeoutForOperation, cancellationToken);
}
private static WinFabricRepairTaskState Convert(RepairTaskState repairTaskState)
{
if (!Enum.IsDefined(typeof(RepairTaskState), repairTaskState))
{
throw new ArgumentOutOfRangeException("Invalid RepairTaskState value " + repairTaskState, "repairTaskState");
}
return((WinFabricRepairTaskState)repairTaskState);
}
/// <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));
}
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);
}
/// <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);
}
}
}
