Skip to content
Closed
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
32 changes: 32 additions & 0 deletions pkg/setup/controller_context.go
Original file line number Diff line number Diff line change
Expand Up @@ -3,7 +3,9 @@ package setup
import (
"context"
"fmt"
"maps"
"os"
"slices"
"time"

vclusterconfig "github.com/loft-sh/vcluster/config"
Expand All @@ -19,6 +21,7 @@ import (
"github.com/loft-sh/vcluster/pkg/syncer/synccontext"
"github.com/loft-sh/vcluster/pkg/telemetry"
"github.com/loft-sh/vcluster/pkg/util/blockingcacheclient"
"github.com/loft-sh/vcluster/pkg/util/namespaces"
"github.com/loft-sh/vcluster/pkg/util/pluginhookclient"
"github.com/pkg/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
Expand Down Expand Up @@ -119,6 +122,15 @@ func getLocalCacheOptions(options *config.VirtualClusterConfig) cache.Options {
if !options.Sync.ToHost.Namespaces.Enabled {
defaultNamespaces[options.HostNamespace] = cache.Config{}
gatewayNamespaces = gatewaySourceNamespaces(options)
} else if mapped := mappedHostNamespaces(options); mapped != nil {
// only exact namespace mappings are synced, so the syncer never needs
// objects outside of these namespaces and RBAC can stay namespaced
defaultNamespaces = mapped
gatewayNamespaces = gatewaySourceNamespaces(options)
klog.Infof("Restricting host cache to namespaces %v", slices.Sorted(maps.Keys(mapped)))
} else {
// synced namespaces are not known up front
return cache.Options{DefaultNamespaces: nil}
}
// 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
Expand Down Expand Up @@ -146,6 +158,26 @@ func getLocalCacheOptions(options *config.VirtualClusterConfig) cache.Options {
return cacheOptions
}

// mappedHostNamespaces returns the host namespaces the syncer works in when
// namespace sync only allows exact mappings, or nil if they are not known up
// front.
func mappedHostNamespaces(options *config.VirtualClusterConfig) map[string]cache.Config {
namespaceSync := options.Sync.ToHost.Namespaces
if !namespaceSync.Enabled || !namespaceSync.MappingsOnly || len(namespaceSync.Mappings.ByName) == 0 {
return nil
}

hostNamespaces := map[string]cache.Config{options.HostNamespace: {}}
for virtualNamespace, hostNamespace := range namespaceSync.Mappings.ByName {
if namespaces.IsPattern(virtualNamespace) || namespaces.IsPattern(hostNamespace) {
return nil
}
hostNamespaces[namespaces.ProcessNamespaceName(hostNamespace, options.Name)] = cache.Config{}
}

return hostNamespaces
}

func startPlugins(ctx context.Context, virtualConfig *rest.Config, virtualRawConfig *clientcmdapi.Config, options *config.VirtualClusterConfig) error {
klog.Infof("Start Plugins Manager...")
createKubeConfigOptions := CreateKubeConfigOptions{
Expand Down
127 changes: 127 additions & 0 deletions pkg/setup/controller_context_namespaces_test.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,127 @@
package setup

import (
"maps"
"slices"
"testing"

rootconfig "github.com/loft-sh/vcluster/config"
pkgconfig "github.com/loft-sh/vcluster/pkg/config"
"sigs.k8s.io/controller-runtime/pkg/cache"
)

func namespaceSyncOptions() *pkgconfig.VirtualClusterConfig {
options := &pkgconfig.VirtualClusterConfig{}
options.Name = "tenant"
options.HostNamespace = "tenant-control-plane"
options.Sync.ToHost.Namespaces.Enabled = true
options.Sync.ToHost.Namespaces.MappingsOnly = true
options.Sync.ToHost.Namespaces.Mappings.ByName = map[string]string{
"default": "${name}-ns-default",
"kube-system": "${name}-ns-kube-system",
}
return options
}

func cacheNamespaces(cacheOptions cache.Options) []string {
return slices.Sorted(maps.Keys(cacheOptions.DefaultNamespaces))
}

func TestLocalCacheWatchesHostNamespaceWithoutNamespaceSync(t *testing.T) {
options := &pkgconfig.VirtualClusterConfig{}
options.HostNamespace = "tenant-control-plane"

got := cacheNamespaces(getLocalCacheOptions(options))
if !slices.Equal(got, []string{"tenant-control-plane"}) {
t.Fatalf("expected host namespace only, got %v", got)
}
}

func TestLocalCacheWatchesMappedNamespacesWithMappingsOnly(t *testing.T) {
got := cacheNamespaces(getLocalCacheOptions(namespaceSyncOptions()))
want := []string{"tenant-control-plane", "tenant-ns-default", "tenant-ns-kube-system"}
if !slices.Equal(got, want) {
t.Fatalf("expected %v, got %v", want, got)
}
}

func TestLocalCacheMergesAdditionalSecretNamespacesWithMappedNamespaces(t *testing.T) {
options := namespaceSyncOptions()
options.ExportKubeConfig.AdditionalSecrets = []rootconfig.ExportKubeConfigAdditionalSecretReference{
{Namespace: "kubeconfigs", Name: "tenant-kubeconfig"},
}

got := cacheNamespaces(getLocalCacheOptions(options))
want := []string{"kubeconfigs", "tenant-control-plane", "tenant-ns-default", "tenant-ns-kube-system"}
if !slices.Equal(got, want) {
t.Fatalf("expected %v, got %v", want, got)
}
}

func TestLocalCacheWatchesAllNamespacesWhenNamespaceSyncIsNotRestricted(t *testing.T) {
tests := map[string]func(*pkgconfig.VirtualClusterConfig){
"mappings only disabled": func(options *pkgconfig.VirtualClusterConfig) {
options.Sync.ToHost.Namespaces.MappingsOnly = false
},
"no mappings": func(options *pkgconfig.VirtualClusterConfig) {
options.Sync.ToHost.Namespaces.Mappings.ByName = nil
},
"pattern host mapping": func(options *pkgconfig.VirtualClusterConfig) {
options.Sync.ToHost.Namespaces.Mappings.ByName["team-*"] = "${name}-team-*"
},
"additional secrets without restriction": func(options *pkgconfig.VirtualClusterConfig) {
options.Sync.ToHost.Namespaces.MappingsOnly = false
options.ExportKubeConfig.AdditionalSecrets = []rootconfig.ExportKubeConfigAdditionalSecretReference{
{Namespace: "kubeconfigs", Name: "tenant-kubeconfig"},
}
},
}

for name, modify := range tests {
t.Run(name, func(t *testing.T) {
options := namespaceSyncOptions()
modify(options)

cacheOptions := getLocalCacheOptions(options)
if cacheOptions.DefaultNamespaces != nil {
t.Fatalf("expected cache for all namespaces, got %v", cacheNamespaces(cacheOptions))
}
})
}
}

func TestLocalCacheStaysScopedWithFeaturesUsingOwnCaches(t *testing.T) {
// the virtual scheduler, hybrid scheduling and csi storage capacities
// watch the host through their own caches
options := namespaceSyncOptions()
options.ControlPlane.Advanced.VirtualScheduler.Enabled = true
options.Sync.ToHost.Pods.HybridScheduling.Enabled = true
options.Sync.FromHost.CSIStorageCapacities.Enabled = "true"

got := cacheNamespaces(getLocalCacheOptions(options))
want := []string{"tenant-control-plane", "tenant-ns-default", "tenant-ns-kube-system"}
if !slices.Equal(got, want) {
t.Fatalf("expected %v, got %v", want, got)
}
}

func TestLocalCacheWatchesGatewaySourceNamespacesWithMappedNamespaces(t *testing.T) {
options := namespaceSyncOptions()
options.Sync.FromHost.Gateways.Enabled = true
options.Sync.FromHost.Gateways.Mappings.ByName = map[string]string{
"platform-gateways/*": "shared-gateways/*",
}

cacheOptions := getLocalCacheOptions(options)
got := cacheNamespaces(cacheOptions)
want := []string{"tenant-control-plane", "tenant-ns-default", "tenant-ns-kube-system"}
if !slices.Equal(got, want) {
t.Fatalf("expected default local cache %v, got %v", want, got)
}

gatewayNamespaces := slices.Sorted(maps.Keys(gatewayCacheNamespaces(t, cacheOptions)))
want = []string{"platform-gateways", "tenant-control-plane", "tenant-ns-default", "tenant-ns-kube-system"}
if !slices.Equal(gatewayNamespaces, want) {
t.Fatalf("expected Gateway cache %v, got %v", want, gatewayNamespaces)
}
}
Loading