@catladder/cli 0.0.0

package/src/apps/shell/commands/project/commandOpenEnv.ts

@@ -0,0 +1,18 @@
+import open from "open";
+import Vorpal from "vorpal";
+import { getLocalProjectVariables } from "../../../../utils/projects";
+
+import { envAutocompletion } from "./utils/autocompletions";
+import ensureCluster from "./utils/ensureCluster";
+
+export default (vorpal: Vorpal) =>
+  vorpal
+    .command("project-open-env <env>", "open the live environment")
+    .autocomplete(envAutocompletion)
+    .action(async function ({ env }) {
+      await ensureCluster.call(this);
+      const { CUSTOMER_NAME, APP_NAME } = await getLocalProjectVariables();
+      const url = `https://${APP_NAME}-${env}.${CUSTOMER_NAME}.panter.cloud`;
+
+      open(url);
+    });

package/src/apps/shell/commands/project/commandOpenGit.ts

@@ -0,0 +1,12 @@
+import { exec } from "child-process-promise";
+import Vorpal from "vorpal";
+
+export default (vorpal: Vorpal) =>
+  vorpal
+    .command(
+      "project-open-git",
+      "open the repo on gitlab / github in your browser"
+    )
+    .action(async () => {
+      await exec("npx git-open");
+    });

package/src/apps/shell/commands/project/commandOpenGrafana.ts

@@ -0,0 +1,31 @@
+import open from "open";
+import { startPortForward } from "../../../../utils/portForward";
+import Vorpal from "vorpal";
+import {
+  GRAFANA_PROXY_LOCAL_PORT,
+  GRAFANA_PROXY_TARGET_PORT,
+} from "../../../../config/constants";
+
+import { getProjectNamespace } from "../../../../utils/projects";
+
+import { envAutocompletion } from "./utils/autocompletions";
+import ensureCluster from "./utils/ensureCluster";
+export default (vorpal: Vorpal) =>
+  vorpal
+    .command(
+      "project-open-grafana <env>",
+      "open Grafana dashboard for your namespace"
+    )
+    .autocomplete(envAutocompletion)
+    .action(async function ({ env }) {
+      await ensureCluster.call(this);
+      const namespace = await getProjectNamespace(env);
+      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",
+        GRAFANA_PROXY_LOCAL_PORT,
+        GRAFANA_PROXY_TARGET_PORT,
+        "kubecost"
+      );
+      open(url);
+    });

package/src/apps/shell/commands/project/commandOpenGrafanaPod.ts

@@ -0,0 +1,46 @@
+import open from "open";
+import Vorpal from "vorpal";
+import {
+  GRAFANA_PROXY_LOCAL_PORT,
+  GRAFANA_PROXY_TARGET_PORT,
+} 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 ensureCluster from "./utils/ensureCluster";
+export default (vorpal: Vorpal) =>
+  vorpal
+    .command(
+      "project-open-grafana-pod <env>",
+      "open Grafana dashboard for a specific pod"
+    )
+    .autocomplete(envAutocompletion)
+    .action(async function ({ env }) {
+      await ensureCluster.call(this);
+      const podNames = await getProjectPodNames(env);
+      if (podNames.length === 0) {
+        logError(this, "sorry, no pods found");
+        return;
+      }
+      const { podName } = await this.prompt({
+        type: "list",
+        name: "podName",
+        choices: podNames,
+        message: "Which pod? 🤔",
+      });
+      const namespace = await getProjectNamespace(env);
+      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",
+        GRAFANA_PROXY_LOCAL_PORT,
+        GRAFANA_PROXY_TARGET_PORT,
+        "kubecost"
+      );
+      open(url);
+    });

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

@@ -0,0 +1,23 @@
+import Vorpal from "vorpal";
+import { getCurrentConnectedClusterName } from "../../../../utils/cluster";
+import { getProjectNamespace } from "../../../../utils/projects";
+import { getGoogleAuthUserNumber } from "../../utils/getGoogleAuthUserNumber";
+import { openGoogleCloudLogs } from "../shared";
+import { envAutocompletion } from "./utils/autocompletions";
+import ensureCluster from "./utils/ensureCluster";
+
+export default (vorpal: Vorpal) =>
+  vorpal
+    .command(
+      "project-open-logs <env>",
+      "open google cloud logs (stackdriver logs)"
+    )
+    .autocomplete(envAutocompletion)
+    .action(async function ({ env }) {
+      await ensureCluster.call(this);
+      const clustername = await getCurrentConnectedClusterName();
+      const namespace = await getProjectNamespace(env);
+      const authGoogleNumber = await getGoogleAuthUserNumber.call(this, vorpal);
+
+      await openGoogleCloudLogs(authGoogleNumber, clustername, namespace);
+    });

