@catladder/cli 0.0.0-test7 → 0.0.0-waitfor-deploy-e64a33ba

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

@@ -5,17 +5,17 @@ import {
   getProjectNamespace,
   getProjectPodNames,
 } 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-port-forward <env>", "start port-forwarding")
-    .autocomplete(envAutocompletion)
-    .action(async function ({ env }) {
-      await ensureCluster.call(this);
-      const namespace = await getProjectNamespace(env);
-      const podNames = await getProjectPodNames(env);
+    .command("project-port-forward <envComponent>", "start port-forwarding")
+    .autocomplete(await envAndComponents())
+    .action(async function ({ envComponent }) {
+      await ensureCluster.call(this, envComponent);
+      const namespace = await getProjectNamespace(envComponent);
+      const podNames = await getProjectPodNames(envComponent);
       if (podNames.length === 0) {
         logError(this, "sorry, no pods found");
         return;

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

@@ -0,0 +1,12 @@
+import 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,18 @@
 import { V1Job, V1ObjectMeta } from "@kubernetes/client-node";
 
 import Vorpal from "vorpal";
-import { k8sApiBatch, k8sApiBatchBeta } from "../../../../k8sApi";
+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 +34,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 +43,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 +51,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

@@ -8,8 +8,8 @@ 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,14 @@ import commandPauseProject from "./commandPauseProject";
 import commandOpenGrafana from "./commandOpenGrafana";
 import commandPortForward from "./commandPortForward";
 import commandTriggerCronjob from "./commandTriggerCronjob";
-import commandVariables from "./commandVariables";
+
 import commandOpenGrafanaPod from "./commandOpenGrafanaPod";
 
-export default (vorpal: Vorpal) => {
-  commandInitProject(vorpal);
-  commandInitGitlab(vorpal);
+export default async (vorpal: Vorpal) => {
+  commandSetup(vorpal);
+
   commandEnvVars(vorpal);
 
-  commandVariables(vorpal);
   commandNamespace(vorpal);
   commandListPods(vorpal);
   commandPauseProject(vorpal);

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

@@ -0,0 +1,42 @@
+import { CommandInstance } from "vorpal";
+import { getAllPipelineContexts } from "../../../../../config/getProjectConfig";
+import { projectConfigSecrets } from "../commandConfigSecrets";
+import { setupAccessTokens } from "./setupAccessTokens";
+import { setupContext } from "./setupContext";
+
+export const setupProject = async (instance: CommandInstance) => {
+  const allContext = await getAllPipelineContexts();
+
+  for (const context of allContext) {
+    await setupContext(instance, context);
+  }
+  await setupAccessTokens(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,72 @@
+import open from "open";
+import { 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 - 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,
+    });
+  }
+
+  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"],
+    });
+  }
+};

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

@@ -0,0 +1,37 @@
+import { Context, isOfDeployType } from "@catladder/pipeline";
+import { CommandInstance } from "vorpal";
+import { setupKubernetes } from "./setupKubernetes";
+
+export const setupContext = async (
+  instance: CommandInstance,
+  context: Context
+) => {
+  instance.log("");
+  instance.log(
+    "=================================================================================="
+  );
+
+  instance.log(
+    "🐱 🔧 setting up " +
+      context.environment.shortName +
+      ":" +
+      context.componentName +
+      "..."
+  );
+  instance.log("");
+  const deployConfig = context.componentConfig.deploy;
+  if (isOfDeployType(deployConfig, "kubernetes")) {
+    await setupKubernetes(instance, context);
+  }
+
+  instance.log("");
+  instance.log(
+    "✅ " +
+      context.environment.shortName +
+      ":" +
+      context.componentName +
+      " done!"
+  );
+
+  instance.log("");
+};

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

@@ -0,0 +1,112 @@
+import {
+  Context,
+  getFullKubernetesClusterName,
+  isOfDeployType,
+} from "@catladder/pipeline";
+import { CommandInstance } from "vorpal";
+import { $ } from "zx";
+import { connectToCluster } from "../../../../../utils/cluster";
+import { upsertAllVariables } from "../../../../../utils/gitlab";
+import ensureNamespace from "../utils/ensureNamespace";
+
+export const setupKubernetes = async (
+  instance: CommandInstance,
+  context: Context
+) => {
+  const deployConfig = context.componentConfig.deploy;
+  if (!isOfDeployType(deployConfig, "kubernetes")) {
+    throw new Error("cannot run setupKubernetes on non-kubernetes deployments");
+  }
+
+  const fullName = getFullKubernetesClusterName(deployConfig.cluster);
+  instance.log(`cluster: ${fullName}`);
+
+  await connectToCluster(fullName);
+  instance.log("");
+  instance.log("ensuring namespace ...");
+  const namespace = await ensureNamespace(context);
+  instance.log("Namespace " + namespace + " created / updated!");
+  instance.log("");
+  //$.verbose = true;
+
+  // we name the service account and the role and the role binding with the same name
+  // we currently create one per component to better separate them
+  instance.log("ensuring service accounts...");
+  const serviceAccountName = `cl-${context.componentName}-deploy`;
+  const KUBE_URL =
+    await $`TERM=dumb kubectl cluster-info | grep -E 'Kubernetes master|Kubernetes control plane' | awk '/http/ {print $NF}'`.then(
+      (s) => s.stdout.trim()
+    );
+
+  // first upsert service acount in the ns
+  try {
+    await $`kubectl delete serviceaccount --namespace ${namespace} ${serviceAccountName}`;
+    await $`kubectl delete rolebinding --namespace ${namespace} ${serviceAccountName}`;
+    await $`kubectl delete role --namespace ${namespace} ${serviceAccountName}`;
+  } catch (e) {
+    // ignore
+  }
+
+  await $`kubectl create serviceaccount --namespace ${namespace} ${serviceAccountName}`;
+
+  // upsert role in the ns
+
+  await $`cat <<EOF | kubectl apply -f -
+kind: Role
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+  namespace: ${namespace}
+  name: ${serviceAccountName}
+rules:
+- apiGroups: ["", "extensions", "apps", "networking.k8s.io", "batch", "autoscaling"]
+  resources: ["deployments", "replicasets", "statefulsets", "pods", "secrets", "configmaps", "services", "ingresses", "serviceaccounts", "jobs", "cronjobs", "horizontalpodautoscalers"]
+  verbs: ["get", "list", "watch", "create", "update", "patch", "delete"] # You can also use ["*"]
+---
+kind: RoleBinding
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+  name: ${serviceAccountName}
+  namespace: ${namespace}
+subjects:
+  - kind: ServiceAccount
+    name: ${serviceAccountName}
+    namespace:  ${namespace}
+roleRef:
+  kind: Role
+  name: ${serviceAccountName}
+  apiGroup: rbac.authorization.k8s.io
+EOF
+`;
+
+  // get token name
+  const tokenName =
+    await $`kubectl get serviceaccount --namespace ${namespace} ${serviceAccountName} -o jsonpath='{.secrets[0].name}'`;
+
+  const KUBE_CA_PEM =
+    await $`kubectl get secret ${tokenName} --namespace ${namespace} -o jsonpath="{['data']['ca\\.crt']}"`.then(
+      (c) => c.stdout.trim()
+    );
+  const KUBE_TOKEN =
+    await $`kubectl get secret ${tokenName} --namespace ${namespace} -o jsonpath="{['data']['token']}" | base64 --decode`.then(
+      (c) => c.stdout.trim()
+    );
+
+  const vars = {
+    KUBE_TOKEN,
+    KUBE_CA_PEM,
+    KUBE_URL,
+  };
+
+  instance.log("service accounts created / updated!");
+
+  instance.log("");
+  instance.log("pusing secrets to gitlab...");
+
+  await upsertAllVariables(
+    instance,
+    vars,
+    context.environment.shortName,
+    context.componentName
+  );
+  instance.log("done!");
+};

package/src/apps/cli/commands/project/utils/autocompletions.ts

@@ -0,0 +1,26 @@
+import { getAllEnvs, getAllEnvsInAllComponents } from "@catladder/pipeline";
+import {
+  getAllComponentsWithAllEnvsFlat,
+  getProjectConfig,
+} from "../../../../../config/getProjectConfig";
+
+export const allEnvs = async () => {
+  const config = await getProjectConfig();
+  if (!config) {
+    return [];
+  }
+  return getAllEnvsInAllComponents(config);
+};
+
+export const envAndComponents = async () => {
+  const allEnvAndcomponents = await getAllComponentsWithAllEnvsFlat();
+
+  return allEnvAndcomponents.reduce<string[]>(
+    (acc, { env, componentName }) => [...acc, env + ":" + componentName],
+    []
+  );
+};
+
+export const allEnvsAndAllComponents = async () => {
+  return [...(await allEnvs()), ...(await envAndComponents())];
+};

package/src/apps/cli/commands/project/utils/ensureCluster.ts

@@ -0,0 +1,42 @@
+import {
+  isOfDeployType,
+  getFullKubernetesClusterName,
+} from "@catladder/pipeline";
+import {
+  getPipelineContextByChoice,
+  parseChoice,
+} from "../../../../../config/getProjectConfig";
+import {
+  connectToCluster,
+  getCurrentConnectedClusterName,
+} from "../../../../../utils/cluster";
+export default async function (envComponent: string) {
+  const { env, componentName } = parseChoice(envComponent);
+  const context = await getPipelineContextByChoice(env, componentName);
+  if (!isOfDeployType(context.componentConfig.deploy, "kubernetes")) {
+    throw new Error("can't ensure cluster for non-kubernetes deployments");
+  }
+  const cluster = getFullKubernetesClusterName(
+    context.componentConfig.deploy.cluster
+  );
+  const connectedClusterName = await getCurrentConnectedClusterName();
+
+  if (cluster !== connectedClusterName) {
+    this.log(
+      `you are currently connected to cluster '${connectedClusterName}'`
+    );
+    this.log(`but the project requires cluster '${cluster}'`);
+    const { shouldContinue } = await this.prompt({
+      type: "confirm",
+      name: "shouldContinue",
+      default: true,
+      message: `Do you want to connect to '${cluster}'?`,
+    });
+    if (!shouldContinue) {
+      this.log("abort");
+    } else {
+      await connectToCluster(cluster);
+      this.log(`connected to cluster '${cluster}'`);
+    }
+  }
+}

package/src/apps/cli/commands/project/utils/ensureNamespace.ts

@@ -0,0 +1,56 @@
+import { Context, getKubernetesNamespace } from "@catladder/pipeline";
+import { V1Namespace, V1ObjectMeta } from "@kubernetes/client-node";
+import { getk8sApi } from "../../../../../k8sApi";
+
+export default async function (context: Context) {
+  const namespace = getKubernetesNamespace(
+    context.fullConfig,
+    context.environment.shortName
+  );
+  const namespaceBody = new V1Namespace();
+  const metadata: V1ObjectMeta = {
+    name: namespace,
+    labels: {
+      customerName: context.fullConfig.customerName,
+      appName: context.fullConfig.appName,
+      environment: context.environment.shortName,
+      components: Object.keys(context.fullConfig.components).join("_"), // limited chars available...
+      buildTypes: Object.values(context.fullConfig.components)
+        .map((config) => config.build.type)
+        .join("_"), // limited chars available...
+      ...Object.fromEntries(
+        Object.entries(context.fullConfig.components).map(
+          ([componentName, config]) => [
+            "buildType_" + componentName,
+            config.build.type,
+          ]
+        )
+      ),
+      ...(context.fullConfig.meta?.labels ?? {}),
+    },
+  };
+
+  namespaceBody.metadata = metadata;
+  const k8sApi = getk8sApi();
+  try {
+    await k8sApi.readNamespace(namespace);
+
+    await k8sApi.patchNamespace(
+      namespace,
+      namespaceBody,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      { headers: { "content-type": "application/merge-patch+json" } } // see https://github.com/kubernetes-client/javascript/issues/443
+    ); // update meta data
+  } catch (e) {
+    if (e.response?.body?.reason === "NotFound") {
+      await k8sApi.createNamespace(namespaceBody);
+    } else {
+      console.error(e.response?.body);
+      throw e;
+    }
+  }
+  return namespace;
+}

package/src/apps/cli/commands/project/utils/showProjectBanner.ts

@@ -0,0 +1,11 @@
+import Vorpal from "vorpal";
+import { getProjectConfig } from "../../../../../config/getProjectConfig";
+
+export const showProjectBanner = async (vorpal: Vorpal) => {
+  const projectConfig = await getProjectConfig();
+  if (projectConfig) {
+    vorpal.log("project: " + projectConfig.appName);
+    vorpal.log("customer: " + projectConfig.customerName);
+    vorpal.log("");
+  }
+};

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

@@ -0,0 +1,36 @@
+import { DeployConfigKubernetesCluster } from "@catladder/pipeline";
+import open from "open";
+
+export const openGoogleCloudLogs = async (
+  cluster?: DeployConfigKubernetesCluster,
+  namespace?: string,
+  googleAuthUserNumber = 0
+) => {
+  const resource = `k8s_container/cluster_name/${cluster.name}${
+    namespace ? `/namespace_name/${namespace}` : ""
+  }`;
+
+  const url = `https://console.cloud.google.com/logs/viewer?project=${
+    cluster.projectId
+  }${
+    resource ? `&resource=${encodeURIComponent(resource)}` : ""
+  }&authuser=${googleAuthUserNumber}`;
+  open(url);
+};
+
+export const openGoogleCloudKubernetesDashboard = async (
+  cluster: DeployConfigKubernetesCluster,
+  namespace: string,
+  googleAuthUserNumber = 0
+) => {
+  //gke_skynet-164509_europe-west1-d_production
+  // ?authuser=1&project=skynet-swiss&pageState=pageState%3D(%22savedViews%22:(%22c%22:%5B%22gke%2Feurope-west6-a%2Fch-production%22%5D,%22n%22:%5B%22pvl-bike2school-review%22%5D,%22i%22:%224e42e0b9cd6147f8a4fba7516752ec48%22))
+  // ?authuser=1&project=skynet-swiss&pageState=(%22savedViews%22:(%22i%22:%2279802e2b154d46d480dff4e086e87875%22,%22c%22:%5B%22gke%2Feurope-west6-a%2Fch-production%22%5D,%22n%22:%5B%22pvl-bike2school-review%22%5D))
+
+  const pageState = `("savedViews":("c":["gke/${cluster.region}/${cluster.name}"],"n":["${namespace}"],"i":"4e42e0b9cd6147f8a4fba7516752ec48"))`;
+  const url = `https://console.cloud.google.com/kubernetes/workload?authuser=${googleAuthUserNumber}&project=${
+    cluster.projectId
+  }&pageState=${encodeURIComponent(pageState)}`;
+
+  open(url);
+};

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

@@ -2,50 +2,31 @@ import { spawn } from "child-process-promise";
 import fetch from "node-fetch";
 import Vorpal from "vorpal";
 
-export default (vorpal: Vorpal) => {
-  vorpal.command("dadjoke", "something for jonas.").action(async function() {
+export default async (vorpal: Vorpal) => {
+  vorpal.command("dadjoke", "something for jonas.").action(async function () {
     const result = await fetch("https://icanhazdadjoke.com/", {
       headers: {
-        Accept: "text/plain"
-      }
+        Accept: "text/plain",
+      },
     });
     const text = await result.text();
     this.log("");
     this.log(text);
     this.log("");
   });
-  vorpal.command("pantobot", "the allknowing oracle").action(async function() {
-    const { message } = await this.prompt({
-      type: "string",
-      name: "message",
 
-      message: "Your question, unworthy?: "
-    });
-    const result = await fetch(
-      `https://paas.panter.cloud/api/pantobot/${message}`,
-      {
-        headers: {
-          Accept: "text/plain"
-        }
-      }
-    );
-    const text = await result.text();
-    this.log("");
-    this.log(text);
-    this.log("");
-  });
   let starwarsPromise: any;
   vorpal
     .command("starwars", "Long time ago... in a galaxy far far away...")
-    .action(async function() {
+    .action(async function () {
       starwarsPromise = spawn("telnet", ["towel.blinkenlights.nl"], {
-        stdio: ["pipe", "inherit", "pipe"]
+        stdio: ["pipe", "inherit", "pipe"],
       });
       await starwarsPromise;
     })
     // we need to close it properly, because telnet towel.blinkenlights.nl has no way to cancel and stop itself
     // this is also why we need to only inherit the stdout and not the stdin
-    .cancel(async function() {
+    .cancel(async function () {
       starwarsPromise.childProcess.kill();
     });
 };