Fixing Singleton typing to correctly return child class (#1914)

- Add distinction between `getInstance` and `getInstanceOrCreate` since
  it is not always possible to create an instance (since you might not
  know the correct arguments)

- Remove all the `export const *Store = *Store.getInstance<*Store>();`
  calls as it defeats the purpose of `Singleton`. Plus with the typing
  changes the appropriate `*Store.getInstance()` is "short enough".

- Special case the two extension export facades to not need to use
  `getInstanceOrCreate`. Plus since they are just facades it is always
  possible to create them.

- Move some other types to be also `Singleton`'s: ExtensionLoader,
  ExtensionDiscovery, ThemeStore, LocalizationStore, ...

- Fixed dev-run always using the same port with electron inspect

- Update Store documentation with new recommendations about creating
  instances of singletons

- Fix all unit tests to create their dependent singletons

Signed-off-by: Sebastian Malton <sebastian@malton.name>

src/main/helm/__tests__/helm-service.test.ts

@@ -1,17 +1,24 @@
 import { helmService } from "../helm-service";
-import { repoManager } from "../helm-repo-manager";
+import { HelmRepoManager } from "../helm-repo-manager";
 
-jest.spyOn(repoManager, "init").mockImplementation();
+const mockHelmRepoManager = jest.spyOn(HelmRepoManager, "getInstance").mockImplementation();
 
 jest.mock("../helm-chart-manager");
 
 describe("Helm Service tests", () => {
-  test("list charts without deprecated ones", async () => {
-    jest.spyOn(repoManager, "repositories").mockImplementation(async () => {
-      return [
-        { name: "stable", url: "stableurl" },
-        { name: "experiment", url: "experimenturl" }
-      ];
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  it("list charts without deprecated ones", async () => {
+    mockHelmRepoManager.mockReturnValue({
+      init: jest.fn(),
+      repositories: jest.fn().mockImplementation(async () => {
+        return [
+          { name: "stable", url: "stableurl" },
+          { name: "experiment", url: "experimenturl" },
+        ];
+      }),
     });
 
     const charts = await helmService.listCharts();
@@ -55,11 +62,14 @@ describe("Helm Service tests", () => {
     });
   });
 
-  test("list charts sorted by version in descending order", async () => {
-    jest.spyOn(repoManager, "repositories").mockImplementation(async () => {
-      return [
-        { name: "bitnami", url: "bitnamiurl" }
-      ];
+  it("list charts sorted by version in descending order", async () => {
+    mockHelmRepoManager.mockReturnValue({
+      init: jest.fn(),
+      repositories: jest.fn().mockImplementation(async () => {
+        return [
+          { name: "bitnami", url: "bitnamiurl" },
+        ];
+      }),
     });
 
     const charts = await helmService.listCharts();

src/main/helm/helm-release-manager.ts

@@ -1,17 +1,17 @@
 import * as tempy from "tempy";
-import fs from "fs";
+import fse from "fs-extra";
 import * as yaml from "js-yaml";
 import { promiseExec} from "../promise-exec";
 import { helmCli } from "./helm-cli";
 import { Cluster } from "../cluster";
 import { toCamelCase } from "../../common/utils/camelCase";
 
-export class HelmReleaseManager {
+export async function listReleases(pathToKubeconfig: string, namespace?: string) {
+  const helm = await helmCli.binaryPath();
+  const namespaceFlag = namespace ? `-n ${namespace}` : "--all-namespaces";
 
-  public async listReleases(pathToKubeconfig: string, namespace?: string) {
-    const helm = await helmCli.binaryPath();
-    const namespaceFlag = namespace ? `-n ${namespace}` : "--all-namespaces";
-    const { stdout } = await promiseExec(`"${helm}" ls --output json ${namespaceFlag} --kubeconfig ${pathToKubeconfig}`).catch((error) => { throw(error.stderr);});
+  try {
+    const { stdout } = await promiseExec(`"${helm}" ls --output json ${namespaceFlag} --kubeconfig ${pathToKubeconfig}`);
     const output = JSON.parse(stdout);
 
     if (output.length == 0) {
@@ -22,106 +22,132 @@ export class HelmReleaseManager {
     });
 
     return output;
-  }
-
-
-  public async installChart(chart: string, values: any, name: string, namespace: string, version: string, pathToKubeconfig: string){
-    const helm = await helmCli.binaryPath();
-    const fileName = tempy.file({name: "values.yaml"});
-
-    await fs.promises.writeFile(fileName, yaml.safeDump(values));
-
-    try {
-      let generateName = "";
-
-      if (!name) {
-        generateName = "--generate-name";
-        name = "";
-      }
-      const { stdout } = await promiseExec(`"${helm}" install ${name} ${chart} --version ${version} -f ${fileName} --namespace ${namespace} --kubeconfig ${pathToKubeconfig} ${generateName}`).catch((error) => { throw(error.stderr);});
-      const releaseName = stdout.split("\n")[0].split(" ")[1].trim();
-
-      return {
-        log: stdout,
-        release: {
-          name: releaseName,
-          namespace
-        }
-      };
-    } finally {
-      await fs.promises.unlink(fileName);
-    }
-  }
-
-  public async upgradeRelease(name: string, chart: string, values: any, namespace: string, version: string, cluster: Cluster){
-    const helm = await helmCli.binaryPath();
-    const fileName = tempy.file({name: "values.yaml"});
-    const proxyKubeconfig = await cluster.getProxyKubeconfigPath();
-
-    await fs.promises.writeFile(fileName, yaml.safeDump(values));
-
-    try {
-      const { stdout } = await promiseExec(`"${helm}" upgrade ${name} ${chart} --version ${version} -f ${fileName} --namespace ${namespace} --kubeconfig ${proxyKubeconfig}`).catch((error) => { throw(error.stderr);});
-
-      return {
-        log: stdout,
-        release: this.getRelease(name, namespace, cluster)
-      };
-    } finally {
-      await fs.promises.unlink(fileName);
-    }
-  }
-
-  public async getRelease(name: string, namespace: string, cluster: Cluster) {
-    const helm = await helmCli.binaryPath();
-    const proxyKubeconfig = await cluster.getProxyKubeconfigPath();
-
-    const { stdout } = await promiseExec(`"${helm}" status ${name} --output json --namespace ${namespace} --kubeconfig ${proxyKubeconfig}`).catch((error) => { throw(error.stderr);});
-    const release = JSON.parse(stdout);
-
-    release.resources = await this.getResources(name, namespace, cluster);
-
-    return release;
-  }
-
-  public async deleteRelease(name: string, namespace: string, pathToKubeconfig: string) {
-    const helm = await helmCli.binaryPath();
-    const { stdout  } = await promiseExec(`"${helm}" delete ${name} --namespace ${namespace} --kubeconfig ${pathToKubeconfig}`).catch((error) => { throw(error.stderr);});
-
-    return stdout;
-  }
-
-  public async getValues(name: string, namespace: string, all: boolean, pathToKubeconfig: string) {
-    const helm = await helmCli.binaryPath();
-    const { stdout,  } = await promiseExec(`"${helm}" get values ${name} ${all? "--all": ""} --output yaml --namespace ${namespace} --kubeconfig ${pathToKubeconfig}`).catch((error) => { throw(error.stderr);});
-
-    return stdout;
-  }
-
-  public async getHistory(name: string, namespace: string, pathToKubeconfig: string) {
-    const helm = await helmCli.binaryPath();
-    const { stdout } = await promiseExec(`"${helm}" history ${name} --output json --namespace ${namespace} --kubeconfig ${pathToKubeconfig}`).catch((error) => { throw(error.stderr);});
-
-    return JSON.parse(stdout);
-  }
-
-  public async rollback(name: string, namespace: string, revision: number, pathToKubeconfig: string) {
-    const helm = await helmCli.binaryPath();
-    const { stdout } = await promiseExec(`"${helm}" rollback ${name} ${revision} --namespace ${namespace} --kubeconfig ${pathToKubeconfig}`).catch((error) => { throw(error.stderr);});
-
-    return stdout;
-  }
-
-  protected async getResources(name: string, namespace: string, cluster: Cluster) {
-    const helm = await helmCli.binaryPath();
-    const kubectl = await cluster.kubeCtl.getPath();
-    const pathToKubeconfig = await cluster.getProxyKubeconfigPath();
-    const { stdout } = await promiseExec(`"${helm}" get manifest ${name} --namespace ${namespace} --kubeconfig ${pathToKubeconfig} | "${kubectl}" get -n ${namespace} --kubeconfig ${pathToKubeconfig} -f - -o=json`).catch(() => {
-      return { stdout: JSON.stringify({items: []})};
-    });
-
-    return stdout;
+  } catch ({ stderr }) {
+    throw stderr;
   }
 }
 
-export const releaseManager = new HelmReleaseManager();
+
+export async function installChart(chart: string, values: any, name: string | undefined, namespace: string, version: string, pathToKubeconfig: string){
+  const helm = await helmCli.binaryPath();
+  const fileName = tempy.file({name: "values.yaml"});
+
+  await fse.writeFile(fileName, yaml.safeDump(values));
+
+  try {
+    let generateName = "";
+
+    if (!name) {
+      generateName = "--generate-name";
+      name = "";
+    }
+    const { stdout } = await promiseExec(`"${helm}" install ${name} ${chart} --version ${version} -f ${fileName} --namespace ${namespace} --kubeconfig ${pathToKubeconfig} ${generateName}`);
+    const releaseName = stdout.split("\n")[0].split(" ")[1].trim();
+
+    return {
+      log: stdout,
+      release: {
+        name: releaseName,
+        namespace
+      }
+    };
+  } catch ({ stderr }) {
+    throw stderr;
+  } finally {
+    await fse.unlink(fileName);
+  }
+}
+
+export async function upgradeRelease(name: string, chart: string, values: any, namespace: string, version: string, cluster: Cluster) {
+  const helm = await helmCli.binaryPath();
+  const fileName = tempy.file({name: "values.yaml"});
+
+  await fse.writeFile(fileName, yaml.safeDump(values));
+
+  try {
+    const proxyKubeconfig = await cluster.getProxyKubeconfigPath();
+    const { stdout } = await promiseExec(`"${helm}" upgrade ${name} ${chart} --version ${version} -f ${fileName} --namespace ${namespace} --kubeconfig ${proxyKubeconfig}`);
+
+    return {
+      log: stdout,
+      release: getRelease(name, namespace, cluster)
+    };
+  } catch ({ stderr }) {
+    throw stderr;
+  } finally {
+    await fse.unlink(fileName);
+  }
+}
+
+export async function getRelease(name: string, namespace: string, cluster: Cluster) {
+  try {
+    const helm = await helmCli.binaryPath();
+    const proxyKubeconfig = await cluster.getProxyKubeconfigPath();
+
+    const { stdout } = await promiseExec(`"${helm}" status ${name} --output json --namespace ${namespace} --kubeconfig ${proxyKubeconfig}`);
+    const release = JSON.parse(stdout);
+
+    release.resources = await getResources(name, namespace, cluster);
+
+    return release;
+  } catch ({ stderr }) {
+    throw stderr;
+  }
+}
+
+export async function deleteRelease(name: string, namespace: string, pathToKubeconfig: string) {
+  try {
+    const helm = await helmCli.binaryPath();
+    const { stdout  } = await promiseExec(`"${helm}" delete ${name} --namespace ${namespace} --kubeconfig ${pathToKubeconfig}`);
+
+    return stdout;
+  } catch ({ stderr }) {
+    throw stderr;
+  }
+}
+
+export async function getValues(name: string, namespace: string, all: boolean, pathToKubeconfig: string) {
+  try {
+    const helm = await helmCli.binaryPath();
+    const { stdout,  } = await promiseExec(`"${helm}" get values ${name} ${all ? "--all": ""} --output yaml --namespace ${namespace} --kubeconfig ${pathToKubeconfig}`);
+
+    return stdout;
+  } catch ({ stderr }) {
+    throw stderr;
+  }
+}
+
+export async function getHistory(name: string, namespace: string, pathToKubeconfig: string) {
+  try {
+    const helm = await helmCli.binaryPath();
+    const { stdout } = await promiseExec(`"${helm}" history ${name} --output json --namespace ${namespace} --kubeconfig ${pathToKubeconfig}`);
+
+    return JSON.parse(stdout);
+  } catch ({ stderr }) {
+    throw stderr;
+  }
+}
+
+export async function rollback(name: string, namespace: string, revision: number, pathToKubeconfig: string) {
+  try {
+    const helm = await helmCli.binaryPath();
+    const { stdout } = await promiseExec(`"${helm}" rollback ${name} ${revision} --namespace ${namespace} --kubeconfig ${pathToKubeconfig}`);
+
+    return stdout;
+  } catch ({ stderr }) {
+    throw stderr;
+  }
+}
+
+async function getResources(name: string, namespace: string, cluster: Cluster) {
+  try {
+    const helm = await helmCli.binaryPath();
+    const kubectl = await cluster.kubeCtl.getPath();
+    const pathToKubeconfig = await cluster.getProxyKubeconfigPath();
+    const { stdout } = await promiseExec(`"${helm}" get manifest ${name} --namespace ${namespace} --kubeconfig ${pathToKubeconfig} | "${kubectl}" get -n ${namespace} --kubeconfig ${pathToKubeconfig} -f - -o=json`);
+
+    return stdout;
+  } catch {
+    return { stdout: JSON.stringify({ items: [] }) };
+  }
+}

src/main/helm/helm-repo-manager.ts

@@ -77,10 +77,6 @@ export class HelmRepoManager extends Singleton {
   }
 
   public async repositories(): Promise<HelmRepo[]> {
-    if (!this.initialized) {
-      await this.init();
-    }
-
     try {
       const repoConfigFile = this.helmEnv.HELM_REPOSITORY_CONFIG;
       const { repositories }: HelmRepoConfig = await readFile(repoConfigFile, "utf8")
@@ -160,5 +156,3 @@ export class HelmRepoManager extends Singleton {
     return stdout;
   }
 }
-
-export const repoManager = HelmRepoManager.getInstance<HelmRepoManager>();

src/main/helm/helm-service.ts

@@ -1,23 +1,21 @@
 import semver from "semver";
 import { Cluster } from "../cluster";
 import logger from "../logger";
-import { repoManager } from "./helm-repo-manager";
+import { HelmRepoManager } from "./helm-repo-manager";
 import { HelmChartManager } from "./helm-chart-manager";
-import { releaseManager } from "./helm-release-manager";
 import { HelmChartList, RepoHelmChartList } from "../../renderer/api/endpoints/helm-charts.api";
+import { deleteRelease, getHistory, getRelease, getValues, installChart, listReleases, rollback, upgradeRelease } from "./helm-release-manager";
 
 class HelmService {
   public async installChart(cluster: Cluster, data: { chart: string; values: {}; name: string; namespace: string; version: string }) {
     const proxyKubeconfig = await cluster.getProxyKubeconfigPath();
 
-    return await releaseManager.installChart(data.chart, data.values, data.name, data.namespace, data.version, proxyKubeconfig);
+    return installChart(data.chart, data.values, data.name, data.namespace, data.version, proxyKubeconfig);
   }
 
   public async listCharts() {
     const charts: HelmChartList = {};
-
-    await repoManager.init();
-    const repositories = await repoManager.repositories();
+    const repositories = await HelmRepoManager.getInstance().repositories();
 
     for (const repo of repositories) {
       charts[repo.name] = {};
@@ -36,7 +34,7 @@ class HelmService {
       readme: "",
       versions: {}
     };
-    const repo = await repoManager.repository(repoName);
+    const repo = await HelmRepoManager.getInstance().repository(repoName);
     const chartManager = new HelmChartManager(repo);
     const chart = await chartManager.chart(chartName);
 
@@ -47,23 +45,22 @@ class HelmService {
   }
 
   public async getChartValues(repoName: string, chartName: string, version = "") {
-    const repo = await repoManager.repository(repoName);
+    const repo = await HelmRepoManager.getInstance().repository(repoName);
     const chartManager = new HelmChartManager(repo);
 
     return chartManager.getValues(chartName, version);
   }
 
   public async listReleases(cluster: Cluster, namespace: string = null) {
-    await repoManager.init();
     const proxyKubeconfig = await cluster.getProxyKubeconfigPath();
 
-    return await releaseManager.listReleases(proxyKubeconfig, namespace);
+    return listReleases(proxyKubeconfig, namespace);
   }
 
   public async getRelease(cluster: Cluster, releaseName: string, namespace: string) {
     logger.debug("Fetch release");
 
-    return await releaseManager.getRelease(releaseName, namespace, cluster);
+    return getRelease(releaseName, namespace, cluster);
   }
 
   public async getReleaseValues(cluster: Cluster, releaseName: string, namespace: string, all: boolean) {
@@ -71,7 +68,7 @@ class HelmService {
 
     logger.debug("Fetch release values");
 
-    return await releaseManager.getValues(releaseName, namespace, all, proxyKubeconfig);
+    return getValues(releaseName, namespace, all, proxyKubeconfig);
   }
 
   public async getReleaseHistory(cluster: Cluster, releaseName: string, namespace: string) {
@@ -79,7 +76,7 @@ class HelmService {
 
     logger.debug("Fetch release history");
 
-    return await releaseManager.getHistory(releaseName, namespace, proxyKubeconfig);
+    return getHistory(releaseName, namespace, proxyKubeconfig);
   }
 
   public async deleteRelease(cluster: Cluster, releaseName: string, namespace: string) {
@@ -87,20 +84,20 @@ class HelmService {
 
     logger.debug("Delete release");
 
-    return await releaseManager.deleteRelease(releaseName, namespace, proxyKubeconfig);
+    return deleteRelease(releaseName, namespace, proxyKubeconfig);
   }
 
   public async updateRelease(cluster: Cluster, releaseName: string, namespace: string, data: { chart: string; values: {}; version: string }) {
     logger.debug("Upgrade release");
 
-    return await releaseManager.upgradeRelease(releaseName, data.chart, data.values, namespace, data.version, cluster);
+    return upgradeRelease(releaseName, data.chart, data.values, namespace, data.version, cluster);
   }
 
   public async rollback(cluster: Cluster, releaseName: string, namespace: string, revision: number) {
     const proxyKubeconfig = await cluster.getProxyKubeconfigPath();
 
     logger.debug("Rollback release");
-    const output = await releaseManager.rollback(releaseName, namespace, revision, proxyKubeconfig);
+    const output = rollback(releaseName, namespace, revision, proxyKubeconfig);
 
     return { message: output };
   }