@catladder/cli 0.0.0-test3 → 0.0.0-yarnrc-support-bdbef31f

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

@@ -0,0 +1,262 @@
+import {
+  BuildConfig,
+  ComponentConfig,
+  Config,
+  DeployConfigKubernetes,
+  Env,
+} from "@catladder/pipeline";
+import {
+  existsSync,
+  lstatSync,
+  readdirSync,
+  readFile,
+  writeFile,
+} from "fs-extra";
+import { isEmpty } from "lodash";
+import { join } from "path";
+import Vorpal from "vorpal";
+import {
+  getGitlabCi,
+  getGitlabCiFilePath,
+} from "../../../../config/getProjectConfig";
+import { readYaml } from "../../../../utils/files";
+import { syncBitwarden } from "../../../../utils/passwordstore";
+import { getGitRoot } from "../../../../utils/projects";
+import { writeConfig } from "../../config/writeConfig";
+import { migrateSecrets } from "./migrateSecrets";
+import {
+  detectBuildConfig,
+  isOldInclude,
+  OldGitlabCiFile,
+} from "./oldGitlabCi";
+export const LEGACY_ENVS = [
+  "dev-local",
+  "dev",
+  "review",
+  "stage",
+  "prod",
+] as const;
+
+const arrayToRecord = (arr: { name: string }[]): Record<string, any> => {
+  if (!arr) return undefined;
+  return Object.fromEntries(arr.map(({ name, ...rest }) => [name, rest]));
+};
+
+const transformVars = (rawVars: {
+  public: Record<string, any>;
+  secret: Record<string, any>;
+  fromCommponents: any;
+}) => {
+  if (rawVars.fromCommponents) {
+    console.warn("cant transform legacy fromCommponents");
+  }
+
+  return {
+    public: rawVars.public,
+    secret: rawVars.secret ? Object.keys(rawVars.secret) : undefined,
+  };
+};
+
+const getLegacyMonorepoSubCiFiles = (dir: string) => {
+  return readdirSync(dir)
+    .filter((file) => lstatSync(file).isDirectory())
+    .map((dir) => ({
+      dir,
+      ci: join(dir, ".gitlab-ci.yml"),
+    }))
+    .filter(({ ci }) => existsSync(ci));
+};
+
+const transformValues = (
+  valuesIn: Record<string, any>
+): DeployConfigKubernetes["values"] => {
+  if (isEmpty(valuesIn)) {
+    return undefined;
+  }
+  delete valuesIn?.application?.host;
+  delete valuesIn?.application?.command;
+
+  return {
+    ...valuesIn,
+    jobs: arrayToRecord(valuesIn?.jobs),
+    cronjobs: arrayToRecord(valuesIn?.cronjobs),
+  };
+};
+
+export const isV2 = async () => {
+  const gitlabCi = await getGitlabCi<OldGitlabCiFile>();
+  return isOldInclude(gitlabCi);
+};
+export const migrateV2 = async (vorpal: Vorpal) => {
+  const gitlabCi = await getGitlabCi<OldGitlabCiFile>();
+  const gitRoot = await getGitRoot();
+
+  const {
+    CUSTOMER_NAME,
+    APP_NAME,
+    COMPONENT_NAME,
+    APP_DIR = ".",
+    STAGING_ENABLED,
+  } = gitlabCi.variables;
+
+  vorpal
+    .command("migrate")
+
+    .action(async function () {
+      this.log("");
+      this.log("⚠️ this project uses legacy catladder (v2)");
+      this.log("");
+      this.log(
+        "😼 I can migrate the project for you. This contains the following steps:"
+      );
+      this.log("");
+      this.log(
+        " - migrate the config from values-*.yml to catladder config file"
+      );
+      this.log(
+        " - migrate the secrets from bitwarden to gitlab (this will trash the entries in bitwarden)"
+      );
+      this.log("");
+      this.log(
+        "☝ make sure that you checked in your current state in case something goes wrong."
+      );
+      this.log(
+        "☝ secrets in bitwarden are deleted, but can be restored within 30 days."
+      );
+      this.log("");
+      const { shouldContinue } = await this.prompt({
+        default: true,
+        message: "Migrate project now? 🤔",
+        name: "shouldContinue",
+        type: "confirm",
+      });
+
+      if (shouldContinue) {
+        vorpal.log("");
+        vorpal.log("");
+        vorpal.log("💪😼 ok, let's go...");
+        vorpal.log("");
+        vorpal.log("");
+
+        const createComponent = async (
+          dir: string,
+          ciFile: OldGitlabCiFile
+        ): Promise<ComponentConfig> => {
+          const { env, ...baseValues } =
+            (await readYaml(dir + "/values.yml")) ?? {};
+
+          const startCommand = Array.isArray(baseValues?.application?.command)
+            ? baseValues?.application?.command.join(" ")
+            : baseValues?.application?.command
+          return {
+            vars: env ? transformVars(env) : undefined,
+            dir: dir,
+            build: {
+              type: detectBuildConfig(ciFile),
+              startCommand: startCommand,
+            } as BuildConfig,
+            deploy: {
+              type: "kubernetes",
+              values: transformValues(baseValues),
+              cluster: {
+                type: "gcloud",
+                name: "ch-production",
+                projectId: "skynet-swiss",
+                region: "europe-west6-a",
+                domainCanonical: "panter.swiss",
+              },
+            },
+            env: await LEGACY_ENVS.reduce<Promise<Env>>(
+              async (acc, envName) => {
+                if (envName === "stage" && !STAGING_ENABLED) {
+                  return {
+                    ...(await acc),
+                    [envName]: false,
+                  };
+                }
+                const newEnvName = envName === "dev-local" ? "local" : envName;
+
+                const envValues =
+                  (await readYaml(dir + `/values-${envName}.yml`)) ?? {};
+                const { env, ...rest } = envValues;
+                const host = rest?.application?.host;
+                const values = transformValues(rest);
+                return {
+                  ...(await acc),
+                  [newEnvName]: {
+                    host: host,
+                    vars: env ? transformVars(env) : undefined,
+                    deploy: values
+                      ? {
+                          values: values,
+                        }
+                      : undefined,
+                  },
+                };
+              },
+              Promise.resolve({})
+            ),
+          };
+        };
+        let components: Record<string, ComponentConfig>;
+        if (detectBuildConfig(gitlabCi) === "monorepo") {
+          components = await getLegacyMonorepoSubCiFiles(gitRoot).reduce<
+            Promise<Record<string, ComponentConfig>>
+          >(async (acc, el) => {
+            return {
+              ...(await acc),
+              [el.dir]: await createComponent(el.dir, await readYaml(el.ci)),
+            };
+          }, Promise.resolve({}));
+        } else {
+          components = {
+            [COMPONENT_NAME]: await createComponent(APP_DIR, gitlabCi),
+          };
+        }
+        // we only have one component
+        const config: Config = {
+          customerName: CUSTOMER_NAME,
+          appName: APP_NAME,
+          components,
+        };
+
+        const comment =
+          "Old migrated config:\n\n" +
+          (await readFile(await getGitlabCiFilePath(), {
+            encoding: "utf-8",
+          }));
+
+        this.log("-------------------");
+        this.log("migrate config");
+        await writeConfig(this, config, {
+          endComment: comment,
+        });
+        this.log("write gitlab-ci.yml");
+        await writeFile(
+          await getGitlabCiFilePath(),
+          "include: https://git.panter.ch/api/v4/projects/catladder%2Fcatladder/packages/generic/ci-includes/main/gitlab-ci.yml",
+          { encoding: "utf-8" }
+        );
+
+        this.log("-------------------");
+        this.log("migrate secrets");
+        await syncBitwarden();
+        for (const env of LEGACY_ENVS) {
+          if (env === "stage" && !STAGING_ENABLED) return;
+          await migrateSecrets(this, config, env);
+        }
+
+        this.log("-------------------");
+
+        this.log("done!");
+
+        this.log("-------------------");
+      } else {
+        this.log(
+          "☝ if you want to use catladder in legacy mode, install @panter/catladder globally and invoke catladder-legacy"
+        );
+      }
+    });
+
+  vorpal.exec("migrate");
+};

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

