IEnumerable <OrchestratorAction> ExecuteCore(IEnumerable <HistoryEvent> eventHistory) { SynchronizationContext prevCtx = SynchronizationContext.Current; try { SynchronizationContext syncCtx = new TaskOrchestrationSynchronizationContext(decisionScheduler); SynchronizationContext.SetSynchronizationContext(syncCtx); OrchestrationContext.IsOrchestratorThread = true; try { foreach (HistoryEvent historyEvent in eventHistory) { if (historyEvent.EventType == EventType.OrchestratorStarted) { var decisionStartedEvent = (OrchestratorStartedEvent)historyEvent; context.CurrentUtcDateTime = decisionStartedEvent.Timestamp; continue; } context.IsReplaying = historyEvent.IsPlayed; ProcessEvent(historyEvent); historyEvent.IsPlayed = true; } // check if workflow is completed after this replay if (!context.HasOpenTasks) { if (result.IsCompleted) { if (result.IsFaulted) { context.FailOrchestration(result.Exception.InnerExceptions.FirstOrDefault()); } else { context.CompleteOrchestration(result.Result); } } // TODO: It is an error if result is not completed when all OpenTasks are done. // Throw an exception in that case. } } catch (NonDeterministicOrchestrationException exception) { context.FailOrchestration(exception); } return(context.OrchestratorActions); } finally { orchestrationRuntimeState.Status = taskOrchestration.GetStatus(); SynchronizationContext.SetSynchronizationContext(prevCtx); OrchestrationContext.IsOrchestratorThread = false; } }
public IEnumerable<OrchestratorAction> Execute() { SynchronizationContext prevCtx = SynchronizationContext.Current; try { SynchronizationContext syncCtx = new TaskOrchestrationSynchronizationContext(decisionScheduler); SynchronizationContext.SetSynchronizationContext(syncCtx); try { foreach (HistoryEvent historyEvent in orchestrationRuntimeState.Events) { if (historyEvent.EventType == EventType.OrchestratorStarted) { var decisionStartedEvent = (OrchestratorStartedEvent) historyEvent; context.CurrentUtcDateTime = decisionStartedEvent.Timestamp; continue; } context.IsReplaying = historyEvent.IsPlayed; ProcessEvent(historyEvent); historyEvent.IsPlayed = true; } // check if workflow is completed after this replay if (!context.HasOpenTasks) { if (result.IsCompleted) { if (result.IsFaulted) { context.FailOrchestration(result.Exception.InnerExceptions.FirstOrDefault()); } else { context.CompleteOrchestration(result.Result); } } // TODO: It is an error if result is not completed when all OpenTasks are done. // Throw an exception in that case. } } catch (NonDeterministicOrchestrationException exception) { context.FailOrchestration(exception); } return context.OrchestratorActions; } finally { orchestrationRuntimeState.Status = taskOrchestration.GetStatus(); SynchronizationContext.SetSynchronizationContext(prevCtx); } }
OrchestratorExecutionResult ExecuteCore(IEnumerable <HistoryEvent> pastEvents, IEnumerable <HistoryEvent> newEvents) { SynchronizationContext prevCtx = SynchronizationContext.Current; try { SynchronizationContext syncCtx = new TaskOrchestrationSynchronizationContext(this.decisionScheduler); SynchronizationContext.SetSynchronizationContext(syncCtx); OrchestrationContext.IsOrchestratorThread = true; try { void ProcessEvents(IEnumerable <HistoryEvent> events) { foreach (HistoryEvent historyEvent in events) { if (historyEvent.EventType == EventType.OrchestratorStarted) { var decisionStartedEvent = (OrchestratorStartedEvent)historyEvent; this.context.CurrentUtcDateTime = decisionStartedEvent.Timestamp; continue; } this.ProcessEvent(historyEvent); historyEvent.IsPlayed = true; } } // Replay the old history to rebuild the local state of the orchestration. // TODO: Log a verbose message indicating that the replay has started (include event count?) this.context.IsReplaying = true; ProcessEvents(pastEvents); // Play the newly arrived events to determine the next action to take. // TODO: Log a verbose message indicating that new events are being processed (include event count?) this.context.IsReplaying = false; ProcessEvents(newEvents); // check if workflow is completed after this replay // TODO: Create a setting that allows orchestrations to complete when the orchestrator // function completes, even if there are open tasks. if (!this.context.HasOpenTasks) { if (this.result !.IsCompleted) { if (this.result.IsFaulted) { Exception?exception = this.result.Exception?.InnerExceptions.FirstOrDefault(); Debug.Assert(exception != null); if (Utils.IsExecutionAborting(exception)) { // Let this exception propagate out to be handled by the dispatcher ExceptionDispatchInfo.Capture(exception).Throw(); } this.context.FailOrchestration(exception); } else { this.context.CompleteOrchestration(this.result.Result); } } // TODO: It is an error if result is not completed when all OpenTasks are done. // Throw an exception in that case. } } catch (NonDeterministicOrchestrationException exception) { this.context.FailOrchestration(exception); } return(new OrchestratorExecutionResult { Actions = this.context.OrchestratorActions, CustomStatus = this.taskOrchestration.GetStatus(), }); } finally { SynchronizationContext.SetSynchronizationContext(prevCtx); OrchestrationContext.IsOrchestratorThread = false; } }
IEnumerable <OrchestratorAction> ExecuteCore(IEnumerable <HistoryEvent> eventHistory) { SynchronizationContext prevCtx = SynchronizationContext.Current; try { SynchronizationContext syncCtx = new TaskOrchestrationSynchronizationContext(this.decisionScheduler); SynchronizationContext.SetSynchronizationContext(syncCtx); OrchestrationContext.IsOrchestratorThread = true; try { foreach (HistoryEvent historyEvent in eventHistory) { if (historyEvent.EventType == EventType.OrchestratorStarted) { var decisionStartedEvent = (OrchestratorStartedEvent)historyEvent; this.context.CurrentUtcDateTime = decisionStartedEvent.Timestamp; continue; } this.context.IsReplaying = historyEvent.IsPlayed; this.ProcessEvent(historyEvent); historyEvent.IsPlayed = true; } // check if workflow is completed after this replay if (!this.context.HasOpenTasks) { if (this.result.IsCompleted) { if (this.result.IsFaulted) { Exception exception = this.result.Exception?.InnerExceptions.FirstOrDefault(); Debug.Assert(exception != null); if (Utils.IsExecutionAborting(exception)) { // Let this exception propagate out to be handled by the dispatcher ExceptionDispatchInfo.Capture(exception).Throw(); } this.context.FailOrchestration(exception); } else { this.context.CompleteOrchestration(this.result.Result); } } // TODO: It is an error if result is not completed when all OpenTasks are done. // Throw an exception in that case. } } catch (NonDeterministicOrchestrationException exception) { this.context.FailOrchestration(exception); } return(this.context.OrchestratorActions); } finally { this.orchestrationRuntimeState.Status = this.taskOrchestration.GetStatus(); SynchronizationContext.SetSynchronizationContext(prevCtx); OrchestrationContext.IsOrchestratorThread = false; } }