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
245 lines
9.8 KiB
Go
245 lines
9.8 KiB
Go
// Package rules is the checker's judging rules, the checking program's: given the facts of one check (what the build
|
|
// modules, the manifest validator and the composer answered, and what failed in the asking), the verdict (novox/hq ADR
|
|
// 0644, ADR 0656; design 47's bootstrap delivery). The running checker asks, waits, keeps and records; it gathers the
|
|
// facts and has them judged by the checking program built from the change's heads (cmd/mesh-checking-program), which
|
|
// imports this package, so a change to a rule is judged by its own rule.
|
|
//
|
|
// It is the checker module's own package (novox/hq ADR 0634 §1): no seat carries it and no other module imports it.
|
|
package rules
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"path"
|
|
"sort"
|
|
|
|
"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-builder/buildrun"
|
|
"git.novox.be/novox/mesh-sdk/go/delivery"
|
|
)
|
|
|
|
// FactsVersion is the version of Facts this program reads. A checking program built from a later change reads the facts
|
|
// a running checker of this version writes, so a version is added to, never changed; a program refuses one it does not
|
|
// read, naming it (DecodeFacts).
|
|
const FactsVersion = 1
|
|
|
|
// Facts are everything one check judges, in the order the running checker met it.
|
|
type Facts struct {
|
|
V int `json:"v"`
|
|
// Group and Heads name the check (delivery.Verdict's Group and Heads); Trunk is each repository's trunk head merged.
|
|
Group string `json:"group"`
|
|
Heads string `json:"heads"`
|
|
Trunk map[string]string `json:"trunk,omitempty"`
|
|
Members []Member `json:"members"`
|
|
// Steps are, in the order met, each level a build module answered and each failure the asking met.
|
|
Steps []Step `json:"steps,omitempty"`
|
|
// CloneMS is how much of the steps' time their levels' running did not take (delivery.Took.Clone).
|
|
CloneMS int64 `json:"clone-ms,omitempty"`
|
|
// Composition is how the check composed, after every step; nil when it was not composed (a narrowed try, a checker
|
|
// that composes nothing): its composition is then not run, unsaid.
|
|
Composition *Composition `json:"composition,omitempty"`
|
|
// Notes are the running checker's notes of the check, for a reader.
|
|
Notes []string `json:"notes,omitempty"`
|
|
}
|
|
|
|
// Member is one pull request of the check.
|
|
type Member struct {
|
|
Repository string `json:"repository"`
|
|
Number int `json:"number"`
|
|
Head string `json:"head"`
|
|
Trunk string `json:"trunk,omitempty"`
|
|
}
|
|
|
|
// Step is one fact of the check, in the order met: the node that ran it, and one of a level its build module answered
|
|
// (Level, as the build module gave it), what its fetch read of compiled programs (Programs), the manifest validator's
|
|
// answers (Manifests) or a failure the asking met (Failed: a step not asked, refused or not answered, a conflict, worded
|
|
// by the running checker). A step with none only says which node ran it.
|
|
type Step struct {
|
|
Repository string `json:"repository"`
|
|
Number int `json:"number"`
|
|
Module string `json:"module,omitempty"`
|
|
Node string `json:"node,omitempty"`
|
|
Level *delivery.LevelAnswer `json:"level,omitempty"`
|
|
Failed *delivery.FailedFirst `json:"failed,omitempty"`
|
|
Programs *Programs `json:"programs,omitempty"`
|
|
Manifests *Manifests `json:"manifests,omitempty"`
|
|
}
|
|
|
|
// DecodeFacts reads facts, refusing a version this program does not read, naming it.
|
|
func DecodeFacts(data []byte) (Facts, error) {
|
|
var f Facts
|
|
if err := json.Unmarshal(data, &f); err != nil {
|
|
return Facts{}, fmt.Errorf("rules: the facts are not JSON of their shape: %w", err)
|
|
}
|
|
if f.V != FactsVersion {
|
|
return Facts{}, fmt.Errorf("rules: facts of version %d, this checking program reads version %d", f.V, FactsVersion)
|
|
}
|
|
return f, nil
|
|
}
|
|
|
|
// Counts are one level's counts across a check's members.
|
|
type Counts struct {
|
|
Run, Kept, Skipped int
|
|
Elapsed, Setup float64
|
|
Lint float64
|
|
Over bool
|
|
Slowest []TestTime
|
|
}
|
|
|
|
// Tally is a check's counts by level.
|
|
type Tally map[string]*Counts
|
|
|
|
// NewTally is a tally of both levels, at nothing.
|
|
func NewTally() Tally {
|
|
return Tally{delivery.LevelUnit: {}, delivery.LevelIntegration: {}}
|
|
}
|
|
|
|
// Level judges one level of a member's check step as it was answered: the kept ones taken are counted, and every test
|
|
// result is read and counted, also after one that did not pass, so the verdict names every failed test of the level
|
|
// (issue 1921). It answers the level's failure (nil when it passed), its running time (its tests' and setup's) and the
|
|
// results read, for the running checker to keep the passes from.
|
|
func (t Tally) Level(repository string, number int, module, node string, la delivery.LevelAnswer) (*delivery.Verdict, float64, []Tested) {
|
|
a := t[la.Level]
|
|
if a == nil {
|
|
return failAt(node, fmt.Sprintf("the check of %s#%d answered the level %q, which is no level", repository, number, la.Level)), 0, nil
|
|
}
|
|
for _, k := range la.Kept {
|
|
a.Kept += k.Tests
|
|
}
|
|
elapsed := 0.0
|
|
var results, failed []Tested
|
|
for _, raw := range la.Tests {
|
|
var res Tested
|
|
if err := json.Unmarshal(raw, &res); err != nil {
|
|
return failAt(node, fmt.Sprintf("the %s level of %s#%d answered what is not a result: %v", la.Level, repository, number, err)), elapsed, results
|
|
}
|
|
results = append(results, res)
|
|
elapsed += res.Elapsed + res.Setup + res.Lint
|
|
if module == buildrun.NodeBuildModule {
|
|
if !res.NoTests {
|
|
a.Run++ // a Node package is counted whole: its build module counts no tests (ADR 0484 clause 10)
|
|
}
|
|
} else {
|
|
a.Run += res.Tests
|
|
a.Skipped += res.Skipped
|
|
a.Slowest = append(a.Slowest, res.Slowest...)
|
|
}
|
|
a.Elapsed += res.Elapsed
|
|
a.Setup += res.Setup
|
|
a.Lint += res.Lint
|
|
a.Over = a.Over || res.OverBound
|
|
if !res.Passed {
|
|
failed = append(failed, res)
|
|
}
|
|
}
|
|
if len(failed) > 0 {
|
|
return LevelFailure(repository, module, la.Level, failed...), elapsed, results
|
|
}
|
|
return nil, elapsed, results
|
|
}
|
|
|
|
// Judge is the verdict of the facts (Judged without its notes).
|
|
func Judge(f Facts) delivery.Verdict { return Judged(f).Verdict }
|
|
|
|
// Judged is the answer of the facts: every failure in the order met, joined and settled, or a pass; the levels'
|
|
// counts, times, machines and the levels over their bound; then the composition taken in; and the notes the rules give
|
|
// a reader (the manifest validator's warnings and acceptances).
|
|
func Judged(f Facts) Answer {
|
|
var notes []string
|
|
tally := NewTally()
|
|
var failures []*delivery.Verdict
|
|
nodes := map[string]bool{}
|
|
for _, s := range f.Steps {
|
|
if s.Node != "" {
|
|
nodes[s.Node] = true
|
|
}
|
|
switch {
|
|
case s.Failed != nil:
|
|
failures = append(failures, &delivery.Verdict{State: delivery.VerdictFail, Failed: *s.Failed})
|
|
case s.Level != nil:
|
|
if v, _, _ := tally.Level(s.Repository, s.Number, s.Module, s.Node, *s.Level); v != nil {
|
|
failures = append(failures, v)
|
|
}
|
|
case s.Programs != nil:
|
|
if ff := JudgePrograms(s.Node, *s.Programs); ff != nil {
|
|
failures = append(failures, &delivery.Verdict{State: delivery.VerdictFail, Failed: *ff})
|
|
}
|
|
case s.Manifests != nil:
|
|
ff, said := JudgeManifests(*s.Manifests)
|
|
notes = append(notes, said...)
|
|
if ff != nil {
|
|
failures = append(failures, &delivery.Verdict{State: delivery.VerdictFail, Failed: *ff})
|
|
}
|
|
}
|
|
}
|
|
v := delivery.Verdict{State: delivery.VerdictPass}
|
|
if joined := Settled(JoinFailures(failures...)); joined != nil {
|
|
v = *joined
|
|
}
|
|
v.Group, v.Heads, v.Trunk = f.Group, f.Heads, f.Trunk
|
|
Outcome(&v, tally, f.CloneMS, nodes)
|
|
if f.Composition != nil {
|
|
JudgeComposition(&v, *f.Composition)
|
|
}
|
|
return Answer{V: AnswerVersion, Verdict: v, Notes: notes}
|
|
}
|
|
|
|
// Outcome fills a verdict's levels (on a pass, or when it names none), times, machines and levels over their bound from
|
|
// the tally, and says its composition is not yet run (ADR 0484 clause 6).
|
|
func Outcome(v *delivery.Verdict, tally Tally, cloneMS int64, nodes map[string]bool) {
|
|
if v.State == delivery.VerdictPass || len(v.Levels) == 0 {
|
|
v.Levels = map[string]delivery.LevelResult{}
|
|
for level, a := range tally {
|
|
v.Levels[level] = delivery.LevelResult{Run: a.Run, Kept: a.Kept, Skipped: a.Skipped}
|
|
}
|
|
}
|
|
ms := func(s float64) int64 { return int64(s * 1000) }
|
|
u, i := tally[delivery.LevelUnit], tally[delivery.LevelIntegration]
|
|
v.Took = delivery.Took{Clone: cloneMS, Unit: ms(u.Elapsed), Lint: ms(u.Lint), IntegrationSetup: ms(i.Setup), IntegrationRun: ms(i.Elapsed)}
|
|
v.Machines = nil
|
|
for node := range nodes {
|
|
v.Machines = append(v.Machines, node)
|
|
}
|
|
sort.Strings(v.Machines)
|
|
v.OverBound = nil
|
|
for _, level := range []string{delivery.LevelUnit, delivery.LevelIntegration} {
|
|
if tally[level].Over {
|
|
v.OverBound = append(v.OverBound, level)
|
|
}
|
|
}
|
|
v.Composition = &delivery.Composition{State: delivery.CompositionNotRun}
|
|
}
|
|
|
|
// Slowest are, of each level over its bound, its three slowest tests, worded for the status line.
|
|
func Slowest(tally Tally) []string {
|
|
var slow []string
|
|
for _, level := range []string{delivery.LevelUnit, delivery.LevelIntegration} {
|
|
a := tally[level]
|
|
if !a.Over {
|
|
continue
|
|
}
|
|
sort.SliceStable(a.Slowest, func(x, y int) bool { return a.Slowest[x].Elapsed > a.Slowest[y].Elapsed })
|
|
for n, s := range a.Slowest {
|
|
if n == 3 {
|
|
break
|
|
}
|
|
slow = append(slow, fmt.Sprintf("%s %s %.1fs", level, path.Base(s.Package)+"."+s.Test, s.Elapsed))
|
|
}
|
|
}
|
|
return slow
|
|
}
|
|
|
|
func failAt(machine, words string) *delivery.Verdict {
|
|
return &delivery.Verdict{State: delivery.VerdictFail, Failed: delivery.FailedFirst{Machine: machine, Words: words}}
|
|
}
|
|
|
|
// AnswerVersion is the version of Answer this program writes.
|
|
const AnswerVersion = 1
|
|
|
|
// Answer is what the checking program answers on the last line of its standard output: its version, the verdict and the
|
|
// notes its rules give a reader of the check.
|
|
type Answer struct {
|
|
V int `json:"v"`
|
|
Verdict delivery.Verdict `json:"verdict"`
|
|
Notes []string `json:"notes,omitempty"`
|
|
}
|