feat: use pathaware provider and retrieve orgs client via manager (#239)

On-behalf-of: @SAP <simon@simontesar.com>

Author: simontesar

cmd/serve.go

@@ -34,6 +34,7 @@ import (
 	kcpclientset "github.com/kcp-dev/sdk/client/clientset/versioned/cluster"
 
 	"github.com/kcp-dev/multicluster-provider/apiexport"
+	pathaware "github.com/kcp-dev/multicluster-provider/path-aware"
 )
 
 var serverCfg *config.Config
@@ -56,7 +57,7 @@ func NewServeCmd() *cobra.Command {
 			endpointSliceName := serverCfg.APIExportEndpointSliceName
 			klog.InfoS("using endpoint slice name", "name", endpointSliceName)
 
-			provider, err := apiexport.New(restCfg, endpointSliceName, apiexport.Options{
+			provider, err := pathaware.New(restCfg, endpointSliceName, apiexport.Options{
 				Scheme: scheme,
 			})
 			if err != nil {
@@ -127,7 +128,7 @@ func NewServeCmd() *cobra.Command {
 			orgsClusterID := logicalcluster.From(orgsCluster)
 			klog.InfoS("found orgs cluster", "name", orgsCluster.Name, "cluster", orgsClusterID.String())
 
-			clusterCache, err := clustercache.New(restCfg)
+			clusterCache, err := clustercache.New(mgr)
 			if err != nil {
 				klog.Exit(err, "failed to create cluster cache")
 			}

pkg/clustercache/clustercache.go

@@ -37,36 +37,22 @@ type Provider interface {
 }
 
 type clusterCache struct {
-	lock       sync.RWMutex
-	cache      map[string]ClusterInfo
-	orgsClient client.Client
+	lock  sync.RWMutex
+	cache map[string]ClusterInfo
+	mgr   mcmanager.Manager
 }
 
-func New(cfg *rest.Config) (*clusterCache, error) {
-	copiedCfg := rest.CopyConfig(cfg)
-	parsed, err := url.Parse(copiedCfg.Host)
-	if err != nil {
-		return nil, err
-	}
-
-	parsed.Path = "/clusters/root:orgs"
-	copiedCfg.Host = parsed.String()
-
-	orgsClient, err := client.New(copiedCfg, client.Options{})
-	if err != nil {
-		return nil, err
-	}
+func New(mgr mcmanager.Manager) (*clusterCache, error) {
 
 	return &clusterCache{
-		cache:      make(map[string]ClusterInfo),
-		orgsClient: orgsClient,
+		cache: make(map[string]ClusterInfo),
+		mgr:   mgr,
 	}, nil
 }
 
 func NewWithClient(orgsClient client.Client) *clusterCache {
 	return &clusterCache{
-		cache:      make(map[string]ClusterInfo),
-		orgsClient: orgsClient,
+		cache: make(map[string]ClusterInfo),
 	}
 }
 
@@ -129,7 +115,14 @@ func (c *clusterCache) Engage(ctx context.Context, name string, cl cluster.Clust
 			Version: "v1alpha1",
 			Kind:    "Store",
 		})
-		if err := c.orgsClient.Get(ctx, types.NamespacedName{Name: orgName}, &store); err != nil {
+
+		orgsCluster, err := c.mgr.GetCluster(ctx, "root:orgs")
+		if err != nil {
+			return false, err
+		}
+		orgsClient := orgsCluster.GetClient()
+
+		if err := orgsClient.Get(ctx, types.NamespacedName{Name: orgName}, &store); err != nil {
 			klog.V(5).ErrorS(err, "Failed to get Store for org, will retry", "clusterName", name, "orgName", orgName)
 			return false, nil
 		}

pkg/clustercache/clustercache_test.go

@@ -17,34 +17,11 @@ import (
 )
 
 func TestNew(t *testing.T) {
-	tests := []struct {
-		name    string
-		host    string
-		wantErr bool
-	}{
-		{
-			name: "valid URL",
-			host: "https://example.com",
-		},
-		{
-			name:    "invalid URL",
-			host:    "://invalid-url",
-			wantErr: true,
-		},
-	}
+	mgr := mocks.NewManager(t)
 
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			cc, err := clustercache.New(&rest.Config{Host: tt.host})
-			if tt.wantErr {
-				assert.Error(t, err)
-				assert.Nil(t, cc)
-			} else {
-				assert.NoError(t, err)
-				assert.NotNil(t, cc)
-			}
-		})
-	}
+	cc, err := clustercache.New(mgr)
+	assert.NoError(t, err)
+	assert.NotNil(t, cc)
 }
 
 func TestClusterCache_Engage(t *testing.T) {
@@ -101,6 +78,8 @@ func TestClusterCache_Engage(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			cl := mocks.NewCluster(t)
 			k8sClient := mocks.NewClient(t)
+			mgr := mocks.NewManager(t)
+			orgsCluster := mocks.NewCluster(t)
 			orgsClient := mocks.NewClient(t)
 
 			cl.EXPECT().GetClient().Return(k8sClient)
@@ -125,14 +104,17 @@ func TestClusterCache_Engage(t *testing.T) {
 				Return(tt.lcGetErr)
 
 			if tt.setupOrgsClient != nil {
+				mgr.EXPECT().GetCluster(mock.Anything, "root:orgs").Return(orgsCluster, nil)
+				orgsCluster.EXPECT().GetClient().Return(orgsClient)
 				tt.setupOrgsClient(orgsClient)
 			}
 			if tt.setupCluster != nil {
 				tt.setupCluster(cl)
 			}
 
-			cc := clustercache.NewWithClient(orgsClient)
-			err := cc.Engage(ctx, "test-cluster", cl)
+			cc, err := clustercache.New(mgr)
+			assert.NoError(t, err)
+			err = cc.Engage(ctx, "test-cluster", cl)
 
 			if tt.wantErr {
 				assert.Error(t, err)
@@ -153,7 +135,9 @@ func TestClusterCache_Engage(t *testing.T) {
 }
 
 func TestClusterCache_Get_NotFound(t *testing.T) {
-	cc := clustercache.NewWithClient(nil)
+	mgr := mocks.NewManager(t)
+	cc, err := clustercache.New(mgr)
+	assert.NoError(t, err)
 	info, found := cc.Get("non-existing")
 	assert.False(t, found)
 	assert.Empty(t, info.StoreID)