public async Task <string> SubmitNewTaskAndAwaitCompletionAsync(ControllableProcessTask task, bool successIsExpected)
{
var status = await TashAccessor.PutControllableProcessTaskAsync(task);
Assert.AreEqual(HttpStatusCode.Created, status);
var startTime = DateTime.Now;
var result
= await TashAccessor.AwaitCompletionAsync(task.Id, MilliSecondsToAttemptWhileRequestedOrProcessing)
?? await TashAccessor.GetControllableProcessTaskAsync(task.Id);
if (result.Status == ControllableProcessTaskStatus.Processing)
{
var endTime = DateTime.Now;
var elapsed = (endTime - startTime).TotalMilliseconds;
Assert.IsTrue(elapsed > MilliSecondsToAttemptWhileRequestedOrProcessing,
$"Task started at {startTime.ToLongTimeString()} and given up at {endTime.ToLongTimeString()}");
}
if (successIsExpected)
{
var errorMessage = $"Task status is {Enum.GetName(typeof(ControllableProcessTaskStatus), result.Status)}, error message: {result.ErrorMessage}";
Assert.AreEqual(ControllableProcessTaskStatus.Completed, result.Status, errorMessage);
return(result.Text);
}
else
{
var errorMessage = $"Unexpected task status {Enum.GetName(typeof(ControllableProcessTaskStatus), result.Status)}";
Assert.AreEqual(ControllableProcessTaskStatus.Failed, result.Status, errorMessage);
return(result.ErrorMessage);
}
}
public bool MarkTaskAsCompleted(ControllableProcessTask theTaskIAmProcessing, int processId, string type, string controlName, string text)
{
return(theTaskIAmProcessing != null &&
theTaskIAmProcessing.Status == ControllableProcessTaskStatus.Processing &&
theTaskIAmProcessing.ProcessId == processId &&
theTaskIAmProcessing.Type == type &&
theTaskIAmProcessing.ControlName == controlName &&
theTaskIAmProcessing.Text == text);
}
public static ControllableProcessTask CreateControllableProcessTask(global::System.Guid ID, int processId, global::Aspenlaub.Net.GitHub.CSharp.Tash.ControllableProcessTaskStatus status)
{
ControllableProcessTask controllableProcessTask = new ControllableProcessTask();
controllableProcessTask.Id = ID;
controllableProcessTask.ProcessId = processId;
controllableProcessTask.Status = status;
return(controllableProcessTask);
}
public async Task <HttpStatusCode> ConfirmStatusAsync(Guid taskId, ControllableProcessTaskStatus status, string text, string errorMessage)
{
using (_SimpleLogger.BeginScope(SimpleLoggingScopeId.Create(nameof(ConfirmStatusAsync)))) {
var methodNamesFromStack = _MethodNamesFromStackFramesExtractor.ExtractMethodNamesFromStackFrames();
_SimpleLogger.LogInformationWithCallStack($"Confirm status {Enum.GetName(typeof(ControllableProcessStatus), status)} for task id={taskId}", methodNamesFromStack);
DefaultContainer context;
ControllableProcessTask controllableProcessTask = null;
bool wasExceptionThrown;
do
{
wasExceptionThrown = false;
context = new DefaultContainer(new Uri(BaseUrl));
try {
if (!await ProcessTaskExists(context, taskId))
{
return(HttpStatusCode.NotFound);
}
_SimpleLogger.LogInformationWithCallStack($"Select task with id={taskId} for update", methodNamesFromStack);
controllableProcessTask = await context.ControllableProcessTasks.ByKey(taskId).GetValueAsync();
} catch {
_SimpleLogger.LogErrorWithCallStack($"Could not select task with id={taskId} for update, trying again", methodNamesFromStack);
wasExceptionThrown = true;
}
} while (wasExceptionThrown);
if (controllableProcessTask == null)
{
_SimpleLogger.LogInformationWithCallStack($"No task found with id={taskId}", methodNamesFromStack);
return(HttpStatusCode.NotFound);
}
_SimpleLogger.LogInformationWithCallStack($"Update task with id={taskId}", methodNamesFromStack);
controllableProcessTask.Status = status;
controllableProcessTask.Text = text;
controllableProcessTask.ErrorMessage = errorMessage;
context.UpdateObject(controllableProcessTask);
var response = await context.SaveChangesAsync(SaveChangesOptions.None);
var statusCode = response.Select(r => (HttpStatusCode)r.StatusCode).FirstOrDefault();
return(statusCode);
}
}
public async Task <HttpStatusCode> PutControllableProcessTaskAsync(ControllableProcessTask processTask)
{
using (_SimpleLogger.BeginScope(SimpleLoggingScopeId.Create(nameof(PutControllableProcessTaskAsync)))) {
var methodNamesFromStack = _MethodNamesFromStackFramesExtractor.ExtractMethodNamesFromStackFrames();
_SimpleLogger.LogInformationWithCallStack($"Put controllable process task with id={processTask.Id}", methodNamesFromStack);
var context = new DefaultContainer(new Uri(BaseUrl));
ControllableProcessTask controllableProcessTask;
if (await ProcessTaskExists(context, processTask.Id))
{
_SimpleLogger.LogInformationWithCallStack($"Update controllable process task with id={processTask.Id}", methodNamesFromStack);
controllableProcessTask = await context.ControllableProcessTasks.ByKey(processTask.Id).GetValueAsync();
controllableProcessTask.ProcessId = processTask.ProcessId;
controllableProcessTask.Type = processTask.Type;
controllableProcessTask.ControlName = processTask.ControlName;
controllableProcessTask.Text = processTask.Text;
controllableProcessTask.Status = processTask.Status;
context.UpdateObject(controllableProcessTask);
}
else
{
_SimpleLogger.LogInformationWithCallStack($"Insert controllable process task with id={processTask.Id}", methodNamesFromStack);
controllableProcessTask = new ControllableProcessTask {
Id = processTask.Id,
ProcessId = processTask.ProcessId,
Type = processTask.Type,
ControlName = processTask.ControlName,
Text = processTask.Text,
Status = processTask.Status
};
context.AddToControllableProcessTasks(controllableProcessTask);
}
var response = await context.SaveChangesAsync(SaveChangesOptions.ReplaceOnUpdate);
var statusCode = response.Select(r => (HttpStatusCode)r.StatusCode).FirstOrDefault();
return(statusCode);
}
}
public void AddToControllableProcessTasks(ControllableProcessTask controllableProcessTask)
{
base.AddObject("ControllableProcessTasks", controllableProcessTask);
}
public async Task <string> SubmitNewTaskAndAwaitCompletionAsync(ControllableProcessTask task)
{
return(await SubmitNewTaskAndAwaitCompletionAsync(task, true));
}
