@catladder/cli 0.0.1-bla → 1.0.0

package/src/apps/{shell → cli}/commands/mongodb/projectMongoGetShell.ts

@@ -1,24 +1,26 @@
 import Vorpal from "vorpal";
 import { logError } from "../../../../utils/log";
 import { getProjectNamespace } from "../../../../utils/projects";
-import { envAutocompletion } from "../project/utils/autocompletions";
+import { envAndComponents } from "../project/utils/autocompletions";
 import ensureCluster from "../project/utils/ensureCluster";
 import {
   getMongodbShell,
-  getProjectMongodbAllPodsSortedWithLabel
+  getProjectMongodbAllPodsSortedWithLabel,
 } from "./utils";
 
-export default (vorpal: Vorpal) =>
+export default async (vorpal: Vorpal) =>
   vorpal
     .command(
-      "project-mongo-get-shell <env>",
+      "project-mongo-get-shell <envComponent>",
       "get a shell to a mongodb in the environment"
     )
-    .autocomplete(envAutocompletion)
-    .action(async function({ env }) {
-      await ensureCluster.call(this);
-      const namespace = await getProjectNamespace(env);
-      const podNames = await getProjectMongodbAllPodsSortedWithLabel(env);
+    .autocomplete(await envAndComponents())
+    .action(async function ({ envComponent }) {
+      await ensureCluster.call(this, envComponent);
+      const namespace = await getProjectNamespace(envComponent);
+      const podNames = await getProjectMongodbAllPodsSortedWithLabel(
+        envComponent
+      );
       if (podNames.length === 0) {
         logError(this, "sorry, no pods found");
         return;
@@ -32,7 +34,7 @@ export default (vorpal: Vorpal) =>
             type: "list",
             name: "podName",
             choices: podNames,
-            message: "Which pod? 🤔"
+            message: "Which pod? 🤔",
           })
         ).podName;
       }

package/src/apps/{shell → cli}/commands/mongodb/projectMongoPortForward.ts

@@ -2,18 +2,23 @@ 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 { envAndComponents } from "../project/utils/autocompletions";
 import ensureCluster from "../project/utils/ensureCluster";
 import { getProjectMongodbAllPodsSortedWithLabel } from "./utils";
 
-export default (vorpal: Vorpal) =>
+export default async (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);
+    .command(
+      "project-mongo-port-forward <envComponent>",
+      "port foward to a mongodb"
+    )
+    .autocomplete(await envAndComponents())
+    .action(async function ({ envComponent }) {
+      await ensureCluster.call(this, envComponent);
+      const namespace = await getProjectNamespace(envComponent);
+      const podNames = await getProjectMongodbAllPodsSortedWithLabel(
+        envComponent
+      );
       if (podNames.length === 0) {
         logError(this, "sorry, no pods found");
         return;

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

@@ -1,5 +1,4 @@
 import { exec, spawn } from "child-process-promise";
-import { Env } from "../../../../../types/types";
 import {
   getProjectNamespace,
   getProjectPodNames,
@@ -8,8 +7,8 @@ import {
 const filterMongoDbs = (podNames: string[]) =>
   podNames.filter((name) => name.includes("mongodb-replicaset"));
 
-export const getProjectMongodbAllPods = async (env: Env) =>
-  filterMongoDbs(await getProjectPodNames(env));
+export const getProjectMongodbAllPods = async (envComponent: string) =>
+  filterMongoDbs(await getProjectPodNames(envComponent));
 
 export const getMongodbShell = async (namespace: string, podName: string) => {
   const command = `kubectl exec -it ${podName} --namespace ${namespace} mongo`;
@@ -55,12 +54,12 @@ export const podIsMaster = async (namespace: string, podName: string) => {
 
 const spaces = (n: number) => " ".repeat(n);
 
-export const getMongoDbPodsWithReplInfo = async (env: Env) => {
-  const namespace = await getProjectNamespace(env);
+export const getMongoDbPodsWithReplInfo = async (envComponent: string) => {
+  const namespace = await getProjectNamespace(envComponent);
   return (
     await Promise.all(
       (
-        await getProjectMongodbAllPods(env)
+        await getProjectMongodbAllPods(envComponent)
       ).map(async (podName) => ({
         podName,
         componentName: podName.replace(/-mongodb-replicaset-[0-9]+/, ""),
@@ -70,8 +69,10 @@ export const getMongoDbPodsWithReplInfo = async (env: Env) => {
   ).sort((podA, podB) => (podA.isMaster ? (podB.isMaster ? 0 : -1) : 1));
 };
 
-export const getProjectMongodbAllPodsSortedWithLabel = async (env: Env) => {
-  const pods = await getMongoDbPodsWithReplInfo(env);
+export const getProjectMongodbAllPodsSortedWithLabel = async (
+  envComponent: string
+) => {
+  const pods = await getMongoDbPodsWithReplInfo(envComponent);
   const maxComponentNameLength = Math.max(
     ...pods.map((c) => c.componentName.length)
   );

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

@@ -1,3 +1,4 @@
+import { isOfDeployType } from "@catladder/pipeline";
 import { spawn } from "child-process-promise";
 import { writeFile } from "fs-extra";
 import { withFile } from "tmp-promise";
@@ -6,21 +7,23 @@ 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";
+  getEnvVars,
+  getPipelineContextByChoice,
+  getProjectConfig,
+  parseChoice,
+} from "../../../../config/getProjectConfig";
+import { readPass } from "../../../../utils/passwordstore";
+import { envAndComponents } from "./utils/autocompletions";
 
-export default (vorpal: Vorpal) =>
+export default async (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();
+    .command("project-cloud-sql-proxy <envComponent>", "proxy to cloud sql db")
+    .autocomplete(await envAndComponents())
+    .action(async function ({ envComponent }) {
+      const { env, componentName } = parseChoice(envComponent);
+
+      const config = await getProjectConfig();
       // skynet-164509:europe-west6:pvl-cyclomania-review=tcp:5432
 
       const { localPort } = await this.prompt({
@@ -30,18 +33,21 @@ export default (vorpal: Vorpal) =>
         message: "Local port: ",
       });
 
-      const subapp = await promptForSubAppIfAny(this);
-      const POSTGRESQL_PASSWORD = (await getAllEnvVars(env, subapp))
+      const POSTGRESQL_PASSWORD = (await getEnvVars(this, env, componentName))
         ?.POSTGRESQL_PASSWORD;
 
-      const values = await getProjectValues(env, subapp);
-      this.log("");
+      const context = await getPipelineContextByChoice(env, componentName);
+      if (!isOfDeployType(context.componentConfig.deploy, "kubernetes")) {
+        throw new Error("currently only supported for kubernetes deployment");
+      }
       this.log(`postgres-PW: ${POSTGRESQL_PASSWORD}`);
       this.log("");
 
+      const values = context.componentConfig.deploy.values;
+
       const projectId = values?.cloudsql?.projectId || GOOGLE_PROJECT;
 
-      const defaultInstanceId = `${CUSTOMER_NAME}-${APP_NAME}-${env}`;
+      const defaultInstanceId = `${config.customerName}-${config.appName}-${env}`;
       const instanceId = values?.cloudsql?.instanceId || defaultInstanceId;
 
       const defaultRegion = "europe-west6"; // currently hardcoded

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

@@ -0,0 +1,204 @@
+/* eslint-disable no-constant-condition */
+import { stripIndents } from "common-tags";
+import { difference } from "lodash";
+import Vorpal, { CommandInstance } from "vorpal";
+import { GOOGLE_CLOUD_SQL_PASS_PATH } from "../../../../config/constants";
+import {
+  getEnvironment,
+  getEnvVars,
+  getPipelineContextByChoice,
+  getProjectComponents,
+  parseChoice,
+} from "../../../../config/getProjectConfig";
+import { editAsFile } from "../../../../utils/editAsFile";
+import { upsertAllVariables } from "../../../../utils/gitlab";
+import { hasBitwarden, readPass } from "../../../../utils/passwordstore";
+import { delay } from "../../../../utils/promise";
+import { allEnvsAndAllComponents } from "./utils/autocompletions";
+
+/* for convenience, parse json objects. that makes it easier to edit secrets that are object */
+const resolveJson = (v: Record<string, Record<string, string>>) =>
+  Object.fromEntries(
+    Object.entries(v).map(([c, secrets]) => {
+      return [
+        c,
+        Object.fromEntries(
+          Object.entries(secrets).map(([key, value]) => {
+            try {
+              return [key, JSON.parse(value)];
+            } catch (e) {
+              return [key, value];
+            }
+          })
+        ),
+      ];
+    })
+  );
+const getEnvVarsToEdit = async (env: string, componentName: string) => {
+  const { secretEnvVarKeys } = await getEnvironment(env, componentName);
+
+  const allEnvVars = await getEnvVars(this, env, componentName);
+  return Object.fromEntries(
+    secretEnvVarKeys.map((key) => [key, allEnvVars[key]])
+  );
+};
+const doItFor = async (
+  instance: CommandInstance,
+  env: string,
+  components: string[]
+) => {
+  let valuesToEdit: Record<string, Record<string, string>> = Object.fromEntries(
+    await Promise.all(
+      components.map(async (componentName) => [
+        componentName,
+        await getEnvVarsToEdit(env, componentName),
+      ])
+    )
+  );
+  let hasErrors = true;
+  while (hasErrors) {
+    valuesToEdit = await editAsFile(
+      resolveJson(valuesToEdit),
+      stripIndents`
+        Please fill in all secrets for: ${components.join(", ")}
+
+        `
+    );
+    // check for errors
+    hasErrors = false;
+    for (const componentName of components) {
+      const usedKeys = valuesToEdit[componentName]
+        ? Object.keys(valuesToEdit[componentName])
+        : [];
+      // check whether newValues have the exact number of keys
+      const { secretEnvVarKeys } = await getEnvironment(env, componentName);
+      const extranous = difference(usedKeys, secretEnvVarKeys);
+      const missing = difference(secretEnvVarKeys, usedKeys);
+
+      if (extranous.length > 0 || missing.length > 0) {
+        instance.log("");
+        instance.log(
+          `😿 Oh no! There is something wrong with "${componentName}"`
+        );
+        instance.log("");
+        if (extranous.length > 0) {
+          instance.log("these secrets are not declared in the config");
+          extranous.forEach((key) => instance.log(key));
+          instance.log("");
+        }
+        if (missing.length > 0) {
+          instance.log("these secrets have not been provided:");
+          missing.forEach((key) => instance.log(key));
+          instance.log("");
+        }
+
+        await delay(1000);
+        const { shouldContinue } = await instance.prompt({
+          default: true,
+          message: "Try again? 🤔",
+          name: "shouldContinue",
+          type: "confirm",
+        });
+
+        if (!shouldContinue) {
+          throw new Error("abort");
+        }
+        hasErrors = true;
+      }
+    }
+  }
+
+  for (const componentName of components) {
+    await upsertAllVariables(
+      this,
+      valuesToEdit[componentName],
+      env,
+      componentName
+    );
+
+    if (hasBitwarden()) {
+      // add cloud sql secret if needed.
+      // TODO: this is legacy, in the future we want to have one service account per app
+
+      const context = await getPipelineContextByChoice(env, componentName);
+      if (
+        context.componentConfig.deploy &&
+        context.componentConfig.deploy.values?.cloudsql?.enabled
+      ) {
+        await upsertAllVariables(
+          this,
+          {
+            cloudsqlProxyCredentials: await readPass(
+              GOOGLE_CLOUD_SQL_PASS_PATH
+            ),
+          },
+          env,
+          componentName
+        );
+      }
+    }
+  }
+};
+
+export default async (vorpal: Vorpal) => {
+  vorpal
+    .command(
+      "project-config-secrets <envComponent>",
+      "setup/update secrets stored in pass"
+    )
+    .autocomplete(await allEnvsAndAllComponents())
+    .action(async function ({ envComponent }) {
+      const { env, componentName } = parseChoice(envComponent);
+
+      // componentName can be null. in this case, iterate over all  components
+      if (!componentName) {
+        const components = await getProjectComponents();
+        await doItFor(this, env, components);
+      }
+      if (componentName) {
+        await doItFor(this, env, [componentName]);
+      }
+
+      /*
+
+      
+        // 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 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: [...(await envAndComponents()).filter((e) => e !== env), noAnswer],
+    message: "Do you want to copy an env?",
+  });
+  // TODO: reimplenent
+}
+*/

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

@@ -4,24 +4,24 @@ 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";
+  getEnvVars,
+  getProjectConfig,
+  parseChoice,
+} from "../../../../config/getProjectConfig";
+import { readPass } from "../../../../utils/passwordstore";
+import { envAndComponents } from "./utils/autocompletions";
 
-export default (vorpal: Vorpal) =>
+export default async (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();
+    .command(
+      "copy-db <envComponent>",
+      "replace local db with the one from an env"
+    )
+    .autocomplete(await envAndComponents())
+    .action(async function copyDB({ envComponent }) {
+      const { env, componentName } = parseChoice(envComponent);
+      const { customerName, appName } = await getProjectConfig();
 
       const { shouldContinue } = await this.prompt({
         type: "confirm",
@@ -34,15 +34,16 @@ export default (vorpal: Vorpal) =>
         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 { POSTGRESQL_PASSWORD } = await getEnvVars(
+        this,
+        env,
+        componentName
+      );
 
       const LOCAL_PORT = 54321;
 
-      const instanceName = `${GOOGLE_PROJECT}:${GOOGLE_CLOUD_SQL_REGION}:${CUSTOMER_NAME}-${APP_NAME}-${env}=tcp:${LOCAL_PORT}`;
+      const instanceName = `${GOOGLE_PROJECT}:${GOOGLE_CLOUD_SQL_REGION}:${customerName}-${appName}-${env}=tcp:${LOCAL_PORT}`;
       const cloudsqlCredentials = await readPass(GOOGLE_CLOUD_SQL_PASS_PATH);
 
       const { POSTGRESQL_URL } = process.env;
@@ -72,9 +73,7 @@ export default (vorpal: Vorpal) =>
       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
+      pg_dump --dbname=postgres://postgres:${POSTGRESQL_PASSWORD}@localhost:${LOCAL_PORT}/${componentName} --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..."

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

@@ -1,4 +1,3 @@
-import { V1DeleteOptions } from "@kubernetes/client-node";
 import Vorpal from "vorpal";
 import k8sApi from "../../../../k8sApi";
 
@@ -7,17 +6,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-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);
+    .command("project-delete-pods <envComponent>", "delete / restart pods")
+    .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/{shell → cli}/commands/project/commandDeleteProject.ts

@@ -1,18 +1,17 @@
 import Vorpal from "vorpal";
-import { exec, spawn } from "child-process-promise";
-import { Env } from "../../../../types/types";
+import { exec } from "child-process-promise";
 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-delete <env>",
+      "project-delete <envComponent>",
       "deletes a environment of a project (it deletes the namespace)"
     )
-    .autocomplete(envAutocompletion)
-    .action(async function ({ env }) {
-      const namespace = await getProjectNamespace(env as Env);
+    .autocomplete(await envAndComponents())
+    .action(async function ({ envComponent }) {
+      const namespace = await getProjectNamespace(envComponent);
       const { shouldContinue } = await this.prompt({
         type: "confirm",
         name: "shouldContinue",

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

@@ -0,0 +1,15 @@
+import Vorpal from "vorpal";
+import { getEnvVars, parseChoice } from "../../../../config/getProjectConfig";
+import { envAndComponents } from "./utils/autocompletions";
+
+export default async (vorpal: Vorpal) =>
+  vorpal
+    .command("project-env-vars <envComponent>", "list env vars")
+    .autocomplete(await envAndComponents())
+    .action(async function ({ envComponent }) {
+      const { env, componentName } = parseChoice(envComponent);
+      const envvars = await getEnvVars(this, env, componentName);
+      Object.keys(envvars).forEach((key) =>
+        this.log(`${key}: ${envvars[key]}`)
+      );
+    });

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

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

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

@@ -2,24 +2,24 @@ import Vorpal from "vorpal";
 import { logError } from "../../../../utils/log";
 import {
   getProjectNamespace,
-  getProjectPodNames
+  getProjectPodNames,
 } from "../../../../utils/projects";
 import { getShell } from "../../../../utils/shell";
 
-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-get-shell <env>",
+      "project-get-shell <envComponent>",
       "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);
+    .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;
@@ -28,7 +28,7 @@ export default (vorpal: Vorpal) =>
         type: "list",
         name: "podName",
         choices: podNames,
-        message: "Which pod? 🤔"
+        message: "Which pod? 🤔",
       });
 
       return getShell(namespace, podName);

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

@@ -64,7 +64,7 @@ const promptJob = async (vorpal: CommandInstance, projectId: any, ctx: any) => {
   return jobs.find((j: any) => j.id === jobId);
 };
 
-export default (vorpal: Vorpal) => {
+export default async (vorpal: Vorpal) => {
   vorpal.command("project-ci-job-open", "Open a Job").action(async function () {
     const { id: projectId } = await getProjectInfo(this);