G-24: one composition run per candidate and machine, one test run per level, every reading step timed #244

Merged
mesh-tools merged 49 commits from fix/47-G-shared-runs into main 2026-11-17 12:15:36 +00:00
7 changed files with 371 additions and 44 deletions
Showing only changes of commit 2b3a9e4a6a - Show all commits
@@ -34,7 +34,7 @@ type testRunsKV struct {
kv jetstream.KeyValue
}
func (t testRunsKV) Create(key string, r seat.TestRun) error {
func (t testRunsKV) Create(key string, r pipeline.Run) error {
raw, err := json.Marshal(r)
if err != nil {
return err
@@ -47,22 +47,22 @@ func (t testRunsKV) Create(key string, r seat.TestRun) error {
return nil
}
func (t testRunsKV) Get(key string) (seat.TestRun, uint64, error) {
func (t testRunsKV) Get(key string) (pipeline.Run, uint64, error) {
e, err := t.kv.Get(t.ctx, key)
if errors.Is(err, jetstream.ErrKeyNotFound) {
return seat.TestRun{}, 0, pipeline.ErrNoRun
return pipeline.Run{}, 0, pipeline.ErrNoRun
}
if err != nil {
return seat.TestRun{}, 0, err
return pipeline.Run{}, 0, err
}
var r seat.TestRun
var r pipeline.Run
if err := json.Unmarshal(e.Value(), &r); err != nil {
return seat.TestRun{}, 0, fmt.Errorf("the test run %s is no test run: %w", key, err)
return pipeline.Run{}, 0, fmt.Errorf("the test run %s is no test run: %w", key, err)
}
return r, e.Revision(), nil
}
func (t testRunsKV) Update(key string, r seat.TestRun, revision uint64) (uint64, error) {
func (t testRunsKV) Update(key string, r pipeline.Run, revision uint64) (uint64, error) {
raw, err := json.Marshal(r)
if err != nil {
return 0, err
@@ -331,38 +331,38 @@ func TestAnArtifactWithoutALanguageIsPlacedByItsKind(t *testing.T) {
// testRunsMem is the state test-runs in memory, a write by compare-and-set on the revision read.
type testRunsMem map[string]struct {
r seat.TestRun
r Run
rev uint64
}
func (m testRunsMem) Create(key string, r seat.TestRun) error {
func (m testRunsMem) Create(key string, r Run) error {
if _, ok := m[key]; ok {
return ErrExists
}
m[key] = struct {
r seat.TestRun
r Run
rev uint64
}{r, 1}
return nil
}
func (m testRunsMem) Get(key string) (seat.TestRun, uint64, error) {
func (m testRunsMem) Get(key string) (Run, uint64, error) {
e, ok := m[key]
if !ok {
return seat.TestRun{}, 0, ErrNoRun
return Run{}, 0, ErrNoRun
}
e.r.Readers = append([]seat.TestRunReader(nil), e.r.Readers...)
e.r.Readers = append([]RunReader(nil), e.r.Readers...)
return e.r, e.rev, nil
}
func (m testRunsMem) Delete(key string) error { delete(m, key); return nil }
func (m testRunsMem) Update(key string, r seat.TestRun, rev uint64) (uint64, error) {
func (m testRunsMem) Update(key string, r Run, rev uint64) (uint64, error) {
if m[key].rev != rev {
return 0, ErrChanged
}
m[key] = struct {
r seat.TestRun
r Run
rev uint64
}{r, rev + 1}
return rev + 1, nil
@@ -231,10 +231,10 @@ func (h *Hearer) runSettings() RunSettings {
}
// EndRun ends the test run under run with end's outcome, words, counts, node and output, written once by compare-and-set,
// and ends each of its readers with it but skip, the step whose own end ended it (§725, §726). A run ended already is
// not ended again.
// and ends each of its readers with it but skip, the step whose own end ended it (§725, §726). A run ended already is not
// ended again.
func (h *Hearer) EndRun(run string, end seat.TestRun, skip *seat.TestRunReader) error {
var r seat.TestRun
var r Run
for {
got, rev, err := h.TestRuns.Get(run)
if errors.Is(err, ErrNoRun) {
@@ -271,7 +271,7 @@ func (h *Hearer) EndRun(run string, end seat.TestRun, skip *seat.TestRunReader)
}
var first error
for _, reader := range r.Readers {
if skip != nil && reader == *skip {
if skip != nil && reader.Of() == *skip {
continue
}
if err := h.endReader(reader, run, r); err != nil && first == nil {
@@ -282,17 +282,24 @@ func (h *Hearer) EndRun(run string, end seat.TestRun, skip *seat.TestRunReader)
}
// endReader ends reader's step of run with the run's result (§726): its outcome, words, counts and node, the step naming
// the run in Shared as it did. A step ended already takes nothing.
func (h *Hearer) endReader(reader seat.TestRunReader, run string, r seat.TestRun) error {
// the run in Shared as it did. A step ended already takes nothing, but one the rerun that asked the run marked (A-470d,
// A-470e): it read another ask of the key, and it moves with this one, said again marked a rerun by that caller, naming
// the new ask, its pipeline reopened (§727).
func (h *Hearer) endReader(reader RunReader, run string, r Run) error {
for {
p, rev, err := h.Store.Get(reader.Pipeline)
if err != nil {
return nil // a pipeline gone has no reader left to end
}
i := -1
i, moved := -1, false
for j, s := range p.Steps {
if s.Artifact == reader.Artifact && sharedRun(s) == run && s.Outcome == seat.StepResultOutcomeRunning {
i = j
if s.Artifact != reader.Artifact || sharedRun(s) != run {
continue
}
if s.Outcome == seat.StepResultOutcomeRunning {
i, moved = j, false
} else if reader.Rerun && s.Shared[0].Ask != r.Ask && s.Accepted == nil {
i, moved = j, true
}
}
if i < 0 {
@@ -300,7 +307,14 @@ func (h *Hearer) endReader(reader seat.TestRunReader, run string, r seat.TestRun
}
now := h.now()
s := &p.Steps[i]
s.Outcome, s.Why, s.Node, s.Ended = r.Outcome, r.Said, r.Node, &now
if moved {
s.Rerun, s.By = true, reader.By
s.Shared = []seat.Shared{{Run: run, Ask: r.Ask, AskedBy: s.Shared[0].AskedBy}}
if p.Outcome != seat.PipelineOutcomeRunning {
p.Outcome, p.Why, p.Ended = seat.PipelineOutcomeRunning, "", nil
}
}
s.Outcome, s.Why, s.Node, s.Ended, s.Tests = r.Outcome, r.Said, r.Node, &now, nil
if r.Tests != nil {
t := *r.Tests
s.Tests = &t
@@ -350,7 +364,7 @@ func (h *Hearer) leaveRun(key string, s seat.StepResult, why string) {
}
left := r.Readers[:0:0]
for _, o := range r.Readers {
if o != reader {
if o.Of() != reader {
left = append(left, o)
}
}
@@ -154,7 +154,7 @@ type Hearer struct {
func (h *Hearer) EndReaders(run string, readers []seat.TestRunReader, r seat.TestRun) error {
var first error
for _, reader := range readers {
if err := h.endReader(reader, run, r); err != nil && first == nil {
if err := h.endReader(RunReader{Pipeline: reader.Pipeline, Artifact: reader.Artifact}, run, Run{TestRun: r}); err != nil && first == nil {
first = err
}
}
@@ -236,6 +236,8 @@ func (h *Hearer) OnStepEndedShared(bs StepSeat, subject string, ev StepEnded, sh
}
unlogged := endEntry(ev.Pipeline, *s, now, keptKeys...)
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)
from := now
if ev.Ended != nil {
from = ev.Ended.UTC()
@@ -268,6 +270,11 @@ func (h *Hearer) OnStepEndedShared(bs StepSeat, subject string, ev StepEnded, sh
if err := h.say(seat.EventStepEnded, p, s); err != nil {
return p, fmt.Errorf("pipeline %s's %s is written but not said: %w", ev.Pipeline, seat.EventStepEnded, err)
}
for _, j := range readers {
if err := h.say(seat.EventStepEnded, p, &p.Steps[j]); err != nil {
return p, fmt.Errorf("pipeline %s's %s is written but not said: %w", ev.Pipeline, seat.EventStepEnded, 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()
@@ -279,6 +286,48 @@ func (h *Hearer) OnStepEndedShared(bs StepSeat, subject string, ev StepEnded, sh
}
}
// sameRunReaders ends, in p, every other step reading the test run step i asked with ev, its ask's end: a running reader,
// and one the rerun that asked the run marked, which moves (A-470d, A-470e), said again marked a rerun by that caller. It
// answers their indexes.
func (h *Hearer) sameRunReaders(p *seat.Pipeline, i int, ev StepEnded, now time.Time) []int {
asker := p.Steps[i]
run := sharedRun(asker)
if run == "" || h.TestRuns == nil || asker.Ask != ev.ID {
return nil
}
marks := map[string]RunReader{}
if r, _, err := h.TestRuns.Get(run); err == nil {
for _, o := range r.Readers {
if o.Pipeline == p.Pipeline {
marks[o.Artifact] = o
}
}
}
var out []int
for j := range p.Steps {
s := &p.Steps[j]
if j == i || sharedRun(*s) != run {
continue
}
switch m := marks[s.Artifact]; {
case s.Outcome == seat.StepResultOutcomeRunning && s.Ask == "":
case m.Rerun && s.Shared[0].Ask != ev.ID && s.Accepted == nil:
s.Rerun, s.By = true, m.By
s.Shared = []seat.Shared{{Run: run, Ask: ev.ID, AskedBy: &seat.SharedAskedBy{Pipeline: p.Pipeline, Artifact: asker.Artifact}}}
default:
continue
}
s.Outcome, s.Why, s.Node, s.Ended, s.Tests = asker.Outcome, asker.Why, asker.Node, &now, nil
if asker.Tests != nil {
t := *asker.Tests
s.Tests = &t
}
p.Unlogged = append(p.Unlogged, endEntry(p.Pipeline, *s, now))
out = append(out, j)
}
return out
}
// endRunOf ends the test run step s of p asked, with the end ev of its ask (§725, §726): the run's output kept in
// test-runs-objects under the run's key, its outcome, words, counts and node written, and every other reader ended with it.
// A step that asked no run ends nothing more.
@@ -18,15 +18,46 @@ import (
// packages, written create-only by the step that asks the run and changed by compare-and-set.
type TestRuns interface {
// Create writes key when it is absent; ErrExists when it is written already.
Create(key string, r seat.TestRun) error
Create(key string, r Run) error
// Get reads key and its revision; ErrNoRun when it is absent.
Get(key string) (seat.TestRun, uint64, error)
Get(key string) (Run, uint64, error)
// Update writes key at the revision read; ErrChanged when another write came between.
Update(key string, r seat.TestRun, revision uint64) (uint64, error)
Update(key string, r Run, revision uint64) (uint64, error)
// Delete deletes key; a key gone is no fault.
Delete(key string) error
}
// Run is a key's value in test-runs (§725): the test run, its readers each marked whether a rerun's new run moves it and by
// whom (A-470d), so the marks are in the key and a restart takes them up.
type Run struct {
seat.TestRun
Readers []RunReader `json:"readers,omitempty"`
}
// RunReader is a step reading a test run, its pipeline key and artifact (§725), marked rerun with the caller of the rerun
// whose new run moves it (A-470d).
type RunReader struct {
Pipeline string `json:"pipeline"`
Artifact string `json:"artifact"`
Rerun bool `json:"rerun,omitempty"`
By string `json:"by,omitempty"`
}
// Of is the reader as the seat names it.
func (r RunReader) Of() seat.TestRunReader {
return seat.TestRunReader{Pipeline: r.Pipeline, Artifact: r.Artifact}
}
// Answer is the run as the seat's read answers it, its readers named by pipeline and artifact.
func (r Run) Answer() seat.TestRun {
t := r.TestRun
t.Readers = nil
for _, o := range r.Readers {
t.Readers = append(t.Readers, o.Of())
}
return t
}
// ErrNoRun is a Get of a test-runs key that is not written.
var ErrNoRun = errors.New("no test run under the key")
@@ -79,14 +110,14 @@ func readsRun(s seat.StepResult, run string) bool {
}
// addReaders adds each reader not in r's readers yet, in order.
func addReaders(r *seat.TestRun, readers []seat.TestRunReader) {
func addReaders(r *Run, readers []seat.TestRunReader) {
for _, n := range readers {
have := false
for _, o := range r.Readers {
have = have || o == n
have = have || o.Of() == n
}
if !have {
r.Readers = append(r.Readers, n)
r.Readers = append(r.Readers, RunReader{Pipeline: n.Pipeline, Artifact: n.Artifact})
}
}
}
@@ -122,7 +153,7 @@ func (s *Starter) share(key string, asks []Asked) []Asked {
return asks
}
var out []Asked
joined := map[string]seat.TestRun{}
joined := map[string]Run{}
for _, a := range asks {
if a.Run == "" {
out = append(out, a)
@@ -162,7 +193,7 @@ func (s *Starter) share(key string, asks []Asked) []Asked {
readers = a.Readers
}
}
if err := s.EndReaders(run, readers, r); err != nil {
if err := s.EndReaders(run, readers, r.TestRun); err != nil {
s.logf("the steps of %s reading the ended test run %s are not ended: %v", key, run, err)
}
}
@@ -219,9 +250,10 @@ func (s *Starter) started(a Asked, write func() error) error {
}
// claimRun writes a's test run create-only; ok says the ask is put (the key is a's own), else run is the run it reads.
func (s *Starter) claimRun(a Asked) (seat.TestRun, bool, error) {
func (s *Starter) claimRun(a Asked) (Run, bool, error) {
now := s.now()
value := seat.TestRun{Level: a.Level, Digest: a.Digest, Seat: a.Seat, Ask: a.ID, Started: &now, Readers: a.Readers}
value := Run{TestRun: seat.TestRun{Level: a.Level, Digest: a.Digest, Seat: a.Seat, Ask: a.ID, Started: &now}}
addReaders(&value, a.Readers)
for {
err := s.started(a, func() error { return s.TestRuns.Create(a.Run, value) })
if err == nil {
@@ -229,17 +261,17 @@ func (s *Starter) claimRun(a Asked) (seat.TestRun, bool, error) {
}
var full *fullErr
if errors.As(err, &full) {
return seat.TestRun{}, false, err
return Run{}, false, err
}
if !errors.Is(err, ErrExists) {
return seat.TestRun{}, false, err
return Run{}, false, err
}
r, rev, err := s.TestRuns.Get(a.Run)
if errors.Is(err, ErrNoRun) {
continue // deleted meanwhile: written again
}
if err != nil {
return seat.TestRun{}, false, err
return Run{}, false, err
}
if r.Ask == a.ID {
return r, true, nil
@@ -252,7 +284,7 @@ func (s *Starter) claimRun(a Asked) (seat.TestRun, bool, error) {
if errors.Is(err, ErrChanged) {
continue
} else if err != nil {
return seat.TestRun{}, false, err
return Run{}, false, err
}
return value, true, nil
}
@@ -260,7 +292,7 @@ func (s *Starter) claimRun(a Asked) (seat.TestRun, bool, error) {
if _, err := s.TestRuns.Update(a.Run, r, rev); errors.Is(err, ErrChanged) {
continue
} else if err != nil {
return seat.TestRun{}, false, err
return Run{}, false, err
}
return r, false, nil
}
@@ -268,7 +300,7 @@ func (s *Starter) claimRun(a Asked) (seat.TestRun, bool, error) {
// readOthers writes pipeline key's steps that read another step's run: no ask of their own, the run's ask and its asker
// in Shared (A-469m, A-469q).
func (s *Starter) readOthers(key string, joined map[string]seat.TestRun) {
func (s *Starter) readOthers(key string, joined map[string]Run) {
if s.Store == nil {
return
}
@@ -303,3 +335,24 @@ func (s *Starter) readOthers(key string, joined map[string]seat.TestRun) {
return
}
}
// joinRun adds reader to run's readers by compare-and-set.
func (s *Starter) joinRun(run string, reader seat.TestRunReader) {
if s.TestRuns == nil {
return
}
for {
r, rev, err := s.TestRuns.Get(run)
if err != nil {
s.logf("the test run %s is not read, so %s does not join it: %v", run, reader.Pipeline, err)
return
}
addReaders(&r, []seat.TestRunReader{reader})
if _, err := s.TestRuns.Update(run, r, rev); errors.Is(err, ErrChanged) {
continue
} else if err != nil {
s.logf("%s does not join the test run %s: %v", reader.Pipeline, run, err)
}
return
}
}
@@ -292,3 +292,67 @@ func TestATestRunsEndMovesEveryReaderAndIsCountedOnce(t *testing.T) {
t.Errorf("the composition step's shared = %+v, want mesh-wants' as it came", s.Shared)
}
}
// Asking a test run again moves every reader (design 47 G §727; A-469l, A-470d, A-470e): a rerun of one artifact's failed
// step starts a new run under the same key, carrying the former readers, the one that did not pass marked; the new run's
// passing end moves the other artifact's step to passed, marked a rerun by the caller and naming the new ask, and the
// pipeline says pipeline-ended again; a step a person accepted does not move.
func TestARerunOfATestRunMovesEveryReaderThatDidNotPass(t *testing.T) {
for _, accepted := range []bool{false, true} {
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"}}}
f.s.Registration = func(string) (catalog.Registration, bool) { return reg, true }
p := f.start(t, 4, 9)
e := f.store[p.Pipeline]
e.p.Steps[0].Outcome = seat.StepResultOutcomePassed // the build
f.store[p.Pipeline] = e
unit := stepNamed(p, "app:program", "unit")
end := func(ask string, outcome string, rerun bool) {
t.Helper()
ended := time.Now()
if _, err := f.h.OnStepEnded(stepSeatOf(t, "node-build-go"), "mesh.seat.node-build-go.event.step-ended.ace", StepEnded{ID: ask,
Pipeline: p.Pipeline, Module: "app", Commit: "c1", Fingerprint: "src2:aa", Step: "unit", Node: "ace", Outcome: outcome,
Rerun: rerun, By: map[bool]string{true: "op@shanks"}[rerun], Ended: &ended}); err != nil {
t.Fatal(err)
}
}
end(unit.Ask, "failed", false)
if q := f.pipeline(p); q.Outcome != seat.PipelineOutcomeFailed || q.EndCount != 1 || stepNamed(q, "app:tools", "unit").Outcome != "failed" {
t.Fatalf("after the failing run the pipeline = %s (%d), tools %s", q.Outcome, q.EndCount, stepNamed(q, "app:tools", "unit").Outcome)
}
if accepted {
e := f.store[p.Pipeline]
i := stepIndex(e.p, "unit", "app:program")
e.p.Steps[i].Outcome, e.p.Steps[i].Accepted = seat.StepResultOutcomeAccepted, &seat.Accepted{By: "op@shanks", Why: "known"}
f.store[p.Pipeline] = e
}
v := Verbs{Hearer: f.h, Starter: f.s, View: func(string) (Half, bool) { return Half{Entries: map[string]catalog.CatalogEntry{
"app": {Module: "app", Path: "modules/app", Artifacts: []catalog.Artifact{{Ref: "app:program", Language: "go"}, {Ref: "app:tools", Language: "go"}}},
"mesh-build-go": {Module: "mesh-build-go", Acts: []catalog.ActingRule{{Seat: "node-build-go", Step: "build", On: "go"}}}}}, true }, Acts: &actLog{}}
a, err := v.Rerun("op@shanks", seat.RerunInput{Pipeline: p.Pipeline, Step: "unit", Artifact: "app:tools", Why: "flaky"})
if err != nil {
t.Fatal(err)
}
again := a.Result.Ask
r, _, _ := f.runs.Get(unit.Shared[0].Run)
if again == "" || again == unit.Ask || r.Ask != again || r.Ended != nil || len(r.Readers) != 2 || r.Readers[0].Rerun == accepted || (!accepted && r.Readers[0].By != "op@shanks") {
t.Fatalf("the rerun's run = %+v (ask %s), want a new run under the same key carrying the program, marked unless accepted", r, again)
}
end(again, "passed", true)
q := f.pipeline(p)
prog := stepNamed(q, "app:program", "unit")
if accepted {
if prog.Outcome != seat.StepResultOutcomeAccepted {
t.Errorf("an accepted step moved to %s", prog.Outcome)
}
continue
}
if prog.Outcome != seat.StepResultOutcomePassed || !prog.Rerun || prog.By != "op@shanks" || prog.Shared[0].Ask != again {
t.Errorf("the program's step = %+v, want passed, a rerun by the caller, naming the new ask", prog)
}
if q.Outcome != seat.PipelineOutcomePassed || q.EndCount != 2 {
t.Errorf("the pipeline = %s (%d), want passed at its second end", q.Outcome, q.EndCount)
}
}
}
@@ -236,6 +236,11 @@ func (v Verbs) Rerun(caller string, in seat.RerunInput) (seat.RerunAnswer, error
if in.Step == seat.StepResultStepApproval {
return seat.RerunAnswer{}, errors.New("an approval is asked again by ask-again, not rerun")
}
if p, _, err := v.Hearer.Store.Get(in.Pipeline); err == nil {
if i, err := stepOf(p, in.Step, in.Artifact); err == nil && v.Hearer.TestRuns != nil && sharedRun(p.Steps[i]) != "" && BoundSeat(p.Steps[i].Seat) {
return v.rerunTest(caller, in, p.Steps[i])
}
}
var ask *Asked
p, _, err := v.change(in.Pipeline, seat.EventStepStarted, func() error {
return v.record(seat.VerbRerun, fmt.Sprintf("asked the %s step of %s again", in.Step, in.Pipeline), in.Why)
@@ -295,6 +300,148 @@ func (v Verbs) Rerun(caller string, in seat.RerunInput) (seat.RerunAnswer, error
return seat.RerunAnswer{Pipeline: in.Pipeline, Result: &r}, nil
}
// rerunTest asks a test step of a test run again (design 47 G §727, A-469l): it joins its key's run while that runs, reads one
// that started after the step's last end, or else starts a new run under a new ask, replacing the ended key by compare-and-set
// and carrying its readers into the new value, so the new run's end moves every former reader that did not pass.
func (v Verbs) rerunTest(caller string, in seat.RerunInput, st seat.StepResult) (seat.RerunAnswer, error) {
h := v.Hearer
run := sharedRun(st)
if st.Outcome == seat.StepResultOutcomeRunning {
return seat.RerunAnswer{}, fmt.Errorf("the %s step of %s is running: it is not asked again", in.Step, in.Pipeline)
}
r, rev, err := h.TestRuns.Get(run)
if err != nil && !errors.Is(err, ErrNoRun) {
return seat.RerunAnswer{}, fmt.Errorf("the test run %s is not read: %w", run, err)
}
exists := err == nil
reader := seat.TestRunReader{Pipeline: in.Pipeline, Artifact: st.Artifact}
read := exists && r.Ended != nil && r.Outcome != seat.StepResultOutcomeCouldNotRun && st.Ended != nil && r.Started != nil && r.Started.After(*st.Ended)
join := exists && r.Ended == nil
var ask *Asked
if !join && !read {
p, _, err := h.Store.Get(in.Pipeline)
if err != nil {
return seat.RerunAnswer{}, err
}
if ask, err = v.askOf(p, st, caller, h.now()); err != nil {
return seat.RerunAnswer{}, err
}
}
var asker *seat.SharedAskedBy
if join || read {
if asker, err = askerOf(h.Store, r.Ask); err != nil {
return seat.RerunAnswer{}, err
}
if asker != nil && *asker == (seat.SharedAskedBy{Pipeline: reader.Pipeline, Artifact: reader.Artifact}) {
asker = nil
}
}
event := seat.EventStepStarted
if read {
event = seat.EventStepEnded
}
p, _, err := v.change(in.Pipeline, event, func() error {
return v.record(seat.VerbRerun, fmt.Sprintf("asked the %s step of %s again", in.Step, in.Pipeline), in.Why)
}, func(p *seat.Pipeline, now time.Time) (int, error) {
switch p.Outcome {
case seat.PipelineOutcomeCancelled, seat.PipelineOutcomeSuperseded:
return -1, fmt.Errorf("the pipeline %s is %s: a step of it is not asked again", p.Pipeline, p.Outcome)
}
i, err := stepOf(*p, in.Step, in.Artifact)
if err != nil {
return -1, err
}
s := &p.Steps[i]
*s = seat.StepResult{Step: s.Step, Artifact: s.Artifact, Status: s.Status, Fingerprint: s.Fingerprint, Seat: s.Seat,
Outcome: seat.StepResultOutcomeRunning, By: caller, Rerun: true, Started: &now}
switch {
case ask != nil:
s.Ask, s.Shared = ask.ID, []seat.Shared{{Run: run, Ask: ask.ID}}
case read:
s.Shared = []seat.Shared{{Run: run, Ask: r.Ask, AskedBy: asker}}
s.Outcome, s.Why, s.Node, s.Ended = r.Outcome, r.Said, r.Node, &now
if r.Tests != nil {
t := *r.Tests
s.Tests = &t
}
default:
s.Shared = []seat.Shared{{Run: run, Ask: r.Ask, AskedBy: asker}}
}
if p.Outcome != seat.PipelineOutcomeRunning {
p.Outcome, p.Why, p.Ended = seat.PipelineOutcomeRunning, "", nil
}
for j := range p.Steps {
if p.Steps[j].Step == seat.StepResultStepApproval && p.Steps[j].Outcome == seat.StepResultOutcomeNotAsked {
p.Steps[j].Outcome, p.Steps[j].Why = seat.StepResultOutcomeWaiting, ""
}
}
return i, nil
})
if err != nil {
return seat.RerunAnswer{}, err
}
h.pin(p)
switch {
case join || read:
v.Starter.joinRun(run, reader)
default:
now := h.now()
value := Run{TestRun: seat.TestRun{Level: st.Step, Digest: r.Digest, Seat: st.Seat, Ask: ask.ID, Started: &now}}
// Every former reader is carried, each that did not pass marked to move with the new run by this caller (A-470d).
for _, o := range r.Readers {
if o.Of() == reader {
continue
}
o.Rerun, o.By = !v.passedReader(o, run), ""
if o.Rerun {
o.By = caller
}
value.Readers = append(value.Readers, o)
}
addReaders(&value, []seat.TestRunReader{reader})
a := *ask
a.Run = run
if err := v.Starter.started(a, func() error {
if !exists {
return h.TestRuns.Create(run, value)
}
_, err := h.TestRuns.Update(run, value, rev)
return err
}); err != nil {
return seat.RerunAnswer{}, fmt.Errorf("the step is written running but its test run %s is not: %w", run, err)
}
v.Starter.carry(in.Pipeline, []Asked{*ask})
if err := askAll(v.Starter.Steps, in.Pipeline, []Asked{*ask}, v.Starter.recovered(in.Pipeline, p.Commit)); err != nil {
return seat.RerunAnswer{}, fmt.Errorf("the step is written running but not asked, it is asked again at the next start: %w", err)
}
}
i, err := stepOf(p, in.Step, in.Artifact)
if err != nil {
return seat.RerunAnswer{}, err
}
res := p.Steps[i]
return seat.RerunAnswer{Pipeline: in.Pipeline, Result: &res}, nil
}
// passedReader says whether reader's step of run passed, or a person accepted it (§30): a step that moves with no new run.
func (v Verbs) passedReader(reader RunReader, run string) bool {
p, _, err := v.Hearer.Store.Get(reader.Pipeline)
if err != nil {
return true // a pipeline gone has no step to move
}
for _, s := range p.Steps {
if s.Artifact == reader.Artifact && sharedRun(s) == run {
switch s.Outcome {
case seat.StepResultOutcomePassed, seat.StepResultOutcomeCarried, seat.StepResultOutcomeAccepted,
seat.StepResultOutcomeSuperseded, seat.StepResultOutcomeCancelled:
return true
}
return s.Accepted != nil
}
}
return true
}
// askOf is the ask to put on the serving seat for step s again: the one Place makes for it, under a new id (an ask put twice
// under one id is kept once), saying it is a rerun and by whom.
func (v Verbs) askOf(p seat.Pipeline, s seat.StepResult, caller string, now time.Time) (*Asked, error) {
@@ -319,7 +466,7 @@ func (v Verbs) askOf(p seat.Pipeline, s seat.StepResult, caller string, now time
} else {
return nil, fmt.Errorf("the catalog half of %s is not held yet: the step is asked when it is", p.Branch)
}
_, placed := Place(p, reg, half.Entries, now, v.Starter.Name)
_, placed := place(p, reg, half.Entries, now, v.Starter.Name, false)
base := AskID(startOf(p, now), p.Pipeline, s.Artifact, s.Step)
for _, a := range placed {
if a.ID != base {