fix: all client (#121)

* fix: all client

* fix: tests

* chore: use fatal instead of error

Author: aaronschweig

internal/controller/store_controller.go

@@ -2,9 +2,13 @@ package controller
 
 import (
 	"context"
+	"net/url"
+	"strings"
 
+	"github.com/kcp-dev/logicalcluster/v3"
 	"github.com/platform-mesh/golang-commons/controller/lifecycle/builder"
 	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/client-go/rest"
 	ctrl "sigs.k8s.io/controller-runtime"
 	mcbuilder "sigs.k8s.io/multicluster-runtime/pkg/builder"
 	mccontext "sigs.k8s.io/multicluster-runtime/pkg/context"
@@ -32,12 +36,38 @@ type StoreReconciler struct {
 }
 
 func NewStoreReconciler(log *logger.Logger, fga openfgav1.OpenFGAServiceClient, mcMgr mcmanager.Manager) *StoreReconciler {
+
+	allCfg := rest.CopyConfig(mcMgr.GetLocalManager().GetConfig())
+
+	parsed, err := url.Parse(allCfg.Host)
+	if err != nil {
+		log.Fatal().Err(err).Msg("unable to parse host from config")
+	}
+
+	parts := strings.Split(parsed.Path, "clusters")
+
+	parsed.Path, err = url.JoinPath(parts[0], "clusters", logicalcluster.Wildcard.String())
+	if err != nil {
+		log.Fatal().Err(err).Msg("unable to join path")
+	}
+
+	allCfg.Host = parsed.String()
+
+	log.Info().Str("host", allCfg.Host).Msg("using host")
+
+	allClient, err := client.New(allCfg, client.Options{
+		Scheme: mcMgr.GetLocalManager().GetScheme(),
+	})
+	if err != nil {
+		log.Fatal().Err(err).Msg("unable to create new client")
+	}
+
 	return &StoreReconciler{
 		fga: fga,
 		log: log,
 		lifecycle: builder.NewBuilder("store", "StoreReconciler", []lifecyclesubroutine.Subroutine{
 			subroutine.NewStoreSubroutine(fga, mcMgr),
-			subroutine.NewAuthorizationModelSubroutine(fga, mcMgr),
+			subroutine.NewAuthorizationModelSubroutine(fga, mcMgr, allClient, log),
 			subroutine.NewTupleSubroutine(fga, mcMgr),
 		}, log).WithConditionManagement().
 			BuildMultiCluster(mcMgr),
@@ -59,7 +89,7 @@ func (r *StoreReconciler) SetupWithManager(mgr mcmanager.Manager, cfg *platforme
 		Watches(
 			&corev1alpha1.AuthorizationModel{},
 			handler.EnqueueRequestsFromMapFunc(func(ctx context.Context, obj client.Object) []reconcile.Request {
-				model,ok := obj.(*corev1alpha1.AuthorizationModel)
+				model, ok := obj.(*corev1alpha1.AuthorizationModel)
 				if !ok {
 					return nil
 				}

internal/subroutine/authorization_model.go

@@ -22,14 +22,16 @@ import (
 const schemaVersion = "1.2"
 
 type authorizationModelSubroutine struct {
-	fga openfgav1.OpenFGAServiceClient
-	mgr mcmanager.Manager
+	fga       openfgav1.OpenFGAServiceClient
+	mgr       mcmanager.Manager
+	allClient client.Client
 }
 
-func NewAuthorizationModelSubroutine(fga openfgav1.OpenFGAServiceClient, mgr mcmanager.Manager) *authorizationModelSubroutine {
+func NewAuthorizationModelSubroutine(fga openfgav1.OpenFGAServiceClient, mgr mcmanager.Manager, allClient client.Client, log *logger.Logger) *authorizationModelSubroutine {
 	return &authorizationModelSubroutine{
-		fga: fga,
-		mgr: mgr,
+		fga:       fga,
+		mgr:       mgr,
+		allClient: allClient,
 	}
 }
 
@@ -73,12 +75,7 @@ func (a *authorizationModelSubroutine) Process(ctx context.Context, instance run
 	log := logger.LoadLoggerFromContext(ctx)
 	store := instance.(*v1alpha1.Store)
 
-	cluster, err := a.mgr.ClusterFromContext(ctx)
-	if err != nil {
-		return ctrl.Result{}, errors.NewOperatorError(fmt.Errorf("unable to get cluster from context: %w", err), true, false)
-	}
-
-	extendingModules, err := getRelatedAuthorizationModels(ctx, cluster.GetClient(), store)
+	extendingModules, err := getRelatedAuthorizationModels(ctx, a.allClient, store)
 	if err != nil {
 		log.Error().Err(err).Msg("unable to get related authorization models")
 		return ctrl.Result{}, errors.NewOperatorError(err, true, false)

internal/subroutine/authorization_model_test.go

@@ -9,6 +9,7 @@ import (
 	openfgav1 "github.com/openfga/api/proto/openfga/v1"
 	language "github.com/openfga/language/pkg/go/transformer"
 	"github.com/platform-mesh/golang-commons/errors"
+	"github.com/platform-mesh/golang-commons/logger/testlogger"
 	"github.com/platform-mesh/security-operator/api/v1alpha1"
 	"github.com/platform-mesh/security-operator/internal/subroutine"
 	"github.com/platform-mesh/security-operator/internal/subroutine/mocks"
@@ -52,17 +53,17 @@ type user
 `
 
 func TestAuthorizationModelGetName(t *testing.T) {
-	subroutine := subroutine.NewAuthorizationModelSubroutine(nil, nil)
+	subroutine := subroutine.NewAuthorizationModelSubroutine(nil, nil, nil, nil)
 	assert.Equal(t, "AuthorizationModel", subroutine.GetName())
 }
 
 func TestAuthorizationModelFinalizers(t *testing.T) {
-	subroutine := subroutine.NewAuthorizationModelSubroutine(nil, nil)
+	subroutine := subroutine.NewAuthorizationModelSubroutine(nil, nil, nil, nil)
 	assert.Equal(t, []string(nil), subroutine.Finalizers(nil))
 }
 
 func TestAuthorizationModelFinalize(t *testing.T) {
-	subroutine := subroutine.NewAuthorizationModelSubroutine(nil, nil)
+	subroutine := subroutine.NewAuthorizationModelSubroutine(nil, nil, nil, nil)
 	_, err := subroutine.Finalize(context.Background(), nil)
 	assert.Nil(t, err)
 }
@@ -326,10 +327,12 @@ func TestAuthorizationModelProcess(t *testing.T) {
 				test.k8sMocks(client)
 			}
 
-			manager.EXPECT().ClusterFromContext(mock.Anything).Return(cluster, nil)
-			cluster.EXPECT().GetClient().Return(client)
+			manager.EXPECT().ClusterFromContext(mock.Anything).Return(cluster, nil).Maybe()
+			cluster.EXPECT().GetClient().Return(client).Maybe()
 
-			subroutine := subroutine.NewAuthorizationModelSubroutine(fga, manager)
+			logger := testlogger.New()
+
+			subroutine := subroutine.NewAuthorizationModelSubroutine(fga, manager, client, logger.Logger)
 			ctx := mccontext.WithCluster(context.Background(), string(logicalcluster.Name("path")))
 
 			_, err := subroutine.Process(ctx, test.store)