feat(engine): run modules through Detect/Plan/Apply/Verify with DAG + skip-on-failure
This commit is contained in:
MDietermann
189
internal/engine/engine.go
Normal file
189
internal/engine/engine.go
Normal file
@@ -0,0 +1,189 @@
|
|||||||
|
package engine
|
||||||
|
|
||||||
|
import (
|
||||||
|
"context"
|
||||||
|
"errors"
|
||||||
|
"fmt"
|
||||||
|
"sort"
|
||||||
|
|
||||||
|
"github.com/MDietermann/ArduinoArchSetup/internal/module"
|
||||||
|
)
|
||||||
|
|
||||||
|
// RunOptions controls a single engine run.
|
||||||
|
type RunOptions struct {
|
||||||
|
Selected []string // module IDs to run; empty = all
|
||||||
|
DryRun bool // Detect + Plan only, no Apply/Verify
|
||||||
|
HaltOnError bool // stop at first failure instead of continuing siblings
|
||||||
|
Reporter module.Reporter
|
||||||
|
}
|
||||||
|
|
||||||
|
// ModuleStatus is the terminal state of a module within a run.
|
||||||
|
type ModuleStatus string
|
||||||
|
|
||||||
|
const (
|
||||||
|
StatusSucceeded ModuleStatus = "succeeded"
|
||||||
|
StatusFailed ModuleStatus = "failed"
|
||||||
|
StatusSkipped ModuleStatus = "skipped"
|
||||||
|
StatusPlanned ModuleStatus = "planned" // dry-run only
|
||||||
|
)
|
||||||
|
|
||||||
|
// ModuleResult captures what happened for one module.
|
||||||
|
type ModuleResult struct {
|
||||||
|
ID string
|
||||||
|
Status ModuleStatus
|
||||||
|
Plan module.Plan
|
||||||
|
Err error
|
||||||
|
}
|
||||||
|
|
||||||
|
// Summary aggregates results.
|
||||||
|
type Summary struct {
|
||||||
|
Results []ModuleResult
|
||||||
|
}
|
||||||
|
|
||||||
|
// Counts returns (succeeded, failed, skipped).
|
||||||
|
func (s Summary) Counts() (int, int, int) {
|
||||||
|
var ok, fail, skip int
|
||||||
|
for _, r := range s.Results {
|
||||||
|
switch r.Status {
|
||||||
|
case StatusSucceeded, StatusPlanned:
|
||||||
|
ok++
|
||||||
|
case StatusFailed:
|
||||||
|
fail++
|
||||||
|
case StatusSkipped:
|
||||||
|
skip++
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return ok, fail, skip
|
||||||
|
}
|
||||||
|
|
||||||
|
// Run drives the selected modules through the four phases in DAG order.
|
||||||
|
// Parallelism is intentionally omitted in this foundation; a later plan
|
||||||
|
// will introduce it. Sequential execution is a correct baseline.
|
||||||
|
func Run(ctx context.Context, reg *module.Registry, opts RunOptions) (Summary, error) {
|
||||||
|
mods, err := resolveSelection(reg, opts.Selected)
|
||||||
|
if err != nil {
|
||||||
|
return Summary{}, err
|
||||||
|
}
|
||||||
|
|
||||||
|
metas := make([]module.Meta, 0, len(mods))
|
||||||
|
for _, m := range mods {
|
||||||
|
metas = append(metas, m.Meta())
|
||||||
|
}
|
||||||
|
order, err := TopoSort(metas)
|
||||||
|
if err != nil {
|
||||||
|
return Summary{}, fmt.Errorf("module graph: %w", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
byID := make(map[string]module.Module, len(mods))
|
||||||
|
for _, m := range mods {
|
||||||
|
byID[m.Meta().ID] = m
|
||||||
|
}
|
||||||
|
|
||||||
|
results := make(map[string]*ModuleResult, len(mods))
|
||||||
|
failed := make(map[string]bool)
|
||||||
|
skipped := make(map[string]bool)
|
||||||
|
|
||||||
|
for _, id := range order {
|
||||||
|
if skipped[id] {
|
||||||
|
results[id] = &ModuleResult{ID: id, Status: StatusSkipped, Err: errors.New("skipped: upstream failed")}
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
m := byID[id]
|
||||||
|
res := &ModuleResult{ID: id}
|
||||||
|
results[id] = res
|
||||||
|
|
||||||
|
state, err := m.Detect(ctx)
|
||||||
|
if err != nil {
|
||||||
|
res.Status = StatusFailed
|
||||||
|
res.Err = fmt.Errorf("detect: %w", err)
|
||||||
|
markFailed(metas, id, failed, skipped)
|
||||||
|
if opts.HaltOnError {
|
||||||
|
break
|
||||||
|
}
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
|
||||||
|
plan, err := m.Plan(ctx, state)
|
||||||
|
if err != nil {
|
||||||
|
res.Status = StatusFailed
|
||||||
|
res.Err = fmt.Errorf("plan: %w", err)
|
||||||
|
markFailed(metas, id, failed, skipped)
|
||||||
|
if opts.HaltOnError {
|
||||||
|
break
|
||||||
|
}
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
res.Plan = plan
|
||||||
|
|
||||||
|
if opts.DryRun {
|
||||||
|
res.Status = StatusPlanned
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
|
||||||
|
if err := m.Apply(ctx, plan, opts.Reporter); err != nil {
|
||||||
|
res.Status = StatusFailed
|
||||||
|
res.Err = fmt.Errorf("apply: %w", err)
|
||||||
|
markFailed(metas, id, failed, skipped)
|
||||||
|
if opts.HaltOnError {
|
||||||
|
break
|
||||||
|
}
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if err := m.Verify(ctx); err != nil {
|
||||||
|
res.Status = StatusFailed
|
||||||
|
res.Err = fmt.Errorf("verify: %w", err)
|
||||||
|
markFailed(metas, id, failed, skipped)
|
||||||
|
if opts.HaltOnError {
|
||||||
|
break
|
||||||
|
}
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
res.Status = StatusSucceeded
|
||||||
|
}
|
||||||
|
|
||||||
|
summary := Summary{}
|
||||||
|
// Emit results in topo order for stable output.
|
||||||
|
ids := make([]string, 0, len(results))
|
||||||
|
for id := range results {
|
||||||
|
ids = append(ids, id)
|
||||||
|
}
|
||||||
|
sort.SliceStable(ids, func(i, j int) bool {
|
||||||
|
return indexOf(order, ids[i]) < indexOf(order, ids[j])
|
||||||
|
})
|
||||||
|
for _, id := range ids {
|
||||||
|
summary.Results = append(summary.Results, *results[id])
|
||||||
|
}
|
||||||
|
return summary, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func resolveSelection(reg *module.Registry, selected []string) ([]module.Module, error) {
|
||||||
|
all := reg.All()
|
||||||
|
if len(selected) == 0 {
|
||||||
|
return all, nil
|
||||||
|
}
|
||||||
|
out := make([]module.Module, 0, len(selected))
|
||||||
|
for _, id := range selected {
|
||||||
|
m, ok := reg.Get(id)
|
||||||
|
if !ok {
|
||||||
|
return nil, fmt.Errorf("unknown module %q", id)
|
||||||
|
}
|
||||||
|
out = append(out, m)
|
||||||
|
}
|
||||||
|
return out, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func markFailed(metas []module.Meta, id string, failed, skipped map[string]bool) {
|
||||||
|
failed[id] = true
|
||||||
|
for d := range Descendants(metas, id) {
|
||||||
|
skipped[d] = true
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func indexOf(s []string, v string) int {
|
||||||
|
for i, x := range s {
|
||||||
|
if x == v {
|
||||||
|
return i
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return -1
|
||||||
|
}
|
||||||
146
internal/engine/engine_test.go
Normal file
146
internal/engine/engine_test.go
Normal file
@@ -0,0 +1,146 @@
|
|||||||
|
package engine
|
||||||
|
|
||||||
|
import (
|
||||||
|
"context"
|
||||||
|
"errors"
|
||||||
|
"testing"
|
||||||
|
|
||||||
|
"github.com/MDietermann/ArduinoArchSetup/internal/module"
|
||||||
|
)
|
||||||
|
|
||||||
|
// scriptedModule lets tests control what each phase returns.
|
||||||
|
type scriptedModule struct {
|
||||||
|
id string
|
||||||
|
deps []string
|
||||||
|
detect func() (module.State, error)
|
||||||
|
plan func() (module.Plan, error)
|
||||||
|
apply func() error
|
||||||
|
verify func() error
|
||||||
|
}
|
||||||
|
|
||||||
|
func (s scriptedModule) Meta() module.Meta { return module.Meta{ID: s.id, Name: s.id, Deps: s.deps} }
|
||||||
|
func (s scriptedModule) Detect(ctx context.Context) (module.State, error) {
|
||||||
|
if s.detect != nil {
|
||||||
|
return s.detect()
|
||||||
|
}
|
||||||
|
return nil, nil
|
||||||
|
}
|
||||||
|
func (s scriptedModule) Plan(ctx context.Context, _ module.State) (module.Plan, error) {
|
||||||
|
if s.plan != nil {
|
||||||
|
return s.plan()
|
||||||
|
}
|
||||||
|
return module.Plan{}, nil
|
||||||
|
}
|
||||||
|
func (s scriptedModule) Apply(ctx context.Context, _ module.Plan, _ module.Reporter) error {
|
||||||
|
if s.apply != nil {
|
||||||
|
return s.apply()
|
||||||
|
}
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
func (s scriptedModule) Verify(ctx context.Context) error {
|
||||||
|
if s.verify != nil {
|
||||||
|
return s.verify()
|
||||||
|
}
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func newReg(t *testing.T, mods ...module.Module) *module.Registry {
|
||||||
|
t.Helper()
|
||||||
|
r := module.NewRegistry()
|
||||||
|
for _, m := range mods {
|
||||||
|
if err := r.Register(m); err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return r
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestRunAllSucceed(t *testing.T) {
|
||||||
|
reg := newReg(t,
|
||||||
|
scriptedModule{id: "a"},
|
||||||
|
scriptedModule{id: "b", deps: []string{"a"}},
|
||||||
|
)
|
||||||
|
sum, err := Run(context.Background(), reg, RunOptions{Reporter: NewBufferedReporter()})
|
||||||
|
if err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
ok, fail, skip := sum.Counts()
|
||||||
|
if ok != 2 || fail != 0 || skip != 0 {
|
||||||
|
t.Fatalf("counts = (%d,%d,%d)", ok, fail, skip)
|
||||||
|
}
|
||||||
|
if sum.Results[0].ID != "a" || sum.Results[1].ID != "b" {
|
||||||
|
t.Fatalf("order = %v", sum.Results)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestRunDryRunDoesNotApply(t *testing.T) {
|
||||||
|
applied := false
|
||||||
|
reg := newReg(t, scriptedModule{
|
||||||
|
id: "a",
|
||||||
|
apply: func() error { applied = true; return nil },
|
||||||
|
})
|
||||||
|
sum, err := Run(context.Background(), reg, RunOptions{DryRun: true, Reporter: NewBufferedReporter()})
|
||||||
|
if err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
if applied {
|
||||||
|
t.Fatal("Apply was called during dry-run")
|
||||||
|
}
|
||||||
|
if sum.Results[0].Status != StatusPlanned {
|
||||||
|
t.Fatalf("status = %v", sum.Results[0].Status)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestRunFailureSkipsDescendantsContinuesSiblings(t *testing.T) {
|
||||||
|
reg := newReg(t,
|
||||||
|
scriptedModule{id: "root"},
|
||||||
|
scriptedModule{id: "fails", deps: []string{"root"}, apply: func() error { return errors.New("boom") }},
|
||||||
|
scriptedModule{id: "child", deps: []string{"fails"}},
|
||||||
|
scriptedModule{id: "sibling", deps: []string{"root"}},
|
||||||
|
)
|
||||||
|
sum, err := Run(context.Background(), reg, RunOptions{Reporter: NewBufferedReporter()})
|
||||||
|
if err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
status := map[string]ModuleStatus{}
|
||||||
|
for _, r := range sum.Results {
|
||||||
|
status[r.ID] = r.Status
|
||||||
|
}
|
||||||
|
if status["root"] != StatusSucceeded {
|
||||||
|
t.Errorf("root = %v", status["root"])
|
||||||
|
}
|
||||||
|
if status["fails"] != StatusFailed {
|
||||||
|
t.Errorf("fails = %v", status["fails"])
|
||||||
|
}
|
||||||
|
if status["child"] != StatusSkipped {
|
||||||
|
t.Errorf("child = %v", status["child"])
|
||||||
|
}
|
||||||
|
if status["sibling"] != StatusSucceeded {
|
||||||
|
t.Errorf("sibling = %v (should have run)", status["sibling"])
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestRunHaltOnError(t *testing.T) {
|
||||||
|
reg := newReg(t,
|
||||||
|
scriptedModule{id: "a", apply: func() error { return errors.New("nope") }},
|
||||||
|
scriptedModule{id: "b"}, // independent
|
||||||
|
)
|
||||||
|
sum, err := Run(context.Background(), reg, RunOptions{HaltOnError: true, Reporter: NewBufferedReporter()})
|
||||||
|
if err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
// "b" should not appear in results because we halted before reaching it.
|
||||||
|
for _, r := range sum.Results {
|
||||||
|
if r.ID == "b" {
|
||||||
|
t.Fatalf("b was run despite HaltOnError")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestRunUnknownModule(t *testing.T) {
|
||||||
|
reg := module.NewRegistry()
|
||||||
|
_, err := Run(context.Background(), reg, RunOptions{Selected: []string{"ghost"}})
|
||||||
|
if err == nil {
|
||||||
|
t.Fatal("expected error for unknown module")
|
||||||
|
}
|
||||||
|
}
|
||||||
Reference in New Issue
Block a user