fix: remove k8.getKubeConfig

src/commands/cluster/tasks.ts

@@ -55,7 +55,7 @@
         if (!context) {
           const isQuiet = self.parent.getConfigManager().getFlag(flags.quiet);
           if (isQuiet) {
-            context = self.parent.getK8().getKubeConfig().currentContext;
+            context = self.parent.getK8().getCurrentContext();
           } else {
             context = await self.promptForContext(parentTask, cluster);
           }
@@ -96,11 +96,12 @@
       title: 'Read clusters from remote config',
       task: async (ctx, task) => {
         const localConfig = this.parent.getLocalConfig();
-        const currentCluster = this.parent.getK8().getKubeConfig().getCurrentCluster();
+        const currentCluster = this.parent.getK8().getCurrentCluster();
+        const currentClusterName = this.parent.getK8().getCurrentClusterName();
         const currentRemoteConfig: RemoteConfigDataWrapper = await this.parent.getRemoteConfigManager().get();
         const subTasks = [];
         const remoteConfigClusters = Object.keys(currentRemoteConfig.clusters);
-        const otherRemoteConfigClusters: string[] = remoteConfigClusters.filter(c => c !== currentCluster.name);
+        const otherRemoteConfigClusters: string[] = remoteConfigClusters.filter(c => c !== currentClusterName);
 
         // Validate connections for the other clusters
         for (const cluster of otherRemoteConfigClusters) {
@@ -163,7 +164,7 @@
           } else if (!localConfig.clusterContextMapping[cluster]) {
             // In quiet mode, use the currently selected context to update the mapping
             if (isQuiet) {
-              localConfig.clusterContextMapping[cluster] = this.parent.getK8().getKubeConfig().getCurrentContext();
+              localConfig.clusterContextMapping[cluster] = this.parent.getK8().getCurrentContext();
             }
 
             // Prompt the user to select a context if mapping value is missing
@@ -186,7 +187,7 @@
   ) {
     let selectedContext;
     if (isQuiet) {
-      selectedContext = this.parent.getK8().getKubeConfig().getCurrentContext();
+      selectedContext = this.parent.getK8().getCurrentContext();
     } else {
       selectedContext = await this.promptForContext(task, selectedCluster);
       localConfig.clusterContextMapping[selectedCluster] = selectedContext;
@@ -304,8 +305,8 @@
           else {
             // Add the deployment to the LocalConfig with the currently selected cluster and context in KubeConfig
             if (isQuiet) {
-              selectedContext = this.parent.getK8().getKubeConfig().getCurrentContext();
-              selectedCluster = this.parent.getK8().getKubeConfig().getCurrentCluster().name;
+              selectedContext = this.parent.getK8().getCurrentContext();
+              selectedCluster = this.parent.getK8().getCurrentClusterName();
               localConfig.deployments[deploymentName] = {
                 clusters: [selectedCluster],
               };
@@ -364,7 +365,7 @@
   getClusterInfo() {
     return new Task('Get cluster info', async (ctx: any, task: ListrTaskWrapper<any, any, any>) => {
       try {
-        const cluster = this.parent.getK8().getKubeConfig().getCurrentCluster();
+        const cluster = this.parent.getK8().getCurrentCluster();
         this.parent.logger.showJSON(`Cluster Information (${cluster.name})`, cluster);
         this.parent.logger.showUser('\n');
       } catch (e: Error | unknown) {

src/core/config/local_config.ts

@@ -189,7 +189,7 @@
 
         if (!deploymentClusters) {
           if (isQuiet) {
-            deploymentClusters = k8.getKubeConfig().getCurrentCluster().name;
+            deploymentClusters = k8.getCurrentClusterName();
           } else {
             deploymentClusters = await flags.deploymentClusters.prompt(task, deploymentClusters);
           }
@@ -221,7 +221,7 @@
             }
             self.configManager.setFlag(flags.context, promptedContexts.join(','));
           } else {
-            const context = k8.getKubeConfig().getCurrentContext();
+            const context = k8.getCurrentContext();
             for (const cluster of parsedClusters) {
               self.clusterContextMapping[cluster] = context;
             }

src/core/config/remote/remote_config_manager.ts

@@ -161,7 +161,7 @@
     try {
       await RemoteConfigValidator.validateComponents(this.remoteConfig.components, this.k8);
     } catch (e) {
-      throw new SoloError(ErrorMessages.REMOTE_CONFIG_IS_INVALID(this.k8.getKubeConfig().getCurrentCluster().name));
+      throw new SoloError(ErrorMessages.REMOTE_CONFIG_IS_INVALID(this.k8.getCurrentClusterName()));
     }
     return this.remoteConfig;
   }
@@ -338,7 +338,7 @@
   private setDefaultContextIfNotSet(): void {
     if (this.configManager.hasFlag(flags.context)) return;
 
-    const context = this.k8.getKubeConfig().currentContext;
+    const context = this.k8.getCurrentContext();
 
     if (!context) {
       this.logger.error("Context is not passed and default one can't be acquired", this.localConfig);

src/core/k8.ts

@@ -39,6 +39,7 @@
 import {inject, injectable} from 'tsyringe-neo';
 import {patchInject} from './container_helper.js';
 import type {Namespace} from './config/remote/types.js';
+import {type Cluster} from '@kubernetes/client-node/dist/config_types.js';
 
 interface TDirectoryData {
   directory: boolean;
@@ -78,10 +79,6 @@
     this.init();
   }
 
-  getKubeConfig() {
-    return this.kubeConfig;
-  }
-
   init() {
     this.kubeConfig = new k8s.KubeConfig();
     this.kubeConfig.loadFromDefault();
@@ -1729,11 +1726,29 @@
     this.logger.debug(`getNodeState(${pod.metadata.name}): ...end`);
   }
 
-  setCurrentContext(context: string) {
+  public setCurrentContext(context: string) {
     this.kubeConfig.setCurrentContext(context);
 
     // Reinitialize clients
     this.kubeClient = this.kubeConfig.makeApiClient(k8s.CoreV1Api);
     this.coordinationApiClient = this.kubeConfig.makeApiClient(k8s.CoordinationV1Api);
   }
+
+  public getCurrentContext(): string {
+    return this.kubeConfig.getCurrentContext();
+  }
+
+  public getCurrentContextObject(): Context {
+    return this.kubeConfig.getContextObject(this.getCurrentContext());
+  }
+
+  public getCurrentCluster(): Cluster {
+    return this.kubeConfig.getCurrentCluster();
+  }
+
+  public getCurrentClusterName(): string {
+    const currentCluster = this.kubeConfig.getCurrentCluster();
+    if (!currentCluster) return '';
+    return currentCluster.name;
+  }
 }

src/index.ts

@@ -79,9 +79,8 @@ export function main(argv: any) {
 
     // set cluster and namespace in the global configManager from kubernetes context
     // so that we don't need to prompt the user
-    const kubeConfig = k8.getKubeConfig();
-    const context = kubeConfig.getContextObject(kubeConfig.getCurrentContext());
-    const cluster = kubeConfig.getCurrentCluster();
+    const context = k8.getCurrentContextObject();
+    const currentClusterName = k8.getCurrentClusterName();
 
     const opts: Opts = {
       logger,
@@ -106,7 +105,7 @@ export function main(argv: any) {
         configManager.reset();
       }
 
-      const clusterName = configManager.getFlag(flags.clusterName) || cluster.name;
+      const clusterName = configManager.getFlag(flags.clusterName) || currentClusterName;
 
       if (context.namespace) {
         configManager.setFlag(flags.namespace, context.namespace);

test/unit/commands/cluster.test.ts

@@ -182,24 +182,28 @@ describe('ClusterCommand unit tests', () => {
         k8Stub.testClusterConnection.resolves(true);
       }
 
-      const kubeConfigStub = sandbox.createStubInstance(KubeConfig);
-      kubeConfigStub.getCurrentContext.returns('context-from-kubeConfig');
-      kubeConfigStub.getCurrentCluster.returns({
+      const kubeConfigClusterObject = {
         name: 'cluster-3',
         caData: 'caData',
         caFile: 'caFile',
         server: 'server-3',
         skipTLSVerify: true,
         tlsServerName: 'tls-3',
-      } as Cluster);
+      } as Cluster;
+
+      const kubeConfigStub = sandbox.createStubInstance(KubeConfig);
+      kubeConfigStub.getCurrentContext.returns('context-from-kubeConfig');
+      kubeConfigStub.getCurrentCluster.returns(kubeConfigClusterObject);
 
       remoteConfigManagerStub = sandbox.createStubInstance(RemoteConfigManager);
       remoteConfigManagerStub.modify.callsFake(async callback => {
         await callback(remoteConfig);
       });
       remoteConfigManagerStub.get.resolves(remoteConfig);
 
-      k8Stub.getKubeConfig.returns(kubeConfigStub);
+      k8Stub.getCurrentClusterName.returns(kubeConfigClusterObject.name);
+      k8Stub.getCurrentCluster.returns(kubeConfigClusterObject);
+      k8Stub.getCurrentContext.returns('context-from-kubeConfig');
 
       const configManager = sandbox.createStubInstance(ConfigManager);