part 1

Signed-off-by: Roman <ixrock@gmail.com>
Signed-off-by: Lauri Nevala <lauri.nevala@gmail.com>

src/common/cluster-store.ts

@@ -1,10 +1,8 @@
 import type { WorkspaceId } from "./workspace-store";
 import path from "path";
-import filenamify from "filenamify";
 import { app, ipcRenderer, remote } from "electron";
-import { copyFile, ensureDir, unlink } from "fs-extra";
+import { unlink } from "fs-extra";
 import { action, computed, observable, toJS } from "mobx";
-import { appProto, noClustersHost } from "./vars";
 import { BaseStore } from "./base-store";
 import { Cluster, ClusterState } from "../main/cluster";
 import migrations from "../migrations/cluster-store"
@@ -177,12 +175,11 @@ export class ClusterStore extends BaseStore<ClusterStoreModel> {
 
 export const clusterStore = ClusterStore.getInstance<ClusterStore>();
 
-export function isNoClustersView() {
-  return location.hostname === noClustersHost
-}
-
-export function getHostedClusterId() {
-  return location.hostname.split(".")[0];
+export function getHostedClusterId(): ClusterId {
+  const clusterHost = location.hostname.match(/^(.*?)\.localhost/);
+  if (clusterHost) {
+    return clusterHost[1]
+  }
 }
 
 export function getHostedCluster(): Cluster {

src/common/kube-helpers.ts

@@ -156,7 +156,7 @@ export function saveConfigToAppFiles(clusterId: string, kubeConfig: KubeConfig |
 
 export async function getKubeConfigLocal(): Promise<string> {
   try {
-    const configFile = path.join(process.env.HOME, '.kube', 'config');
+    const configFile = path.join(os.homedir(), '.kube', 'config');
     const file = await readFile(configFile, "utf8");
     const obj = yaml.safeLoad(file);
     if (obj.contexts) {

src/common/user-store.ts

@@ -71,11 +71,12 @@ export class UserStore extends BaseStore<UserStoreModel> {
     if (kubeConfig) {
       this.newContexts.clear();
       const localContexts = loadConfig(kubeConfig).getContexts();
-      console.log(localContexts)
-      localContexts
-        .filter(ctx => ctx.cluster)
-        .filter(ctx => !this.seenContexts.has(ctx.name))
-        .forEach(ctx => this.newContexts.add(ctx.name));
+      localContexts.forEach(({ cluster, name }) => {
+        if (!cluster) return;
+        if (!this.seenContexts.has(name)) {
+          this.newContexts.add(name)
+        }
+      })
     }
   }
 

src/common/vars.ts

@@ -10,8 +10,6 @@ export const isDevelopment = isDebugging || !isProduction;
 export const isTestEnv = !!process.env.JEST_WORKER_ID;
 
 export const appName = `${packageInfo.productName}${isDevelopment ? "Dev" : ""}`
-export const appProto = "lens"  // app.getPath("userData") folder
-export const staticProto = "static"  // static folder (e.g. "static://RELEASE_NOTES.md")
 
 // System paths
 export const contextDir = process.cwd();
@@ -22,9 +20,6 @@ export const rendererDir = path.join(contextDir, "src/renderer");
 export const htmlTemplate = path.resolve(rendererDir, "template.html");
 export const sassCommonVars = path.resolve(rendererDir, "components/vars.scss");
 
-// System pages
-export const noClustersHost = "no-clusters.localhost"
-
 // Apis
 export const apiPrefix = "/api" // local router apis
 export const apiKubePrefix = "/api-kube" // k8s cluster apis

src/common/workspace-store.ts

@@ -1,4 +1,4 @@
-import { action, computed, observable, toJS } from "mobx";
+import { action, computed, observable, reaction, toJS } from "mobx";
 import { BaseStore } from "./base-store";
 import { clusterStore } from "./cluster-store"
 
@@ -22,6 +22,15 @@ export class WorkspaceStore extends BaseStore<WorkspaceStoreModel> {
     super({
       configName: "lens-workspace-store",
     });
+
+    // switch to first available cluster in current workspace
+    reaction(() => this.currentWorkspaceId, workspaceId => {
+      const clusters = clusterStore.getByWorkspaceId(workspaceId);
+      const activeClusterInWorkspace = clusters.some(cluster => cluster.id === clusterStore.activeClusterId);
+      if (!activeClusterInWorkspace) {
+        clusterStore.activeClusterId = clusters.length ? clusters[0].id : null;
+      }
+    })
   }
 
   @observable currentWorkspaceId = WorkspaceStore.defaultId;

src/main/cluster-manager.ts

@@ -1,6 +1,5 @@
 import type http from "http"
 import { autorun } from "mobx";
-import { apiKubePrefix } from "../common/vars";
 import { ClusterId, clusterStore } from "../common/cluster-store"
 import { Cluster } from "./cluster"
 import { clusterIpc } from "../common/cluster-ipc";
@@ -50,23 +49,8 @@ export class ClusterManager {
   }
 
   getClusterForRequest(req: http.IncomingMessage): Cluster {
-    let cluster: Cluster = null
-
-    // lens-server is connecting to 127.0.0.1:<port>/<uid>
-    if (req.headers.host.startsWith("127.0.0.1")) {
-      const clusterId = req.url.split("/")[1]
-      if (clusterId) {
-        cluster = this.getCluster(clusterId)
-        if (cluster) {
-          // we need to swap path prefix so that request is proxied to kube api
-          req.url = req.url.replace(`/${clusterId}`, apiKubePrefix)
-        }
-      }
-    } else {
-      const id = req.headers.host.split(".")[0]
-      cluster = this.getCluster(id)
-    }
-
-    return cluster;
+    logger.info(`getClusterForRequest(): ${req.headers.host}${req.url}`)
+    const clusterId = req.headers.host.split(".")[0]
+    return this.getCluster(clusterId)
   }
 }

src/main/cluster.ts

@@ -1,7 +1,8 @@
 import type { ClusterId, ClusterModel, ClusterPreferences } from "../common/cluster-store"
-import type { FeatureStatusMap } from "./feature"
+import type { IMetricsReqParams } from "../renderer/api/endpoints/metrics.api";
 import type { WorkspaceId } from "../common/workspace-store";
-import { action, observable, reaction, toJS, when } from "mobx";
+import type { FeatureStatusMap } from "./feature"
+import { action, computed, observable, reaction, toJS, when } from "mobx";
 import { apiKubePrefix } from "../common/vars";
 import { broadcastIpc } from "../common/ipc";
 import { ContextHandler } from "./context-handler"
@@ -52,7 +53,6 @@ export class Cluster implements ClusterModel {
   @observable kubeConfigPath: string;
   @observable apiUrl: string; // cluster server url
   @observable kubeProxyUrl: string; // lens-proxy to kube-api url
-  @observable webContentUrl: string; // page content url for loading in renderer
   @observable online: boolean;
   @observable accessible: boolean;
   @observable disconnected: boolean;
@@ -67,6 +67,11 @@ export class Cluster implements ClusterModel {
   @observable allowedNamespaces: string[] = [];
   @observable allowedResources: string[] = [];
 
+  @computed get host() {
+    const proxyHost = new URL(this.kubeProxyUrl).host;
+    return `${this.id}.${proxyHost}`
+  }
+
   constructor(model: ClusterModel) {
     this.updateModel(model);
   }
@@ -80,20 +85,15 @@ export class Cluster implements ClusterModel {
 
   @action
   async init(port: number) {
-    if (this.initialized) {
-      return;
-    }
     try {
       this.contextHandler = new ContextHandler(this);
       this.kubeconfigManager = new KubeconfigManager(this, this.contextHandler);
       this.kubeProxyUrl = `http://localhost:${port}${apiKubePrefix}`;
-      this.webContentUrl = `http://${this.id}.localhost:${port}`;
       this.initialized = true;
-      logger.info(`[CLUSTER]: init success`, {
+      logger.info(`[CLUSTER]: "${this.contextName}" init success`, {
         id: this.id,
-        serverUrl: this.apiUrl,
-        webContentUrl: this.webContentUrl,
-        kubeProxyUrl: this.kubeProxyUrl,
+        context: this.contextName,
+        apiUrl: this.apiUrl
       });
     } catch (err) {
       logger.error(`[CLUSTER]: init failed: ${err}`, {
@@ -155,7 +155,7 @@ export class Cluster implements ClusterModel {
   @action
   async refresh() {
     logger.info(`[CLUSTER]: refresh`, this.getMeta());
-    await this.refreshConnectionStatus();
+    await this.refreshConnectionStatus(); // refresh "version", "online", etc.
     if (this.accessible) {
       this.kubeCtl = new Kubectl(this.version)
       this.distribution = this.detectKubernetesDistribution(this.version)
@@ -217,22 +217,28 @@ export class Cluster implements ClusterModel {
     return uninstallFeature(name, this)
   }
 
-  getPrometheusApiPrefix() {
-    return this.preferences.prometheus?.prefix || ""
-  }
-
-  protected async k8sRequest(path: string, options: RequestPromiseOptions = {}) {
+  protected async k8sRequest<T = any>(path: string, options: RequestPromiseOptions = {}): Promise<T> {
     const apiUrl = this.kubeProxyUrl + path;
     return request(apiUrl, {
       json: true,
       timeout: 5000,
       headers: {
+        Host: this.host, // provide cluster-id for ClusterManager.getClusterForRequest()
         ...(options.headers || {}),
-        Host: new URL(this.webContentUrl).host,
       },
     })
   }
 
+  getMetrics(prometheusPath: string, queryParams: IMetricsReqParams & { query: string }) {
+    const prometheusPrefix = this.preferences.prometheus?.prefix || "";
+    const metricsPath = `/api/v1/namespaces/${prometheusPath}/proxy${prometheusPrefix}/api/v1/query_range`;
+    return this.k8sRequest(metricsPath, {
+      resolveWithFullResponse: false,
+      json: true,
+      qs: queryParams,
+    })
+  }
+
   protected async getConnectionStatus(): Promise<ClusterStatus> {
     try {
       const response = await this.k8sRequest("/version")

src/main/index.ts

@@ -3,9 +3,8 @@
 import "../common/system-ca"
 import "../common/prometheus-providers"
 import { app, dialog } from "electron"
-import { appName, appProto, staticDir, staticProto } from "../common/vars";
+import { appName, staticDir } from "../common/vars";
 import path from "path"
-import { initMenu } from "./menu"
 import { LensProxy } from "./lens-proxy"
 import { WindowManager } from "./window-manager";
 import { ClusterManager } from "./cluster-manager";
@@ -41,8 +40,7 @@ async function main() {
   const updater = new AppUpdater()
   updater.start();
 
-  registerFileProtocol(appProto, app.getPath("userData"));
-  registerFileProtocol(staticProto, staticDir);
+  registerFileProtocol("static", staticDir);
 
   // find free port
   let proxyPort: number
@@ -74,7 +72,6 @@ async function main() {
 
   // create window manager and open app
   windowManager = new WindowManager(proxyPort);
-  initMenu(windowManager);
 }
 
 app.on("ready", main);

src/main/lens-proxy.ts

@@ -7,10 +7,11 @@ import { openShell } from "./node-shell-session";
 import { Router } from "./router"
 import { ClusterManager } from "./cluster-manager"
 import { ContextHandler } from "./context-handler";
-import { apiKubePrefix, noClustersHost } from "../common/vars";
+import { apiKubePrefix } from "../common/vars";
 import logger from "./logger"
 
 export class LensProxy {
+  protected origin: string
   protected proxyServer: http.Server
   protected router: Router
   protected closed = false
@@ -21,12 +22,13 @@ export class LensProxy {
   }
 
   private constructor(protected port: number, protected clusterManager: ClusterManager) {
+    this.origin = `http://localhost:${port}`
     this.router = new Router();
   }
 
   listen(port = this.port): this {
     this.proxyServer = this.buildCustomProxy().listen(port);
-    logger.info(`LensProxy server has started http://localhost:${port}`);
+    logger.info(`LensProxy server has started at ${this.origin}`);
     return this;
   }
 
@@ -117,26 +119,17 @@ export class LensProxy {
   }
 
   protected async handleRequest(proxy: httpProxy, req: http.IncomingMessage, res: http.ServerResponse) {
-    if (req.headers.host.split(":")[0] === noClustersHost) {
-      this.router.handleStaticFile(req.url, res);
-      return;
-    }
     const cluster = this.clusterManager.getClusterForRequest(req)
-    if (!cluster) {
-      const reqId = this.getRequestId(req);
-      logger.error("Got request to unknown cluster", { reqId })
-      res.statusCode = 503
-      res.end()
-      return
-    }
-    const contextHandler = cluster.contextHandler
-    await contextHandler.ensureServer();
-    const proxyTarget = await this.getProxyTarget(req, contextHandler)
-    if (proxyTarget) {
-      proxy.web(req, res, proxyTarget)
-    } else {
-      this.router.route(cluster, req, res);
+    if (cluster) {
+      await cluster.contextHandler.ensureServer();
+      const proxyTarget = await this.getProxyTarget(req, cluster.contextHandler)
+      if (proxyTarget) {
+        // allow to fetch apis in "clusterId.localhost:port" from "localhost:port"
+        res.setHeader("Access-Control-Allow-Origin", this.origin);
+        return proxy.web(req, res, proxyTarget);
+      }
     }
+    this.router.route(cluster, req, res);
   }
 
   protected async handleWsUpgrade(req: http.IncomingMessage, socket: net.Socket, head: Buffer) {

src/main/menu.ts

@@ -1,7 +1,6 @@
 import type { WindowManager } from "./window-manager";
 import { app, BrowserWindow, dialog, Menu, MenuItem, MenuItemConstructorOptions, shell, webContents } from "electron"
 import { autorun } from "mobx";
-import { broadcastIpc } from "../common/ipc";
 import { appName, isMac, issuesTrackerUrl, isWindows, slackUrl } from "../common/vars";
 import { clusterStore } from "../common/cluster-store";
 import { addClusterURL } from "../renderer/components/+add-cluster/add-cluster.route";
@@ -17,19 +16,7 @@ export function initMenu(windowManager: WindowManager) {
   });
 }
 
-function buildMenu(windowManager: WindowManager) {
-  const hasClusters = clusterStore.hasClusters();
-  const activeClusterId = clusterStore.activeClusterId;
-
-  function navigate(url: string) {
-    const clusterView = windowManager.getClusterView(activeClusterId);
-    broadcastIpc({
-      channel: "menu:navigate",
-      webContentId: clusterView ? clusterView.id : undefined /*no-clusters*/,
-      args: [url],
-    });
-  }
-
+export function buildMenu(windowManager: WindowManager) {
   function macOnly(menuItems: MenuItemConstructorOptions[]): MenuItemConstructorOptions[] {
     if (!isMac) return [];
     return menuItems;
@@ -41,20 +28,20 @@ function buildMenu(windowManager: WindowManager) {
       {
         label: 'Add Cluster',
         click() {
-          navigate(addClusterURL())
+          windowManager.navigateMain(addClusterURL())
         }
       },
-      ...(hasClusters ? [{
+      ...(clusterStore.activeCluster ? [{
         label: 'Cluster Settings',
         click() {
-          navigate(clusterSettingsURL())
+          windowManager.navigateMain(clusterSettingsURL())
         }
       }] : []),
       { type: 'separator' },
       {
         label: 'Preferences',
         click() {
-          navigate(preferencesURL())
+          windowManager.navigateMain(preferencesURL())
         }
       },
       ...macOnly([
@@ -125,7 +112,7 @@ function buildMenu(windowManager: WindowManager) {
       {
         label: "What's new?",
         click() {
-          navigate(whatsNewURL())
+          windowManager.navigateMain(whatsNewURL())
         },
       },
       {