From b63be2d6f5b0ee4251ae026bf2561af5498d08ec Mon Sep 17 00:00:00 2001 From: Denis Bilenko Date: Sun, 8 Dec 2024 19:09:40 +0100 Subject: [PATCH] all --- bundle/config/mutator/initialize_urls.go | 4 +- .../mutator/resolve_resource_references.go | 4 +- bundle/deploy/state_pull.go | 10 ++++- bundle/libraries/upload_test.go | 12 +++--- bundle/render/render_text_output.go | 8 +++- cmd/auth/describe.go | 4 +- cmd/bundle/debug/terraform.go | 10 ++++- cmd/bundle/deploy.go | 8 +++- cmd/bundle/run.go | 8 +++- cmd/configure/flags.go | 5 ++- cmd/root/auth.go | 4 +- cmd/root/bundle.go | 12 ++++-- cmd/root/io.go | 4 +- cmd/root/logger.go | 40 ++++++++++++++----- cmd/root/progress_logger.go | 8 +++- libs/auth/callback.go | 6 ++- libs/cmdio/logger.go | 24 ++++++++--- libs/cmdio/render.go | 4 +- libs/dyn/convert/from_typed.go | 8 +++- libs/dyn/convert/normalize.go | 15 +++++-- libs/dyn/jsonloader/json.go | 4 +- libs/dyn/mapping.go | 8 +++- libs/dyn/merge/merge.go | 8 +++- libs/dyn/pattern.go | 4 +- libs/dyn/visit.go | 4 +- libs/dyn/visit_map.go | 4 +- libs/dyn/visit_set.go | 4 +- libs/dyn/walk.go | 4 +- libs/dyn/yamlloader/loader.go | 4 +- libs/env/loader.go | 4 +- libs/git/config.go | 8 +++- libs/process/stub.go | 12 ++++-- libs/sync/output.go | 15 +++++-- 33 files changed, 211 insertions(+), 70 deletions(-) diff --git a/bundle/config/mutator/initialize_urls.go b/bundle/config/mutator/initialize_urls.go index 319305912..d6a92da4c 100644 --- a/bundle/config/mutator/initialize_urls.go +++ b/bundle/config/mutator/initialize_urls.go @@ -32,7 +32,9 @@ func (m *initializeURLs) Apply(ctx context.Context, b *bundle.Bundle) diag.Diagn } orgId := strconv.FormatInt(workspaceId, 10) host := b.WorkspaceClient().Config.CanonicalHostName() - initializeForWorkspace(b, orgId, host) + if err := initializeForWorkspace(b, orgId, host); err != nil { + return diag.FromErr(err) + } return nil } diff --git a/bundle/config/mutator/resolve_resource_references.go b/bundle/config/mutator/resolve_resource_references.go index 89eaa346c..cb4c8223c 100644 --- a/bundle/config/mutator/resolve_resource_references.go +++ b/bundle/config/mutator/resolve_resource_references.go @@ -36,7 +36,9 @@ func (m *resolveResourceReferences) Apply(ctx context.Context, b *bundle.Bundle) return fmt.Errorf("failed to resolve %s, err: %w", v.Lookup, err) } - v.Set(id) + if err := v.Set(id); err != nil { + return err + } return nil }) } diff --git a/bundle/deploy/state_pull.go b/bundle/deploy/state_pull.go index 5e301a6f3..96f138e9d 100644 --- a/bundle/deploy/state_pull.go +++ b/bundle/deploy/state_pull.go @@ -62,8 +62,14 @@ func (s *statePull) Apply(ctx context.Context, b *bundle.Bundle) diag.Diagnostic } // Truncating the file before writing - local.Truncate(0) - local.Seek(0, 0) + err = local.Truncate(0) + if err != nil { + return diag.FromErr(err) + } + _, err = local.Seek(0, 0) + if err != nil { + return diag.FromErr(err) + } // Write file to disk. log.Infof(ctx, "Writing remote deployment state file to local cache directory") diff --git a/bundle/libraries/upload_test.go b/bundle/libraries/upload_test.go index 493785bf5..4d777adfc 100644 --- a/bundle/libraries/upload_test.go +++ b/bundle/libraries/upload_test.go @@ -23,7 +23,7 @@ func TestArtifactUploadForWorkspace(t *testing.T) { tmpDir := t.TempDir() whlFolder := filepath.Join(tmpDir, "whl") testutil.Touch(t, whlFolder, "source.whl") - whlLocalPath := filepath.Join(whlFolder, "source.whl") + _ = filepath.Join(whlFolder, "source.whl") b := &bundle.Bundle{ SyncRootPath: tmpDir, @@ -32,10 +32,10 @@ func TestArtifactUploadForWorkspace(t *testing.T) { ArtifactPath: "/foo/bar/artifacts", }, Artifacts: config.Artifacts{ - "whl": { + "whl": &config.Artifact{ Type: config.ArtifactPythonWheel, Files: []config.ArtifactFile{ - {Source: whlLocalPath}, + {Source: filepath.Join(whlFolder, "source.whl")}, }, }, }, @@ -111,7 +111,7 @@ func TestArtifactUploadForVolumes(t *testing.T) { tmpDir := t.TempDir() whlFolder := filepath.Join(tmpDir, "whl") testutil.Touch(t, whlFolder, "source.whl") - whlLocalPath := filepath.Join(whlFolder, "source.whl") + _ = filepath.Join(whlFolder, "source.whl") b := &bundle.Bundle{ SyncRootPath: tmpDir, @@ -120,10 +120,10 @@ func TestArtifactUploadForVolumes(t *testing.T) { ArtifactPath: "/Volumes/foo/bar/artifacts", }, Artifacts: config.Artifacts{ - "whl": { + "whl": &config.Artifact{ Type: config.ArtifactPythonWheel, Files: []config.ArtifactFile{ - {Source: whlLocalPath}, + {Source: filepath.Join(whlFolder, "source.whl")}, }, }, }, diff --git a/bundle/render/render_text_output.go b/bundle/render/render_text_output.go index 92dacb448..af437d9be 100644 --- a/bundle/render/render_text_output.go +++ b/bundle/render/render_text_output.go @@ -171,10 +171,14 @@ func RenderDiagnostics(out io.Writer, b *bundle.Bundle, diags diag.Diagnostics, if err != nil { return fmt.Errorf("failed to render summary: %w", err) } - io.WriteString(out, "\n") + if _, err := io.WriteString(out, "\n"); err != nil { + return err + } } trailer := buildTrailer(diags) - io.WriteString(out, trailer) + if _, err := io.WriteString(out, trailer); err != nil { + return err + } } return nil diff --git a/cmd/auth/describe.go b/cmd/auth/describe.go index 3a6e3d5d7..16c5fe466 100644 --- a/cmd/auth/describe.go +++ b/cmd/auth/describe.go @@ -141,7 +141,9 @@ func render(ctx context.Context, cmd *cobra.Command, status *authStatus, templat if err != nil { return err } - cmd.OutOrStdout().Write(buf) + if _, err := cmd.OutOrStdout().Write(buf); err != nil { + return err + } default: return fmt.Errorf("unknown output type %s", root.OutputType(cmd)) } diff --git a/cmd/bundle/debug/terraform.go b/cmd/bundle/debug/terraform.go index 843ecac4e..c2b4e8f7a 100644 --- a/cmd/bundle/debug/terraform.go +++ b/cmd/bundle/debug/terraform.go @@ -60,13 +60,19 @@ For more information about filesystem mirrors, see the Terraform documentation: } switch root.OutputType(cmd) { case flags.OutputText: - cmdio.Render(cmd.Context(), dependencies.Terraform) + err := cmdio.Render(cmd.Context(), dependencies.Terraform) + if err != nil { + return err + } case flags.OutputJSON: buf, err := json.MarshalIndent(dependencies, "", " ") if err != nil { return err } - cmd.OutOrStdout().Write(buf) + _, err = cmd.OutOrStdout().Write(buf) + if err != nil { + return err + } default: return fmt.Errorf("unknown output type %s", root.OutputType(cmd)) } diff --git a/cmd/bundle/deploy.go b/cmd/bundle/deploy.go index a25e02f6c..1ada76531 100644 --- a/cmd/bundle/deploy.go +++ b/cmd/bundle/deploy.go @@ -33,10 +33,14 @@ func newDeployCommand() *cobra.Command { cmd.Flags().StringVar(&clusterId, "compute-id", "", "Override cluster in the deployment with the given compute ID.") cmd.Flags().StringVarP(&clusterId, "cluster-id", "c", "", "Override cluster in the deployment with the given cluster ID.") cmd.Flags().BoolVar(&autoApprove, "auto-approve", false, "Skip interactive approvals that might be required for deployment.") - cmd.Flags().MarkDeprecated("compute-id", "use --cluster-id instead") + if err := cmd.Flags().MarkDeprecated("compute-id", "use --cluster-id instead"); err != nil { + return nil + } cmd.Flags().BoolVar(&verbose, "verbose", false, "Enable verbose output.") // Verbose flag currently only affects file sync output, it's used by the vscode extension - cmd.Flags().MarkHidden("verbose") + if err := cmd.Flags().MarkHidden("verbose"); err != nil { + return nil + } cmd.RunE = func(cmd *cobra.Command, args []string) error { ctx := cmd.Context() diff --git a/cmd/bundle/run.go b/cmd/bundle/run.go index 7a92766d9..41068ef52 100644 --- a/cmd/bundle/run.go +++ b/cmd/bundle/run.go @@ -159,13 +159,17 @@ task or a Python wheel task, the second example applies. if err != nil { return err } - cmd.OutOrStdout().Write([]byte(resultString)) + if _, err := cmd.OutOrStdout().Write([]byte(resultString)); err != nil { + return err + } case flags.OutputJSON: b, err := json.MarshalIndent(output, "", " ") if err != nil { return err } - cmd.OutOrStdout().Write(b) + if _, err := cmd.OutOrStdout().Write(b); err != nil { + return err + } default: return fmt.Errorf("unknown output type %s", root.OutputType(cmd)) } diff --git a/cmd/configure/flags.go b/cmd/configure/flags.go index 80e650268..911dce245 100644 --- a/cmd/configure/flags.go +++ b/cmd/configure/flags.go @@ -21,5 +21,8 @@ func (f *configureFlags) Register(cmd *cobra.Command) { // Include token flag for compatibility with the legacy CLI. // It doesn't actually do anything because we always use PATs. cmd.Flags().Bool("token", true, "Configure using Databricks Personal Access Token") - cmd.Flags().MarkHidden("token") + err := cmd.Flags().MarkHidden("token") + if err != nil { + panic(err) + } } diff --git a/cmd/root/auth.go b/cmd/root/auth.go index 107679105..4a5a9eb88 100644 --- a/cmd/root/auth.go +++ b/cmd/root/auth.go @@ -37,7 +37,9 @@ func (e ErrNoAccountProfiles) Error() string { func initProfileFlag(cmd *cobra.Command) { cmd.PersistentFlags().StringP("profile", "p", "", "~/.databrickscfg profile") - cmd.RegisterFlagCompletionFunc("profile", profile.ProfileCompletion) + if err := cmd.RegisterFlagCompletionFunc("profile", profile.ProfileCompletion); err != nil { + panic(err) + } } func profileFlagValue(cmd *cobra.Command) (string, bool) { diff --git a/cmd/root/bundle.go b/cmd/root/bundle.go index 8b98f2cf2..ec72e3b67 100644 --- a/cmd/root/bundle.go +++ b/cmd/root/bundle.go @@ -146,13 +146,19 @@ func targetCompletion(cmd *cobra.Command, args []string, toComplete string) ([]s func initTargetFlag(cmd *cobra.Command) { // To operate in the context of a bundle, all commands must take an "target" parameter. cmd.PersistentFlags().StringP("target", "t", "", "bundle target to use (if applicable)") - cmd.RegisterFlagCompletionFunc("target", targetCompletion) + if err := cmd.RegisterFlagCompletionFunc("target", targetCompletion); err != nil { + panic(err) + } } // DEPRECATED flag func initEnvironmentFlag(cmd *cobra.Command) { // To operate in the context of a bundle, all commands must take an "environment" parameter. cmd.PersistentFlags().StringP("environment", "e", "", "bundle target to use (if applicable)") - cmd.PersistentFlags().MarkDeprecated("environment", "use --target flag instead") - cmd.RegisterFlagCompletionFunc("environment", targetCompletion) + if err := cmd.PersistentFlags().MarkDeprecated("environment", "use --target flag instead"); err != nil { + panic(err) + } + if err := cmd.RegisterFlagCompletionFunc("environment", targetCompletion); err != nil { + panic(err) + } } diff --git a/cmd/root/io.go b/cmd/root/io.go index b224bbb27..1c03ce70f 100644 --- a/cmd/root/io.go +++ b/cmd/root/io.go @@ -21,7 +21,9 @@ func initOutputFlag(cmd *cobra.Command) *outputFlag { // Configure defaults from environment, if applicable. // If the provided value is invalid it is ignored. if v, ok := env.Lookup(cmd.Context(), envOutputFormat); ok { - f.output.Set(v) + if err := f.output.Set(v); err != nil { + panic(err) + } } cmd.PersistentFlags().VarP(&f.output, "output", "o", "output type: text or json") diff --git a/cmd/root/logger.go b/cmd/root/logger.go index 48cb99a37..a2c2cc49a 100644 --- a/cmd/root/logger.go +++ b/cmd/root/logger.go @@ -45,7 +45,9 @@ func (f *logFlags) makeLogHandler(opts slog.HandlerOptions) (slog.Handler, error func (f *logFlags) initializeContext(ctx context.Context) (context.Context, error) { if f.debug { - f.level.Set("debug") + if err := f.level.Set("debug"); err != nil { + panic(err) + } } opts := slog.HandlerOptions{} @@ -81,13 +83,19 @@ func initLogFlags(cmd *cobra.Command) *logFlags { // Configure defaults from environment, if applicable. // If the provided value is invalid it is ignored. if v, ok := env.Lookup(cmd.Context(), envLogFile); ok { - f.file.Set(v) + if err := f.file.Set(v); err != nil { + panic(err) + } } if v, ok := env.Lookup(cmd.Context(), envLogLevel); ok { - f.level.Set(v) + if err := f.level.Set(v); err != nil { + panic(err) + } } if v, ok := env.Lookup(cmd.Context(), envLogFormat); ok { - f.output.Set(v) + if err := f.output.Set(v); err != nil { + panic(err) + } } flags := cmd.PersistentFlags() @@ -97,12 +105,24 @@ func initLogFlags(cmd *cobra.Command) *logFlags { flags.Var(&f.output, "log-format", "log output format (text or json)") // mark fine-grained flags hidden from global --help - flags.MarkHidden("log-file") - flags.MarkHidden("log-level") - flags.MarkHidden("log-format") + if err := flags.MarkHidden("log-file"); err != nil { + panic(err) + } + if err := flags.MarkHidden("log-level"); err != nil { + panic(err) + } + if err := flags.MarkHidden("log-format"); err != nil { + panic(err) + } - cmd.RegisterFlagCompletionFunc("log-file", f.file.Complete) - cmd.RegisterFlagCompletionFunc("log-level", f.level.Complete) - cmd.RegisterFlagCompletionFunc("log-format", f.output.Complete) + if err := cmd.RegisterFlagCompletionFunc("log-file", f.file.Complete); err != nil { + panic(err) + } + if err := cmd.RegisterFlagCompletionFunc("log-level", f.level.Complete); err != nil { + panic(err) + } + if err := cmd.RegisterFlagCompletionFunc("log-format", f.output.Complete); err != nil { + panic(err) + } return &f } diff --git a/cmd/root/progress_logger.go b/cmd/root/progress_logger.go index 7d6a1fa46..4d30bf425 100644 --- a/cmd/root/progress_logger.go +++ b/cmd/root/progress_logger.go @@ -59,12 +59,16 @@ func initProgressLoggerFlag(cmd *cobra.Command, logFlags *logFlags) *progressLog // Configure defaults from environment, if applicable. // If the provided value is invalid it is ignored. if v, ok := env.Lookup(cmd.Context(), envProgressFormat); ok { - f.Set(v) + if err := f.ProgressLogFormat.Set(v); err != nil { + panic(err) + } } flags := cmd.PersistentFlags() flags.Var(&f.ProgressLogFormat, "progress-format", "format for progress logs (append, inplace, json)") - flags.MarkHidden("progress-format") + if err := flags.MarkHidden("progress-format"); err != nil { + panic(err) + } cmd.RegisterFlagCompletionFunc("progress-format", f.ProgressLogFormat.Complete) return &f } diff --git a/libs/auth/callback.go b/libs/auth/callback.go index 5a2400697..852e1f1b8 100644 --- a/libs/auth/callback.go +++ b/libs/auth/callback.go @@ -53,7 +53,11 @@ func newCallback(ctx context.Context, a *PersistentAuth) (*callbackServer, error a: a, } cb.srv.Handler = cb - go cb.srv.Serve(cb.ln) + go func() { + if err := cb.srv.Serve(cb.ln); err != http.ErrServerClosed { + panic(err) + } + }() return cb, nil } diff --git a/libs/cmdio/logger.go b/libs/cmdio/logger.go index 45b1883ce..405533dee 100644 --- a/libs/cmdio/logger.go +++ b/libs/cmdio/logger.go @@ -188,23 +188,35 @@ func (l *Logger) writeJson(event Event) { // we panic because there we cannot catch this in jobs.RunNowAndWait panic(err) } - l.Writer.Write([]byte(b)) - l.Writer.Write([]byte("\n")) + if _, err := l.Writer.Write([]byte(b)); err != nil { + panic(err) + } + if _, err := l.Writer.Write([]byte("\n")); err != nil { + panic(err) + } } func (l *Logger) writeAppend(event Event) { - l.Writer.Write([]byte(event.String())) - l.Writer.Write([]byte("\n")) + if _, err := l.Writer.Write([]byte(event.String())); err != nil { + panic(err) + } + if _, err := l.Writer.Write([]byte("\n")); err != nil { + panic(err) + } } func (l *Logger) writeInplace(event Event) { if l.isFirstEvent { // save cursor location - l.Writer.Write([]byte("\033[s")) + if _, err := l.Writer.Write([]byte("\033[s")); err != nil { + panic(err) + } } // move cursor to saved location - l.Writer.Write([]byte("\033[u")) + if _, err := l.Writer.Write([]byte("\033[u")); err != nil { + panic(err) + } // clear from cursor to end of screen l.Writer.Write([]byte("\033[0J")) diff --git a/libs/cmdio/render.go b/libs/cmdio/render.go index c68ddca0d..1529274a3 100644 --- a/libs/cmdio/render.go +++ b/libs/cmdio/render.go @@ -361,7 +361,9 @@ func renderUsingTemplate(ctx context.Context, r templateRenderer, w io.Writer, h if err != nil { return err } - tw.Write([]byte("\n")) + if _, err := tw.Write([]byte("\n")); err != nil { + return err + } // Do not flush here. Instead, allow the first 100 resources to determine the initial spacing of the header columns. } t, err := base.Parse(tmpl) diff --git a/libs/dyn/convert/from_typed.go b/libs/dyn/convert/from_typed.go index cd92ad0eb..3d54e9d5d 100644 --- a/libs/dyn/convert/from_typed.go +++ b/libs/dyn/convert/from_typed.go @@ -126,7 +126,9 @@ func fromTypedStruct(src reflect.Value, ref dyn.Value, options ...fromTypedOptio // Either if the key was set in the reference or the field is not zero-valued, we include it. if ok || nv.Kind() != dyn.KindNil { - out.Set(refk, nv) + if err := out.Set(refk, nv); err != nil { + return dyn.InvalidValue, err + } } } @@ -184,7 +186,9 @@ func fromTypedMap(src reflect.Value, ref dyn.Value) (dyn.Value, error) { // Every entry is represented, even if it is a nil. // Otherwise, a map with zero-valued structs would yield a nil as well. - out.Set(refk, nv) + if err := out.Set(refk, nv); err != nil { + return dyn.InvalidValue, err + } } return dyn.V(out), nil diff --git a/libs/dyn/convert/normalize.go b/libs/dyn/convert/normalize.go index 106add35d..08b55e7e4 100644 --- a/libs/dyn/convert/normalize.go +++ b/libs/dyn/convert/normalize.go @@ -116,7 +116,12 @@ func (n normalizeOptions) normalizeStruct(typ reflect.Type, src dyn.Value, seen } } - out.Set(pk, nv) + if err := out.Set(pk, nv); err != nil { + return dyn.InvalidValue, diag.Diagnostics{diag.Diagnostic{ + Severity: diag.Error, + Summary: err.Error(), + }} + } } // Return the normalized value if missing fields are not included. @@ -162,7 +167,9 @@ func (n normalizeOptions) normalizeStruct(typ reflect.Type, src dyn.Value, seen continue } if v.IsValid() { - out.Set(dyn.V(k), v) + if err := out.Set(dyn.V(k), v); err != nil { + return dyn.InvalidValue, diag.FromErr(err) + } } } @@ -201,7 +208,9 @@ func (n normalizeOptions) normalizeMap(typ reflect.Type, src dyn.Value, seen []r } } - out.Set(pk, nv) + if err := out.Set(pk, nv); err != nil { + return dyn.InvalidValue, diag.FromErr(err) + } } return dyn.NewValue(out, src.Locations()), diags diff --git a/libs/dyn/jsonloader/json.go b/libs/dyn/jsonloader/json.go index cbf539263..39d1c51ba 100644 --- a/libs/dyn/jsonloader/json.go +++ b/libs/dyn/jsonloader/json.go @@ -70,7 +70,9 @@ func decodeValue(decoder *json.Decoder, o *Offset) (dyn.Value, error) { return invalidValueWithLocation(decoder, o), err } - obj.Set(keyVal, val) + if err := obj.Set(keyVal, val); err != nil { + return invalidValueWithLocation(decoder, o), err + } } // Consume the closing '}' if _, err := decoder.Token(); err != nil { diff --git a/libs/dyn/mapping.go b/libs/dyn/mapping.go index f9f2d2e97..98400f8a3 100644 --- a/libs/dyn/mapping.go +++ b/libs/dyn/mapping.go @@ -41,7 +41,9 @@ func newMappingWithSize(size int) Mapping { func newMappingFromGoMap(vin map[string]Value) Mapping { m := newMappingWithSize(len(vin)) for k, v := range vin { - m.Set(V(k), v) + if err := m.Set(V(k), v); err != nil { + panic(err) + } } return m } @@ -144,6 +146,8 @@ func (m Mapping) Clone() Mapping { // Merge merges the key-value pairs from another Mapping into the current Mapping. func (m *Mapping) Merge(n Mapping) { for _, p := range n.pairs { - m.Set(p.Key, p.Value) + if err := m.Set(p.Key, p.Value); err != nil { + panic(err) + } } } diff --git a/libs/dyn/merge/merge.go b/libs/dyn/merge/merge.go index 29decd779..b96d493a1 100644 --- a/libs/dyn/merge/merge.go +++ b/libs/dyn/merge/merge.go @@ -88,10 +88,14 @@ func mergeMap(a, b dyn.Value) (dyn.Value, error) { if err != nil { return dyn.InvalidValue, err } - out.Set(pk, merged) + if err := out.Set(pk, merged); err != nil { + return dyn.InvalidValue, err + } } else { // Otherwise, just set the value. - out.Set(pk, pv) + if err := out.Set(pk, pv); err != nil { + return dyn.InvalidValue, err + } } } diff --git a/libs/dyn/pattern.go b/libs/dyn/pattern.go index aecdc3ca6..fb9758559 100644 --- a/libs/dyn/pattern.go +++ b/libs/dyn/pattern.go @@ -69,7 +69,9 @@ func (c anyKeyComponent) visit(v Value, prefix Path, suffix Pattern, opts visitO return InvalidValue, err } - m.Set(pk, nv) + if err := m.Set(pk, nv); err != nil { + panic(err) + } } return NewValue(m, v.Locations()), nil diff --git a/libs/dyn/visit.go b/libs/dyn/visit.go index 38adec24f..cc2d8619c 100644 --- a/libs/dyn/visit.go +++ b/libs/dyn/visit.go @@ -122,7 +122,9 @@ func (component pathComponent) visit(v Value, prefix Path, suffix Pattern, opts // Return an updated map value. m = m.Clone() - m.Set(V(component.key), nv) + if err := m.Set(V(component.key), nv); err != nil { + return InvalidValue, err + } return Value{ v: m, k: KindMap, diff --git a/libs/dyn/visit_map.go b/libs/dyn/visit_map.go index 3f0cded03..cbd1af13d 100644 --- a/libs/dyn/visit_map.go +++ b/libs/dyn/visit_map.go @@ -25,7 +25,9 @@ func Foreach(fn MapFunc) MapFunc { if err != nil { return InvalidValue, err } - m.Set(pk, nv) + if err := m.Set(pk, nv); err != nil { + return InvalidValue, err + } } return NewValue(m, v.Locations()), nil case KindSequence: diff --git a/libs/dyn/visit_set.go b/libs/dyn/visit_set.go index b086fb8a9..d5a687a02 100644 --- a/libs/dyn/visit_set.go +++ b/libs/dyn/visit_set.go @@ -41,7 +41,9 @@ func SetByPath(v Value, p Path, nv Value) (Value, error) { // Return an updated map value. m = m.Clone() - m.Set(V(component.key), nv) + if err := m.Set(V(component.key), nv); err != nil { + return InvalidValue, err + } return Value{ v: m, k: KindMap, diff --git a/libs/dyn/walk.go b/libs/dyn/walk.go index c51a11e22..94e2a36c0 100644 --- a/libs/dyn/walk.go +++ b/libs/dyn/walk.go @@ -45,7 +45,9 @@ func walk(v Value, p Path, fn func(p Path, v Value) (Value, error)) (Value, erro if err != nil { return InvalidValue, err } - out.Set(pk, nv) + if err := out.Set(pk, nv); err != nil { + panic(err) + } } v.v = out case KindSequence: diff --git a/libs/dyn/yamlloader/loader.go b/libs/dyn/yamlloader/loader.go index a77ee0744..a8111e6c4 100644 --- a/libs/dyn/yamlloader/loader.go +++ b/libs/dyn/yamlloader/loader.go @@ -129,7 +129,9 @@ func (d *loader) loadMapping(node *yaml.Node, loc dyn.Location) (dyn.Value, erro return dyn.InvalidValue, err } - acc.Set(k, v) + if err := acc.Set(k, v); err != nil { + return dyn.InvalidValue, err + } } if merge == nil { diff --git a/libs/env/loader.go b/libs/env/loader.go index f441ffa15..74c54cee8 100644 --- a/libs/env/loader.go +++ b/libs/env/loader.go @@ -43,7 +43,9 @@ func (le *configLoader) Configure(cfg *config.Config) error { if v == "" { continue } - a.Set(cfg, v) + if err := a.Set(cfg, v); err != nil { + return err + } } } return nil diff --git a/libs/git/config.go b/libs/git/config.go index fafd81bd6..15bffa153 100644 --- a/libs/git/config.go +++ b/libs/git/config.go @@ -155,8 +155,12 @@ func globalGitConfig() (*config, error) { // > are missing or unreadable they will be ignored. // // We therefore ignore the error return value for the calls below. - config.loadFile(vfs.MustNew(xdgConfigHome), "git/config") - config.loadFile(vfs.MustNew(config.home), ".gitconfig") + if err := config.loadFile(vfs.MustNew(xdgConfigHome), "git/config"); err != nil { + return nil, err + } + if err := config.loadFile(vfs.MustNew(config.home), ".gitconfig"); err != nil { + return nil, err + } return config, nil } diff --git a/libs/process/stub.go b/libs/process/stub.go index 8472f65d5..422f02b22 100644 --- a/libs/process/stub.go +++ b/libs/process/stub.go @@ -149,10 +149,14 @@ func (s *processStub) run(cmd *exec.Cmd) error { continue } if resp.stdout != "" { - cmd.Stdout.Write([]byte(resp.stdout)) + if _, err := cmd.Stdout.Write([]byte(resp.stdout)); err != nil { + return err + } } if resp.stderr != "" { - cmd.Stderr.Write([]byte(resp.stderr)) + if _, err := cmd.Stderr.Write([]byte(resp.stderr)); err != nil { + return err + } } return resp.err } @@ -164,7 +168,9 @@ func (s *processStub) run(cmd *exec.Cmd) error { return fmt.Errorf("no default process stub") } if s.reponseStub.stdout != "" { - cmd.Stdout.Write([]byte(s.reponseStub.stdout)) + if _, err := cmd.Stdout.Write([]byte(s.reponseStub.stdout)); err != nil { + return err + } } return s.reponseStub.err } diff --git a/libs/sync/output.go b/libs/sync/output.go index c01b25ef6..5d41635ad 100644 --- a/libs/sync/output.go +++ b/libs/sync/output.go @@ -43,9 +43,18 @@ func TextOutput(ctx context.Context, ch <-chan Event, w io.Writer) { // Log only if something actually happened. // Sync events produce an empty string if nothing happened. if str := e.String(); str != "" { - bw.WriteString(str) - bw.WriteString("\n") - bw.Flush() + _, err := bw.WriteString(str) + if err != nil { + panic(err) + } + _, err = bw.WriteString("\n") + if err != nil { + panic(err) + } + err = bw.Flush() + if err != nil { + panic(err) + } } } }