Compare commits

..
Author SHA1 Message Date
mesh-tools c6edd5987f Merge pull request 'Design 47 H: a re-pin of the same source keeps a mover in its pipeline (H-A-283..286)' (#314) from fix/47-H1-runner-same-source-repin into main 2026-11-21 17:00:58 +00:00
jschoubben 9a49b0f4f7 Give a kept mover's asks ids of its kept revision and place it from that revision (H-A-286)
Review round 1: a kept mover's ask ids still came from the pipeline's start
time, so a pin-held ask or a composition took the id of an ask the runner
had just dropped for the old fingerprint, and a restart never matched the
steps placed again; and a kept mover placed later read the branch's held
view, so a lagging view gave the new fingerprint the old pins. Every ask id
of a kept mover's steps (build, tests, validate, pin-held asks,
composition, rerun, restart) now mixes its kept revision into the id's
sum, and every placing of a kept mover (at once, later, at a restart, a
rerun) reads its entries at its kept revision by number, waiting while
that revision cannot be read. The test's starter gets a clock that moves.

Builds: design 47 H H-A-286 (amending H-A-284; with H-A-283, H-A-285)
2026-11-21 17:58:07 +01:00
jschoubben 47f81051be Keep a same-source re-pin's mover in its pipeline and build it again there (H-A-283)
A module importing packages its own pipeline releases was re-pinned at
each publish; each re-pin revision of the same source took it out of the
running pipeline, and each newer build withdrew the older reservation, so
nothing ever published. A revision of the same source now moves no mover
out of the open pipeline of that source: the pipeline keeps it at its new
fingerprint, ends every step of it superseded (said at the old
fingerprint, its asks dropped, its runs left) and places them again from
the re-pin revision's entry under new asks, the build first, still naming
the pipeline's revision. The revision the mover is kept at rides in the
record's kept-revisions, beside the movers, where the pin check reads its
entry. A revision whose every mover is kept starts no pipeline; one of a
new source moves movers as before.

