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

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

@@ -0,0 +1,14 @@
+import type Vorpal from "vorpal";
+import { getProjectNamespace } from "../../../../utils/projects";
+import { envAndComponents } from "./utils/autocompletions";
+
+export default async (vorpal: Vorpal) =>
+  vorpal
+    .command(
+      "project-namespace <envComponent>",
+      "show namespace of local project"
+    )
+    .autocomplete(await envAndComponents())
+    .action(async function ({ envComponent }) {
+      this.log(await getProjectNamespace(envComponent));
+    });

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

@@ -0,0 +1,32 @@
+import open from "open";
+import type Vorpal from "vorpal";
+import {
+  GRAFANA_PROXY_LOCAL_PORT,
+  GRAFANA_PROXY_TARGET_PORT,
+} from "../../../../config/constants";
+
+import { startKubePortForward } from "../../../../kubernetes/portForward";
+
+import { getProjectNamespace } from "../../../../utils/projects";
+
+import { envAndComponents } from "./utils/autocompletions";
+import ensureCluster from "./utils/ensureCluster";
+export default async (vorpal: Vorpal) =>
+  vorpal
+    .command(
+      "project-check-costs <envComponent>",
+      "Shows you how much you're spending"
+    )
+    .autocomplete(await envAndComponents())
+    .action(async function ({ envComponent }) {
+      await ensureCluster.call(this, envComponent);
+      const namespace = await getProjectNamespace(envComponent);
+      const url = `http://localhost:${GRAFANA_PROXY_LOCAL_PORT}/namespace.html?name=${namespace}`;
+      await startKubePortForward(
+        "deployment/kubecost-cost-analyzer",
+        GRAFANA_PROXY_LOCAL_PORT,
+        GRAFANA_PROXY_TARGET_PORT,
+        "kubecost"
+      );
+      open(url);
+    });

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

@@ -0,0 +1,28 @@
+import { isOfDeployType } from "@catladder/pipeline";
+import type Vorpal from "vorpal";
+import {
+  getPipelineContextByChoice,
+  parseChoice,
+} from "../../../../config/getProjectConfig";
+import { openGoogleCloudRunDashboard } from "../../../../gcloud/cloudRun/openCloudRunDashboards";
+import { openGoogleCloudKubernetesDashboard } from "../../../../kubernetes/openKubernetesDashboards";
+
+import { envAndComponents } from "./utils/autocompletions";
+
+export default async (vorpal: Vorpal) =>
+  vorpal
+    .command(
+      "project-open-dashboard <envComponent>",
+      "open an apps dashboard (kubernetes or cloudrun)"
+    )
+    .autocomplete(await envAndComponents())
+    .action(async function ({ envComponent }) {
+      const { env, componentName } = parseChoice(envComponent);
+      const context = await getPipelineContextByChoice(env, componentName);
+      if (isOfDeployType(context.componentConfig.deploy, "kubernetes")) {
+        await openGoogleCloudKubernetesDashboard(this, context);
+      }
+      if (isOfDeployType(context.componentConfig.deploy, "google-cloudrun")) {
+        await openGoogleCloudRunDashboard(this, context);
+      }
+    });

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

@@ -0,0 +1,22 @@
+import open from "open";
+import type Vorpal from "vorpal";
+import {
+  getEnvironment,
+  parseChoice,
+} from "../../../../config/getProjectConfig";
+
+import { envAndComponents } from "./utils/autocompletions";
+import ensureCluster from "./utils/ensureCluster";
+
+export default async (vorpal: Vorpal) =>
+  vorpal
+    .command("project-open-env <envComponent>", "open the live environment")
+    .autocomplete(await envAndComponents())
+    .action(async function ({ envComponent }) {
+      const { env, componentName } = parseChoice(envComponent);
+      await ensureCluster.call(this, envComponent);
+      const environment = await getEnvironment(env, componentName);
+      const url = environment.url;
+
+      open(url);
+    });

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

@@ -1,7 +1,7 @@
+import type Vorpal from "vorpal";
 import { exec } from "child-process-promise";
-import Vorpal from "vorpal";
 
