@catladder/cli 0.0.0

package/src/apps/shell/commands/project/commandGitlabCi.ts

@@ -0,0 +1,114 @@
+import { exec } from "child-process-promise";
+import { last } from "lodash";
+import open from "open";
+import Vorpal, { CommandInstance } from "vorpal";
+import {
+  doGitlabRequest,
+  getGitlabToken,
+  getProjectInfo,
+} from "../../../../utils/gitlab";
+
+const statusEmojiMap: any = {
+  failed: "🙀",
+  warning: "😿",
+  pending: "🍺",
+  running: "🏃‍",
+  manual: "🤚",
+  scheduled: "🍺",
+  canceled: "😽",
+  success: "😻",
+  skipped: "🤭",
+  created: "🍺",
+};
+
+const statusTxt = (status: any) =>
+  statusEmojiMap[status] ? `${statusEmojiMap[status]} ${status}` : status;
+
+const getCurrentCommit = async () => {
+  const result = await exec("git rev-parse HEAD");
+  return result.stdout && result.stdout.replace(/\n$/, "");
+};
+
+const delay = async (ms: any) =>
+  new Promise((resolve) => setTimeout(resolve, ms));
+
+const promptJob = async (vorpal: CommandInstance, projectId: any, ctx: any) => {
+  const jobs = await doGitlabRequest(vorpal, `projects/${projectId}/jobs`);
+
+  const commitId = await getCurrentCommit();
+
+  const jobsToName = (jo: any[]) =>
+    jo.map(
+      (j: any) => `${j.ref}-${j.name}-${j.user.username}-${j.status}-${j.id}`
+    );
+
+  const preferredJobs = jobs.filter((j: any) => j.commit.id === commitId);
+  const moreJobs = jobs.filter((j: any) => !preferredJobs.includes(j.ref));
+  const sortedJobs =
+    preferredJobs.length > 1
+      ? [
+          ...jobsToName(preferredJobs),
+          "========================================================",
+          ...jobsToName(moreJobs),
+        ]
+      : jobsToName([...preferredJobs, ...moreJobs]);
+
+  const { jobName } = await ctx.prompt({
+    type: "list",
+    name: "jobName",
+    choices: sortedJobs,
+    message: "Which job? 🤔",
+  });
+
+  const jobId = Number(last(jobName.split("-")));
+  return jobs.find((j: any) => j.id === jobId);
+};
+
+export default (vorpal: Vorpal) => {
+  vorpal.command("project-ci-job-open", "Open a Job").action(async function () {
+    const { id: projectId } = await getProjectInfo(this);
+
+    const job = await promptJob(this, projectId, this);
+    open(job.web_url);
+  });
+
+  vorpal
+    .command("project-ci-job-log", "Show a job's log")
+    .action(async function () {
+      const { id: projectId } = await getProjectInfo(this);
+
+      const { id } = await promptJob(this, projectId, this);
+
+      let finished = false;
+      while (!finished) {
+        const trace = await exec(
+          `curl -s --header "PRIVATE-TOKEN: ${await getGitlabToken(
+            this
+          )}" "https://git.panter.ch/api/v4/projects/${projectId}/jobs/${id}/trace"`
+        );
+
+        const job = await doGitlabRequest(
+          this,
+          `projects/${projectId}/jobs/${id}`
+        );
+
+        if (trace.stdout) {
+          vorpal.ui.redraw(`${trace.stdout}`);
+        } else {
+          vorpal.ui.redraw(`
+
+          ${statusTxt(job.status)}
+          ${job.web_url}
+
+          `);
+        }
+
+        finished = !!job.finished_at;
+        if (!finished) {
+          await delay(5000);
+        } else {
+          vorpal.ui.redraw.done();
+        }
+      }
+    });
+};

package/src/apps/shell/commands/project/commandInitGitlab.ts

