public async Task <IList <IRepairTask> > GetRepairTaskListAsync(
Guid activityId,
string taskIdFilter = null,
RepairTaskStateFilter stateFilter = RepairTaskStateFilter.Default,
string executorFilter = null)
{
//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
RepairTaskList repairTaskList = await repairManager.GetRepairTaskListAsync(taskIdFilter, stateFilter, executorFilter).ConfigureAwait(false);
var repairTasks = new List <IRepairTask>(repairTaskList.Count);
foreach (var repairTask in repairTaskList)
{
repairTasks.Add(new ServiceFabricRepairTask(repairTask));
}
//activityLogger.LogOperation(activityId, startTime);
return(repairTasks);
}
catch (Exception ex)
{
traceType.WriteWarning("Unable to get repair task list. Errors: {0}", ex.GetMessage());
//activityLogger.LogOperation(activityId, startTime, OperationResult.Failure, ex);
throw;
}
}
/// <summary>
/// <para>Gets a list of repair tasks matching all of the given filters.</para>
/// </summary>
/// <param name="taskIdFilter">
/// <para>The repair task ID prefix to be matched. If null, no filter is applied to the task ID.</para>
/// </param>
/// <param name="stateFilter">
/// <para>A bitwise combination of state filter values that specify which task states should be included in the list.</para>
/// </param>
/// <param name="executorFilter">
/// <para>The name of the repair executor whose claimed tasks should be included in the list. If null, no filter is applied to the executor name.</para>
/// </param>
/// <returns>
/// <para>The list of repair tasks matching all of the given filters.</para>
/// </returns>
public Task <RepairTaskList> GetRepairTaskListAsync(
string taskIdFilter,
RepairTaskStateFilter stateFilter,
string executorFilter)
{
return(this.GetRepairTaskListAsync(taskIdFilter, stateFilter, executorFilter, FabricClient.DefaultTimeout, CancellationToken.None));
}
private async Task <IEnumerable <RepairTask> > GetRepairList(RepairTaskStateFilter stateFilter, TimeSpan timeout, CancellationToken token)
{
var repairTaskList = await this.repairManagementClient.GetRepairTaskListAsync(
string.Empty,
stateFilter,
string.Empty,
timeout,
token);
return(repairTaskList.Where(task => task.Executor.StartsWith(ExecutorPrefix) && !string.IsNullOrWhiteSpace(task.ExecutorData)));
}
internal RepairTaskQueryDescription(
RepairScopeIdentifier scope,
string taskIdFilter,
RepairTaskStateFilter stateFilter,
string executorFilter)
{
this.Scope = scope;
this.TaskIdFilter = taskIdFilter;
this.StateFilter = stateFilter;
this.ExecutorFilter = executorFilter;
}
public Task <IList <IRepairTask> > GetRepairTaskListAsync(
Guid activityId,
string taskIdFilter = null,
RepairTaskStateFilter stateFilter = RepairTaskStateFilter.Default,
string executorFilter = null)
{
IList <IRepairTask> matchingRepairTasks = new List <IRepairTask>();
foreach (var rt in repairTasks.Values)
{
if (taskIdFilter != null && !rt.TaskId.StartsWith(taskIdFilter, StringComparison.OrdinalIgnoreCase))
{
continue;
}
if (executorFilter != null)
{
if (rt.Executor == null)
{
continue;
}
if (!rt.Executor.StartsWith(executorFilter, StringComparison.OrdinalIgnoreCase))
{
continue;
}
}
if (stateFilter != RepairTaskStateFilter.Default)
{
var stateMask = (RepairTaskStateFilter)rt.State;
if (stateMask != stateFilter)
{
continue;
}
}
matchingRepairTasks.Add(rt);
}
return(Task.FromResult(matchingRepairTasks));
}
/// <summary>
/// <para>Gets a list of repair tasks matching all of the given filters.</para>
/// </summary>
/// <param name="taskIdFilter">
/// <para>The repair task ID prefix to be matched. If null, no filter is applied to the task ID.</para>
/// </param>
/// <param name="stateFilter">
/// <para>A bitwise combination of state filter values that specify which task states should be included in the list.</para>
/// </param>
/// <param name="executorFilter">
/// <para>The name of the repair executor whose claimed tasks should be included in the list. If null, no filter is applied to the executor name.</para>
/// </param>
/// <param name="timeout">
/// <para>The maximum amount of time Service Fabric will allow this operation to continue before returning a <see cref="System.TimeoutException" />.</para>
/// </param>
/// <param name="cancellationToken">
/// <para>The optional cancellation token that the operation is observing. It can be used to send a notification that the operation should be canceled. Note that cancellation is advisory and that the operation may still be completed even if it is cancelled.</para>
/// </param>
/// <returns>
/// <para>The list of repair tasks matching all of the given filters.</para>
/// </returns>
public Task <RepairTaskList> GetRepairTaskListAsync(
string taskIdFilter,
RepairTaskStateFilter stateFilter,
string executorFilter,
TimeSpan timeout,
CancellationToken cancellationToken)
{
this.fabricClient.ThrowIfDisposed();
var queryDescription = new RepairTaskQueryDescription(
DefaultScope,
taskIdFilter,
stateFilter,
executorFilter);
return(Utility.WrapNativeAsyncInvokeInMTA <RepairTaskList>(
callback => this.GetRepairTaskListAsyncBeginWrapper(queryDescription, timeout, callback),
this.GetRepairTaskListAsyncEndWrapper,
cancellationToken,
"RepairManagementClient.GetRepairTaskListAsync"));
}
public Task <IList <IRepairTask> > GetRepairTaskListAsync(Guid activityId, string taskIdFilter = null, RepairTaskStateFilter stateFilter = RepairTaskStateFilter.Default, string executorFilter = null)
{
return(Task.FromResult((IList <IRepairTask>) new List <IRepairTask>()));
}
/// <summary>
/// Gets repair task for the node specified
/// </summary>
/// <param name="fc">Fabric client to carry out ServiceFabric operations</param>
/// <param name="nodeName">Node for which repair task is queried</param>
/// <param name="timeout">Timeout for operation</param>
/// <param name="cancellationToken">Cancellation token to cancel this async operation</param>
/// <param name="taskFilter">Optional parameter to specify filter when searching repair tasks for current node</param>
/// <returns>A Task representing the asnyc operation, result of task would be <see cref="RepairTask"/></returns>
internal static async Task <RepairTask> GetRepairTaskForNode(FabricClient fc, string nodeName, TimeSpan timeout,
CancellationToken cancellationToken, RepairTaskStateFilter taskFilter = RepairTaskStateFilter.Active)
{
var taskIdPrefix = String.Format("{0}_{1}_", TaskIdPrefix, nodeName);
var repairTasks = await fc.RepairManager.GetRepairTaskListAsync(taskIdPrefix,
taskFilter,
ExecutorName, timeout, cancellationToken);
ServiceEventSource.Current.InfoMessage("{0} repair tasks found for node {1}", repairTasks.Count, nodeName);
if (repairTasks.Count > 0)
{
RepairTask oldestActiveTask = repairTasks.Aggregate(
(curMin, task) => (task.CreatedTimestamp < curMin.CreatedTimestamp ? task : curMin));
ServiceEventSource.Current.VerboseMessage(String.Format("Oldest active repair task = {0} found in {1} state",
oldestActiveTask.TaskId, oldestActiveTask.State));
return(oldestActiveTask);
}
return(null);
}
public Task <IList <IRepairTask> > GetRepairTaskListAsync(Guid activityId, string taskIdFilter = null, RepairTaskStateFilter stateFilter = RepairTaskStateFilter.Default, string executorFilter = null)
{
return(this.GetRepairTaskListAsyncHandler(taskIdFilter, stateFilter, executorFilter));
}
public Task <IList <IRepairTask> > GetRepairTaskListAsync(Guid activityId, string taskIdFilter = null, RepairTaskStateFilter stateFilter = RepairTaskStateFilter.Default, string executorFilter = null)
{
throw new NotImplementedException();
}
