diff --git a/modules/mesh-delivery-builder/buildrun/faults.go b/modules/mesh-delivery-builder/buildrun/faults.go index 0d9b4def4..90a5f31f5 100644 --- a/modules/mesh-delivery-builder/buildrun/faults.go +++ b/modules/mesh-delivery-builder/buildrun/faults.go @@ -4,7 +4,6 @@ import ( "strings" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-builder/builds" - "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-sdk/buildstep" ) // The words of a key that failed on a transport fault (design 47 G §568, A-76): `transport fault: , , @@ -23,8 +22,9 @@ const ( ) // FaultClass is the class of a call's error or a step's reason: the words the builder's retake reads a transport fault by -// (buildstep.PassingCause), read as no responders, a name lookup, a deadline or, for every other refused, reset or cut -// connection, a connection. +// (buildstep.PassingCause), read as no responders (a registry's bundle that exited included, design 47 H2 §799), a name +// lookup, a deadline or, for every other refused, reset or cut connection (a forge's 401 or 5xx included), a connection. +// A build module's why keeps its part, `fetch: ` or `publish: ` (§799), in the cause TransportFault says. func FaultClass(cause string) string { c := strings.ToLower(cause) has := func(words ...string) bool { @@ -36,7 +36,7 @@ func FaultClass(cause string) string { return false } switch { - case has("no responders", strings.ToLower(buildstep.HolderSilentWords), "jetstream not enabled"): + case has("no responders", "bundle exited", "jetstream not enabled"): return ClassNoResponders case has("no such host", "name resolution", "lookup ", "could not resolve", "enotfound", "eai_again"): return ClassNameLookup diff --git a/modules/mesh-delivery-builder/buildrun/faults_test.go b/modules/mesh-delivery-builder/buildrun/faults_test.go index 528b06999..d8fe02e16 100644 --- a/modules/mesh-delivery-builder/buildrun/faults_test.go +++ b/modules/mesh-delivery-builder/buildrun/faults_test.go @@ -1,17 +1,23 @@ package buildrun -import "testing" +import ( + "strings" + "testing" + + "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-builder/builds" +) // Design 47 G §568, A-76: the class of a transport fault is read from the call's error, and its words are one form. func TestFaultClassAndWords(t *testing.T) { for cause, class := range map[string]string{ - "nats: no responders available for request": ClassNoResponders, - "the holder is silent: seat x answered": ClassNoResponders, - "lookup proxy: no such host": ClassNameLookup, - "Get https://r: context deadline exceeded": ClassDeadline, - "read tcp: i/o timeout": ClassDeadline, - "dial tcp: connection refused": ClassConnection, - "ssh: kex_exchange_identification: read: reset": ClassConnection, + "nats: no responders available for request": ClassNoResponders, + "publish: the bundle exited": ClassNoResponders, + "fetch: git fetch: The requested URL returned error: 401": ClassConnection, + "lookup proxy: no such host": ClassNameLookup, + "Get https://r: context deadline exceeded": ClassDeadline, + "read tcp: i/o timeout": ClassDeadline, + "dial tcp: connection refused": ClassConnection, + "ssh: kex_exchange_identification: read: reset": ClassConnection, } { if got := FaultClass(cause); got != class { t.Errorf("FaultClass(%q) = %q, want %q", cause, got, class) @@ -20,4 +26,10 @@ func TestFaultClassAndWords(t *testing.T) { if got, want := TransportFault(ClassDeadline, "node-build-go", "ace", "i/o timeout"), "transport fault: deadline, node-build-go ace, i/o timeout"; got != want { t.Errorf("TransportFault = %q, want %q", got, want) } + // §799: a fetch's and a publish's why are said apart, each in the cause of its key's transport fault. + for _, why := range []string{"fetch: git fetch: HTTP 503", "publish: nats: no responders available for request"} { + if got := TransportFault(FaultClass(why), "node-build-go", "ace", why); !builds.FailedOnTransportFault(got) || !strings.HasSuffix(got, ", "+why) { + t.Errorf("TransportFault of %q = %q", why, got) + } + } } diff --git a/modules/mesh-delivery-sdk/buildstep/ask.go b/modules/mesh-delivery-sdk/buildstep/ask.go index e6d3e96f7..2e256a6fa 100644 --- a/modules/mesh-delivery-sdk/buildstep/ask.go +++ b/modules/mesh-delivery-sdk/buildstep/ask.go @@ -85,15 +85,6 @@ const ( AskMaxDeliver = AskRuns + 2 ) -// AgainAfter is how long the bus waits before it gives an ask again after its run-th run ended on a transport fault: 1 -// minute after the first, 4 after the second (ADR 0664 §2). It outlasts a per-source penalty of a forge's sshd. -func AgainAfter(run int) time.Duration { - if run < 1 { - run = 1 - } - return time.Minute << (2 * (run - 1)) -} - // StepAskVersion is the layout version of an ask. const StepAskVersion = 1 diff --git a/modules/mesh-delivery-sdk/buildstep/ask_test.go b/modules/mesh-delivery-sdk/buildstep/ask_test.go index 252729925..7220baca4 100644 --- a/modules/mesh-delivery-sdk/buildstep/ask_test.go +++ b/modules/mesh-delivery-sdk/buildstep/ask_test.go @@ -500,7 +500,6 @@ func TestPauseCapacityAndComposerKey(t *testing.T) { "npm error code ECONNRESET": true, "fatal: unable to access the forge: Could not resolve host: mesh-forge": true, "Get \"https://example.com/x.tar.gz\": context deadline exceeded (Client.Timeout exceeded while awaiting headers)": true, - (&HolderSilent{Seat: "go-package-registry", Holder: "gopkgs", Node: "ace"}).Error(): true, `invalid version: Get "https://proxy.golang.org/x/@v/y.info": dial tcp [2a00::1]:443: connect: network is unreachable`: true, "dial tcp 10.10.0.1:22: connect: No route to host": true, "nats: no responders available for request": false, @@ -512,8 +511,8 @@ func TestPauseCapacityAndComposerKey(t *testing.T) { t.Errorf("PassingCause(%q) = %v, want %v", words, !want, want) } } - if !IsPassing(fmt.Errorf("fetch: %w", &HolderSilent{Seat: "s"})) || IsPassing(errors.New("i/o timeout")) { - t.Error("a HolderSilent is a Passing error and a bare error is none") + if !IsPassing(fmt.Errorf("fetch: %w", &Passing{Err: errors.New("s")})) || IsPassing(errors.New("i/o timeout")) { + t.Error("a wrapped Passing is a Passing error and a bare error is none") } if Ended(Step{State: StepRunning}) || Ended(Step{State: StepAgain}) || !Ended(Step{State: StepPassed}) || !Ended(Step{State: StepFailed}) { t.Error("Ended: running and again are no end") @@ -522,9 +521,6 @@ func TestPauseCapacityAndComposerKey(t *testing.T) { if raw, err := EncodeStep(Step{ID: "mvl0frv18d1990", Tool: "go ask", Node: "ace", State: StepDropped, Reason: "withdrawn"}); err != nil || !Ended(Step{State: StepDropped}) { t.Errorf("a dropped step: %v (%s)", err, raw) } - if AgainAfter(1) != time.Minute || AgainAfter(2) != 4*time.Minute { - t.Errorf("AgainAfter = %v, %v", AgainAfter(1), AgainAfter(2)) - } } // The part `build-step` is one layout for the three build seats: each seat's fixtures read strictly in the neutral diff --git a/modules/mesh-delivery-sdk/buildstep/passing.go b/modules/mesh-delivery-sdk/buildstep/passing.go index 0be69a938..e926dd457 100644 --- a/modules/mesh-delivery-sdk/buildstep/passing.go +++ b/modules/mesh-delivery-sdk/buildstep/passing.go @@ -2,7 +2,6 @@ package buildstep import ( "errors" - "fmt" "strings" ) @@ -21,26 +20,12 @@ func IsPassing(err error) bool { return errors.As(err, &p) } -// HolderSilentWords opens the words of a HolderSilent, so PassingCause reads them from a step's reason too. -const HolderSilentWords = "the holder is silent" - -// HolderSilent is a seat verb that answered "no responders" while the assigner names a holder of the seat: its tool -// runner is being replaced, a moment later it answers. It is a Passing fault (ADR 0664 §1); a seat nothing holds is not. -type HolderSilent struct{ Seat, Holder, Node string } - -func (h *HolderSilent) Error() string { - return fmt.Sprintf("%s: seat %s, held by %s on %s, answered no responders", HolderSilentWords, h.Seat, h.Holder, h.Node) -} - -// Unwrap makes a HolderSilent a Passing. -func (h *HolderSilent) Unwrap() error { return &Passing{Err: errors.New(h.Error())} } - // passingWords are the words of a network that did not answer, lower-cased: go's and git's (a lookup, a timeout, a refused or // reset connection, ssh's key exchange cut by a forge's per-source penalty) and npm's error codes. "no responders" alone is not -// one: it is the same for a seat nothing holds (HolderSilent is the case a holder is named). +// one: a publish's is the build module's to say (steprun.PublishFault, design 47 H2 §799). var passingWords = []string{"i/o timeout", "no such host", "temporary failure in name resolution", "connection refused", "connection reset", "tls handshake timeout", "network is unreachable", "no route to host", "lookup ", "kex_exchange_identification", "connection closed by", - "could not resolve host", "client.timeout", "operation timed out", "connection timed out", "eai_again", "etimedout", "econnreset", "econnrefused", "enotfound", strings.ToLower(HolderSilentWords)} + "could not resolve host", "client.timeout", "operation timed out", "connection timed out", "eai_again", "etimedout", "econnreset", "econnrefused", "enotfound"} // PassingCause says words (a tool's output or a step's reason) are those of a transport fault. func PassingCause(words string) bool { diff --git a/modules/mesh-delivery-sdk/steprun/again.go b/modules/mesh-delivery-sdk/steprun/again.go new file mode 100644 index 000000000..7dbe6e0b3 --- /dev/null +++ b/modules/mesh-delivery-sdk/steprun/again.go @@ -0,0 +1,41 @@ +package steprun + +import ( + "fmt" + "strings" + "time" +) + +// AgainDelaysSetting is the setting each build module declares for the delay it passes with a run's `again` (design 47 +// H2 §799): how long the bus waits before it gives an ask again after its first, then its second run ended on a +// transport fault, as Go durations separated by commas. DefaultAgainDelays is its default, so three runs span a +// one-minute absence of a holder. +const ( + AgainDelaysSetting = "again-delays" + DefaultAgainDelays = "15s,60s" +) + +// AgainDelays reads the setting again-delays into a Puller's Delay (§799): the run-th delay of the list, its last for a +// run past it; an empty setting is DefaultAgainDelays. A delay that is no positive duration is an error naming it. +func AgainDelays(setting string) (func(run int) time.Duration, error) { + if strings.TrimSpace(setting) == "" { + setting = DefaultAgainDelays + } + var delays []time.Duration + for _, w := range strings.Split(setting, ",") { + d, err := time.ParseDuration(strings.TrimSpace(w)) + if err != nil || d <= 0 { + return nil, fmt.Errorf("the setting %s holds %q, whose %q is not a positive duration", AgainDelaysSetting, setting, w) + } + delays = append(delays, d) + } + return func(run int) time.Duration { + if run < 1 { + run = 1 + } + return delays[min(run, len(delays))-1] + }, nil +} + +// defaultAgainDelay is DefaultAgainDelays read, a Puller's delay when it names none. +var defaultAgainDelay, _ = AgainDelays(DefaultAgainDelays) diff --git a/modules/mesh-delivery-sdk/steprun/again_test.go b/modules/mesh-delivery-sdk/steprun/again_test.go new file mode 100644 index 000000000..89133b165 --- /dev/null +++ b/modules/mesh-delivery-sdk/steprun/again_test.go @@ -0,0 +1,74 @@ +package steprun + +import ( + "context" + "errors" + "strings" + "testing" + "time" + + sdkstep "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-sdk/buildstep" +) + +// Design 47 H2 §799: a fetch met by a forge's 401 or a connection fault, and a publish met by no responders or a bundle +// that exited, end their run `again` after again-delays' delay, with no seat call; a third run's fault ends the step failed +// with the why `fetch: ` or `publish: `. +func TestAFetchOrAPublishMetAwayIsATransportFault(t *testing.T) { + delay, err := AgainDelays("") + if err != nil || delay(1) != 15*time.Second || delay(2) != time.Minute || delay(3) != time.Minute { + t.Fatalf("the default again-delays: %v", err) + } + if own, err := AgainDelays("2s, 5s"); err != nil || own(1) != 2*time.Second || own(2) != 5*time.Second { + t.Errorf("a setting's own again-delays: %v", err) + } + if _, err := AgainDelays("15s,soon"); err == nil || !strings.Contains(err.Error(), AgainDelaysSetting) { + t.Errorf("a delay that is no duration is refused naming the setting: %v", err) + } + for _, tc := range []struct { + name, why string + err error + }{ + {"a fetch met by a 401", "fetch: ", gitFailure("fetch", "fatal: unable to access the forge: The requested URL returned error: 401")}, + {"a fetch met by a 503", "fetch: ", gitFailure("fetch", "remote: HTTP 503 store unavailable")}, + {"a fetch met by a reset connection", "fetch: ", gitFailure("fetch", "kex_exchange_identification: read: Connection reset by peer")}, + {"a publish met by no responders", "publish: ", PublishFault(errors.New("nats: no responders available for request"))}, + {"a publish met by a bundle that exited", "publish: ", PublishFault(errors.New("the bundle exited"))}, + {"a fetch of a commit that is not there", "", gitFailure("fetch", "fatal: unknown revision or path not in the working tree")}, + {"a publish refused", "", PublishFault(errors.New("refused: the digest differs"))}, + } { + t.Run(tc.name, func(t *testing.T) { + if tc.why == "" { + if sdkstep.IsPassing(tc.err) { + t.Fatalf("%v is a transport fault, want a failure", tc.err) + } + return + } + if !sdkstep.IsPassing(tc.err) || !strings.HasPrefix(tc.err.Error(), tc.why) { + t.Fatalf("%v: want a transport fault opening with %q", tc.err, tc.why) + } + for _, prior := range []int{0, 2} { // its first run ends again after 15 s; its third ends the step failed + src, st := NewFakeAsks(), newSteps() + a := testAsk(sdkstep.AskDelivery) + _ = src.PublishAsk(a) + p := &Puller{Source: src, Language: sdkstep.AskGo, Node: "shanks", Put: st.put, Capacity: func() int { return 1 }, + PullWait: 10 * time.Millisecond, Prior: func(string) int { return prior }, + Run: func(context.Context, sdkstep.StepAsk) (any, error) { return nil, tc.err }} + ctx, cancel := context.WithCancel(context.Background()) + go p.Pull(ctx) + key, _ := sdkstep.AskStepKey("", "shanks", a.ID) + waitFor(t, "the run's end", func() bool { s, ok := st.get(key); return ok && s.State != sdkstep.StepRunning }) + cancel() + s, _ := st.get(key) + src.mu.Lock() + delays := append([]time.Duration(nil), src.Delays...) + src.mu.Unlock() + if prior == 0 && (s.State != sdkstep.StepAgain || len(delays) != 1 || delays[0] != 15*time.Second) { + t.Errorf("the first run: step %+v, delays %v, want again after 15s", s, delays) + } + if prior == 2 && (s.State != sdkstep.StepFailed || !strings.HasPrefix(s.Reason, tc.why)) { + t.Errorf("the third run: step %+v, want failed with the why %q", s, tc.why) + } + } + }) + } +} diff --git a/modules/mesh-delivery-sdk/steprun/fetch.go b/modules/mesh-delivery-sdk/steprun/fetch.go index e5118dd61..47bef6550 100644 --- a/modules/mesh-delivery-sdk/steprun/fetch.go +++ b/modules/mesh-delivery-sdk/steprun/fetch.go @@ -54,15 +54,21 @@ var ( ) // gitFailure is a failed git command said in git's own words; one whose words are a network's (a lookup, a timeout, ssh's key -// exchange cut by a forge's per-source penalty) is a sdkstep.Passing, so the ask is given again after a delay (ADR 0664 §1). +// exchange cut by a forge's per-source penalty) or a forge's answer 401 or 5xx is a sdkstep.Passing whose words open with +// "fetch: ", so the ask is given again after a delay (ADR 0664 §1) and a third run's fault ends the step failed with the +// why `fetch: ` (design 47 H2 §799). func gitFailure(verb, said string) error { err := fmt.Errorf("git %s: %s", verb, said) - if sdkstep.PassingCause(said) { - return &sdkstep.Passing{Err: err} + if sdkstep.PassingCause(said) || forgeAnswered.MatchString(said) { + return &sdkstep.Passing{Err: fmt.Errorf("fetch: %w", err)} } return err } +// forgeAnswered are git's words of a forge that answered 401 or a 5xx (§799): "The requested URL returned error: 502", +// "HTTP 503", "status 401". +var forgeAnswered = regexp.MustCompile(`(?i)(returned error|http|status)[: ]+(401|5[0-9][0-9])\b`) + // FetchCommit fetches one commit of a forge repository into dir, an empty directory, and checks it out detached // (novox/hq ADR 0466 §4, §5; issue 1474). remote is ssh:////.git, the ssh name being the // one the build module's templates set up (ADR 0409 §1); commit is a full 40-hex sha; ref is optional, and names diff --git a/modules/mesh-delivery-sdk/steprun/publish.go b/modules/mesh-delivery-sdk/steprun/publish.go index 415bdaff4..945a5f630 100644 --- a/modules/mesh-delivery-sdk/steprun/publish.go +++ b/modules/mesh-delivery-sdk/steprun/publish.go @@ -15,7 +15,6 @@ import ( "os" "strings" - assigner "git.novox.be/novox/mesh-contracts/go/seats/meshmoduleassigner" imageclient "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/clients/containerimageregistryclient" goclient "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/clients/gopackageregistryclient" npmclient "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/clients/npmpackageregistryclient" @@ -79,37 +78,21 @@ func SentHow(n int) func(parts.Sent) string { // (the four registry seats share the publish verb's input, design 51), the parts are written by the client. func PublishParts(ctx context.Context, call SeatCall, seat string, in reg.PublishInput, ps []parts.Part) (parts.Sent, error) { sent, err := publishParts(ctx, call, seat, in, ps) - return sent, HolderSilentOr(call, seat, err) + return sent, PublishFault(err) } -// AssignerHolders is the verb that tells who holds a seat: `mesh-module-assigner.assignments` with seats -// (the state seat-holders). The build modules' manifests `invokes` it. -const AssignerHolders = "seat:" + assigner.Seat + "." + assigner.VerbAssignments - -// HolderSilentOr is err, or when it is a seat verb's "no responders" and the assigner names a holder of seat, a -// sdkstep.HolderSilent (a Passing: the holder's tool runner is being replaced and answers a moment later, ADR 0664 §1). The -// bus says "no responders" for a seat nothing holds too, so the words alone are no transport fault: with no holder named, or -// when the holders cannot be asked, the error stays as it is, said with why, and fails at once. -func HolderSilentOr(call SeatCall, seat string, err error) error { - if err == nil || !strings.Contains(strings.ToLower(err.Error()), "no responders") { +// PublishFault is err, or, when a publish met no responders or a registry's bundle that exited, a sdkstep.Passing whose +// words open with "publish: " (design 47 H2 §799, ADR 0664 §1): the run ends `again`, with no seat call to learn why, +// and a third run's fault ends the step failed with the why `publish: `. Any other error is returned as it is. +func PublishFault(err error) error { + if err == nil || sdkstep.IsPassing(err) { return err } - raw, aerr := call(AssignerHolders, map[string]any{"seats": assigner.AssignmentsInputSeatsTrue}) - if aerr != nil { - return fmt.Errorf("%w (who holds %s could not be asked: %v)", err, seat, aerr) + words := strings.ToLower(err.Error()) + if !strings.Contains(words, "no responders") && !strings.Contains(words, "bundle exited") { + return err } - var answer struct { - Seats []assigner.SeatHolders `json:"seats"` - } - if jerr := json.Unmarshal(raw, &answer); jerr != nil { - return fmt.Errorf("%w (who holds %s was answered in what is not read: %v)", err, seat, jerr) - } - for _, sh := range answer.Seats { - if sh.Seat == seat && len(sh.Holders) > 0 { - return fmt.Errorf("%w: %w", err, &sdkstep.HolderSilent{Seat: seat, Holder: sh.Holders[0].Module, Node: sh.Holders[0].Node}) - } - } - return fmt.Errorf("%w (nothing holds %s)", err, seat) + return &sdkstep.Passing{Err: fmt.Errorf("publish: %w", err)} } func publishParts(ctx context.Context, call SeatCall, seat string, in reg.PublishInput, ps []parts.Part) (parts.Sent, error) { diff --git a/modules/mesh-delivery-sdk/steprun/pull.go b/modules/mesh-delivery-sdk/steprun/pull.go index 72ef627db..b35a30ad0 100644 --- a/modules/mesh-delivery-sdk/steprun/pull.go +++ b/modules/mesh-delivery-sdk/steprun/pull.go @@ -75,8 +75,8 @@ type Puller struct { Run func(ctx context.Context, ask sdkstep.StepAsk) (any, error) // PullWait and Heartbeat default to DefaultPullWait and DefaultHeartbeat. PullWait time.Duration - // Delay is how long the bus waits before it gives an ask again after its run-th run ended on a transport fault; nil is - // sdkstep.AgainAfter (a minute, then four). A test's own is short. + // Delay is how long the bus waits before it gives an ask again after its run-th run ended on a transport fault: the + // module's setting again-delays read by AgainDelays (design 47 H2 §799); nil is DefaultAgainDelays. Delay func(run int) time.Duration Heartbeat time.Duration // Say publishes one event of the seat on this node's subject (SayOn): ask-taken when an ask starts, step-progress once @@ -820,7 +820,7 @@ func (p *Puller) run(ctx context.Context, msg *Pulled, ask sdkstep.StepAsk, key if run := step.Run; err != nil && sdkstep.IsPassing(err) && run < sdkstep.AskRuns && msg.NakAfter != nil { // A transport fault (ADR 0664 §1): the step says it is given again and the bus gives it after a delay, to this node or // another; it is not acknowledged, so its asker sees no end. Run AskRuns times it ends failed, said as a transport fault. - delay := sdkstep.AgainAfter(run) + delay := defaultAgainDelay(run) if p.Delay != nil { delay = p.Delay(run) } diff --git a/modules/mesh-delivery-sdk/steprun/pull_poison_test.go b/modules/mesh-delivery-sdk/steprun/pull_poison_test.go index 6ec823d47..67e8728e6 100644 --- a/modules/mesh-delivery-sdk/steprun/pull_poison_test.go +++ b/modules/mesh-delivery-sdk/steprun/pull_poison_test.go @@ -207,7 +207,8 @@ func TestAnEndedPipelineStepIsSaidAndAcknowledged(t *testing.T) { } // ADR 0664 §1 with the bus's count above the runs that started: the ask was given back twice before its first run, so the -// bus says delivered 3 while the step key says 1 run began; a transport fault is run 2 (given again after 4 minutes), not 3. +// bus says delivered 3 while the step key says 1 run began; a transport fault is run 2 (given again after again-delays' +// second, 60 s, design 47 H2 §799), not 3. func TestATransportFaultCountsRunsThatStartedNotDeliveries(t *testing.T) { src, st := NewFakeAsks(), newSteps() src.Delivered = 3 @@ -227,8 +228,8 @@ func TestATransportFaultCountsRunsThatStartedNotDeliveries(t *testing.T) { src.mu.Lock() delays := append([]time.Duration(nil), src.Delays...) src.mu.Unlock() - if s.State != sdkstep.StepAgain || s.Run != 2 || len(delays) != 1 || delays[0] != sdkstep.AgainAfter(2) { - t.Errorf("step %+v, delays %v, want again in run 2 after %s", s, delays, sdkstep.AgainAfter(2)) + if s.State != sdkstep.StepAgain || s.Run != 2 || len(delays) != 1 || delays[0] != time.Minute { + t.Errorf("step %+v, delays %v, want again in run 2 after 60s", s, delays) } } diff --git a/modules/mesh-delivery-sdk/steprun/pull_test.go b/modules/mesh-delivery-sdk/steprun/pull_test.go index f5cc9578e..bb514f3a9 100644 --- a/modules/mesh-delivery-sdk/steprun/pull_test.go +++ b/modules/mesh-delivery-sdk/steprun/pull_test.go @@ -559,8 +559,8 @@ func TestAPoisonedAskIsSaidAndRunNoMore(t *testing.T) { passing bool ackedOnly bool }{ - {"a transport fault in run 1", 1, &sdkstep.Passing{Err: errors.New("lookup proxy: i/o timeout")}, sdkstep.StepAgain, time.Minute, true, false}, - {"a transport fault in run 2", 2, &sdkstep.Passing{Err: errors.New("lookup proxy: i/o timeout")}, sdkstep.StepAgain, 4 * time.Minute, true, false}, + {"a transport fault in run 1", 1, &sdkstep.Passing{Err: errors.New("lookup proxy: i/o timeout")}, sdkstep.StepAgain, 15 * time.Second, true, false}, + {"a transport fault in run 2", 2, &sdkstep.Passing{Err: errors.New("lookup proxy: i/o timeout")}, sdkstep.StepAgain, time.Minute, true, false}, {"a transport fault in the last run", sdkstep.AskRuns, &sdkstep.Passing{Err: errors.New("lookup proxy: i/o timeout")}, sdkstep.StepFailed, 0, true, true}, {"a compile error in run 1", 1, errors.New("undefined: x"), sdkstep.StepFailed, 0, false, true}, } {