private async Task <ExecutionUpdateApiModel> ToExecutionUpdateApiModelAsync(Core.Models.Execution execution, string signatureRsaKeyXml = null)
{
var apiModel = new ExecutionUpdateApiModel
{
ExecutionId = execution.ExecutionId,
ExecutionStatus = execution.Status.ToString(),
ExpirationDateTimeUtc = execution.ExecutionTimeoutDateTimeUtc,
LastUpdatedDateTimeUtc = execution.LastUpdatedDateTimeUtc,
PercentComplete = execution.PercentComplete,
ResultData = execution.ResultData,
StatusMessage = execution.StatusMessage,
GetExecutionStatusUrl = GetExecutionStatusUrl(execution.ExecutionId),
PutExecutionStatusUrl = PutExecutionStatusUrl(execution.ExecutionId),
ExecutorProperties = execution.ExecutorProperties
};
if (execution.Status == ExecutionStatus.PendingInputObjects)
{
apiModel.InputObjects = await extensionObjectApiModelService.CreateInputObjectDictionaryAsync(
execution.InputObjects.Where(io => execution.ProvidedInputObjects.Contains(io.Name) == false),
execution);
}
apiModel.OutputObjects = await extensionObjectApiModelService.CreateOutputObjectDictionaryAsync(
execution.OutputObjects.Where(oo => execution.ProvidedOutputObjects.Contains(oo.Name)),
execution);
if (execution.ValidationErrors?.Any() == true)
{
apiModel.ValidationErrors = execution.ValidationErrors.Select(ve => ve.ToApiModel()).ToList();
}
return(apiModel);
}
public async Task <Dictionary <string, OutputObjectApiModel> > CreateOutputObjectDictionaryAsync(
IEnumerable <ExtensionOutputObject> outputObjects,
Core.Models.Execution execution)
{
var dictionary = new Dictionary <string, OutputObjectApiModel>();
foreach (var outputObject in outputObjects)
{
var accessor = await outputAccessorProvider.GetReadableAccessorAsync(
new OutputObjectAccessorRequest
{
ExecutionMetadata = execution,
ObjectMetadata = outputObject,
ObjectProviderName = execution.ObjectProviderName,
SignatureRsaKeyXml = execution.SignatureRsaKeyXml
});
dictionary[outputObject.Name] =
new OutputObjectApiModel
{
Accessor = accessor,
Description = outputObject.Description,
ObjectProviderName = execution.ObjectProviderName,
ObjectTypeName = outputObject.ObjectTypeName,
ObjectTypeUrl = outputObject.ObjectTypeUrl
};
}
return(dictionary);
}
private async Task <IActionResult> ToExecutionRequestRoutedResultAsync(Core.Models.Execution execution)
{
// At this point, the execution request has already been displatched to the execution pipeline (/doc/architecture/execution-pipeline.md),
// We're taking the result of that processing, converting into an HTTP response, and passing it back to the original caller.
var updateApiModel = await ToExecutionUpdateApiModelAsync(execution);
// Map the execution status to the right HTTP status code...
switch (execution.Status)
{
case ExecutionStatus.Processing:
case ExecutionStatus.Queued:
return(Accepted(updateApiModel));
case ExecutionStatus.Canceled:
case ExecutionStatus.Succeeded:
case ExecutionStatus.ValidationSucceeded:
return(Ok(updateApiModel));
case ExecutionStatus.ValidationFailed:
return(BadRequest(updateApiModel));
default:
return(StatusCode((int)(HttpStatusCode.InternalServerError), updateApiModel));
}
}
public async Task <Dictionary <string, InputObjectApiModel> > CreateInputObjectDictionaryAsync(
IEnumerable <ExtensionInputObject> inputObjects,
Core.Models.Execution execution)
{
var dictionary = new Dictionary <string, InputObjectApiModel>();
foreach (var inputObject in inputObjects)
{
var accessor = await inputAccessorProvider.GetWritableAccessorAsync(
new InputObjectAccessorRequest
{
ExecutionMetadata = execution,
ObjectMetadata = inputObject,
ObjectProviderName = execution.ObjectProviderName,
SignatureRsaKeyXml = execution.SignatureRsaKeyXml
});
dictionary[inputObject.Name] =
new InputObjectApiModel
{
Accessor = accessor,
Description = inputObject.Description,
IsRequired = inputObject.IsRequired,
ObjectProviderName = execution.ObjectProviderName,
ObjectTypeName = inputObject.ObjectTypeName,
ObjectTypeUrl = inputObject.ObjectTypeUrl
};
}
return(dictionary);
}
public static Execution ToCosmosModel(this Core.Models.Execution coreModel) => new Execution
{
CreatedDateTimeUtc = coreModel.CreatedDateTimeUtc,
ExecutionId = coreModel.ExecutionId,
Executor = coreModel.Executor,
ExpiresDateTimeUtc = coreModel.ExecutionTimeoutDateTimeUtc,
ExtensionId = coreModel.ExtensionId,
ExtensionVersionId = coreModel.ExtensionVersionId,
LastUpdatedDateTimeUtc = coreModel.LastUpdatedDateTimeUtc,
PercentageComplete = coreModel.PercentComplete,
Priority = coreModel.Priority,
Status = coreModel.Status,
StatusMessage = coreModel.StatusMessage,
StatusUpdateKey = coreModel.StatusUpdateKey,
ValidateOnly = coreModel.ValidateOnly,
ExecutionModelName = coreModel.ExecutionModelName,
ExecutionProfileName = coreModel.ExecutionProfileName,
ObjectProviderName = coreModel.ObjectProviderName,
ProvidedInputObjects = coreModel.ProvidedInputObjects,
ProvidedOutputObjects = coreModel.ProvidedOutputObjects,
InputObjects = coreModel.InputObjects,
OutputObjects = coreModel.OutputObjects,
RequestData = coreModel.RequestData,
ResultData = coreModel.ResultData,
Mode = coreModel.Mode,
SignatureRsaKeyXml = coreModel.SignatureRsaKeyXml,
ExecutorProperties = coreModel.ExecutorProperties
};
private async Task UpdateExecutionAsync(Core.Models.Execution execution)
{
// Save the execution model to the execution repository...
await execRepository.UpsertExecutionAsync(execution);
// And publish an execution update event.
await execUpdatePublisher.PublishUpdateAsync(execution);
}
public async Task UpsertExecutionAsync(Core.Models.Execution execution)
{
if (execution == null)
{
throw new ArgumentNullException(nameof(execution));
}
await DocumentClient.UpsertDocumentAsync(
DocumentCollectionUri,
execution.ToCosmosModel());
}
public async Task PublishUpdateAsync(Core.Models.Execution execution)
{
if (execution == null)
{
throw new ArgumentNullException(nameof(execution));
}
await eventGridClient.PublishEventsAsync(topicHostName, new List <EventGridEvent>
{
new EventGridEvent
{
Id = Guid.NewGuid().ToString(),
EventType = EventType,
Data = execution.ToEvent(),
EventTime = DateTime.UtcNow,
Subject = execution.ExecutionId,
DataVersion = EventVersion
}
});
}
private Core.Models.Execution ApplyExecutionContext(Core.Models.ExecutionContext execContext, Core.Models.Execution execution)
{
execution.LastUpdatedDateTimeUtc = DateTime.UtcNow;
execution.PercentComplete = execContext.PercentComplete;
if (execContext.ProvidedOutputObjects != null)
{
execution.ProvidedInputObjects.AddRange(
execContext.ProvidedInputObjects.Except(execution.ProvidedInputObjects));
}
if (execContext.ProvidedOutputObjects != null)
{
execution.ProvidedOutputObjects.AddRange(
execContext.ProvidedOutputObjects.Except(execution.ProvidedOutputObjects));
}
execution.ResultData = (execContext.ResultData ?? execution.ResultData);
execution.Status = execContext.Status;
execution.StatusMessage = execContext.StatusMessage;
execution.ExecutionTimeoutDateTimeUtc = execContext.ExecutionTimeoutDateTimeUtc.GetValueOrDefault();
if (execContext.ValidationErrors != null)
{
execution.ValidationErrors.AddRange(execContext.ValidationErrors);
}
return(execution);
}
private Core.Models.Execution ApplyExecutionUpdate(UpdateExecutionStatusApiModel updateApiModel, Core.Models.Execution execution)
{
execution.LastUpdatedDateTimeUtc = (updateApiModel.LastUpdatedDateTimeUtc ?? DateTime.UtcNow);
execution.PercentComplete = updateApiModel.PercentComplete;
execution.ProvidedOutputObjects.AddRange(updateApiModel.ProvidedOutputObjects.Except(execution.ProvidedOutputObjects));
execution.ResultData = (updateApiModel.ResultData ?? execution.ResultData);
execution.StatusMessage = updateApiModel.StatusMessage;
execution.ExecutionTimeoutDateTimeUtc = updateApiModel.ExecutionTimeoutDateTimeUtc.GetValueOrDefault();
execution.ValidationErrors.AddRange(
updateApiModel.ValidationErrors
.Where(ve => execution.ValidationErrors.None(eve => (ve.ErrorId == eve.ErrorId)))
.Select(ve => ve.ToCoreModel()));
return(execution);
}
