@catladder/cli 0.0.0-waitfor-deploy-31ebcf14 → 0.0.0-yarn-cache-a697966f

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

@@ -0,0 +1,136 @@
+import type Vorpal from "vorpal";
+import { spawnCopyDb } from "../../../../gcloud/cloudSql/copyDb";
+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;
+      }
+
+      try {
+        await spawnCopyDb({
+          targetPassword,
+          targetPort,
+          targetUsername,
+          sourceUsername,
+          sourcePassword,
+          sourcePort,
+          sourceDbName,
+          targetDbName,
+        });
+      } 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/cli/commands/general/index.ts

@@ -1,5 +1,5 @@
 import memoizee from "memoizee";
-import Vorpal from "vorpal";
+import type Vorpal from "vorpal";
 import { getk8sApi } from "../../../../k8sApi";
 import { getCurrentContext } from "../../../../utils/cluster";
 import { logError } from "../../../../utils/log";
@@ -7,7 +7,7 @@ import { syncBitwarden } from "../../../../utils/passwordstore";
 import {
   getAllRunningPortForwards,
   stopPortForward,
-} from "../../../../utils/portForward";
+} from "../../../../utils/portForwards";
 import { getShell } from "../../../../utils/shell";
 import { namespaceAutoCompletion } from "./namespaceAutoCompletion";
 import portForward from "./portForward";
@@ -26,19 +26,19 @@ export const getAllNamespacesNames = async () => {
   return namespaces.map((n) => n.metadata.name);
 };
 export default async (vorpal: Vorpal) => {
-  vorpal.command("current-context").action(async function () {
+  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();
@@ -53,7 +53,7 @@ export default async (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();
@@ -62,14 +62,17 @@ export default async (vorpal: Vorpal) => {
     });
 
   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("get-shell <namespace>", "get a shell to a pod in the environment")
+    .command(
+      "kube-get-shell <namespace>",
+      "get a shell to a pod in the environment"
+    )
     .autocomplete(namespaceAutoCompletion)
     .action(async function ({ namespace }) {
       const k8sApi = getk8sApi();

package/src/apps/cli/commands/general/portForward.ts

@@ -1,14 +1,14 @@
-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 { getk8sApi } from "../../../../k8sApi";
 import { namespaceAutoCompletion } from "./namespaceAutoCompletion";
 
 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();
@@ -44,5 +44,5 @@ export default async (vorpal: Vorpal) =>
         message: "Remote port: ",
       });
 
-      return startPortForward(podName, localPort, remotePort, namespace);
+      return startKubePortForward(podName, localPort, remotePort, namespace);
     });

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

@@ -1,4 +1,4 @@
-import Vorpal from "vorpal";
+import type Vorpal from "vorpal";
 import projectMongoDestroyMember from "./projectMongoDestroyMember";
 import projectMongoGetShell from "./projectMongoGetShell";
 import projectMongoPortForward from "./projectMongoPortForward";

package/src/apps/cli/commands/mongodb/projectMongoDestroyMember.ts

@@ -1,10 +1,8 @@
 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 { getProjectNamespace } from "../../../../utils/projects";
 import { envAndComponents } from "../project/utils/autocompletions";
 import ensureCluster from "../project/utils/ensureCluster";
 import { getMongoDbPodsWithReplInfo } from "./utils";

package/src/apps/cli/commands/mongodb/projectMongoGetShell.ts

@@ -1,4 +1,4 @@
-import Vorpal from "vorpal";
+import type Vorpal from "vorpal";
 import { logError } from "../../../../utils/log";
 import { getProjectNamespace } from "../../../../utils/projects";
 import { envAndComponents } from "../project/utils/autocompletions";

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

@@ -1,10 +1,15 @@
-import Vorpal from "vorpal";
+import type Vorpal from "vorpal";
+import {
+  getEnvVarsResolved,
+  parseChoice,
+} from "../../../../config/getProjectConfig";
 import { logError } from "../../../../utils/log";
-import { startPortForward } from "../../../../utils/portForward";
+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
@@ -43,5 +48,18 @@ export default async (vorpal: Vorpal) =>
         default: "30000",
         message: "Local port: ",
       });
-      return startPortForward(podName, localPort, 27017, namespace);
+      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/cli/commands/mongodb/utils/index.ts

@@ -1,11 +1,14 @@
 import { exec, spawn } from "child-process-promise";
-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 (envComponent: string) =>
   filterMongoDbs(await getProjectPodNames(envComponent));
@@ -43,13 +46,18 @@ 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);

package/src/apps/cli/commands/project/cloudSql/commandProjectRestoreDb.ts

