when.go

package steps

import "go.bigb.es/auxilia/legatus"

// When wraps a step with a precondition. Cond is evaluated in Check: when it is

// set and returns false the inner step is skipped (need=false); when it is nil or

// returns true, Check delegates to the inner step. Apply always delegates

// unchanged — When gates whether the step runs, never what it does.

type When struct {

	Cond func(*legatus.FlowCtx) bool

	Step legatus.Step

}

// Name returns the inner step's name, so logs, the reporter, and change tracking

// all key off the wrapped step.

func (w When) Name() string { return w.Step.Name() }

// Check skips (need=false) when Cond is set and false; otherwise it delegates to

// the inner step's Check.

func (w When) Check(fc *legatus.FlowCtx) (bool, error) {

	if w.Cond != nil && !w.Cond(fc) {

		return false, nil

	}

	return w.Step.Check(fc)

}

// Apply delegates to the inner step unchanged.

func (w When) Apply(fc *legatus.FlowCtx) (legatus.Outcome, error) {

	return w.Step.Apply(fc)

}

// OnChanged runs inner only if any of the watched earlier steps changed during

// this flow execution on this host — the restart-on-change pattern. Watch entries

// are step names, e.g. File{Path: p}.Name(). With no watch names it runs inner

// when any earlier step changed.

func OnChanged(inner legatus.Step, watch ...string) When {

	return When{

		Cond: func(fc *legatus.FlowCtx) bool { return fc.AnyChanged(watch...) },

		Step: inner,

	}

}