refactor: remove target namespace (#3221)

FabianKramm · web-flow · commit 28215aa61048 · 2025-09-22T17:43:09.000+02:00
diff --git a/.github/workflows/e2e.yaml b/.github/workflows/e2e.yaml
@@ -343,10 +343,6 @@ jobs:
             haValues="-f ./test/values_ha.yaml"
           fi
 
-          if [ "${{ matrix.test-suite-path }}" = "./test/e2e_target_namespace" ]; then
-            kubectl apply -f "${{ matrix.test-suite-path }}/role.yaml"
-          fi
-
           if [ "${{ matrix.test-suite-path }}" = "./test/e2e" ]; then
             kubectl create namespace from-host-sync-test
             kubectl create namespace from-host-sync-test-2
diff --git a/chart/templates/limitrange.yaml b/chart/templates/limitrange.yaml
@@ -4,11 +4,7 @@ apiVersion: v1
 kind: LimitRange
 metadata:
   name: vc-{{ .Release.Name }}
-  {{- if .Values.experimental.syncSettings.targetNamespace }}
-  namespace: {{ .Values.experimental.syncSettings.targetNamespace }}
-  {{- else }}
   namespace: {{ .Release.Namespace }}
-  {{- end }}
   labels:
     app: vcluster
     chart: "{{ include "vcluster.version.label"  $ }}"
diff --git a/chart/templates/networkpolicy.yaml b/chart/templates/networkpolicy.yaml
@@ -3,11 +3,7 @@ apiVersion: networking.k8s.io/v1
 kind: NetworkPolicy
 metadata:
   name: vc-work-{{ .Release.Name }}
-  {{- if .Values.experimental.syncSettings.targetNamespace }}
-  namespace: {{ .Values.experimental.syncSettings.targetNamespace }}
-  {{- else }}
   namespace: {{ .Release.Namespace }}
-  {{- end }}
   labels:
     app: vcluster
     chart: "{{ include "vcluster.version.label"  $ }}"
diff --git a/chart/templates/resourcequota.yaml b/chart/templates/resourcequota.yaml
@@ -4,11 +4,7 @@ apiVersion: v1
 kind: ResourceQuota
 metadata:
   name: vc-{{ .Release.Name }}
-  {{- if .Values.experimental.syncSettings.targetNamespace }}
-  namespace: {{ .Values.experimental.syncSettings.targetNamespace }}
-  {{- else }}
   namespace: {{ .Release.Namespace }}
-  {{- end }}
   labels:
     app: vcluster
     chart: "{{ include "vcluster.version.label"  $ }}"
diff --git a/chart/values.schema.json b/chart/values.schema.json
@@ -1850,10 +1850,6 @@
     },
     "ExperimentalSyncSettings": {
       "properties": {
-        "targetNamespace": {
-          "type": "string",
-          "description": "TargetNamespace is the namespace where the workloads should get synced to.\nDeprecated: Removed in 0.29.0."
-        },
         "setOwner": {
           "type": "boolean",
           "description": "SetOwner specifies if vCluster should set an owner reference on the synced objects to the vCluster service. This allows for easy garbage collection."
diff --git a/chart/values.yaml b/chart/values.yaml
@@ -1192,9 +1192,6 @@ plugins: {}
 experimental:
   # SyncSettings are advanced settings for the syncer controller.
   syncSettings:
-    # TargetNamespace is the namespace where the workloads should get synced to.
-    # Deprecated: Removed in 0.29.0.
-    targetNamespace: ""
     # SetOwner specifies if vCluster should set an owner reference on the synced objects to the vCluster service. This allows for easy garbage collection.
     setOwner: true
   
diff --git a/config/config.go b/config/config.go
@@ -2914,10 +2914,6 @@ func (e Experimental) JSONSchemaExtend(base *jsonschema.Schema) {
 }
 
 type ExperimentalSyncSettings struct {
-	// TargetNamespace is the namespace where the workloads should get synced to.
-	// Deprecated: Removed in 0.29.0.
-	TargetNamespace string `json:"targetNamespace,omitempty"`
-
 	// SetOwner specifies if vCluster should set an owner reference on the synced objects to the vCluster service. This allows for easy garbage collection.
 	SetOwner bool `json:"setOwner,omitempty"`
 
diff --git a/config/legacyconfig/migrate.go b/config/legacyconfig/migrate.go
@@ -412,7 +412,7 @@ func convertBaseValues(oldConfig BaseHelm, newConfig *config.Config) error {
 		}
 
 		if oldConfig.Isolation.Namespace != nil {
-			return fmt.Errorf("isolation.namespace is no longer supported, use experimental.syncSettings.targetNamespace instead")
+			return fmt.Errorf("isolation.namespace is no longer supported")
 		}
 		if oldConfig.Isolation.NodeProxyPermission.Enabled != nil {
 			return fmt.Errorf("isolation.nodeProxyPermission.enabled is no longer supported, use rbac.clusterRole.overwriteRules instead")
@@ -815,11 +815,7 @@ func migrateFlag(distro, key, value string, newConfig *config.Config) error {
 
 		newConfig.ControlPlane.Proxy.ExtraSANs = append(newConfig.ControlPlane.Proxy.ExtraSANs, strings.Split(value, ",")...)
 	case "target-namespace":
-		if value == "" {
-			return fmt.Errorf("value is missing")
-		}
-
-		newConfig.Experimental.SyncSettings.TargetNamespace = value
+		return fmt.Errorf("this is not supported anymore, vCluster needs to be created in the same namespace as the target workloads")
 	case "service-name":
 		return fmt.Errorf("this is not supported anymore, the service needs to be the vCluster name")
 	case "name":
diff --git a/config/values.yaml b/config/values.yaml
@@ -642,7 +642,6 @@ plugins: {}
 
 experimental:
   syncSettings:
-    targetNamespace: ""
     setOwner: true
 
   deploy:
diff --git a/pkg/config/config.go b/pkg/config/config.go
@@ -26,9 +26,6 @@ type VirtualClusterConfig struct {
 	// Name is the name of the vCluster
 	Name string `json:"name"`
 
-	// HostTargetNamespace is the namespace of the host cluster where the workloads should get created in
-	HostTargetNamespace string `json:"hostTargetNamespace,omitempty"`
-
 	// HostNamespace is the namespace in the host cluster where the vCluster is running
 	HostNamespace string `json:"hostNamespace,omitempty"`
 
@@ -120,7 +117,6 @@ func (v VirtualClusterConfig) LegacyOptions() (*legacyconfig.LegacyVirtualCluste
 		BindAddress:                 v.ControlPlane.Proxy.BindAddress,
 		Port:                        v.ControlPlane.Proxy.Port,
 		Name:                        v.Name,
-		TargetNamespace:             v.HostTargetNamespace,
 		ServiceName:                 v.Name,
 		SetOwner:                    v.Experimental.SyncSettings.SetOwner,
 		SyncAllNodes:                v.Sync.FromHost.Nodes.Selector.All,
diff --git a/pkg/controllers/deploy/deploy.go b/pkg/controllers/deploy/deploy.go
@@ -181,7 +181,7 @@ func (r *Deployer) ProcessInitManifests(ctx context.Context, vConfig *config.Vir
 	var err error
 	manifests := vConfig.Experimental.Deploy.VCluster.Manifests
 	if vConfig.Experimental.Deploy.VCluster.ManifestsTemplate != "" {
-		templatedManifests, err := k8s.ExecTemplate(vConfig.Experimental.Deploy.VCluster.ManifestsTemplate, vConfig.Name, vConfig.HostTargetNamespace, &vConfig.Config)
+		templatedManifests, err := k8s.ExecTemplate(vConfig.Experimental.Deploy.VCluster.ManifestsTemplate, vConfig.Name, vConfig.HostNamespace, &vConfig.Config)
 		if err != nil {
 			return fmt.Errorf("exec manifests template: %w", err)
 		}
diff --git a/pkg/controllers/register.go b/pkg/controllers/register.go
@@ -102,10 +102,7 @@ func RegisterControllers(ctx *synccontext.ControllerContext, syncers []syncertyp
 }
 
 func registerServiceSyncControllers(ctx *synccontext.ControllerContext) error {
-	hostNamespace := ctx.Config.HostTargetNamespace
-	if ctx.Config.Sync.ToHost.Namespaces.Enabled {
-		hostNamespace = ctx.Config.HostNamespace
-	}
+	hostNamespace := ctx.Config.HostNamespace
 
 	if len(ctx.Config.Networking.ReplicateServices.FromHost) > 0 {
 		mapping, err := parseMapping(ctx.Config.Networking.ReplicateServices.FromHost, hostNamespace, "")
diff --git a/pkg/integrations/metricsserver/metricsserver.go b/pkg/integrations/metricsserver/metricsserver.go
@@ -184,7 +184,7 @@ func handleMetricsServerProxyRequest(
 			splitted[5] = mappings.VirtualToHostNamespace(syncContext, info.Namespace)
 		} else if translate.Default.SingleNamespaceTarget() {
 			// limit to current namespace in host cluster
-			splitted = append(splitted[:4], append([]string{"namespaces", ctx.Config.HostTargetNamespace}, splitted[4:]...)...)
+			splitted = append(splitted[:4], append([]string{"namespaces", ctx.Config.HostNamespace}, splitted[4:]...)...)
 		}
 
 		metricsServerProxy.resourceType = PodResource
diff --git a/pkg/mappings/resources/namespaces.go b/pkg/mappings/resources/namespaces.go
@@ -12,7 +12,7 @@ import (
 
 func CreateNamespacesMapper(ctx *synccontext.RegisterContext) (synccontext.Mapper, error) {
 	singleNamespaceMapper := &singleNamespaceModeMapper{
-		targetNamespace: ctx.Config.HostTargetNamespace,
+		targetNamespace: ctx.Config.HostNamespace,
 	}
 	if ctx.Config.Sync.ToHost.Namespaces.Enabled {
 		return pro.GetNamespaceMapper(ctx, singleNamespaceMapper)
diff --git a/pkg/plugin/plugin.go b/pkg/plugin/plugin.go
@@ -43,7 +43,7 @@ func (m *manager) Start(
 		return fmt.Errorf("build legacy options: %w", err)
 	}
 
-	err = m.legacyManager.Start(ctx, vConfig.HostNamespace, vConfig.HostTargetNamespace, virtualKubeConfig, vConfig.HostConfig, syncerConfig, legacyOptions)
+	err = m.legacyManager.Start(ctx, vConfig.HostNamespace, vConfig.HostNamespace, virtualKubeConfig, vConfig.HostConfig, syncerConfig, legacyOptions)
 	if err != nil {
 		return fmt.Errorf("start legacy plugins: %w", err)
 	}
diff --git a/pkg/setup/cleanup_test.go b/pkg/setup/cleanup_test.go
@@ -70,7 +70,6 @@ func TestDeletePreviouslyReplicatedServices(t *testing.T) {
 
 	testCases := []struct {
 		name                                string
-		workloadTargetNamespace             string
 		replicateServicesConfig             vclusterconfig.ReplicateServices
 		initialHostServicesBeforeCleanup    []runtime.Object
 		initialVirtualServicesBeforeCleanup []runtime.Object
@@ -95,22 +94,6 @@ func TestDeletePreviouslyReplicatedServices(t *testing.T) {
 			expectedHostServicesAfterCleanup:    []runtime.Object{hostService1},
 			expectedVirtualServicesAfterCleanup: []runtime.Object{virtualService1},
 		},
-		{
-			name:                    "Has replicated service config that uses target namespace on host, no cleanup",
-			workloadTargetNamespace: "my-vcluster",
-			replicateServicesConfig: vclusterconfig.ReplicateServices{
-				FromHost: []vclusterconfig.ServiceMapping{
-					{
-						From: "host-service",
-						To:   "virtual-namespace-2/virtual-service-2",
-					},
-				},
-			},
-			initialHostServicesBeforeCleanup:    []runtime.Object{hostServiceDefaultTargetNamespace},
-			initialVirtualServicesBeforeCleanup: []runtime.Object{virtualService2},
-			expectedHostServicesAfterCleanup:    []runtime.Object{hostServiceDefaultTargetNamespace},
-			expectedVirtualServicesAfterCleanup: []runtime.Object{virtualService2},
-		},
 		{
 			name: "Replicated service removed from config",
 			replicateServicesConfig: vclusterconfig.ReplicateServices{
@@ -153,9 +136,6 @@ func TestDeletePreviouslyReplicatedServices(t *testing.T) {
 			ctx := context.Background()
 			fakeConfig := testingutil.NewFakeConfig()
 			fakeConfig.Networking.ReplicateServices = tc.replicateServicesConfig
-			if tc.workloadTargetNamespace != "" {
-				fakeConfig.HostTargetNamespace = tc.workloadTargetNamespace
-			}
 			pClient := testingutil.NewFakeClient(scheme.Scheme, tc.initialHostServicesBeforeCleanup...)
 			vClient := testingutil.NewFakeClient(scheme.Scheme, tc.initialVirtualServicesBeforeCleanup...)
 			fakeControllerContext := NewFakeControllerContext(ctx, fakeConfig, pClient, vClient)
diff --git a/pkg/setup/config/config.go b/pkg/setup/config/config.go
@@ -55,20 +55,14 @@ func InitClients(vConfig *config.VirtualClusterConfig) error {
 		return err
 	}
 
-	// ensure target namespace
-	vConfig.HostTargetNamespace = vConfig.Experimental.SyncSettings.TargetNamespace
-	if vConfig.HostTargetNamespace == "" {
-		vConfig.HostTargetNamespace = vConfig.HostNamespace
-	}
-
 	// get workload target namespace translator
 	if vConfig.Sync.ToHost.Namespaces.Enabled {
-		translate.Default, err = pro.GetWithSyncedNamespacesTranslator(vConfig.HostTargetNamespace, vConfig.Sync.ToHost.Namespaces.Mappings)
+		translate.Default, err = pro.GetWithSyncedNamespacesTranslator(vConfig.HostNamespace, vConfig.Sync.ToHost.Namespaces.Mappings)
 		if err != nil {
 			return err
 		}
 	} else {
-		translate.Default = translate.NewSingleNamespaceTranslator(vConfig.HostTargetNamespace)
+		translate.Default = translate.NewSingleNamespaceTranslator(vConfig.HostNamespace)
 	}
 
 	return nil
@@ -229,12 +223,6 @@ func SetGlobalOwner(ctx context.Context, vConfig *config.VirtualClusterConfig) e
 		return nil
 	}
 
-	if vConfig.HostNamespace != vConfig.HostTargetNamespace {
-		klog.Warningf("Skip setting owner, because current namespace %s != target namespace %s", vConfig.HostNamespace, vConfig.HostTargetNamespace)
-
-		return nil
-	}
-
 	if vConfig.HostClient == nil {
 		return errors.New("nil HostClient")
 	}
diff --git a/pkg/setup/controller_context.go b/pkg/setup/controller_context.go
@@ -115,7 +115,7 @@ func getLocalCacheOptions(options *config.VirtualClusterConfig) cache.Options {
 	// is multi namespace mode?
 	defaultNamespaces := make(map[string]cache.Config)
 	if !options.Sync.ToHost.Namespaces.Enabled {
-		defaultNamespaces[options.HostTargetNamespace] = cache.Config{}
+		defaultNamespaces[options.HostNamespace] = cache.Config{}
 	}
 	// do we need access to another namespace to export the kubeconfig ?
 	// we will need access to all the objects that the vcluster usually has access to
@@ -368,11 +368,7 @@ func initControllerContext(
 	// create a new current namespace client
 	var currentNamespaceClient client.Client
 	if !vClusterOptions.ControlPlane.Standalone.Enabled {
-		currentNamespaceClient, err = newCurrentNamespaceClient(ctx, localManager, vClusterOptions)
-		if err != nil {
-			return nil, err
-		}
-
+		currentNamespaceClient = localManager.GetClient()
 		localDiscoveryClient, err := discovery.NewDiscoveryClientForConfig(localManager.GetConfig())
 		if err != nil {
 			return nil, err
@@ -428,55 +424,3 @@ func initControllerContext(
 	controllerContext.Mappings = mappings.NewMappingsRegistry(mappingStore)
 	return controllerContext, nil
 }
-
-func newCurrentNamespaceClient(ctx context.Context, localManager ctrl.Manager, options *config.VirtualClusterConfig) (client.Client, error) {
-	if localManager == nil {
-		return nil, errors.New("nil localManager")
-	}
-	if options == nil {
-		return nil, errors.New("nil options")
-	}
-
-	var err error
-
-	// currentNamespaceCache is needed for tasks such as finding out fake kubelet ips
-	// as those are saved as Kubernetes services inside the same namespace as vcluster
-	// is running. In the case of options.TargetNamespace != currentNamespace (the namespace
-	// where vcluster is currently running in), we need to create a new object cache
-	// as the regular cache is scoped to the options.TargetNamespace and cannot return
-	// objects from the current namespace.
-	currentNamespaceCache := localManager.GetCache()
-	if !options.Sync.ToHost.Namespaces.Enabled && options.HostNamespace != options.HostTargetNamespace {
-		currentNamespaceCache, err = cache.New(localManager.GetConfig(), cache.Options{
-			Scheme:            localManager.GetScheme(),
-			Mapper:            localManager.GetRESTMapper(),
-			DefaultNamespaces: map[string]cache.Config{options.HostNamespace: {}},
-		})
-		if err != nil {
-			return nil, err
-		}
-
-		// start cache now if it's not in the same namespace
-		go func() {
-			err := currentNamespaceCache.Start(ctx)
-			if err != nil {
-				panic(err)
-			}
-		}()
-		currentNamespaceCache.WaitForCacheSync(ctx)
-	}
-
-	// create a current namespace client
-	currentNamespaceClient, err := blockingcacheclient.NewCacheClient(localManager.GetConfig(), client.Options{
-		Scheme: localManager.GetScheme(),
-		Mapper: localManager.GetRESTMapper(),
-		Cache: &client.CacheOptions{
-			Reader: currentNamespaceCache,
-		},
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return currentNamespaceClient, nil
-}
diff --git a/pkg/util/testing/config.go b/pkg/util/testing/config.go
@@ -22,10 +22,9 @@ func NewFakeConfig() *config.VirtualClusterConfig {
 
 	// parse config
 	vConfig := &config.VirtualClusterConfig{
-		Config:              *defaultConfig,
-		Name:                DefaultTestVClusterName,
-		HostNamespace:       DefaultTestTargetNamespace,
-		HostTargetNamespace: DefaultTestTargetNamespace,
+		Config:        *defaultConfig,
+		Name:          DefaultTestVClusterName,
+		HostNamespace: DefaultTestTargetNamespace,
 	}
 
 	err = config.ValidateConfigAndSetDefaults(vConfig)
diff --git a/test/README.md b/test/README.md
@@ -21,7 +21,7 @@
         
          For e.g.
          ```
-         helm template vcluster ./charts/k3s/ -f ./test/commonValues.yaml -f ./test/e2e_target_namespace/values.yaml
+         helm template vcluster ./charts/k3s/ -f ./test/commonValues.yaml
 
          # Then look for `name: syncer` container
 
diff --git a/test/e2e_target_namespace/e2e_target_namespace_test.go b/test/e2e_target_namespace/e2e_target_namespace_test.go
diff --git a/test/e2e_target_namespace/role.yaml b/test/e2e_target_namespace/role.yaml
diff --git a/test/e2e_target_namespace/targetnamespace/target_namespace.go b/test/e2e_target_namespace/targetnamespace/target_namespace.go
diff --git a/test/e2e_target_namespace/values.yaml b/test/e2e_target_namespace/values.yaml

Original file line number	Diff line number	Diff line change
`@@ -2914,10 +2914,6 @@ func (e Experimental) JSONSchemaExtend(base *jsonschema.Schema) {`
`2914`	`2914`	`}`
`2915`	`2915`
`2916`	`2916`	`type ExperimentalSyncSettings struct {`
`2917`		`- // TargetNamespace is the namespace where the workloads should get synced to.`
`2918`		`- // Deprecated: Removed in 0.29.0.`
`2919`		- TargetNamespace string `json:"targetNamespace,omitempty"`
`2920`		`-`
`2921`	`2917`	`// SetOwner specifies if vCluster should set an owner reference on the synced objects to the vCluster service. This allows for easy garbage collection.`
`2922`	`2918`	SetOwner bool `json:"setOwner,omitempty"`
`2923`	`2919`