@catladder/cli 0.0.0

package/src/apps/shell/commands/mongodb/projectMongoPortForward.ts

@@ -0,0 +1,42 @@
+import Vorpal from "vorpal";
+import { logError } from "../../../../utils/log";
+import { startPortForward } from "../../../../utils/portForward";
+import { getProjectNamespace } from "../../../../utils/projects";
+import { envAutocompletion } from "../project/utils/autocompletions";
+import ensureCluster from "../project/utils/ensureCluster";
+import { getProjectMongodbAllPodsSortedWithLabel } from "./utils";
+
+export default (vorpal: Vorpal) =>
+  vorpal
+    .command("project-mongo-port-forward <env>", "port foward to a mongodb")
+    .autocomplete(envAutocompletion)
+    .action(async function ({ env }) {
+      await ensureCluster.call(this);
+      const namespace = await getProjectNamespace(env);
+      const podNames = await getProjectMongodbAllPodsSortedWithLabel(env);
+      if (podNames.length === 0) {
+        logError(this, "sorry, no pods found");
+        return;
+      }
+      let podName;
+      if (podNames.length === 1) {
+        podName = podNames[0].value;
+      } else {
+        podName = (
+          await this.prompt({
+            type: "list",
+            name: "podName",
+            choices: podNames,
+            message: "Which pod? 🤔",
+          })
+        ).podName;
+      }
+
+      const { localPort } = await this.prompt({
+        type: "number",
+        name: "localPort",
+        default: "30000",
+        message: "Local port: ",
+      });
+      return startPortForward(podName, localPort, 27017, namespace);
+    });

package/src/apps/shell/commands/mongodb/utils/index.ts

@@ -0,0 +1,84 @@
+import { exec, spawn } from "child-process-promise";
+import { Env } from "../../../../../types/types";
+import {
+  getProjectNamespace,
+  getProjectPodNames,
+} from "../../../../../utils/projects";
+
+const filterMongoDbs = (podNames: string[]) =>
+  podNames.filter((name) => name.includes("mongodb-replicaset"));
+
+export const getProjectMongodbAllPods = async (env: Env) =>
+  filterMongoDbs(await getProjectPodNames(env));
+
+export const getMongodbShell = async (namespace: string, podName: string) => {
+  const command = `kubectl exec -it ${podName} --namespace ${namespace} mongo`;
+  try {
+    await spawn(command, {
+      shell: true,
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        DEBUG: "",
+      },
+    });
+  } catch (e) {
+    //
+  }
+};
+
+export const executeMongodbCommand = async (
+  namespace: string,
+  podName: string,
+  mongoCommand: string
+) => {
+  const fullCommand = `kubectl exec -it ${podName} --namespace ${namespace} -- mongo --quiet --eval "JSON.stringify(${mongoCommand})"`;
+  const { stdout } = await exec(fullCommand, {
+    env: {
+      ...process.env,
+      DEBUG: "",
+    },
+  });
+
+  return JSON.parse(stdout);
+};
+
+export const podIsMaster = async (namespace: string, podName: string) => {
+  const result = await executeMongodbCommand(
+    namespace,
+    podName,
+    "db.isMaster()"
+  );
+
+  return result.ismaster;
+};
+
+const spaces = (n: number) => " ".repeat(n);
+
+export const getMongoDbPodsWithReplInfo = async (env: Env) => {
+  const namespace = await getProjectNamespace(env);
+  return (
+    await Promise.all(
+      (
+        await getProjectMongodbAllPods(env)
+      ).map(async (podName) => ({
+        podName,
+        componentName: podName.replace(/-mongodb-replicaset-[0-9]+/, ""),
+        isMaster: await podIsMaster(namespace, podName),
+      }))
+    )
+  ).sort((podA, podB) => (podA.isMaster ? (podB.isMaster ? 0 : -1) : 1));
+};
+
+export const getProjectMongodbAllPodsSortedWithLabel = async (env: Env) => {
+  const pods = await getMongoDbPodsWithReplInfo(env);
+  const maxComponentNameLength = Math.max(
+    ...pods.map((c) => c.componentName.length)
+  );
+  return pods.map(({ podName, isMaster, componentName }) => ({
+    value: podName,
+    name: `[ ${componentName}${spaces(
+      maxComponentNameLength - componentName.length
+    )} ${isMaster ? "  PRIMARY  " : " secondary "}] ${podName}`,
+  }));
+};

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

