Merge branch 'master' into extensions-api

# Conflicts:
#	package.json
#	src/common/cluster-store.ts
#	src/renderer/bootstrap.tsx
#	src/renderer/components/cluster-manager/clusters-menu.tsx
#	static/RELEASE_NOTES.md
#	webpack.dll.ts

src/common/cluster-ipc.ts

@@ -3,21 +3,14 @@ import { ClusterId, clusterStore } from "./cluster-store";
 import { tracker } from "./tracker";
 
 export const clusterIpc = {
-  initView: createIpcChannel({
-    channel: "cluster:init",
-    handle: async (clusterId: ClusterId, frameId: number) => {
-      const cluster = clusterStore.getById(clusterId);
-      if (cluster) {
-        cluster.frameId = frameId; // save cluster's webFrame.routingId to be able to send push-updates
-        return cluster.pushState();
-      }
-    },
-  }),
-
   activate: createIpcChannel({
     channel: "cluster:activate",
-    handle: (clusterId: ClusterId) => {
-      return clusterStore.getById(clusterId)?.activate();
+    handle: (clusterId: ClusterId, frameId?: number) => {
+      const cluster = clusterStore.getById(clusterId);
+      if (cluster) {
+        if (frameId) cluster.frameId = frameId; // save cluster's webFrame.routingId to be able to send push-updates
+        return cluster.activate(true);
+      }
     },
   }),
 

src/common/cluster-store.ts

@@ -209,11 +209,17 @@ export class ClusterStore extends BaseStore<ClusterStoreModel> {
 
 export const clusterStore = ClusterStore.getInstance<ClusterStore>();
 
-export function getHostedClusterId(): ClusterId {
-  const clusterHost = location.hostname.match(/^(.*?)\.localhost/);
-  if (clusterHost) {
-    return clusterHost[1]
-  }
+export function getClusterIdFromHost(hostname: string): ClusterId {
+  const subDomains = hostname.split(":")[0].split(".");
+  return subDomains.slice(-2)[0]; // e.g host == "%clusterId.localhost:45345"
+}
+
+export function getClusterFrameUrl(clusterId: ClusterId) {
+  return `//${clusterId}.${location.host}`;
+}
+
+export function getHostedClusterId() {
+  return getClusterIdFromHost(location.hostname);
 }
 
 export function getHostedCluster(): Cluster {

src/common/cluster-store_test.ts

@@ -31,9 +31,10 @@ describe("empty config", () => {
   it("adds new cluster to store", async () => {
     const cluster = new Cluster({
       id: "foo",
+      contextName: "minikube",
       preferences: {
         terminalCWD: "/tmp",
-        icon: "data:image/jpeg;base64, iVBORw0KGgoAAAANSUhEUgAAA1wAAAKoCAYAAABjkf5",
+        icon: "data:;base64,iVBORw0KGgoAAAANSUhEUgAAA1wAAAKoCAYAAABjkf5",
         clusterName: "minikube"
       },
       kubeConfigPath: ClusterStore.embedCustomKubeConfig("foo", "fancy foo config"),
@@ -54,6 +55,7 @@ describe("empty config", () => {
   it("check if store can contain multiple clusters", () => {
     const prodCluster = new Cluster({
       id: "prod",
+      contextName: "prod",
       preferences: {
         clusterName: "prod"
       },
@@ -62,6 +64,7 @@ describe("empty config", () => {
     });
     const devCluster = new Cluster({
       id: "dev",
+      contextName: "dev",
       preferences: {
         clusterName: "dev"
       },
@@ -142,11 +145,13 @@ describe("config with existing clusters", () => {
             {
               id: 'cluster1',
               kubeConfig: 'foo',
+              contextName: 'foo',
               preferences: { terminalCWD: '/foo' }
             },
             {
               id: 'cluster2',
               kubeConfig: 'foo2',
+              contextName: 'foo2',
               preferences: { terminalCWD: '/foo2' }
             }
           ]
@@ -285,7 +290,7 @@ describe("pre 2.6.0 config with a cluster icon", () => {
     const storedClusterData = clusterStore.clustersList[0];
     expect(storedClusterData.hasOwnProperty('icon')).toBe(false);
     expect(storedClusterData.preferences.hasOwnProperty('icon')).toBe(true);
-    expect(storedClusterData.preferences.icon.startsWith("data:image/jpeg;base64,")).toBe(true);
+    expect(storedClusterData.preferences.icon.startsWith("data:;base64,")).toBe(true);
   })
 })
 
@@ -339,6 +344,7 @@ describe("pre 3.6.0-beta.1 config with an existing cluster", () => {
             {
               id: 'cluster1',
               kubeConfig: 'kubeconfig content',
+              contextName: 'cluster',
               preferences: {
                 icon: "store://icon_path",
               }
@@ -364,6 +370,6 @@ describe("pre 3.6.0-beta.1 config with an existing cluster", () => {
 
   it("migrates to modern format with icon not in file", async () => {
     const { icon } = clusterStore.clustersList[0].preferences;
-    expect(icon.startsWith("data:image/jpeg;base64, ")).toBe(true);
+    expect(icon.startsWith("data:;base64,")).toBe(true);
   })
-})
+})

src/common/workspace-store.ts

@@ -51,6 +51,10 @@ export class WorkspaceStore extends BaseStore<WorkspaceStoreModel> {
     return this.workspaces.get(id);
   }
 
+  getByName(name: string): Workspace {
+    return this.workspacesList.find(workspace => workspace.name === name);
+  }
+
   @action
   setActive(id = WorkspaceStore.defaultId, { redirectToLanding = true, resetActiveCluster = true } = {}) {
     if (id === this.currentWorkspaceId) return;
@@ -68,13 +72,16 @@ export class WorkspaceStore extends BaseStore<WorkspaceStoreModel> {
 
   @action
   saveWorkspace(workspace: Workspace) {
-    const id = workspace.id;
+    const { id, name } = workspace;
     const existingWorkspace = this.getById(id);
+    if (!name.trim() || this.getByName(name.trim())) {
+      return;
+    }
     if (existingWorkspace) {
       Object.assign(existingWorkspace, workspace);
-    } else {
-      this.workspaces.set(id, workspace);
     }
+    this.workspaces.set(id, workspace);
+    return workspace;
   }
 
   @action

src/common/workspace-store_test.ts

@@ -92,6 +92,50 @@ describe("workspace store tests", () => {
 
       expect(ws.workspaces.size).toBe(2);
     })
+
+    it("cannot create workspace with existent name", () => {
+      const ws = WorkspaceStore.getInstance<WorkspaceStore>();
+
+      ws.saveWorkspace({
+        id: "someid",
+        name: "default",
+      });
+
+      expect(ws.workspacesList.length).toBe(1);  // default workspace only
+    })
+
+    it("cannot create workspace with empty name", () => {
+      const ws = WorkspaceStore.getInstance<WorkspaceStore>();
+
+      ws.saveWorkspace({
+        id: "random",
+        name: "",
+      });
+
+      expect(ws.workspacesList.length).toBe(1);  // default workspace only
+    })
+
+    it("cannot create workspace with ' ' name", () => {
+      const ws = WorkspaceStore.getInstance<WorkspaceStore>();
+
+      ws.saveWorkspace({
+        id: "random",
+        name: " ",
+      });
+
+      expect(ws.workspacesList.length).toBe(1);  // default workspace only
+    })
+
+    it("trim workspace name", () => {
+      const ws = WorkspaceStore.getInstance<WorkspaceStore>();
+
+      ws.saveWorkspace({
+        id: "random",
+        name: "default ",
+      });
+
+      expect(ws.workspacesList.length).toBe(1);  // default workspace only
+    })
   })
 
   describe("for a non-empty config", () => {