@leverege/build-tools 2.4.9 → 2.5.0-beta.40

package/lib/web/build-tools.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+"use strict";
+
+const chalk = require('chalk');
+
+const cliArgs = require('command-line-args');
+
+const cliHelp = require('command-line-usage');
+
+const fs = require('fs');
+
+const npmRegistryFetch = require('npm-registry-fetch');
+
+const path = require('path');
+
+const semverLt = require('semver/functions/lt');
+/* eslint-disable no-console */
+
+
+const optionList = [// Use optionList to tie into the Usage statements
+{
+  name: 'root',
+  type: Boolean,
+  default: false,
+  description: 'returns the root of the build-tools installation'
+}, {
+  name: 'bashfun',
+  type: Boolean,
+  default: false,
+  descriptions: 'returns path to a script to source for common bash functions'
+}, {
+  name: 'help',
+  type: Boolean,
+  default: false,
+  description: 'display this help screen'
+}, {
+  name: 'latest',
+  type: Boolean,
+  default: false,
+  description: 'verifies the latest build-tools are installed'
+}, {
+  name: 'version',
+  type: Boolean,
+  default: false,
+  description: 'returns the build-tools repo version'
+}, {
+  name: 'verbose',
+  alias: 'v',
+  type: Boolean,
+  default: false,
+  description: 'emit additional info at run time'
+}];
+const sections = [{
+  header: 'Something to go in the Header',
+  content: 'Generate something {italic very} important.'
+}, {
+  header: 'Options',
+  optionList
+}];
+const args = cliArgs(optionList, {
+  partial: true
+});
+const help = cliHelp(sections);
+const repoRoot = path.dirname(__dirname);
+
+const thisPackage = require(`${repoRoot}/package.json`);
+
+const thisVersion = thisPackage.version;
+
+if (args.root) {
+  console.log(repoRoot);
+  process.exit(0);
+}
+
+if (args.bashfun) {
+  console.log(`${repoRoot}/src/bash-funcs`);
+  process.exit(0);
+}
+
+const checkForLatest = async (pkg = '@leverege/build-tools') => {
+  const getToken = () => {
+    const tokenFile = `${process.env.HOME}/.npmrc`;
+
+    if (!fs.existsSync(tokenFile)) {
+      console.error(`Cannot find token file ${tokenFile}`);
+      process.exit(1);
+    }
+
+    try {
+      const tokenLine = fs.readFileSync(tokenFile).toString();
+      const tokenRegX = new RegExp('.*registry.npmjs.org\\/:\\w+=+(.*)');
+      const tokenStr = tokenLine.match(tokenRegX);
+
+      if (!tokenStr) {
+        console.error(`\n***ERROR: malformed npm token in ${tokenFile}\n`);
+        process.exit(1);
+      }
+
+      return tokenLine.match(tokenRegX)[1];
+    } catch (err) {
+      console.error(err);
+    }
+  };
+
+  try {
+    const list = await npmRegistryFetch.json(pkg, {
+      '//registry.npmjs.org/:token': getToken()
+    });
+    return list['dist-tags'].latest;
+  } catch (err) {
+    console.log(err);
+  }
+};
+
+if (args.latest) {
+  checkForLatest().then(latestVersion => {
+    if (semverLt(thisVersion, latestVersion)) {
+      console.log(chalk.white`
+  Update available ${chalk.grey(thisVersion)} \u2b62 ${chalk.green(latestVersion)}
+  Run ${chalk.cyan('npm i -g @leverege/build-tools')} to update
+`);
+      process.exit(1);
+    } else {
+      process.exit(0);
+    }
+  }).catch(err => {});
+}
+
+if (args.version) {
+  console.log(`build-tools version ${thisVersion}`);
+  process.exit(0);
+}
+
+if (args.help) {
+  console.log(help);
+  process.exit(0);
+}
+/* eslint-disable no-underscore-dangle */
+
+
+if (args._unknown) {
+  console.log(`Hey Bozo, WTF am I supposed to do with ${args._unknown}?`);
+  process.exit(1);
+}

