/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
{
ListTasksResponse response = new ListTasksResponse();
context.Read();
int targetDepth = context.CurrentDepth;
while (context.ReadAtDepth(targetDepth))
{
if (context.TestExpression("NextToken", targetDepth))
{
var unmarshaller = StringUnmarshaller.Instance;
response.NextToken = unmarshaller.Unmarshall(context);
continue;
}
if (context.TestExpression("Tasks", targetDepth))
{
var unmarshaller = new ListUnmarshaller <TaskListEntry, TaskListEntryUnmarshaller>(TaskListEntryUnmarshaller.Instance);
response.Tasks = unmarshaller.Unmarshall(context);
continue;
}
}
return(response);
}
public override void Invoke(AWSCredentials creds, RegionEndpoint region, int maxItems)
{
AmazonDataSyncConfig config = new AmazonDataSyncConfig();
config.RegionEndpoint = region;
ConfigureClient(config);
AmazonDataSyncClient client = new AmazonDataSyncClient(creds, config);
ListTasksResponse resp = new ListTasksResponse();
do
{
ListTasksRequest req = new ListTasksRequest
{
NextToken = resp.NextToken
,
MaxResults = maxItems
};
resp = client.ListTasks(req);
CheckError(resp.HttpStatusCode, "200");
foreach (var obj in resp.Tasks)
{
AddObject(obj);
}
}while (!string.IsNullOrEmpty(resp.NextToken));
}
private static void UnmarshallResult(XmlUnmarshallerContext context, ListTasksResponse response)
{
int originalDepth = context.CurrentDepth;
int targetDepth = originalDepth + 1;
if (context.IsStartOfDocument)
{
targetDepth += 2;
}
while (context.ReadAtDepth(originalDepth))
{
if (context.IsStartElement || context.IsAttribute)
{
if (context.TestExpression("nextToken", targetDepth))
{
var unmarshaller = StringUnmarshaller.Instance;
response.NextToken = unmarshaller.Unmarshall(context);
continue;
}
if (context.TestExpression("taskArns/member", targetDepth))
{
var unmarshaller = StringUnmarshaller.Instance;
var item = unmarshaller.Unmarshall(context);
response.TaskArns.Add(item);
continue;
}
}
}
return;
}
public static ListTasksResponse Unmarshall(UnmarshallerContext _ctx)
{
ListTasksResponse listTasksResponse = new ListTasksResponse();
listTasksResponse.HttpResponse = _ctx.HttpResponse;
listTasksResponse.RequestId = _ctx.StringValue("ListTasks.RequestId");
listTasksResponse.TotalCount = _ctx.IntegerValue("ListTasks.TotalCount");
listTasksResponse.PageNumber = _ctx.IntegerValue("ListTasks.PageNumber");
listTasksResponse.PageSize = _ctx.IntegerValue("ListTasks.PageSize");
List <ListTasksResponse.ListTasks_TaskInfo> listTasksResponse_tasks = new List <ListTasksResponse.ListTasks_TaskInfo>();
for (int i = 0; i < _ctx.Length("ListTasks.Tasks.Length"); i++)
{
ListTasksResponse.ListTasks_TaskInfo taskInfo = new ListTasksResponse.ListTasks_TaskInfo();
taskInfo.TaskId = _ctx.StringValue("ListTasks.Tasks[" + i + "].TaskId");
taskInfo.TaskType = _ctx.StringValue("ListTasks.Tasks[" + i + "].TaskType");
taskInfo.ClusterId = _ctx.StringValue("ListTasks.Tasks[" + i + "].ClusterId");
taskInfo.Request = _ctx.StringValue("ListTasks.Tasks[" + i + "].Request");
taskInfo.Status = _ctx.StringValue("ListTasks.Tasks[" + i + "].Status");
taskInfo.CurrentStep = _ctx.IntegerValue("ListTasks.Tasks[" + i + "].CurrentStep");
taskInfo.TotalSteps = _ctx.IntegerValue("ListTasks.Tasks[" + i + "].TotalSteps");
taskInfo.Result = _ctx.StringValue("ListTasks.Tasks[" + i + "].Result");
taskInfo.Errors = _ctx.StringValue("ListTasks.Tasks[" + i + "].Errors");
listTasksResponse_tasks.Add(taskInfo);
}
listTasksResponse.Tasks = listTasksResponse_tasks;
return(listTasksResponse);
}
public override AmazonWebServiceResponse Unmarshall(XmlUnmarshallerContext context)
{
ListTasksResponse response = new ListTasksResponse();
context.Read();
int targetDepth = context.CurrentDepth;
while (context.ReadAtDepth(targetDepth))
{
if (context.IsStartElement)
{
if (context.TestExpression("ListTasksResult", 2))
{
UnmarshallResult(context, response);
continue;
}
if (context.TestExpression("ResponseMetadata", 2))
{
response.ResponseMetadata = ResponseMetadataUnmarshaller.Instance.Unmarshall(context);
}
}
}
return(response);
}
public ListTasksResponse GetAll()
{
ListTasksResponse response = new ListTasksResponse();
response.Records = _taskItemRepository.List();
return(response);
}
public static ListTasksResponse Unmarshall(UnmarshallerContext _ctx)
{
ListTasksResponse listTasksResponse = new ListTasksResponse();
listTasksResponse.HttpResponse = _ctx.HttpResponse;
listTasksResponse.Code = _ctx.StringValue("ListTasks.Code");
listTasksResponse.Message = _ctx.StringValue("ListTasks.Message");
listTasksResponse.RequestId = _ctx.StringValue("ListTasks.RequestId");
ListTasksResponse.ListTasks_Data data = new ListTasksResponse.ListTasks_Data();
data.TotalElements = _ctx.LongValue("ListTasks.Data.TotalElements");
data.TotalPages = _ctx.IntegerValue("ListTasks.Data.TotalPages");
List <ListTasksResponse.ListTasks_Data.ListTasks_ItemsItem> data_items = new List <ListTasksResponse.ListTasks_Data.ListTasks_ItemsItem>();
for (int i = 0; i < _ctx.Length("ListTasks.Data.Items.Length"); i++)
{
ListTasksResponse.ListTasks_Data.ListTasks_ItemsItem itemsItem = new ListTasksResponse.ListTasks_Data.ListTasks_ItemsItem();
itemsItem.CreatedAt = _ctx.StringValue("ListTasks.Data.Items[" + i + "].CreatedAt");
itemsItem.Id = _ctx.StringValue("ListTasks.Data.Items[" + i + "].Id");
itemsItem.Status = _ctx.StringValue("ListTasks.Data.Items[" + i + "].Status");
itemsItem.VideoMetaUrl = _ctx.StringValue("ListTasks.Data.Items[" + i + "].VideoMetaUrl");
itemsItem.VideoUrl = _ctx.StringValue("ListTasks.Data.Items[" + i + "].VideoUrl");
data_items.Add(itemsItem);
}
data.Items = data_items;
listTasksResponse.Data = data;
return(listTasksResponse);
}
public async Task ListTasksQueryHandler_WithOtherFilename_ReturnsTasksFromOtherFile()
{
var command = new ListTasksQuery {
Filename = "Other.txt", Terms = new string[0]
};
ListTasksResponse result = await _handler.Handle(command, new CancellationToken());
result.Tasks.Should().HaveCount(2);
}
public async Task ListTasksQueryHandler_AndsTheQueryForMultipleSearchTerms()
{
var command = new ListTasksQuery {
Filename = _config.TodoFile, Terms = new string[] { "+project", "@context" }
};
ListTasksResponse result = await _handler.Handle(command, new CancellationToken());
result.Tasks.Should().HaveCount(1);
}
public async Task ListTasksQueryHandler_ReturnsTasksWithSearchTerms()
{
var command = new ListTasksQuery {
Filename = _config.TodoFile, Terms = new string[] { "+project" }
};
ListTasksResponse result = await _handler.Handle(command, new CancellationToken());
result.Tasks.Should().HaveCount(2);
}
public async Task ListTasksQueryHandler_ReturnsTasksInPriorityOrder()
{
var command = new ListTasksQuery {
Filename = _config.TodoFile, Terms = null
};
ListTasksResponse result = await _handler.Handle(command, new CancellationToken());
result.Tasks.First().Text.Should().Be("(A) This is high priority");
result.Tasks.Last().Text.Should().Be("x 2020-10-16 This is something to do!");
}
public void ListTasksMaxCountTest()
{
// Verify default max count
Assert.Equal(Microsoft.Azure.Commands.Batch.Utils.Constants.DefaultMaxCount, cmdlet.MaxCount);
// Setup cmdlet to list Tasks without filters and a max count
BatchAccountContext context = BatchTestHelpers.CreateBatchContextWithKeys();
cmdlet.BatchContext = context;
cmdlet.WorkItemName = "workItem";
cmdlet.JobName = "job-0000000001";
cmdlet.Name = null;
cmdlet.Filter = null;
int maxCount = 2;
cmdlet.MaxCount = maxCount;
string[] namesOfConstructedTasks = new[] { "testTask1", "testTask2", "testTask3" };
// Build some Tasks instead of querying the service on a ListTasks call
YieldInjectionInterceptor interceptor = new YieldInjectionInterceptor((opContext, request) =>
{
if (request is ListTasksRequest)
{
ListTasksResponse response = BatchTestHelpers.CreateListTasksResponse(namesOfConstructedTasks);
Task <object> task = Task <object> .Factory.StartNew(() => { return(response); });
return(task);
}
return(null);
});
cmdlet.AdditionalBehaviors = new List <BatchClientBehavior>()
{
interceptor
};
// Setup the cmdlet to write pipeline output to a list that can be examined later
List <PSCloudTask> pipeline = new List <PSCloudTask>();
commandRuntimeMock.Setup(r =>
r.WriteObject(It.IsAny <PSCloudTask>()))
.Callback <object>(t => pipeline.Add((PSCloudTask)t));
cmdlet.ExecuteCmdlet();
// Verify that the max count was respected
Assert.Equal(maxCount, pipeline.Count);
// Verify setting max count <= 0 doesn't return nothing
cmdlet.MaxCount = -5;
pipeline.Clear();
cmdlet.ExecuteCmdlet();
Assert.Equal(namesOfConstructedTasks.Length, pipeline.Count);
}
public void ListBatchTasksByODataFilterTest()
{
// Setup cmdlet to list Tasks using an OData filter. Use WorkItemName and JobName input.
BatchAccountContext context = BatchTestHelpers.CreateBatchContextWithKeys();
cmdlet.BatchContext = context;
cmdlet.WorkItemName = "workItem";
cmdlet.JobName = "job-0000000001";
cmdlet.Name = null;
cmdlet.Filter = "startswith(name,'test')";
string[] namesOfConstructedTasks = new[] { "testTask1", "testTask2" };
// Build some Tasks instead of querying the service on a ListTasks call
YieldInjectionInterceptor interceptor = new YieldInjectionInterceptor((opContext, request) =>
{
if (request is ListTasksRequest)
{
ListTasksResponse response = BatchTestHelpers.CreateListTasksResponse(namesOfConstructedTasks);
Task <object> task = Task <object> .Factory.StartNew(() => { return(response); });
return(task);
}
return(null);
});
cmdlet.AdditionalBehaviors = new List <BatchClientBehavior>()
{
interceptor
};
// Setup the cmdlet to write pipeline output to a list that can be examined later
List <PSCloudTask> pipeline = new List <PSCloudTask>();
commandRuntimeMock.Setup(r =>
r.WriteObject(It.IsAny <PSCloudTask>()))
.Callback <object>(t => pipeline.Add((PSCloudTask)t));
cmdlet.ExecuteCmdlet();
// Verify that the cmdlet wrote the constructed Tasks to the pipeline
Assert.Equal(2, pipeline.Count);
int taskCount = 0;
foreach (PSCloudTask t in pipeline)
{
Assert.True(namesOfConstructedTasks.Contains(t.Name));
taskCount++;
}
Assert.Equal(namesOfConstructedTasks.Length, taskCount);
}
/// <summary>
/// Builds a ListTasksResponse object
/// </summary>
public static ListTasksResponse CreateListTasksResponse(IEnumerable <string> taskNames)
{
ListTasksResponse response = new ListTasksResponse();
SetProperty(response, "StatusCode", HttpStatusCode.OK);
List <Azure.Batch.Protocol.Entities.Task> tasks = new List <Azure.Batch.Protocol.Entities.Task>();
foreach (string name in taskNames)
{
Azure.Batch.Protocol.Entities.Task task = new Azure.Batch.Protocol.Entities.Task();
SetProperty(task, "Name", name);
tasks.Add(task);
}
SetProperty(response, "Tasks", tasks);
return(response);
}
/// <summary>
/// Handles a list tasks request
/// </summary>
internal async Task HandleListTasksRequest(
ListTasksParams listTasksParams,
RequestContext <ListTasksResponse> context)
{
Logger.Write(TraceEventType.Verbose, "HandleListTasksRequest");
Func <Task <ListTasksResponse> > getAllTasks = () =>
{
Validate.IsNotNull(nameof(listTasksParams), listTasksParams);
return(Task.Factory.StartNew(() =>
{
ListTasksResponse response = new ListTasksResponse();
response.Tasks = TaskManager.Tasks.Select(x => x.ToTaskInfo()).ToArray();
return response;
}));
};
await HandleRequestAsync(getAllTasks, context, "HandleListTasksRequest");
}
public ActionResult <ListTasksResponse> Post(ListTasks request)
{
ListTasksResponse ret = new ListTasksResponse();
GXSelectArgs arg = GXSelectArgs.SelectAll <GXTask>();
arg.Count = (UInt32)request.Count;
arg.Descending = true;
if (request.AttributeId != 0)
{
arg.Columns.Add <GXDevice>();
arg.Columns.Add <GXObject>();
arg.Columns.Add <GXAttribute>();
arg.Joins.AddInnerJoin <GXTask, GXObject>(a => a.Object, b => b.Id);
arg.Joins.AddInnerJoin <GXObject, GXDevice>(a => a.DeviceId, b => b.Id);
arg.Joins.AddInnerJoin <GXObject, GXAttribute>(a => a.Id, b => b.ObjectId);
arg.Where.And <GXAttribute>(q => q.Id == request.AttributeId);
}
else if (request.ObjectId != 0)
{
arg.Columns.Add <GXDevice>();
arg.Columns.Add <GXObject>();
arg.Columns.Add <GXAttribute>();
arg.Joins.AddInnerJoin <GXTask, GXObject>(a => a.Object, b => b.Id);
arg.Joins.AddInnerJoin <GXObject, GXDevice>(a => a.DeviceId, b => b.Id);
arg.Where.And <GXObject>(q => q.Id == request.ObjectId);
}
else if (request.DeviceId != 0)
{
arg.Columns.Add <GXDevice>();
arg.Columns.Add <GXObject>();
arg.Columns.Add <GXAttribute>();
arg.Joins.AddInnerJoin <GXTask, GXObject>(a => a.Object, b => b.Id);
arg.Joins.AddInnerJoin <GXObject, GXDevice>(a => a.DeviceId, b => b.Id);
arg.Joins.AddInnerJoin <GXObject, GXAttribute>(a => a.Id, b => b.ObjectId);
arg.Where.And <GXObject>(q => q.DeviceId == request.DeviceId);
}
else if ((request.Targets & TargetType.Attribute) != 0)
{
arg.Columns.Add <GXDevice>();
arg.Columns.Add <GXObject>();
arg.Columns.Add <GXAttribute>();
arg.Joins.AddInnerJoin <GXTask, GXObject>(a => a.Object, b => b.Id);
arg.Joins.AddInnerJoin <GXObject, GXDevice>(a => a.DeviceId, b => b.Id);
arg.Joins.AddInnerJoin <GXObject, GXAttribute>(a => a.Id, b => b.ObjectId);
}
else if ((request.Targets & TargetType.Object) != 0)
{
arg.Columns.Add <GXDevice>();
arg.Columns.Add <GXObject>();
arg.Joins.AddInnerJoin <GXTask, GXObject>(a => a.Object.Id, b => b.Id);
arg.Joins.AddInnerJoin <GXObject, GXDevice>(a => a.DeviceId, b => b.Id);
}
else if ((request.Targets & TargetType.Device) != 0)
{
arg.Columns.Add <GXDevice>();
arg.Joins.AddInnerJoin <GXTask, GXObject>(a => a.Object.Id, b => b.Id);
arg.Joins.AddInnerJoin <GXObject, GXDevice>(a => a.DeviceId, b => b.Id);
}
arg.OrderBy.Add <GXTask>(q => q.Id);
ret.Tasks = host.Connection.Select <GXTask>(arg).ToArray();
return(ret);
}
/// <summary>
/// Builds a ListTasksResponse object
/// </summary>
public static ListTasksResponse CreateListTasksResponse(IEnumerable<string> taskNames)
{
ListTasksResponse response = new ListTasksResponse();
SetProperty(response, "StatusCode", HttpStatusCode.OK);
List<Azure.Batch.Protocol.Entities.Task> tasks = new List<Azure.Batch.Protocol.Entities.Task>();
foreach (string name in taskNames)
{
Azure.Batch.Protocol.Entities.Task task = new Azure.Batch.Protocol.Entities.Task();
SetProperty(task, "Name", name);
tasks.Add(task);
}
SetProperty(response, "Tasks", tasks);
return response;
}