Builds: design 47 H H-A-283, H-A-284, H-A-285 (with H-A-223, H-A-244, ADR 0682)
2026-11-21 17:47:54 +01:00
11 changed files with 679 additions and 56 deletions
@@ -177,6 +177,8 @@ func run(ctx context.Context, getenv func(string) string, logOut io.Writer) erro
clock := askClock(ctx, bounds, askBound, silentBound, rv.Findings, cred.Module, time.Now)
starter.Asks, hearer.Asks = clock, clock
starter.Supersede = func(newer seat.Pipeline) { hearer.SupersedeRunning(newer) }
starter.Left = hearer.LeftInPlace // a same-source re-pin's superseded steps leave their runs (H-A-284)
starter.Revision = widener.Revision // a kept mover is placed from its kept revision (H-A-286)
hearer.Unplaced = func(p seat.Pipeline, module string) string { return starter.Unplaced(p, module, rv.Catalog.View) }
hearer.AskPinHeld = func(key, module string, pins map[string]string) {
if _, err := starter.AskPinHeld(hearer.Store, key, module, pins, widener.Revision); err != nil {
@@ -324,7 +324,7 @@ func (h *Hearer) endUnanswered(key, ask, why string) error {
var readers []int
if s.Step == seat.StepResultStepValidate {
readers = sameValidate(&p, i, now)
_, notAsked := releaseCompositions(&p, now)
_, notAsked := releaseCompositions(&p, now, h.kept(key))
readers = append(readers, notAsked...)
}
asked, err := askApproval(key, &p, now, h.Asker)
@@ -288,6 +288,65 @@ func (s *MoverStore) Get(key string) (seat.Pipeline, uint64, error) {
// when the record or a mover key was written since the read revision gave. A record carrying its steps inline has its
// mover keys written before the record, so its steps are never lost between the two.
func (s *MoverStore) Update(key string, p seat.Pipeline, revision uint64) (uint64, error) {
return s.update(key, p, revision, nil)
}
// UpdateKept is Update with kept laid over the record's kept-revisions (H-A-285): the catalog revision each kept mover's
// fingerprint is from (H-A-283, H-A-284 (2)).
func (s *MoverStore) UpdateKept(key string, p seat.Pipeline, revision uint64, kept map[string]int64) (uint64, error) {
return s.update(key, p, revision, kept)
}
// KeptRevisions are pipeline key's kept-revisions, the catalog revision each mover a same-source re-pin kept in it is from
// (H-A-283, H-A-284 (2), H-A-285); none for a pipeline that kept none.
func (s *MoverStore) KeptRevisions(key string) (map[string]int64, error) {
defer s.lock(key)()
raw, _, err := s.Raw.Get(key)
if err != nil {
return nil, err
}
if raw == nil {
return nil, fmt.Errorf("%w: %s", ErrNoPipeline, key)
}
return keptOf(raw)
}
// keptRevisionsField is the pipeline record's property kept-revisions, beside its movers (H-A-285): written and read by the
// runner alone, never part of the seat's Go form of a pipeline, which drops it on every decode.
const keptRevisionsField = "kept-revisions"
// keptOf is the kept-revisions a record carries; none when it carries none.
func keptOf(raw []byte) (map[string]int64, error) {
var fields map[string]json.RawMessage
if err := json.Unmarshal(raw, &fields); err != nil {
return nil, fmt.Errorf("the record is no object: %w", err)
}
f, ok := fields[keptRevisionsField]
if !ok {
return nil, nil
}
var kept map[string]int64
if err := json.Unmarshal(f, &kept); err != nil {
return nil, fmt.Errorf("the record's %s is no map of module to revision: %w", keptRevisionsField, err)
}
return kept, nil
}
// withKept is record with kept as its kept-revisions.
func withKept(record []byte, kept map[string]int64) ([]byte, error) {
var fields map[string]json.RawMessage
if err := json.Unmarshal(record, &fields); err != nil {
return nil, err
}
raw, err := json.Marshal(kept)
if err != nil {
return nil, err
}
fields[keptRevisionsField] = raw
return json.Marshal(fields)
}
func (s *MoverStore) update(key string, p seat.Pipeline, revision uint64, kept map[string]int64) (uint64, error) {
defer s.lock(key)()
record, want, err := split(key, p)
if err != nil {
@@ -303,6 +362,20 @@ func (s *MoverStore) Update(key string, p seat.Pipeline, revision uint64) (uint6
if cur != revision {
return 0, ErrChanged
}
// The record's kept-revisions ride on through every write, kept laid over them (H-A-285).
merged, err := keptOf(raw)
if err != nil {
return 0, fmt.Errorf("the pipeline %s: %w", key, err)
}
if len(kept) > 0 && merged == nil {
merged = map[string]int64{}
}
maps.Copy(merged, kept)
if len(merged) > 0 {
if record, err = withKept(record, merged); err != nil {
return 0, err
}
}
vals, revs, err := s.moverKeys(key)
if err != nil {
return 0, err
@@ -61,7 +61,18 @@ var moduleSteps = []string{seat.StepResultStepValidate, seat.StepResultStepCompo
// placement makes the same id at every start and the bus dedupes on it, and each mover's step its own id (design 47 H
// §746); started is the pipeline's start time, or a rerun's own (design 47 G A-297).
func AskID(started time.Time, pipeline, module, artifact, step string) string {
sum := sha256.Sum256([]byte(pipeline + "\n" + module + "\n" + artifact + "\n" + step))
return keptAskID(started, pipeline, module, artifact, step, 0)
}
// keptAskID is AskID of a step of a mover a same-source re-pin kept at catalog revision kept (H-A-286): the kept revision
// is mixed into the id's sum, so no id equals one the pipeline asked for the mover's old fingerprint, and every placing,
// pin-held ask, composition, rerun and restart of the kept mover finds the same ids again; kept 0 is AskID's own form.
func keptAskID(started time.Time, pipeline, module, artifact, step string, kept int64) string {
in := pipeline + "\n" + module + "\n" + artifact + "\n" + step
if kept > 0 {
in += "\nkept " + strconv.FormatInt(kept, 10)
}
sum := sha256.Sum256([]byte(in))
return strconv.FormatInt(started.UnixMilli(), 36) + hex.EncodeToString(sum[:3])
}
@@ -80,14 +91,16 @@ func startOf(p seat.Pipeline, now time.Time) time.Time {
// could not run naming the missing seat; the module's steps wait. It returns the steps and the asks to put on the seats'
// work queues, one per running step.
func Place(p seat.Pipeline, m seat.Mover, reg catalog.Registration, entries map[string]catalog.CatalogEntry, now time.Time, asker string) ([]seat.StepResult, []Asked) {
return place(p, m, reg, entries, now, asker, true)
return place(p, m, reg, entries, now, asker, true, 0)
}
// place is Place; share false places each build step its own ask, as a step asked before the test runs is (§730, A-468k).
// With share, the build steps of one candidate, level and share digest are asked once (§724): the first artifact's step, in
// reference order, asks the run and names it in Shared; every other step of the key reads it, keeping no ask of its own and
// naming the run's ask and the step that asked it (A-469m, A-469q).
func place(p seat.Pipeline, m seat.Mover, reg catalog.Registration, entries map[string]catalog.CatalogEntry, now time.Time, asker string, share bool) ([]seat.StepResult, []Asked) {
// kept is the catalog revision a same-source re-pin kept m at, 0 for a mover not kept: its every ask id mixes it in
// (H-A-286).
func place(p seat.Pipeline, m seat.Mover, reg catalog.Registration, entries map[string]catalog.CatalogEntry, now time.Time, asker string, share bool, kept int64) ([]seat.StepResult, []Asked) {
entry := entries[m.Module]
candidate, named := CandidateOf(p)
share = share && named
@@ -99,16 +112,9 @@ func place(p seat.Pipeline, m seat.Mover, reg catalog.Registration, entries map[
// The build step is every mover's first, required whatever the policy names, asked of the seat mesh-builds for the
// mover's own entry only (A-99, A-97): each mover is built by its own step (§746).
build := seat.StepResult{Step: seat.StepResultStepBuild, Module: m.Module, Status: seat.StepResultStatusRequired, Fingerprint: m.Fingerprint,
Seat: builds.Seat, Outcome: seat.StepResultOutcomeRunning, Started: &now, Ask: AskID(startOf(p, now), p.Pipeline, m.Module, "", seat.StepResultStepBuild)}
Seat: builds.Seat, Outcome: seat.StepResultOutcomeRunning, Started: &now, Ask: keptAskID(startOf(p, now), p.Pipeline, m.Module, "", seat.StepResultStepBuild, kept)}
steps = append(steps, build)
// A run on request's build step ask names no source (the seat mesh-builds' contract; H-A-162): its candidate's
// fingerprints are never in the builder's picture of the branch, so it waits for no revision there.
source := p.Source
if p.Run != "" {
source = 0
}
asks = append(asks, Asked{Seat: builds.Seat, ID: build.Ask, Commit: m.Commit, Ask: builds.StepRun{Pipeline: p.Pipeline, Step: builds.StepRunStepBuild, Branch: p.Branch,
Revision: p.Revision, Source: source, Entries: []builds.BuildEntry{{Module: m.Module, Commit: m.Commit, Fingerprint: m.Fingerprint}}}})
asks = append(asks, buildAsk(p, m, build.Ask))
for _, a := range arts {
name := a.Ref
if _, after, ok := strings.Cut(a.Ref, ":"); ok {
@@ -151,7 +157,7 @@ func place(p seat.Pipeline, m seat.Mover, reg catalog.Registration, entries map[
continue
}
s.Seat, s.Outcome, s.Started = bs, seat.StepResultOutcomeRunning, &now
s.Ask = AskID(startOf(p, now), p.Pipeline, m.Module, a.Ref, step)
s.Ask = keptAskID(startOf(p, now), p.Pipeline, m.Module, a.Ref, step, kept)
body := stepAsk(p, m, entry, a, language, step, s.Ask, asker, now)
ask := Asked{Seat: bs, ID: s.Ask, Ask: body, Toolchain: a.Language, Commit: m.Commit}
if share && BoundSeat(bs) {
@@ -196,7 +202,7 @@ func place(p seat.Pipeline, m seat.Mover, reg catalog.Registration, entries map[
// 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)
s.Ask = keptAskID(startOf(p, now), p.Pipeline, "", "", seat.StepResultStepValidate, kept)
asks = append(asks, wantsAsk(p, m, s.Ask, wants.StepRunStepValidate))
validating = true
case seat.StepResultStepComposition:
@@ -204,7 +210,7 @@ func place(p seat.Pipeline, m seat.Mover, reg catalog.Registration, entries map[
// 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)
s.Ask = keptAskID(startOf(p, now), p.Pipeline, m.Module, "", step, kept)
if validating {
s.Ask, s.Why = "", "asked once validate passed"
break
@@ -309,12 +315,13 @@ func (s *Starter) AskPinHeld(store Updater, key, module string, pins map[string]
return 0, nil
}
var entry catalog.CatalogEntry
unread := ""
switch half, err := readRevision(revision, p.Branch, p.Revision); {
at, kept, whose, unread := moverRevision(store, p, module)
switch half, err := readRevision(revision, p.Branch, at); {
case unread != "":
case err != nil:
unread = fmt.Sprintf("revision %d of %s, the pipeline's, cannot be read for its entry: %v", p.Revision, p.Branch, err)
unread = fmt.Sprintf("revision %d of %s, %s, cannot be read for its entry: %v", at, p.Branch, whose, err)
case half.Entries[module].Fp != m.Fingerprint:
unread = fmt.Sprintf("revision %d of %s holds %s at %q, not the mover's %s", p.Revision, p.Branch, module, half.Entries[module].Fp, m.Fingerprint)
unread = fmt.Sprintf("revision %d of %s holds %s at %q, not the mover's %s", at, p.Branch, module, half.Entries[module].Fp, m.Fingerprint)
default:
entry = half.Entries[module]
}
@@ -332,7 +339,7 @@ func (s *Starter) AskPinHeld(store Updater, key, module string, pins map[string]
if unread != "" || j < 0 || err != nil {
why := unread
if why == "" {
why = fmt.Sprintf("revision %d of %s names no artifact %s of %s to ask it of", p.Revision, p.Branch, st.Artifact, module)
why = fmt.Sprintf("revision %d of %s names no artifact %s of %s to ask it of", at, p.Branch, st.Artifact, module)
}
st.Outcome, st.Ended = seat.StepResultOutcomeCouldNotRun, &now
st.Why = "its build passed with its pins, but " + why + " (H-A-207, H-A-205)"
@@ -342,7 +349,7 @@ func (s *Starter) AskPinHeld(store Updater, key, module string, pins map[string]
}
a := entry.Artifacts[j]
st.Outcome, st.Why, st.Started = seat.StepResultOutcomeRunning, "", &now
st.Ask = AskID(startOf(p, now), p.Pipeline, module, a.Ref, st.Step)
st.Ask = keptAskID(startOf(p, now), p.Pipeline, module, a.Ref, st.Step, kept)
ask := Asked{Seat: st.Seat, ID: st.Ask, Ask: stepAsk(p, m, entry, a, language, st.Step, st.Ask, s.Name, now), Toolchain: a.Language, Commit: m.Commit}
if a.Package != nil {
ask.Package = a.Package.Name
@@ -363,6 +370,57 @@ func (s *Starter) AskPinHeld(store Updater, key, module string, pins map[string]
}
}
// keptRevisions is the state pipelines' kept-revisions (MoverStore, H-A-285): the catalog revision each mover a same-source
// re-pin kept in a pipeline is from (H-A-283, H-A-284 (2)).
type keptRevisions interface {
KeptRevisions(key string) (map[string]int64, error)
UpdateKept(key string, p seat.Pipeline, revision uint64, kept map[string]int64) (uint64, error)
}
// moverRevision is the catalog revision mover module's entry of p is read at (H-A-284 (2)): the one its pipeline kept it at
// when a same-source re-pin kept it, else the pipeline's; whose says which, and unread why it is not read when its record
// cannot be.
// It answers that revision, the kept revision (0 for a mover not kept), whose it is, and why it is not read.
func moverRevision(store Updater, p seat.Pipeline, module string) (int64, int64, string, string) {
kept, err := keptOfStore(store, p.Pipeline)
if err != nil {
return p.Revision, 0, "the pipeline's", fmt.Sprintf("the revision %s was kept at in %s cannot be read: %v", module, p.Pipeline, err)
}
if r := kept[module]; r > 0 {
return r, r, "the one the pipeline kept " + module + " at (H-A-284)", ""
}
return p.Revision, 0, "the pipeline's", ""
}
// keptOfStore is pipeline key's kept-revisions in store (H-A-285); none for a store that keeps none.
func keptOfStore(store any, key string) (map[string]int64, error) {
ks, ok := store.(keptRevisions)
if !ok || key == "" {
return nil, nil
}
kept, err := ks.KeptRevisions(key)
if errors.Is(err, ErrNoPipeline) {
return nil, nil // a pipeline not written yet keeps none
}
return kept, err
}
// keptEntries are the entries of branch's catalog revision rev, the one a same-source re-pin kept a mover at, read by its
// number (H-A-286): a kept mover is placed and pin-checked from them, never from the branch's held view; false while they
// cannot be read, and the mover waits.
func (s *Starter) keptEntries(branch string, rev int64) (map[string]catalog.CatalogEntry, bool) {
if s.Revision == nil {
s.logf("the runner reads no catalog revision, so a mover kept at revision %d of %s waits", rev, branch)
return nil, false
}
half, err := s.Revision(branch, rev)
if err != nil || half.Revision != rev {
s.logf("revision %d of %s, which a mover is kept at, is not read (%v): the mover waits for it (H-A-286)", rev, branch, err)
return nil, false
}
return half.Entries, true
}
func stepAsk(p seat.Pipeline, m seat.Mover, e catalog.CatalogEntry, a catalog.Artifact, language, step, id, asker string, now time.Time) nodebuildgo.StepAsk {
// A step is for its module alone (principle 10, A-447): the fetch always names the module's directory, and the
// artifact's named paths in it when the entry has them.
@@ -440,7 +498,8 @@ func wantsAsk(p seat.Pipeline, m seat.Mover, id, step string) Asked {
// 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) {
// kept is p's kept-revisions: a kept mover's composition id mixes its kept revision in (H-A-286).
func releaseCompositions(p *seat.Pipeline, now time.Time, kept map[string]int64) ([]Asked, []int) {
var asks []Asked
var ended []int
for _, m := range p.Movers {
@@ -466,7 +525,7 @@ func releaseCompositions(p *seat.Pipeline, now time.Time) ([]Asked, []int) {
ended = append(ended, c)
continue
}
s.Ask = AskID(startOf(*p, now), p.Pipeline, m.Module, "", seat.StepResultStepComposition)
s.Ask = keptAskID(startOf(*p, now), p.Pipeline, m.Module, "", seat.StepResultStepComposition, kept[m.Module])
s.Outcome, s.Started, s.Why = seat.StepResultOutcomeRunning, &now, ""
asks = append(asks, wantsAsk(*p, m, s.Ask, wants.StepRunStepComposition))
}
@@ -0,0 +1,213 @@
package pipeline
import (
"errors"
"fmt"
"slices"
"strings"
"time"
builds "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshbuilds"
seat "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshpipelinerunner"
)
// keepSameSource keeps, in the open pipeline of the same source revision that holds it, each mover of the revision half a
// re-pin made (design 47 H H-A-283): a revision of the same source moves no mover out of a running or waiting pipeline (as
// H-A-223 and H-A-244 (1) move one for a revision of a new source); the pipeline keeps the mover and takes its new
// fingerprint, and the revision's own pipeline starts without it. It answers the movers no open pipeline of the source
// holds, which the revision's pipeline carries.
func (s *Starter) keepSameSource(branch string, half Half, movers []seat.Mover) []seat.Mover {
if s.Store == nil || len(movers) == 0 {
return movers
}
pkeys, err := branchKeys(s.Store, branch)
if err != nil {
s.logf("the pipelines of %s are not listed, so no open pipeline of source %d keeps the movers of revision %d: %v", branch, half.Source, half.Revision, err)
return movers
}
left := movers
for _, key := range pkeys {
if len(left) == 0 {
break
}
left = s.keepIn(key, half, left)
}
return left
}
// holdsOpen says whether the pipeline p, not ended and of no run on request, is of revision half's source, older than it, and
// still holds mover module as its own.
func holdsOpen(p seat.Pipeline, half Half, module string) bool {
return (p.Outcome == seat.PipelineOutcomeRunning || p.Outcome == seat.PipelineOutcomeWaiting) && p.Run == "" &&
p.Source == half.Source && p.Revision < half.Revision && Moves(p, module) && !slices.Contains(p.Superseded, module)
}
// keepIn keeps in pipeline key each of movers it holds (H-A-283), answering the movers it does not hold. A kept mover whose
// fingerprint the re-pin moved takes its new fingerprint and commit, and the pipeline keeps the revision it is from in its
// kept-revisions (H-A-285); when its steps were placed, every one of them, open or ended, ends superseded and its steps are
// placed again from the revision's entry, the build first (H-A-284 (1)), each under an ask id its kept revision is mixed
// into (H-A-286), so no ask of the old fingerprint is kept for the new. One not placed yet is placed when it is due, from
// the entries of the revision it is kept at.
func (s *Starter) keepIn(key string, half Half, movers []seat.Mover) []seat.Mover {
for {
p, rev, err := s.Store.Get(key)
if err != nil {
return movers
}
var kept, left []seat.Mover
for _, m := range movers {
if holdsOpen(p, half, m.Module) {
kept = append(kept, m)
} else {
left = append(left, m)
}
}
if len(kept) == 0 {
return movers
}
now := s.now()
why := fmt.Sprintf("superseded: the re-pin revision %d of the pipeline's own source %d moved its mover's fingerprint; its steps are placed again (H-A-283, H-A-284)", half.Revision, half.Source)
revisions := map[string]int64{}
olds := slices.Clone(p.Movers) // the superseded steps are said at the fingerprint they ran for
var moved, unregistered []string
var ended []seat.StepResult
var leave, drop []seat.StepResult
var asks []Asked
var notAsked []int
for _, m := range kept {
i := slices.IndexFunc(p.Movers, func(o seat.Mover) bool { return o.Module == m.Module })
old := p.Movers[i]
if old.Fingerprint == m.Fingerprint && old.Commit == m.Commit {
continue
}
p.Movers[i].Fingerprint, p.Movers[i].Commit = m.Fingerprint, m.Commit
revisions[m.Module] = half.Revision
moved = append(moved, fmt.Sprintf("%s %s to %s", m.Module, old.Fingerprint, m.Fingerprint))
if p.Outcome != seat.PipelineOutcomeRunning || !placed(p, m.Module) {
continue
}
rest := make([]seat.StepResult, 0, len(p.Steps))
for _, st := range p.Steps {
if st.Module != m.Module {
rest = append(rest, st)
continue
}
live := open(st) || st.Outcome == seat.StepResultOutcomeWaiting
l, d := supersedeStep(&p, &st, why, now)
if live {
leave, drop = append(leave, l...), append(drop, d...)
}
ended = append(ended, st)
}
p.Steps = rest
a, n, unreg := s.placeAgain(&p, p.Movers[i], half, now)
asks, notAsked = append(asks, a...), append(notAsked, n...)
if unreg {
unregistered = append(unregistered, m.Module)
}
}
if len(moved) == 0 {
s.logf("%s keeps %d movers of revision %d, of its own source %d, at the fingerprints it holds (H-A-283)", key, len(kept), half.Revision, half.Source)
return left
}
var holderEnded []int
if len(asks) > 0 {
asks, holderEnded = s.holderless(&p, asks, now)
}
ks, keeps := s.Store.(keptRevisions)
if keeps {
_, err = ks.UpdateKept(key, p, rev, revisions)
} else {
_, err = s.Store.Update(key, p, rev)
}
if errors.Is(err, ErrChanged) {
continue
} else if err != nil {
s.logf("%s is not written, so the movers revision %d re-pinned stay its own at their old fingerprints: %v", key, half.Revision, err)
return left
}
if !keeps {
s.logf("%s keeps no kept-revisions, so the pin check of its re-pinned movers reads the pipeline's revision (H-A-285)", key)
}
s.logf("%s keeps the movers revision %d of its own source %d re-pinned, %s: %d steps ended superseded, %d asked again (H-A-283, H-A-284)",
key, half.Revision, half.Source, strings.Join(moved, ", "), len(ended), len(asks))
for _, st := range ended {
if s.Say == nil {
break
}
was := p
was.Movers = olds
if err := s.Say(stepEvent(seat.EventStepEnded, was, st, now)); err != nil {
s.logf("step-ended of %s's %s %s, superseded, is not said: %v", key, st.Module, st.Step, err)
}
}
if s.Left != nil {
s.Left(key, leave, drop, why)
}
for _, m := range unregistered {
s.logf("%s: %s has no registration yet: its steps wait on its registration, which places them (A-327)", key, m)
s.registrationMissing(m, key)
}
s.sayNotAsked(p, notAsked)
if len(holderEnded) > 0 {
if err := s.endedAtPlacing(p, holderEnded); err != nil {
s.logf("%v", err)
}
return left
}
if s.Steps != nil && len(asks) > 0 {
if err := s.askSteps(key, asks); err != nil {
s.logf("%s: the steps placed again are not all put, they are asked at the next start: %v", key, err)
}
}
return left
}
}
// placeAgain places the steps of kept mover m of p from the re-pin revision half's entry (H-A-284 (1)), as a mover is placed
// (placeMovers), under ask ids its kept revision is mixed into (H-A-286): it answers the asks to put, the steps placed not asked because a
// dependency did not build, and whether m has no registration. A mover not due yet (it waits on a publish) is left
// unplaced, placed when the publish is heard.
func (s *Starter) placeAgain(p *seat.Pipeline, m seat.Mover, half Half, now time.Time) ([]Asked, []int, bool) {
if s.Registration == nil {
return nil, nil, false
}
r, ok := s.Registration(m.Module)
if !ok {
return nil, nil, true
}
due, waiting, failed := ready(*p, m.Module, half.Entries)
if !due && failed == "" {
s.logf("%s: %s waits for %s before its build", p.Pipeline, m.Module, strings.Join(waiting, ", "))
return nil, nil, false
}
steps, asks := place(*p, m, r, half.Entries, now, s.Name, true, half.Revision)
supersededWhy(*p, m.Module, half.Entries, steps)
var notAsked []int
if failed != "" {
why := "its dependency " + failed + " did not build"
for k := range steps {
st := &steps[k]
if st.Outcome == seat.StepResultOutcomeBypassed {
continue
}
st.Outcome, st.Why, st.Ask, st.Shared, st.Ended = seat.StepResultOutcomeNotAsked, why, "", nil, &now
p.Unlogged = append(p.Unlogged, endEntry(p.Pipeline, *st, now))
notAsked = append(notAsked, len(p.Steps)+k)
}
asks = nil
}
p.Steps = append(p.Steps, steps...)
return asks, notAsked, false
}
// buildAsk is mover m's build step ask under id, of the seat mesh-builds for the mover's own entry only (A-99, A-97): a run on
// request's names no source (H-A-162).
func buildAsk(p seat.Pipeline, m seat.Mover, id string) Asked {
source := p.Source
if p.Run != "" {
source = 0
}
return Asked{Seat: builds.Seat, ID: id, Commit: m.Commit, Ask: builds.StepRun{Pipeline: p.Pipeline, Step: builds.StepRunStepBuild, Branch: p.Branch,
Revision: p.Revision, Source: source, Entries: []builds.BuildEntry{{Module: m.Module, Commit: m.Commit, Fingerprint: m.Fingerprint}}}}
}
@@ -0,0 +1,191 @@
package pipeline
import (
"fmt"
"slices"
"strings"
"testing"
"time"
builds "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshbuilds"
catalog "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshcatalog"
seat "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshpipelinerunner"
nodebuildgo "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/nodebuildgo"
"git.novox.be/novox/mesh-sdk/go/keys"
)
// ticking is a clock that moves a second at every read, so a start and a later re-pin never share a millisecond.
func ticking() func() time.Time {
at := time.Date(2026, 11, 21, 17, 0, 0, 0, time.UTC)
return func() time.Time { at = at.Add(time.Second); return at }
}
// repinFixture is a pipeline main.10 of source 41 moving app at src2:aa, started, with the re-pin revision 11 of the same
// source moving app to src2:ab (an entry naming a package with no version yet), and a revision 12 of a new source 42.
func repinFixture() (catalog.Registration, map[string]catalog.CatalogEntry, map[string]catalog.CatalogEntry, func(string, int64) (Half, error)) {
reg, entries := placeFixture()
repinned := map[string]catalog.CatalogEntry{}
for k, e := range entries {
repinned[k] = e
}
app := entries["app"]
app.Fp = "src2:aa"
entries["app"] = app
re := app
re.Fp, re.Packages = "src2:ab", map[string]string{"git.novox.be/novox/mesh-sdk/go": "v0.1.26", "git.novox.be/novox/x/go": ""}
repinned["app"] = re
read := func(branch string, revision int64) (Half, error) {
switch revision {
case 10:
return Half{Revision: 10, Source: 41, Entries: entries}, nil
case 11:
return Half{Revision: 11, Source: 41, Entries: repinned, Call: "release of mesh-sdk 0.1.26",
Movers: []catalog.TakeInEntry{{Module: "app", Commit: "c1", Fingerprint: "src2:ab", Repository: "o/app"}}}, nil
case 12:
return Half{Revision: 12, Source: 42, Entries: repinned, Call: "take-in of 42",
Movers: []catalog.TakeInEntry{{Module: "app", Commit: "c2", Fingerprint: "src2:ac", Repository: "o/app"}}}, nil
}
return Half{}, fmt.Errorf("no revision %d", revision)
}
return reg, entries, repinned, read
}
func revisionEvent(n int64) catalog.CatalogRevisionEvent {
return catalog.CatalogRevisionEvent{Kind: "trunk", Branch: keys.EscapeName("main"), Revision: n, CallKind: "release"}
}
// H-A-283, H-A-284, H-A-285, H-A-286: a re-pin revision of the same source moves no mover out of the running pipeline of that source:
// the pipeline keeps it at its new fingerprint, every step of it ends superseded (said at the old fingerprint, its asks
// dropped) and is placed again from the re-pin revision's entry under new asks, the build first, still naming the
// pipeline's revision; the revision the mover is kept at rides in the record's kept-revisions, where the pin check reads
// its entry; the re-pin starts no pipeline. A revision of a new source still starts its own and moves the mover out.
func TestASameSourceRepinKeepsTheMoverInItsPipeline(t *testing.T) {
reg, entries, _, read := repinFixture()
store := &MoverStore{Raw: newMemRaw()}
asks := &stepAsks{}
var said []seat.StepEvent
var left [][]seat.StepResult
s := &Starter{Pipelines: store, Store: store, Steps: asks, Name: "the-runner", Now: ticking(), Revision: read,
Registration: func(m string) (catalog.Registration, bool) { return reg, m == "app" },
Say: func(_ string, body any) error {
if ev, ok := body.(seat.StepEvent); ok && ev.Result.Outcome == seat.StepResultOutcomeSuperseded {
said = append(said, ev)
}
return nil
},
Left: func(_ string, leave, drop []seat.StepResult, _ string) { left = append(left, append(leave, drop...)) }}
h := &Hearer{Store: store, Say: func(string, any) error { return nil }}
s.Supersede = func(newer seat.Pipeline) { h.SupersedeRunning(newer) }
key := Key("main", 10)
if ok, err := s.Start(Begin{Branch: "main", Source: 41, Revision: 10, Entries: entries,
Movers: []seat.Mover{{Module: "app", Commit: "c1", Fingerprint: "src2:aa", Repository: "o/app"}}}); !ok || err != nil {
t.Fatalf("start = %v, %v", ok, err)
}
before, _, _ := store.Get(key)
oldAsks := map[string]bool{}
for _, st := range before.Steps {
if st.Ask != "" {
oldAsks[st.Ask] = true
}
}
asks.at, asks.ids, asks.asks = nil, nil, nil
ev := revisionEvent
if n, err := s.Revised(ev(11), read); n != 0 || err != nil {
t.Fatalf("the same-source re-pin started %d pipelines (%v), want none", n, err)
}
if _, _, err := store.Get(Key("main", 11)); err == nil {
t.Fatal("the same-source re-pin wrote a pipeline of its own")
}
p, _, err := store.Get(key)
if err != nil {
t.Fatal(err)
}
if m, _ := MoverOf(p, "app"); m.Fingerprint != "src2:ab" || slices.Contains(p.Superseded, "app") || p.Outcome != seat.PipelineOutcomeRunning {
t.Fatalf("the kept mover = %+v, superseded %v, outcome %s: want it kept at src2:ab, the pipeline running", m, p.Superseded, p.Outcome)
}
if len(p.Steps) != len(before.Steps) || p.Steps[0].Step != seat.StepResultStepBuild || p.Steps[0].Outcome != seat.StepResultOutcomeRunning ||
p.Steps[0].Fingerprint != "src2:ab" || oldAsks[p.Steps[0].Ask] {
t.Fatalf("the steps placed again = %+v, want the build first, running at src2:ab under a new ask", p.Steps)
}
for _, st := range p.Steps {
if st.Outcome == seat.StepResultOutcomeSuperseded || (st.Ask != "" && oldAsks[st.Ask]) {
t.Errorf("the step %s %s stands for the old fingerprint: %+v", st.Artifact, st.Step, st)
}
}
// Every old step ended superseded, said at the fingerprint it ran for; the ones open on a build node are dropped.
if len(said) != len(before.Steps) || said[0].Fingerprint != "src2:aa" || len(left) != 1 || len(left[0]) == 0 {
t.Errorf("said %d superseded steps (of %d), the first at %+v; left %v", len(said), len(before.Steps), said, left)
}
b, ok := asks.asks[0].(builds.StepRun)
if !ok || asks.ids[0] != p.Steps[0].Ask || b.Revision != 10 || b.Source != 41 || len(b.Entries) != 1 || b.Entries[0].Fingerprint != "src2:ab" {
t.Fatalf("the build asked again = %+v (%s), want the new fingerprint at the pipeline's revision", asks.asks[0], asks.ids[0])
}
if kept, err := store.KeptRevisions(key); err != nil || kept["app"] != 11 {
t.Errorf("kept-revisions = %v (%v), want app at 11", kept, err)
}
// The pin check reads the kept mover's entry at the revision it was kept at, never the pipeline's.
if n, err := s.AskPinHeld(store, key, "app", map[string]string{"git.novox.be/novox/mesh-sdk/go": "v0.1.26", "git.novox.be/novox/x/go": "v0.1.1"}, read); n == 0 || err != nil {
after, _, _ := store.Get(key)
t.Fatalf("the held steps asked %d (%v): %+v", n, err, after.Steps)
}
last := asks.asks[len(asks.asks)-1].(nodebuildgo.StepAsk)
if last.Step.Fingerprint != "src2:ab" || last.Step.Fetch.Packages["git.novox.be/novox/x/go"] != "v0.1.1" {
t.Errorf("a held step asked = %+v", last.Step)
}
// A revision of a new source starts its own pipeline and moves the mover out (H-A-223).
if n, err := s.Revised(ev(12), read); n != 1 || err != nil {
t.Fatalf("a new source's revision started %d (%v)", n, err)
}
if p, _, _ := store.Get(key); !slices.Contains(p.Superseded, "app") {
t.Errorf("the new source's revision left app in %s: %v", key, p.Superseded)
}
}
// H-A-286: a kept mover not placed at its keep (its registration arrived later) is placed from the revision it is kept at
// while the branch's held view still holds the older revision, under ask ids its kept revision is mixed into; and a restart
// (Resume) finds its running steps by those ids and asks them again.
func TestAKeptMoverIsPlacedLateAndResumedAtItsKeptRevision(t *testing.T) {
reg, entries, _, read := repinFixture()
store := &MoverStore{Raw: newMemRaw()}
asks := &stepAsks{}
registered := false
s := &Starter{Pipelines: store, Store: store, Steps: asks, Name: "the-runner", Now: ticking(), Revision: read,
Say: func(string, any) error { return nil },
Registration: func(m string) (catalog.Registration, bool) { return reg, registered && m == "app" }}
key := Key("main", 10)
if ok, err := s.Start(Begin{Branch: "main", Source: 41, Revision: 10, Entries: entries,
Movers: []seat.Mover{{Module: "app", Commit: "c1", Fingerprint: "src2:aa", Repository: "o/app"}}}); !ok || err != nil {
t.Fatalf("start = %v, %v", ok, err)
}
if n, err := s.Revised(revisionEvent(11), read); n != 0 || err != nil {
t.Fatalf("the re-pin started %d (%v)", n, err)
}
// The registration arrives while the runner's view still holds revision 10.
registered = true
lagging := func(string) (Half, bool) { return Half{Revision: 10, Source: 41, Entries: entries}, true }
if n, err := s.Registered(store, reg, lagging); n != 1 || err != nil {
t.Fatalf("the late registration placed in %d pipelines (%v)", n, err)
}
p, _, err := store.Get(key)
if err != nil {
t.Fatal(err)
}
var build seat.StepResult
held := 0
for _, st := range p.Steps {
switch {
case st.Step == seat.StepResultStepBuild:
build = st
case pinHeld(st) && strings.HasSuffix(st.Why, "git.novox.be/novox/x/go"):
held++
}
}
if want := keptAskID(*p.Started, key, "app", "", seat.StepResultStepBuild, 11); build.Ask != want || build.Fingerprint != "src2:ab" || held == 0 {
t.Fatalf("the late placing: build %+v (want ask %s), %d steps held on revision 11's unpinned package: %+v", build, want, held, p.Steps)
}
// A restart asks the kept mover's running steps again under the same ids.
asks.at, asks.ids, asks.asks = nil, nil, nil
if n, err := s.Resume(store, "main", Half{Revision: 10, Source: 41, Entries: entries}); n == 0 || err != nil || !slices.Contains(asks.ids, build.Ask) {
t.Fatalf("Resume asked %d (%v), ids %v: want the kept build %s again", n, err, asks.ids, build.Ask)
}
}
@@ -165,6 +165,13 @@ type Starter struct {
// Supersede takes out of every older running pipeline of newer's branch each mover whose fingerprint newer moved
// (H-A-223; Hearer.SupersedeRunning); nil leaves running pipelines as they are.
Supersede func(newer seat.Pipeline)
// Left takes the steps a same-source re-pin superseded in a pipeline that kept their mover out of the test runs they
// read and drops their own asks (H-A-283, H-A-284 (1); Hearer.LeftInPlace); nil leaves them.
Left func(key string, leave, drop []seat.StepResult, why string)
// Revision reads a catalog revision of a branch by its number through the catalog seat's revision verb: a mover a
// same-source re-pin kept is placed from the entries of the revision it is kept at (H-A-286); nil leaves such a mover
// waiting.
Revision func(branch string, revision int64) (Half, error)
// Fills refuses a start while a store of the runner is full (§366); nil refuses none.
Fills *Fills
// Recovered says whether a commit is named a recovery (§81, §86): its steps are asked on the build seats' stream delivery.
@@ -334,6 +341,11 @@ func (s *Starter) placeMovers(p *seat.Pipeline, reg func(module string) (catalog
var unregistered []string
var notAsked []int
var waits []seat.Mover
kept, err := keptOfStore(s.Store, p.Pipeline)
if err != nil {
s.logf("the kept-revisions of %s are not read, so its movers are placed as movers not kept: %v", p.Pipeline, err)
}
all := entries
for _, m := range p.Movers {
if placed(*p, m.Module) {
continue
@@ -343,6 +355,13 @@ func (s *Starter) placeMovers(p *seat.Pipeline, reg func(module string) (catalog
unregistered = append(unregistered, m.Module)
continue
}
// A mover a same-source re-pin kept is placed from the revision it is kept at, its ids its own (H-A-286).
entries := all
if rev := kept[m.Module]; rev > 0 {
if entries, ok = s.keptEntries(p.Branch, rev); !ok {
continue
}
}
// A mover's steps wait for the publish of each mover it builds on (§746, H-A-83 (2)): placed once each is heard,
// ended not asked when one's build ended without passing.
due, waiting, failed := ready(*p, m.Module, entries)
@@ -351,7 +370,7 @@ func (s *Starter) placeMovers(p *seat.Pipeline, reg func(module string) (catalog
waits = append(waits, m)
continue
}
steps, a := Place(*p, m, r, entries, now, s.Name)
steps, a := place(*p, m, r, entries, now, s.Name, true, kept[m.Module])
supersededWhy(*p, m.Module, entries, steps)
for _, st := range steps {
if pinHeld(st) {
@@ -390,13 +409,13 @@ func (s *Starter) placeMovers(p *seat.Pipeline, reg func(module string) (catalog
}
}
}
if steps, ended := cycled(p, waits, unregistered, reg, entries, now, s.Name); ended {
if steps, ended := cycled(p, waits, unregistered, reg, all, now, s.Name); ended {
return nil, unregistered, steps, notAsked
} else {
notAsked = append(notAsked, steps...)
}
// A mover placed after the validate ended has its composition asked, or not asked, at once (§745).
more, _ := releaseCompositions(p, now)
more, _ := releaseCompositions(p, now, kept)
asks = append(asks, more...)
asks, ended := s.holderless(p, asks, now)
return asks, unregistered, ended, notAsked
@@ -611,13 +630,24 @@ func (s *Starter) Resume(store Updater, branch string, half Half) (int, error) {
}
}
var due []Asked
kept, err := keptOfStore(store, key)
if err != nil {
s.logf("the kept-revisions of %s are not read, so its kept movers' steps are not asked again: %v", key, err)
}
for _, m := range p.Movers {
reg, ok := s.Registration(m.Module)
if !ok {
continue
}
_, shared := Place(p, m, reg, half.Entries, now, s.Name)
_, unshared := place(p, m, reg, half.Entries, now, s.Name, false)
// A kept mover's steps are found by the ids its kept revision gives, from that revision's entries (H-A-286).
entries, rev := half.Entries, kept[m.Module]
if rev > 0 {
if entries, ok = s.keptEntries(p.Branch, rev); !ok {
continue
}
}
_, shared := place(p, m, reg, entries, now, s.Name, true, rev)
_, unshared := place(p, m, reg, entries, now, s.Name, false, rev)
for _, a := range shared {
if running[a.ID] && !own[a.ID] {
due = append(due, a)
@@ -1023,6 +1053,12 @@ func (s *Starter) Revised(ev catalog.CatalogRevisionEvent, read func(branch stri
for _, e := range half.Movers {
movers = append(movers, seat.Mover{Module: e.Module, Commit: e.Commit, Fingerprint: e.Fingerprint, Repository: e.Repository})
}
// A revision of the same source moves no mover out of the open pipeline of that source holding it: that pipeline keeps
// it, and this revision starts no pipeline of its own for it (H-A-283); only a revision of a new source moves movers.
if movers = s.keepSameSource(branch, half, movers); len(movers) == 0 {
s.logf("the revision %d of %s (%s) moves only movers the open pipelines of its source %d keep: it starts no pipeline (H-A-283)", ev.Revision, branch, ev.Call, half.Source)
return 0, nil
}
movers = Tiers(movers, half.Entries, s.logf)
call := half.Call
if call == "" {
@@ -88,6 +88,9 @@ func TestARevisionOfAReleaseStartsOnePipeline(t *testing.T) {
return Half{}, fmt.Errorf("branch %q", branch)
}
r := Half{Revision: revision, Source: 41, Entries: entries, Call: "release of mesh-sdk 0.1.17"}
if revision > 10 {
r.Source = 41 + revision // a later source's revision: one of the same source keeps its movers in 10's (H-A-283)
}
if revision != 12 {
r.Movers = movers
}
@@ -199,6 +199,15 @@ func (h *Hearer) EndReaders(run string, readers []seat.TestRunReader, r seat.Tes
return first
}
// kept is pipeline key's kept-revisions (H-A-285, H-A-286); none when they cannot be read, said.
func (h *Hearer) kept(key string) map[string]int64 {
kept, err := keptOfStore(h.Store, key)
if err != nil {
h.logf("the kept-revisions of %s are not read, so its kept movers' asks take the ids of movers not kept: %v", key, err)
}
return kept
}
func (h *Hearer) now() time.Time {
if h.Now != nil {
return h.Now().UTC()
@@ -314,7 +323,7 @@ func (h *Hearer) OnStepEndedPinned(bs StepSeat, subject string, ev StepEnded, sh
if s.Step == seat.StepResultStepValidate {
readers = append(readers, sameValidate(&p, i, now)...)
var notAsked []int
due, notAsked = releaseCompositions(&p, now)
due, notAsked = releaseCompositions(&p, now, h.kept(ev.Pipeline))
readers = append(readers, notAsked...)
}
from := now
@@ -118,14 +118,8 @@ func (h *Hearer) supersedeRunningOne(key string, newer seat.Pipeline) bool {
if !slices.Contains(moved, st.Module) || (!open(*st) && st.Outcome != seat.StepResultOutcomeWaiting) {
continue
}
switch {
case sharedRun(*st) != "" && st.Seat != wants.Seat:
leave = append(leave, *st)
case st.Ask != "" && BoundSeat(st.Seat):
drop = append(drop, *st) // its own ask on a build node: the seat's drop cancels it
}
st.Outcome, st.Why, st.Ended = seat.StepResultOutcomeSuperseded, why, &now
p.Unlogged = append(p.Unlogged, endEntry(key, *st, now))
l, d := supersedeStep(&p, st, why, now)
leave, drop = append(leave, l...), append(drop, d...)
ended = append(ended, i)
}
p.Superseded = append(p.Superseded, moved...)
@@ -142,20 +136,7 @@ func (h *Hearer) supersedeRunningOne(key string, newer seat.Pipeline) bool {
h.logf("step-ended of %s's %s %s, superseded, is not said: %v", key, p.Steps[i].Module, p.Steps[i].Step, err)
}
}
for _, st := range leave {
h.leaveRun(key, st, "the mover "+st.Module+" left "+key+" for the newer "+newer.Pipeline)
}
// Its running asks on the build nodes are cancelled through the seat's drop (H-A-223). The seat mesh-builds serves no
// drop, so a build ask there runs to its end, which the runner ignores: the step is no longer open.
for _, st := range drop {
if h.DropRun == nil {
h.logf("%s: the ask %s of %s's %s is not dropped: the runner has no drop", key, st.Ask, st.Module, st.Step)
continue
}
if err := h.DropRun(st.Seat, st.Node, st.Ask, why); err != nil {
h.logf("%s: the drop of the ask %s of %s's %s is not asked of %s: %v", key, st.Ask, st.Module, st.Step, st.Seat, err)
}
}
h.leaveSteps(key, leave, drop, "the mover %s left "+key+" for the newer "+newer.Pipeline, why)
if err := h.said(p, nil, done); err != nil {
h.logf("%v", err)
}
@@ -164,6 +145,45 @@ func (h *Hearer) supersedeRunningOne(key string, newer seat.Pipeline) bool {
}
}
// supersedeStep ends the open or waiting step st of p superseded, naming why, with its step log entry: a step reading a test
// run is answered to leave it, and one with its own ask on a build node to drop it (H-A-223).
func supersedeStep(p *seat.Pipeline, st *seat.StepResult, why string, now time.Time) (leave, drop []seat.StepResult) {
switch {
case sharedRun(*st) != "" && st.Seat != wants.Seat:
leave = append(leave, *st)
case st.Ask != "" && BoundSeat(st.Seat):
drop = append(drop, *st) // its own ask on a build node: the seat's drop cancels it
}
st.Outcome, st.Why, st.Ended = seat.StepResultOutcomeSuperseded, why, &now
p.Unlogged = append(p.Unlogged, endEntry(p.Pipeline, *st, now))
return leave, drop
}
// leaveSteps takes the superseded steps of pipeline key out of the test runs they read (leaving, its %s the step's mover)
// and drops their own asks on the build nodes, naming why (H-A-223). The seat mesh-builds serves no drop, so a build ask
// there runs to its end, which the runner ignores: the step is no longer open.
func (h *Hearer) leaveSteps(key string, leave, drop []seat.StepResult, leaving, why string) {
for _, st := range leave {
h.leaveRun(key, st, fmt.Sprintf(leaving, st.Module))
}
for _, st := range drop {
if h.DropRun == nil {
h.logf("%s: the ask %s of %s's %s is not dropped: the runner has no drop", key, st.Ask, st.Module, st.Step)
continue
}
if err := h.DropRun(st.Seat, st.Node, st.Ask, why); err != nil {
h.logf("%s: the drop of the ask %s of %s's %s is not asked of %s: %v", key, st.Ask, st.Module, st.Step, st.Seat, err)
}
}
}
// LeftInPlace takes the steps a same-source re-pin superseded in pipeline key, whose mover it kept (H-A-283, H-A-284 (1)),
// out of the test runs they read and drops their own asks, naming why, and appends their step log entries.
func (h *Hearer) LeftInPlace(key string, leave, drop []seat.StepResult, why string) {
h.leaveSteps(key, leave, drop, "the mover %s of "+key+" was re-pinned and its steps placed again (H-A-284)", why)
h.appendUnlogged(key)
}
// supersedeWaiting takes, in each older waiting pipeline of newer's branch, the movers newer also moves out of it (design 47 H
// §748, ADR 0682 §7): a waiting pipeline left with no mover ends superseded, its waiting key deleted, saying wait-ended and its
// pipeline-ended. newer is a pipeline just written, waiting or placed: a mover a newer revision moves leaves every pipeline not
@@ -530,9 +530,11 @@ func (v Verbs) passedReader(reader RunReader, run string) bool {
// under one id is kept once), saying it is a rerun and by whom. The validate ask is the pipeline's one, naming no mover
// (H-A-51): its rerun asks that one ask again; a composition's rerun builds the mover's composition ask (H-A-236).
func (v Verbs) askOf(p seat.Pipeline, s seat.StepResult, caller string, now time.Time) (*Asked, error) {
id := AskID(now, p.Pipeline, s.Module, s.Artifact, s.Step)
// A kept mover's rerun mixes its kept revision into the id (H-A-286).
rev := v.keptOf(p.Pipeline)[s.Module]
id := keptAskID(now, p.Pipeline, s.Module, s.Artifact, s.Step, rev)
if s.Seat == wants.Seat && s.Step == seat.StepResultStepValidate {
id = AskID(now, p.Pipeline, "", "", seat.StepResultStepValidate)
id = keptAskID(now, p.Pipeline, "", "", seat.StepResultStepValidate, rev)
}
a, err := v.placedAsk(p, s, id, now)
if err != nil {
@@ -580,8 +582,15 @@ func (v Verbs) placedAsk(p seat.Pipeline, s seat.StepResult, id 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, m, reg, half.Entries, now, v.Starter.Name, false)
base := AskID(startOf(p, now), p.Pipeline, m.Module, s.Artifact, s.Step)
// A kept mover's step is the one placed from the revision it is kept at, under its kept ids (H-A-286).
entries, rev := half.Entries, v.keptOf(p.Pipeline)[m.Module]
if rev > 0 {
if entries, ok = v.Starter.keptEntries(p.Branch, rev); !ok {
return nil, fmt.Errorf("revision %d of %s, which %s is kept at, is not read: the step is asked when it is", rev, p.Branch, m.Module)
}
}
_, placed := place(p, m, reg, entries, now, v.Starter.Name, false, rev)
base := keptAskID(startOf(p, now), p.Pipeline, m.Module, s.Artifact, s.Step, rev)
for _, a := range placed {
if a.ID != base {
continue
@@ -596,6 +605,14 @@ func (v Verbs) placedAsk(p seat.Pipeline, s seat.StepResult, id string, now time
return nil, fmt.Errorf("the %s step of %s is placed no ask now", s.Step, p.Pipeline)
}
// keptOf is pipeline key's kept-revisions (H-A-285); none when they cannot be read, said.
func (v Verbs) keptOf(key string) map[string]int64 {
if v.Hearer == nil {
return nil
}
return v.Hearer.kept(key)
}
// Run starts a run on request for the caller the bus proved (design 47 G §64; Starter.Run): its pipelines written, its
// run-started said, its steps placed when its candidate's revision is heard.
func (v Verbs) Run(caller string, in seat.RunInput) (seat.RunAnswer, error) {