R9: validate comes before composition, one run per pipeline
Each mover gets a validate step on the seat mesh-wants before its composition, its status from the policy; one ask per pipeline that every mover's validate step reads (a mover placed later reads it, its result too). A mover's composition waits until validate ends: asked once it passed, ended not asked when it did not, so a manifest the validator refuses is never composed. The step runs name the runner's seat as their asker. Unit tests 81 to 82. Builds: design 47 H §745 (the runner's order); lead answers H-A-51, H-A-88 Claude-Session: https://claude.ai/code/session_01JG73KHUnBze48rdua8u2sy
This commit is contained in:
@@ -151,6 +151,7 @@ func run(ctx context.Context, getenv func(string) string, logOut io.Writer) erro
|
||||
Registration: rv.Registrations.Registration, Steps: busStepAsker{ctx: ctx, js: js, cred: cred}, Name: cred.Module,
|
||||
Kept: keptReader(ctx, kept), Toolchain: toolchainReader(ctx, toolchains),
|
||||
Fills: fills, Recovered: kvRecoveries{ctx, recovered}.Has, Holders: rv.Holders.Holders, Ended: hearer.EndedAtPlacing}
|
||||
hearer.AskSteps = starter.AskSteps
|
||||
placeHalf := func(ev catalog.CatalogRevisionEvent, half pipeline.Half) error {
|
||||
n, err := starter.PlaceRun(ev, half, rv.Catalog.View)
|
||||
logger.Printf("the candidate %s's revision %d placed %d pipelines of its run", ev.Group, ev.Revision, n)
|
||||
|
||||
@@ -88,7 +88,7 @@ func TestTheRunnerPlacesAPipelineAsksItsBuildTakesItsEndAndAnswersAReview(t *tes
|
||||
}
|
||||
|
||||
// The seats the runner calls, answered as their holders do.
|
||||
reg := catalog.Registration{Module: "app", Branches: []string{"main"}, Origin: "o/app", Policy: catalog.Policy{Steps: catalog.StepStatuses{Review: "optional", Composition: "bypass", Approval: "bypass"}}}
|
||||
reg := catalog.Registration{Module: "app", Branches: []string{"main"}, Origin: "o/app", Policy: catalog.Policy{Steps: catalog.StepStatuses{Review: "optional", Validate: "bypass", Composition: "bypass", Approval: "bypass"}}}
|
||||
answer := func(subject string, body any) {
|
||||
if _, err := nc.Subscribe(subject, func(m *nats.Msg) {
|
||||
raw, _ := json.Marshal(map[string]any{"result": body})
|
||||
|
||||
+1
-1
@@ -101,7 +101,7 @@ func TestTestRunsAreAskedOncePerLevelAndMoveEveryReader(t *testing.T) {
|
||||
|
||||
// The registrations: app tests its program and tools bundle from one directory, its unit step required and its
|
||||
// integration step optional; web is built by node-build-node.
|
||||
policy := catalog.Policy{Steps: catalog.StepStatuses{Lint: "bypass", Unit: "required", Integration: "optional", Composition: "bypass", Review: "bypass", Approval: "bypass"}}
|
||||
policy := catalog.Policy{Steps: catalog.StepStatuses{Lint: "bypass", Unit: "required", Integration: "optional", Validate: "bypass", Composition: "bypass", Review: "bypass", Approval: "bypass"}}
|
||||
regs := []catalog.Registration{{Module: "app", Branches: []string{"main"}, Origin: "o/app", Policy: policy},
|
||||
{Module: "web", Branches: []string{"main"}, Origin: "o/web", Policy: policy}}
|
||||
answer := func(subject string, body any) {
|
||||
|
||||
@@ -49,9 +49,9 @@ var acceptRecovery = map[string]string{
|
||||
// buildSteps are the steps an artifact's build seat runs, in the order they are asked (design 47 G §22).
|
||||
var buildSteps = []string{seat.StepResultStepLint, seat.StepResultStepUnit, seat.StepResultStepIntegration}
|
||||
|
||||
// moduleSteps are the steps of the whole module: composition (the assigner's), review (the runner's own verb) and the
|
||||
// approval, asked last (§22, §26).
|
||||
var moduleSteps = []string{seat.StepResultStepComposition, seat.StepResultStepReview, seat.StepResultStepApproval}
|
||||
// moduleSteps are the steps of the whole module: validate and composition (the assigner's, validate before composition,
|
||||
// design 47 H §745), review (the runner's own verb) and the approval, asked last (§22, §26).
|
||||
var moduleSteps = []string{seat.StepResultStepValidate, seat.StepResultStepComposition, seat.StepResultStepReview, seat.StepResultStepApproval}
|
||||
|
||||
// AskID is a step's ask id in the usual ask id form the holders accept (buildstep.CheckAskID): base 36 of started in
|
||||
// milliseconds, then six hex digits of the sha256 of the pipeline, the mover, the artifact and the step, so the same
|
||||
@@ -163,6 +163,7 @@ func place(p seat.Pipeline, m seat.Mover, reg catalog.Registration, entries map[
|
||||
asks = append(asks, ask)
|
||||
}
|
||||
}
|
||||
validating := false
|
||||
for _, step := range moduleSteps {
|
||||
status := Status(reg, "", step)
|
||||
if status == "" {
|
||||
@@ -171,17 +172,31 @@ func place(p seat.Pipeline, m seat.Mover, reg catalog.Registration, entries map[
|
||||
s := seat.StepResult{Step: step, Module: m.Module, Status: status, Outcome: seat.StepResultOutcomeWaiting}
|
||||
if status == seat.StepResultStatusBypass {
|
||||
s.Outcome, s.Why = seat.StepResultOutcomeBypassed, "bypassed by the module's policy"
|
||||
steps = append(steps, s)
|
||||
continue
|
||||
}
|
||||
// Composition is the assigner's, an accepted kind step of the seat mesh-wants (§22): it is asked with the others,
|
||||
// running at once, and its end is heard from that seat as the build seats' are; the ask names the runner's seat as its
|
||||
// asker (H-A-88). Review and approval wait.
|
||||
if step == seat.StepResultStepComposition && status != seat.StepResultStatusBypass {
|
||||
switch step {
|
||||
case seat.StepResultStepValidate:
|
||||
// validate is the assigner's, an accepted kind step of the seat mesh-wants, run once per take-in revision: every
|
||||
// mover's validate step reads the one ask, its id naming no mover (§745, H-A-51).
|
||||
s.Seat, s.Outcome, s.Started, s.Fingerprint = wants.Seat, seat.StepResultOutcomeRunning, &now, m.Fingerprint
|
||||
s.Ask = ValidateAskID(p, now)
|
||||
asks = append(asks, wantsAsk(p, m, s.Ask, wants.StepRunStepValidate))
|
||||
validating = true
|
||||
case seat.StepResultStepComposition:
|
||||
// Composition is the assigner's (§22): its end is heard from that seat as the build seats' are; the ask names the
|
||||
// runner's seat as its asker (H-A-88). It is asked once the mover's validate passed, at once when it has none
|
||||
// (§745).
|
||||
s.Seat, s.Fingerprint = wants.Seat, m.Fingerprint
|
||||
s.Ask = AskID(startOf(p, now), p.Pipeline, m.Module, "", step)
|
||||
asks = append(asks, Asked{Seat: wants.Seat, ID: s.Ask, Commit: m.Commit, Ask: wants.StepRun{Branch: p.Branch, Commit: m.Commit, Fingerprint: m.Fingerprint,
|
||||
Module: m.Module, Pipeline: p.Pipeline, Revision: p.Revision, Source: p.Source, Run: p.Run, Step: wants.StepRunStepComposition,
|
||||
Asker: seat.Seat}})
|
||||
if validating {
|
||||
s.Ask, s.Why = "", "asked once validate passed"
|
||||
break
|
||||
}
|
||||
s.Outcome, s.Started = seat.StepResultOutcomeRunning, &now
|
||||
asks = append(asks, wantsAsk(p, m, s.Ask, wants.StepRunStepComposition))
|
||||
}
|
||||
// Review and approval wait.
|
||||
steps = append(steps, s)
|
||||
}
|
||||
return steps, asks
|
||||
@@ -249,3 +264,51 @@ func artifactPaths(e catalog.CatalogEntry, ref string) []string {
|
||||
_, name, _ := strings.Cut(ref, ":")
|
||||
return e.Inputs.Paths[name]
|
||||
}
|
||||
|
||||
// ValidateAskID is the one ask id of a pipeline's validate run (design 47 H §745, H-A-51): every mover's validate step reads
|
||||
// it.
|
||||
func ValidateAskID(p seat.Pipeline, now time.Time) string {
|
||||
return AskID(startOf(p, now), p.Pipeline, "", "", seat.StepResultStepValidate)
|
||||
}
|
||||
|
||||
// wantsAsk is the ask of a step the seat mesh-wants serves, validate or composition, for mover m (§745, §22; H-A-88).
|
||||
func wantsAsk(p seat.Pipeline, m seat.Mover, id, step string) Asked {
|
||||
return Asked{Seat: wants.Seat, ID: id, Commit: m.Commit, Ask: wants.StepRun{Branch: p.Branch, Commit: m.Commit, Fingerprint: m.Fingerprint,
|
||||
Module: m.Module, Pipeline: p.Pipeline, Revision: p.Revision, Source: p.Source, Run: p.Run, Step: step, Asker: seat.Seat}}
|
||||
}
|
||||
|
||||
// releaseCompositions asks the composition of each mover whose validate ended passed, and ends `not asked` the composition
|
||||
// of each whose validate did not pass, so a manifest the validator refuses is never composed (design 47 H §745). It answers
|
||||
// the asks to put and the indexes of the steps it ended.
|
||||
func releaseCompositions(p *seat.Pipeline, now time.Time) ([]Asked, []int) {
|
||||
var asks []Asked
|
||||
var ended []int
|
||||
for _, m := range p.Movers {
|
||||
v, c := -1, -1
|
||||
for i, st := range p.Steps {
|
||||
if st.Module != m.Module {
|
||||
continue
|
||||
}
|
||||
switch {
|
||||
case st.Step == seat.StepResultStepValidate && st.Ask != "":
|
||||
v = i
|
||||
case st.Step == seat.StepResultStepComposition && st.Seat == wants.Seat && st.Ask == "" && st.Outcome == seat.StepResultOutcomeWaiting:
|
||||
c = i
|
||||
}
|
||||
}
|
||||
if v < 0 || c < 0 || open(p.Steps[v]) {
|
||||
continue
|
||||
}
|
||||
s := &p.Steps[c]
|
||||
if !stepPassed(p.Steps[v]) {
|
||||
s.Outcome, s.Why, s.Ended = seat.StepResultOutcomeNotAsked, "validate ended "+p.Steps[v].Outcome+": nothing is composed", &now
|
||||
p.Unlogged = append(p.Unlogged, endEntry(p.Pipeline, *s, now))
|
||||
ended = append(ended, c)
|
||||
continue
|
||||
}
|
||||
s.Ask = AskID(startOf(*p, now), p.Pipeline, m.Module, "", seat.StepResultStepComposition)
|
||||
s.Outcome, s.Started, s.Why = seat.StepResultOutcomeRunning, &now, ""
|
||||
asks = append(asks, wantsAsk(*p, m, s.Ask, wants.StepRunStepComposition))
|
||||
}
|
||||
return asks, ended
|
||||
}
|
||||
|
||||
@@ -40,7 +40,7 @@ func (s *stepAsks) AskStep(accept, id string, body any) error {
|
||||
|
||||
func placeFixture() (catalog.Registration, map[string]catalog.CatalogEntry) {
|
||||
reg := catalog.Registration{Module: "app", Branches: []string{"main"}, Policy: catalog.Policy{
|
||||
Steps: catalog.StepStatuses{Lint: "required", Unit: "optional", Approval: "required"},
|
||||
Steps: catalog.StepStatuses{Lint: "required", Unit: "optional", Approval: "required", Validate: "bypass"},
|
||||
Artifacts: map[string]catalog.StepStatuses{"tools": {Lint: "bypass"}},
|
||||
}}
|
||||
return reg, map[string]catalog.CatalogEntry{
|
||||
@@ -74,7 +74,7 @@ func TestStartPlacesTheStepsThePolicyNamesAndAsksEachBuildSeat(t *testing.T) {
|
||||
want := []string{" build running", "app:program lint running", "app:program unit running", "app:program integration running",
|
||||
"app:tools lint bypassed", "app:tools unit running", "app:tools integration running",
|
||||
"app:web lint could not run", "app:web unit could not run", "app:web integration could not run",
|
||||
" composition running", " review waiting", " approval waiting"}
|
||||
" validate bypassed", " composition running", " review waiting", " approval waiting"}
|
||||
if strings.Join(got, "|") != strings.Join(want, "|") {
|
||||
t.Errorf("steps = %q, want %q", got, want)
|
||||
}
|
||||
@@ -120,7 +120,7 @@ func TestStartPlacesTheStepsThePolicyNamesAndAsksEachBuildSeat(t *testing.T) {
|
||||
// not due at its start (A-99, §26).
|
||||
func TestTheBuildHoldsTheApprovalWhateverThePolicyNames(t *testing.T) {
|
||||
reg, entries := placeFixture()
|
||||
reg.Policy = catalog.Policy{Steps: catalog.StepStatuses{Lint: "bypass", Unit: "bypass", Approval: "required"}}
|
||||
reg.Policy = catalog.Policy{Steps: catalog.StepStatuses{Lint: "bypass", Unit: "bypass", Approval: "required", Validate: "bypass"}}
|
||||
store := created{}
|
||||
s := &Starter{Pipelines: store, Say: func(string, any) error { return nil }, Steps: &stepAsks{},
|
||||
Registration: func(string) (catalog.Registration, bool) { return reg, true }}
|
||||
@@ -161,7 +161,7 @@ func TestTheBuildStepsEndIsTakenOnItsOneEntry(t *testing.T) {
|
||||
// end is heard from that seat (design 47 G §22, §24; H H-A-88): a pipeline whose policy names it places it running with its own ask, a bypassed one asks no one.
|
||||
func TestCompositionIsAskedOfTheAssignerAndItsEndIsTaken(t *testing.T) {
|
||||
reg, entries := placeFixture()
|
||||
reg.Policy = catalog.Policy{Steps: catalog.StepStatuses{Lint: "bypass", Unit: "bypass", Composition: "required", Approval: "required"}}
|
||||
reg.Policy = catalog.Policy{Steps: catalog.StepStatuses{Lint: "bypass", Unit: "bypass", Composition: "required", Approval: "required", Validate: "bypass"}}
|
||||
p := seat.Pipeline{Pipeline: "main.4", Branch: "main", Revision: 7, Source: 4, Movers: []seat.Mover{{Module: "app", Commit: "c1", Fingerprint: "src2:aa"}}}
|
||||
steps, asked := Place(p, p.Movers[0], reg, entries, time.Unix(1, 0), "the-runner")
|
||||
var comp seat.StepResult
|
||||
@@ -303,7 +303,7 @@ func TestAStepAskCarriesTheKeptResultsAndTheToolchain(t *testing.T) {
|
||||
// artifact's lint, unit and integration are bypassed whatever the policy says, asked of no one; an artifact whose language no
|
||||
// build seat serves stays could not run, naming it (§535).
|
||||
func TestAnArtifactWithoutALanguageIsPlacedByItsKind(t *testing.T) {
|
||||
reg := catalog.Registration{Module: "app", Policy: catalog.Policy{Steps: catalog.StepStatuses{Lint: "required", Unit: "required", Integration: "required"}}}
|
||||
reg := catalog.Registration{Module: "app", Policy: catalog.Policy{Steps: catalog.StepStatuses{Lint: "required", Unit: "required", Integration: "required", Validate: "bypass"}}}
|
||||
entries := map[string]catalog.CatalogEntry{
|
||||
"app": {Module: "app", Artifacts: []catalog.Artifact{{Ref: "app:server", Kind: "image"}, {Ref: "app:files", Kind: "archive"},
|
||||
{Ref: "app:mirror", Kind: "upstream"}, {Ref: "app:web", Language: "rust"}, {Ref: "app:lib", Language: "typescript"}, {Ref: "app:cli", Language: "go"}}},
|
||||
@@ -557,7 +557,7 @@ func TestASeatWithNoHolderIsReadFromTheSeatHoldersView(t *testing.T) {
|
||||
// step naming its mover, and each ask id names its mover, so the same step of two movers is two asks.
|
||||
func TestEachMoverIsPlacedFromItsOwnRegistrationAndEntry(t *testing.T) {
|
||||
reg, entries := placeFixture()
|
||||
lib := catalog.Registration{Module: "lib", Branches: []string{"main"}, Policy: catalog.Policy{Steps: catalog.StepStatuses{Lint: "bypass", Unit: "required"}}}
|
||||
lib := catalog.Registration{Module: "lib", Branches: []string{"main"}, Policy: catalog.Policy{Steps: catalog.StepStatuses{Lint: "bypass", Unit: "required", Validate: "bypass"}}}
|
||||
entries["lib"] = catalog.CatalogEntry{Module: "lib", Path: "lib", Artifacts: []catalog.Artifact{{Ref: "lib:lib", Language: "go"}}}
|
||||
store := created{}
|
||||
asks := &stepAsks{}
|
||||
@@ -599,3 +599,63 @@ func TestEachMoverIsPlacedFromItsOwnRegistrationAndEntry(t *testing.T) {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// R9/AC1 (design 47 H §745, H-A-51, acceptance test 117's runner half): validate is placed before composition, one ask of
|
||||
// the seat mesh-wants for the pipeline that every mover's validate step reads; a mover's composition is asked only once
|
||||
// validate passed; validate ending failed asks no composition and ends each not asked, so a required one fails the pipeline.
|
||||
func TestValidateComesBeforeCompositionAndAFailureAsksNone(t *testing.T) {
|
||||
for _, outcome := range []string{seat.StepResultOutcomePassed, seat.StepResultOutcomeFailed} {
|
||||
reg, entries := placeFixture()
|
||||
reg.Policy = catalog.Policy{Steps: catalog.StepStatuses{Lint: "bypass", Unit: "bypass", Integration: "bypass", Validate: "required", Composition: "required"}}
|
||||
entries["lib"] = catalog.CatalogEntry{Module: "lib", Artifacts: []catalog.Artifact{{Ref: "lib:lib", Language: "go"}}}
|
||||
mem := memStore{}
|
||||
asks := &stepAsks{}
|
||||
s := &Starter{Pipelines: memCreated{mem}, Store: mem, Say: func(string, any) error { return nil }, Steps: asks, Name: "the-runner",
|
||||
Registration: func(string) (catalog.Registration, bool) { return reg, true }}
|
||||
if ok, err := s.Start(Begin{Branch: "main", Source: 4, Revision: 7, Entries: entries, Movers: []seat.Mover{
|
||||
{Module: "app", Commit: "c1", Fingerprint: "src2:aa"}, {Module: "lib", Commit: "c2", Fingerprint: "src2:bb"}}}); !ok || err != nil {
|
||||
t.Fatalf("start = %v, %v", ok, err)
|
||||
}
|
||||
validates, compositions := 0, 0
|
||||
var validateAsk string
|
||||
for i, a := range asks.asks {
|
||||
if r, ok := a.(wants.StepRun); ok {
|
||||
switch r.Step {
|
||||
case wants.StepRunStepValidate:
|
||||
validates, validateAsk = validates+1, asks.ids[i]
|
||||
case wants.StepRunStepComposition:
|
||||
compositions++
|
||||
}
|
||||
}
|
||||
}
|
||||
p, _, _ := mem.Get("main.4")
|
||||
if validates != 1 || compositions != 0 || stepNamed(p, "", seat.StepResultStepComposition).Outcome != seat.StepResultOutcomeWaiting {
|
||||
t.Fatalf("placed: %d validate and %d composition asks, steps %+v; want one validate, no composition yet", validates, compositions, p.Steps)
|
||||
}
|
||||
h := &Hearer{Store: mem, Name: "the-runner", Say: func(string, any) error { return nil }, AskSteps: s.AskSteps}
|
||||
bs := stepSeatOf(t, wants.Seat)
|
||||
raw := `{"id":"` + validateAsk + `","pipeline":"main.4","step":"validate","module":"app","commit":"c1","fingerprint":"src2:aa","node":"n1","outcome":"` + outcome + `","said":"manifest-refused: app names an unknown field"}`
|
||||
ev, err := bs.Decode([]byte(raw))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
before := len(asks.asks)
|
||||
if _, err := h.OnStepEnded(bs, bs.Prefix+"n1", ev); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
p, _, _ = mem.Get("main.4")
|
||||
for _, st := range p.Steps {
|
||||
if st.Step == seat.StepResultStepValidate && st.Outcome != outcome {
|
||||
t.Errorf("%s: %s's validate is %s, want every mover's read from the one run", outcome, st.Module, st.Outcome)
|
||||
}
|
||||
}
|
||||
asked := len(asks.asks) - before
|
||||
comp := stepNamed(p, "", seat.StepResultStepComposition)
|
||||
if outcome == seat.StepResultOutcomePassed && (asked != 2 || comp.Outcome != seat.StepResultOutcomeRunning || comp.Ask == "") {
|
||||
t.Errorf("validate passed: %d asks, composition %+v; want both movers' compositions asked", asked, comp)
|
||||
}
|
||||
if outcome == seat.StepResultOutcomeFailed && (asked != 0 || comp.Outcome != seat.StepResultOutcomeNotAsked || !strings.Contains(comp.Why, "validate ended failed")) {
|
||||
t.Errorf("validate failed: %d asks, composition %+v; want none asked and it ended not asked", asked, comp)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -32,6 +32,8 @@ func Status(reg catalog.Registration, artifact, step string) string {
|
||||
|
||||
func statusOf(s catalog.StepStatuses, step string) string {
|
||||
switch step {
|
||||
case seat.StepResultStepValidate:
|
||||
return s.Validate
|
||||
case seat.StepResultStepLint:
|
||||
return s.Lint
|
||||
case seat.StepResultStepUnit:
|
||||
|
||||
@@ -318,13 +318,50 @@ func (s *Starter) placeMovers(p *seat.Pipeline, reg func(module string) (catalog
|
||||
continue
|
||||
}
|
||||
steps, a := Place(*p, m, r, entries, now, s.Name)
|
||||
// The pipeline's validate is one run (§745, H-A-51): a mover placed after it was asked reads it, its result too
|
||||
// when it ended.
|
||||
if j := validateStep(*p); j >= 0 {
|
||||
a = slices.DeleteFunc(a, func(x Asked) bool { return x.ID == p.Steps[j].Ask })
|
||||
for k := range steps {
|
||||
if steps[k].Step == seat.StepResultStepValidate && steps[k].Ask == p.Steps[j].Ask && !open(p.Steps[j]) {
|
||||
v := p.Steps[j]
|
||||
steps[k].Outcome, steps[k].Why, steps[k].Node, steps[k].Ended = v.Outcome, v.Why, v.Node, v.Ended
|
||||
}
|
||||
}
|
||||
}
|
||||
p.Steps = append(p.Steps, steps...)
|
||||
asks = append(asks, a...)
|
||||
for _, x := range a {
|
||||
if !slices.ContainsFunc(asks, func(y Asked) bool { return y.ID == x.ID }) {
|
||||
asks = append(asks, x)
|
||||
}
|
||||
}
|
||||
}
|
||||
// A mover placed after the validate ended has its composition asked, or not asked, at once (§745).
|
||||
more, _ := releaseCompositions(p, now)
|
||||
asks = append(asks, more...)
|
||||
asks, ended := s.holderless(p, asks, now)
|
||||
return asks, unregistered, ended
|
||||
}
|
||||
|
||||
// AskSteps puts the asks of pipeline key and says their step-started (askSteps), for the hearer's asks of a step another's
|
||||
// end made due: a mover's composition once validate passed (§745).
|
||||
func (s *Starter) AskSteps(key string, asks []Asked) error {
|
||||
if s.Steps == nil || len(asks) == 0 {
|
||||
return nil
|
||||
}
|
||||
return s.askSteps(key, asks)
|
||||
}
|
||||
|
||||
// validateStep is the index of p's first validate step that names its ask, -1 when it has none.
|
||||
func validateStep(p seat.Pipeline) int {
|
||||
for i, st := range p.Steps {
|
||||
if st.Step == seat.StepResultStepValidate && st.Ask != "" {
|
||||
return i
|
||||
}
|
||||
}
|
||||
return -1
|
||||
}
|
||||
|
||||
// Start writes b's pipeline, running, and says pipeline-started; false, nil when its key was written already (the second
|
||||
// start writes nothing, §746).
|
||||
func (s *Starter) Start(b Begin) (bool, error) {
|
||||
|
||||
@@ -149,6 +149,9 @@ type Hearer struct {
|
||||
DropRun Drop
|
||||
// RunOutputs keeps a test run's output in test-runs-objects (§725, A-466v).
|
||||
RunOutputs RunObjects
|
||||
// AskSteps puts the asks a step's end made due, a mover's composition once validate passed (§745; Starter.AskSteps);
|
||||
// nil asks none.
|
||||
AskSteps func(key string, asks []Asked) error
|
||||
}
|
||||
|
||||
// EndReaders ends each of readers' steps of run with r's result (§725, §726): a step that read an ended run, or the steps
|
||||
@@ -254,6 +257,15 @@ func (h *Hearer) OnStepEndedShared(bs StepSeat, subject string, ev StepEnded, sh
|
||||
p.Unlogged = append(p.Unlogged, unlogged)
|
||||
// The steps of this pipeline reading the run end in the same write, so the pipeline ends once (§726, §727).
|
||||
readers := h.sameRunReaders(&p, i, ev, now)
|
||||
// Every mover's validate reads the one run (§745, H-A-51); its end asks each mover's composition, or ends it not
|
||||
// asked when validate did not pass.
|
||||
var due []Asked
|
||||
if s.Step == seat.StepResultStepValidate {
|
||||
readers = append(readers, sameValidate(&p, i, now)...)
|
||||
var notAsked []int
|
||||
due, notAsked = releaseCompositions(&p, now)
|
||||
readers = append(readers, notAsked...)
|
||||
}
|
||||
from := now
|
||||
if ev.Ended != nil {
|
||||
from = ev.Ended.UTC()
|
||||
@@ -294,6 +306,11 @@ func (h *Hearer) OnStepEndedShared(bs StepSeat, subject string, ev StepEnded, sh
|
||||
return p, fmt.Errorf("pipeline %s's %s is written but not said: %w", ev.Pipeline, seat.EventStepEnded, err)
|
||||
}
|
||||
}
|
||||
if h.AskSteps != nil && len(due) > 0 {
|
||||
if err := h.AskSteps(ev.Pipeline, due); err != nil {
|
||||
h.logf("the compositions of %s are written running and not asked, asked again at the next start: %v", ev.Pipeline, err)
|
||||
}
|
||||
}
|
||||
// The step's end is written and said before its log entry is appended, so a log that refuses ends no step (§486, §606).
|
||||
h.appendUnlogged(ev.Pipeline)
|
||||
h.Ager.Age()
|
||||
@@ -607,3 +624,20 @@ func (h *Hearer) EndedAtPlacing(p seat.Pipeline, steps []int) error {
|
||||
}
|
||||
return first
|
||||
}
|
||||
|
||||
// sameValidate ends, in p, every other mover's validate step reading the ask step i's end ended, with its result (§745,
|
||||
// H-A-51). It answers their indexes.
|
||||
func sameValidate(p *seat.Pipeline, i int, now time.Time) []int {
|
||||
v := p.Steps[i]
|
||||
var out []int
|
||||
for j := range p.Steps {
|
||||
s := &p.Steps[j]
|
||||
if j == i || s.Step != seat.StepResultStepValidate || s.Ask != v.Ask || !open(*s) {
|
||||
continue
|
||||
}
|
||||
s.Outcome, s.Why, s.Node, s.Ended = v.Outcome, v.Why, v.Node, &now
|
||||
p.Unlogged = append(p.Unlogged, endEntry(p.Pipeline, *s, now))
|
||||
out = append(out, j)
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
@@ -88,7 +88,7 @@ type runFixture struct {
|
||||
func newRunFixture() *runFixture {
|
||||
f := &runFixture{store: memStore{}, runs: testRunsMem{}, objects: objectsMem{}, asks: &stepAsks{}}
|
||||
f.clock = &clockMem{runs: f.runs, bound: map[string]time.Duration{}}
|
||||
reg := catalog.Registration{Module: "app", Branches: []string{"main"}}
|
||||
reg := catalog.Registration{Module: "app", Branches: []string{"main"}, Policy: catalog.Policy{Steps: catalog.StepStatuses{Validate: "bypass"}}}
|
||||
say := func(_ string, body any) error {
|
||||
if e, ok := body.(seat.StepEvent); ok {
|
||||
f.said = append(f.said, e)
|
||||
@@ -353,7 +353,7 @@ func TestARerunOfATestRunMovesEveryReaderThatDidNotPass(t *testing.T) {
|
||||
accepted := c.accepted
|
||||
f := newRunFixture()
|
||||
reg := catalog.Registration{Module: "app", Branches: []string{"main"}, Policy: catalog.Policy{Steps: catalog.StepStatuses{Lint: "bypass", Unit: "required",
|
||||
Integration: "bypass", Composition: "bypass", Review: "bypass", Approval: "bypass"}}}
|
||||
Integration: "bypass", Composition: "bypass", Review: "bypass", Approval: "bypass", Validate: "bypass"}}}
|
||||
f.s.Registration = func(string) (catalog.Registration, bool) { return reg, true }
|
||||
p := f.start(t, 4, 9)
|
||||
e := f.store[p.Pipeline]
|
||||
@@ -615,7 +615,7 @@ func TestNoWriteOfATestRunActsOnAReadBeforeItsLatestChange(t *testing.T) {
|
||||
t.Run("the run ends before the step's finding is written", func(t *testing.T) {
|
||||
f := newRunFixture()
|
||||
reg := catalog.Registration{Module: "app", Branches: []string{"main"}, Policy: catalog.Policy{Steps: catalog.StepStatuses{Lint: "bypass", Unit: "required",
|
||||
Integration: "bypass", Composition: "bypass", Review: "bypass", Approval: "bypass"}}}
|
||||
Integration: "bypass", Composition: "bypass", Review: "bypass", Approval: "bypass", Validate: "bypass"}}}
|
||||
f.s.Registration = func(string) (catalog.Registration, bool) { return reg, true }
|
||||
p := f.start(t, 4, 9)
|
||||
unit := stepNamed(p, "app:program", "unit")
|
||||
|
||||
Reference in New Issue
Block a user