@@ -0,0 +1,157 @@
+import open from "open";
+import Vorpal from "vorpal";
+import { getClusterByName } from "../../../../utils/cluster";
+import { doGitlabRequest, getProjectInfo } from "../../../../utils/gitlab";
+import { readPass, syncBitwarden } from "../../../../utils/passwordstore/";
+import {
+  getLocalProjectVariables,
+  getProjectNamespace,
+} from "../../../../utils/projects";
+
+export default (vorpal: Vorpal) =>
+  vorpal
+    .command(
+      "project-init-gitlab",
+      "Initializes the gitlab repo, e.g. connects the cluster to it"
+    )
+    .action(async function () {
+      const { id: projectId, web_url: projectWebUrl } = await getProjectInfo(
+        this
+      );
+      await syncBitwarden();
+      const clusters = await doGitlabRequest(
+        this,
+        `projects/${projectId}/clusters`
+      );
+
+      if (clusters.length === 0) {
+        this.log("");
+        this.log("there is no cluster on the current project?");
+      } else {
+        this.log("there are already these clusters on the gitlab: ");
+        this.log("");
+        clusters.forEach((cluster: any) => this.log(` - ${cluster.name}`));
+      }
+
+      this.log("");
+      this.log("your project specifies the following cluster:");
+      this.log("");
+      const { CLUSTER_NAME } = await getLocalProjectVariables();
+      const configuredCluster = await getClusterByName(CLUSTER_NAME);
+      if (!configuredCluster) {
+        throw new Error(
+          `there exist no cluster with the name '${CLUSTER_NAME}'`
+        );
+      }
+      this.log(`${CLUSTER_NAME} (${configuredCluster.fullName})`);
+      this.log("");
+      const { shouldContinue } = await this.prompt({
+        type: "confirm",
+        name: "shouldContinue",
+        message: "Should I add the this cluster ? 🤔  ",
+      });
+      this.log("");
+      if (shouldContinue) {
+        const { api_url, passCredentials } = configuredCluster;
+        if (!api_url) {
+          throw new Error("no api_url on this cluster!");
+        }
+        if (!passCredentials) {
+          throw new Error("no passCredentials on this cluster!");
+        }
+        const token = await readPass(passCredentials.token);
+        const ca_cert = await readPass(passCredentials.ca_cert);
+
+        const postResult = await doGitlabRequest(
+          this,
+          `projects/${projectId}/clusters/user`,
+          {
+            name: configuredCluster.fullName,
+            managed: false,
+            platform_kubernetes_attributes: {
+              api_url,
+              ca_cert,
+              token,
+              namespace: await getProjectNamespace("prod"),
+            },
+          }
+        );
+        const { message } = postResult;
+        if (message) {
+          this.log(`Message from gitlab: ${message}`);
+        }
+      }
+
+      const variables = await doGitlabRequest(
+        this,
+        `projects/${projectId}/variables`
+      );
+
+      if (!variables.find((v: any) => v.key === "GL_TOKEN")) {
+        this.log(
+          "I need add a GL_TOKEN to the project, so that semantic release will work\n"
+        );
+        this.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 - scopes: api, read_repository"
+        );
+        this.log("\n");
+
+        const { understood } = await this.prompt({
+          default: true,
+          message: "Understood and open gitlab now? 🤔",
+          name: "understood",
+          type: "confirm",
+        });
+        if (!understood) {
+          this.log("continuing anyway...");
+        }
+        open(`${projectWebUrl}/-/settings/access_tokens`);
+
+        this.log("\n");
+
+        this.log("Enter your copied token now: ");
+
+        this.log("\n");
+        const { GL_TOKEN } = await this.prompt({
+          type: "password",
+          name: "GL_TOKEN",
+          message: "Access Token: ",
+        });
+        await doGitlabRequest(this, `projects/${projectId}/variables`, {
+          key: "GL_TOKEN",
+          value: GL_TOKEN,
+        });
+      }
+
+      const deploy_tokens = await doGitlabRequest(
+        this,
+        `projects/${projectId}/deploy_tokens`
+      );
+
+      if (
+        !deploy_tokens.find(
+          (v: { name: string }) => v.name === "gitlab-deploy-token"
+        )
+      ) {
+        this.log(
+          "I will setup the 'GitLab Deploy Token', so Kubernetes can pull images from this project."
+        );
+
+        await doGitlabRequest(this, `projects/${projectId}/deploy_tokens`, {
+          id: projectId,
+          name: "gitlab-deploy-token",
+          scopes: ["read_registry"],
+        });
+      }
+      this.log("gitlab is ready! 🥂");
+      this.log("\n");
+      this.log("do not forget to make sure that:");
+      [
+        "you have __health route in place",
+        "lint and test are defined",
+        "eat your vegetables",
+        "be awesome 🤩",
+      ].forEach((tip) => this.log(` - ${tip}`));
+      this.log("\n");
+      this.log("\n");
+    });