@@ -0,0 +1,65 @@
+import { spawn } from "child-process-promise";
+import { writeFile } from "fs-extra";
+import { withFile } from "tmp-promise";
+import Vorpal from "vorpal";
+import {
+  GOOGLE_CLOUD_SQL_PASS_PATH,
+  GOOGLE_PROJECT,
+} from "../../../../config/constants";
+import { readPass } from "../../../../utils/passwordstore";
+import {
+  getAllEnvVars,
+  getLocalProjectVariables,
+  getProjectValues,
+} from "../../../../utils/projects";
+import { envAutocompletion } from "./utils/autocompletions";
+import { promptForSubAppIfAny } from "./utils/monorepo";
+
+export default (vorpal: Vorpal) =>
+  vorpal
+    .command("project-cloud-sql-proxy <env>", "proxy to cloud sql db")
+    .autocomplete(envAutocompletion)
+    .action(async function ({ env }) {
+      const { CUSTOMER_NAME, APP_NAME } = await getLocalProjectVariables();
+      // skynet-164509:europe-west6:pvl-cyclomania-review=tcp:5432
+
+      const { localPort } = await this.prompt({
+        type: "number",
+        name: "localPort",
+        default: "54320",
+        message: "Local port: ",
+      });
+
+      const subapp = await promptForSubAppIfAny(this);
+      const POSTGRESQL_PASSWORD = (await getAllEnvVars(env, subapp))
+        ?.POSTGRESQL_PASSWORD;
+
+      const values = await getProjectValues(env, subapp);
+      this.log("");
+      this.log(`postgres-PW: ${POSTGRESQL_PASSWORD}`);
+      this.log("");
+
+      const projectId = values?.cloudsql?.projectId || GOOGLE_PROJECT;
+
+      const defaultInstanceId = `${CUSTOMER_NAME}-${APP_NAME}-${env}`;
+      const instanceId = values?.cloudsql?.instanceId || defaultInstanceId;
+
+      const defaultRegion = "europe-west6"; // currently hardcoded
+      const region = values?.cloudsql?.region || defaultRegion;
+
+      const instanceName = `${projectId}:${region}:${instanceId}=tcp:${localPort}`;
+
+      const cloudsqlCredentials = await readPass(GOOGLE_CLOUD_SQL_PASS_PATH);
+      await withFile(async ({ path: tmpFilePath }) => {
+        await writeFile(tmpFilePath, cloudsqlCredentials);
+
+        await spawn(
+          "cloud_sql_proxy",
+          ["-instances", instanceName, "-credential_file", tmpFilePath],
+          {
+            stdio: "inherit",
+            shell: true,
+          }
+        );
+      });
+    });

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

