fix: improve detection of minikube clusters

lizardruss · lizardruss · commit 24acd5244af7 · 2023-02-09T15:32:12.000-05:00
Signed-off-by: Russell Centanni &lt;russell.centanni@gmail.com&gt;
diff --git a/cmd/cleanup/images.go b/cmd/cleanup/images.go
@@ -2,9 +2,9 @@ package cleanup
 
 import (
 	"context"
+	"github.com/loft-sh/devspace/pkg/devspace/docker"
 
 	"github.com/loft-sh/devspace/cmd/flags"
-	"github.com/loft-sh/devspace/pkg/devspace/docker"
 	"github.com/loft-sh/devspace/pkg/util/factory"
 	"github.com/loft-sh/devspace/pkg/util/message"
 
@@ -48,31 +48,23 @@ func (cmd *imagesCmd) RunCleanupImages(f factory.Factory, cobraCmd *cobra.Comman
 	if err != nil {
 		return err
 	}
-	kubeConfigLoader := f.NewKubeConfigLoader()
+
 	configExists, err := configLoader.SetDevSpaceRoot(log)
 	if err != nil {
 		return err
 	}
+
 	if !configExists {
 		return errors.New(message.ConfigNotFound)
 	}
 
-	// Get active context
-	kubeContext, err := kubeConfigLoader.GetCurrentContext()
-	if err != nil {
-		return err
-	}
-	if cmd.KubeContext != "" {
-		kubeContext = cmd.KubeContext
-	}
-
-	kubeClient, err := f.NewKubeDefaultClient()
+	kubeClient, err := f.NewKubeClientFromContext(cmd.KubeContext, cmd.Namespace)
 	if err != nil {
 		return errors.Wrap(err, "new kube client")
 	}
 
 	// Create docker client
-	client, err := docker.NewClientWithMinikube(ctx, kubeContext, true, log)
+	client, err := docker.NewClientWithMinikube(ctx, kubeClient, true, log)
 	if err != nil {
 		return err
 	}
diff --git a/pkg/devspace/build/builder/buildkit/buildkit.go b/pkg/devspace/build/builder/buildkit/buildkit.go
@@ -71,8 +71,8 @@ func (b *Builder) ShouldRebuild(ctx devspacecontext.Context, forceRebuild bool)
 
 	// Check if image is present in local docker daemon
 	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.Context(), ctx.KubeClient().CurrentContext(), b.helper.ImageConf.BuildKit.PreferMinikube == nil || *b.helper.ImageConf.BuildKit.PreferMinikube, ctx.Log())
+		if b.skipPushOnLocalKubernetes && ctx.KubeClient() != nil && kubectl.IsLocalKubernetes(ctx.KubeClient()) {
+			dockerClient, err := dockerpkg.NewClientWithMinikube(ctx.Context(), ctx.KubeClient(), b.helper.ImageConf.BuildKit.PreferMinikube == nil || *b.helper.ImageConf.BuildKit.PreferMinikube, ctx.Log())
 			if err != nil {
 				return false, err
 			}
@@ -108,14 +108,14 @@ func (b *Builder) BuildImage(ctx devspacecontext.Context, contextPath, dockerfil
 	}
 
 	// We skip pushing when it is the minikube client
-	usingLocalKubernetes := ctx.KubeClient() != nil && kubectl.IsLocalKubernetes(ctx.KubeClient().CurrentContext())
+	usingLocalKubernetes := ctx.KubeClient() != nil && kubectl.IsLocalKubernetes(ctx.KubeClient())
 	if b.skipPushOnLocalKubernetes && usingLocalKubernetes {
 		b.skipPush = true
 	}
 
 	// Should we use the minikube docker daemon?
 	useMinikubeDocker := false
-	if ctx.KubeClient() != nil && kubectl.IsMinikubeKubernetes(ctx.KubeClient().CurrentContext()) && (buildKitConfig.PreferMinikube == nil || *buildKitConfig.PreferMinikube) {
+	if ctx.KubeClient() != nil && kubectl.IsMinikubeKubernetes(ctx.KubeClient()) && (buildKitConfig.PreferMinikube == nil || *buildKitConfig.PreferMinikube) {
 		useMinikubeDocker = true
 	}
 
@@ -191,7 +191,7 @@ func buildWithCLI(ctx context.Context, dir string, environ expand.Environ, conte
 		err         error
 	)
 	if useMinikubeDocker {
-		minikubeEnv, err = dockerpkg.GetMinikubeEnvironment(ctx)
+		minikubeEnv, err = dockerpkg.GetMinikubeEnvironment(ctx, kubeClient.CurrentContext())
 		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)
 		}
diff --git a/pkg/devspace/build/builder/docker/docker.go b/pkg/devspace/build/builder/docker/docker.go
@@ -58,7 +58,7 @@ func (b *Builder) ShouldRebuild(ctx devspacecontext.Context, forceRebuild bool)
 
 	// Check if image is present in local docker daemon
 	if !rebuild && err == nil {
-		if b.skipPushOnLocalKubernetes && ctx.KubeClient() != nil && kubectl.IsLocalKubernetes(ctx.KubeClient().CurrentContext()) {
+		if b.skipPushOnLocalKubernetes && ctx.KubeClient() != nil && kubectl.IsLocalKubernetes(ctx.KubeClient()) {
 			found, err := b.helper.IsImageAvailableLocally(ctx, b.client)
 			if !found && err == nil {
 				ctx.Log().Infof("Rebuild image %s because it was not found in local docker daemon", imageName)
@@ -88,7 +88,7 @@ func (b *Builder) BuildImage(ctx devspacecontext.Context, contextPath, dockerfil
 	}
 
 	// We skip pushing when it is the minikube client
-	if b.skipPushOnLocalKubernetes && ctx.KubeClient() != nil && kubectl.IsLocalKubernetes(ctx.KubeClient().CurrentContext()) {
+	if b.skipPushOnLocalKubernetes && ctx.KubeClient() != nil && kubectl.IsLocalKubernetes(ctx.KubeClient()) {
 		b.skipPush = true
 	}
 
diff --git a/pkg/devspace/build/builder/helper/helper.go b/pkg/devspace/build/builder/helper/helper.go
@@ -6,6 +6,7 @@ import (
 	"github.com/docker/docker/pkg/progress"
 	"github.com/docker/docker/pkg/streamformatter"
 	"github.com/loft-sh/devspace/pkg/devspace/build/builder/restart"
+	"github.com/loft-sh/devspace/pkg/util/kubeconfig"
 	logpkg "github.com/loft-sh/devspace/pkg/util/log"
 	dockerterm "github.com/moby/term"
 	"github.com/sirupsen/logrus"
@@ -156,9 +157,26 @@ func (b *BuildHelper) ShouldRebuild(ctx devspacecontext.Context, forceRebuild bo
 		ctx.Log().Infof("Rebuild image %s because entrypoint has changed", imageCache.ImageName)
 	}
 
+	var lastContextClient kubectl.Client
+	if ctx.Config().LocalCache().GetLastContext() != nil {
+		lastContextClient, err = kubectl.NewClientFromContext(
+			ctx.Config().LocalCache().GetLastContext().Context,
+			ctx.Config().LocalCache().GetLastContext().Namespace,
+			false,
+			kubeconfig.NewLoader(),
+		)
+		if err != nil {
+			return false, err
+		}
+	}
+
 	// Okay this check verifies if the previous deploy context was local kubernetes context where we didn't push the image and now have a kubernetes context where we probably push
 	// or use another docker client (e.g. minikube <-> docker-desktop)
-	if !mustRebuild && ctx.KubeClient() != nil && ctx.Config().LocalCache().GetLastContext() != nil && ctx.Config().LocalCache().GetLastContext().Context != ctx.KubeClient().CurrentContext() && kubectl.IsLocalKubernetes(ctx.Config().LocalCache().GetLastContext().Context) {
+	if !mustRebuild &&
+		ctx.KubeClient() != nil &&
+		ctx.Config().LocalCache().GetLastContext() != nil &&
+		ctx.Config().LocalCache().GetLastContext().Context != ctx.KubeClient().CurrentContext() &&
+		kubectl.IsLocalKubernetes(lastContextClient) {
 		mustRebuild = true
 		ctx.Log().Infof("Rebuild image %s because previous build was local kubernetes", imageCache.ImageName)
 		ctx.Config().LocalCache().SetLastContext(&localcache.LastContextConfig{
diff --git a/pkg/devspace/build/create_builder.go b/pkg/devspace/build/create_builder.go
@@ -13,7 +13,6 @@ import (
 	devspacecontext "github.com/loft-sh/devspace/pkg/devspace/context"
 	dockerclient "github.com/loft-sh/devspace/pkg/devspace/docker"
 	"github.com/loft-sh/devspace/pkg/devspace/kubectl"
-	"github.com/loft-sh/devspace/pkg/util/kubeconfig"
 	"github.com/pkg/errors"
 )
 
@@ -61,17 +60,7 @@ func (c *controller) createBuilder(ctx devspacecontext.Context, imageConf *lates
 			preferMinikube = *imageConf.Docker.PreferMinikube
 		}
 
-		kubeContext := ""
-		if ctx.KubeClient() == nil {
-			kubeContext, err = kubeconfig.NewLoader().GetCurrentContext()
-			if err != nil {
-				return nil, errors.Wrap(err, "get current context")
-			}
-		} else {
-			kubeContext = ctx.KubeClient().CurrentContext()
-		}
-
-		dockerClient, err := dockerclient.NewClientWithMinikube(ctx.Context(), kubeContext, preferMinikube, ctx.Log())
+		dockerClient, err := dockerclient.NewClientWithMinikube(ctx.Context(), ctx.KubeClient(), preferMinikube, ctx.Log())
 		if err != nil {
 			return nil, errors.Errorf("Error creating docker client: %v", err)
 		}
diff --git a/pkg/devspace/build/localregistry/util.go b/pkg/devspace/build/localregistry/util.go
@@ -82,7 +82,7 @@ func UseLocalRegistry(client kubectl.Client, config *latest.Config, imageConfig
 	isVClusterContext := strings.Contains(context, "vcluster_")
 
 	// Determine if this is a local kubernetes cluster
-	isLocalKubernetes := kubectl.IsLocalKubernetes(context)
+	isLocalKubernetes := kubectl.IsLocalKubernetes(client)
 	return !isLocalKubernetes && !(isVClusterContext && isLocalKubernetes)
 }
 
diff --git a/pkg/devspace/configure/image.go b/pkg/devspace/configure/image.go
@@ -3,6 +3,7 @@ package configure
 import (
 	"context"
 	"fmt"
+	"github.com/loft-sh/devspace/pkg/devspace/kubectl"
 	"github.com/loft-sh/devspace/pkg/util/dockerfile"
 	"mvdan.cc/sh/v3/expand"
 	"os"
@@ -115,14 +116,13 @@ func (m *manager) AddImage(imageName, image, projectNamespace, dockerfile string
 	}
 
 	if image == "" && buildMethod != skip {
-		// Ignore error as context may not be a Space
-		kubeContext, err := m.factory.NewKubeConfigLoader().GetCurrentContext()
+		kubeClient, err := kubectl.NewDefaultClient()
 		if err != nil {
 			return err
 		}
 
 		// Get docker client
-		dockerClient, err := m.factory.NewDockerClientWithMinikube(context.TODO(), kubeContext, true, m.log)
+		dockerClient, err := m.factory.NewDockerClientWithMinikube(context.TODO(), kubeClient, true, m.log)
 		if err != nil {
 			return errors.Errorf("Cannot create docker client: %v", err)
 		}
diff --git a/pkg/devspace/configure/manager.go b/pkg/devspace/configure/manager.go
@@ -2,6 +2,7 @@ package configure
 
 import (
 	"context"
+	"github.com/loft-sh/devspace/pkg/devspace/kubectl"
 
 	"github.com/loft-sh/devspace/pkg/devspace/config/localcache"
 	"github.com/loft-sh/devspace/pkg/devspace/config/versions/latest"
@@ -21,7 +22,7 @@ type Manager interface {
 
 // Factory defines the factory methods needed by the configure manager to create new configuration
 type Factory interface {
-	NewDockerClientWithMinikube(ctx context.Context, currentKubeContext string, preferMinikube bool, log log.Logger) (docker.Client, error)
+	NewDockerClientWithMinikube(ctx context.Context, client kubectl.Client, preferMinikube bool, log log.Logger) (docker.Client, error)
 	NewKubeConfigLoader() kubeconfig.Loader
 }
 
diff --git a/pkg/devspace/docker/client.go b/pkg/devspace/docker/client.go
@@ -53,16 +53,16 @@ type client struct {
 
 // NewClient retrieves a new docker client
 func NewClient(ctx context.Context, log log.Logger) (Client, error) {
-	return NewClientWithMinikube(ctx, "", false, log)
+	return NewClientWithMinikube(ctx, nil, false, log)
 }
 
 // NewClientWithMinikube creates a new docker client with optionally from the minikube vm
-func NewClientWithMinikube(ctx context.Context, currentKubeContext string, preferMinikube bool, log log.Logger) (Client, error) {
+func NewClientWithMinikube(ctx context.Context, kubectlClient kubectl.Client, preferMinikube bool, log log.Logger) (Client, error) {
 	var cli Client
 	var err error
 
 	if preferMinikube {
-		cli, err = newDockerClientFromMinikube(ctx, currentKubeContext)
+		cli, err = newDockerClientFromMinikube(ctx, kubectlClient)
 		if err != nil && err != errNotMinikube {
 			log.Warnf("Error creating minikube docker client: %v", err)
 		}
@@ -108,12 +108,12 @@ func newDockerClientFromEnvironment() (Client, error) {
 	}, nil
 }
 
-func newDockerClientFromMinikube(ctx context.Context, currentKubeContext string) (Client, error) {
-	if !kubectl.IsMinikubeKubernetes(currentKubeContext) {
+func newDockerClientFromMinikube(ctx context.Context, kubectlClient kubectl.Client) (Client, error) {
+	if !kubectl.IsMinikubeKubernetes(kubectlClient) {
 		return nil, errNotMinikube
 	}
 
-	env, err := GetMinikubeEnvironment(ctx)
+	env, err := GetMinikubeEnvironment(ctx, kubectlClient.CurrentContext())
 	if err != nil {
 		return nil, errors.Errorf("can't retrieve minikube docker environment due to error: %v", err)
 	}
@@ -155,8 +155,8 @@ func newDockerClientFromMinikube(ctx context.Context, currentKubeContext string)
 	}, nil
 }
 
-func GetMinikubeEnvironment(ctx context.Context) (map[string]string, error) {
-	out, err := command.Output(ctx, "", expand.ListEnviron(os.Environ()...), "minikube", "docker-env", "--shell", "none")
+func GetMinikubeEnvironment(ctx context.Context, kubeContext string) (map[string]string, error) {
+	out, err := command.Output(ctx, "", expand.ListEnviron(os.Environ()...), "minikube", "docker-env", "--shell", "none", "--profile", kubeContext)
 	if err != nil {
 		if ee, ok := err.(*exec.ExitError); ok {
 			out = ee.Stderr
diff --git a/pkg/devspace/kubectl/util.go b/pkg/devspace/kubectl/util.go
@@ -3,6 +3,7 @@ package kubectl
 import (
 	"context"
 	"fmt"
+	"k8s.io/apimachinery/pkg/runtime"
 	"net"
 	"net/http"
 	"strings"
@@ -19,6 +20,7 @@ import (
 
 const (
 	minikubeContext         = "minikube"
+	minikubeProvider        = "minikube.sigs.k8s.io"
 	dockerDesktopContext    = "docker-desktop"
 	dockerForDesktopContext = "docker-for-desktop"
 )
@@ -203,15 +205,22 @@ func NewPortForwarder(client Client, pod *corev1.Pod, ports []string, addresses
 }
 
 // IsLocalKubernetes returns true if the context belongs to a local Kubernetes cluster
-func IsLocalKubernetes(context string) bool {
-	if context == minikubeContext ||
-		strings.HasPrefix(context, "kind-") ||
+func IsLocalKubernetes(kubeClient Client) bool {
+	if kubeClient == nil {
+		return false
+	}
+
+	if IsMinikubeKubernetes(kubeClient) {
+		return true
+	}
+
+	context := kubeClient.CurrentContext()
+	if strings.HasPrefix(context, "kind-") ||
 		context == dockerDesktopContext ||
 		context == dockerForDesktopContext {
 		return true
 	} else if strings.Contains(context, "vcluster_") &&
-		(strings.HasSuffix(context, minikubeContext) ||
-			strings.HasSuffix(context, dockerDesktopContext) ||
+		(strings.HasSuffix(context, dockerDesktopContext) ||
 			strings.HasSuffix(context, dockerForDesktopContext) ||
 			strings.Contains(context, "kind-")) {
 		return true
@@ -220,15 +229,37 @@ func IsLocalKubernetes(context string) bool {
 	return false
 }
 
-func IsMinikubeKubernetes(context string) bool {
-	if context == minikubeContext {
+func IsMinikubeKubernetes(kubeClient Client) bool {
+	if kubeClient == nil {
+		return false
+	}
+
+	if kubeClient.CurrentContext() == minikubeContext {
 		return true
 	}
 
-	if strings.HasPrefix(context, "vcluster_") && strings.HasSuffix(context, minikubeContext) {
+	if strings.Contains(kubeClient.CurrentContext(), "vcluster_") && strings.HasSuffix(kubeClient.CurrentContext(), minikubeContext) {
 		return true
 	}
 
+	if kubeClient.ClientConfig() == nil {
+		return false
+	}
+
+	if rawConfig, err := kubeClient.ClientConfig().RawConfig(); err == nil {
+		clusters := rawConfig.Clusters[rawConfig.Contexts[rawConfig.CurrentContext].Cluster]
+		for _, extension := range clusters.Extensions {
+			ext, err := runtime.DefaultUnstructuredConverter.ToUnstructured(extension)
+			if err == nil {
+				if provider, ok := ext["provider"].(string); ok {
+					if provider == minikubeProvider {
+						return true
+					}
+				}
+			}
+		}
+	}
+
 	return false
 }
 
diff --git a/pkg/util/factory/factory.go b/pkg/util/factory/factory.go
@@ -40,7 +40,7 @@ type Factory interface {
 
 	// NewDockerClient creates a new docker API client
 	NewDockerClient(ctx context.Context, log log.Logger) (docker.Client, error)
-	NewDockerClientWithMinikube(ctx context.Context, currentKubeContext string, preferMinikube bool, log log.Logger) (docker.Client, error)
+	NewDockerClientWithMinikube(ctx context.Context, client kubectl.Client, preferMinikube bool, log log.Logger) (docker.Client, error)
 
 	// NewBuildController & NewDeployController
 	NewBuildController() build.Controller
@@ -118,8 +118,8 @@ func (f *DefaultFactoryImpl) NewDockerClient(ctx context.Context, log log.Logger
 }
 
 // NewDockerClientWithMinikube implements interface
-func (f *DefaultFactoryImpl) NewDockerClientWithMinikube(ctx context.Context, currentKubeContext string, preferMinikube bool, log log.Logger) (docker.Client, error) {
-	return docker.NewClientWithMinikube(ctx, currentKubeContext, preferMinikube, log)
+func (f *DefaultFactoryImpl) NewDockerClientWithMinikube(ctx context.Context, kubectlClient kubectl.Client, preferMinikube bool, log log.Logger) (docker.Client, error) {
+	return docker.NewClientWithMinikube(ctx, kubectlClient, preferMinikube, log)
 }
 
 // NewKubeDefaultClient implements interface
diff --git a/pkg/util/factory/testing/factory.go b/pkg/util/factory/testing/factory.go
@@ -98,7 +98,7 @@ func (f *Factory) NewDockerClient(ctx context.Context, log log.Logger) (docker.C
 }
 
 // NewDockerClientWithMinikube implements interface
-func (f *Factory) NewDockerClientWithMinikube(ctx context.Context, currentKubeContext string, preferMinikube bool, log log.Logger) (docker.Client, error) {
+func (f *Factory) NewDockerClientWithMinikube(ctx context.Context, kubeClient kubectl.Client, preferMinikube bool, log log.Logger) (docker.Client, error) {
 	return f.DockerClient, nil
 }
 

Original file line number	Diff line number	Diff line change
`@@ -71,8 +71,8 @@ func (b *Builder) ShouldRebuild(ctx devspacecontext.Context, forceRebuild bool)`
`71`	`71`
`72`	`72`	`// Check if image is present in local docker daemon`
`73`	`73`	`if !rebuild && err == nil && b.helper.ImageConf.BuildKit.InCluster == nil {`
`74`		`- if b.skipPushOnLocalKubernetes && ctx.KubeClient() != nil && kubectl.IsLocalKubernetes(ctx.KubeClient().CurrentContext()) {`
`75`		`- dockerClient, err := dockerpkg.NewClientWithMinikube(ctx.Context(), ctx.KubeClient().CurrentContext(), b.helper.ImageConf.BuildKit.PreferMinikube == nil \|\| *b.helper.ImageConf.BuildKit.PreferMinikube, ctx.Log())`
	`74`	`+ if b.skipPushOnLocalKubernetes && ctx.KubeClient() != nil && kubectl.IsLocalKubernetes(ctx.KubeClient()) {`
	`75`	`+ dockerClient, err := dockerpkg.NewClientWithMinikube(ctx.Context(), ctx.KubeClient(), b.helper.ImageConf.BuildKit.PreferMinikube == nil \|\| *b.helper.ImageConf.BuildKit.PreferMinikube, ctx.Log())`
`76`	`76`	`if err != nil {`
`77`	`77`	`return false, err`
`78`	`78`	`}`
`@@ -108,14 +108,14 @@ func (b *Builder) BuildImage(ctx devspacecontext.Context, contextPath, dockerfil`
`108`	`108`	`}`
`109`	`109`
`110`	`110`	`// We skip pushing when it is the minikube client`
`111`		`- usingLocalKubernetes := ctx.KubeClient() != nil && kubectl.IsLocalKubernetes(ctx.KubeClient().CurrentContext())`
	`111`	`+ usingLocalKubernetes := ctx.KubeClient() != nil && kubectl.IsLocalKubernetes(ctx.KubeClient())`
`112`	`112`	`if b.skipPushOnLocalKubernetes && usingLocalKubernetes {`
`113`	`113`	`b.skipPush = true`
`114`	`114`	`}`
`115`	`115`
`116`	`116`	`// Should we use the minikube docker daemon?`
`117`	`117`	`useMinikubeDocker := false`
`118`		`- if ctx.KubeClient() != nil && kubectl.IsMinikubeKubernetes(ctx.KubeClient().CurrentContext()) && (buildKitConfig.PreferMinikube == nil \|\| *buildKitConfig.PreferMinikube) {`
	`118`	`+ if ctx.KubeClient() != nil && kubectl.IsMinikubeKubernetes(ctx.KubeClient()) && (buildKitConfig.PreferMinikube == nil \|\| *buildKitConfig.PreferMinikube) {`
`119`	`119`	`useMinikubeDocker = true`
`120`	`120`	`}`
`121`	`121`
`@@ -191,7 +191,7 @@ func buildWithCLI(ctx context.Context, dir string, environ expand.Environ, conte`
`191`	`191`	`err error`
`192`	`192`	`)`
`193`	`193`	`if useMinikubeDocker {`
`194`		`- minikubeEnv, err = dockerpkg.GetMinikubeEnvironment(ctx)`
	`194`	`+ minikubeEnv, err = dockerpkg.GetMinikubeEnvironment(ctx, kubeClient.CurrentContext())`
`195`	`195`	`if err != nil {`
`196`	`196`	`return fmt.Errorf("error retrieving minikube environment with 'minikube docker-env --shell none'. Try setting the option preferMinikube to false: %v", err)`
`197`	`197`	`}`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ func (b *Builder) ShouldRebuild(ctx devspacecontext.Context, forceRebuild bool)`
`58`	`58`
`59`	`59`	`// Check if image is present in local docker daemon`
`60`	`60`	`if !rebuild && err == nil {`
`61`		`- if b.skipPushOnLocalKubernetes && ctx.KubeClient() != nil && kubectl.IsLocalKubernetes(ctx.KubeClient().CurrentContext()) {`
	`61`	`+ if b.skipPushOnLocalKubernetes && ctx.KubeClient() != nil && kubectl.IsLocalKubernetes(ctx.KubeClient()) {`
`62`	`62`	`found, err := b.helper.IsImageAvailableLocally(ctx, b.client)`
`63`	`63`	`if !found && err == nil {`
`64`	`64`	`ctx.Log().Infof("Rebuild image %s because it was not found in local docker daemon", imageName)`
`@@ -88,7 +88,7 @@ func (b *Builder) BuildImage(ctx devspacecontext.Context, contextPath, dockerfil`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`// We skip pushing when it is the minikube client`
`91`		`- if b.skipPushOnLocalKubernetes && ctx.KubeClient() != nil && kubectl.IsLocalKubernetes(ctx.KubeClient().CurrentContext()) {`
	`91`	`+ if b.skipPushOnLocalKubernetes && ctx.KubeClient() != nil && kubectl.IsLocalKubernetes(ctx.KubeClient()) {`
`92`	`92`	`b.skipPush = true`
`93`	`93`	`}`
`94`	`94`
Original file line number	Diff line number	Diff line change
`@@ -82,7 +82,7 @@ func UseLocalRegistry(client kubectl.Client, config *latest.Config, imageConfig`
`82`	`82`	`isVClusterContext := strings.Contains(context, "vcluster_")`
`83`	`83`
`84`	`84`	`// Determine if this is a local kubernetes cluster`
`85`		`- isLocalKubernetes := kubectl.IsLocalKubernetes(context)`
	`85`	`+ isLocalKubernetes := kubectl.IsLocalKubernetes(client)`
`86`	`86`	`return !isLocalKubernetes && !(isVClusterContext && isLocalKubernetes)`
`87`	`87`	`}`
`88`	`88`