async Task TimerMessageSchedulerAsync()
{
while (!this.cancellationTokenSource.Token.IsCancellationRequested)
{
lock (this.thisLock)
{
foreach (TaskMessage tm in this.timerMessages)
{
TimerFiredEvent te = tm.Event as TimerFiredEvent;
if (te == null)
{
// AFFANDAR : TODO : unobserved task exception
throw new InvalidOperationException("Invalid timer message");
}
if (te.FireAt <= DateTime.UtcNow)
{
this.orchestratorQueue.SendMessage(tm);
this.timerMessages.Remove(tm);
}
}
}
await Task.Delay(TimeSpan.FromSeconds(1));
}
return;
}
public void Can_be_returned_as_custom_action_workflow()
{
var timerFiredEventGraph = _builder.TimerFiredGraph(Identity.Timer("timer1"), TimeSpan.FromSeconds(2));
var timerFiredEvent = new TimerFiredEvent(timerFiredEventGraph.First(), timerFiredEventGraph);
var decisions = timerFiredEvent.Interpret(new WorkflowToReturnRecordMarker("markerName", "details")).GetDecisions();
Assert.That(decisions, Is.EqualTo(new [] { new RecordMarkerWorkflowDecision("markerName", "details") }));
}
public void Can_be_returned_as_custom_action_from_workflow()
{
var workflow = new WorkflowToReturnCancelRequest("id", "runid");
var timerFiredEventGraph = _builder.TimerFiredGraph(Identity.Timer("timer1"), TimeSpan.FromSeconds(2));
var timerEvent = new TimerFiredEvent(timerFiredEventGraph.First(), timerFiredEventGraph);
var decisions = timerEvent.Interpret(workflow).GetDecisions();
Assert.That(decisions, Is.EqualTo(new [] { new CancelRequestWorkflowDecision("id", "runid") }));
}
public void Setup()
{
_graphBuilder = new EventGraphBuilder();
_builder = new HistoryEventsBuilder();
_builder.AddProcessedEvents(_graphBuilder.WorkflowStartedEvent("input"));
_builder.AddWorkflowRunId(ParentWorkflowRunId);
_identity = Identity.Timer(TimerName);
_timerFiredEvent = CreateTimerFiredEvent(_identity, _fireAfter);
}
public void Timerof_test()
{
var eventGraph = _builder.TimerFiredGraph(Identity.Timer("Timer1"), TimeSpan.FromSeconds(2));
var activityCompletedEvent = new TimerFiredEvent(eventGraph.First(), eventGraph);
var workflow = new TestWorkflow();
var activity = workflow.GetTimerOf(activityCompletedEvent);
Assert.That(activity, Is.EqualTo(TimerItem.New(Identity.Timer("Timer1"), workflow)));
}
public void HandleTimerFiredEvent(TimerFiredEvent timerFiredEvent)
{
int taskId = timerFiredEvent.TimerId;
if (openTasks.ContainsKey(taskId))
{
OpenTaskInfo info = openTasks[taskId];
info.Result.SetResult(timerFiredEvent.TimerId.ToString());
openTasks.Remove(taskId);
}
}
public void HandleTimerFiredEvent(TimerFiredEvent timerFiredEvent)
{
int taskId = timerFiredEvent.TimerId;
if (this.openTasks.ContainsKey(taskId))
{
OpenTaskInfo info = this.openTasks[taskId];
info.Result.SetResult(timerFiredEvent.TimerId.ToString());
this.openTasks.Remove(taskId);
}
else
{
LogDuplicateEvent("TimerFired", timerFiredEvent, taskId);
}
}
static TaskMessage ProcessCreateTimerDecision(
CreateTimerOrchestratorAction createTimerOrchestratorAction, OrchestrationRuntimeState runtimeState)
{
var taskMessage = new TaskMessage();
var timerCreatedEvent = new TimerCreatedEvent(createTimerOrchestratorAction.Id);
timerCreatedEvent.FireAt = createTimerOrchestratorAction.FireAt;
runtimeState.AddEvent(timerCreatedEvent);
var timerFiredEvent = new TimerFiredEvent(-1);
timerFiredEvent.TimerId = createTimerOrchestratorAction.Id;
taskMessage.Event = timerFiredEvent;
taskMessage.OrchestrationInstance = runtimeState.OrchestrationInstance;
return(taskMessage);
}
public static HistoryEvent GetHistoryEvent(this DbDataReader reader, bool isOrchestrationHistory = false)
{
string eventTypeString = (string)reader["EventType"];
if (!Enum.TryParse(eventTypeString, out EventType eventType))
{
throw new InvalidOperationException($"Unknown event type '{eventTypeString}'.");
}
int eventId = GetTaskId(reader);
HistoryEvent historyEvent;
switch (eventType)
{
case EventType.ContinueAsNew:
historyEvent = new ContinueAsNewEvent(eventId, GetPayloadText(reader));
break;
case EventType.EventRaised:
historyEvent = new EventRaisedEvent(eventId, GetPayloadText(reader))
{
Name = GetName(reader),
};
break;
case EventType.EventSent:
historyEvent = new EventSentEvent(eventId)
{
Input = GetPayloadText(reader),
Name = GetName(reader),
InstanceId = GetInstanceId(reader),
};
break;
case EventType.ExecutionCompleted:
historyEvent = new ExecutionCompletedEvent(
eventId,
result: GetPayloadText(reader),
orchestrationStatus: OrchestrationStatus.Completed);
break;
case EventType.ExecutionFailed:
historyEvent = new ExecutionCompletedEvent(
eventId,
result: GetPayloadText(reader),
orchestrationStatus: OrchestrationStatus.Failed);
break;
case EventType.ExecutionStarted:
historyEvent = new ExecutionStartedEvent(eventId, GetPayloadText(reader))
{
Name = GetName(reader),
OrchestrationInstance = new OrchestrationInstance
{
InstanceId = GetInstanceId(reader),
ExecutionId = GetExecutionId(reader),
},
Tags = null, // TODO
Version = GetVersion(reader),
};
string?parentInstanceId = GetParentInstanceId(reader);
if (parentInstanceId != null)
{
((ExecutionStartedEvent)historyEvent).ParentInstance = new ParentInstance
{
OrchestrationInstance = new OrchestrationInstance
{
InstanceId = parentInstanceId
},
TaskScheduleId = GetTaskId(reader)
};
}
break;
case EventType.ExecutionTerminated:
historyEvent = new ExecutionTerminatedEvent(eventId, GetPayloadText(reader));
break;
case EventType.GenericEvent:
historyEvent = new GenericEvent(eventId, GetPayloadText(reader));
break;
case EventType.OrchestratorCompleted:
historyEvent = new OrchestratorCompletedEvent(eventId);
break;
case EventType.OrchestratorStarted:
historyEvent = new OrchestratorStartedEvent(eventId);
break;
case EventType.SubOrchestrationInstanceCompleted:
historyEvent = new SubOrchestrationInstanceCompletedEvent(eventId, GetTaskId(reader), GetPayloadText(reader));
break;
case EventType.SubOrchestrationInstanceCreated:
historyEvent = new SubOrchestrationInstanceCreatedEvent(eventId)
{
Input = GetPayloadText(reader),
InstanceId = null, // TODO
Name = GetName(reader),
Version = null,
};
break;
case EventType.SubOrchestrationInstanceFailed:
historyEvent = new SubOrchestrationInstanceFailedEvent(
eventId,
taskScheduledId: GetTaskId(reader),
reason: GetReason(reader),
details: GetPayloadText(reader));
break;
case EventType.TaskCompleted:
historyEvent = new TaskCompletedEvent(
eventId,
taskScheduledId: GetTaskId(reader),
result: GetPayloadText(reader));
break;
case EventType.TaskFailed:
historyEvent = new TaskFailedEvent(
eventId,
taskScheduledId: GetTaskId(reader),
reason: GetReason(reader),
details: GetPayloadText(reader));
break;
case EventType.TaskScheduled:
historyEvent = new TaskScheduledEvent(eventId)
{
Input = GetPayloadText(reader),
Name = GetName(reader),
Version = GetVersion(reader),
};
break;
case EventType.TimerCreated:
historyEvent = new TimerCreatedEvent(eventId)
{
FireAt = GetVisibleTime(reader),
};
break;
case EventType.TimerFired:
historyEvent = new TimerFiredEvent(eventId)
{
FireAt = GetVisibleTime(reader),
TimerId = GetTaskId(reader),
};
break;
default:
throw new InvalidOperationException($"Don't know how to interpret '{eventType}'.");
}
historyEvent.Timestamp = GetTimestamp(reader);
historyEvent.IsPlayed = isOrchestrationHistory && (bool)reader["IsPlayed"];
return(historyEvent);
}
public void Setup()
{
_builder = new HistoryEventsBuilder();
_timerFiredEvent = CreateTimerFiredEvent(Identity.Timer(_timerName), _fireAfter);
}