Method RetryTaskRun

internal/task/manager_test.go:1458–1505

(
	_ context.Context,
	retry RetryRunMutation,
)

}

func (s *inMemoryManagerStore) RetryTaskRun(
	_ context.Context,
	retry RetryRunMutation,
) (RetryRunResult, error) {
	source, ok := s.runs[strings.TrimSpace(retry.SourceRunID)]
	if !ok {
		return RetryRunResult{}, ErrTaskRunNotFound
	}
	if source.Status.Normalize() != TaskRunStatusFailed {
		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 := retry.QueuedAt.UTC()
	if queuedAt.IsZero() {
		queuedAt = time.Now().UTC()
	}
	run := Run{
		ID:                    strings.TrimSpace(retry.NewRunID),
		TaskID:                source.TaskID,
		Status:                TaskRunStatusQueued,
		Attempt:               attempt,
		PreviousRunID:         source.ID,
		Origin:                retry.Origin,
		NetworkChannel:        source.NetworkChannel,
		CoordinationChannelID: source.CoordinationChannelID,
		Metadata:              cloneRawJSON(retry.Metadata),
		QueuedAt:              queuedAt,
	}
	s.runs[run.ID] = cloneTaskRun(run)
	return RetryRunResult{PreviousRun: cloneTaskRun(source), Run: cloneTaskRun(run)}, nil
}

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