package/lib/web/getfbcfg.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+/**
+ * This script parses a firebase config into something useful.
+ */
+"use strict";
+
+const stdbuf = [];
+/* eslint-disable no-console */
+
+process.stdin.on('data', d => {
+  stdbuf.push(d);
+}).on('end', () => {
+  const rawCfg = stdbuf.join('').replace(/["\n\r]/g, '');
+  const keyVals = rawCfg.match(/\{(.*)\}/)[1].split(',');
+  const lastLine = keyVals.length - 1;
+  console.log('{');
+
+  for (let i = 0; i <= lastLine; i++) {
+    const kv = keyVals[i].trim().split(' ');
+    console.log(`  "${kv[0].replace(/:/, '')}": "${kv[1]}"${i < lastLine ? ',' : ''}`);
+  }
+
+  console.log('}');
+}).setEncoding('utf8');

package/lib/web/getjson.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+
+/**
+ * This script will allow the user to grab a value from a JSON file and
+ * optionally apply a regular expression to it. Given this test.json file:
+ * 
+ * {
+ *   "name": "@leverege/packagename",
+ *   "main": "lib/index.js"
+ * }
+ *
+ * and invoking as:
+ *   ./getjson --file ./test.json --key name --regex "^@\w{3}"
+ *
+ * will yield an output of: @lev
+ */
+
+/**
+ * Get a command line switch parser.
+ */
+"use strict";
+
+const fs = require('fs');
+
+const cliArgs = require('command-line-args');
+
+const cliHelp = require('command-line-usage');
+/* eslint-disable no-console */
+
+
+const optionList = [// Use optionList to tie into the Usage statements
+{
+  name: 'file',
+  type: String,
+  alias: 'f',
+  description: 'file to parse JSON from'
+}, {
+  name: 'key',
+  type: String,
+  alias: 'k',
+  description: 'JSON key whose value to grab'
+}, {
+  name: 'regex',
+  type: String,
+  alias: 'r',
+  description: 'regular expression to apply to the value'
+}];
+const sections = [{
+  header: 'JSON variable fetching script',
+  content: `  This script is intended to give shell scripts a simple JSON
+  parsing capability.`
+}, {
+  header: 'Options',
+  optionList
+}];
+const args = cliArgs(optionList, {
+  partial: true
+});
+const help = cliHelp(sections);
+
+if (!args.file) {
+  console.error('\n***ERROR: Missing a --file param\n');
+  console.log(help);
+  process.exit(1);
+}
+
+try {
+  const json = JSON.parse(fs.readFileSync(args.file, 'utf8'));
+  const value = json[args.key];
+  const match = new RegExp(args.regex || '.*').exec(value);
+  console.log(match ? match[match.length - 1] : '');
+} catch (e) {
+  console.log(e);
+}

package/lib/web/npm-scripts/postinstall.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+"use strict";
+
+const execa = require('execa');
+
+const fs = require('fs');
+
+const untarConfigTarball = async (subdir, tarball) => {
+  if (fs.existsSync(subdir)) {
+    process.chdir(subdir);
+    await execa('tar', ['xf', tarball]);
+  }
+};
+
+const awaiter = async (subdir, tarball) => {
+  await untarConfigTarball(subdir, tarball);
+};
+
+awaiter('lib/server/repo-init', 'config.tgz');

package/lib/web/overwhelm.js

@@ -0,0 +1,373 @@
+#!/usr/bin/env node
+
+/* eslint-disable no-console */
+"use strict";
+
+const chalk = require('chalk');
+
+const cliArgs = require('command-line-args'); // const cliHelp = require( 'command-line-usage' )
+
+
+const exec = require('child_process').execSync;
+
+const fs = require('fs');
+
+const glob = require('glob');
+
+const parse = require('parse-gitignore');
+
+const ask = require('readline-sync');
+
+const YAML = require('js-yaml');
+
+const optionsDefinitions = [
+/* eslint-disable no-multi-spaces */
+{
+  name: 'context',
+  alias: 'x',
+  type: String,
+  default: ''
+}, {
+  name: 'section',
+  alias: 's',
+  type: String,
+  default: 'default'
+}, {
+  name: 'key',
+  alias: 'k',
+  type: String
+}, {
+  name: 'export',
+  alias: 'e',
+  type: Boolean,
+  default: false
+}, {
+  name: 'continue',
+  alias: 'c',
+  type: Boolean,
+  default: false
+}, {
+  name: 'checkctx',
+  alias: 't',
+  type: Boolean,
+  default: false
+}, {
+  name: 'fetchctx',
+  alias: 'f',
+  type: Boolean,
+  default: false
+}, {
+  name: 'verbose',
+  alias: 'v',
+  type: Boolean,
+  default: false
+}
+/* eslint-enable no-multi-spaces */
+];
+const args = cliArgs(optionsDefinitions); // The kubernetes context is equal to the git branch name.
+
+const gitBranch = require('git-branch').sync();
+
+const context = args.context || gitBranch;
+
+if (context === 'master') {
+  console.log('***ERROR: master context is forbidden; change to a different branch\n\n');
+  process.exit(1);
+} // Load the default values and then overlay with the project specific yaml
+// values. This supports the notion of this type of approach in the
+// overwhelm yaml settings:
+//   default:
+//     GCE_MACHINE : "n1-standard-2"
+//
+//   my-project:
+//     GCE_MACHINE : "n1-highcpu-8"
+//
+// fashion, but it is advised not to set a default region with this
+// approach in order to keep us cognizant of exactly where a cluster is
+// being formed.
+//
+
+
+const yaml = YAML.safeLoad(fs.readFileSync('overwhelm.yaml', 'utf-8'));
+const over = yaml.default;
+let cfgs = yaml[context]; // If we just need to check context return 0 if cfgs exists, else error.
+
+if (args.checkctx) {
+  process.exit(!cfgs);
+}
+
+if (!cfgs) {
+  console.log(`***ERROR: Unknown context => [${context}]\n`);
+  console.log('   Known k8s contexts are:');
+  Object.keys(yaml).forEach(key => {
+    if (key !== 'default') {
+      console.log(`             ${key}`);
+    }
+  });
+  console.log(`Add a section into overwhelm.yaml for ${context}\n\n`);
+  process.exit(1);
+} // Check to see if we are deriving from another configuration.
+
+
+if (cfgs['PROJECT_BASE']) {
+  const baseName = cfgs['PROJECT_BASE'];
+  const tempCfgs = cfgs;
+  cfgs = yaml[baseName];
+  Object.keys(tempCfgs).forEach(key => {
+    cfgs[key] = tempCfgs[key];
+  });
+  console.log('PROJECT_BASE still under evaluation');
+  console.log('\n  cfgs=', cfgs);
+  process.exit(1); // XXX HERE
+}
+
+Object.keys(cfgs).forEach(key => {
+  over[key] = cfgs[key] || over[key];
+}); // Expand any variables that reference other variable settings. A perfect
+// example of where this is useful is in the setting of a PROJECT_NAME and
+// a PROJECT_ID. Most of the time these values are identical, which is why
+// this setting exists in the default section:
+//   default:
+//     PROJECT_ID : ${PROJECT_NAME}
+//
+// However, in the case of projects like Siren Marine, this is the more
+// likely setup due to legacy naming schemes:
+//   sire-marine:
+//     PROJECT_NAME : siren-marine
+//     PROJECT_ID   : prod-rt-data
+//
+
+const varErrors = [];
+Object.keys(over).forEach(key => {
+  if (!over[key]) return; // no value to work with - skip it
+  // Look for something in the form of "thing-${VAR1}-${VAR2}-${VARn}-stuff"
+
+  const matches = over[key].match(/\$\{\w+\}/g);
+  if (!matches) return;
+  matches.forEach(replaceThis => {
+    // The matched variable names will be in the form of ${VARNAME} so drop
+    // the ${} characters before using the VARNAME to map into the
+    // overwhelm map containing the desired replacement value.
+    const withThat = over[replaceThis.replace(/\W+/g, '')];
+
+    if (!withThat) {
+      varErrors.push(`${key} : ${over[key]}`);
+      return;
+    } // Store the replaced string back in the overwhelm value map.
+
+
+    over[key] = over[key].replace(replaceThis, withThat);
+  });
+});
+
+if (varErrors.length > 0) {
+  console.log('***ERROR: unkown variable reference(s) in overwhelm.yaml:\n');
+  varErrors.forEach(error => {
+    console.log(`     ${error}`);
+  });
+  console.log('');
+  process.exit(1);
+} // Grab a list of the existing yaml templates.
+
+
+const yams = glob.sync('values-*.yaml'); // A function to apply the replacements to all of the matching yaml which
+// will error out if it runs into an unknown OVH<tag>.
+
+const doReplacements = (yamls, replacements) => {
+  let replYaml = yamls;
+  Object.keys(replacements).forEach(repl => {
+    const replaceThis = new RegExp(`OVH:<${repl}>`, 'g');
+    const withThat = `${replacements[repl]}`;
+    replYaml = replYaml.replace(replaceThis, withThat);
+  }); // Verify all replaceables have been handled, or error out.
+
+  const missed = replYaml.match(/OVH:<(.*)>/g);
+
+  if (missed) {
+    console.log('\n***ERROR: missing replacements in overwhelm.yaml for these tags:\n');
+    missed.forEach(miss => {
+      console.log(`     TAG: ${miss.match(/OVH:<(.*)>/)[1]}`);
+    });
+    console.log('');
+    process.exit(1);
+  }
+
+  return replYaml;
+}; // Collect all of the yaml from the yams, and always expect the default and
+// platform yamls to be in that list.
+
+
+const buildYaml = (yamls, replacements) => {
+  // We always start with default but values-platform is no longer needed.
+  const always = ['values-default.yaml'];
+  const values = [...always, ...yamls];
+  const loaded = [];
+  let allYamls = '';
+  values.forEach(yaml => {
+    if (!fs.existsSync(yaml)) {
+      console.log(`\n***ERROR: yaml file missing => ${yaml}\n`);
+      process.exit(1);
+    }
+
+    if (!loaded.includes(yaml)) {
+      allYamls += `\n# AHOY => ${yaml}\n\n`;
+      allYamls += fs.readFileSync(yaml, {
+        encoding: 'utf-8'
+      });
+      loaded.push(yaml);
+    }
+  }); // Now apply all of the replacements from the overwhelm file.
+
+  return doReplacements(allYamls, replacements);
+}; // Call buildYaml to replace the OVH strings in the yaml files.
+
+
+const values = buildYaml(yams, over); // Check to see if someone is requesting a value from the yaml.
+
+if (args.key) {
+  const section = args.section || 'default';
+  const keys = yaml[section];
+
+  if (args.verbose) {
+    console.log('replacements');
+    console.log(keys);
+  }
+
+  if (args.export) {
+    console.log(`export ${args.key}=${keys[args.key]}`);
+  } else {
+    console.log(keys[args.key]);
+  }
+
+  if (!args.continue) process.exit();
+} // Find all of the potential target dirs. Utilize .gitignore to ignore files
+
+
+const opt = {
+  ignore: parse(fs.readFileSync('.gitignore'))
+};
+const ahoy = glob.sync('*/', opt); // .noahoy = skips generation of values.yaml but allows helmup to run
+// .nohelm = overwhelm and helmup will skip the deployment entirely
+
+ahoy.forEach(dir => {
+  if (fs.existsSync(`${dir}/.noahoy`)) {
+    !args.fetchctx && console.log(chalk.yellow(`***WARNING: .noahoy detected, not regenerating ${dir}values.yaml`));
+  } else if (!fs.existsSync(`${dir}/.nohelm`)) {
+    args.verbose && console.log(`Generating values in ${dir}`); // eslint-disable-line no-unused-expressions
+
+    let valuesOut = []; // An accumulator for all of the output values.
+    // Add support for localized values for things like keel (or whatever)
+
+    const valuesLocal = `${dir}values-local.yaml`;
+
+    if (fs.existsSync(valuesLocal)) {
+      args.verbose && console.log(`     Local values in ${valuesLocal}`); // eslint-disable-line no-unused-expressions
+
+      valuesOut += '\n# AHOY => values-local.yaml\n\n';
+      valuesOut += fs.readFileSync(valuesLocal, {
+        encoding: 'utf-8'
+      });
+    }
+
+    valuesOut += `\n${values}`;
+    valuesOut = doReplacements(valuesOut, over);
+    fs.writeFileSync(`${dir}/values.yaml`, valuesOut);
+  }
+}); // Set the GCP context for safety!
+
+const clusterName = over.CLUSTER_NAME;
+const projectId = over.PROJECT_ID;
+let zone = over['GCE_REGION'] + (over['GCE_ZONE'] ? `-${over['GCE_ZONE']}` : '');
+
+if (!clusterName) {
+  console.log(chalk.yellow(`
+
+    The overwhelm.yaml file in this branch is missing a CLUSTER_NAME setting,
+    which was added to support cluster names that do not match the project
+    name. Since the mismatch is rare, you can probably get by with simply
+    adding this line following PROJECT_NAME in the default section of
+    overwhelm.yaml:
+
+      ${chalk.bold.green(`CLUSTER_NAME   : "\${PROJECT_NAME}"`)}
+
+    However, if the CLUSTER_NAME is not the same as the PROJECT_NAME then go
+    ahead and add the CLUSTER_NAME setting to the ${chalk.bold.green(projectId)} section of the
+    overwhelm.yaml file.
+
+    `));
+  process.exit(1);
+}
+
+let kubeout = '_no_current_context_';
+
+try {
+  kubeout = exec('kubectl config current-context', {
+    stdio: [undefined]
+  });
+} catch (err) {// err && console.log( `Caught Error =>[${err}]` )
+}
+
+const currentCtx = kubeout.toString().trim();
+let desiredCtx = `gke_${projectId}_${zone}_${clusterName}`;
+let cmd = `gcloud container clusters get-credentials ${clusterName} --zone ${zone} --project ${projectId}`; // Check if we are using AWS
+
+if (cfgs.CLOUD === 'aws') {
+  const awsAcctId = cfgs['AWS_ACCT_ID'];
+  zone = over['AWS_REGION'];
+  desiredCtx = `arn:aws:eks:${zone}:${awsAcctId}:cluster/${clusterName}`;
+  cmd = `aws eks --region ${zone} update-kubeconfig --name ${clusterName}`;
+} // TODO - FETCH AWS CLUSTER CREDENTIALS 
+
+
+const matchedCtx = currentCtx === desiredCtx; // just fetch the context and exit if -f is specified
+
+if (args.fetchctx) {
+  if (!matchedCtx) {
+    try {
+      exec(`${cmd}`, {
+        stdio: [undefined]
+      });
+    } catch (err) {
+      process.exit(61); // ECONNREFUSED
+    }
+  }
+
+  process.exit(0);
+}
+
+if (matchedCtx) {
+  console.log(`
+
+  Current context matches => ${chalk.bold.green(currentCtx)}
+
+  `);
+} else {
+  console.log(`
+  You are about to change your Kubernetes context to:
+      CLUSTER_NAME => ${chalk.bold.green(clusterName)}
+      PROJECT_ID   => ${chalk.bold.green(projectId)}
+      REGION       => ${chalk.bold.green(zone)}
+
+  `);
+}
+
+const operation = matchedCtx ? 'refetch the credentials' : 'switch your context';
+const ans = ask.question(`Enter "${chalk.bold.green('yes')}" if you wish to ${operation} => `);
+
+if (ans !== 'yes') {
+  if (matchedCtx) {
+    console.log(chalk.bold.yellow('\n\nSkipping a refetch of your Kubernetes context and credentials\n\n'));
+    process.exit(0);
+  }
+
+  console.log(chalk.bold.red('\n\nYour Kubernetes context and credentials do NOT match - this could be bad!\n\n'));
+  process.exit(1);
+}
+
+console.log(`\n\nExecuting: ${chalk.bold.yellow(cmd)}\n\n`);
+exec(`${cmd}`, (error, out) => {
+  if (error) {
+    console.log(`\n\n***ERROR ${error}\n\n`);
+    process.exit(1);
+  }
+});