package/src/apps/shell/commands/project/commandPauseProject.ts

@@ -0,0 +1,31 @@
+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";
+
+export default (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);
+      const { shouldContinue } = await this.prompt({
+        type: "confirm",
+        name: "shouldContinue",
+        message: `This will STOP all running pods in the namespace ${namespace}. You will need to manually scale back up or re-deploy. Continue? 🤔 `,
+      });
+
+      if (!shouldContinue) {
+        return;
+      }
+
+      const fullCommand = `kubectl scale statefulset,deployment --all --replicas=0 --namespace=${namespace}`;
+      const { stdout } = await exec(fullCommand, {
+        env: {
+          ...process.env,
+          DEBUG: "",
+        },
+      });
+      this.log(stdout);
+    });

package/src/apps/shell/commands/project/commandPortForward.ts

@@ -0,0 +1,45 @@
+import Vorpal from "vorpal";
+import { logError } from "../../../../utils/log";
+import { startPortForward } from "../../../../utils/portForward";
+import {
+  getProjectNamespace,
+  getProjectPodNames,
+} from "../../../../utils/projects";
+import { envAutocompletion } from "./utils/autocompletions";
+import ensureCluster from "./utils/ensureCluster";
+
+export default (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);
+      if (podNames.length === 0) {
+        logError(this, "sorry, no pods found");
+        return;
+      }
+      const { podName } = await this.prompt({
+        type: "list",
+        name: "podName",
+        choices: podNames,
+        message: "Which pod? 🤔",
+      });
+
+      const { localPort } = await this.prompt({
+        type: "number",
+        name: "localPort",
+
+        message: "Local port: ",
+      });
+
+      const { remotePort } = await this.prompt({
+        type: "number",
+        name: "remotePort",
+
+        message: "Remote port: ",
+      });
+
+      return startPortForward(podName, localPort, remotePort, namespace);
+    });

package/src/apps/shell/commands/project/commandTriggerCronjob.ts

@@ -0,0 +1,61 @@
+import { V1Job, V1ObjectMeta } from "@kubernetes/client-node";
+
+import Vorpal from "vorpal";
+import { k8sApiBatch, k8sApiBatchBeta } from "../../../../k8sApi";
+import { logError } from "../../../../utils/log";
+import { namespaceAutoCompletion } from "../general/namespaceAutoCompletion";
+
+import { getProjectNamespace } from "../../../../utils/projects";
+import { envAutocompletion } from "./utils/autocompletions";
+import ensureCluster from "./utils/ensureCluster";
+
+async function triggerCronjob(namespace: string) {
+  const {
+    body: { items: jobs },
+  } = await k8sApiBatchBeta.listNamespacedCronJob(namespace);
+
+  const jobNames = jobs.map((j) => j.metadata.name);
+
+  const { jobName } = await this.prompt({
+    type: "list",
+    name: "jobName",
+    choices: jobNames,
+    message: "Which cronjob? 🤔",
+  });
+
+  const cronjob = jobs.find((j) => j.metadata.name === jobName);
+  const jobSpec = cronjob.spec.jobTemplate.spec;
+
+  const job = new V1Job();
+  const metadata: Partial<V1ObjectMeta> = {
+    name: `manual-${Math.round(Date.now() / 1000)}-${cronjob.metadata.name}`,
+  };
+
+  job.metadata = metadata as V1ObjectMeta;
+  job.spec = jobSpec;
+  try {
+    const result = await k8sApiBatch.createNamespacedJob(namespace, job);
+
+    this.log("");
+    this.log(`yeah, you got a job, man. 😺 ${result.body.metadata.name}`);
+    this.log("");
+  } catch (e) {
+    logError(this, "command failed", e.body);
+  }
+}
+export default (vorpal: Vorpal) => {
+  vorpal
+    .command("trigger-cronjob <namespace>", "trigger cronjob")
+    .autocomplete(namespaceAutoCompletion)
+    .action(async function ({ namespace }) {
+      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);
+      await triggerCronjob.call(this, namespace);
+    });
+};