@@ -0,0 +1,37 @@
+import { Config, getEnvironment } from "@catladder/pipeline";
+import { load } from "js-yaml";
+import { pick } from "lodash";
+import { CommandInstance } from "vorpal";
+import { upsertAllVariables } from "../../../../utils/gitlab";
+import { readPass, trashItem } from "../../../../utils/passwordstore";
+import { LEGACY_ENVS } from "./fromv2";
+
+const getPassPath = (newConfig: Config, env: string) => {
+  return `${newConfig.customerName}/${newConfig.appName}/${env}/secrets.yml`;
+};
+
+export const migrateSecrets = async (
+  vorpal: CommandInstance,
+  newConfig: Config,
+  oldEnv: typeof LEGACY_ENVS[number]
+) => {
+  const newEnv = oldEnv === "dev-local" ? "local" : oldEnv;
+  const path = getPassPath(newConfig, oldEnv);
+  try {
+    const yamlstring = await readPass(path);
+    const secrets = load(yamlstring);
+
+    Object.keys(newConfig.components).forEach(async (componentName) => {
+      const environment = getEnvironment(newConfig, componentName, newEnv);
+      await upsertAllVariables(
+        vorpal,
+        pick(secrets, environment.secretEnvVarKeys),
+        newEnv,
+        componentName
+      );
+    });
+    await trashItem(path);
+  } catch (e) {
+    console.warn(`could not migrate secrets for env '${oldEnv}': ${e}`);
+  }
+};

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