package/src/apps/shell/commands/project/commandInitProject.ts

@@ -0,0 +1,282 @@
+import { readFile, writeFile } from "fs-extra";
+import { safeDump } from "js-yaml";
+import { mapKeys, snakeCase, toUpper } from "lodash";
+import path from "path";
+import Vorpal from "vorpal";
+import { hasGitlabCiFile } from "../../../../utils/projects";
+
+const transformVar = (key: string) => toUpper(snakeCase(key));
+type GitlabCiIncludeObj = {
+  project: string;
+  ref: string;
+  file: string;
+};
+
+type FileToCreate = {
+  filename: string;
+  content: string | (() => Promise<string>);
+};
+
+type PlatformDefinition = {
+  variables: {
+    [key: string]: string;
+  };
+  gitlabCiInclude: GitlabCiIncludeObj;
+  values: { [key: string]: unknown };
+  filesToCreate?: FileToCreate[];
+};
+const DEFAULT_VARIABLES = {
+  clusterName: "production",
+};
+// TODO: we should find a way how to fetch the variables of the inclues directly from gitlab
+const DEFAULT_NODE_APPLICATION = {};
+
+const DEFAULT_FILES_TO_CREATE: FileToCreate[] = [
+  {
+    filename: ".envrc",
+    content: async () =>
+      readFile(path.resolve(__dirname, "../includes/envrc"), "utf8"),
+  },
+];
+const PLATFORMS: { [platformName: string]: PlatformDefinition } = {
+  nextJS: {
+    variables: {},
+    gitlabCiInclude: {
+      project: "catladder/gitlab-ci",
+      ref: "v1",
+      file: "node-kubernetes.yml",
+    },
+    values: {
+      application: DEFAULT_NODE_APPLICATION,
+    },
+    filesToCreate: [
+      {
+        content: "v14",
+        filename: ".nvmrc",
+      },
+    ],
+  },
+  nestJS: {
+    variables: {},
+    gitlabCiInclude: {
+      project: "catladder/gitlab-ci",
+      ref: "v1",
+      file: "node-kubernetes.yml",
+    },
+    values: {
+      application: {
+        command: "yarn start:prod --port $(PORT)",
+      },
+    },
+    filesToCreate: [
+      {
+        content: "v14",
+        filename: ".nvmrc",
+      },
+    ],
+  },
+  node: {
+    variables: {},
+    gitlabCiInclude: {
+      project: "catladder/gitlab-ci",
+      ref: "v1",
+      file: "node-kubernetes.yml",
+    },
+    values: {
+      application: DEFAULT_NODE_APPLICATION,
+    },
+    filesToCreate: [
+      {
+        content: "v14",
+        filename: ".nvmrc",
+      },
+    ],
+  },
+  staticJs: {
+    variables: {},
+    gitlabCiInclude: {
+      project: "catladder/gitlab-ci",
+      ref: "v1",
+      file: "static-js-kubernetes.yml",
+    },
+    values: {},
+  },
+  meteor: {
+    variables: {},
+    gitlabCiInclude: {
+      project: "gitlab-ci/meteor-kubernetes",
+      ref: "v1",
+      file: "meteor-kubernetes.yml",
+    },
+    values: {},
+  },
+  rails: {
+    variables: {},
+    gitlabCiInclude: {
+      project: "catladder/gitlab-ci",
+      ref: "v1",
+      file: "rails-kubernetes.yml",
+    },
+    values: {
+      env: {
+        public: {
+          RAILS_ENV: "production",
+          PORT: 8080,
+        },
+        secret: {
+          POSTGRESQL_PASSWORD: "app-secrets",
+        },
+      },
+      application: {
+        command: ["/cnb/process/web"],
+        livenessProbe: {
+          httpGet: {
+            path: "/robots.txt",
+            httpHeaders: null,
+          },
+        },
+        readinessProbe: {
+          httpGet: {
+            path: "/robots.txt",
+            httpHeaders: null,
+          },
+        },
+      },
+      cloudsql: { enabled: true },
+      jobs: {
+        "db-prepare": {
+          hook: "post-install,post-upgrade",
+          command: "/cnb/lifecycle/launcher bundle exec rake db:prepare",
+        },
+      },
+    },
+    filesToCreate: [
+      {
+        filename: "values-review.yml",
+        content: async () =>
+          safeDump({
+            jobs: {
+              "db-prepare-seed": {
+                hook: "post-install",
+                command:
+                  "/cnb/lifecycle/launcher bundle exec rake db:prepare db:seed",
+              },
+              "db-prepare": {
+                hook: "post-upgrade",
+                command: "/cnb/lifecycle/launcher bundle exec rake db:prepare",
+              },
+            },
+          }),
+      },
+    ],
+  },
+  other: {
+    variables: {},
+    gitlabCiInclude: {
+      project: "catladder/gitlab-ci",
+      ref: "v1",
+      file: "panter-kubernetes-base.yml",
+    },
+    values: {},
+  },
+};
+export default (vorpal: Vorpal) =>
+  vorpal
+    .command("project-init", "Inits a new project")
+    .action(async function () {
+      const hasGitlabFile = await hasGitlabCiFile();
+      if (hasGitlabFile) {
+        this.log("there is already a gitlab-ci.yml file. Skipping");
+      } else {
+        this.log("Alright. Let's do this! 😼");
+        this.log("");
+
+        const questions = [
+          {
+            type: "input",
+            name: "customerName",
+            default: "pan",
+            message: "Which customer?",
+          },
+          {
+            type: "input",
+            name: "appName",
+            message: "What is the app's name?",
+          },
+          {
+            type: "input",
+            name: "componentName",
+            default: "web",
+            message:
+              "And the componentName?\n(in multi-app projects, you have to chose a different componentName for each app, e.g. frontend and backend)\n\n",
+          },
+          {
+            type: "list",
+            name: "platform",
+            choices: Object.keys(PLATFORMS),
+            message: "What is your app platform?",
+          },
+        ].map((q) => ({
+          ...q,
+          validate: Boolean,
+          message: `${q.message} `,
+        }));
+        const { customerName, appName, componentName, platform } =
+          await this.prompt(questions);
+
+        const {
+          gitlabCiInclude,
+          variables: platformVariables,
+          values,
+          filesToCreate,
+        } = PLATFORMS[platform];
+
+        const allVariables = {
+          customerName,
+          appName,
+          componentName,
+          ...DEFAULT_VARIABLES,
+          ...platformVariables,
+        };
+        const allFilesToCreate = [
+          ...DEFAULT_FILES_TO_CREATE,
+          ...(filesToCreate ?? []),
+        ];
+        const transformedVariables = mapKeys(allVariables, (value, key) =>
+          transformVar(key)
+        );
+
+        const gitlabCiContentObj = {
+          include: [gitlabCiInclude],
+          variables: transformedVariables,
+        };
+
+        const gitlabCiContent = safeDump(gitlabCiContentObj);
+        await writeFile(".gitlab-ci.yml", gitlabCiContent);
+
+        allFilesToCreate.forEach(async ({ filename, content }) => {
+          const theContent =
+            typeof content === "function" ? await content() : content;
+          await writeFile(filename, theContent);
+        });
+
+        await writeFile("values.yml", safeDump(values));
+
+        this.log("");
+        this.log("gitlab-ci created! 💪😻");
+        this.log("feel free to adjust it to your needs!");
+        this.log("");
+        this.log("we also create an .envrc for you which works with direnv");
+        this.log("");
+      }
+      const { shouldContinue } = await this.prompt({
+        default: true,
+        message:
+          "should we continue with setting up your gitlab? 🤔 (connecting cluster and stuff)",
+        name: "shouldContinue",
+        type: "confirm",
+      });
+      if (shouldContinue) {
+        await vorpal.execSync(`project-init-gitlab`);
+      }
+    });

