use Config instead of global RunContext is present

Author: tejal29

cmd/skaffold/app/cmd/cmd.go

@@ -23,6 +23,7 @@ import (
 	"os"
 	"strings"
 
+	sErrors "github.com/GoogleContainerTools/skaffold/pkg/skaffold/errors"
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
@@ -265,12 +266,12 @@ func setUpLogs(stdErr io.Writer, level string, timestamp bool) error {
 	return nil
 }
 
-func alwaysSucceedWhenCancelled(ctx context.Context, err error) error {
+func alwaysSucceedWhenCancelled(ctx context.Context, cfg sErrors.Config, err error) error {
 	// if the context was cancelled act as if all is well
-	if err != nil && ctx.Err() == context.Canceled {
+	if err == nil || ctx.Err() == context.Canceled {
 		return nil
 	}
-	return err
+	return sErrors.ShowAIError(cfg, err)
 }
 
 func isHouseKeepingMessagesAllowed(cmd *cobra.Command) bool {

cmd/skaffold/app/cmd/commands.go

@@ -23,8 +23,6 @@ import (
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
-
-	sErrors "github.com/GoogleContainerTools/skaffold/pkg/skaffold/errors"
 )
 
 // Builder is used to build cobra commands.
@@ -107,7 +105,7 @@ func (b *builder) Hidden() Builder {
 func (b *builder) ExactArgs(argCount int, action func(context.Context, io.Writer, []string) error) *cobra.Command {
 	b.cmd.Args = cobra.ExactArgs(argCount)
 	b.cmd.RunE = func(_ *cobra.Command, args []string) error {
-		err := handleWellKnownErrors(action(b.cmd.Context(), b.cmd.OutOrStdout(), args))
+		err := action(b.cmd.Context(), b.cmd.OutOrStdout(), args)
 		// clean up server at end of the execution since post run hooks are only executed if
 		// RunE is successful
 		if shutdownAPIServer != nil {
@@ -121,7 +119,7 @@ func (b *builder) ExactArgs(argCount int, action func(context.Context, io.Writer
 func (b *builder) NoArgs(action func(context.Context, io.Writer) error) *cobra.Command {
 	b.cmd.Args = cobra.NoArgs
 	b.cmd.RunE = func(*cobra.Command, []string) error {
-		err := handleWellKnownErrors(action(b.cmd.Context(), b.cmd.OutOrStdout()))
+		err := action(b.cmd.Context(), b.cmd.OutOrStdout())
 		// clean up server at end of the execution since post run hooks are only executed if
 		// RunE is successful
 		if shutdownAPIServer != nil {
@@ -131,11 +129,3 @@ func (b *builder) NoArgs(action func(context.Context, io.Writer) error) *cobra.C
 	}
 	return &b.cmd
 }
-
-func handleWellKnownErrors(err error) error {
-	if err == nil {
-		return err
-	}
-
-	return sErrors.ShowAIError(err)
-}

cmd/skaffold/app/cmd/runner.go

@@ -46,32 +46,30 @@ import (
 var createRunner = createNewRunner
 
 func withRunner(ctx context.Context, out io.Writer, action func(runner.Runner, []*latest.SkaffoldConfig) error) error {
-	runner, config, err := createRunner(out, opts)
+	runner, runCtx, config, err := createRunner(out, opts)
 	if err != nil {
 		return err
 	}
 
 	err = action(runner, config)
 
-	return alwaysSucceedWhenCancelled(ctx, err)
+	return alwaysSucceedWhenCancelled(ctx, runCtx, err)
 }
 
 // createNewRunner creates a Runner and returns the SkaffoldConfig associated with it.
-func createNewRunner(out io.Writer, opts config.SkaffoldOptions) (runner.Runner, []*latest.SkaffoldConfig, error) {
+func createNewRunner(out io.Writer, opts config.SkaffoldOptions) (runner.Runner, *runcontext.RunContext, []*latest.SkaffoldConfig, error) {
 	runCtx, configs, err := runContext(out, opts)
 	if err != nil {
-		return nil, nil, err
+		return nil, nil, nil, err
 	}
-	sErrors.SetRunContext(*runCtx)
-
 	instrumentation.InitMeterFromConfig(configs)
 	runner, err := runner.NewForConfig(runCtx)
 	if err != nil {
 		event.InititializationFailed(err)
-		return nil, nil, fmt.Errorf("creating runner: %w", err)
+		return nil, nil, nil, fmt.Errorf("creating runner: %w", err)
 	}
 
-	return runner, configs, nil
+	return runner, runCtx, configs, nil
 }
 
 func runContext(out io.Writer, opts config.SkaffoldOptions) (*runcontext.RunContext, []*latest.SkaffoldConfig, error) {

pkg/skaffold/build/scheduler.go

@@ -90,7 +90,7 @@ func (s *scheduler) build(ctx context.Context, tags tag.ImageTags, i int) error
 
 	w, closeFn, err := s.logger.GetWriter()
 	if err != nil {
-		event.BuildFailed(s., a.ImageName, err)
+		event.BuildFailed(a.ImageName, err)
 		return err
 	}
 	defer closeFn()

pkg/skaffold/deploy/error/errors.go

@@ -24,7 +24,6 @@ import (
 	"github.com/GoogleContainerTools/skaffold/pkg/skaffold/cluster"
 	"github.com/GoogleContainerTools/skaffold/pkg/skaffold/constants"
 	sErrors "github.com/GoogleContainerTools/skaffold/pkg/skaffold/errors"
-	"github.com/GoogleContainerTools/skaffold/pkg/skaffold/runner/runcontext"
 	"github.com/GoogleContainerTools/skaffold/proto/v1"
 )
 
@@ -78,16 +77,18 @@ func isClusterInternalSystemError(err error) bool {
 	return internalServerError.MatchString(err.Error())
 }
 
-func internalSystemError(err error) error {
+func internalSystemError(cfg sErrors.Config, err error) error {
 	return sErrors.NewProblem(
 		func(err error) string {
 			return fmt.Sprintf("Deploy Failed. %v", err)
 		},
 		proto.StatusCode_DEPLOY_CLUSTER_INTERNAL_SYSTEM_ERR,
-		func(runCtx runcontext.RunContext) []*proto.Suggestion {
-			action := fmt.Sprintf("Something went wrong with your cluster %q", runCtx.KubeContext)
-			if isMinikube(runCtx.KubeContext) {
-				action = fmt.Sprintf("Run minikube status -p %s to check if minikube is running", runCtx.KubeContext)
+		cfg,
+		func(cfg sErrors.Config) []*proto.Suggestion {
+			kubectx := cfg.GetKubeContext()
+			action := fmt.Sprintf("Something went wrong with your cluster %q", kubectx)
+			if isMinikube(kubectx) {
+				action = fmt.Sprintf("Run minikube status -p %s to check if minikube is running", kubectx)
 			}
 			return []*proto.Suggestion{{
 				SuggestionCode: proto.SuggestionCode_OPEN_ISSUE,
@@ -99,12 +100,12 @@ func internalSystemError(err error) error {
 	)
 }
 
-func UserError(err error, sc proto.StatusCode) error {
+func UserError(cfg sErrors.Config, err error, sc proto.StatusCode) error {
 	if sErrors.IsSkaffoldErr(err) {
 		return err
 	}
 	if isClusterInternalSystemError(err) {
-		return internalSystemError(err)
+		return internalSystemError(cfg, err)
 	}
 	return sErrors.NewError(err,
 		proto.ActionableErr{

pkg/skaffold/deploy/error/errors_test.go

@@ -21,7 +21,6 @@ import (
 	"testing"
 
 	sErrors "github.com/GoogleContainerTools/skaffold/pkg/skaffold/errors"
-	"github.com/GoogleContainerTools/skaffold/pkg/skaffold/runner/runcontext"
 	"github.com/GoogleContainerTools/skaffold/proto/v1"
 	"github.com/GoogleContainerTools/skaffold/testutil"
 )
@@ -60,9 +59,18 @@ func TestUserError(t *testing.T) {
 			t.Override(&isMinikube, func(string) bool {
 				return test.isMinikube
 			})
-			sErrors.SetRunContext(runcontext.RunContext{KubeContext: "test"})
-			actual := UserError(test.err, proto.StatusCode_DEPLOY_HELM_USER_ERR)
-			t.CheckDeepEqual(test.expected, sErrors.ShowAIError(actual).Error())
+			actual := UserError(errConfig{}, test.err, proto.StatusCode_DEPLOY_HELM_USER_ERR)
+			t.CheckDeepEqual(test.expected, sErrors.ShowAIError(errConfig{}, actual).Error())
 		})
 	}
 }
+
+type errConfig struct{}
+
+func (e errConfig) GetKubeContext() string { return "test" }
+func (e errConfig) GlobalConfig() string   { return "" }
+func (e errConfig) Command() string        { return "" }
+func (e errConfig) DefaultRepo() *string {
+	o := ""
+	return &o
+}

pkg/skaffold/deploy/helm/deploy.go

@@ -30,6 +30,7 @@ import (
 	"strings"
 	"time"
 
+	sErrors "github.com/GoogleContainerTools/skaffold/pkg/skaffold/errors"
 	"github.com/blang/semver"
 	backoff "github.com/cenkalti/backoff/v4"
 	shell "github.com/kballard/go-shellquote"
@@ -72,6 +73,7 @@ var (
 // Deployer deploys workflows using the helm CLI
 type Deployer struct {
 	*latest.HelmDeploy
+	errCfg sErrors.Config
 
 	kubeContext string
 	kubeConfig  string
@@ -111,6 +113,7 @@ func NewDeployer(cfg kubectl.Config, labels map[string]string, h *latest.HelmDep
 		labels:      labels,
 		bV:          hv,
 		enableDebug: cfg.Mode() == config.RunModes.Debug,
+		errCfg:      cfg,
 	}, nil
 }
 
@@ -126,11 +129,11 @@ func (h *Deployer) Deploy(ctx context.Context, out io.Writer, builds []build.Art
 	for _, r := range h.Releases {
 		releaseName, err := util.ExpandEnvTemplateOrFail(r.Name, nil)
 		if err != nil {
-			return nil, userErr(fmt.Sprintf("cannot expand release name %q", r.Name), err)
+			return nil, userErr(h.errCfg, fmt.Sprintf("cannot expand release name %q", r.Name), err)
 		}
 		results, err := h.deployRelease(ctx, out, releaseName, r, builds, valuesSet, h.bV)
 		if err != nil {
-			return nil, userErr(fmt.Sprintf("deploying %q", releaseName), err)
+			return nil, userErr(h.errCfg, fmt.Sprintf("deploying %q", releaseName), err)
 		}
 
 		// collect namespaces
@@ -217,7 +220,7 @@ func (h *Deployer) Dependencies() ([]string, error) {
 		}
 
 		if err := walk.From(release.ChartPath).When(isDep).AppendPaths(&deps); err != nil {
-			return deps, userErr("issue walking releases", err)
+			return deps, userErr(h.errCfg, "issue walking releases", err)
 		}
 	}
 	sort.Strings(deps)
@@ -277,7 +280,7 @@ func (h *Deployer) Render(ctx context.Context, out io.Writer, builds []build.Art
 
 		args, err = constructOverrideArgs(&r, builds, args, func(string) {})
 		if err != nil {
-			return userErr("construct override args", err)
+			return userErr(h.errCfg, "construct override args", err)
 		}
 
 		namespace, err := h.releaseNamespace(r)
@@ -290,7 +293,7 @@ func (h *Deployer) Render(ctx context.Context, out io.Writer, builds []build.Art
 
 		outBuffer := new(bytes.Buffer)
 		if err := h.exec(ctx, outBuffer, false, nil, args...); err != nil {
-			return userErr("std out err", fmt.Errorf(outBuffer.String()))
+			return userErr(h.errCfg, "std out err", fmt.Errorf(outBuffer.String()))
 		}
 		renderedManifests.Write(outBuffer.Bytes())
 	}
@@ -366,19 +369,19 @@ func (h *Deployer) deployRelease(ctx context.Context, out io.Writer, releaseName
 		logrus.Infof("Building helm dependencies...")
 
 		if err := h.exec(ctx, out, false, nil, "dep", "build", r.ChartPath); err != nil {
-			return nil, userErr("building helm dependencies", err)
+			return nil, userErr(h.errCfg, "building helm dependencies", err)
 		}
 	}
 
 	// Dump overrides to a YAML file to pass into helm
 	if len(r.Overrides.Values) != 0 {
 		overrides, err := yaml.Marshal(r.Overrides)
 		if err != nil {
-			return nil, userErr("cannot marshal overrides to create overrides values.yaml", err)
+			return nil, userErr(h.errCfg, "cannot marshal overrides to create overrides values.yaml", err)
 		}
 
 		if err := ioutil.WriteFile(constants.HelmOverridesFilename, overrides, 0666); err != nil {
-			return nil, userErr(fmt.Sprintf("cannot create file %q", constants.HelmOverridesFilename), err)
+			return nil, userErr(h.errCfg, fmt.Sprintf("cannot create file %q", constants.HelmOverridesFilename), err)
 		}
 
 		defer func() {
@@ -389,25 +392,25 @@ func (h *Deployer) deployRelease(ctx context.Context, out io.Writer, releaseName
 	if r.Packaged != nil {
 		chartPath, err := h.packageChart(ctx, r)
 		if err != nil {
-			return nil, userErr("cannot package chart", err)
+			return nil, userErr(h.errCfg, "cannot package chart", err)
 		}
 
 		opts.chartPath = chartPath
 	}
 
 	args, err := h.installArgs(r, builds, valuesSet, opts)
 	if err != nil {
-		return nil, userErr("release args", err)
+		return nil, userErr(h.errCfg, "release args", err)
 	}
 
 	err = h.exec(ctx, out, r.UseHelmSecrets, installEnv, args...)
 	if err != nil {
-		return nil, userErr("install", err)
+		return nil, userErr(h.errCfg, "install", err)
 	}
 
 	b, err := h.getRelease(ctx, releaseName, opts.namespace)
 	if err != nil {
-		return nil, userErr("get release", err)
+		return nil, userErr(h.errCfg, "get release", err)
 	}
 
 	artifacts := parseReleaseInfo(opts.namespace, bufio.NewReader(&b))

pkg/skaffold/deploy/helm/errors.go

@@ -67,8 +67,8 @@ func helmLabelErr(err error) error {
 		})
 }
 
-func userErr(prefix string, err error) error {
-	return deployerr.UserError(errors.Wrap(err, prefix), proto.StatusCode_DEPLOY_HELM_USER_ERR)
+func userErr(cfg sErrors.Config, prefix string, err error) error {
+	return deployerr.UserError(cfg, errors.Wrap(err, prefix), proto.StatusCode_DEPLOY_HELM_USER_ERR)
 }
 
 func noMatchingBuild(image string) error {

pkg/skaffold/deploy/kubectl/cli.go

@@ -24,6 +24,7 @@ import (
 	"strings"
 	"time"
 
+	sErrors "github.com/GoogleContainerTools/skaffold/pkg/skaffold/errors"
 	"github.com/sirupsen/logrus"
 
 	"github.com/GoogleContainerTools/skaffold/pkg/skaffold/config"
@@ -42,6 +43,7 @@ type CLI struct {
 	forceDeploy      bool
 	waitForDeletions config.WaitForDeletions
 	previousApply    manifest.ManifestList
+	cfg              sErrors.Config
 }
 
 type Config interface {
@@ -58,6 +60,7 @@ func NewCLI(cfg Config, flags latest.KubectlFlags, defaultNameSpace string) CLI
 		Flags:            flags,
 		forceDeploy:      cfg.ForceDeploy(),
 		waitForDeletions: cfg.WaitForDeletions(),
+		cfg:              cfg,
 	}
 }
 
@@ -92,7 +95,7 @@ func (c *CLI) Apply(ctx context.Context, out io.Writer, manifests manifest.Manif
 	}
 
 	if err := c.Run(ctx, updated.Reader(), out, "apply", c.args(c.Flags.Apply, args...)...); err != nil {
-		return userErr(fmt.Errorf("kubectl apply: %w", err))
+		return userErr(c.cfg, fmt.Errorf("kubectl apply: %w", err))
 	}
 
 	return nil

pkg/skaffold/deploy/kubectl/errors.go

@@ -89,6 +89,6 @@ func listManifestErr(err error) error {
 		})
 }
 
-func userErr(err error) error {
-	return deployerr.UserError(err, proto.StatusCode_DEPLOY_KUBECTL_USER_ERR)
+func userErr(cfg sErrors.Config, err error) error {
+	return deployerr.UserError(cfg, err, proto.StatusCode_DEPLOY_KUBECTL_USER_ERR)
 }