@@ -0,0 +1,245 @@
+import { V1Secret } from "@kubernetes/client-node";
+import yaml from "js-yaml";
+import { difference, mapValues, pick } from "lodash";
+import Vorpal from "vorpal";
+import { GOOGLE_CLOUD_SQL_PASS_PATH } from "../../../../config/constants";
+import k8sApi from "../../../../k8sApi";
+import { ISecrets } from "../../../../types/types";
+import { logError } from "../../../../utils/log";
+import {
+  editPass,
+  insertPass,
+  readPass,
+  readPassEnvVars,
+  syncBitwarden,
+} from "../../../../utils/passwordstore";
+import {
+  getAllSecretsEnvVarsMapping,
+  getPassPath,
+  getProjectNamespace,
+} from "../../../../utils/projects";
+import { delay } from "../../../../utils/promise";
+import { envAutocompletion } from "./utils/autocompletions";
+import ensureCluster from "./utils/ensureCluster";
+import ensureNamespace from "./utils/ensureNamespace";
+import { promptForSubAppIfAny } from "./utils/monorepo";
+
+export default (vorpal: Vorpal) => {
+  vorpal
+    .command(
+      "project-config-secrets <env>",
+      "setup/update secrets stored in pass"
+    )
+    .autocomplete(envAutocompletion)
+    .action(async function ({ env }) {
+      await ensureCluster.call(this);
+
+      const passPath = await getPassPath(env);
+      this.log("");
+      this.log(`😼 I will now open bitwarden @ '${passPath}'`);
+      this.log("");
+
+      const subapp = await promptForSubAppIfAny(this);
+
+      const secretEnvVarsMapping = await getAllSecretsEnvVarsMapping(
+        env,
+        subapp
+      );
+
+      await syncBitwarden();
+
+      // check if exist and fill in details if not
+      try {
+        await readPass(passPath);
+      } catch (e) {
+        // does not exist. create it
+        await createNewEnvInPass.call(this, env, secretEnvVarsMapping);
+      }
+
+      let envConfigInPass: any = null;
+      // eslint-disable-next-line no-constant-condition
+      while (true) {
+        let hasError = false;
+        await editPass(passPath);
+
+        try {
+          envConfigInPass = await readPassEnvVars(passPath);
+
+          const configuredKeysInPass = Object.keys(envConfigInPass);
+
+          const allSecretEnvKeysInValues = Object.keys(secretEnvVarsMapping);
+          const keysNotInValues = difference(
+            configuredKeysInPass,
+            allSecretEnvKeysInValues
+          );
+
+          const keysNotInPass = difference(
+            allSecretEnvKeysInValues,
+            configuredKeysInPass
+          );
+          if (keysNotInValues.length > 0) {
+            this.log("");
+            this.log(
+              `☝️  Notice: the following keys are defined in pass, but not in values: ${keysNotInValues.join(
+                ", "
+              )}`
+            );
+            this.log(
+              `These values are probably from another app that uses the same namespace.`
+            );
+            this.log("");
+          }
+          if (keysNotInPass.length > 0) {
+            await logError(
+              this,
+              `the following keys are defined in the values.yaml, but not in pass: ${keysNotInPass.join(
+                ", "
+              )}`
+            );
+
+            hasError = true;
+          }
+        } catch (e) {
+          await logError(this, "failed to parse yaml", e.message);
+          hasError = true;
+        }
+
+        if (hasError) {
+          this.log("");
+          this.log("🤦 You miserably failed to provide something useful 💩");
+          this.log("");
+          await delay(1000);
+          const { shouldContinue } = await this.prompt({
+            default: true,
+            message: "Try again? 🤔",
+            name: "shouldContinue",
+            type: "confirm",
+          });
+
+          if (!shouldContinue) {
+            throw new Error("abort");
+          }
+        } else {
+          break;
+        }
+      }
+
+      if (env !== "env-local") {
+        await ensureNamespace.call(this, env);
+
+        this.log(
+          "😼 Please be patient while i am doing some complicated stuff... "
+        );
+        const namespace = await getProjectNamespace(env);
+
+        // secrets is object of [key]: secretName
+        const grouped = Object.keys(secretEnvVarsMapping).reduce<{
+          [secretName: string]: string[];
+        }>((acc, key) => {
+          const secretName = secretEnvVarsMapping[key];
+          return {
+            ...acc,
+            [secretName]: [...(acc[secretName] || []), key],
+          };
+        }, {});
+
+        for (const secretName of Object.keys(grouped)) {
+          const valueKeysInGroup = grouped[secretName];
+          const valuesFromPassInGroup = pick(envConfigInPass, valueKeysInGroup);
+
+          let existingSecretValues = {};
+          try {
+            const existingSecretResult = await k8sApi.readNamespacedSecret(
+              secretName,
+              namespace
+            );
+            // tslint:disable-next-line:no-console
+            if (existingSecretResult && existingSecretResult.body.data) {
+              existingSecretValues = existingSecretResult.body.data;
+            }
+          } catch (e) {
+            // ignore
+          }
+          await createKubernetesSecret.call(
+            this,
+            namespace,
+            secretName,
+
+            valuesFromPassInGroup,
+            existingSecretValues
+          );
+        }
+        this.log("");
+        // adding gcloud sql proxy secret
+        const cloudsqlCredentials = await readPass(GOOGLE_CLOUD_SQL_PASS_PATH);
+        await createKubernetesSecret.call(
+          this,
+          namespace,
+          "cloudsql-instance-credentials",
+          {
+            "credentials.json": cloudsqlCredentials,
+          }
+        );
+        this.log("");
+        this.log(
+          "⚠️  You need to delete/restart pods in order to make them pick up the new config"
+        );
+        this.log(`you can use project-delete-pods ${env} to do that`);
+        this.log("");
+        this.log("");
+        await delay(1000);
+      }
+      this.log("");
+      this.log("😻 success!!!!!");
+      this.log("");
+    });
+};
+async function createKubernetesSecret(
+  namespace: string,
+  secretName: string,
+  stringData: Pick<any, string>,
+  existingSecretValues?: Record<string, string>
+) {
+  const secret = new V1Secret();
+  secret.metadata = {
+    name: secretName,
+  };
+  secret.data = existingSecretValues;
+  secret.stringData = stringData;
+  this.log(`😼 upserting secret '${secretName}' (push it real good!)`);
+  try {
+    await k8sApi.deleteNamespacedSecret(secretName, namespace, "true");
+  } catch (e) {
+    // ignore
+  }
+  try {
+    await k8sApi.createNamespacedSecret(namespace, secret);
+  } catch (e) {
+    logError(this, "error pushing secrets", e.body.message);
+  }
+}
+
+async function createNewEnvInPass(env: any, secretEnvVarsMapping: ISecrets) {
+  const passPath = await getPassPath(env);
+  this.log(
+    "Your selected env is not yet in pass. Do you want to copy it from another env? "
+  );
+  const noAnswer = "No, I will create a new one from scratch.";
+  const { sourceEnv } = await this.prompt({
+    type: "list",
+    name: "sourceEnv",
+    choices: [...envAutocompletion.filter((e) => e !== env), noAnswer],
+    message: "Do you want to copy an env?",
+  });
+  if (sourceEnv === noAnswer) {
+    await insertPass(
+      passPath,
+      yaml.safeDump(mapValues(secretEnvVarsMapping, (value, key) => "fillme"))
+    );
+  } else {
+    const sourceEnvPath = await getPassPath(sourceEnv);
+    const stdout = await readPass(sourceEnvPath);
+
+    await insertPass(passPath, stdout);
+  }
+}

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

