@catladder/cli 0.0.0-test7 → 0.0.0-update-meteor-53480fed

package/src/apps/{shell/shell.ts → cli/cli.ts}

@@ -1,16 +1,21 @@
 import Vorpal from "vorpal";
 // tslint:disable-next-line:no-var-requires
 import packageInfos from "../../packageInfos";
-import { stopAllPortForwards } from "../../utils/portForward";
+import { stopAllPortForwards } from "../../utils/portForwards";
 import general from "./commands/general";
 import mongodb from "./commands/mongodb";
+import cloudSQL from "./commands/cloudSQL";
 import project from "./commands/project";
 import theStuffThatReallyMatters from "./commands/theStuffThatReallyMatters";
-const welcomeMessage = `catladder 2 😻 version ${packageInfos.version}`;
 
-export default () => {
+import { verify } from "./verify";
+import { showProjectBanner } from "./commands/project/utils/showProjectBanner";
+
+export default async () => {
   const vorpal = new Vorpal();
 
+  const welcomeMessage = `catladder 2022 😻 version ${packageInfos.version}`;
+
   vorpal
     .delimiter("catladder $") // emoji messes with cursor :-( https://github.com/dthree/vorpal/issues/332
     .history("catladder")
@@ -19,8 +24,13 @@ export default () => {
     .log(welcomeMessage)
     .log("");
 
+  await showProjectBanner(vorpal);
+
+  verify(vorpal);
+
   general(vorpal);
   project(vorpal);
+  cloudSQL(vorpal);
   mongodb(vorpal);
   theStuffThatReallyMatters(vorpal);
 

package/src/apps/cli/commands/cloudSQL/commandRestoreDb.ts

@@ -0,0 +1,154 @@
+import { spawn } from "child-process-promise";
+
+import type Vorpal from "vorpal";
+import type { CloudSqlBackgroundProxy } from "../../../../gcloud/cloudSql/startProxy";
+import { startCloudSqlProxyInBackground } from "../../../../gcloud/cloudSql/startProxy";
+
+export default async (vorpal: Vorpal) =>
+  vorpal
+    .command(
+      "cloud-sql-restore-db",
+      "restore a db from one source to another target"
+    )
+    .action(async function restoreDb() {
+      const { sourceInstance } = await this.prompt({
+        type: "input",
+        name: "sourceInstance",
+
+        message: "Source instance (connection string or 'local')? 🤔 ",
+      });
+
+      let sourceProxy: CloudSqlBackgroundProxy;
+
+      let targetProxy: CloudSqlBackgroundProxy;
+
+      let sourcePort: number;
+      let targetPort: number;
+
+      if (sourceInstance === "local") {
+        const { sourceLocalPort } = await this.prompt({
+          type: "number",
+          name: "sourceLocalPort",
+          default: 5432,
+
+          message: "Local Port for source? 🤔 ",
+        });
+        sourcePort = sourceLocalPort;
+      } else {
+        sourcePort = 54399;
+        sourceProxy = await startCloudSqlProxyInBackground({
+          instanceName: sourceInstance,
+          localPort: sourcePort,
+        });
+      }
+
+      const { sourceUsername } = await this.prompt({
+        type: "input",
+        name: "sourceUsername",
+        default: "postgres",
+
+        message: "Source Username? 🤔 ",
+      });
+
+      const { sourcePassword } = await this.prompt({
+        type: "input",
+        name: "sourcePassword",
+
+        message: "Source Password? 🤔 ",
+      });
+
+      const { sourceDbName } = await this.prompt({
+        type: "input",
+        name: "sourceDbName",
+
+        message: "Source DB name? 🤔 ",
+      });
+
+      const { targetInstance } = await this.prompt({
+        type: "input",
+        name: "targetInstance",
+
+        message: "Target INSTANCE (connection string or 'local')? 🤔  ",
+      });
+
+      if (targetInstance === "local") {
+        const { targetLocalPort } = await this.prompt({
+          type: "number",
+          name: "targetLocalPort",
+          default: 5432,
+
+          message: "Local Port for target? 🤔 ",
+        });
+        targetPort = targetLocalPort;
+      } else {
+        targetPort = 54499;
+        targetProxy = await startCloudSqlProxyInBackground({
+          instanceName: targetInstance,
+          localPort: targetPort,
+        });
+      }
+
+      const { targetUsername } = await this.prompt({
+        type: "input",
+        name: "targetUsername",
+        default: "postgres",
+
+        message: "Target Username? 🤔 ",
+      });
+      const { targetPassword } = await this.prompt({
+        type: "input",
+        name: "targetPassword",
+
+        message: "Target Password? 🤔 ",
+      });
+
+      const { targetDbName } = await this.prompt({
+        type: "input",
+        name: "targetDbName",
+
+        message: "Target DB name? 🤔 ",
+      });
+
+      const { shouldContinue } = await this.prompt({
+        type: "confirm",
+        name: "shouldContinue",
+        message: `This will drop ${targetInstance}/${targetDbName} and replace it with ${sourceInstance}/${sourceDbName}. Continue? 🤔 `,
+      });
+
+      if (!shouldContinue) {
+        return;
+      }
+
+      const targetPSQL = (command: string) =>
+        `PGPASSWORD=${targetPassword} psql -p ${targetPort} --host=localhost --user=${targetUsername} -q ${command}`;
+
+      const copyDBScript = `
+      set -e
+     
+    
+
+      dumptmp=$(mktemp /tmp/dump.XXXXXX)
+
+      echo "Dumping file to $dumptmp"
+      pg_dump --dbname=postgres://${sourceUsername}:${sourcePassword}@localhost:${sourcePort}/${sourceDbName} --no-owner --no-privileges > $dumptmp
+      echo "dump done"
+      ${targetPSQL(
+        `-c 'drop database "${targetDbName}" WITH (FORCE)' 1> /dev/null || true`
+      )}
+      ${targetPSQL(`-c 'create database "${targetDbName}"' 1> /dev/null`)}
+          echo "Restoring dump..."
+      ${targetPSQL(`"${targetDbName}" < $dumptmp 1> /dev/null`)}
+  
+
+      echo "Clean up..."
+      set +e
+      rm $dumptmp
+      echo "\n🐱 Done!"
+      `;
+      try {
+        await spawn(copyDBScript, [], { shell: "bash", stdio: "inherit" });
+      } finally {
+        sourceProxy?.stop();
+        targetProxy?.stop();
+      }
+    });

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

@@ -0,0 +1,8 @@
+import type Vorpal from "vorpal";
+//import commandInitProject from "./commandInitProject.old";
+
+import commandRestoreDb from "./commandRestoreDb";
+
+export default async (vorpal: Vorpal) => {
+  commandRestoreDb(vorpal);
+};

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

@@ -1,29 +1,20 @@
 import memoizee from "memoizee";
-import Vorpal from "vorpal";
-import k8sApi from "../../../../k8sApi";
-import {
-  connectToCluster,
-  getAllClusterNames,
-  getCurrentConnectedClusterName,
-  getCurrentContext,
-} from "../../../../utils/cluster";
+import type Vorpal from "vorpal";
+import { getk8sApi } from "../../../../k8sApi";
+import { getCurrentContext } from "../../../../utils/cluster";
 import { logError } from "../../../../utils/log";
 import { syncBitwarden } from "../../../../utils/passwordstore";
 import {
   getAllRunningPortForwards,
   stopPortForward,
-} from "../../../../utils/portForward";
+} from "../../../../utils/portForwards";
 import { getShell } from "../../../../utils/shell";
-import { getGoogleAuthUserNumber } from "../../utils/getGoogleAuthUserNumber";
-import {
-  openGoogleCloudKubernetesDashboard,
-  openGoogleCloudLogs,
-} from "../shared";
 import { namespaceAutoCompletion } from "./namespaceAutoCompletion";
 import portForward from "./portForward";
 
 const getAllNamespaces = memoizee(
   async () => {
+    const k8sApi = getk8sApi();
     const res = await k8sApi.listNamespace();
     return res.body.items;
   },
@@ -34,29 +25,23 @@ export const getAllNamespacesNames = async () => {
   const namespaces = await getAllNamespaces();
   return namespaces.map((n) => n.metadata.name);
 };
-export default (vorpal: Vorpal) => {
-  vorpal
-    .command("connect-cluster <clustername>")
-    .autocomplete(getAllClusterNames())
-    .action(async function ({ clustername }) {
-      this.log(`connecting to ${clustername}`);
-      await connectToCluster(clustername);
-    });
-  vorpal.command("current-context").action(async function () {
+export default async (vorpal: Vorpal) => {
+  vorpal.command("kube-current-context").action(async function () {
     this.log(await getCurrentContext());
   });
 
   vorpal
-    .command("list-namespaces", "list all namespaces")
+    .command("kube-list-namespaces", "list all namespaces")
     .action(async function () {
       const namespaces = await getAllNamespacesNames();
       this.log(namespaces.join("\n"));
     });
 
   vorpal
-    .command("list-secrets <namespace>", "show secrets")
+    .command("kube-list-secrets <namespace>", "show secrets")
     .autocomplete(namespaceAutoCompletion)
     .action(async function ({ namespace }) {
+      const k8sApi = getk8sApi();
       const res = await k8sApi.listNamespacedSecret(namespace);
 
       this.log(res.body.items.map((n) => n.metadata.name).join("\n"));
@@ -68,50 +53,29 @@ export default (vorpal: Vorpal) => {
   });
 
   vorpal
-    .command("list-pods <namespace>", "list all pods of namespace")
+    .command("kube-list-pods <namespace>", "list all pods of namespace")
     .autocomplete(namespaceAutoCompletion)
     .action(async function ({ namespace }) {
+      const k8sApi = getk8sApi();
       const res = await k8sApi.listNamespacedPod(namespace);
       this.log(res.body.items.map((n) => n.metadata.name).join("\n"));
     });
 
   vorpal
-    .command("stop-portforward <name>", "stop a running port forward")
+    .command("kube-stop-portforward <name>", "stop a running port forward")
     .autocomplete({ data: async () => getAllRunningPortForwards() })
     .action(async function ({ name }) {
       stopPortForward(name.trim());
     });
 
-  vorpal
-    .command("open-dashboard <namespace>", "open kubernetes dashboard")
-    .autocomplete(namespaceAutoCompletion)
-    .action(async function ({ namespace }) {
-      const clustername = await getCurrentConnectedClusterName();
-      const authGoogleNumber = await getGoogleAuthUserNumber.call(this, vorpal);
-
-      await openGoogleCloudKubernetesDashboard(
-        authGoogleNumber,
-        clustername,
-        namespace
-      );
-    });
   vorpal
     .command(
-      "open-logs <namespace>",
-      "open google cloud logs (stackdriver stuff)"
+      "kube-get-shell <namespace>",
+      "get a shell to a pod in the environment"
     )
     .autocomplete(namespaceAutoCompletion)
     .action(async function ({ namespace }) {
-      const clustername = await getCurrentConnectedClusterName();
-      const authGoogleNumber = await getGoogleAuthUserNumber.call(this, vorpal);
-
-      await openGoogleCloudLogs(authGoogleNumber, clustername, namespace);
-    });
-
-  vorpal
-    .command("get-shell <namespace>", "get a shell to a pod in the environment")
-    .autocomplete(namespaceAutoCompletion)
-    .action(async function ({ namespace }) {
+      const k8sApi = getk8sApi();
       const res = await k8sApi.listNamespacedPod(namespace);
       if (res.body.items.length === 0) {
         logError(this, "sorry, no pods found");

package/src/apps/{shell → cli}/commands/general/portForward.ts

@@ -1,16 +1,17 @@
-import Vorpal from "vorpal";
+import type Vorpal from "vorpal";
 import { logError } from "../../../../utils/log";
 
-import { startPortForward } from "../../../../utils/portForward";
+import { startKubePortForward } from "../../../../kubernetes/portForward";
 
-import k8sApi from "../../../../k8sApi";
+import { getk8sApi } from "../../../../k8sApi";
 import { namespaceAutoCompletion } from "./namespaceAutoCompletion";
 
-export default (vorpal: Vorpal) =>
+export default async (vorpal: Vorpal) =>
   vorpal
-    .command("port-forward <namespace>", "start port-forwarding")
+    .command("kube-port-forward <namespace>", "start port-forwarding")
     .autocomplete(namespaceAutoCompletion)
     .action(async function ({ namespace }) {
+      const k8sApi = getk8sApi();
       const res = await k8sApi.listNamespacedPod(namespace);
       if (res.body.items.length === 0) {
         logError(this, "sorry, no pods found");
@@ -43,5 +44,5 @@ export default (vorpal: Vorpal) =>
         message: "Remote port: ",
       });
 
-      return startPortForward(podName, localPort, remotePort, namespace);
+      return startKubePortForward(podName, localPort, remotePort, namespace);
     });

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

@@ -1,9 +1,9 @@
-import Vorpal from "vorpal";
+import type Vorpal from "vorpal";
 import projectMongoDestroyMember from "./projectMongoDestroyMember";
 import projectMongoGetShell from "./projectMongoGetShell";
 import projectMongoPortForward from "./projectMongoPortForward";
 
-export default (vorpal: Vorpal) => {
+export default async (vorpal: Vorpal) => {
   projectMongoGetShell(vorpal);
   projectMongoPortForward(vorpal);
   projectMongoDestroyMember(vorpal);

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

@@ -1,11 +1,9 @@
 import { exec } from "child-process-promise";
-import Vorpal from "vorpal";
+import type Vorpal from "vorpal";
+import { getProjectPvcs } from "../../../../kubernetes";
 import { logError } from "../../../../utils/log";
-import {
-  getProjectNamespace,
-  getProjectPvcs
-} from "../../../../utils/projects";
-import { envAutocompletion } from "../project/utils/autocompletions";
+import { getProjectNamespace } from "../../../../utils/projects";
+import { envAndComponents } from "../project/utils/autocompletions";
 import ensureCluster from "../project/utils/ensureCluster";
 import { getMongoDbPodsWithReplInfo } from "./utils";
 
@@ -31,18 +29,18 @@ const removeFinalizerAndDelete = async (
 ) => {
   return Promise.all([
     removeFinalizer(namespace, type, name),
-    await deleteResource(namespace, type, name)
+    await deleteResource(namespace, type, name),
   ]);
 };
-export default (vorpal: Vorpal) =>
+export default async (vorpal: Vorpal) =>
   vorpal
     .command(
-      "project-mongo-destroy-member <env>",
+      "project-mongo-destroy-member <envComponent>",
       "DESTROY a member of a replicaset in order to reinitialize it"
     )
-    .autocomplete(envAutocompletion)
-    .action(async function({ env }) {
-      await ensureCluster.call(this);
+    .autocomplete(await envAndComponents())
+    .action(async function ({ envComponent }) {
+      await ensureCluster.call(this, envComponent);
       this.log(
         "this command tries to delete a (secondary) member of the replicaset, it's persistent volume claim (pvc) and the volume"
       );
@@ -67,18 +65,18 @@ export default (vorpal: Vorpal) =>
         default: true,
         message: "DO YOU UNDERSTAND?",
         name: "understood",
-        type: "confirm"
+        type: "confirm",
       });
 
       if (!understood) {
         throw new Error("abort");
       }
 
-      const namespace = await getProjectNamespace(env);
-      const mongodbPods = await getMongoDbPodsWithReplInfo(env);
+      const namespace = await getProjectNamespace(envComponent);
+      const mongodbPods = await getMongoDbPodsWithReplInfo(envComponent);
 
-      const pvcs = await getProjectPvcs(env);
-      const secondaries = mongodbPods.filter(pod => !pod.isMaster);
+      const pvcs = await getProjectPvcs(envComponent);
+      const secondaries = mongodbPods.filter((pod) => !pod.isMaster);
 
       if (secondaries.length === 0) {
         logError(this, "sorry, no pods found");
@@ -89,16 +87,16 @@ export default (vorpal: Vorpal) =>
         await this.prompt({
           type: "list",
           name: "podName",
-          choices: secondaries.map(p => ({
+          choices: secondaries.map((p) => ({
             name: `[ secondary ] ${p.podName}`,
-            value: p.podName
+            value: p.podName,
           })),
-          message: "Which pod? 🤔"
+          message: "Which pod? 🤔",
         })
       ).podName;
 
       const thePvc = pvcs.find(
-        pvc => pvc.metadata.name === `datadir-${podName}`
+        (pvc) => pvc.metadata.name === `datadir-${podName}`
       );
       if (!thePvc) {
         logError(this, `sorry, no pvc found for ${podName}`);
@@ -109,7 +107,7 @@ export default (vorpal: Vorpal) =>
         message:
           "THIS WILL DESTROY THE POD, ITS VOLUME AND ALL ITS DATA 🙀🙀🙀!!! continue? 🤔",
         name: "shouldContinue",
-        type: "confirm"
+        type: "confirm",
       });
 
       if (!shouldContinue) {

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

@@ -1,24 +1,26 @@
-import Vorpal from "vorpal";
+import type 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/cli/commands/mongodb/projectMongoPortForward.ts

@@ -0,0 +1,65 @@
+import type Vorpal from "vorpal";
+import {
+  getEnvVarsResolved,
+  parseChoice,
+} from "../../../../config/getProjectConfig";
+import { logError } from "../../../../utils/log";
+import { startKubePortForward } from "../../../../kubernetes/portForward";
+import { getProjectNamespace } from "../../../../utils/projects";
+import { envAndComponents } from "../project/utils/autocompletions";
+import ensureCluster from "../project/utils/ensureCluster";
+import { getProjectMongodbAllPodsSortedWithLabel } from "./utils";
+import clipboard from "clipboardy";
+
+export default async (vorpal: Vorpal) =>
+  vorpal
+    .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;
+      }
+      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: ",
+      });
+      const { env, componentName } = parseChoice(envComponent);
+      const envVars = await getEnvVarsResolved(this, env, componentName);
+      const MONGODB_ROOT_PASSWORD = envVars?.MONGODB_ROOT_PASSWORD;
+      const connectionUrl = `mongodb://root:${MONGODB_ROOT_PASSWORD}@localhost:${localPort}`;
+      clipboard.writeSync(connectionUrl);
+      this.log("");
+      this.log("username: root");
+      this.log(`password: ${MONGODB_ROOT_PASSWORD}`);
+      this.log(`connection string: ${connectionUrl}`);
+      this.log("");
+      this.log("👆 connection string has been copied to your clipboard!");
+      this.log("");
+
+      return startKubePortForward(podName, localPort, 27017, namespace);
+    });

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

@@ -1,15 +1,17 @@
 import { exec, spawn } from "child-process-promise";
-import { Env } from "../../../../../types/types";
-import {
-  getProjectNamespace,
-  getProjectPodNames,
-} from "../../../../../utils/projects";
+import { getProjectPodNames } from "../../../../../kubernetes";
+import { getProjectNamespace } from "../../../../../utils/projects";
 
 const filterMongoDbs = (podNames: string[]) =>
-  podNames.filter((name) => name.includes("mongodb-replicaset"));
+  podNames.filter(
+    (name) =>
+      name.includes("mongodb") &&
+      !name.includes("mongodb-backup") &&
+      !name.includes("arbiter")
+  );
 
-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`;
@@ -44,23 +46,28 @@ export const executeMongodbCommand = async (
 };
 
 export const podIsMaster = async (namespace: string, podName: string) => {
-  const result = await executeMongodbCommand(
-    namespace,
-    podName,
-    "db.isMaster()"
-  );
+  try {
+    const result = await executeMongodbCommand(
+      namespace,
+      podName,
+      "db.isMaster()"
+    );
 
-  return result.ismaster;
+    return result.ismaster;
+  } catch (e) {
+    // maybe shutting down ?
+    return null;
+  }
 };
 
 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 +77,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)
   );