refactor: improve context handling

Author: FabianKramm

cmd/cleanup/images.go

@@ -41,6 +41,7 @@ Deletes all locally created docker images from docker
 // RunCleanupImages executes the cleanup images command logic
 func (cmd *imagesCmd) RunCleanupImages(f factory.Factory, cobraCmd *cobra.Command, args []string) error {
 	// Set config root
+	ctx := context.Background()
 	log := f.GetLog()
 	configLoader, err := f.NewConfigLoader(cmd.ConfigPath)
 	if err != nil {
@@ -65,13 +66,13 @@ func (cmd *imagesCmd) RunCleanupImages(f factory.Factory, cobraCmd *cobra.Comman
 	}
 
 	// Create docker client
-	client, err := docker.NewClientWithMinikube(kubeContext, true, log)
+	client, err := docker.NewClientWithMinikube(ctx, kubeContext, true, log)
 	if err != nil {
 		return err
 	}
 
 	// Load config
-	configInterface, err := configLoader.Load(context.Background(), nil, cmd.ToConfigOptions(), log)
+	configInterface, err := configLoader.Load(ctx, nil, cmd.ToConfigOptions(), log)
 	if err != nil {
 		return err
 	}
@@ -82,7 +83,7 @@ func (cmd *imagesCmd) RunCleanupImages(f factory.Factory, cobraCmd *cobra.Comman
 		return nil
 	}
 
-	_, err = client.Ping(context.Background())
+	_, err = client.Ping(ctx)
 	if err != nil {
 		return errors.Errorf("Docker seems to be not running: %v", err)
 	}
@@ -91,7 +92,7 @@ func (cmd *imagesCmd) RunCleanupImages(f factory.Factory, cobraCmd *cobra.Comman
 	for _, imageConfig := range config.Images {
 		log.Info("Deleting local image " + imageConfig.Image + "...")
 
-		response, err := client.DeleteImageByName(imageConfig.Image, log)
+		response, err := client.DeleteImageByName(ctx, imageConfig.Image, log)
 		if err != nil {
 			return err
 		}
@@ -109,7 +110,7 @@ func (cmd *imagesCmd) RunCleanupImages(f factory.Factory, cobraCmd *cobra.Comman
 
 	// Cleanup dangling images aswell
 	for {
-		response, err := client.DeleteImageByFilter(filters.NewArgs(filters.Arg("dangling", "true")), log)
+		response, err := client.DeleteImageByFilter(ctx, filters.NewArgs(filters.Arg("dangling", "true")), log)
 		if err != nil {
 			return err
 		}

cmd/init.go

@@ -373,7 +373,7 @@ func (cmd *InitCmd) Run(f factory.Factory) error {
 			}
 		}
 
-		err = configureManager.AddImage(imageName, image, projectNamespace+"/"+projectName, cmd.Dockerfile, languageHandler)
+		err = configureManager.AddImage(imageName, image, projectNamespace+"/"+projectName, cmd.Dockerfile)
 		if err != nil {
 			if err.Error() != "" {
 				cmd.log.Errorf("Error: %s", err.Error())

pkg/devspace/build/builder/buildkit/buildkit.go

@@ -67,7 +67,7 @@ func (b *Builder) ShouldRebuild(ctx *devspacecontext.Context, forceRebuild bool)
 	// Check if image is present in local repository
 	if !rebuild && err == nil && b.helper.ImageConf.BuildKit.InCluster == nil {
 		if b.skipPushOnLocalKubernetes && ctx.KubeClient != nil && kubectl.IsLocalKubernetes(ctx.KubeClient.CurrentContext()) {
-			dockerClient, err := dockerpkg.NewClientWithMinikube(ctx.KubeClient.CurrentContext(), b.helper.ImageConf.BuildKit.PreferMinikube == nil || *b.helper.ImageConf.BuildKit.PreferMinikube, ctx.Log)
+			dockerClient, err := dockerpkg.NewClientWithMinikube(ctx.Context, ctx.KubeClient.CurrentContext(), b.helper.ImageConf.BuildKit.PreferMinikube == nil || *b.helper.ImageConf.BuildKit.PreferMinikube, ctx.Log)
 			if err != nil {
 				return false, err
 			}
@@ -201,7 +201,7 @@ func buildWithCLI(ctx context.Context, dir string, context io.Reader, writer io.
 		err         error
 	)
 	if useMinikubeDocker {
-		minikubeEnv, err = dockerpkg.GetMinikubeEnvironment()
+		minikubeEnv, err = dockerpkg.GetMinikubeEnvironment(ctx)
 		if err != nil {
 			return fmt.Errorf("error retrieving minikube environment with 'minikube docker-env --shell none'. Try setting the option preferMinikube to false: %v", err)
 		}

pkg/devspace/build/builder/docker/docker.go

@@ -112,7 +112,7 @@ func (b *Builder) BuildImage(ctx *devspacecontext.Context, contextPath, dockerfi
 	// Authenticate
 	if !b.skipPush && !b.helper.ImageConf.SkipPush {
 		ctx.Log.Info("Authenticating (" + displayRegistryURL + ")...")
-		_, err = b.Authenticate()
+		_, err = b.Authenticate(ctx.Context)
 		if err != nil {
 			return errors.Errorf("Error during image registry authentication: %v", err)
 		}
@@ -173,7 +173,7 @@ func (b *Builder) BuildImage(ctx *devspacecontext.Context, contextPath, dockerfi
 	// Check if we skip push
 	if !b.skipPush && !b.helper.ImageConf.SkipPush {
 		for _, tag := range buildOptions.Tags {
-			err = b.pushImage(writer, tag)
+			err = b.pushImage(ctx.Context, writer, tag)
 			if err != nil {
 				return errors.Errorf("error during image push: %v", err)
 			}
@@ -188,13 +188,13 @@ func (b *Builder) BuildImage(ctx *devspacecontext.Context, contextPath, dockerfi
 }
 
 // Authenticate authenticates the client with a remote registry
-func (b *Builder) Authenticate() (*types.AuthConfig, error) {
+func (b *Builder) Authenticate(ctx context.Context) (*types.AuthConfig, error) {
 	registryURL, err := pullsecrets.GetRegistryFromImageName(b.helper.ImageName + ":" + b.helper.ImageTags[0])
 	if err != nil {
 		return nil, err
 	}
 
-	b.authConfig, err = b.client.Login(registryURL, "", "", true, false, false)
+	b.authConfig, err = b.client.Login(ctx, registryURL, "", "", true, false, false)
 	if err != nil {
 		return nil, err
 	}
@@ -203,7 +203,7 @@ func (b *Builder) Authenticate() (*types.AuthConfig, error) {
 }
 
 // pushImage pushes an image to the specified registry
-func (b *Builder) pushImage(writer io.Writer, imageName string) error {
+func (b *Builder) pushImage(ctx context.Context, writer io.Writer, imageName string) error {
 	ref, err := reference.ParseNormalizedNamed(imageName)
 	if err != nil {
 		return err
@@ -214,7 +214,7 @@ func (b *Builder) pushImage(writer io.Writer, imageName string) error {
 		return err
 	}
 
-	out, err := b.client.ImagePush(context.Background(), reference.FamiliarString(ref), types.ImagePushOptions{
+	out, err := b.client.ImagePush(ctx, reference.FamiliarString(ref), types.ImagePushOptions{
 		RegistryAuth: encodedAuth,
 	})
 	if err != nil {

pkg/devspace/build/builder/helper/helper.go

@@ -1,7 +1,6 @@
 package helper
 
 import (
-	"context"
 	"github.com/docker/cli/cli/command/image/build"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/pkg/archive"
@@ -206,7 +205,7 @@ func (b *BuildHelper) IsImageAvailableLocally(ctx *devspacecontext.Context, dock
 	imageCache, _ := ctx.Config.LocalCache().GetImageCache(b.ImageConfigName)
 	imageName := imageCache.ImageName + ":" + imageCache.Tag
 	dockerAPIClient := dockerClient.DockerAPIClient()
-	imageList, err := dockerAPIClient.ImageList(context.Background(), types.ImageListOptions{})
+	imageList, err := dockerAPIClient.ImageList(ctx.Context, types.ImageListOptions{})
 	if err != nil {
 		return false, err
 	}

pkg/devspace/build/create_builder.go

@@ -1,7 +1,6 @@
 package build
 
 import (
-	"context"
 	"github.com/loft-sh/devspace/pkg/devspace/build/builder"
 	"github.com/loft-sh/devspace/pkg/devspace/build/builder/buildkit"
 	"github.com/loft-sh/devspace/pkg/devspace/build/builder/custom"
@@ -59,13 +58,13 @@ func (c *controller) createBuilder(ctx *devspacecontext.Context, imageConfigName
 			kubeContext = ctx.KubeClient.CurrentContext()
 		}
 
-		dockerClient, err := dockerclient.NewClientWithMinikube(kubeContext, preferMinikube, ctx.Log)
+		dockerClient, err := dockerclient.NewClientWithMinikube(ctx.Context, kubeContext, preferMinikube, ctx.Log)
 		if err != nil {
 			return nil, errors.Errorf("Error creating docker client: %v", err)
 		}
 
 		// Check if docker daemon is running
-		_, err = dockerClient.Ping(context.Background())
+		_, err = dockerClient.Ping(ctx.Context)
 		if err != nil {
 			if imageConf.Docker != nil && imageConf.Docker.DisableFallback != nil && *imageConf.Docker.DisableFallback {
 				return nil, errors.Errorf("Couldn't reach docker daemon: %v. Is the docker daemon running?", err)
@@ -89,7 +88,7 @@ func (c *controller) createBuilder(ctx *devspacecontext.Context, imageConfigName
 			return nil, err
 		}
 
-		dockerClient, err := dockerclient.NewClient(ctx.Log)
+		dockerClient, err := dockerclient.NewClient(ctx.Context, ctx.Log)
 		if err == nil {
 			if imageConf.Kaniko != nil && imageConf.Kaniko.Namespace != "" && ctx.KubeClient.Namespace() != imageConf.Kaniko.Namespace {
 				err = pullsecrets.NewClient().EnsurePullSecret(ctx, dockerClient, imageConf.Kaniko.Namespace, registryURL)

pkg/devspace/config/loader/loader.go

@@ -172,7 +172,7 @@ func (l *configLoader) LoadWithParser(ctx context.Context, localCache localcache
 		return nil, err
 	}
 
-	err = l.ensureRequires(parsedConfig, log)
+	err = l.ensureRequires(ctx, parsedConfig, log)
 	if err != nil {
 		return nil, errors.Wrap(err, "require versions")
 	}
@@ -191,7 +191,7 @@ func (l *configLoader) LoadWithParser(ctx context.Context, localCache localcache
 	return c, nil
 }
 
-func (l *configLoader) ensureRequires(config *latest.Config, log log.Logger) error {
+func (l *configLoader) ensureRequires(ctx context.Context, config *latest.Config, log log.Logger) error {
 	if config == nil {
 		return nil
 	}
@@ -259,7 +259,7 @@ func (l *configLoader) ensureRequires(config *latest.Config, log log.Logger) err
 			return errors.Wrapf(err, "parsing require.commands[%d].version", index)
 		}
 
-		out, err := command.Output(context.TODO(), filepath.Dir(l.absConfigPath), c.Name, versionArgs...)
+		out, err := command.Output(ctx, filepath.Dir(l.absConfigPath), c.Name, versionArgs...)
 		if err != nil {
 			return fmt.Errorf("cannot run command '%s' (%v), however it is required by the config. Please make sure you have correctly installed '%s' with version %s", c.Name, err, c.Name, c.Version)
 		}

pkg/devspace/config/versions/latest/schema.go

@@ -1328,7 +1328,7 @@ type CommandConfig struct {
 	// the command was interrupted which will set the env variable COMMAND_INTERRUPT
 	// to true as well as when the command errored which will set the error string to
 	// COMMAND_ERROR.
-	After string `yaml:"after" json:"after"`
+	After string `yaml:"after,omitempty" json:"after,omitempty"`
 
 	// DisableReplace signals DevSpace to not replace the default command. E.g.
 	// dev does not replace devspace dev.

pkg/devspace/config/versions/versions.go

@@ -60,7 +60,7 @@ func ParseProfile(ctx context.Context, basePath string, data map[string]interfac
 	activatedProfiles := []string{}
 	if !disableProfileActivation {
 		var err error
-		activatedProfiles, err = getActivatedProfiles(data, resolver, log)
+		activatedProfiles, err = getActivatedProfiles(ctx, data, resolver, log)
 		if err != nil {
 			return nil, err
 		}
@@ -305,7 +305,7 @@ func getProfiles(ctx context.Context, basePath string, data map[string]interface
 	return errors.Errorf("Couldn't find profile '%s'", profile)
 }
 
-func getActivatedProfiles(data map[string]interface{}, resolver variable.Resolver, log log.Logger) ([]string, error) {
+func getActivatedProfiles(ctx context.Context, data map[string]interface{}, resolver variable.Resolver, log log.Logger) ([]string, error) {
 	activatedProfiles := []string{}
 
 	// Check if there are profiles
@@ -331,7 +331,7 @@ func getActivatedProfiles(data map[string]interface{}, resolver variable.Resolve
 				return activatedProfiles, errors.Wrap(err, "error activating profile with env")
 			}
 
-			activatedByVars, err := matchVars(activation.Vars, resolver)
+			activatedByVars, err := matchVars(ctx, activation.Vars, resolver)
 			if err != nil {
 				return activatedProfiles, errors.Wrap(err, "error activating profile with vars")
 			}
@@ -360,9 +360,9 @@ func matchEnvironment(env map[string]string) (bool, error) {
 	return true, nil
 }
 
-func matchVars(activationVars map[string]string, resolver variable.Resolver) (bool, error) {
+func matchVars(ctx context.Context, activationVars map[string]string, resolver variable.Resolver) (bool, error) {
 	for k, v := range activationVars {
-		value, err := resolveVariableValue(k, resolver)
+		value, err := resolveVariableValue(ctx, k, resolver)
 		if err != nil {
 			return false, err
 		}
@@ -393,8 +393,8 @@ func sanitizeMatchExpression(expression string) string {
 	return exp
 }
 
-func resolveVariableValue(name string, resolver variable.Resolver) (string, error) {
-	val, err := resolver.FillVariables(context.TODO(), "${"+name+"}")
+func resolveVariableValue(ctx context.Context, name string, resolver variable.Resolver) (string, error) {
+	val, err := resolver.FillVariables(ctx, "${"+name+"}")
 	if err != nil {
 		return "", err
 	}

pkg/devspace/configure/image.go

@@ -24,7 +24,7 @@ import (
 const dockerHubHostname = "hub.docker.com"
 
 // AddImage adds an image to the provided config
-func (m *manager) AddImage(imageName, image, projectNamespace, dockerfile string, languageHandler *generator.LanguageHandler) error {
+func (m *manager) AddImage(imageName, image, projectNamespace, dockerfile string) error {
 	var (
 		useDockerHub          = "Use " + dockerHubHostname
 		useGithubRegistry     = "Use GitHub image registry"
@@ -113,22 +113,22 @@ func (m *manager) AddImage(imageName, image, projectNamespace, dockerfile string
 		}
 
 		// Get docker client
-		dockerClient, err := m.factory.NewDockerClientWithMinikube(kubeContext, true, m.log)
+		dockerClient, err := m.factory.NewDockerClientWithMinikube(context.TODO(), kubeContext, true, m.log)
 		if err != nil {
 			return errors.Errorf("Cannot create docker client: %v", err)
 		}
 
 		// Check if user is logged into docker hub
 		isLoggedIntoDockerHub := false
-		authConfig, err := dockerClient.GetAuthConfig(dockerHubHostname, true)
+		authConfig, err := dockerClient.GetAuthConfig(context.TODO(), dockerHubHostname, true)
 		if err == nil && authConfig.Username != "" {
 			useDockerHub = useDockerHub + fmt.Sprintf(registryUsernameHint, authConfig.Username)
 			isLoggedIntoDockerHub = true
 		}
 
 		// Check if user is logged into GitHub
 		isLoggedIntoGitHub := false
-		authConfig, err = dockerClient.GetAuthConfig(generator.GithubContainerRegistry, true)
+		authConfig, err = dockerClient.GetAuthConfig(context.TODO(), generator.GithubContainerRegistry, true)
 		if err == nil && authConfig.Username != "" {
 			useGithubRegistry = useGithubRegistry + fmt.Sprintf(registryUsernameHint, authConfig.Username)
 			isLoggedIntoGitHub = true
@@ -236,7 +236,7 @@ func (m *manager) addPullSecretConfig(dockerClient docker.Client, image string)
 
 	for {
 		m.log.Info("Checking registry authentication for " + registryHostnamePrintable + "...")
-		authConfig, err := dockerClient.Login(registryHostname, registryUsername, registryPassword, true, false, false)
+		authConfig, err := dockerClient.Login(context.TODO(), registryHostname, registryUsername, registryPassword, true, false, false)
 		if err == nil && (authConfig.Username != "" || authConfig.Password != "") {
 			registryUsername = authConfig.Username