configurable k8sclient context

configurable k8sclient context

Author: petar-cvit

cyclops-ctrl/api/v1alpha1/module_types.go

@@ -47,6 +47,8 @@ const (
 	GitOpsWriteRepoAnnotation     = "cyclops-ui.com/write-repo"
 	GitOpsWritePathAnnotation     = "cyclops-ui.com/write-path"
 	GitOpsWriteRevisionAnnotation = "cyclops-ui.com/write-revision"
+
+	ModuleManagerAnnotation = "cyclops-ui.com/module-manager"
 )
 
 type TemplateRef struct {

cyclops-ctrl/internal/modulecontroller/module_controller.go

@@ -136,6 +136,10 @@ func (r *ModuleReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctr
 		return ctrl.Result{}, err
 	}
 
+	if module.Annotations[cyclopsv1alpha1.ModuleManagerAnnotation] == "mcp" {
+		r.telemetryClient.MCPModuleReconciliation()
+	}
+
 	r.logger.Info("upsert module", "namespaced name", req.NamespacedName)
 
 	templateVersion := module.Status.TemplateResolvedVersion

cyclops-ctrl/internal/telemetry/client.go

@@ -8,6 +8,7 @@ import (
 type Client interface {
 	ModuleCreation()
 	ModuleReconciliation()
+	MCPModuleReconciliation()
 	InstanceStart()
 	ReleaseUpdate()
 	ReleaseMigration()
@@ -80,6 +81,14 @@ func (c EnqueueClient) ModuleReconciliation() {
 	})
 }
 
+func (c EnqueueClient) MCPModuleReconciliation() {
+	_ = c.client.Enqueue(posthog.Capture{
+		Event:      "mcp-module-reconciliation",
+		DistinctId: c.distinctID,
+		Properties: c.messageProps(),
+	})
+}
+
 func (c EnqueueClient) ModuleCreation() {
 	_ = c.client.Enqueue(posthog.Capture{
 		Event:      "module-creation",
@@ -140,6 +149,9 @@ func (c MockClient) InstanceStart() {
 func (c MockClient) ModuleReconciliation() {
 }
 
+func (c MockClient) MCPModuleReconciliation() {
+}
+
 func (c MockClient) ModuleCreation() {
 }
 

cyclops-ctrl/pkg/cluster/k8sclient/client.go

@@ -2,8 +2,10 @@ package k8sclient
 
 import (
 	"context"
+	"fmt"
 
 	"k8s.io/client-go/rest"
+	"k8s.io/client-go/tools/clientcmd"
 	"k8s.io/client-go/tools/remotecommand"
 
 	"github.com/go-logr/logr"
@@ -37,43 +39,93 @@ type KubernetesClient struct {
 	logger logr.Logger
 }
 
-func New(
-	moduleNamespace string,
-	helmReleaseNamespace string,
-	moduleTargetNamespace string,
-	logger logr.Logger,
-) (*KubernetesClient, error) {
-	config := ctrl.GetConfigOrDie()
-	clientset, err := kubernetes.NewForConfig(config)
+type ClientConfig struct {
+	KubeconfigPath string
+	Context        string
+
+	ModuleNamespace       string
+	HelmReleaseNamespace  string
+	ModuleTargetNamespace string
+}
+
+func NewWithConfig(config ClientConfig, logger logr.Logger) (*KubernetesClient, error) {
+	var k8sConfig *rest.Config
+	var err error
+
+	if config.KubeconfigPath == "" {
+		k8sConfig, err = rest.InClusterConfig()
+		if err != nil {
+			k8sConfig, err = ctrl.GetConfig()
+			if err != nil {
+				return nil, err
+			}
+		}
+	} else {
+		loadingRules := &clientcmd.ClientConfigLoadingRules{
+			ExplicitPath: config.KubeconfigPath,
+		}
+
+		configOverrides := &clientcmd.ConfigOverrides{}
+		if config.Context != "" {
+			configOverrides.CurrentContext = config.Context
+		}
+
+		k8sConfig, err = clientcmd.NewNonInteractiveDeferredLoadingClientConfig(
+			loadingRules,
+			configOverrides,
+		).ClientConfig()
+		if err != nil {
+			return nil, fmt.Errorf("failed to load kubeconfig: %w", err)
+		}
+	}
+
+	clientset, err := kubernetes.NewForConfig(k8sConfig)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to create clientset: %w", err)
 	}
 
-	moduleSet, err := client.NewForConfig(config)
+	moduleSet, err := client.NewForConfig(k8sConfig)
 	if err != nil {
-		panic(err)
+		return nil, fmt.Errorf("failed to create module client: %w", err)
 	}
 
-	discovery := discovery.NewDiscoveryClientForConfigOrDie(config)
+	discovery, err := discovery.NewDiscoveryClientForConfig(k8sConfig)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create discovery client: %w", err)
+	}
 
-	dynamic, err := dynamic.NewForConfig(config)
+	dynamic, err := dynamic.NewForConfig(k8sConfig)
 	if err != nil {
-		panic(err.Error())
+		return nil, fmt.Errorf("failed to create dynamic client: %w", err)
 	}
 
 	return &KubernetesClient{
-		config:                config,
+		config:                k8sConfig,
 		Dynamic:               dynamic,
 		discovery:             discovery,
 		clientset:             clientset,
 		moduleset:             moduleSet,
-		moduleNamespace:       moduleNamespace,
-		helmReleaseNamespace:  helmReleaseNamespace,
-		moduleTargetNamespace: moduleTargetNamespace,
+		moduleNamespace:       config.ModuleNamespace,
+		helmReleaseNamespace:  config.HelmReleaseNamespace,
+		moduleTargetNamespace: config.ModuleTargetNamespace,
 		logger:                logger,
 	}, nil
 }
 
+func New(
+	moduleNamespace string,
+	helmReleaseNamespace string,
+	moduleTargetNamespace string,
+	logger logr.Logger,
+) (*KubernetesClient, error) {
+	config := ClientConfig{
+		ModuleNamespace:       moduleNamespace,
+		HelmReleaseNamespace:  helmReleaseNamespace,
+		ModuleTargetNamespace: moduleTargetNamespace,
+	}
+	return NewWithConfig(config, logger)
+}
+
 type IKubernetesClient interface {
 	GetStreamedPodLogs(ctx context.Context, namespace, container, name string, logCount *int64, logChan chan<- string) error
 	GetPodLogs(namespace, container, name string, numLogs *int64) ([]string, error)