Merge pull request #2614 from 89luca89/main

fix: ensure namespaces during dependencies resolution

Author: FabianKramm

e2e/framework/helper.go

@@ -62,6 +62,21 @@ func ExpectEmpty(actual interface{}, explain ...interface{}) {
 	gomega.ExpectWithOffset(1, actual).To(gomega.BeEmpty(), explain...)
 }
 
+func ExpectNamespace(namespace string) {
+	kubeClient, err := kube.NewKubeHelper()
+	ExpectNoErrorWithOffset(1, err)
+
+	err = wait.PollImmediate(time.Second, time.Minute*2, func() (done bool, err error) {
+		ns, err := kubeClient.Client().KubeClient().CoreV1().Namespaces().Get(context.TODO(), namespace, metav1.GetOptions{})
+		if err != nil {
+			return false, nil
+		}
+
+		return ns.Name == namespace, nil
+	})
+	ExpectNoErrorWithOffset(1, err)
+}
+
 func ExpectRemoteFileContents(imageSelector string, namespace string, filePath string, contents string) {
 	kubeClient, err := kube.NewKubeHelper()
 	ExpectNoErrorWithOffset(1, err)

e2e/tests/dependencies/dependencies.go

@@ -3,13 +3,14 @@ package dependencies
 import (
 	"bytes"
 	"context"
-	ginkgo "github.com/onsi/ginkgo/v2"
-	"github.com/onsi/gomega"
-	"github.com/sirupsen/logrus"
 	"os"
 	"path/filepath"
 	"time"
 
+	ginkgo "github.com/onsi/ginkgo/v2"
+	"github.com/onsi/gomega"
+	"github.com/sirupsen/logrus"
+
 	"github.com/loft-sh/devspace/pkg/devspace/config/versions/latest"
 	dependencyutil "github.com/loft-sh/devspace/pkg/devspace/dependency/util"
 	"github.com/loft-sh/devspace/pkg/devspace/kubectl/selector"
@@ -208,6 +209,47 @@ dep2dep2wait
 		framework.ExpectEqual(len(list.Items), 0)
 	})
 