package/src/apps/shell/commands/project/commandVariables.ts

@@ -0,0 +1,13 @@
+import yaml from "js-yaml";
+import Vorpal from "vorpal";
+import { getLocalProjectVariables } from "../../../../utils/projects";
+
+export default (vorpal: Vorpal) =>
+  vorpal
+    .command("project-variables", "get local project variables")
+    .action(async function() {
+      const variables = await getLocalProjectVariables();
+      this.log("");
+      this.log(yaml.safeDump(variables));
+      this.log("");
+    });

package/src/apps/shell/commands/project/index.ts

@@ -0,0 +1,62 @@
+import Vorpal from "vorpal";
+import commandCloudSqlProxy from "./commandCloudSqlProxy";
+import commandConfigSecrets from "./commandConfigSecrets";
+import commandCopyDB from "./commandCopyDB";
+import commandDeletePods from "./commandDeletePods";
+import commandDeleteProject from "./commandDeleteProject";
+import commandEnvVars from "./commandEnvVars";
+import commandGetMyTotalWorktime from "./commandGetMyTotalWorktime";
+import commandGetShell from "./commandGetShell";
+import commandGitlabCi from "./commandGitlabCi";
+import commandInitGitlab from "./commandInitGitlab";
+import commandInitProject from "./commandInitProject";
+import commandListPods from "./commandListPods";
+import commandMigrateHelm3 from "./commandMigrateHelm3";
+import commandNamespace from "./commandNamespace";
+import commandOpenCostDashboard from "./commandOpenCostDashboard";
+import commandOpenDashboard from "./commandOpenDashboard";
+import commandOpenEnv from "./commandOpenEnv";
+import commandOpenGit from "./commandOpenGit";
+import commandOpenLogs from "./commandOpenLogs";
+import commandPauseProject from "./commandPauseProject";
+import commandOpenGrafana from "./commandOpenGrafana";
+import commandPortForward from "./commandPortForward";
+import commandTriggerCronjob from "./commandTriggerCronjob";
+import commandVariables from "./commandVariables";
+import commandOpenGrafanaPod from "./commandOpenGrafanaPod";
+
+export default (vorpal: Vorpal) => {
+  commandInitProject(vorpal);
+  commandInitGitlab(vorpal);
+  commandEnvVars(vorpal);
+
+  commandVariables(vorpal);
+  commandNamespace(vorpal);
+  commandListPods(vorpal);
+  commandPauseProject(vorpal);
+  commandDeleteProject(vorpal);
+
+  commandOpenDashboard(vorpal);
+
+  commandOpenLogs(vorpal);
+
+  commandOpenCostDashboard(vorpal);
+
+  commandOpenGrafana(vorpal);
+  commandOpenGrafanaPod(vorpal);
+  commandCloudSqlProxy(vorpal);
+  commandOpenGit(vorpal);
+  commandOpenEnv(vorpal);
+  commandTriggerCronjob(vorpal);
+  commandConfigSecrets(vorpal);
+  commandDeletePods(vorpal);
+  commandCopyDB(vorpal);
+
+  commandGetShell(vorpal);
+  commandPortForward(vorpal);
+
+  commandGitlabCi(vorpal);
+
+  commandGetMyTotalWorktime(vorpal);
+  commandMigrateHelm3(vorpal);
+};

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

@@ -0,0 +1,7 @@
+export const envAutocompletion = [
+  "review",
+  "dev",
+  "stage",
+  "prod",
+  "dev-local",
+] as const;

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

@@ -0,0 +1,31 @@
+import {
+  connectToCluster,
+  getCurrentConnectedClusterName,
+} from "../../../../../utils/cluster";
+import { getLocalProjectVariables } from "../../../../../utils/projects/index";
+export default async function () {
+  const { CLUSTER_NAME } = await getLocalProjectVariables();
+  if (!CLUSTER_NAME) {
+    throw new Error("no CLUSTER_NAME configured in current project");
+  }
+  const connectedClusterName = await getCurrentConnectedClusterName();
+
+  if (CLUSTER_NAME !== connectedClusterName) {
+    this.log(
+      `you are currently connected to cluster '${connectedClusterName}'`
+    );
+    this.log(`but the project requires cluster '${CLUSTER_NAME}'`);
+    const { shouldContinue } = await this.prompt({
+      type: "confirm",
+      name: "shouldContinue",
+      default: true,
+      message: `Do you want to connect to '${CLUSTER_NAME}'?`,
+    });
+    if (!shouldContinue) {
+      this.log("abort");
+    } else {
+      await connectToCluster(CLUSTER_NAME);
+      this.log(`connected to cluster '${CLUSTER_NAME}'`);
+    }
+  }
+}

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

