Rewrite/dag runner

[Tanker2020]

Summary

Ports the Python oper8 DAG execution engine to Go as the first package in the github.com/example/oper8-go module (rewrite/). This is a standalone package with no dependencies on other rewrite PRs — it can be reviewed and merged independently.

Files changed:

• rewrite/dag/node.go — Node, ResourceNode
• rewrite/dag/graph.go — Graph
• rewrite/dag/completion_state.go — CompletionState, HaltError
• rewrite/dag/runner.go — Runner (serial + concurrent modes)
• rewrite/dag/runner_test.go — 23 table-driven tests
• rewrite/go.mod — module root, go 1.23
• .github/workflows/pr1-dag-runner.yml — CI

---

What was ported

Python	Go equivalent
dag/node.py — Node, ResourceNode	dag/node.go
dag/graph.py — Graph	dag/graph.go
dag/completion_state.py — CompletionState	dag/completion_state.go
dag/runner.py — Runner, DagHaltError, NonThreadPoolExecutor	dag/runner.go

---

Design decisions

ThreadPoolExecutor + sleep-poll → goroutines + buffered channel

Python's Runner submits nodes to a ThreadPoolExecutor and busy-polls with time.sleep(poll_time) to check completion. Go replaces this entirely with a scheduler loop that reads from a buffered chan nodeResult. Nodes post their result when done; the scheduler wakes only when there is actual work — zero busy-polling.

DagHaltError → HaltError struct

Python used DagHaltError(failure=True/False, exception=...). Go uses *HaltError{Fatal bool, Cause error}. The Fatal field maps directly to Python's failure field. Any non-HaltError returned from a NodeFunc is automatically wrapped as a fatal halt (matches Python's bare except Exception handler).

(bool, bool) returns → (changed bool, err error)

Python returned (success, changed) tuples throughout. Go uses the idiomatic (result, error) pattern. Callers use if err != nil instead of checking two booleans.

Serial mode (concurrency=0) bug fix

Python's NonThreadPoolExecutor ran nodes synchronously but the loop breaked on a fatal error, meaning independent branches of the graph would never run. The Go serial runner uses continue instead — a failed node marks its dependents Unstarted but independent nodes still execute. This matches the intended concurrent behaviour.

CompletionState.all_nodes removed

Python computed all_nodes as the union of all four sets in __init__. Go omits this field — all_nodes is always derivable as len(Verified) + len(Unverified) + len(Failed) + len(Unstarted) and the component-status formatter computes it inline. Removing it eliminates a redundant field that could become inconsistent.

EdgeFunc / verify_upstream

Python's _dependency_satisfied checked verify_fn() per-edge to gate dependent execution. Go preserves this exactly via EdgeFunc on each edge. The WithVerifyUpstream(false) option disables all edge checks, matching Python's verify_upstream=False.

---

Test coverage (23 tests)

Area	Tests
Graph construction	empty graph, duplicate node, empty name, cycle detection, self-loop, topology order, String()
Serial runner	all succeed, empty graph, fatal halt + independent branch still runs, unverified halt, disabled node, execution order
Concurrent runner	all succeed, fatal halt, independent nodes run in parallel (timing assertion), race detector (20 nodes), context cancellation
EdgeFunc	blocks dependent, allows dependent
CompletionState predicates	DeployCompleted, VerifyCompleted, AnyFailed
ResourceNode	construction, DeployMethod default

All tests run with -race.