Method RecoverTaskRun

internal/task/manager_test.go:1507–1560

(
	_ context.Context,
	mutation RecoverRunMutation,
)

}

func (s *inMemoryManagerStore) RecoverTaskRun(
	_ context.Context,
	mutation RecoverRunMutation,
) (RetryRunResult, error) {
	source, ok := s.runs[strings.TrimSpace(mutation.SourceRunID)]
	if !ok {
		return RetryRunResult{}, ErrTaskRunNotFound
	}
	if source.Status.Normalize() != TaskRunStatusNeedsAttention {
		return RetryRunResult{}, ErrInvalidStatusTransition
	}
	for _, run := range s.runs {
		if strings.TrimSpace(run.PreviousRunID) == source.ID {
			return RetryRunResult{}, ErrInvalidStatusTransition
		}
	}
	taskRecord, ok := s.tasks[source.TaskID]
	if !ok {
		return RetryRunResult{}, ErrTaskNotFound
	}
	attempt := 1
	for _, run := range s.runs {
		if run.TaskID == source.TaskID && run.Attempt >= attempt {
			attempt = run.Attempt + 1
		}
	}
	if attempt > taskRecord.MaxAttempts {
		return RetryRunResult{}, ErrInvalidStatusTransition
	}
	queuedAt := mutation.QueuedAt.UTC()
	if queuedAt.IsZero() {
		queuedAt = time.Now().UTC()
	}
	failed := source
	failed.Status = TaskRunStatusFailed
	failed.FailureKind = FailureKindOperatorForced
	failed.Error = strings.TrimSpace(mutation.Reason)
	failed.EndedAt = queuedAt
	s.runs[failed.ID] = cloneTaskRun(failed)
	run := Run{
		ID:                    strings.TrimSpace(mutation.NewRunID),
		TaskID:                source.TaskID,
		Status:                TaskRunStatusQueued,
		Attempt:               attempt,
		PreviousRunID:         source.ID,
		Origin:                mutation.Origin,
		NetworkChannel:        source.NetworkChannel,
		CoordinationChannelID: source.CoordinationChannelID,
		Metadata:              cloneRawJSON(mutation.Metadata),
		QueuedAt:              queuedAt,
	}
	s.runs[run.ID] = cloneTaskRun(run)
	return RetryRunResult{PreviousRun: cloneTaskRun(failed), Run: cloneTaskRun(run)}, nil
}

func (s *inMemoryManagerStore) MarkTaskRunNeedsAttention(
	_ context.Context,