Minor updates

Author: cgillum

backend/runtimestate.go

@@ -18,11 +18,11 @@ var (
 )
 
 type OrchestrationRuntimeState struct {
-	instanceID      api.InstanceID
-	committedEvents []*protos.HistoryEvent
-	pendingEvents   []*protos.HistoryEvent
-	newEvents       []*protos.HistoryEvent
-	newActions      []*protos.OrchestratorAction
+	instanceID    api.InstanceID
+	oldEvents     []*protos.HistoryEvent
+	pendingEvents []*protos.HistoryEvent
+	newEvents     []*protos.HistoryEvent
+	newActions    []*protos.OrchestratorAction
 
 	startEvent       *protos.ExecutionStartedEvent
 	completedEvent   *protos.ExecutionCompletedEvent
@@ -46,18 +46,21 @@ type OrchestratorMessage struct {
 // See https://github.com/microsoft/durabletask-go/issues/44 for more details.
 type ChunkingConfiguration struct {
 	// MaxHistoryEventCount is the maximum number of history events that can be stored in a single chunk.
+	// If the number of history events exceeds this value, the history events will be saved in multiple chunks that are each less than or equal to this value.
 	// A value of 0 or less means that there is no limit.
 	MaxHistoryEventCount int
 	// MaxHistoryEventSizeInKB is the maximum size of a single chunk in kilobytes.
 	// For example, a max size of 2MB would be specified as 2048.
+	// If the aggregate size of a batch of history events exceeds this value, the history events will be saved in multiple chunks that are each less than or equal to this size.
+	// If the size of a single history event exceeds this value, the orchestration will fail.
 	// A value of 0 or less means that there is no limit.
 	MaxHistoryEventSizeInKB int
 }
 
 func NewOrchestrationRuntimeState(instanceID api.InstanceID, existingHistory []*HistoryEvent) *OrchestrationRuntimeState {
 	s := &OrchestrationRuntimeState{
 		instanceID:       instanceID,
-		committedEvents:  make([]*HistoryEvent, 0, len(existingHistory)+10),
+		oldEvents:        make([]*HistoryEvent, 0, len(existingHistory)+10),
 		startedTaskIDs:   make(map[int32]bool),
 		completedTaskIDs: make(map[int32]bool),
 	}
@@ -116,15 +119,15 @@ func (s *OrchestrationRuntimeState) addEvent(e *HistoryEvent, isNew bool) error
 		s.pendingEvents = append(s.pendingEvents, e)
 		s.newEvents = append(s.newEvents, e)
 	} else {
-		s.committedEvents = append(s.committedEvents, e)
+		s.oldEvents = append(s.oldEvents, e)
 	}
 
 	s.lastUpdatedTime = e.Timestamp.AsTime()
 	return nil
 }
 
 func (s *OrchestrationRuntimeState) IsValid() bool {
-	if len(s.committedEvents) == 0 && len(s.pendingEvents) == 0 {
+	if len(s.oldEvents) == 0 && len(s.pendingEvents) == 0 && len(s.newEvents) == 0 {
 		// empty orchestration state
 		return true
 	} else if s.startEvent != nil {
@@ -388,6 +391,13 @@ func (s *OrchestrationRuntimeState) SetFailed(err error) {
 	// Clear the list of pending events since we don't care about these anymore.
 	s.pendingEvents = nil
 
+	// Add a fake "execution started" event if one doesn't already exist.
+	if s.startEvent == nil {
+		s.newEvents = append(s.newEvents, helpers.NewExecutionStartedEvent(
+			"(Unknown)",
+			string(s.instanceID),
+		))
+
 	// Apply an "orchestration failed" action to the current state.
 	s.newActions = []*protos.OrchestratorAction{helpers.NewCompleteOrchestrationAction(
 		-1,
@@ -469,7 +479,7 @@ func (s *OrchestrationRuntimeState) IsCompleted() bool {
 }
 
 func (s *OrchestrationRuntimeState) OldEvents() []*HistoryEvent {
-	return s.committedEvents
+	return s.oldEvents
 }
 
 func (s *OrchestrationRuntimeState) NewEvents() []*HistoryEvent {
@@ -496,10 +506,10 @@ func (s *OrchestrationRuntimeState) String() string {
 
 func (s *OrchestrationRuntimeState) getStartedTime() time.Time {
 	var startTime time.Time
-	if len(s.committedEvents) > 0 {
-		startTime = s.committedEvents[0].Timestamp.AsTime()
-	} else if len(s.committedEvents) > 0 {
-		startTime = s.committedEvents[0].Timestamp.AsTime()
+	if len(s.oldEvents) > 0 {
+		startTime = s.oldEvents[0].Timestamp.AsTime()
+	} else if len(s.newEvents) > 0 {
+		startTime = s.newEvents[0].Timestamp.AsTime()
 	}
 	return startTime
 }

tests/runtimestate_test.go

@@ -508,6 +508,18 @@ func Test_DuplicateOutgoingEvents(t *testing.T) {
 
 func Test_SetFailed(t *testing.T) {
 	errFailure := errors.New("you got terminated")
+	t.Run("Pending", func(t *testing.T) {
+		s := backend.NewOrchestrationRuntimeState("abc", []*protos.HistoryEvent{})
+		assert.NotEqual(t, protos.OrchestrationStatus_ORCHESTRATION_STATUS_FAILED, s.RuntimeStatus())
+		s.SetFailed(errFailure)
+		s.ProcessChanges(defaultChunkingConfig, nil, logger)
+		require.True(t, s.IsValid())
+		assert.Equal(t, protos.OrchestrationStatus_ORCHESTRATION_STATUS_FAILED, s.RuntimeStatus())
+		failureDetails, err := s.FailureDetails()
+		require.NoError(t, err)
+		assert.Equal(t, errFailure.Error(), failureDetails.ErrorMessage)
+	})
+
 	t.Run("Running", func(t *testing.T) {
 		s := backend.NewOrchestrationRuntimeState("abc", []*protos.HistoryEvent{
 			helpers.NewExecutionStartedEvent("MyOrchestration", "abc", nil, nil, nil),