-export default (vorpal: Vorpal) =>
+export default async (vorpal: Vorpal) =>
   vorpal
     .command(
       "project-open-git",

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

@@ -1,6 +1,6 @@
 import open from "open";
-import { startPortForward } from "../../../../utils/portForward";
-import Vorpal from "vorpal";
+import { startKubePortForward } from "../../../../kubernetes/portForward";
+import type Vorpal from "vorpal";
 import {
   GRAFANA_PROXY_LOCAL_PORT,
   GRAFANA_PROXY_TARGET_PORT,
@@ -8,20 +8,20 @@ import {
 
 import { getProjectNamespace } 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-open-grafana <env>",
+      "project-open-grafana <envComponent>",
       "open Grafana dashboard for your namespace"
     )
-    .autocomplete(envAutocompletion)
-    .action(async function ({ env }) {
-      await ensureCluster.call(this);
-      const namespace = await getProjectNamespace(env);
+    .autocomplete(await envAndComponents())
+    .action(async function ({ envComponent }) {
+      await ensureCluster.call(this, envComponent);
+      const namespace = await getProjectNamespace(envComponent);
       const url = `http://localhost:${GRAFANA_PROXY_LOCAL_PORT}/grafana/d/at-cost-analysis-namespace2/namespace-utilization-metrics?var-namespace=${namespace}`;
-      await startPortForward(
+      await startKubePortForward(
         "deployment/kubecost-cost-analyzer",
         GRAFANA_PROXY_LOCAL_PORT,
         GRAFANA_PROXY_TARGET_PORT,

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

@@ -1,29 +1,26 @@
 import open from "open";
-import Vorpal from "vorpal";
+import type Vorpal from "vorpal";
 import {
   GRAFANA_PROXY_LOCAL_PORT,
   GRAFANA_PROXY_TARGET_PORT,
 } from "../../../../config/constants";
+import { getProjectPodNames } from "../../../../kubernetes";
 import { logError } from "../../../../utils/log";
-import { startPortForward } from "../../../../utils/portForward";
-
-import {
-  getProjectNamespace,
-  getProjectPodNames,
-} from "../../../../utils/projects";
-
-import { envAutocompletion } from "./utils/autocompletions";
+import { startKubePortForward } from "../../../../kubernetes/portForward";
+import { getProjectNamespace } from "../../../../utils/projects";
+import { envAndComponents } from "./utils/autocompletions";
 import ensureCluster from "./utils/ensureCluster";
-export default (vorpal: Vorpal) =>
+
+export default async (vorpal: Vorpal) =>
   vorpal
     .command(
-      "project-open-grafana-pod <env>",
+      "project-open-grafana-pod <envComponent>",
       "open Grafana dashboard for a specific pod"
     )
-    .autocomplete(envAutocompletion)
-    .action(async function ({ env }) {
-      await ensureCluster.call(this);
-      const podNames = await getProjectPodNames(env);
+    .autocomplete(await envAndComponents())
+    .action(async function ({ envComponent }) {
+      await ensureCluster.call(this, envComponent);
+      const podNames = await getProjectPodNames(envComponent);
       if (podNames.length === 0) {
         logError(this, "sorry, no pods found");
         return;
@@ -34,9 +31,9 @@ export default (vorpal: Vorpal) =>
         choices: podNames,
         message: "Which pod? 🤔",
       });
-      const namespace = await getProjectNamespace(env);
+      const namespace = await getProjectNamespace(envComponent);
       const url = `http://localhost:${GRAFANA_PROXY_LOCAL_PORT}/grafana/d/at-cost-analysis-pod/pod-cost-and-utilization-metrics?var-namespace=${namespace}&var-pod=${podName}`;
-      await startPortForward(
+      await startKubePortForward(
         "deployment/kubecost-cost-analyzer",
         GRAFANA_PROXY_LOCAL_PORT,
         GRAFANA_PROXY_TARGET_PORT,

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

@@ -0,0 +1,21 @@
+import type Vorpal from "vorpal";
+import {
+  getPipelineContextByChoice,
+  parseChoice,
+} from "../../../../config/getProjectConfig";
+import { openGoogleCloudLogs } from "../../../../kubernetes/openKubernetesDashboards";
+import { envAndComponents } from "./utils/autocompletions";
+
+export default async (vorpal: Vorpal) =>
+  vorpal
+    .command(
+      "project-open-logs <envComponent>",
+      "open google cloud logs (stackdriver logs)"
+    )
+    .autocomplete(await envAndComponents())
+    .action(async function ({ envComponent }) {
+      const { env, componentName } = parseChoice(envComponent);
+      const context = await getPipelineContextByChoice(env, componentName);
+
+      await openGoogleCloudLogs(this, context);
+    });

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

@@ -1,15 +1,17 @@
-import Vorpal from "vorpal";
+import type Vorpal from "vorpal";
 import { exec } from "child-process-promise";
-import { Env } from "../../../../types/types";
 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-pause <env>", "halts all running pods (scales to 0)")
-    .autocomplete(envAutocompletion)
-    .action(async function ({ env }) {
-      const namespace = await getProjectNamespace(env as Env);
+    .command(
+      "project-pause <envComponent>",
+      "halts all running pods (scales to 0)"
+    )
+    .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/commandPortForward.ts

@@ -0,0 +1,86 @@
+import type Vorpal from "vorpal";
+import { getProjectPodNames } from "../../../../kubernetes";
+import { logError } from "../../../../utils/log";
+import { startKubePortForward } from "../../../../kubernetes/portForward";
+import { getProjectNamespace } from "../../../../utils/projects";
+import { envAndComponents } from "./utils/autocompletions";
+import ensureCluster from "./utils/ensureCluster";
+import type { CommandInstance } from "vorpal";
+import { parseChoice } from "../../../../config/parseChoice";
+import { getPipelineContextByChoice } from "../../../../config/getProjectConfig";
+import type { Context } from "@catladder/pipeline";
+import { isOfDeployType } from "@catladder/pipeline";
+import { startPortForwardCommand } from "../../../../utils/portForwards";
+import open from "open";
+const kubePortForward = async (cmd: CommandInstance, envComponent: string) => {
+  await ensureCluster.call(cmd, envComponent);
+  const namespace = await getProjectNamespace(envComponent);
+  const podNames = await getProjectPodNames(envComponent);
+  if (podNames.length === 0) {
+    logError(cmd, "sorry, no pods found");
+    return;
+  }
+  const { podName } = await cmd.prompt({
+    type: "list",
+    name: "podName",
+    choices: podNames,
+    message: "Which pod? 🤔",
+  });
+
+  const { localPort } = await cmd.prompt({
+    type: "number",
+    name: "localPort",
+
+    message: "Local port: ",
+  });
+
+  const { remotePort } = await cmd.prompt({
+    type: "number",
+    name: "remotePort",
+
+    message: "Remote port: ",
+  });
+
+  return startKubePortForward(podName, localPort, remotePort, namespace);
+};
+
+const cloudRunPortForward = async (cmd: CommandInstance, context: Context) => {
+  if (!isOfDeployType(context.componentConfig.deploy, "google-cloudrun")) {
+    throw new Error("not cloud run");
+  }
+
+  const { fullName } = context.environment;
+  let serviceName = fullName;
+  if (context.environment.envType === "review") {
+    const { mr } = await cmd.prompt({
+      type: "number",
+      name: "mr",
+
+      message: "Which mr 🤔 ",
+    });
+    // poor mans solution
+    serviceName = serviceName.replace("-review-", "-review-mr" + mr + "-");
+  }
+
+  const { projectId, region } = context.componentConfig.deploy;
+
+  const command = `gcloud beta run services proxy ${serviceName} --project ${projectId} --region ${region}`;
+
+  await startPortForwardCommand(`cloudRun/${serviceName}`, command);
+  open("http://localhost:8080");
+};
+export default async (vorpal: Vorpal) =>
+  vorpal
+    .command("project-port-forward <envComponent>", "start port-forwarding")
+    .autocomplete(await envAndComponents())
+    .action(async function ({ envComponent }) {
+      const { env, componentName } = parseChoice(envComponent);
+      const context = await getPipelineContextByChoice(env, componentName);
+
+      if (isOfDeployType(context.componentConfig.deploy, "kubernetes")) {
+        await kubePortForward(this, envComponent);
+      }
+      if (isOfDeployType(context.componentConfig.deploy, "google-cloudrun")) {
+        await cloudRunPortForward(this, context);
+      }
+    });

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

@@ -0,0 +1,27 @@
+/* eslint-disable no-constant-condition */
+import type Vorpal from "vorpal";
+import type { CommandInstance } from "vorpal";
+import { clearBackups } from "../../../../utils/gitlab";
+import { allEnvsAndAllComponents } from "./utils/autocompletions";
+
+export const projectSecretsClearBackups = async (
+  vorpal: CommandInstance,
+  keep = 3
+) => {
+  await clearBackups(vorpal, keep);
+};
+
+export default async (vorpal: Vorpal) => {
+  vorpal
+    .command("project-secrets-clear-backups", "clears all backups")
+    .autocomplete(await allEnvsAndAllComponents())
+    .action(async function () {
+      const { keep } = await this.prompt({
+        type: "number",
+        name: "keep",
+        default: 1,
+        message: "How many backups should we keep? 🤔",
+      });
+      return await projectSecretsClearBackups(this, keep);
+    });
+};

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

@@ -0,0 +1,12 @@
+import type Vorpal from "vorpal";
+import { setupProject } from "./setup";
+
+export default async (vorpal: Vorpal) =>
+  vorpal
+    .command(
+      "project-setup",
+      "Initializes all environments and creates requires resources, service accounts, etc."
+    )
+    .action(async function () {
+      await setupProject(this);
+    });

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

@@ -1,18 +1,19 @@
-import { V1Job, V1ObjectMeta } from "@kubernetes/client-node";
+import type { V1ObjectMeta } from "@kubernetes/client-node";
+import { V1Job } from "@kubernetes/client-node";
 
-import Vorpal from "vorpal";
-import { k8sApiBatch, k8sApiBatchBeta } from "../../../../k8sApi";
+import type Vorpal from "vorpal";
+import { getk8sApiBatch, getk8sApiBatchBeta } from "../../../../k8sApi";
 import { logError } from "../../../../utils/log";
 import { namespaceAutoCompletion } from "../general/namespaceAutoCompletion";
 
 import { getProjectNamespace } from "../../../../utils/projects";
-import { envAutocompletion } from "./utils/autocompletions";
+import { envAndComponents } from "./utils/autocompletions";
 import ensureCluster from "./utils/ensureCluster";
 
 async function triggerCronjob(namespace: string) {
   const {
     body: { items: jobs },
-  } = await k8sApiBatchBeta.listNamespacedCronJob(namespace);
+  } = await getk8sApiBatchBeta().listNamespacedCronJob(namespace);
 
   const jobNames = jobs.map((j) => j.metadata.name);
 
@@ -34,7 +35,7 @@ async function triggerCronjob(namespace: string) {
   job.metadata = metadata as V1ObjectMeta;
   job.spec = jobSpec;
   try {
-    const result = await k8sApiBatch.createNamespacedJob(namespace, job);
+    const result = await getk8sApiBatch().createNamespacedJob(namespace, job);
 
     this.log("");
     this.log(`yeah, you got a job, man. 😺 ${result.body.metadata.name}`);
@@ -43,7 +44,7 @@ async function triggerCronjob(namespace: string) {
     logError(this, "command failed", e.body);
   }
 }
-export default (vorpal: Vorpal) => {
+export default async (vorpal: Vorpal) => {
   vorpal
     .command("trigger-cronjob <namespace>", "trigger cronjob")
     .autocomplete(namespaceAutoCompletion)
@@ -51,11 +52,11 @@ export default (vorpal: Vorpal) => {
       await triggerCronjob.call(this, namespace);
     });
   vorpal
-    .command("project-trigger-cronjob <env>", "trigger cronjob")
-    .autocomplete(envAutocompletion)
-    .action(async function ({ env }) {
-      await ensureCluster.call(this);
-      const namespace = await getProjectNamespace(env);
+    .command("project-trigger-cronjob <envComponent>", "trigger cronjob")
+    .autocomplete(await envAndComponents())
+    .action(async function ({ envComponent }) {
+      await ensureCluster.call(this, envComponent);
+      const namespace = await getProjectNamespace(envComponent);
       await triggerCronjob.call(this, namespace);
     });
 };

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

@@ -1,15 +1,15 @@
-import Vorpal from "vorpal";
+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";
 import commandGetMyTotalWorktime from "./commandGetMyTotalWorktime";
 import commandGetShell from "./commandGetShell";
 import commandGitlabCi from "./commandGitlabCi";
-import commandInitGitlab from "./commandInitGitlab";
-import commandInitProject from "./commandInitProject";
+import commandSetup from "./commandSetup";
+//import commandInitProject from "./commandInitProject.old";
 import commandListPods from "./commandListPods";
 import commandMigrateHelm3 from "./commandMigrateHelm3";
 import commandNamespace from "./commandNamespace";
@@ -22,15 +22,15 @@ import commandPauseProject from "./commandPauseProject";
 import commandOpenGrafana from "./commandOpenGrafana";
 import commandPortForward from "./commandPortForward";
 import commandTriggerCronjob from "./commandTriggerCronjob";
-import commandVariables from "./commandVariables";
+
 import commandOpenGrafanaPod from "./commandOpenGrafanaPod";
+import commandSecretsClearBackups from "./commandSecretsClearBackups";
+
+export default async (vorpal: Vorpal) => {
+  commandSetup(vorpal);
 
-export default (vorpal: Vorpal) => {
-  commandInitProject(vorpal);
-  commandInitGitlab(vorpal);
   commandEnvVars(vorpal);
 
-  commandVariables(vorpal);
   commandNamespace(vorpal);
   commandListPods(vorpal);
   commandPauseProject(vorpal);
@@ -49,8 +49,8 @@ export default (vorpal: Vorpal) => {
   commandOpenEnv(vorpal);
   commandTriggerCronjob(vorpal);
   commandConfigSecrets(vorpal);
+  commandSecretsClearBackups(vorpal);
   commandDeletePods(vorpal);
-  commandCopyDB(vorpal);
 
   commandGetShell(vorpal);
   commandPortForward(vorpal);

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

@@ -0,0 +1,44 @@
+import type { CommandInstance } from "vorpal";
+import { getAllPipelineContexts } from "../../../../../config/getProjectConfig";
+import { projectConfigSecrets } from "../commandConfigSecrets";
+import { setupAccessTokens } from "./setupAccessTokens";
+import { setupContext } from "./setupContext";
+import { setupTopic } from "./setupTopic";
+
+export const setupProject = async (instance: CommandInstance) => {
+  const allContext = await getAllPipelineContexts();
+
+  for (const context of allContext) {
+    await setupContext(instance, context);
+  }
+  await setupAccessTokens(instance);
+  await setupTopic(instance);
+  instance.log("");
+  const { configSecrets } = await instance.prompt({
+    default: true,
+    message: "Before deployments work, you need to config secrets. Do it now?",
+    name: "configSecrets",
+    type: "confirm",
+  });
+  instance.log("");
+  if (configSecrets) {
+    await projectConfigSecrets(instance);
+  } else {
+    instance.log(
+      "👆 don't forget to config secret using `project-config-secrets`"
+    );
+  }
+  instance.log("");
+  instance.log("gitlab is ready! 🥂");
+  instance.log("\n");
+  instance.log("do not forget to make sure that:");
+  [
+    "you have __health route in place",
+    "lint and test are defined",
+    "secrets are configured (call project-config-secret)",
+    "eat your vegetables",
+    "be awesome 🤩",
+  ].forEach((tip) => instance.log(` - ${tip}`));
+  instance.log("\n");
+  instance.log("\n");
+};

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

@@ -0,0 +1,84 @@
+import open from "open";
+import type { CommandInstance } from "vorpal";
+import { doGitlabRequest, getProjectInfo } from "../../../../../utils/gitlab";
+
+export const setupAccessTokens = async (instance: CommandInstance) => {
+  const { id: projectId, web_url: projectWebUrl } = await getProjectInfo(
+    instance
+  );
+  try {
+    await doGitlabRequest(instance, `projects/${projectId}/variables/GL_TOKEN`);
+  } catch (e) {
+    if (e.message !== "not found") {
+      throw e;
+    }
+    // not found
+
+    instance.log(
+      "I need add a GL_TOKEN to the project, so that semantic release will work\n"
+    );
+    instance.log(
+      "👉 Please please create a project access token in gitlab and copy its value into clipboard\n\n - name: something like 'semantic-release'\n - expires: leave empty\n - role: maintainer - scopes: api, read_repository"
+    );
+    instance.log("\n");
+
+    const { understood } = await instance.prompt({
+      default: true,
+      message: "Understood and open gitlab now? 🤔",
+      name: "understood",
+      type: "confirm",
+    });
+    if (!understood) {
+      instance.log("continuing anyway...");
+    }
+    open(`${projectWebUrl}/-/settings/access_tokens`);
+
+    instance.log("\n");
+
+    instance.log("Enter your copied token now: ");
+
+    instance.log("\n");
+    const { GL_TOKEN } = await instance.prompt({
+      type: "password",
+      name: "GL_TOKEN",
+      message: "Access Token: ",
+    });
+
+    await doGitlabRequest(
+      instance,
+      `projects/${projectId}/variables`,
+      {
+        key: "GL_TOKEN",
+        value: GL_TOKEN,
+        masked: true,
+      },
+      "POST"
+    );
+  }
+
+  const deploy_tokens = await doGitlabRequest(
+    instance,
+    `projects/${projectId}/deploy_tokens`
+  );
+
+  if (
+    !deploy_tokens.find(
+      (v: { name: string }) => v.name === "gitlab-deploy-token"
+    )
+  ) {
+    instance.log(
+      "I will setup the 'GitLab Deploy Token', so Kubernetes can pull images from this project."
+    );
+
+    await doGitlabRequest(
+      instance,
+      `projects/${projectId}/deploy_tokens`,
+      {
+        id: projectId,
+        name: "gitlab-deploy-token",
+        scopes: ["read_registry"],
+      },
+      "POST"
+    );
+  }
+};