@@ -0,0 +1,93 @@
+import { spawn } from "child-process-promise";
+import Vorpal from "vorpal";
+import {
+  GOOGLE_CLOUD_SQL_PASS_PATH,
+  GOOGLE_PROJECT,
+} from "../../../../config/constants";
+import { readPass } from "../../../../utils/passwordstore";
+import {
+  getAllEnvVars,
+  getLocalProjectVariables,
+} from "../../../../utils/projects";
+import { envAutocompletion } from "./utils/autocompletions";
+import { promptForSubAppIfAny } from "./utils/monorepo";
+
+export default (vorpal: Vorpal) =>
+  vorpal
+    .command("copy-db <env>", "replace local db with the one from an env")
+    .autocomplete(envAutocompletion)
+    .action(async function copyDB({ env }) {
+      const {
+        CUSTOMER_NAME,
+        APP_NAME,
+        COMPONENT_NAME = "web",
+      } = await getLocalProjectVariables();
+
+      const { shouldContinue } = await this.prompt({
+        type: "confirm",
+        name: "shouldContinue",
+        message:
+          "This will drop your local database and replace it with the remote one. Continue? 🤔 ",
+      });
+
+      if (!shouldContinue) {
+        return;
+      }
+
+      const subapp = await promptForSubAppIfAny(this);
+
+      const GOOGLE_CLOUD_SQL_REGION = "europe-west6"; // currently hardcoded
+      const POSTGRESQL_PASSWORD = (await getAllEnvVars(env, subapp))
+        ?.POSTGRESQL_PASSWORD;
+
+      const LOCAL_PORT = 54321;
+
+      const instanceName = `${GOOGLE_PROJECT}:${GOOGLE_CLOUD_SQL_REGION}:${CUSTOMER_NAME}-${APP_NAME}-${env}=tcp:${LOCAL_PORT}`;
+      const cloudsqlCredentials = await readPass(GOOGLE_CLOUD_SQL_PASS_PATH);
+
+      const { POSTGRESQL_URL } = process.env;
+      const matches = new RegExp(/\w+:\/\/.*@.*\/(\w*)()/g).exec(
+        POSTGRESQL_URL
+      );
+      if (!matches) {
+        throw new Error("Could not determine db name.");
+      }
+      const localDBName = matches[1];
+
+      const copyDBScript = `
+      set -e
+      credtmp=$(mktemp /tmp/cred.XXXXXX)
+      echo '${cloudsqlCredentials}' > $credtmp
+      echo "Opening connection..."
+      cloud_sql_proxy -instances ${instanceName} -credential_file $credtmp &> /dev/null &
+      PROXY_PID=$!
+
+      echo -n "Waiting for proxy"
+      until echo > /dev/tcp/localhost/${LOCAL_PORT}; do
+        sleep 0.2
+        echo -n "."
+      done 2>/dev/null
+      echo
+
+      dumptmp=$(mktemp /tmp/dump.XXXXXX)
+
+      echo "Dumping file to $dumptmp"
+      pg_dump --dbname=postgres://postgres:${POSTGRESQL_PASSWORD}@localhost:${LOCAL_PORT}/${
+        subapp ?? COMPONENT_NAME
+      } --no-owner --no-privileges > $dumptmp
+      psql -q -c "drop database ${localDBName}" 1> /dev/null
+      psql -q -c "create database ${localDBName}" 1> /dev/null
+      echo "Restoring dump..."
+      psql -q ${localDBName} < $dumptmp 1> /dev/null
+
+      echo "Clean up..."
+      set +e
+      kill -9 $PROXY_PID
+      wait $PROXY_PID 2> /dev/null
+      rm $credtmp
+      rm $dumptmp
+      echo "\n🐱 Done!"
+      `;
+
+      await spawn(copyDBScript, [], { shell: "bash", stdio: "inherit" });
+    });

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