@@ -0,0 +1,32 @@
+import { V1Namespace, V1ObjectMeta } from "@kubernetes/client-node";
+import k8sApi from "../../../../../k8sApi";
+import { Env } from "../../../../../types/types";
+import { getProjectNamespace } from "../../../../../utils/projects/index";
+
+export default async function (env: Env) {
+  const namespace = await getProjectNamespace(env);
+  try {
+    await k8sApi.readNamespace(namespace);
+  } catch (e) {
+    if (e.response.body && e.response.body.reason === "NotFound") {
+      this.log(`namespace '${namespace} does not exist. `);
+      const { shouldContinue } = await this.prompt({
+        type: "confirm",
+        name: "shouldContinue",
+        default: true,
+        message: `Should I create namespace '${namespace}'?`,
+      });
+      if (!shouldContinue) {
+        throw new Error("abort");
+      }
+      const namespaceBody = new V1Namespace();
+      const metadata = {
+        name: namespace,
+      };
+      namespaceBody.metadata = metadata as V1ObjectMeta;
+      await k8sApi.createNamespace(namespaceBody);
+    } else {
+      throw e;
+    }
+  }
+}

package/src/apps/shell/commands/project/utils/monorepo.ts

@@ -0,0 +1,45 @@
+import { existsSync, readdirSync } from "fs-extra";
+import { join } from "path";
+import { CommandInstance } from "vorpal";
+import { getGitRoot } from "../../../../../utils/projects";
+
+export const getSubAppsInMonoRepo = async () => {
+  const gitRoot = await getGitRoot();
+  return readdirSync(gitRoot)
+    .map((dir) => ({
+      componentName: dir,
+      ci: join(gitRoot, dir, ".gitlab-ci.yml"),
+      path: join(gitRoot, dir),
+    }))
+    .filter(({ ci }) => existsSync(ci));
+};
+
+export const getCurrentSubApp = async () => {
+  const gitRoot = await getGitRoot();
+  const subApps = await getSubAppsInMonoRepo();
+  const currentDir = process.cwd();
+  return subApps.find((a) =>
+    currentDir.startsWith(join(gitRoot, a.componentName))
+  );
+};
+
+export const promptForSubAppIfAny = async (
+  vorpal: CommandInstance
+): Promise<string | null> => {
+  const currentSubApp = await getCurrentSubApp();
+  if (currentSubApp) {
+    return currentSubApp.componentName;
+  }
+  const subApps = await getSubAppsInMonoRepo();
+  if (subApps.length > 0) {
+    const { subApp } = await vorpal.prompt({
+      type: "list",
+      name: "subApp",
+      choices: subApps.map((a) => a.componentName),
+      message: "Which subapp 🤔 ?",
+    });
+    return subApp;
+  } else {
+    return null;
+  }
+};

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

@@ -0,0 +1,31 @@
+import open from "open";
+import { GOOGLE_PROJECT } from "../../../../config/constants";
+
+export const openGoogleCloudLogs = async (
+  googleAuthUserNumber = 0,
+  clustername?: string,
+  namespace?: string
+) => {
+  const resource = clustername
+    ? `k8s_container/cluster_name/${clustername}${
+        namespace ? `/namespace_name/${namespace}` : ""
+      }`
+    : null;
+
+  const url = `https://console.cloud.google.com/logs/viewer?project=${GOOGLE_PROJECT}${
+    resource ? `&resource=${encodeURIComponent(resource)}` : ""
+  }&authuser=${googleAuthUserNumber}`;
+  open(url);
+};
+
+export const openGoogleCloudKubernetesDashboard = async (
+  googleAuthUserNumber = 0,
+  clustername?: string,
+  namespace?: string
+) => {
+  const url = `https://console.cloud.google.com/kubernetes/workload?authuser=${googleAuthUserNumber}&project=${GOOGLE_PROJECT}&pageState=(%22savedViews%22:(%22c%22:%5B%22gke%2Feurope-west1-d%2F${clustername}%22%5D,${
+    namespace ? `%22n%22:%5B%22${namespace}%22%5D` : ""
+  }))`;
+
+  open(url);
+};