+	ginkgo.It("should deploy dependency in custom namespace", func() {
+		tempDir, err := framework.CopyToTempDir("tests/dependencies/testdata/namespace")
+		framework.ExpectNoError(err)
+		defer framework.CleanupTempDir(initialDir, tempDir)
+
+		depNamespace := "custon"
+
+		ns, err := kubeClient.CreateNamespace("dependencies")
+		framework.ExpectNoError(err)
+		defer func() {
+			err := kubeClient.DeleteNamespace(ns)
+			framework.ExpectNoError(err)
+			err = kubeClient.DeleteNamespace(depNamespace)
+			framework.ExpectNoError(err)
+		}()
+
+		// create a new dev command and start it
+		cancelCtx, cancel := context.WithCancel(context.Background())
+		defer cancel()
+
+		os.Setenv("DEP1_NAMESPACE", depNamespace)
+		defer os.Unsetenv("DEP1_NAMESPACE")
+		devCmd := &cmd.RunPipelineCmd{
+			GlobalFlags: &flags.GlobalFlags{
+				NoWarn:    true,
+				Namespace: ns,
+			},
+			Pipeline: "dev",
+			Ctx:      cancelCtx,
+		}
+		err = devCmd.RunDefault(f)
+		framework.ExpectNoError(err)
+		cancel()
+
+		// now check if nonExistentNs got created
+		framework.ExpectNamespace(depNamespace)
+
+		framework.ExpectNoError(err)
+
+	})
+
 	ginkgo.It("should deploy git dependency", func() {
 		tempDir, err := framework.CopyToTempDir("tests/dependencies/testdata/git")
 		framework.ExpectNoError(err)

e2e/tests/dependencies/testdata/namespace/dep1.yaml

@@ -0,0 +1,8 @@
+version: v1beta10
+deployments:
+- name: nginx
+  helm:
+    componentChart: true
+    values:
+      containers:
+      - image: nginx

e2e/tests/dependencies/testdata/namespace/devspace.yaml

@@ -0,0 +1,16 @@
+version: v2beta1
+vars:
+  DEP1_NAMESPACE:
+    source: env
+    default: false
+deployments:
+  nginx:
+    helm:
+      values:
+        containers:
+          - image: nginx
+
+dependencies:
+  test-dependency:
+    path: ./dep1.yaml
+    namespace: ${DEP1_NAMESPACE}

pkg/devspace/build/localregistry/local_registry.go

@@ -14,9 +14,6 @@ import (
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/wait"
-	applyv1 "k8s.io/client-go/applyconfigurations/core/v1"
-
-	kerrors "k8s.io/apimachinery/pkg/api/errors"
 
 	"github.com/google/go-containerregistry/pkg/v1/remote"
 	"github.com/loft-sh/devspace/pkg/devspace/kubectl"
@@ -176,41 +173,7 @@ func (r *LocalRegistry) ensureNamespace(ctx devspacecontext.Context) error {
 		return nil
 	}
 
-	// Try to get the namespace we need
-	_, err := ctx.KubeClient().
-		KubeClient().
-		CoreV1().
-		Namespaces().
-		Get(ctx.Context(), r.Namespace, metav1.GetOptions{})
-	// Ignore not found errors, but if we have any other type or error, report it
-	if err != nil && !kerrors.IsNotFound(err) {
-		return err
-	}
-	// And if we don't have errors, it means the namespace already exists.
-	if err == nil {
-		ctx.Log().Debugf("Namespace %s already exists, skipping creation", r.Namespace)
-		return nil
-	}
-
-	ctx.Log().Debugf("Namespace %s doesn't exist, attempting creation", r.Namespace)
-	applyConfiguration, err := applyv1.ExtractNamespace(&corev1.Namespace{
-		ObjectMeta: metav1.ObjectMeta{
-			Name: r.Namespace,
-		},
-	}, ApplyFieldManager)
-	if err != nil {
-		return err
-	}
-
-	_, err = ctx.KubeClient().KubeClient().CoreV1().Namespaces().Apply(
-		ctx.Context(),
-		applyConfiguration,
-		metav1.ApplyOptions{
-			FieldManager: ApplyFieldManager,
-			Force:        true,
-		},
-	)
-	return err
+	return kubectl.EnsureNamespace(ctx.Context(), ctx.KubeClient(), r.Namespace, ctx.Log())
 }
 
 func (r *LocalRegistry) SelectRegistryPod(ctx devspacecontext.Context) (*corev1.Pod, error) {

pkg/devspace/pipeline/pipeline.go

@@ -257,6 +257,17 @@ func (p *pipeline) StartNewDependencies(ctx devspacecontext.Context, dependencie
 	return t.Wait()
 }
 
+func ensureNamespace(ctx devspacecontext.Context, namespace string) error {
+	// If localregistry namespace is the same as devspace, we don't have
+	// anything to do.
+	if namespace == ctx.KubeClient().Namespace() || namespace == "" {
+		ctx.Log().Debugf("Namespace %s is the default Devspace namespace", namespace)
+		return nil
+	}
+
+	return kubectl.EnsureNamespace(ctx.Context(), ctx.KubeClient(), namespace, ctx.Log())
+}
+
 func waitForDependency(ctx context.Context, start types.Pipeline, dependencyName string, log log.Logger) {
 	// get top level pipeline
 	for start.Parent() != nil {
@@ -373,6 +384,13 @@ func (p *pipeline) startNewDependency(ctx devspacecontext.Context, dependency ty
 		pipelineConfig *latest.Pipeline
 		err            error
 	)
+
+	// Ensure dependency namespace exists
+	err = ensureNamespace(ctx, dependency.DependencyConfig().Namespace)
+	if err != nil {
+		return errors.Wrapf(err, "cannot run dependency %s", dependency.Name())
+	}
+
 	if dependency.Config().Config().Pipelines == nil || dependency.Config().Config().Pipelines[executePipeline] == nil {
 		pipelineConfig, err = types.GetDefaultPipeline(executePipeline)
 		if err != nil {