@catladder/cli 0.0.0-test3 → 0.0.0-yarnrc-support-bdbef31f

package/src/apps/{shell → cli}/commands/project/commandOpenGrafana.ts

@@ -8,18 +8,18 @@ import {
 
 import { getProjectNamespace } from "../../../../utils/projects";
 
-import { envAutocompletion } from "./utils/autocompletions";
+import { envAndComponents } from "./utils/autocompletions";
 import ensureCluster from "./utils/ensureCluster";
-export default (vorpal: Vorpal) =>
+export default async (vorpal: Vorpal) =>
   vorpal
     .command(
-      "project-open-grafana <env>",
+      "project-open-grafana <envComponent>",
       "open Grafana dashboard for your namespace"
     )
-    .autocomplete(envAutocompletion)
-    .action(async function ({ env }) {
-      await ensureCluster.call(this);
-      const namespace = await getProjectNamespace(env);
+    .autocomplete(await envAndComponents())
+    .action(async function ({ envComponent }) {
+      await ensureCluster.call(this, envComponent);
+      const namespace = await getProjectNamespace(envComponent);
       const url = `http://localhost:${GRAFANA_PROXY_LOCAL_PORT}/grafana/d/at-cost-analysis-namespace2/namespace-utilization-metrics?var-namespace=${namespace}`;
       await startPortForward(
         "deployment/kubecost-cost-analyzer",

package/src/apps/{shell → cli}/commands/project/commandOpenGrafanaPod.ts

@@ -6,24 +6,23 @@ import {
 } from "../../../../config/constants";
 import { logError } from "../../../../utils/log";
 import { startPortForward } from "../../../../utils/portForward";
-
 import {
   getProjectNamespace,
   getProjectPodNames,
 } from "../../../../utils/projects";
-
-import { envAutocompletion } from "./utils/autocompletions";
+import { envAndComponents } from "./utils/autocompletions";
 import ensureCluster from "./utils/ensureCluster";
-export default (vorpal: Vorpal) =>
+
+export default async (vorpal: Vorpal) =>
   vorpal
     .command(
-      "project-open-grafana-pod <env>",
+      "project-open-grafana-pod <envComponent>",
       "open Grafana dashboard for a specific pod"
     )
-    .autocomplete(envAutocompletion)
-    .action(async function ({ env }) {
-      await ensureCluster.call(this);
-      const podNames = await getProjectPodNames(env);
+    .autocomplete(await envAndComponents())
+    .action(async function ({ envComponent }) {
+      await ensureCluster.call(this, envComponent);
+      const podNames = await getProjectPodNames(envComponent);
       if (podNames.length === 0) {
         logError(this, "sorry, no pods found");
         return;
@@ -34,7 +33,7 @@ export default (vorpal: Vorpal) =>
         choices: podNames,
         message: "Which pod? 🤔",
       });
-      const namespace = await getProjectNamespace(env);
+      const namespace = await getProjectNamespace(envComponent);
       const url = `http://localhost:${GRAFANA_PROXY_LOCAL_PORT}/grafana/d/at-cost-analysis-pod/pod-cost-and-utilization-metrics?var-namespace=${namespace}&var-pod=${podName}`;
       await startPortForward(
         "deployment/kubecost-cost-analyzer",

package/src/apps/cli/commands/project/commandOpenLogs.ts

@@ -0,0 +1,52 @@
+import Vorpal from "vorpal";
+import {
+  getPipelineContextByChoice,
+  parseChoice,
+} from "../../../../config/getProjectConfig";
+import { getCurrentConnectedClusterName } from "../../../../utils/cluster";
+import { getProjectNamespace } from "../../../../utils/projects";
+import { getGoogleAuthUserNumber } from "../../utils/getGoogleAuthUserNumber";
+import { openGoogleCloudLogs } from "../shared";
+import { envAndComponents } from "./utils/autocompletions";
+import ensureCluster from "./utils/ensureCluster";
+
+export default async (vorpal: Vorpal) =>
+  vorpal
+    .command(
+      "project-open-logs <envComponent>",
+      "open google cloud logs (stackdriver logs)"
+    )
+    .autocomplete(await envAndComponents())
+    .action(async function ({ envComponent }) {
+      const { env, componentName } = parseChoice(envComponent);
+      const { componentConfig, environment } = await getPipelineContextByChoice(
+        env,
+        componentName
+      );
+
+      if (
+        !componentConfig.deploy ||
+        componentConfig.deploy.type !== "kubernetes"
+      ) {
+        throw new Error(
+          "only kubernetes deployments are supported at the moment"
+        );
+      }
+
+      if (
+        !componentConfig.deploy.cluster ||
+        componentConfig.deploy.cluster.type !== "gcloud"
+      ) {
+        throw new Error("no gcloud custer configured");
+      }
+      // currently only supports kubernetes
+      const namespace = environment.envVars.KUBE_NAMESPACE;
+
+      const authGoogleNumber = await getGoogleAuthUserNumber.call(this, vorpal);
+
+      await openGoogleCloudLogs(
+        componentConfig.deploy.cluster,
+        namespace,
+        authGoogleNumber
+      );
+    });

package/src/apps/{shell → cli}/commands/project/commandPauseProject.ts

@@ -1,15 +1,17 @@
 import Vorpal from "vorpal";
 import { exec } from "child-process-promise";
-import { Env } from "../../../../types/types";
 import { getProjectNamespace } from "../../../../utils/projects";
-import { envAutocompletion } from "./utils/autocompletions";
+import { envAndComponents } from "./utils/autocompletions";
 
-export default (vorpal: Vorpal) =>
+export default async (vorpal: Vorpal) =>
   vorpal
-    .command("project-pause <env>", "halts all running pods (scales to 0)")
-    .autocomplete(envAutocompletion)
-    .action(async function ({ env }) {
-      const namespace = await getProjectNamespace(env as Env);
+    .command(
+      "project-pause <envComponent>",
+      "halts all running pods (scales to 0)"
+    )
+    .autocomplete(await envAndComponents())
+    .action(async function ({ envComponent }) {
+      const namespace = await getProjectNamespace(envComponent);
       const { shouldContinue } = await this.prompt({
         type: "confirm",
         name: "shouldContinue",

package/src/apps/{shell → cli}/commands/project/commandPortForward.ts

@@ -5,17 +5,17 @@ import {
   getProjectNamespace,
   getProjectPodNames,
 } from "../../../../utils/projects";
-import { envAutocompletion } from "./utils/autocompletions";
+import { envAndComponents } from "./utils/autocompletions";
 import ensureCluster from "./utils/ensureCluster";
 
-export default (vorpal: Vorpal) =>
+export default async (vorpal: Vorpal) =>
   vorpal
-    .command("project-port-forward <env>", "start port-forwarding")
-    .autocomplete(envAutocompletion)
-    .action(async function ({ env }) {
-      await ensureCluster.call(this);
-      const namespace = await getProjectNamespace(env);
-      const podNames = await getProjectPodNames(env);
+    .command("project-port-forward <envComponent>", "start port-forwarding")
+    .autocomplete(await envAndComponents())
+    .action(async function ({ envComponent }) {
+      await ensureCluster.call(this, envComponent);
+      const namespace = await getProjectNamespace(envComponent);
+      const podNames = await getProjectPodNames(envComponent);
       if (podNames.length === 0) {
         logError(this, "sorry, no pods found");
         return;

package/src/apps/cli/commands/project/commandReloadConfig.ts

@@ -0,0 +1,12 @@
+import Vorpal from "vorpal";
+import { reloadConfig } from "../../../../config/getProjectConfig";
+import { showProjectBanner } from "./utils/showProjectBanner";
+
+export default async (vorpal: Vorpal) =>
+  vorpal
+    .command("project-reload-config", "reloads the config")
+
+    .action(async function () {
+      await reloadConfig();
+      await showProjectBanner(vorpal);
+    });

package/src/apps/{shell → cli}/commands/project/commandTriggerCronjob.ts

@@ -6,7 +6,7 @@ import { logError } from "../../../../utils/log";
 import { namespaceAutoCompletion } from "../general/namespaceAutoCompletion";
 
 import { getProjectNamespace } from "../../../../utils/projects";
-import { envAutocompletion } from "./utils/autocompletions";
+import { envAndComponents } from "./utils/autocompletions";
 import ensureCluster from "./utils/ensureCluster";
 
 async function triggerCronjob(namespace: string) {
@@ -43,7 +43,7 @@ async function triggerCronjob(namespace: string) {
     logError(this, "command failed", e.body);
   }
 }
-export default (vorpal: Vorpal) => {
+export default async (vorpal: Vorpal) => {
   vorpal
     .command("trigger-cronjob <namespace>", "trigger cronjob")
     .autocomplete(namespaceAutoCompletion)
@@ -51,11 +51,11 @@ export default (vorpal: Vorpal) => {
       await triggerCronjob.call(this, namespace);
     });
   vorpal
-    .command("project-trigger-cronjob <env>", "trigger cronjob")
-    .autocomplete(envAutocompletion)
-    .action(async function ({ env }) {
-      await ensureCluster.call(this);
-      const namespace = await getProjectNamespace(env);
+    .command("project-trigger-cronjob <envComponent>", "trigger cronjob")
+    .autocomplete(await envAndComponents())
+    .action(async function ({ envComponent }) {
+      await ensureCluster.call(this, envComponent);
+      const namespace = await getProjectNamespace(envComponent);
       await triggerCronjob.call(this, namespace);
     });
 };

package/src/apps/{shell → cli}/commands/project/index.ts

@@ -22,15 +22,16 @@ import commandPauseProject from "./commandPauseProject";
 import commandOpenGrafana from "./commandOpenGrafana";
 import commandPortForward from "./commandPortForward";
 import commandTriggerCronjob from "./commandTriggerCronjob";
-import commandVariables from "./commandVariables";
+
 import commandOpenGrafanaPod from "./commandOpenGrafanaPod";
+import commandReloadConfig from "./commandReloadConfig";
 
-export default (vorpal: Vorpal) => {
+export default async (vorpal: Vorpal) => {
+  commandReloadConfig(vorpal);
   commandInitProject(vorpal);
   commandInitGitlab(vorpal);
   commandEnvVars(vorpal);
 
-  commandVariables(vorpal);
   commandNamespace(vorpal);
   commandListPods(vorpal);
   commandPauseProject(vorpal);

package/src/apps/cli/commands/project/utils/autocompletions.ts

@@ -0,0 +1,26 @@
+import { getAllEnvs, getAllEnvsInAllComponents } from "@catladder/pipeline";
+import {
+  getAllComponentsWithAllEnvsFlat,
+  getProjectConfig,
+} from "../../../../../config/getProjectConfig";
+
+export const allEnvs = async () => {
+  const config = await getProjectConfig();
+  if (!config) {
+    return [];
+  }
+  return getAllEnvsInAllComponents(config);
+};
+
+export const envAndComponents = async () => {
+  const allEnvAndcomponents = await getAllComponentsWithAllEnvsFlat();
+
+  return allEnvAndcomponents.reduce<string[]>(
+    (acc, { env, componentName }) => [...acc, env + ":" + componentName],
+    []
+  );
+};
+
+export const allEnvsAndAllComponents = async () => {
+  return [...(await allEnvs()), ...(await envAndComponents())];
+};

package/src/apps/cli/commands/project/utils/ensureCluster.ts

@@ -0,0 +1,42 @@
+import {
+  isOfDeployType,
+  getFullKubernetesClusterName,
+} from "@catladder/pipeline";
+import {
+  getPipelineContextByChoice,
+  parseChoice,
+} from "../../../../../config/getProjectConfig";
+import {
+  connectToCluster,
+  getCurrentConnectedClusterName,
+} from "../../../../../utils/cluster";
+export default async function (envComponent: string) {
+  const { env, componentName } = parseChoice(envComponent);
+  const context = await getPipelineContextByChoice(env, componentName);
+  if (!isOfDeployType(context.componentConfig.deploy, "kubernetes")) {
+    throw new Error("can't ensure cluster for non-kubernetes deployments");
+  }
+  const cluster = getFullKubernetesClusterName(
+    context.componentConfig.deploy.cluster
+  );
+  const connectedClusterName = await getCurrentConnectedClusterName();
+
+  if (cluster !== connectedClusterName) {
+    this.log(
+      `you are currently connected to cluster '${connectedClusterName}'`
+    );
+    this.log(`but the project requires cluster '${cluster}'`);
+    const { shouldContinue } = await this.prompt({
+      type: "confirm",
+      name: "shouldContinue",
+      default: true,
+      message: `Do you want to connect to '${cluster}'?`,
+    });
+    if (!shouldContinue) {
+      this.log("abort");
+    } else {
+      await connectToCluster(cluster);
+      this.log(`connected to cluster '${cluster}'`);
+    }
+  }
+}

package/src/apps/cli/commands/project/utils/ensureNamespace.ts

@@ -0,0 +1,55 @@
+import { Context, getKubernetesNamespace } from "@catladder/pipeline";
+import { V1Namespace, V1ObjectMeta } from "@kubernetes/client-node";
+import k8sApi from "../../../../../k8sApi";
+
+export default async function (context: Context) {
+  const namespace = getKubernetesNamespace(
+    context.fullConfig,
+    context.environment.shortName
+  );
+  const namespaceBody = new V1Namespace();
+  const metadata: V1ObjectMeta = {
+    name: namespace,
+    labels: {
+      customerName: context.fullConfig.customerName,
+      appName: context.fullConfig.appName,
+      environment: context.environment.shortName,
+      components: Object.keys(context.fullConfig.components).join("_"), // limited chars available...
+      buildTypes: Object.values(context.fullConfig.components)
+        .map((config) => config.build.type)
+        .join("_"), // limited chars available...
+      ...Object.fromEntries(
+        Object.entries(context.fullConfig.components).map(
+          ([componentName, config]) => [
+            "buildType_" + componentName,
+            config.build.type,
+          ]
+        )
+      ),
+      ...(context.fullConfig.meta?.labels ?? {}),
+    },
+  };
+
+  namespaceBody.metadata = metadata;
+  try {
+    await k8sApi.readNamespace(namespace);
+
+    await k8sApi.patchNamespace(
+      namespace,
+      namespaceBody,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      { headers: { "content-type": "application/merge-patch+json" } } // see https://github.com/kubernetes-client/javascript/issues/443
+    ); // update meta data
+  } catch (e) {
+    if (e.response?.body?.reason === "NotFound") {
+      await k8sApi.createNamespace(namespaceBody);
+    } else {
+      console.error(e.response?.body);
+      throw e;
+    }
+  }
+  return namespace;
+}

package/src/apps/cli/commands/project/utils/showProjectBanner.ts

@@ -0,0 +1,11 @@
+import Vorpal from "vorpal";
+import { getProjectConfig } from "../../../../../config/getProjectConfig";
+
+export const showProjectBanner = async (vorpal: Vorpal) => {
+  const projectConfig = await getProjectConfig();
+  if (projectConfig) {
+    vorpal.log("project: " + projectConfig.appName);
+    vorpal.log("customer: " + projectConfig.customerName);
+    vorpal.log("");
+  }
+};

package/src/apps/cli/commands/shared/index.ts

@@ -0,0 +1,36 @@
+import { DeployConfigKubernetesCluster } from "@catladder/pipeline";
+import open from "open";
+
+export const openGoogleCloudLogs = async (
+  cluster?: DeployConfigKubernetesCluster,
+  namespace?: string,
+  googleAuthUserNumber = 0
+) => {
+  const resource = `k8s_container/cluster_name/${cluster.name}${
+    namespace ? `/namespace_name/${namespace}` : ""
+  }`;
+
+  const url = `https://console.cloud.google.com/logs/viewer?project=${
+    cluster.projectId
+  }${
+    resource ? `&resource=${encodeURIComponent(resource)}` : ""
+  }&authuser=${googleAuthUserNumber}`;
+  open(url);
+};
+
+export const openGoogleCloudKubernetesDashboard = async (
+  cluster: DeployConfigKubernetesCluster,
+  namespace: string,
+  googleAuthUserNumber = 0
+) => {
+  //gke_skynet-164509_europe-west1-d_production
+  // ?authuser=1&project=skynet-swiss&pageState=pageState%3D(%22savedViews%22:(%22c%22:%5B%22gke%2Feurope-west6-a%2Fch-production%22%5D,%22n%22:%5B%22pvl-bike2school-review%22%5D,%22i%22:%224e42e0b9cd6147f8a4fba7516752ec48%22))
+  // ?authuser=1&project=skynet-swiss&pageState=(%22savedViews%22:(%22i%22:%2279802e2b154d46d480dff4e086e87875%22,%22c%22:%5B%22gke%2Feurope-west6-a%2Fch-production%22%5D,%22n%22:%5B%22pvl-bike2school-review%22%5D))
+
+  const pageState = `("savedViews":("c":["gke/${cluster.region}/${cluster.name}"],"n":["${namespace}"],"i":"4e42e0b9cd6147f8a4fba7516752ec48"))`;
+  const url = `https://console.cloud.google.com/kubernetes/workload?authuser=${googleAuthUserNumber}&project=${
+    cluster.projectId
+  }&pageState=${encodeURIComponent(pageState)}`;
+
+  open(url);
+};

package/src/apps/{shell → cli}/commands/theStuffThatReallyMatters/index.ts

@@ -2,50 +2,31 @@ import { spawn } from "child-process-promise";
 import fetch from "node-fetch";
 import Vorpal from "vorpal";
 
-export default (vorpal: Vorpal) => {
-  vorpal.command("dadjoke", "something for jonas.").action(async function() {
+export default async (vorpal: Vorpal) => {
+  vorpal.command("dadjoke", "something for jonas.").action(async function () {
     const result = await fetch("https://icanhazdadjoke.com/", {
       headers: {
-        Accept: "text/plain"
-      }
+        Accept: "text/plain",
+      },
     });
     const text = await result.text();
     this.log("");
     this.log(text);
     this.log("");
   });
-  vorpal.command("pantobot", "the allknowing oracle").action(async function() {
-    const { message } = await this.prompt({
-      type: "string",
-      name: "message",
 
-      message: "Your question, unworthy?: "
-    });
-    const result = await fetch(
-      `https://paas.panter.cloud/api/pantobot/${message}`,
-      {
-        headers: {
-          Accept: "text/plain"
-        }
-      }
-    );
-    const text = await result.text();
-    this.log("");
-    this.log(text);
-    this.log("");
-  });
   let starwarsPromise: any;
   vorpal
     .command("starwars", "Long time ago... in a galaxy far far away...")
-    .action(async function() {
+    .action(async function () {
       starwarsPromise = spawn("telnet", ["towel.blinkenlights.nl"], {
-        stdio: ["pipe", "inherit", "pipe"]
+        stdio: ["pipe", "inherit", "pipe"],
       });
       await starwarsPromise;
     })
     // we need to close it properly, because telnet towel.blinkenlights.nl has no way to cancel and stop itself
     // this is also why we need to only inherit the stdout and not the stdin
-    .cancel(async function() {
+    .cancel(async function () {
       starwarsPromise.childProcess.kill();
     });
 };

package/src/apps/cli/config/writeConfig.ts

@@ -0,0 +1,71 @@
+import { Config } from "@catladder/pipeline";
+import { spawn, exec } from "child-process-promise";
+import { writeFile } from "fs-extra";
+import { dump } from "js-yaml";
+import { format } from "prettier";
+import { CommandInstance } from "vorpal";
+import { getGitRoot } from "../../../utils/projects";
+
+export const writeConfig = async (
+  vorpal: CommandInstance,
+  config: Config,
+  options?: {
+    endComment?: string;
+  }
+) => {
+  const gitRoot = await getGitRoot();
+  const TS = "typescript (recommended)";
+  const { configType } = await vorpal.prompt({
+    type: "list",
+    name: "configType",
+    choices: [TS, "yaml"],
+    message: "In which format do you want the config? 🤔",
+  });
+  vorpal.log("");
+  if (configType === TS) {
+    const file = gitRoot + "/catladder.ts";
+    const content = format(
+      `
+      import type { Config } from "@catladder/pipeline";
+      
+      const config: Config = ${JSON.stringify(config)};
+
+      export default config;
+
+     
+      ${options?.endComment ? `/*${options.endComment}*/` : ""}
+      
+      `,
+      {
+        parser: "babel",
+      }
+    );
+
+    await writeFile(file, content, {
+      encoding: "utf-8",
+    });
+    vorpal.log("adding type @catladder/pipeline....");
+    await spawn("yarn add --non-interactive @catladder/pipeline -DW", {
+      shell: true,
+    });
+    await exec("git add " + file);
+  } else {
+    const file = gitRoot + "/catladder.yml";
+    const content = dump(config);
+
+    await writeFile(
+      file,
+      content +
+        "\n\n" +
+        (options.endComment
+          ? "# " + options.endComment.split("\n").join("\n# ")
+          : ""),
+      {
+        encoding: "utf-8",
+      }
+    );
+    await exec("git add " + file);
+  }
+  vorpal.log("done!");
+  vorpal.log("");
+};

package/src/apps/cli/verify/index.ts

@@ -0,0 +1,30 @@
+import Vorpal from "vorpal";
+import {
+  getGitlabCi,
+  getProjectConfig,
+} from "../../../config/getProjectConfig";
+import { hasGitlabToken, setupGitlabToken } from "../../../utils/gitlab";
+import { isV2, migrateV2 } from "./migration/fromv2";
+
+export const verify = async (vorpal: Vorpal) => {
+  // check if has all settings
+
+  if (!(await hasGitlabToken())) {
+    vorpal.command("setup-gitlab-token").action(async function () {
+      await setupGitlabToken(this);
+    });
+    vorpal.exec("setup-gitlab-token");
+  }
+
+  const projectConfig = await getProjectConfig();
+  try {
+    const gitlabCi = getGitlabCi();
+
+    if (gitlabCi && !projectConfig && (await isV2())) {
+      vorpal.log("no project config, needs migration");
+      await migrateV2(vorpal);
+    }
+  } catch (e) {
+    // no gitroot, ignore
+  }
+};