created factory and way to get k8 instance passing in the context

Signed-off-by: Jeromy Cannon <[email protected]>

Author: jeromy-cannon

src/core/constants.ts

@@ -103,6 +103,11 @@ export const TREASURY_ACCOUNT = 2;
 export const LOCAL_NODE_START_PORT = +process.env.LOCAL_NODE_START_PORT || 30212;
 export const ACCOUNT_UPDATE_BATCH_SIZE = +process.env.ACCOUNT_UPDATE_BATCH_SIZE || 10;
 
+/**
+ * The default K8 instance name that will use the kubeconfig current context
+ */
+export const K8_DEFAULT_INSTANCE = 'DEFAULT';
+
 export const POD_PHASE_RUNNING = 'Running';
 
 export const POD_CONDITION_INITIALIZED = 'Initialized';

src/core/kube/k8_client/k8_client.ts

@@ -5,8 +5,7 @@ import * as k8s from '@kubernetes/client-node';
 import {SoloError} from '../../errors.js';
 import {type ConfigManager} from '../../config_manager.js';
 import {type SoloLogger} from '../../logging.js';
-import {inject, injectable} from 'tsyringe-neo';
-import {patchInject} from '../../dependency_injection/container_helper.js';
+import {container} from 'tsyringe-neo';
 import {type K8} from '../k8.js';
 import {type Namespaces} from '../resources/namespace/namespaces.js';
 import {K8ClientClusters} from '../k8_client/resources/cluster/k8_client_clusters.js';
@@ -16,7 +15,6 @@ import {K8ClientConfigMaps} from '../k8_client/resources/config_map/k8_client_co
 import {K8ClientContainers} from '../k8_client/resources/container/k8_client_containers.js';
 import {type Containers} from '../resources/container/containers.js';
 import {type Contexts} from '../resources/context/contexts.js';
-import {K8ClientContexts} from '../k8_client/resources/context/k8_client_contexts.js';
 import {K8ClientPods} from '../k8_client/resources/pod/k8_client_pods.js';
 import {type Pods} from '../resources/pod/pods.js';
 import {type Services} from '../resources/service/services.js';
@@ -33,14 +31,14 @@ import {K8ClientSecrets} from '../k8_client/resources/secret/k8_client_secrets.j
 import {type Ingresses} from '../resources/ingress/ingresses.js';
 import {K8ClientIngresses} from './resources/ingress/k8_client_ingresses.js';
 import {InjectTokens} from '../../dependency_injection/inject_tokens.js';
+import * as constants from '../../constants.js';
 
 /**
  * A kubernetes API wrapper class providing custom functionalities required by solo
  *
  * Note: Take care if the same instance is used for parallel execution, as the behaviour may be unpredictable.
  * For parallel execution, create separate instances by invoking clone()
  */
