public void HandleSubOrchestrationInstanceFailedEvent(SubOrchestrationInstanceFailedEvent failedEvent)
{
int taskId = failedEvent.TaskScheduledId;
if (this.openTasks.ContainsKey(taskId))
{
OpenTaskInfo info = this.openTasks[taskId];
// When using ErrorPropagationMode.SerializeExceptions the "cause" is deserialized from history.
// This isn't fully reliable because not all exception types can be serialized/deserialized.
// When using ErrorPropagationMode.UseFailureDetails we instead use FailureDetails to convey
// error information, which doesn't involve any serialization at all.
Exception cause = this.ErrorPropagationMode == ErrorPropagationMode.SerializeExceptions ?
Utils.RetrieveCause(failedEvent.Details, this.ErrorDataConverter) :
null;
var failedException = new SubOrchestrationFailedException(failedEvent.EventId, taskId, info.Name,
info.Version,
failedEvent.Reason, cause);
failedException.FailureDetails = failedEvent.FailureDetails;
TaskCompletionSource <string> tcs = info.Result;
tcs.SetException(failedException);
this.openTasks.Remove(taskId);
}
else
{
LogDuplicateEvent("SubOrchestrationInstanceFailed", failedEvent, taskId);
}
}
async Task <T> Execute <T>(FakeOrchestrationContext context, string name, string version, object input)
{
OrchestrationInstance instance = context.OrchestrationInstance;
SynchronizationContext prevCtx = SynchronizationContext.Current;
try
{
TaskOrchestration definition = orchestrationObjectManager.GetObject(name, version);
if (definition == null)
{
throw new OrchestrationFrameworkException("Orchestration not found");
}
string serializedInput = dataConverter.Serialize(input);
Task <string> serializedResultTask = definition.Execute(context, serializedInput);
currentExecutions.Add(instance.InstanceId, definition);
string serializedResult = null;
try
{
serializedResult = await serializedResultTask;
}
catch (OrchestrationFailureException e)
{
Exception cause = Utils.RetrieveCause(e.Details, dataConverter);
var subOrchestrationFailedException = new SubOrchestrationFailedException(0, 0, name, version,
e.Message, cause);
throw subOrchestrationFailedException;
}
catch (Exception e)
{
var subOrchestrationFailedException = new SubOrchestrationFailedException(0, 0, name, version,
e.Message, e);
throw subOrchestrationFailedException;
}
return(dataConverter.Deserialize <T>(serializedResult));
}
finally
{
SynchronizationContext.SetSynchronizationContext(prevCtx);
TaskOrchestration orchestration = null;
if (currentExecutions.TryGetValue(instance.InstanceId, out orchestration))
{
currentExecutions.Remove(instance.InstanceId);
completedExecutions.Add(instance, orchestration);
}
}
}
public void HandleSubOrchestrationInstanceFailedEvent(SubOrchestrationInstanceFailedEvent failedEvent)
{
int taskId = failedEvent.TaskScheduledId;
if (openTasks.ContainsKey(taskId))
{
OpenTaskInfo info = openTasks[taskId];
Exception cause = Utils.RetrieveCause(failedEvent.Details, dataConverter);
var failedException = new SubOrchestrationFailedException(failedEvent.EventId, taskId, info.Name,
info.Version,
failedEvent.Reason, cause);
TaskCompletionSource <string> tcs = info.Result;
tcs.SetException(failedException);
openTasks.Remove(taskId);
}
else
{
LogDuplicateEvent("SubOrchestrationInstanceFailed", failedEvent, taskId);
}
}