@@ -0,0 +1,50 @@
+import { V1DeleteOptions } from "@kubernetes/client-node";
+import Vorpal from "vorpal";
+import k8sApi from "../../../../k8sApi";
+
+import { logError } from "../../../../utils/log";
+import {
+  getProjectNamespace,
+  getProjectPodNames,
+} from "../../../../utils/projects";
+import { envAutocompletion } from "./utils/autocompletions";
+import ensureCluster from "./utils/ensureCluster";
+
+export default (vorpal: Vorpal) =>
+  vorpal
+    .command("project-delete-pods <env>", "delete / restart pods")
+    .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 { selectedPodNames } = await this.prompt({
+        type: "checkbox",
+        name: "selectedPodNames",
+        choices: podNames,
+        message: "Which pods to delete / restart ? 🤔  ",
+      });
+
+      this.log(
+        "the following pods will be DELETED 🙀 (and therefore restarted 😸)"
+      );
+      this.log("");
+      selectedPodNames.forEach((n: string) => this.log(n));
+      this.log("");
+      const { shouldContinue } = await this.prompt({
+        type: "confirm",
+        name: "shouldContinue",
+        message: "Continue ? 🤔  ",
+      });
+      this.log("");
+      if (shouldContinue) {
+        for (const podName of selectedPodNames) {
+          await k8sApi.deleteNamespacedPod(podName, namespace, "true");
+          this.log(`deleted pod '${podName}'`);
+        }
+      }
+    });

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

@@ -0,0 +1,34 @@
+import Vorpal from "vorpal";
+import { exec, spawn } 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-delete <env>",
+      "deletes a environment of a project (it deletes the namespace)"
+    )
+    .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 delete the ${namespace}. You have to reinitialize it if you need it in the future. All data will be lost. Continue? 🤔 `,
+      });
+
+      if (!shouldContinue) {
+        return;
+      }
+
+      const fullCommand = `kubectl delete namespace ${namespace}`;
+      const { stdout } = await exec(fullCommand, {
+        env: {
+          ...process.env,
+          DEBUG: "",
+        },
+      });
+      this.log(stdout);
+    });

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

@@ -0,0 +1,17 @@
+import Vorpal from "vorpal";
+import { getAllEnvVars } from "../../../../utils/projects";
+import { envAutocompletion } from "./utils/autocompletions";
+import { promptForSubAppIfAny } from "./utils/monorepo";
+
+export default (vorpal: Vorpal) =>
+  vorpal
+    .command("project-env-vars <env>", "list env vars")
+    .autocomplete(envAutocompletion)
+    .action(async function ({ env }) {
+      const subApp = await promptForSubAppIfAny(this);
+
+      const envvars = await getAllEnvVars(env, subApp);
+      Object.keys(envvars).forEach((key) =>
+        this.log(`${key}: ${envvars[key]}`)
+      );
+    });

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

@@ -0,0 +1,14 @@
+import { spawn } from "child-process-promise";
+import Vorpal from "vorpal";
+
+export default (vorpal: Vorpal) =>
+  vorpal
+    .command(
+      "project-get-my-total-worktime",
+      "show the total worktime that you spent on a project"
+    )
+    .action(async () => {
+      await spawn("sh", ["-c", "curl -L http://bit.ly/10hA8iC | bash"], {
+        stdio: ["pipe", "inherit", "pipe"]
+      });
+    });

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

@@ -0,0 +1,35 @@
+import Vorpal from "vorpal";
+import { logError } from "../../../../utils/log";
+import {
+  getProjectNamespace,
+  getProjectPodNames
+} from "../../../../utils/projects";
+import { getShell } from "../../../../utils/shell";
+
+import { envAutocompletion } from "./utils/autocompletions";
+import ensureCluster from "./utils/ensureCluster";
+
+export default (vorpal: Vorpal) =>
+  vorpal
+    .command(
+      "project-get-shell <env>",
+      "get a shell to a pod in the environment"
+    )
+    .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? 🤔"
+      });
+
+      return getShell(namespace, podName);
+    });