From d13efa8abe2c248cdd30c05c269f1fc2ec4f0b04 Mon Sep 17 00:00:00 2001 From: jochen Date: Sun, 22 Nov 2026 01:22:06 +0100 Subject: [PATCH] R9: the stalled bound is the setting stalled-bound; the health names a step whose ask is untaken past it MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Builds: design 47 H2 §790, §778 (the health line), §781 (read through mesh-sdk's settings reader) --- .../cmd/mesh-delivery-pipeline-tools/main.go | 17 +++++--- .../mesh-delivery-pipeline-tools/main_test.go | 4 +- .../cmd/mesh-delivery-pipeline/main.go | 7 ++++ .../run_integration_test.go | 28 ++++++++++++- .../internal/pipeline/consumers.go | 41 +++++++++++-------- .../internal/pipeline/consumers_test.go | 31 +++++++++++++- .../mesh-delivery-pipeline/manifest_test.go | 10 ++++- modules/mesh-delivery-pipeline/module.json | 7 ++++ 8 files changed, 118 insertions(+), 27 deletions(-) diff --git a/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline-tools/main.go b/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline-tools/main.go index b1a2627e1..ec50980ba 100644 --- a/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline-tools/main.go +++ b/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline-tools/main.go @@ -103,17 +103,18 @@ func FirstViewTools(module string, st stdio.KeptState, acts views.HandActs, now // runner's state pipelines as show does and the ages its process writes in the state consumers, and asks no seat verb. A // running pipeline it first names stalled is said in this program's journal through logf, once per key for the // program's life (H-A-311 (3), H-A-313). -func HealthTool(pipelines, consumers, firstViews pipeline.Kept, now func() time.Time, logf func(string, ...any)) stdio.Tool { +func HealthTool(pipelines, consumers, firstViews pipeline.Kept, bound time.Duration, now func() time.Time, logf func(string, ...any)) stdio.Tool { var mu sync.Mutex said := map[string]bool{} return stdio.Tool{Name: Prefix + "_health", Description: "The pipeline runner's health: healthy when it answers show, each of its durable consumers' oldest " + "unacknowledged message waits less than five minutes and no running pipeline has had nothing open and nothing " + - "newly placed for five minutes; otherwise it names each consumer behind and each such pipeline by its key. It " + + "newly placed, nor a step's ask stayed untaken, for the setting stalled-bound (five minutes by default); otherwise it " + + "names each consumer behind, each such pipeline by its key and each such step. It " + "answers registrations-read: whether the runner's registrations view's first read is in, and since when.", Input: map[string]any{"type": "object", "properties": map[string]any{}}, Run: func(map[string]any) (any, error) { - a, stalled := pipeline.HealthStalled(pipelines, consumers, now()) + a, stalled := pipeline.HealthStalled(pipelines, consumers, now(), bound) // design 47 H2 §788: whether the registrations are read, from the runner's own first-views state. read, err := pipeline.RegistrationsReadOf(firstViews) if err != nil { @@ -124,7 +125,7 @@ func HealthTool(pipelines, consumers, firstViews pipeline.Kept, now func() time. for _, key := range stalled { if !said[key] && logf != nil { said[key] = true - logf("the running pipeline %s has had nothing open and nothing newly placed for %s or more: runner_health names it unhealthy (H-A-311)", key, pipeline.StalledAfter) + logf("%s has stood still for %s or more (nothing open and nothing newly placed, or its ask untaken): runner_health names it unhealthy (H-A-311, design 47 H2 §790)", key, bound) } } return HealthAnswer{Answer: a, RegistrationsRead: read}, nil @@ -174,6 +175,12 @@ func StoresFill(state func(string) (*stdio.StateInfo, error), objects func(strin } func main() { + // design 47 H2 §790, §781: the stalled bound is the runner's setting, read here as its process reads it. + stalledBound, err := stdio.SettingDuration(pipeline.StalledBoundSetting, pipeline.DefaultStalledBound) + if err != nil { + fmt.Fprintf(os.Stderr, "[mesh-delivery-pipeline-tools] %v\n", err) + os.Exit(1) + } fill := StoresFill(func(n string) (*stdio.StateInfo, error) { return stdio.State(n).Info() }, func(n string) (buscalls.Fill, error) { return busstate.ObjectsOf(n).Fill() }, func(n string) (*stdio.LogInfo, error) { return stdio.Log(n).Info() }, time.Now) @@ -185,7 +192,7 @@ func main() { tools = append(tools, CancelTool(r.List, stdio.Ask), RerunTool(stdio.Ask)) tools = append(tools, VerbTools(stdio.Ask)...) tools = append(tools, TestRunsTools(stdio.Ask)...) - tools = append(tools, HealthTool(r.Pipelines, kept{stdio.State(pipeline.StateConsumers)}, kept{stdio.State(views.StatusState)}, time.Now, + tools = append(tools, HealthTool(r.Pipelines, kept{stdio.State(pipeline.StateConsumers)}, kept{stdio.State(views.StatusState)}, stalledBound, time.Now, func(f string, a ...any) { fmt.Fprintf(os.Stderr, "[mesh-delivery-pipeline-tools] "+f+"\n", a...) })) tools = append(tools, WaitingTool(kept{stdio.State(seat.StateQueue)})) tools = append(tools, UnfinishedTools(keptDelete{kept{stdio.State(pipeline.StateUnfinished)}}, meshhandactsclient.Recorder{Ask: stdio.Ask})...) diff --git a/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline-tools/main_test.go b/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline-tools/main_test.go index 768f3daa8..2b1d63a42 100644 --- a/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline-tools/main_test.go +++ b/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline-tools/main_test.go @@ -42,7 +42,7 @@ func TestTools(t *testing.T) { names = append(names, tl.Name) } // RN25 (§468, §76; A-164): the health check is the bundle's runner_health. - names = append(names, HealthTool(none{}, none{}, none{}, nil, nil).Name, WaitingTool(none{}).Name) + names = append(names, HealthTool(none{}, none{}, none{}, pipeline.DefaultStalledBound, nil, nil).Name, WaitingTool(none{}).Name) // §606, §549: the unlogged entries are listed and appended by hand. for _, tl := range UnloggedTools(stdio.State("pipelines"), stdio.Log("step-log"), nil, nil) { names = append(names, tl.Name) @@ -71,7 +71,7 @@ func TestTools(t *testing.T) { `"movers":[{"module":"app"}],"steps":[{"module":"app","step":"build","outcome":"passed","status":"required","started":"2026-11-21T20:15:52Z","ended":"2026-11-21T20:17:55Z"}]}`} var journal []string firstViews := queueOf{} - health := HealthTool(quiet, none{}, firstViews, func() time.Time { return now }, func(f string, a ...any) { journal = append(journal, fmt.Sprintf(f, a...)) }) + health := HealthTool(quiet, none{}, firstViews, pipeline.DefaultStalledBound, func() time.Time { return now }, func(f string, a ...any) { journal = append(journal, fmt.Sprintf(f, a...)) }) for range 2 { out, err := health.Run(nil) if got, _ := json.Marshal(out); err != nil || !strings.Contains(string(got), "main.137 (nothing open and nothing placed for 17m5s)") { diff --git a/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline/main.go b/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline/main.go index 0936a06ea..96dcee407 100644 --- a/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline/main.go +++ b/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline/main.go @@ -20,6 +20,7 @@ import ( 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" + stdio "git.novox.be/novox/mesh-sdk/go" "git.novox.be/novox/mesh-sdk/go/process" "git.novox.be/novox/mesh-sdk/go/seatlist" @@ -166,6 +167,12 @@ func run(ctx context.Context, getenv func(string) string, logOut io.Writer) erro if err != nil { return err } + // design 47 H2 §790, §781: the stalled bound, read as the tools program reads it; a value that is no duration stops the start. + stalledBound, err := stdio.SettingDuration(pipeline.StalledBoundSetting, pipeline.DefaultStalledBound) + if err != nil { + return err + } + logger.Printf("health: a running pipeline with nothing open and nothing newly placed, or a step whose ask is untaken, is named after %s (%s)", stalledBound, pipeline.StalledBoundSetting) // Its asking half (§22, §24): a pipeline's steps are placed from the module's registration and each build seat is asked // for its step. starter := &pipeline.Starter{Pipelines: store, Logf: logger.Printf, Say: say, diff --git a/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline/run_integration_test.go b/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline/run_integration_test.go index fab8b6a12..ea9c12ccb 100644 --- a/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline/run_integration_test.go +++ b/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline/run_integration_test.go @@ -22,6 +22,7 @@ import ( 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" + stdio "git.novox.be/novox/mesh-sdk/go" "git.novox.be/novox/mesh-sdk/go/buscompose" "git.novox.be/novox/mesh-sdk/go/process" "git.novox.be/novox/mesh-sdk/go/seatlist" @@ -50,6 +51,8 @@ func TestTheRunnerPlacesAPipelineAsksItsBuildTakesItsEndAndAnswersAReview(t *tes ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) defer cancel() 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"}}} + // design 47 H2 §790: the stalled bound is the setting stalled-bound, here one minute, read as the node-engine composes it. + t.Setenv(stdio.SettingWord(pipeline.StalledBoundSetting), "1m") // The branch main has no revision yet at the runner's start (none-yet), then revision 1 holding app (A-336). var revised atomic.Bool w := startWhole(t, ctx, []catalog.Registration{reg}, func([]byte) catalog.RevisionAnswer { @@ -77,6 +80,15 @@ func TestTheRunnerPlacesAPipelineAsksItsBuildTakesItsEndAndAnswersAReview(t *tes if len(p.Steps) != 0 { t.Fatalf("a take-in before its branch's half placed %d steps, want none (A-336)", len(p.Steps)) } + // design 47 H2 §790: at one minute the health names the pipeline with nothing placed, a minute after its start. + bound, err := stdio.SettingDuration(pipeline.StalledBoundSetting, pipeline.DefaultStalledBound) + if err != nil || bound != time.Minute || !strings.Contains(logs.String(), "is named after 1m0s (stalled-bound)") { + t.Fatalf("the stalled bound %s (%v); the process says it: %t", bound, err, strings.Contains(logs.String(), "is named after 1m0s")) + } + noConsumers := kvKept{ctx, mustKV(t, ctx, js, module+"_consumers")} + if a := pipeline.Health(kvKept{ctx, pipelines}, noConsumers, p.Started.Add(61*time.Second), bound); a.Healthy || !strings.Contains(a.Why, key+" (nothing open") { + t.Fatalf("a minute after its start, with nothing placed, the health says %+v", a) + } // The revision said is main's first half: held, it places the pipeline's steps from the registration (A-327). revised.Store(true) rev, _ := json.Marshal(catalog.CatalogRevisionEvent{V: 1, Revision: 1, Kind: "trunk", Branch: "main", Source: 3}) @@ -88,6 +100,10 @@ func TestTheRunnerPlacesAPipelineAsksItsBuildTakesItsEndAndAnswersAReview(t *tes if build.Outcome != seat.StepResultOutcomeRunning || build.Ask == "" { t.Fatalf("the build step = %+v", build) } + // Once a step is placed in it, the health no longer names it (§790). + if a := pipeline.Health(kvKept{ctx, pipelines}, noConsumers, p.Started.Add(61*time.Second), bound); strings.Contains(a.Why, key+" (nothing open") { + t.Fatalf("with its build placed, the health still names %s: %+v", key, a) + } // The build is asked of the seat mesh-builds: its ask is on its work queue. waitFor(t, ctx, logs, func() bool { info, err := asks.Info(ctx); return err == nil && info.State.Msgs >= 1 }) @@ -167,7 +183,7 @@ func TestTheRunnerPlacesAPipelineAsksItsBuildTakesItsEndAndAnswersAReview(t *tes e, err := consumers.Get(ctx, "n1_"+module) return err == nil && json.Unmarshal(e.Value(), &facts) == nil && facts.OldestUnacknowledged.IsZero() && facts.Acknowledged > 0 }) - if a := pipeline.Health(kvKept{ctx, pipelines}, kvKept{ctx, consumers}, time.Now()); !a.Healthy { + if a := pipeline.Health(kvKept{ctx, pipelines}, kvKept{ctx, consumers}, time.Now(), bound); !a.Healthy { t.Errorf("runner_health over the bus: %+v", a) } } @@ -293,6 +309,16 @@ func startWhole(t *testing.T, ctx context.Context, regs []catalog.Registration, return whole{nc: nc, js: js, asks: asks, pipelines: pipelines, logs: logs} } +// mustKV is the bucket name. +func mustKV(t *testing.T, ctx context.Context, js jetstream.JetStream, name string) jetstream.KeyValue { + t.Helper() + kv, err := js.KeyValue(ctx, name) + if err != nil { + t.Fatal(err) + } + return kv +} + // kvKept reads a bucket as the tools bundle's states do. type kvKept struct { ctx context.Context diff --git a/modules/mesh-delivery-pipeline/internal/pipeline/consumers.go b/modules/mesh-delivery-pipeline/internal/pipeline/consumers.go index 792c9b92c..50076dbd2 100644 --- a/modules/mesh-delivery-pipeline/internal/pipeline/consumers.go +++ b/modules/mesh-delivery-pipeline/internal/pipeline/consumers.go @@ -22,32 +22,39 @@ const StateConsumers = process.ConsumersState // behind (§76). const BehindAfter = 5 * time.Minute -// StalledAfter is how long a running pipeline may have nothing open and nothing newly placed before the runner's health -// names it stalled (H-A-311 (3)): the mesh's own rule for nothing moving (nothing-moved-in-five-minutes), not a setting -// (H-A-322). -const StalledAfter = 5 * time.Minute +// DefaultStalledBound is the setting stalled-bound's default (design 47 H2 §790): how long a running pipeline may have +// nothing open and nothing newly placed, or a step's ask stay untaken (§778), before the runner's health names it; the +// mesh's own rule for nothing moving (nothing-moved-in-five-minutes). +const DefaultStalledBound = 5 * time.Minute + +// StalledBoundSetting is the runner's setting of that bound, read by its process and its tools program (§790, §781). +const StalledBoundSetting = "stalled-bound" // Stalled is the key of each running pipeline, as show reads it, that has had nothing open (no step asked and not ended, -// no required step waiting but on a package's publish) and nothing newly placed, started or ended for StalledAfter at now (H-A-311 (3)), each with -// how long, in key order. -func Stalled(pipelines Kept, now time.Time) ([]string, error) { +// no required step waiting but on a package's publish) and nothing newly placed, started or ended for bound at now +// (H-A-311 (3), design 47 H2 §790), each with how long, in key order; and each step of a running pipeline whose ask is +// still untaken bound after it was put (§778), each with its seat and how long. +func Stalled(pipelines Kept, now time.Time, bound time.Duration) ([]string, error) { all, err := Reads{Pipelines: pipelines}.pipelines() if err != nil { return nil, err } - var out []string + var out, untaken []string for _, p := range all { if p.Outcome != seat.PipelineOutcomeRunning { continue } last, busy := startedOf(p), false for _, st := range p.Steps { + if st.Ask != "" && st.Ended == nil && st.TakenAt == nil && st.AskedAt != nil && open(st) && now.Sub(*st.AskedAt) >= bound { + untaken = append(untaken, fmt.Sprintf("%s %s %s (its ask on %s untaken for %s)", p.Pipeline, st.Module, st.Step, + st.Seat, now.Sub(*st.AskedAt).Round(time.Second))) + } // A required step waiting (an approval, a composition on its validate) is open, as the end's judgement holds it; // an optional one waiting holds nothing (A-104), and neither does one waiting on a package's publish, as a mover // with no steps waiting on one does not (H-A-326 (2)). if open(st) || (st.Outcome == seat.StepResultOutcomeWaiting && st.Status == seat.StepResultStatusRequired && !pinHeld(st)) { busy = true - break } for _, at := range []*time.Time{st.Started, st.Ended} { if at != nil && at.After(last) { @@ -55,42 +62,42 @@ func Stalled(pipelines Kept, now time.Time) ([]string, error) { } } } - if busy || last.IsZero() || now.Sub(last) < StalledAfter { + if busy || last.IsZero() || now.Sub(last) < bound { continue } out = append(out, fmt.Sprintf("%s (nothing open and nothing placed for %s)", p.Pipeline, now.Sub(last).Round(time.Second))) } - return out, nil + return append(out, untaken...), nil } // Health is the runner's health as its tool runner_health answers it (§468, §76, §495; A-164): healthy when its state // pipelines answers, as show reads it, each durable consumer's oldest unacknowledged message waits less than // BehindAfter, and no running pipeline is stalled (H-A-311 (3)); otherwise unhealthy naming each consumer behind and // how long, and each stalled pipeline by its key. -func Health(pipelines, consumers Kept, now time.Time) health.Answer { - a, _ := HealthStalled(pipelines, consumers, now) +func Health(pipelines, consumers Kept, now time.Time, bound time.Duration) health.Answer { + a, _ := HealthStalled(pipelines, consumers, now, bound) return a } // HealthStalled is Health with the keys of the running pipelines it names stalled, so the tools program says each in its // journal once (H-A-313). -func HealthStalled(pipelines, consumers Kept, now time.Time) (health.Answer, []string) { +func HealthStalled(pipelines, consumers Kept, now time.Time, bound time.Duration) (health.Answer, []string) { if _, err := pipelines.Keys(); err != nil { return health.Unhealthy(fmt.Sprintf("The runner does not answer show: its state pipelines cannot be listed (%v).", err)), nil } - stalled, err := Stalled(pipelines, now) + stalled, err := Stalled(pipelines, now, bound) if err != nil { return health.Unhealthy(fmt.Sprintf("The runner's running pipelines cannot be read as show reads them (%v).", err)), nil } var keys []string for _, s := range stalled { - keys = append(keys, strings.SplitN(s, " ", 2)[0]) + keys = append(keys, strings.SplitN(s, " (", 2)[0]) } a := consumersHealth(consumers, now) if len(stalled) == 0 { return a, nil } - why := fmt.Sprintf("The runner's running pipelines with nothing open and nothing newly placed for %s or more: %s.", StalledAfter, strings.Join(stalled, ", ")) + why := fmt.Sprintf("The runner's running pipelines with nothing open and nothing newly placed, or a step whose ask is untaken, for %s or more: %s.", bound, strings.Join(stalled, ", ")) if !a.Healthy { why = a.Why + " " + why } diff --git a/modules/mesh-delivery-pipeline/internal/pipeline/consumers_test.go b/modules/mesh-delivery-pipeline/internal/pipeline/consumers_test.go index de47a48cc..3c4e0edc6 100644 --- a/modules/mesh-delivery-pipeline/internal/pipeline/consumers_test.go +++ b/modules/mesh-delivery-pipeline/internal/pipeline/consumers_test.go @@ -65,8 +65,37 @@ func TestHealth(t *testing.T) { {"a pipeline waiting only on packages is named", heldOnPublish(piped(now, "main.137", -20*time.Minute, seat.StepResultOutcomeWaiting), "main.137"), age("n_runner", 0), false, "main.137 (nothing open and nothing placed for 20m0s)"}, } + // design 47 H2 §778, §790: a step whose ask is untaken past the bound is named with its seat; the bound is the setting's. + untaken := func(asked time.Duration, taken bool) mapKept { + k := piped(now, "main.140", -time.Minute, seat.StepResultOutcomeWaitingForABuildNode) + var p seat.Pipeline + _ = json.Unmarshal(k["main.140"], &p) + at := now.Add(-asked) + p.Steps[0].Ask, p.Steps[0].Seat, p.Steps[0].AskedAt, p.Steps[0].Ended = "ask-1", "mesh-builds", &at, nil + if taken { + p.Steps[0].TakenAt = &at + } + raw, _ := json.Marshal(p) + k["main.140"] = raw + return k + } + rows = append(rows, []struct { + name string + pipelines Kept + consumers Kept + healthy bool + says string + }{ + {"an ask untaken six minutes is named", untaken(6*time.Minute, false), age("n_runner", 0), false, "main.140 app build (its ask on mesh-builds untaken for 6m0s)"}, + {"an ask untaken four minutes is not", untaken(4*time.Minute, false), age("n_runner", 0), true, ""}, + {"a taken ask is not", untaken(20*time.Minute, true), age("n_runner", 0), true, ""}, + }...) + if a := Health(piped(now, "main.137", -2*time.Minute, seat.StepResultOutcomePassed), age("n_runner", 0), now, time.Minute); a.Healthy || + !strings.Contains(a.Why, "main.137 (nothing open and nothing placed for 2m0s)") { + t.Errorf("at a one-minute bound a pipeline quiet two minutes: %q", a.Why) + } for _, r := range rows { - a := Health(r.pipelines, r.consumers, now) + a := Health(r.pipelines, r.consumers, now, DefaultStalledBound) if a.Healthy != r.healthy || !strings.Contains(a.Why, r.says) { t.Errorf("%s: healthy %v %q; want %v saying %q", r.name, a.Healthy, a.Why, r.healthy, r.says) } diff --git a/modules/mesh-delivery-pipeline/manifest_test.go b/modules/mesh-delivery-pipeline/manifest_test.go index de97d07d5..00ed76286 100644 --- a/modules/mesh-delivery-pipeline/manifest_test.go +++ b/modules/mesh-delivery-pipeline/manifest_test.go @@ -207,7 +207,15 @@ func runSettingsOf(raw []byte) bool { } want := map[string]string{"test-runs-cap-mib": "number", "test-runs-kept": "string", "test-step-bound": "string", "run-untaken-bound": "string", "ask-unanswered-bound": "string", "ask-silent-bound": "string", "widens-read-bound": "string", "revisions-kept": "number", "pipelines-at-once": "number", "pipelines-waiting-cap": "number"} - if len(m.Config) != len(want) || m.Config["test-runs-cap-mib"]["maximum"] != float64(64) || m.Config["test-runs-cap-mib"]["default"] != float64(16) || + // design 47 H2 §790, §781: stalled-bound is read through mesh-sdk's settings reader, by the process and the tools + // program alike, from the words the node-engine composes: no file of its own. + words := map[string]string{"stalled-bound": "string"} + for key, kind := range words { + if m.Config[key]["type"] != kind || m.Config[key]["default"] != "5m" || m.Config[key]["runtime"] != true { + return false + } + } + if len(m.Config) != len(want)+len(words) || m.Config["test-runs-cap-mib"]["maximum"] != float64(64) || m.Config["test-runs-cap-mib"]["default"] != float64(16) || m.Config["pipelines-at-once"]["minimum"] != float64(1) || m.Config["pipelines-at-once"]["maximum"] != float64(8) || m.Config["pipelines-at-once"]["default"] != float64(1) || m.Config["pipelines-waiting-cap"]["default"] != float64(64) { return false diff --git a/modules/mesh-delivery-pipeline/module.json b/modules/mesh-delivery-pipeline/module.json index b5b28ce67..c438b8f3d 100644 --- a/modules/mesh-delivery-pipeline/module.json +++ b/modules/mesh-delivery-pipeline/module.json @@ -167,6 +167,13 @@ "trusted": false, "default": "10m" }, + "stalled-bound": { + "type": "string", + "description": "how long a running pipeline may have nothing open and nothing newly placed, or a step's ask stay untaken, before the runner's health names it, a Go duration such as 5m (design 47 H2 sections 778, 790).", + "trusted": false, + "runtime": true, + "default": "5m" + }, "ask-silent-bound": { "type": "string", "description": "how long an ask the runner puts on a seat whose holder says nothing before the step's end (mesh-builds, mesh-wants) may go without that end before its step ends could not run, a Go duration such as 45m (design 47 H H-A-243).",