@@ -0,0 +1,175 @@
+import type Vorpal from "vorpal";
+import {
+  getEnvVarsResolved,
+  getPipelineContextByChoice,
+} from "../../../../../config/getProjectConfig";
+import type { CloudSqlBackgroundProxy } from "../../../../../gcloud/cloudSql/startProxy";
+import { startCloudSqlProxyInBackground } from "../../../../../gcloud/cloudSql/startProxy";
+import { envAndComponents } from "../utils/autocompletions";
+
+import { ConnectionStringParser } from "connection-string-parser";
+import { spawnCopyDb } from "../../../../../gcloud/cloudSql/copyDb";
+
+export default async (vorpal: Vorpal) =>
+  vorpal
+    .command(
+      "project-cloud-sql-restore-db",
+      "restores a project db from one source to another target"
+    )
+    .action(async function restoreDb() {
+      const envs = await envAndComponents();
+
+      const { sourceEnvAndComponent } = await this.prompt({
+        type: "list",
+        name: "sourceEnvAndComponent",
+        choices: envs,
+
+        message: "Source instance (connection string or 'local')? 🤔 ",
+      });
+
+      const [sourceEnv, sourceComponent] = sourceEnvAndComponent.split(":");
+
+      const sourceContext = await getPipelineContextByChoice(
+        sourceEnv,
+        sourceComponent
+      );
+
+      const sourceEnvVars = await getEnvVarsResolved(
+        this,
+        sourceContext.environment.shortName,
+        sourceContext.componentName
+      );
+
+      let sourceProxy: CloudSqlBackgroundProxy;
+      let sourceDbName: string;
+
+      let sourceUsername: string;
+      let sourcePassword: string;
+
+      let targetUsername: string;
+      let targetPassword: string;
+      let targetProxy: CloudSqlBackgroundProxy;
+
+      let sourcePort: number;
+      let targetPort: number;
+      let targetDbName: string;
+
+      const closeAll = () => {
+        sourceProxy?.stop();
+        targetProxy?.stop();
+      };
+
+      if (sourceEnv === "local") {
+        const parser = new ConnectionStringParser({
+          scheme: "postgres",
+          hosts: [],
+        });
+
+        const parsersResult = parser.parse(sourceEnvVars.DATABASE_URL);
+        sourcePort = parsersResult.hosts?.[0]?.port;
+        sourceUsername = parsersResult.username;
+        sourcePassword = parsersResult.password;
+        sourceDbName = parsersResult.endpoint;
+      } else {
+        sourcePort = 54399;
+        sourceProxy = await startCloudSqlProxyInBackground({
+          instanceName: sourceEnvVars.CLOUD_SQL_INSTANCE_CONNECTION_NAME,
+          localPort: sourcePort,
+        });
+
+        sourceUsername = sourceEnvVars.DB_USER;
+        sourcePassword = sourceEnvVars.DB_PASSWORD;
+        sourceDbName = sourceEnvVars.DB_NAME;
+      }
+
+      const { targetEnvAndComponent } = await this.prompt({
+        type: "list",
+        name: "targetEnvAndComponent",
+        choices: envs,
+
+        message: "target env? 🤔 ",
+      });
+
+      const [targetEnv, targetComponent] = targetEnvAndComponent.split(":");
+
+      const targetContext = await getPipelineContextByChoice(
+        targetEnv,
+        targetComponent
+      );
+
+      const targetEnvVars = await getEnvVarsResolved(
+        this,
+        targetContext.environment.shortName,
+        targetContext.componentName
+      );
+
+      if (targetEnv === "local") {
+        const parser = new ConnectionStringParser({
+          scheme: "postgres",
+          hosts: [],
+        });
+
+        const parsersResult = parser.parse(targetEnvVars.DATABASE_URL);
+
+        targetPort = parsersResult.hosts?.[0]?.port;
+        targetUsername = parsersResult.username;
+        targetPassword = parsersResult.password;
+        targetDbName = parsersResult.endpoint;
+      } else {
+        targetPort = 54499;
+        targetProxy = await startCloudSqlProxyInBackground({
+          instanceName: targetEnvVars.CLOUD_SQL_INSTANCE_CONNECTION_NAME,
+          localPort: targetPort,
+        });
+
+        targetUsername = targetEnvVars.DB_USER;
+        targetPassword = targetEnvVars.DB_PASSWORD;
+        targetDbName = sourceEnvVars.DB_NAME;
+      }
+
+      const { shouldContinue } = await this.prompt({
+        type: "confirm",
+        name: "shouldContinue",
+        message: `This will drop ${targetEnv}/${targetDbName} and replace it with ${sourceEnv}/${sourceDbName}. Continue? 🤔 `,
+      });
+
+      if (!shouldContinue) {
+        this.log("abort");
+        closeAll();
+        return;
+      }
+
+      if (targetContext.environment.envType === "prod") {
+        this.log(
+          `\n🚨 You are overriding a production environment. Please type in ${targetEnvVars.CLOUD_SQL_INSTANCE_CONNECTION_NAME} to continue\n\n`
+        );
+        const { confirmInstance } = await this.prompt({
+          type: "input",
+          name: "confirmInstance",
+          message: "confirm: ",
+        });
+
+        if (
+          confirmInstance !== targetEnvVars.CLOUD_SQL_INSTANCE_CONNECTION_NAME
+        ) {
+          this.log("abort");
+          closeAll();
+          return;
+        }
+      }
+
+      try {
+        await spawnCopyDb({
+          targetPassword,
+          targetPort,
+          targetUsername,
+          sourceUsername,
+          sourcePassword,
+          sourcePort,
+          sourceDbName,
+          targetDbName,
+        });
+      } finally {
+        closeAll();
+      }
+    });