package/src/apps/shell/commands/project/commandListPods.ts

@@ -0,0 +1,21 @@
+import yaml from "js-yaml";
+import { pick } from "lodash";
+import Vorpal from "vorpal";
+import { getProjectPods } from "../../../../utils/projects";
+
+import { envAutocompletion } from "./utils/autocompletions";
+import ensureCluster from "./utils/ensureCluster";
+
+export default (vorpal: Vorpal) =>
+  vorpal
+    .command("project-list-pods <env>", "list pods of local project")
+    .autocomplete(envAutocompletion)
+    .action(async function({ env }) {
+      await ensureCluster.call(this);
+      const pods = await getProjectPods(env);
+      this.log(
+        yaml.safeDump(
+          pods.map(p => pick(p, ["metadata.name", "status.startTime"]))
+        )
+      );
+    });

package/src/apps/shell/commands/project/commandMigrateHelm3.ts

@@ -0,0 +1,53 @@
+import { exec } from "child-process-promise";
+import Vorpal from "vorpal";
+import { logError } from "../../../../utils/log";
+import { getProjectHelmReleaseName } from "../../../../utils/projects";
+import { envAutocompletion } from "./utils/autocompletions";
+
+/**
+ * Error: rendered manifests contain a resource that already exists.
+ * Unable to continue with install: ConfigMap "web-app-env" in namespace "pvl-bike2school-dev" exists and cannot be imported into the current release: invalid ownership metadata; label validation error: missing key "app.kubernetes.io/managed-by": must be set to "Helm"; annotation validation error: missing key "meta.helm.sh/release-name": must be set to "pvl-bike2school-dev-web"; annotation validation error: missing key "meta.helm.sh/release-namespace": must be set to "pvl-bike2school-dev"
+ */
+export default (vorpal: Vorpal) =>
+  vorpal
+    .command(
+      "project-migrate-helm3 <env>",
+      "Do manual step for helm2 to helm3 migration"
+    )
+    .autocomplete(
+      envAutocompletion.filter((e) => e !== "dev-local" && e !== "review")
+    )
+    .action(async function ({ env }) {
+      try {
+        const result = await exec("helm version --short");
+        const version = result.stdout as string;
+        this.log(`your helm version: ${version}`);
+        if (!version.startsWith("v3")) {
+          throw new Error("no helm3");
+        }
+        try {
+          await exec(
+            "helm plugin install https://github.com/helm/helm-2to3.git"
+          );
+          this.log(
+            "successfully installed plugin https://github.com/helm/helm-2to3.git"
+          );
+        } catch (e) {
+          // ignore
+        }
+        const releaseName = await getProjectHelmReleaseName(env);
+        this.log(`helm release name: ${releaseName}`);
+        this.log("");
+        this.log("migrating now... 😼. This may take a moment");
+        this.log("");
+        const r = await exec(
+          `helm 2to3 convert --delete-v2-releases ${releaseName}`
+        );
+        this.log(r);
+      } catch (e) {
+        logError(this, e.message);
+        this.log("make sure that you have installed latest helm3 locally");
+        this.log("(e.g. brew upgrade helm)");
+        this.log("");
+      }
+    });

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

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

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

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

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

@@ -0,0 +1,27 @@
+import Vorpal from "vorpal";
+import { getCurrentConnectedClusterName } from "../../../../utils/cluster";
+import { getProjectNamespace } from "../../../../utils/projects";
+import { getGoogleAuthUserNumber } from "../../utils/getGoogleAuthUserNumber";
+import { openGoogleCloudKubernetesDashboard } from "../shared";
+import { envAutocompletion } from "./utils/autocompletions";
+import ensureCluster from "./utils/ensureCluster";
+
+export default (vorpal: Vorpal) =>
+  vorpal
+    .command(
+      "project-open-dashboard <env>",
+      "open kubernetes dashboard on google"
+    )
+    .autocomplete(envAutocompletion)
+    .action(async function ({ env }) {
+      await ensureCluster.call(this);
+      const clustername = await getCurrentConnectedClusterName();
+      const namespace = await getProjectNamespace(env);
+      const authGoogleNumber = await getGoogleAuthUserNumber.call(this, vorpal);
+
+      openGoogleCloudKubernetesDashboard(
+        authGoogleNumber,
+        clustername,
+        namespace
+      );
+    });