-@injectable()
 export class K8Client implements K8 {
   private kubeConfig!: k8s.KubeConfig;
   private kubeClient!: k8s.CoreV1Api;
@@ -60,20 +58,19 @@ export class K8Client implements K8 {
   private k8Secrets: Secrets;
   private k8Ingresses: Ingresses;
 
-  constructor(
-    @inject(InjectTokens.ConfigManager) private readonly configManager?: ConfigManager,
-    @inject(InjectTokens.SoloLogger) private readonly logger?: SoloLogger,
-  ) {
-    this.configManager = patchInject(configManager, InjectTokens.ConfigManager, this.constructor.name);
-    this.logger = patchInject(logger, InjectTokens.SoloLogger, this.constructor.name);
+  private readonly configManager: ConfigManager;
+  private readonly logger: SoloLogger;
 
-    this.init();
+  constructor(private readonly context: string) {
+    this.configManager = container.resolve(InjectTokens.ConfigManager);
+    this.logger = container.resolve(InjectTokens.SoloLogger);
+
+    this.init(context);
   }
 
   // TODO make private, but first we need to require a cluster to be set and address the test cases using this
-  init(): K8 {
-    this.kubeConfig = new k8s.KubeConfig();
-    this.kubeConfig.loadFromDefault();
+  init(context: string = undefined): K8 {
+    this.kubeConfig = this.getKubeConfig(context);
 
     if (!this.kubeConfig.getCurrentContext()) {
       throw new SoloError('No active kubernetes context found. ' + 'Please set current kubernetes context.');
@@ -89,7 +86,6 @@ export class K8Client implements K8 {
 
     this.k8Clusters = new K8ClientClusters(this.kubeConfig);
     this.k8ConfigMaps = new K8ClientConfigMaps(this.kubeClient);
-    this.k8Contexts = new K8ClientContexts(this.kubeConfig);
     this.k8Services = new K8ClientServices(this.kubeClient);
     this.k8Pods = new K8ClientPods(this.kubeClient, this.kubeConfig);
     this.k8Containers = new K8ClientContainers(this.kubeConfig, this.k8Pods);
@@ -100,7 +96,34 @@ export class K8Client implements K8 {
     this.k8Secrets = new K8ClientSecrets(this.kubeClient);
     this.k8Ingresses = new K8ClientIngresses(this.networkingApi);
 
-    return this; // to enable chaining
+    // TODO this will run in the background, change this to use an await somehow, possibly after init is made private
+    this.contexts()
+      .testContextConnection(this.kubeConfig.getCurrentContext())
+      .then(() => {
+        this.logger.info(`successfully established connection to context: ${this.kubeConfig.getCurrentContext()}`);
+      })
+      .catch(e => {
+        const message = `Failed to create a connect to the K8 context '${this.kubeConfig.getCurrentContext()}'`;
+        this.logger.error(message, e);
+        throw new SoloError(message, e);
+      });
+
+    return this;
+  }
+
+  private getKubeConfig(context: string): k8s.KubeConfig {
+    const kubeConfig = new k8s.KubeConfig();
+    kubeConfig.loadFromDefault();
+
+    if (context !== constants.K8_DEFAULT_INSTANCE) {
+      const kubeConfigContext: k8s.Context = kubeConfig.getContextObject(context);
+      if (!kubeConfigContext) {
+        throw new SoloError(`No kube config context found with name ${context}`);
+      }
+      kubeConfig.setCurrentContext(context);
+    }
+
+    return kubeConfig;
   }
 
   public namespaces(): Namespaces {

src/core/kube/k8_client/k8_client_factory.ts

@@ -0,0 +1,41 @@
+/**
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {type K8Factory} from '../k8_factory.js';
+import {type K8} from '../k8.js';
+import {K8Client} from './k8_client.js';
+import * as constants from '../../constants.js';
+
+@injectable()
+export class K8ClientFactory implements K8Factory {
+  private readonly k8Clients: Map<string, K8> = new Map<string, K8>();
+
+  /**
+   * Get a k8 instance for the given context.  Provide constants.K8_DEFAULT_INSTANCE to get the default instance which
+   * uses the kubeconfig current context
+   * @param context - The context to get the k8 instance for
+   * @returns a k8 instance
+   */
+  public getK8(context: string): K8 {
+    if (!this.k8Clients.has(context)) {
+      this.k8Clients.set(context, this.createK8Client(context));
+    }
+
+    return this.k8Clients.get(context)!;
+  }
+
+  /**
+   * Create a new k8 client for the given context, if it is constants.K8_DEFAULT_INSTANCE, then it will return an
+   * instance with kube configs current context
+   * @param context - The context to create the k8 client for
+   * @returns a new k8 client
+   * @private
+   */
+  private createK8Client(context: string): K8 {
+    if (context === constants.K8_DEFAULT_INSTANCE) {
+      return new K8Client(undefined);
+    } else {
+      return new K8Client(context);
+    }
+  }
+}

src/core/kube/k8_factory.ts

@@ -0,0 +1,12 @@
+/**
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {type K8} from './k8.js';
+
+export interface K8Factory {
+  /**
+   * Get a k8 instance for the given context
+   * @param context - The context to get the k8 instance for
+   */
+  getK8(context: string): K8;
+}