@@ -0,0 +1,48 @@
+import { BuildConfig } from "@catladder/pipeline";
+
+export type OldGitlabCiFile = {
+  variables: {
+    CUSTOMER_NAME: string;
+    APP_NAME: string;
+    COMPONENT_NAME?: string;
+    APP_DIR?: string;
+    CLUSTER_NAME?: string;
+    STAGING_ENABLED?: string;
+  };
+  include: {
+    project: string;
+    ref: string;
+    file: string;
+  }[];
+};
+
+export const isOldInclude = (gitlabCi: OldGitlabCiFile) => {
+  return gitlabCi.include[0]?.project === "catladder/gitlab-ci";
+};
+
+export const detectBuildConfig = (
+  gitlabCi: OldGitlabCiFile
+): BuildConfig["type"] | "monorepo" => {
+  if (!isOldInclude(gitlabCi)) {
+    throw new Error("unsupported gitlab-ci file");
+  }
+
+  const firstInclude = gitlabCi.include[0];
+
+  if (firstInclude.file === "monorepo.yml") return "monorepo";
+
+  if (firstInclude.file === "node-kubernetes.yml") {
+    return "node";
+  }
+
+  if (firstInclude.file === "static-js-kubernetes.yml") {
+    return "node-static";
+  }
+  if (firstInclude.file === "meteor-kubernetes.yml") {
+    return "meteor";
+  }
+
+  if (firstInclude.file === "rails-kubernetes.yml") {
+    throw new Error("rails is not yet implemented");
+  }
+};

package/src/catenv.ts

@@ -0,0 +1,4 @@
+import catenv from "./apps/catenv/catenv";
+import { $ } from "zx";
+$.verbose = false;
+catenv();

package/src/cli.ts

@@ -0,0 +1,9 @@
+import updateNotifier from "update-notifier";
+import cli from "./apps/cli/cli";
+import packageInfos from "./packageInfos";
+import { $ } from "zx";
+$.verbose = false;
+updateNotifier({
+  pkg: packageInfos,
+}).notify();
+cli();

package/src/config/constants.ts

@@ -1,5 +1,4 @@
 export const GRAFANA_PROXY_LOCAL_PORT = 9090;
 export const GRAFANA_PROXY_TARGET_PORT = 9090;
 
-export const GOOGLE_PROJECT = "skynet-164509";
 export const GOOGLE_CLOUD_SQL_PASS_PATH = "cloud-sql-proxy-credentials";

package/src/config/getProjectConfig.ts

@@ -0,0 +1,136 @@
+import {
+  readConfigSync,
+  getAllEnvs,
+  getEnvironment as _getEnvironment,
+  createContext,
+} from "@catladder/pipeline";
+
+import { CommandInstance } from "vorpal";
+import { getAllVariables } from "../utils/gitlab";
+import memoizee from "memoizee";
+import { getGitRoot } from "../utils/projects";
+import { readYaml } from "../utils/files";
+// currently cant change
+
+export const getProjectConfig = memoizee(
+  async () => {
+    try {
+      const gitRoot = await getGitRoot();
+      return readConfigSync(gitRoot);
+    } catch (e) {
+      // ignore
+      return null;
+    }
+  },
+  { promise: true }
+);
+
+export const reloadConfig = () => getProjectConfig.clear();
+
+export const getGitlabCiFilePath = async () => {
+  const gitRoot = await getGitRoot();
+  return gitRoot + "/.gitlab-ci.yml";
+};
+export const getGitlabCi = async <T = Record<string, any>>() => {
+  try {
+    return readYaml(await getGitlabCiFilePath()) as Promise<T>;
+  } catch (e) {
+    // ignore
+    return null;
+  }
+};
+
+export const getProjectComponents = async () => {
+  const config = await getProjectConfig();
+  if (!config) return [];
+  return Object.keys(config.components);
+};
+
+export const parseChoice = (envComponent: string) => {
+  const [env, componentName] = envComponent.split(":");
+  return { env, componentName };
+};
+
+export const getPipelineContextByChoice = async (
+  env: string,
+  componentName: string
+) => {
+  const config = await getProjectConfig();
+  return createContext(config, componentName, env);
+};
+export const getAllComponentsWithAllEnvsFlat = async (): Promise<
+  Array<{ env: string; componentName: string }>
+> => {
+  const config = await getProjectConfig();
+  if (!config) {
+    return [];
+  }
+  return Object.keys(config.components).flatMap((componentName) =>
+    getAllEnvs(config, componentName).map((env) => ({ env, componentName }))
+  );
+};
+
+export const getAllComponentsWithAllEnvsHierarchical = async (): Promise<{
+  [componentName: string]: string[];
+}> => {
+  const config = await getProjectConfig();
+  if (!config) {
+    return {};
+  }
+
+  return Object.fromEntries(
+    Object.keys(config.components).map((componentName) => [
+      componentName,
+      getAllEnvs(config, componentName),
+    ])
+  );
+};
+
+export const getAllPipelineContexts = async () => {
+  return Promise.all(
+    (await getAllComponentsWithAllEnvsFlat())
+      .filter((c) => c.env !== "local")
+      .map(({ env, componentName }) =>
+        getPipelineContextByChoice(env, componentName)
+      )
+  );
+};
+
+export const getEnvironment = async (env: string, componentName: string) => {
+  const config = await getProjectConfig();
+  return _getEnvironment(config, componentName, env);
+};
+
+const resolveSecrets = async (
+  vorpal: CommandInstance,
+  allEnvVars: Record<string, string>
+) => {
+  const allVariablesInGitlab = await getAllVariables(vorpal);
+
+  return Object.fromEntries(
+    Object.entries(allEnvVars).map(([key, value]) => {
+      const isSecret = String(value)?.startsWith?.("$CL_");
+      if (isSecret) {
+        // secrets have CL_XXXX structure
+        const found = allVariablesInGitlab.find((v) => "$" + v.key === value);
+
+        if (found) {
+          return [key, found.value];
+        } else {
+          return [key, ""];
+        }
+      }
+      return [key, value];
+    })
+  );
+};
+
+export const getEnvVars = async (
+  vorpal: CommandInstance,
+  env: string,
+  componentName: string
+) => {
+  const envionment = await getEnvironment(env, componentName);
+
+  return resolveSecrets(vorpal, envionment.envVars);
+};

