@catladder/cli 0.0.0-refactor-env-context-76787e25 → 0.0.0-refactor-needs-c896b98e

package/package.json

@@ -24,7 +24,7 @@
     "node": ">=12.0.0"
   },
   "devDependencies": {
-    "@catladder/pipeline": "0.0.0-refactor-env-context-76787e25",
+    "@catladder/pipeline": "0.0.0-refactor-needs-c896b98e",
     "@kubernetes/client-node": "^0.16.2",
     "@tsconfig/node14": "^1.0.1",
     "@types/common-tags": "^1.8.0",
@@ -57,6 +57,6 @@
     "typescript": "^4.5.4",
     "vorpal": "^1.12.0"
   },
-  "version": "0.0.0-refactor-env-context-76787e25",
+  "version": "0.0.0-refactor-needs-c896b98e",
   "stableVersion": "0.0.0"
 }

package/src/apps/cli/cli.ts

@@ -4,6 +4,7 @@ import packageInfos from "../../packageInfos";
 import { stopAllPortForwards } from "../../utils/portForward";
 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";
 
@@ -29,6 +30,7 @@ export default async () => {
 
   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";
+
+const createProxy = async (instance: string, port: number) => {
+  const proxy = spawn(
+    `cloud_sql_proxy -instances ${instance}=tcp:${port}`,
+    [],
+    { shell: "bash" }
+  );
+  // wait until it starts
+  await spawn(
+    `echo -n "Waiting for proxy"
+      until echo > /dev/tcp/localhost/${port}; do
+        sleep 0.2
+        echo -n "."
+      done 2>/dev/null`,
+    [],
+    { shell: "bash" }
+  );
+  const stop = () => proxy.childProcess.kill();
+  process.on("beforeExit", stop);
+
+  return {
+    stop,
+  };
+};
+
+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: { stop: () => void };
+
+      let targetProxy: { stop: () => void };
+
+      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 createProxy(sourceInstance, sourcePort);
+      }
+
+      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: "Targe 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 createProxy(targetInstance, targetPort);
+      }
+
+      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=postgres -q ${command}`;
+
+      const copyDBScript = `
+      set -e
+     
+    
+
+      dumptmp=$(mktemp /tmp/dump.XXXXXX)
+
+      echo "Dumping file to $dumptmp"
+      pg_dump --dbname=postgres://postgres:${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/cli/commands/project/commandCloudSqlProxy.ts

@@ -1,3 +1,4 @@
+import type { Context } from "@catladder/pipeline";
 import { isOfDeployType } from "@catladder/pipeline";
 import { spawn } from "child-process-promise";
 import { writeFile } from "fs-extra";
@@ -7,11 +8,15 @@ import {
   getEnvVars,
   getGitlabVar,
   getPipelineContextByChoice,
-  getProjectConfig,
   parseChoice,
 } from "../../../../config/getProjectConfig";
 import { envAndComponents } from "./utils/autocompletions";
 
+type ProxyInfo = {
+  instanceName: string;
+  DB_NAME: string;
+  DB_PASSWORD: string;
+};
 export default async (vorpal: Vorpal) =>
   vorpal
     .command("project-cloud-sql-proxy <envComponent>", "proxy to cloud sql db")
