Method ForceFailRun

internal/task/force_ops.go:145–208

ForceFailRun marks one queued or claimed run failed without requiring the raw claim token.

(
	ctx context.Context,
	runID string,
	failure ForceFailRun,
	actor ActorContext,
)

// ForceFailRun marks one queued or claimed run failed without requiring the raw claim token.
func (m *Service) ForceFailRun(
	ctx context.Context,
	runID string,
	failure ForceFailRun,
	actor ActorContext,
) (*Run, error) {
	if err := m.requireForceRunAuthority(actor); err != nil {
		return nil, err
	}
	normalized, err := normalizeForceFailRun(failure)
	if err != nil {
		return nil, err
	}
	previous, taskRecord, err := m.loadRunWithTask(ctx, runID)
	if err != nil {
		return nil, err
	}
	if err := m.requireForceRunRate(actor, taskRecord.ID); err != nil {
		return nil, err
	}
	if err := requireForceFailStatus(previous); err != nil {
		return nil, err
	}

	mutation, err := m.store.ForceFailTaskRun(ctx, ForceFailRunMutation{
		RunID:  previous.ID,
		Reason: normalized.Reason,
		Now:    m.now().UTC(),
	})
	if err != nil {
		return nil, err
	}
	queueGeneration, canceledInputs, err := m.invalidateForceRunInputs(ctx, mutation.Previous)
	if err != nil {
		return nil, err
	}
	reconciledTask, err := m.reconcileTaskCascade(ctx, taskRecord.ID)
	if err != nil {
		return nil, err
	}
	if err := m.recordTaskEvent(
		ctx,
		mutation.Run.TaskID,
		mutation.Run.ID,
		taskEventRunOperatorForcedFail,
		actor,
		operatorForcedFailPayload{
			Manual:               true,
			ActorKind:            actor.Actor.Kind.Normalize(),
			ActorID:              actor.Actor.Ref,
			PreviousStatus:       mutation.Previous.Status,
			Status:               mutation.Run.Status,
			TaskStatus:           reconciledTask.Status,
			Reason:               normalized.Reason,
			SessionID:            mutation.Previous.SessionID,
			QueueGeneration:      queueGeneration,
			CanceledQueuedInputs: canceledInputs,
			Metadata:             cloneRawJSON(normalized.Metadata),