Fix kubeconfig-sync issues (#2692)

- Removed `getFreePort` as its use is always a race condition. Change
  all uses of it to retrive the port after listening

- Added `getPortFrom` as a helper function to read a port from a stream

- Remove `Cluster.ownerRef` as it is outdated and no longer needed for 5.0

- Remove `Cluster.enabled`, no longer needed because of above

- Removed `Cluster.init`, moved its contents into `Cluster.constructor`
  as nothing in that function is asyncronous. Currently only being run
  on `main` as a stop gap until `renderer` gets its own version of
  `Cluster`

- Refactored `LensProxy` so as to prevent `pty.node` (a NodeJS
  extension) being included in `webpack.extension.ts`'s run

- Removed the passing around of the proxy port as that can now be
  accessed from an instance of `LensProxy`

- purge ContextHandler's cache on disconnect

Co-authored-by: Sebastian Malton <sebastian@malton.name>

src/main/proxy/index.ts

@@ -0,0 +1,2 @@
+// Don't export the contents here
+// It will break the extension webpack

src/main/proxy/lens-proxy.ts

@@ -0,0 +1,217 @@
+import net from "net";
+import http from "http";
+import spdy from "spdy";
+import httpProxy from "http-proxy";
+import url from "url";
+import { apiPrefix, apiKubePrefix } from "../../common/vars";
+import { Router } from "../router";
+import { ContextHandler } from "../context-handler";
+import logger from "../logger";
+import { Singleton } from "../../common/utils";
+import { ClusterManager } from "../cluster-manager";
+
+type WSUpgradeHandler = (req: http.IncomingMessage, socket: net.Socket, head: Buffer) => void;
+
+export class LensProxy extends Singleton {
+  protected origin: string;
+  protected proxyServer: http.Server;
+  protected router = new Router();
+  protected closed = false;
+  protected retryCounters = new Map<string, number>();
+
+  public port: number;
+
+  constructor(handleWsUpgrade: WSUpgradeHandler) {
+    super();
+
+    const proxy = this.createProxy();
+
+    this.proxyServer = spdy.createServer({
+      spdy: {
+        plain: true,
+        protocols: ["http/1.1", "spdy/3.1"]
+      }
+    }, (req: http.IncomingMessage, res: http.ServerResponse) => {
+      this.handleRequest(proxy, req, res);
+    });
+
+    this.proxyServer
+      .on("upgrade", (req: http.IncomingMessage, socket: net.Socket, head: Buffer) => {
+        if (req.url.startsWith(`${apiPrefix}?`)) {
+          handleWsUpgrade(req, socket, head);
+        } else {
+          this.handleProxyUpgrade(proxy, req, socket, head);
+        }
+      });
+  }
+
+  /**
+   * Starts the lens proxy.
+   * @resolves After the server is listening
+   * @rejects if there is an error before that happens
+   */
+  listen(): Promise<void> {
+    return new Promise<void>((resolve, reject) => {
+      this.proxyServer.listen(0, "127.0.0.1");
+
+      this.proxyServer
+        .once("listening", () => {
+          this.proxyServer.removeAllListeners("error"); // don't reject the promise
+
+          const { address, port } = this.proxyServer.address() as net.AddressInfo;
+
+          logger.info(`[LENS-PROXY]: Proxy server has started at ${address}:${port}`);
+
+          this.proxyServer.on("error", (error) => {
+            logger.info(`[LENS-PROXY]: Subsequent error: ${error}`);
+          });
+
+          this.port = port;
+          resolve();
+        })
+        .once("error", (error) => {
+          logger.info(`[LENS-PROXY]: Proxy server failed to start: ${error}`);
+          reject(error);
+        });
+    });
+  }
+
+  close() {
+    logger.info("Closing proxy server");
+    this.proxyServer.close();
+    this.closed = true;
+  }
+
+  protected async handleProxyUpgrade(proxy: httpProxy, req: http.IncomingMessage, socket: net.Socket, head: Buffer) {
+    const cluster = ClusterManager.getInstance().getClusterForRequest(req);
+
+    if (cluster) {
+      const proxyUrl = await cluster.contextHandler.resolveAuthProxyUrl() + req.url.replace(apiKubePrefix, "");
+      const apiUrl = url.parse(cluster.apiUrl);
+      const pUrl = url.parse(proxyUrl);
+      const connectOpts = { port: parseInt(pUrl.port), host: pUrl.hostname };
+      const proxySocket = new net.Socket();
+
+      proxySocket.connect(connectOpts, () => {
+        proxySocket.write(`${req.method} ${pUrl.path} HTTP/1.1\r\n`);
+        proxySocket.write(`Host: ${apiUrl.host}\r\n`);
+
+        for (let i = 0; i < req.rawHeaders.length; i += 2) {
+          const key = req.rawHeaders[i];
+
+          if (key !== "Host" && key !== "Authorization") {
+            proxySocket.write(`${req.rawHeaders[i]}: ${req.rawHeaders[i+1]}\r\n`);
+          }
+        }
+        proxySocket.write("\r\n");
+        proxySocket.write(head);
+      });
+
+      proxySocket.setKeepAlive(true);
+      socket.setKeepAlive(true);
+      proxySocket.setTimeout(0);
+      socket.setTimeout(0);
+
+      proxySocket.on("data", function (chunk) {
+        socket.write(chunk);
+      });
+      proxySocket.on("end", function () {
+        socket.end();
+      });
+      proxySocket.on("error", function () {
+        socket.write(`HTTP/${req.httpVersion} 500 Connection error\r\n\r\n`);
+        socket.end();
+      });
+      socket.on("data", function (chunk) {
+        proxySocket.write(chunk);
+      });
+      socket.on("end", function () {
+        proxySocket.end();
+      });
+      socket.on("error", function () {
+        proxySocket.end();
+      });
+    }
+  }
+
+  protected createProxy(): httpProxy {
+    const proxy = httpProxy.createProxyServer();
+
+    proxy.on("proxyRes", (proxyRes, req, res) => {
+      const retryCounterId = this.getRequestId(req);
+
+      if (this.retryCounters.has(retryCounterId)) {
+        this.retryCounters.delete(retryCounterId);
+      }
+
+      if (!res.headersSent && req.url) {
+        const url = new URL(req.url, "http://localhost");
+
+        if (url.searchParams.has("watch")) res.flushHeaders();
+      }
+    });
+
+    proxy.on("error", (error, req, res, target) => {
+      if (this.closed) {
+        return;
+      }
+
+      if (target) {
+        logger.debug(`Failed proxy to target: ${JSON.stringify(target, null, 2)}`);
+
+        if (req.method === "GET" && (!res.statusCode || res.statusCode >= 500)) {
+          const reqId = this.getRequestId(req);
+          const retryCount = this.retryCounters.get(reqId) || 0;
+          const timeoutMs = retryCount * 250;
+
+          if (retryCount < 20) {
+            logger.debug(`Retrying proxy request to url: ${reqId}`);
+            setTimeout(() => {
+              this.retryCounters.set(reqId, retryCount + 1);
+              this.handleRequest(proxy, req, res);
+            }, timeoutMs);
+          }
+        }
+      }
+
+      try {
+        res.writeHead(500).end("Oops, something went wrong.");
+      } catch (e) {
+        logger.error(`[LENS-PROXY]: Failed to write headers: `, e);
+      }
+    });
+
+    return proxy;
+  }
+
+  protected async getProxyTarget(req: http.IncomingMessage, contextHandler: ContextHandler): Promise<httpProxy.ServerOptions> {
+    if (req.url.startsWith(apiKubePrefix)) {
+      delete req.headers.authorization;
+      req.url = req.url.replace(apiKubePrefix, "");
+      const isWatchRequest = req.url.includes("watch=");
+
+      return await contextHandler.getApiTarget(isWatchRequest);
+    }
+  }
+
+  protected getRequestId(req: http.IncomingMessage) {
+    return req.headers.host + req.url;
+  }
+
+  protected async handleRequest(proxy: httpProxy, req: http.IncomingMessage, res: http.ServerResponse) {
+    const cluster = ClusterManager.getInstance().getClusterForRequest(req);
+
+    if (cluster) {
+      const proxyTarget = await this.getProxyTarget(req, cluster.contextHandler);
+
+      if (proxyTarget) {
+        // allow to fetch apis in "clusterId.localhost:port" from "localhost:port"
+        // this should be safe because we have already validated cluster uuid
+        res.setHeader("Access-Control-Allow-Origin", "*");
+
+        return proxy.web(req, res, proxyTarget);
+      }
+    }
+    this.router.route(cluster, req, res);
+  }
+}

src/main/proxy/ws-upgrade.ts

@@ -0,0 +1,36 @@
+/**
+ * This file is here so that the "../shell-session" import can be injected into
+ * LensProxy at creation time. So that the `pty.node` extension isn't loaded
+ * into Lens Extension webpack bundle.
+ */
+
+import * as WebSocket from "ws";
+import http from "http";
+import net from "net";
+import url from "url";
+import { NodeShellSession, LocalShellSession } from "../shell-session";
+import { ClusterManager } from "../cluster-manager";
+import logger from "../logger";
+
+function createWsListener(): WebSocket.Server {
+  const ws = new WebSocket.Server({ noServer: true });
+
+  return ws.on("connection", ((socket: WebSocket, req: http.IncomingMessage) => {
+    const cluster = ClusterManager.getInstance().getClusterForRequest(req);
+    const nodeParam = url.parse(req.url, true).query["node"]?.toString();
+    const shell = nodeParam
+      ? new NodeShellSession(socket, cluster, nodeParam)
+      : new LocalShellSession(socket, cluster);
+
+    shell.open()
+      .catch(error => logger.error(`[SHELL-SESSION]: failed to open: ${error}`, { error }));
+  }));
+}
+
+export async function handleWsUpgrade(req: http.IncomingMessage, socket: net.Socket, head: Buffer) {
+  const wsServer = createWsListener();
+
+  wsServer.handleUpgrade(req, socket, head, (con) => {
+    wsServer.emit("connection", con, req);
+  });
+}