From 1c531e710901c8a7bfc9e42484dfcbc2f0ac2e5c Mon Sep 17 00:00:00 2001 From: Eric Rakestraw Date: Mon, 16 Nov 2026 18:03:24 +0000 Subject: [PATCH] Classify configuration command failures --- docs/roadmap/implementation.md | 9 +- integrations/ckconfig/config_outcomes_test.go | 119 ++++++++++++++++++ integrations/ckconfig/diff.go | 10 +- .../ckconfig/examples/simple/main_test.go | 4 +- integrations/ckconfig/explain.go | 18 +-- integrations/ckconfig/operations.go | 23 +++- integrations/ckconfig/overrides_test.go | 2 +- integrations/ckconfig/show.go | 22 ++-- integrations/ckconfig/sources.go | 18 +-- integrations/ckconfig/validate.go | 4 +- 10 files changed, 185 insertions(+), 44 deletions(-) create mode 100644 integrations/ckconfig/config_outcomes_test.go diff --git a/docs/roadmap/implementation.md b/docs/roadmap/implementation.md index a823329..6fae680 100644 --- a/docs/roadmap/implementation.md +++ b/docs/roadmap/implementation.md @@ -138,7 +138,14 @@ Run the focused classifier tests. Stage 5 owns the final independent module suit ## Stage 2 — Apply classification and cancellation precedence in ckconfig -Status — pending. +Status — complete. The configuration failure boundary now incorporates +invocation cancellation and selects the shared classification. Tests cover all +five operations, both comparison sides, filtered validation, report delivery, +operational failures, and cancellation with retained causes. Updated the native +override and simple-example expectations for their input diagnostic codes. +Verified with Go 1.27.0: `GOTOOLCHAIN=local GOPROXY=off go test +./integrations/ckconfig/...` in the aligned workspace, using a temporary Go +build cache; both the integration and simple example passed. Update `configFailure` in `integrations/ckconfig/operations.go` to receive `context.Context` as its first argument. Update its callers in `operations.go`, diff --git a/integrations/ckconfig/config_outcomes_test.go b/integrations/ckconfig/config_outcomes_test.go new file mode 100644 index 0000000..1df91a0 --- /dev/null +++ b/integrations/ckconfig/config_outcomes_test.go @@ -0,0 +1,119 @@ +package ckconfig + +import ( + "bytes" + "context" + "errors" + "fmt" + "io" + "strings" + "testing" + + "go.maximumdirect.net/commandkit" + "go.maximumdirect.net/configkit" +) + +func TestNativeConfigurationInputOutcomes(t *testing.T) { + _, loadErr := configkit.Load[map[string]any](configkit.Bytes("malformed-input", []byte("broken: ["))) + var native *configkit.LoadError + if !errors.As(loadErr, &native) || len(native.Diagnostics()) == 0 { + t.Fatalf("fixture: %v", loadErr) + } + wrapped := fmt.Errorf("application loader: %w", loadErr) + app := newConfigTestApp(t, AppCommand(func(context.Context, Selection) (*configkit.Result[map[string]any], error) { return nil, wrapped })) + cases := []struct { + name string + args []string + report string + }{ + {"show", []string{"config", "show"}, ""}, + {"sources", []string{"config", "sources", "--format=json"}, `"sources"`}, + {"validation", []string{"config", "validate", "--details", "--format=json"}, `"code": "yaml.invalid"`}, + {"filtered validation", []string{"config", "validate", "--details", "--code=not-selected", "--format=json"}, `"state": "filtered"`}, + {"discovery", []string{"config", "explain", "--list"}, ""}, + {"diff", []string{"config", "diff"}, ""}, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + var out, diag bytes.Buffer + result := app.Execute(context.Background(), tc.args, commandkit.Streams{Out: &out, Err: &diag}) + var got *configkit.LoadError + if result.Kind != commandkit.OutcomeUsage || result.Status != 2 || !errors.Is(result.Cause, loadErr) || !errors.As(result.Cause, &got) || got != native { + t.Fatalf("outcome: %#v", result) + } + if !strings.Contains(diag.String(), native.Diagnostics()[0].Message) || !strings.Contains(diag.String(), "malformed-input") { + t.Fatalf("diagnostics: %q", diag.String()) + } + if tc.report != "" && !strings.Contains(out.String(), tc.report) { + t.Fatalf("report: %q", out.String()) + } + }) + } +} + +func TestNativeConfigurationComparisonFailureSides(t *testing.T) { + _, loadErr := configkit.Load[map[string]any](configkit.Bytes("bad-side", []byte("broken: ["))) + for _, bad := range []string{"left", "right"} { + t.Run(bad, func(t *testing.T) { + app := newConfigTestApp(t, AppCommand(func(_ context.Context, selection Selection) (*configkit.Result[map[string]any], error) { + if selection.Config.Value == bad { + return nil, fmt.Errorf("wrapped: %w", loadErr) + } + return configkit.Load[map[string]any](configkit.Bytes("good-side", []byte("ok: true"))) + })) + var diag bytes.Buffer + result := app.Execute(context.Background(), []string{"config", "diff", "--config=left", "--against-config=right"}, commandkit.Streams{Out: io.Discard, Err: &diag}) + if result.Kind != commandkit.OutcomeUsage || result.Status != 2 || !errors.Is(result.Cause, loadErr) || !strings.Contains(diag.String(), "bad-side") || !strings.Contains(diag.String(), bad) { + t.Fatalf("outcome=%#v diagnostics=%q", result, diag.String()) + } + }) + } +} + +func TestConfigurationFailureCancellationAndDelivery(t *testing.T) { + _, loadErr := configkit.Load[map[string]any](configkit.Bytes("bad-input", []byte("broken: ["))) + for _, args := range [][]string{{"config", "show"}, {"config", "sources"}, {"config", "validate"}, {"config", "explain", "--list"}, {"config", "diff"}} { + t.Run(strings.Join(args, "_"), func(t *testing.T) { + calls := 0 + app := newConfigTestApp(t, AppCommand(func(context.Context, Selection) (*configkit.Result[map[string]any], error) { + calls++ + return nil, loadErr + })) + ctx, cancel := context.WithCancel(context.Background()) + cancel() + var out bytes.Buffer + result := app.Execute(ctx, args, commandkit.Streams{Out: &out, Err: io.Discard}) + if result.Status != 1 || !errors.Is(result.Cause, context.Canceled) || calls != 0 || out.Len() != 0 { + t.Fatalf("outcome=%#v calls=%d output=%q", result, calls, out.String()) + } + ctx, cancel = context.WithCancel(context.Background()) + defer cancel() + app = newConfigTestApp(t, AppCommand(func(context.Context, Selection) (*configkit.Result[map[string]any], error) { + cancel() + return nil, loadErr + })) + result = app.Execute(ctx, args, commandkit.Streams{Out: io.Discard, Err: io.Discard}) + if result.Status != 1 || !errors.Is(result.Cause, context.Canceled) || !errors.Is(result.Cause, loadErr) { + t.Fatalf("joined outcome=%#v", result) + } + }) + } + app := newConfigTestApp(t, AppCommand(func(context.Context, Selection) (*configkit.Result[map[string]any], error) { return nil, loadErr })) + for _, args := range [][]string{{"config", "sources"}, {"config", "validate"}} { + result := app.Execute(context.Background(), args, commandkit.Streams{Out: shortWriter{}, Err: io.Discard}) + if result.Kind != commandkit.OutcomeOperational || result.Status != 1 || !errors.Is(result.Cause, loadErr) || result.Presentation.Output.State != commandkit.DeliveryIncomplete { + t.Fatalf("delivery %v: %#v", args, result) + } + } +} + +func TestConfigurationOperationalFailures(t *testing.T) { + _, loadErr := configkit.Load[map[string]any](configkit.File("/nonexistent-commandkit-outcome-test")) + for _, failure := range []error{errors.New("unavailable"), loadErr} { + app := newConfigTestApp(t, AppCommand(func(context.Context, Selection) (*configkit.Result[map[string]any], error) { return nil, failure })) + result := app.Execute(context.Background(), []string{"config", "show"}, commandkit.Streams{Out: io.Discard, Err: io.Discard}) + if result.Status != 1 || !errors.Is(result.Cause, failure) { + t.Fatalf("outcome=%#v", result) + } + } +} diff --git a/integrations/ckconfig/diff.go b/integrations/ckconfig/diff.go index 359eff2..7071d5b 100644 --- a/integrations/ckconfig/diff.go +++ b/integrations/ckconfig/diff.go @@ -10,25 +10,25 @@ import ( func runConfigDiff[I, S any](invocation commandkit.Invocation, plan *configOperationPlan[I, S], state S) commandkit.Outcome { if plan.comparison == nil || plan.comparison.scope == nil { cause := errors.New("configuration comparison was not prepared") - return configFailure("Configuration comparison was not prepared.", commandkit.Explanation{}, cause) + return configFailure(invocation.Context, "Configuration comparison was not prepared.", commandkit.Explanation{}, cause) } selected := plan.comparison if err := invocation.Context.Err(); err != nil { - return configFailure("Configuration comparison was canceled.", commandkit.Explanation{}, err) + return configFailure(invocation.Context, "Configuration comparison was canceled.", commandkit.Explanation{}, err) } compare := selected.scope.scope.Compare if compare == nil { cause := fmt.Errorf("configuration scope %q has no comparison callback", selected.scope.scope.Name) - return configFailure("Configuration scope does not support comparison.", commandkit.Explanation{}, cause) + return configFailure(invocation.Context, "Configuration scope does not support comparison.", commandkit.Explanation{}, cause) } acquired, err := compare(invocation.Context, selected.request, state) reporter := invocation.Reporter() queueConfigDiagnostics(reporter, acquired.Diagnostics) if err != nil { - return configFailure(fmt.Sprintf("Unable to compare configuration scope %q.", selected.scope.scope.Name), acquired.Explanation, err) + return configFailure(invocation.Context, fmt.Sprintf("Unable to compare configuration scope %q.", selected.scope.scope.Name), acquired.Explanation, err) } if err := invocation.Context.Err(); err != nil { - return configFailure("Configuration comparison was canceled.", acquired.Explanation, err) + return configFailure(invocation.Context, "Configuration comparison was canceled.", acquired.Explanation, err) } outcome := renderPreparedConfigReport(invocation, acquired.Explanation, func() (any, error) { if plan.details { diff --git a/integrations/ckconfig/examples/simple/main_test.go b/integrations/ckconfig/examples/simple/main_test.go index e994dc1..2449131 100644 --- a/integrations/ckconfig/examples/simple/main_test.go +++ b/integrations/ckconfig/examples/simple/main_test.go @@ -176,11 +176,11 @@ func TestSimpleFailedLoadReportsEvidence(t *testing.T) { t.Fatalf("fixture failure = %v", failure) } outcome, output, _ := executeSimple(t, "config", "validate", "--config=fixtures/invalid.yml", "--details", "--severity=error", "--format=json") - if outcome.Kind != commandkit.OutcomeOperational || !strings.Contains(output, `"state": "present"`) || !strings.Contains(output, `"severity": "error"`) { + if outcome.Kind != commandkit.OutcomeUsage || !strings.Contains(output, `"state": "present"`) || !strings.Contains(output, `"severity": "error"`) { t.Fatalf("detailed failure = %#v %q", outcome, output) } outcome, output, _ = executeSimple(t, "config", "sources", "--config=fixtures/invalid.yml", "--source-id="+native.Sources()[0].ID, "--format=json") - if outcome.Kind != commandkit.OutcomeOperational || !strings.Contains(output, `"id":`) || !strings.Contains(output, "invalid.yml") { + if outcome.Kind != commandkit.OutcomeUsage || !strings.Contains(output, `"id":`) || !strings.Contains(output, "invalid.yml") { t.Fatalf("source failure = %#v %q", outcome, output) } } diff --git a/integrations/ckconfig/explain.go b/integrations/ckconfig/explain.go index 0661683..889d41f 100644 --- a/integrations/ckconfig/explain.go +++ b/integrations/ckconfig/explain.go @@ -108,11 +108,11 @@ func runConfigExplanation[I, S any](invocation commandkit.Invocation, plan *conf name := selected.scope.scope.Name reporter := invocation.Reporter() if err := invocation.Context.Err(); err != nil { - return configFailure("Configuration explanation was canceled.", commandkit.Explanation{}, err) + return configFailure(invocation.Context, "Configuration explanation was canceled.", commandkit.Explanation{}, err) } if selected.scope.scope.Acquire == nil { cause := fmt.Errorf("configuration scope %q has no acquisition callback", name) - return configFailure(fmt.Sprintf("Unable to explain configuration scope %q.", name), commandkit.Explanation{}, cause) + return configFailure(invocation.Context, fmt.Sprintf("Unable to explain configuration scope %q.", name), commandkit.Explanation{}, cause) } acquired, acquireErr := selected.scope.scope.Acquire(invocation.Context, Request{ Operation: Explain, @@ -120,14 +120,14 @@ func runConfigExplanation[I, S any](invocation commandkit.Invocation, plan *conf }, selected.input, state) queueConfigAcquisition(reporter, acquired) if acquireErr != nil { - return configFailure(fmt.Sprintf("Unable to explain configuration scope %q.", name), acquired.Explanation, acquireErr) + return configFailure(invocation.Context, fmt.Sprintf("Unable to explain configuration scope %q.", name), acquired.Explanation, acquireErr) } if err := invocation.Context.Err(); err != nil { - return configFailure("Configuration explanation was canceled.", acquired.Explanation, err) + return configFailure(invocation.Context, "Configuration explanation was canceled.", acquired.Explanation, err) } if plan.list { if acquired.Value.Metadata == nil { - return configFailure("Configuration scope did not provide path metadata.", acquired.Explanation, fmt.Errorf("configuration scope %q declared path discovery without metadata", name)) + return configFailure(invocation.Context, "Configuration scope did not provide path metadata.", acquired.Explanation, fmt.Errorf("configuration scope %q declared path discovery without metadata", name)) } report := pathDiscoveryReport{Scope: name, Paths: []pathDiscoveryEntry{}} var prefix []string @@ -157,16 +157,16 @@ func runConfigExplanation[I, S any](invocation commandkit.Invocation, plan *conf } if acquired.Value.Explanation == nil { cause := fmt.Errorf("configuration scope %q did not provide an explanation reader", name) - return configFailure("Configuration scope did not provide explanation data.", acquired.Explanation, cause) + return configFailure(invocation.Context, "Configuration scope did not provide explanation data.", acquired.Explanation, cause) } explanation, found := acquired.Value.Explanation.Explain(plan.path) if !found { cause := fmt.Errorf("configuration path %q is not known in scope %q", plan.path.String(), name) - return configFailure("The requested configuration path is not available.", acquired.Explanation, cause) + return configFailure(invocation.Context, "The requested configuration path is not available.", acquired.Explanation, cause) } if err := invocation.Context.Err(); err != nil { - return configFailure("Configuration explanation was canceled.", acquired.Explanation, err) + return configFailure(invocation.Context, "Configuration explanation was canceled.", acquired.Explanation, err) } report := makeExplanationReport(name, explanation) if acquired.Value.Metadata != nil { @@ -192,7 +192,7 @@ func runConfigExplanation[I, S any](invocation commandkit.Invocation, plan *conf } renderErr := reporter.Report(commandkit.Report{Value: report, TextTemplate: explanationTemplate}) if renderErr != nil && invocation.Context.Err() != nil { - return configFailure("Configuration explanation was canceled.", acquired.Explanation, invocation.Context.Err()) + return configFailure(invocation.Context, "Configuration explanation was canceled.", acquired.Explanation, invocation.Context.Err()) } return commandkit.Success() } diff --git a/integrations/ckconfig/operations.go b/integrations/ckconfig/operations.go index 9ebc8f1..e3d85a4 100644 --- a/integrations/ckconfig/operations.go +++ b/integrations/ckconfig/operations.go @@ -1,6 +1,8 @@ package ckconfig import ( + "context" + "errors" "fmt" "io" @@ -15,7 +17,7 @@ func runConfigOperation[I, S any](invocation commandkit.Invocation, operation Op return invocation.Help() } if err := invocation.Context.Err(); err != nil { - return configFailure("Configuration operation was canceled.", commandkit.Explanation{}, err) + return configFailure(invocation.Context, "Configuration operation was canceled.", commandkit.Explanation{}, err) } plan := input.plan var state S @@ -64,11 +66,23 @@ func queueConfigAcquisition(reporter *commandkit.Reporter, acquired commandkit.A } } -func configFailure(message string, explanation commandkit.Explanation, cause error) commandkit.Outcome { +func configFailure(ctx context.Context, message string, explanation commandkit.Explanation, cause error) commandkit.Outcome { if explanation.Message != "" || len(explanation.Details) > 0 { message = explanation.Message } + if ctx != nil { + if canceled := ctx.Err(); canceled != nil { + if cause == nil { + cause = canceled + } else if !errors.Is(cause, canceled) { + cause = errors.Join(cause, canceled) + } + } + } outcome := commandkit.Failure(message, explanation.Details...) + if cause != nil && ClassifyConfigurationError(cause) == commandkit.OutcomeUsage { + outcome = commandkit.Usage(message, explanation.Details...) + } if cause != nil { outcome = outcome.WithCause(cause) } @@ -76,6 +90,7 @@ func configFailure(message string, explanation commandkit.Explanation, cause err } func configAcquisitionFailure( + ctx context.Context, reporter *commandkit.Reporter, operation, scope string, acquired commandkit.Acquired[View], @@ -83,7 +98,7 @@ func configAcquisitionFailure( ) commandkit.Outcome { queueConfigAcquisition(reporter, acquired) message := fmt.Sprintf("Unable to %s configuration scope %q.", operation, scope) - return configFailure(message, acquired.Explanation, cause) + return configFailure(ctx, message, acquired.Explanation, cause) } // Preserve the preparation/delivery cancellation checkpoint for buffered reports. @@ -105,7 +120,7 @@ func renderPreparedConfigReport(invocation commandkit.Invocation, explanation co canceled = invocation.Context.Err() } if canceled != nil { - return configFailure("Configuration report preparation was canceled.", explanation, canceled) + return configFailure(invocation.Context, "Configuration report preparation was canceled.", explanation, canceled) } if renderErr == nil { _ = invocation.Reporter().Report(commandkit.Report{Value: value}) diff --git a/integrations/ckconfig/overrides_test.go b/integrations/ckconfig/overrides_test.go index 936b722..0b7269f 100644 --- a/integrations/ckconfig/overrides_test.go +++ b/integrations/ckconfig/overrides_test.go @@ -88,7 +88,7 @@ func TestOverrideNativeLoadErrorAndProvenance(t *testing.T) { } result = app.Execute(context.Background(), []string{"config", "validate", "--set==1"}, commandkit.Streams{Out: io.Discard, Err: io.Discard}) var loadErr *configkit.LoadError - if result.Kind != commandkit.OutcomeOperational || !errors.As(result.Cause, &loadErr) { + if result.Kind != commandkit.OutcomeUsage || !errors.As(result.Cause, &loadErr) { t.Fatalf("native invalid root override: %#v", result) } } diff --git a/integrations/ckconfig/show.go b/integrations/ckconfig/show.go index 96e4ea4..d5af428 100644 --- a/integrations/ckconfig/show.go +++ b/integrations/ckconfig/show.go @@ -19,29 +19,29 @@ func runConfigShow[I, S any](invocation commandkit.Invocation, plan *configOpera reporter := invocation.Reporter() for _, selected := range plan.scopes { if err := invocation.Context.Err(); err != nil { - return configFailure("Configuration show was canceled.", commandkit.Explanation{}, err) + return configFailure(invocation.Context, "Configuration show was canceled.", commandkit.Explanation{}, err) } if selected.scope.scope.Acquire == nil { return commandkit.Failure(fmt.Sprintf("Configuration scope %q has no acquisition callback.", selected.scope.scope.Name)) } acquired, acquireErr := selected.scope.scope.Acquire(invocation.Context, Request{Operation: Show, Selection: selected.selection}, selected.input, state) if acquireErr != nil { - return configAcquisitionFailure(reporter, "show", selected.scope.scope.Name, acquired, acquireErr) + return configAcquisitionFailure(invocation.Context, reporter, "show", selected.scope.scope.Name, acquired, acquireErr) } queueConfigAcquisition(reporter, acquired) if err := invocation.Context.Err(); err != nil { - return configFailure("Configuration show was canceled.", acquired.Explanation, err) + return configFailure(invocation.Context, "Configuration show was canceled.", acquired.Explanation, err) } if plan.pathSet { if acquired.Value.Explanation == nil { - return configFailure("Configuration scope did not provide explanation data.", acquired.Explanation, fmt.Errorf("configuration scope %q declared path show without an explanation reader", selected.scope.scope.Name)) + return configFailure(invocation.Context, "Configuration scope did not provide explanation data.", acquired.Explanation, fmt.Errorf("configuration scope %q declared path show without an explanation reader", selected.scope.scope.Name)) } explanation, found := acquired.Value.Explanation.Explain(plan.path) if !found || !explanation.Effective.Present { - return configFailure("The requested effective configuration path is not available.", acquired.Explanation, fmt.Errorf("configuration path %q is not effective in scope %q", plan.path.String(), selected.scope.scope.Name)) + return configFailure(invocation.Context, "The requested effective configuration path is not available.", acquired.Explanation, fmt.Errorf("configuration path %q is not effective in scope %q", plan.path.String(), selected.scope.scope.Name)) } if err := invocation.Context.Err(); err != nil { - return configFailure("Configuration show was canceled.", acquired.Explanation, err) + return configFailure(invocation.Context, "Configuration show was canceled.", acquired.Explanation, err) } var value any err := reporter.RenderOutput(func(io.Writer) error { @@ -51,7 +51,7 @@ func runConfigShow[I, S any](invocation commandkit.Invocation, plan *configOpera }) if err == nil { if canceled := invocation.Context.Err(); canceled != nil { - return configFailure("Configuration show was canceled.", acquired.Explanation, canceled) + return configFailure(invocation.Context, "Configuration show was canceled.", acquired.Explanation, canceled) } _ = reporter.Report(commandkit.Report{Value: value}) } @@ -63,7 +63,7 @@ func runConfigShow[I, S any](invocation commandkit.Invocation, plan *configOpera documents = append(documents, effectiveDocument{name: selected.scope.scope.Name, view: acquired.Value}) } if err := invocation.Context.Err(); err != nil { - return configFailure("Configuration show was canceled.", commandkit.Explanation{}, err) + return configFailure(invocation.Context, "Configuration show was canceled.", commandkit.Explanation{}, err) } var value any var canceled error @@ -92,16 +92,16 @@ func runConfigShow[I, S any](invocation commandkit.Invocation, plan *configOpera return nil }) if canceled != nil { - return configFailure("Configuration show was canceled.", commandkit.Explanation{}, canceled) + return configFailure(invocation.Context, "Configuration show was canceled.", commandkit.Explanation{}, canceled) } if err != nil { if canceled := invocation.Context.Err(); canceled != nil { - return configFailure("Configuration show was canceled.", commandkit.Explanation{}, canceled) + return configFailure(invocation.Context, "Configuration show was canceled.", commandkit.Explanation{}, canceled) } return commandkit.Success() } if err := invocation.Context.Err(); err != nil { - return configFailure("Configuration show was canceled.", commandkit.Explanation{}, err) + return configFailure(invocation.Context, "Configuration show was canceled.", commandkit.Explanation{}, err) } _ = reporter.Report(commandkit.Report{Value: value}) return commandkit.Success() diff --git a/integrations/ckconfig/sources.go b/integrations/ckconfig/sources.go index db45eb4..809de40 100644 --- a/integrations/ckconfig/sources.go +++ b/integrations/ckconfig/sources.go @@ -59,11 +59,11 @@ func runConfigSources[I, S any](invocation commandkit.Invocation, plan *configOp name := selected.scope.scope.Name reporter := invocation.Reporter() if err := invocation.Context.Err(); err != nil { - return configFailure("Configuration source listing was canceled.", commandkit.Explanation{}, err) + return configFailure(invocation.Context, "Configuration source listing was canceled.", commandkit.Explanation{}, err) } if selected.scope.scope.Acquire == nil { cause := fmt.Errorf("configuration scope %q has no acquisition callback", name) - return configFailure(fmt.Sprintf("Unable to list sources for configuration scope %q.", name), commandkit.Explanation{}, cause) + return configFailure(invocation.Context, fmt.Sprintf("Unable to list sources for configuration scope %q.", name), commandkit.Explanation{}, cause) } acquired, acquireErr := selected.scope.scope.Acquire(invocation.Context, Request{ Operation: Sources, @@ -72,15 +72,15 @@ func runConfigSources[I, S any](invocation commandkit.Invocation, plan *configOp queueConfigAcquisition(reporter, acquired) if acquireErr == nil && invocation.Context.Err() != nil { err := invocation.Context.Err() - return configFailure("Configuration source listing was canceled.", acquired.Explanation, err) + return configFailure(invocation.Context, "Configuration source listing was canceled.", acquired.Explanation, err) } if acquired.Value.Sources == nil { if acquireErr != nil { explanation := sourceSelectionExplanation(acquired.Explanation, "Source inventory is unavailable.") - return configFailure(fmt.Sprintf("Unable to list sources for configuration scope %q.", name), explanation, acquireErr) + return configFailure(invocation.Context, fmt.Sprintf("Unable to list sources for configuration scope %q.", name), explanation, acquireErr) } cause := fmt.Errorf("configuration scope %q did not provide a source reader", name) - return configFailure("Configuration scope did not provide source information.", acquired.Explanation, cause) + return configFailure(invocation.Context, "Configuration scope did not provide source information.", acquired.Explanation, cause) } sources := acquired.Value.Sources.Sources() @@ -134,17 +134,17 @@ func runConfigSources[I, S any](invocation commandkit.Invocation, plan *configOp if plan.sourceID.Set && len(document.Sources) == 0 { message := fmt.Sprintf("Source ID %q was not found in configuration scope %q.", plan.sourceID.Value, name) if acquireErr != nil { - return configFailure(fmt.Sprintf("Unable to list sources for configuration scope %q.", name), sourceSelectionExplanation(acquired.Explanation, message), acquireErr) + return configFailure(invocation.Context, fmt.Sprintf("Unable to list sources for configuration scope %q.", name), sourceSelectionExplanation(acquired.Explanation, message), acquireErr) } - return configFailure(message, acquired.Explanation, fmt.Errorf("source ID %q was not found", plan.sourceID.Value)) + return configFailure(invocation.Context, message, acquired.Explanation, fmt.Errorf("source ID %q was not found", plan.sourceID.Value)) } if acquireErr == nil && invocation.Context.Err() != nil { err := invocation.Context.Err() - return configFailure("Configuration source listing was canceled.", acquired.Explanation, err) + return configFailure(invocation.Context, "Configuration source listing was canceled.", acquired.Explanation, err) } _ = reporter.Report(commandkit.Report{Value: document, TextTemplate: sourceTextTemplate}) if acquireErr != nil { - return configFailure(fmt.Sprintf("Unable to list sources for configuration scope %q.", name), acquired.Explanation, acquireErr) + return configFailure(invocation.Context, fmt.Sprintf("Unable to list sources for configuration scope %q.", name), acquired.Explanation, acquireErr) } return commandkit.Success() } diff --git a/integrations/ckconfig/validate.go b/integrations/ckconfig/validate.go index 7ef2018..f69880b 100644 --- a/integrations/ckconfig/validate.go +++ b/integrations/ckconfig/validate.go @@ -71,7 +71,7 @@ func runConfigValidation[I, S any](invocation commandkit.Invocation, plan *confi } for _, selected := range plan.scopes { if err := invocation.Context.Err(); err != nil { - outcome = configFailure("Configuration validation was canceled.", commandkit.Explanation{}, err) + outcome = configFailure(invocation.Context, "Configuration validation was canceled.", commandkit.Explanation{}, err) break } name := selected.scope.scope.Name @@ -109,7 +109,7 @@ func runConfigValidation[I, S any](invocation commandkit.Invocation, plan *confi if entry.Outcome == "canceled" { message = "Configuration validation was canceled." } - outcome = configFailure(message, acquired.Explanation, err) + outcome = configFailure(invocation.Context, message, acquired.Explanation, err) break } }