From 92dd81b461fa36e5d89afd09db923716694ebb8a Mon Sep 17 00:00:00 2001
From: Sebastian Malton <smalton@mirantis.com>
Date: Mon, 6 Jul 2020 14:24:53 -0400
Subject: [PATCH] remove ContextHandler.withTemporaryKubeconfig()

Signed-off-by: Sebastian Malton <smalton@mirantis.com>
---
 src/features/metrics.ts     | 25 +++++++++++++++----------
 src/features/user-mode.ts   |  6 +++---
 src/main/context-handler.ts |  8 ++------
 src/main/feature.ts         | 26 ++++++++------------------
 src/main/proxy.ts           | 30 +++++++++++++++++-------------
 5 files changed, 45 insertions(+), 50 deletions(-)

diff --git a/src/features/metrics.ts b/src/features/metrics.ts
index 98e71e50d2..b22df346f1 100644
--- a/src/features/metrics.ts
+++ b/src/features/metrics.ts
@@ -51,21 +51,26 @@ export class MetricsFeature extends Feature {
     storageClass: null,
   };
 
-  async install(cluster: Cluster): Promise<boolean> {
+  async install(cluster: Cluster): Promise<void> {
     // Check if there are storageclasses
-    const storageClient = cluster.proxyKubeconfig().makeApiClient(k8s.StorageV1Api)
-    const scs = await storageClient.listStorageClass();
-    scs.body.items.forEach(sc => {
-      if(sc.metadata.annotations &&
+    (await cluster
+      .proxyKubeconfig()
+      .makeApiClient(k8s.StorageV1Api)
+      .listStorageClass()
+    )
+      .body
+      .items
+      .forEach(sc => {
+        if(sc.metadata.annotations &&
           (sc.metadata.annotations['storageclass.kubernetes.io/is-default-class'] === 'true' || sc.metadata.annotations['storageclass.beta.kubernetes.io/is-default-class'] === 'true')) {
-        this.config.persistence.enabled = true;
-      }
-    });
+          this.config.persistence.enabled = true;
+        }
+      });
 
-    return super.install(cluster)
+    return super.install(cluster);
   }
 
-  async upgrade(cluster: Cluster): Promise<boolean> {
+  async upgrade(cluster: Cluster): Promise<void> {
     return this.install(cluster)
   }
 
diff --git a/src/features/user-mode.ts b/src/features/user-mode.ts
index d1f1dcf381..fd4e33d77d 100644
--- a/src/features/user-mode.ts
+++ b/src/features/user-mode.ts
@@ -6,12 +6,12 @@ export class UserModeFeature extends Feature {
   name = 'user-mode';
   latestVersion = "v2.0.0"
 
-  async install(cluster: Cluster): Promise<boolean> {
+  async install(cluster: Cluster): Promise<void> {
     return super.install(cluster)
   }
 
-  async upgrade(cluster: Cluster): Promise<boolean> {
-    return true
+  async upgrade(cluster: Cluster): Promise<void> {
+    return;
   }
 
   async featureStatus(kc: KubeConfig): Promise<FeatureStatus> {
diff --git a/src/main/context-handler.ts b/src/main/context-handler.ts
index ad0bd85019..20656b3209 100644
--- a/src/main/context-handler.ts
+++ b/src/main/context-handler.ts
@@ -152,12 +152,8 @@ export class ContextHandler {
     return serverPort
   }
 
-  public async withTemporaryKubeconfig(callback: (kubeconfig: string) => Promise<any>) {
-    try {
-      await callback(this.cluster.proxyKubeconfigPath())
-    } catch (error) {
-      throw(error)
-    }
+  public applyHeaders(req: http.IncomingMessage) {
+    req.headers["authorization"] = `Bearer ${this.id}`
   }
 
   public async ensureServer() {
diff --git a/src/main/feature.ts b/src/main/feature.ts
index eece69d2b1..0e7933009d 100644
--- a/src/main/feature.ts
+++ b/src/main/feature.ts
@@ -29,26 +29,16 @@ export abstract class Feature {
     }
   }
 
-  // TODO Return types for these?
-  async install(cluster: Cluster): Promise<boolean> {
-    return new Promise<boolean>((resolve, reject) => {
-      // Read and process yamls through handlebar
-      const resources = this.renderTemplates();
-
-      // Apply processed manifests
-      cluster.contextHandler.withTemporaryKubeconfig(async (kubeconfigPath) => {
-        const resourceApplier = new ResourceApplier(cluster, kubeconfigPath)
-        try {
-          await resourceApplier.kubectlApplyAll(resources)
-          resolve(true)
-        } catch(error) {
-          reject(error)
-        }
-      });
-    });
+  async install(cluster: Cluster): Promise<void> {
+    // Read and process yamls through handlebar
+    const resources = this.renderTemplates();
+    const kubeconfigPath = cluster.kubeconfigPath();
+    const resourceApplier = new ResourceApplier(cluster, kubeconfigPath)
+    
+    await resourceApplier.kubectlApplyAll(resources)
   }
 
-  abstract async upgrade(cluster: Cluster): Promise<boolean>;
+  abstract async upgrade(cluster: Cluster): Promise<void>;
 
   abstract async uninstall(cluster: Cluster): Promise<boolean>;
 
diff --git a/src/main/proxy.ts b/src/main/proxy.ts
index 2fc28a0adc..f90776fff3 100644
--- a/src/main/proxy.ts
+++ b/src/main/proxy.ts
@@ -104,24 +104,28 @@ export class LensProxy {
   }
 
   protected createWsListener() {
-    const ws = new WebSocket.Server({ noServer: true })
-    ws.on("connection", ((con: WebSocket, req: http.IncomingMessage) => {
+    const ws = new WebSocket.Server({ noServer: true})
+    ws.on("connection", (async (con: WebSocket, req: http.IncomingMessage) => {
       const cluster = this.clusterManager.getClusterForRequest(req)
-      const contextHandler = cluster.contextHandler
-      const nodeParam = url.parse(req.url, true).query["node"]?.toString();
+      const nodeParam = this.getNodeParam(req.url)
 
-      contextHandler.withTemporaryKubeconfig((kubeconfigPath) => {
-        return new Promise<boolean>(async (resolve, reject) => {
-          const shellSession = await shell.open(con, kubeconfigPath, cluster, nodeParam)
-          shellSession.on("exit", () => {
-            resolve(true)
-          })
-        })
-      })
-    }))
+      try {
+        await shell.open(con, cluster.kubeConfigPath, cluster, nodeParam)
+      } catch (err) {
+        console.error(err);
+      }
+    }).bind(this))
     return ws
   }
 
+  protected getNodeParam(requestUrl: string) {
+    const [lastKey, lastValue] = Object.entries(url.parse(requestUrl, true).query)
+      .reverse()
+      .find(([key]) => key == "node");
+
+    return lastValue.toString();
+  }
+
   protected async getProxyTarget(req: http.IncomingMessage, contextHandler: ContextHandler): Promise<httpProxy.ServerOptions> {
     const prefix = apiPrefix.KUBE_BASE;
     if (req.url.startsWith(prefix)) {