jschoubben
e96f8fd1b6
The running checker records the manifest validator's cases, each fetch's programs and the engines' answers as facts, and the rules package judges them, with the notes it gives a reader, so the checking program judges every rule the running checker judged. The module graph's cycle stays with the asking: its facts are whole manifests, over a run's input bound; G's program reads them from the heads. Claude-Session: https://claude.ai/code/session_01NcbgfFSnn24M3GcqttoU7i
77 lines
3.1 KiB
Go
77 lines
3.1 KiB
Go
package check
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"maps"
|
|
"slices"
|
|
"strings"
|
|
|
|
"git.novox.be/novox/mesh-sdk/go/catalogue"
|
|
"git.novox.be/novox/mesh-sdk/go/composer"
|
|
|
|
"git.novox.be/novox/mesh-delivery/sdk/graph"
|
|
)
|
|
|
|
// The check refuses a change whose module graph has a cycle and names it (novox/hq ADR 0603 §2): modules that would each
|
|
// wait for the other for good, through their bases, the provisions and bus state they await, or the verb edges the graph
|
|
// keeps (ADR 0614 §6). A verb edge on a cycle is left out of the graph, so it is never refused (§3), and a package or a
|
|
// build module's edge is a trigger, never a wait, so a cycle through one is not refused either (§6). The graph is worked out from the
|
|
// catalogue as the change leaves it (every trunk manifest, each one a pull request touches replaced by its candidate's),
|
|
// with the contract's ManifestGraph, the way the indexer works out its graph's edges. A cycle the trunk already has among
|
|
// the same modules is the trunk's: said in the verdict's notes, not the change's failure.
|
|
|
|
// ManifestReader reads a kept manifest by its digest (the indexer's manifests state).
|
|
type ManifestReader interface {
|
|
Manifest(ctx context.Context, digest string) (catalogue.Manifest, error)
|
|
}
|
|
|
|
// refuseCycle fails the check for a cycle of the change's module graph, naming it; nil when the case touches no manifest,
|
|
// when nothing reads manifests, or when there is none. A manifest that cannot be read fails the check, said, never passes it.
|
|
func (st *state) refuseCycle(ctx context.Context) {
|
|
if st.j.Manifests == nil || st.j.Read == nil || st.narrowTry() {
|
|
return
|
|
}
|
|
trunk := st.j.Manifests.ManifestDigests()
|
|
req, touched := judgeRequest(trunk, st.c.Pulls)
|
|
if len(touched) == 0 {
|
|
return
|
|
}
|
|
read := func(digests map[string]composer.Manifest) (map[string]catalogue.Manifest, error) {
|
|
out := map[string]catalogue.Manifest{}
|
|
for _, module := range slices.Sorted(maps.Keys(digests)) {
|
|
m, err := st.j.Read.Manifest(ctx, digests[module].Digest)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("the manifest %s of %s: %w", digests[module].Digest, module, err)
|
|
}
|
|
out[module] = m
|
|
}
|
|
return out, nil
|
|
}
|
|
change, err := read(req.Cases[0].Manifests)
|
|
if err != nil {
|
|
st.fail(goModule, "the change's module graph cannot be worked out, so no cycle can be ruled out: "+err.Error())
|
|
return
|
|
}
|
|
cycle := graph.OfManifests(change).Cycle()
|
|
if cycle == nil {
|
|
st.c.note("the change's module graph has no cycle")
|
|
return
|
|
}
|
|
words := strings.Join(cycle, " -> ")
|
|
if before, err := read(req.Cases[1].Manifests); err == nil {
|
|
among := graph.Graph{}
|
|
for name, n := range graph.OfManifests(before) {
|
|
if slices.Contains(cycle, name) {
|
|
among[name] = n
|
|
}
|
|
}
|
|
if among.Cycle() != nil {
|
|
st.c.note("the module graph has the cycle " + words + ", which the trunk already has among the same modules (ADR 0603 §2)")
|
|
return
|
|
}
|
|
}
|
|
st.fail(goModule, fmt.Sprintf("the change's module graph has the cycle %s: these modules would each wait for the other for "+
|
|
"good, through their bases, the provisions and bus state they await, or the verbs they invoke (ADR 0603 §2, ADR 0614 §6)", words))
|
|
}
|