@@ -19,9 +24,26 @@ export default async (vorpal: Vorpal) =>
     .action(async function ({ envComponent }) {
       const { env, componentName } = parseChoice(envComponent);
 
-      const config = await getProjectConfig();
-      // skynet-164509:europe-west6:pvl-cyclomania-review=tcp:5432
+      const context = await getPipelineContextByChoice(env, componentName);
+      let proxyInfo: ProxyInfo;
+
+      if (env === "review") {
+        vorpal.log(
+          "⚠️ connection string does not include mr information on review environments"
+        );
+      }
+      if (isOfDeployType(context.componentConfig.deploy, "kubernetes")) {
+        proxyInfo = await getProxyInfoForKubernetes(context);
+      } else if (
+        isOfDeployType(context.componentConfig.deploy, "google-cloudrun")
+      ) {
+        proxyInfo = await getProxyInfoForCloudRun(context);
+      } else {
+        throw new Error("unsupported environment");
+      }
 
+      // skynet-164509:europe-west6:pvl-cyclomania-review=tcp:5432
+      const { DB_PASSWORD, DB_NAME, instanceName } = proxyInfo;
       const { localPort } = await this.prompt({
         type: "number",
         name: "localPort",
@@ -29,35 +51,16 @@ export default async (vorpal: Vorpal) =>
         message: "Local port: ",
       });
 
-      const envVars = await getEnvVars(this, env, componentName);
-      const POSTGRESQL_PASSWORD = envVars?.POSTGRESQL_PASSWORD;
-
-      const context = await getPipelineContextByChoice(env, componentName);
-      if (!isOfDeployType(context.componentConfig.deploy, "kubernetes")) {
-        throw new Error("currently only supported for kubernetes deployment");
-      }
       this.log("");
-      this.log(`postgres-PW: ${POSTGRESQL_PASSWORD}`);
+      this.log(`postgres-PW: ${DB_PASSWORD}`);
       this.log("");
       this.log(
-        `POSTGRESQL_URL=postgresql://postgres:${POSTGRESQL_PASSWORD}@localhost:${localPort}/${context.environment.envVars.KUBE_APP_NAME}?schema=public`
+        `POSTGRESQL_URL=postgresql://postgres:${DB_PASSWORD}@localhost:${localPort}/${DB_NAME}?schema=public`
       );
       this.log("");
 
-      const values = context.componentConfig.deploy.values;
-
-      const projectId =
-        values?.cloudsql?.projectId ||
-        context.componentConfig.deploy.cluster?.projectId;
-
-      const defaultInstanceId = `${config.customerName}-${config.appName}-${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}`;
-
+      // legacy, some projects have the cloudsqlProxyCredentials in the secrets
+      // actually it works without, if the current local shell user has access to the db through google cloud
       const cloudsqlProxyCredentials = await getGitlabVar(
         this,
         env,
@@ -65,20 +68,20 @@ export default async (vorpal: Vorpal) =>
         "cloudsqlProxyCredentials"
       );
 
-      if (!cloudsqlProxyCredentials) {
-        // we store cloudsqlProxyCredentials on gitlab, but its currently get pushed via bitwarden due to legacy reasons
-        // this will be fixed with when https://git.panter.ch/catladder/catladder/-/merge_requests/32/ is merged
-        this.log(
-          "cloudsqlProxyCredentials env var missing in gitlab. Please contact gilde-ci-cd about that."
-        );
-        throw new Error("cloudsqlProxyCredentials missing in secrets");
-      }
       await withFile(async ({ path: tmpFilePath }) => {
-        await writeFile(tmpFilePath, cloudsqlProxyCredentials);
+        if (cloudsqlProxyCredentials) {
+          await writeFile(tmpFilePath, cloudsqlProxyCredentials);
+        }
 
         await spawn(
           "cloud_sql_proxy",
-          ["-instances", instanceName, "-credential_file", tmpFilePath],
+          [
+            "-instances",
+            `${instanceName}=tcp:${localPort}`,
+            ...(cloudsqlProxyCredentials
+              ? ["-credential_file", tmpFilePath]
+              : []),
+          ],
           {
             stdio: "inherit",
             shell: true,
@@ -86,3 +89,69 @@ export default async (vorpal: Vorpal) =>
         );
       });
     });
+
+const getProxyInfoForKubernetes = async (
+  context: Context
+): Promise<ProxyInfo> => {
+  if (!isOfDeployType(context.componentConfig.deploy, "kubernetes")) {
+    throw new Error("unsupported");
+  }
+
+  const envVars = await getEnvVars(
+    this,
+    context.environment.shortName,
+    context.componentName
+  );
+
+  const DB_PASSWORD = envVars?.DB_PASSWORD || envVars?.POSTGRESQL_PASSWORD;
+
+  const DB_NAME = context.environment.envVars.KUBE_APP_NAME;
+
+  const values = context.componentConfig.deploy.values;
+
+  const projectId =
+    values?.cloudsql?.projectId ||
+    context.componentConfig.deploy.cluster?.projectId;
+
+  const defaultInstanceId = `${context.fullConfig.customerName}-${context.fullConfig.appName}-${context.environment.shortName}`;
+  const instanceId = values?.cloudsql?.instanceId || defaultInstanceId;
+
+  const defaultRegion = "europe-west6"; // currently hardcoded
+  const region = values?.cloudsql?.region || defaultRegion;
+
+  const instanceName = `${projectId}:${region}:${instanceId}`;
+
+  return {
+    instanceName,
+    DB_PASSWORD,
+    DB_NAME,
+  };
+};
+
+const getProxyInfoForCloudRun = async (
+  context: Context
+): Promise<ProxyInfo> => {
+  if (
+    !isOfDeployType(context.componentConfig.deploy, "google-cloudrun") ||
+    !context.componentConfig.deploy.cloudSql
+  ) {
+    throw new Error("unsupported");
+  }
+
+  const envVars = await getEnvVars(
+    this,
+    context.environment.shortName,
+    context.componentName
+  );
+
+  const DB_PASSWORD = envVars?.DB_PASSWORD;
+
+  const DB_NAME = context.environment.envVars.DB_NAME;
+
+  return {
+    instanceName:
+      context.componentConfig.deploy.cloudSql.instanceConnectionName,
+    DB_PASSWORD,
+    DB_NAME,
+  };
+};

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

@@ -8,7 +8,7 @@ export default async (vorpal: Vorpal) =>
       "show the total worktime that you spent on a project"
     )
     .action(async () => {
-      await spawn("sh", ["-c", "curl -L http://bit.ly/10hA8iC | bash"], {
+      await spawn("sh", ["-c", "curl -s -L http://bit.ly/3VQEKNq | bash"], {
         stdio: ["pipe", "inherit", "pipe"],
       });
     });

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

@@ -1,7 +1,7 @@
 import type 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";
@@ -51,7 +51,6 @@ export default async (vorpal: Vorpal) => {
   commandConfigSecrets(vorpal);
   commandSecretsClearBackups(vorpal);
   commandDeletePods(vorpal);
-  commandCopyDB(vorpal);
 
   commandGetShell(vorpal);
   commandPortForward(vorpal);

package/src/apps/cli/commands/project/setup/setupCloudRun.ts

@@ -26,7 +26,15 @@ export const setupCloudRun = async (
 
   instance.log("enable required servies...");
   await enableGCloudServices(
-    ["run.googleapis.com", "artifactregistry.googleapis.com"],
+    [
+      "run.googleapis.com",
+      "artifactregistry.googleapis.com",
+      "cloudscheduler.googleapis.com", // for scheduling jobs
+      "cloudresourcemanager.googleapis.com", // only required to get google cloud project number
+      ...(config.cloudSql
+        ? ["sqladmin.googleapis.com", "sql-component.googleapis.com"]
+        : []),
+    ],
     config
   );
   instance.log("upsert artifacts registry...");
@@ -46,6 +54,8 @@ export const setupCloudRun = async (
         "roles/artifactregistry.repoAdmin",
         "roles/run.admin",
         "roles/iam.serviceAccountUser",
+        "roles/cloudscheduler.admin", // for scheduling
+        ...(config.cloudSql ? ["roles/cloudsql.admin"] : []),
       ],
     },
     GCLOUD_DEPLOY_CREDENTIALS_KEY

package/src/apps/cli/commands/project/setup/setupCloudSQL.ts

@@ -1,15 +1,18 @@
 import type { Context } from "@catladder/pipeline";
-import { getCloudSQLConfig, hasCloudSQL } from "@catladder/pipeline";
+import {
+  getKubernetesCloudSQLConfig,
+  hasKubernetesCloudSQL,
+} from "@catladder/pipeline";
 import type { CommandInstance } from "vorpal";
 
 export const setupCloudSQL = async (
   instance: CommandInstance,
   context: Context
 ) => {
-  if (!hasCloudSQL(context)) {
+  if (!hasKubernetesCloudSQL(context)) {
     throw new Error("cannot setup cloudsql, as it has none");
   }
-  const config = getCloudSQLConfig(context);
+  const config = getKubernetesCloudSQLConfig(context);
   instance.log("");
   instance.log(
     "! make sure to provide cloudsqlProxyCredentials for the cloud sql service account in " +

package/src/apps/cli/commands/project/setup/setupContext.ts

@@ -1,5 +1,5 @@
 import type { Context } from "@catladder/pipeline";
-import { isOfDeployType, hasCloudSQL } from "@catladder/pipeline";
+import { isOfDeployType, hasKubernetesCloudSQL } from "@catladder/pipeline";
 import type { CommandInstance } from "vorpal";
 import { setupCloudRun } from "./setupCloudRun";
 import { setupCloudSQL } from "./setupCloudSQL";
@@ -25,7 +25,7 @@ export const setupContext = async (
   if (isOfDeployType(context.componentConfig.deploy, "google-cloudrun")) {
     await setupCloudRun(instance, context);
   }
-  if (hasCloudSQL(context)) {
+  if (hasKubernetesCloudSQL(context)) {
     await setupCloudSQL(instance, context);
   }
 

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

@@ -19,7 +19,7 @@ export default async (vorpal: Vorpal) => {
   vorpal
     .command("starwars", "Long time ago... in a galaxy far far away...")
     .action(async function () {
-      starwarsPromise = spawn("telnet", ["towel.blinkenlights.nl"], {
+      starwarsPromise = spawn("telnet", ["2001:7b8:666:ffff::1:42"], {
         stdio: ["pipe", "inherit", "pipe"],
       });
       await starwarsPromise;

package/src/apps/cli/verify/migration/fromv2.ts

@@ -36,6 +36,7 @@ export const LEGACY_ENVS = [
 
 const arrayToRecord = (arr: { name: string }[]): Record<string, any> => {
   if (!arr) return undefined;
+  if (!Array.isArray(arr)) return arr;
   return Object.fromEntries(arr.map(({ name, ...rest }) => [name, rest]));
 };
 

package/src/apps/cli/verify/migration/oldGitlabCi.ts

@@ -43,6 +43,6 @@ export const detectBuildConfig = (
   }
 
   if (firstInclude.file === "rails-kubernetes.yml") {
-    throw new Error("rails is not yet implemented");
+    return "rails";
   }
 };

package/src/config/getProjectConfig.ts

@@ -150,8 +150,13 @@ export const getEnvVars = async (
   env: string,
   componentName: string
 ) => {
-  const envionment = await getEnvironment(env, componentName);
-  // in the pipeline the secrets alreadyy exists  and bash will expand them
-  // but here we need to manually load them
-  return resolveSecrets(vorpal, envionment.envVars);
+  try {
+    const envionment = await getEnvironment(env, componentName);
+    // in the pipeline the secrets alreadyy exists  and bash will expand them
+    // but here we need to manually load them
+    return resolveSecrets(vorpal, envionment.envVars);
+  } catch (e) {
+    // env is disabled
+    return {};
+  }
 };

package/dist/apps/cli/commands/project/commandCopyDB.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"commandCopyDB.js","sourceRoot":"","sources":["../../../../../src/apps/cli/commands/project/commandCopyDB.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,wEAI6C;AAE7C,2DAA2D;AAE3D,sBAAe,UAAO,MAAc;;;;;gBAClC,KAAA,CAAA,KAAA,MAAM;qBACH,OAAO,CACN,wBAAwB,EACxB,2CAA2C,CAC5C,CAAA;qBACA,YAAY,CAAA;gBAAC,qBAAM,IAAA,kCAAgB,GAAE,EAAA;oBALxC,sBAAA,cAKgB,SAAwB,EAAC;qBACtC,MAAM,CAAC,SAAe,MAAM,CAAC,EAAgB;wBAAd,YAAY,kBAAA;;;;;;oCACpC,KAAyB,IAAA,8BAAW,EAAC,YAAY,CAAC,EAAhD,GAAG,SAAA,EAAE,aAAa,mBAAA,CAA+B;oCACvB,qBAAM,IAAA,mCAAgB,GAAE,EAAA;;oCAApD,KAA4B,SAAwB,EAAlD,YAAY,kBAAA,EAAE,OAAO,aAAA;oCAEF,qBAAM,IAAI,CAAC,MAAM,CAAC;4CAC3C,IAAI,EAAE,SAAS;4CACf,IAAI,EAAE,gBAAgB;4CACtB,OAAO,EACL,sFAAsF;yCACzF,CAAC,EAAA;;oCALM,cAAc,GAAK,CAAA,SAKzB,CAAA,eALoB;oCAOtB,IAAI,CAAC,cAAc,EAAE;wCACnB,sBAAO;qCACR;;;;;iBA6DF,CAAC,EAAA;;;KAAA,EAAC"}

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

@@ -1,92 +0,0 @@
-import { spawn } from "child-process-promise";
-import type Vorpal from "vorpal";
-import {
-  getEnvVars,
-  getProjectConfig,
-  parseChoice,
-} from "../../../../config/getProjectConfig";
-import { readPass } from "../../../../utils/passwordstore";
-import { envAndComponents } from "./utils/autocompletions";
-
-export default async (vorpal: Vorpal) =>
-  vorpal
-    .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",
-        name: "shouldContinue",
-        message:
-          "This will drop your local database and replace it with the remote one. Continue? 🤔 ",
-      });
-
-      if (!shouldContinue) {
-        return;
-      }
-
-      // TODO: reimpleent with new config
-      /*
-      throw new Error("needs reimplementation with new config");
-      const GOOGLE_CLOUD_SQL_REGION = "europe-west6"; // currently hardcoded
-      const { POSTGRESQL_PASSWORD } = await getEnvVars(
-        this,
-        env,
-        componentName
-      );
-
-      const LOCAL_PORT = 54321;
-
-      const instanceName = `${"xxxxxx reimplement shoulld be project id"}:${GOOGLE_CLOUD_SQL_REGION}:${customerName}-${appName}-${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}/${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..."
-      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" });
-      */
-    });