package/src/k8sApi/index.ts

@@ -7,7 +7,11 @@ import {
 
 const kc = new KubeConfig();
 
-kc.loadFromDefault();
+export const reload = () => {
+  kc.loadFromDefault();
+};
+
+reload();
 
 const k8sApi = kc.makeApiClient(CoreV1Api);
 

package/src/types/types.ts

@@ -1,5 +1,3 @@
-export type Env = "dev-local" | "prod" | "dev" | "stage" | "review";
-
 export type KubernetesSecretName = string;
 export interface ISecrets {
   [key: string]: KubernetesSecretName;

package/src/utils/cluster.ts

@@ -1,21 +1,14 @@
-import { exec } from "child-process-promise";
-import { findKey } from "lodash";
-import clusters from "../config/clusters";
+import { $ } from "zx";
+import { reload } from "../k8sApi";
+
 export const getCurrentContext = async () =>
-  (await exec("kubectl config current-context")).stdout.trim();
+  (await $`kubectl config current-context`).stdout.trim();
 
 export const getCurrentConnectedClusterName = async () => {
-  const currentContext = await getCurrentContext();
-  return findKey(clusters, { fullName: currentContext });
-};
-
-export const getClusterByName = (name: string) => {
-  return clusters[name];
+  return await getCurrentContext();
 };
 
-export const getAllClusterNames = () => Object.keys(clusters);
-
-export const connectToCluster = async (clusterName: string) => {
-  const { connect } = getClusterByName(clusterName);
-  await connect();
+export const connectToCluster = async (fullname: string) => {
+  await $`kubectl config use-context ${fullname}`;
+  reload();
 };

package/src/utils/editAsFile.ts

@@ -0,0 +1,31 @@
+import { withFile } from "tmp-promise";
+import { dump, load } from "js-yaml";
+
+import { readFile, writeFile } from "fs-extra";
+import getEditor from "./getEditor";
+
+export const editAsFile = async <T>(
+  inObject: T,
+  preamble?: string
+): Promise<T> => {
+  const fullPreamble = preamble
+    ? `#
+# ${preamble.split("\n").join("\n# ")}
+#
+
+`
+    : "\n";
+  const asString = fullPreamble + dump(inObject, { noRefs: true });
+  let newContent: T;
+
+  await withFile(
+    async ({ path: tmpFilePath }) => {
+      await writeFile(tmpFilePath, asString);
+      await (await getEditor()).open(tmpFilePath);
+      newContent = load((await readFile(tmpFilePath)).toString("utf-8")) as T;
+    },
+    { postfix: ".yml" }
+  );
+
+  return newContent;
+};

package/src/utils/files.ts

@@ -13,6 +13,10 @@ export const readFileOrError = async (filePath: string) => {
   }
 };
 
-export const readYaml = async (filename: string) => {
-  return yaml.load(await readFile(filename));
+export const readYaml = async <T = Record<string, any>>(filename: string) => {
+  try {
+    return yaml.load(await readFile(filename)) as T;
+  } catch (e) {
+    return null;
+  }
 };