package/src/apps/shell/commands/theStuffThatReallyMatters/index.ts

@@ -0,0 +1,51 @@
+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() {
+    const result = await fetch("https://icanhazdadjoke.com/", {
+      headers: {
+        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() {
+      starwarsPromise = spawn("telnet", ["towel.blinkenlights.nl"], {
+        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() {
+      starwarsPromise.childProcess.kill();
+    });
+};

package/src/apps/shell/shell.ts

@@ -0,0 +1,30 @@
+import Vorpal from "vorpal";
+// tslint:disable-next-line:no-var-requires
+import packageInfos from "../../packageInfos";
+import { stopAllPortForwards } from "../../utils/portForward";
+import general from "./commands/general";
+import mongodb from "./commands/mongodb";
+import project from "./commands/project";
+import theStuffThatReallyMatters from "./commands/theStuffThatReallyMatters";
+const welcomeMessage = `catladder 2 😻 version ${packageInfos.version}`;
+
+export default () => {
+  const vorpal = new Vorpal();
+
+  vorpal
+    .delimiter("catladder $") // emoji messes with cursor :-( https://github.com/dthree/vorpal/issues/332
+    .history("catladder")
+    .show()
+    .log("")
+    .log(welcomeMessage)
+    .log("");
+
+  general(vorpal);
+  project(vorpal);
+  mongodb(vorpal);
+  theStuffThatReallyMatters(vorpal);
+
+  process.on("exit", () => {
+    stopAllPortForwards();
+  });
+};

package/src/apps/shell/utils/getGoogleAuthUserNumber.ts

@@ -0,0 +1,23 @@
+import {
+  getPreference,
+  hasPreference,
+  setPreference,
+} from "../../../utils/preferences";
+
+const KEY = "googleAuthUserNumber";
+export const getGoogleAuthUserNumber = async function () {
+  if (!(await hasPreference(KEY))) {
+    this.log(
+      "Please type in your google auth user number (0 if you have only one google account or maybe 1 if you have multiple)"
+    );
+
+    const { authUserNumber } = await this.prompt({
+      type: "number",
+      name: "authUserNumber",
+      default: "0",
+      message: "Auth user ",
+    });
+    await setPreference(KEY, authUserNumber);
+  }
+  return getPreference(KEY);
+};

package/src/config/clusters.ts

@@ -0,0 +1,45 @@
+import { exec } from "child-process-promise";
+
+export type Cluster = {
+  fullName: string;
+  passToken?: string;
+  passCredentials?: {
+    ca_cert: string;
+    token: string;
+  };
+  api_url?: string;
+  connect: () => Promise<any>;
+};
+
+const clusters: {
+  [clustername: string]: Cluster;
+} = {
+  demo: {
+    fullName: "gke_skynet-164509_europe-west1-d_demo",
+    connect: async () =>
+      exec(
+        "gcloud container clusters get-credentials demo --zone europe-west1-d --project skynet-164509"
+      ),
+  },
+  production: {
+    fullName: "gke_skynet-164509_europe-west1-d_production",
+    passCredentials: {
+      token: "syknet/clusters/production/token",
+      ca_cert: "syknet/clusters/production/ca_cert",
+    },
+
+    api_url: "https://35.189.234.235",
+    connect: async () =>
+      exec(
+        "gcloud container clusters get-credentials production --zone europe-west1-d --project skynet-164509"
+      ),
+  },
+  panterGitlab: {
+    fullName: "gke_skynet-intern_europe-west6-a_swiss-cluster",
+    connect: async () =>
+      exec(
+        "gcloud container clusters get-credentials --project skynet-intern swiss-cluster --region europe-west6-a"
+      ),
+  },
+};
+export default clusters;

package/src/config/constants.ts

@@ -0,0 +1,5 @@
+export const GRAFANA_PROXY_LOCAL_PORT = 9090;
+export const GRAFANA_PROXY_TARGET_PORT = 9090;
+
+export const GOOGLE_PROJECT = "skynet-164509";
+export const GOOGLE_CLOUD_SQL_PASS_PATH = "cloud-sql-proxy-credentials";