@leverege/build-tools 1.8.4

package/lib/server/dnsify/CloudflareAPI.js

@@ -0,0 +1,103 @@
+"use strict";
+
+const ora = require('ora');
+
+const fs = require('fs');
+
+const path = require('path');
+
+const {
+  promisify
+} = require('util');
+
+class CloudflareAPI {
+  constructor(options) {
+    const {
+      args
+    } = options;
+    const {
+      url,
+      proxy,
+      ipaddress,
+      account
+    } = args;
+    this.url = url;
+    this.proxy = proxy;
+    this.ipaddress = ipaddress;
+    this.spinner = ora({
+      text: 'Creating DNS record...',
+      spinner: 'monkey'
+    });
+    this.account = account;
+  }
+
+  async decrypt(projectId = 'leverege-docker-images', keyRingId = 'build-tools', cryptoKeyId = 'circle-ci', ciphertextFileName = './accounts.json.enc', plaintextFileName = './accounts.json') {
+    // Import the library and create a client
+    const kms = require('@google-cloud/kms');
+
+    const client = new kms.KeyManagementServiceClient(); // The location of the crypto key's key ring, e.g. "global"
+
+    const locationId = 'us-east4'; // Reads the file to be decrypted
+
+    const readFile = promisify(fs.readFile);
+    const contentsBuffer = await readFile(path.resolve(__dirname, ciphertextFileName));
+    const name = client.cryptoKeyPath(projectId, locationId, keyRingId, cryptoKeyId);
+    const ciphertext = contentsBuffer.toString('base64'); // Decrypts the file using the specified crypto key
+
+    const [result] = await client.decrypt({
+      name,
+      ciphertext
+    }); // Writes the decrypted file to disk
+
+    const writeFile = promisify(fs.writeFile);
+    await writeFile(path.resolve(__dirname, plaintextFileName), Buffer.from(result.plaintext, 'base64'));
+  }
+
+  setAccountValues() {
+    const accountJson = require(path.resolve(__dirname, './accounts.json'));
+
+    const accountInfo = accountJson[this.account];
+    const {
+      email,
+      key,
+      zone
+    } = accountInfo;
+    this.cf = require('cloudflare')({
+      email,
+      key
+    });
+    this.zone = zone;
+  }
+
+  async deleteSecrets() {
+    const deleteFile = promisify(fs.unlink);
+    await deleteFile(path.resolve(__dirname, './accounts.json'));
+  }
+
+  async createDNSRecord() {
+    try {
+      this.spinner.start();
+      this.spinner.text = 'Decrypting Cloudflare secrets...';
+      await this.decrypt();
+      this.spinner.text = 'Initializing Cloudflare API...';
+      this.setAccountValues();
+      this.spinner.text = 'Adding A name record...';
+      await this.cf.dnsRecords.add(this.zone, {
+        type: 'A',
+        name: this.url,
+        content: this.ipaddress,
+        proxied: this.proxy
+      });
+      this.spinner.text = 'Removing secrets...';
+      await this.deleteSecrets();
+      this.spinner.stop();
+    } catch (ex) {
+      this.spinner.stop();
+      console.log(ex);
+      throw ex;
+    }
+  }
+
+}
+
+module.exports = CloudflareAPI;

package/lib/server/dnsify/index.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+"use strict";
+
+const commandLineArgs = require('command-line-args');
+
+const commandLineUsage = require('command-line-usage');
+
+const Cloudflare = require('./CloudflareAPI');
+
+const defaultConfig = {
+  account: 'leverege',
+  proxy: true
+};
+const sections = [{
+  content: 'Wraps Cloudflare to modify DNS configs for new UI/Servers'
+}, {
+  header: 'Options',
+  optionList: [{
+    name: 'account',
+    alias: 'a',
+    description: 'Cloudflare account to use'
+  }, {
+    name: 'ipaddress',
+    alias: 'i',
+    description: 'IP address to point DNS account to (e.g. 35.178.29.10)'
+  }, {
+    name: 'url',
+    alias: 'u',
+    description: 'URL name (e.g. myserver)'
+  }, {
+    name: 'proxy',
+    alias: 'p',
+    description: 'Turn on Cloudflare proxy (optional)'
+  }, {
+    name: 'help',
+    description: 'Print this usage guide.'
+  }]
+}];
+const usage = commandLineUsage(sections);
+const optionDefinitions = [{
+  name: 'account',
+  alias: 'a',
+  type: String,
+  defaultValue: defaultConfig.account
+}, {
+  name: 'ipaddress',
+  alias: 'i',
+  type: String
+}, {
+  name: 'url',
+  alias: 'u',
+  type: String
+}, {
+  name: 'proxy',
+  alias: 'p',
+  type: Boolean,
+  defaultValue: defaultConfig.proxy
+}, {
+  name: 'help',
+  alias: 'h',
+  type: Boolean
+}];
+const args = commandLineArgs(optionDefinitions);
+
+async function main() {
+  if (args.help) {
+    console.log(usage);
+  }
+
+  if (!args.url || !args.ipaddress) {
+    console.log('\n*******************************************');
+    console.log('**                                       **');
+    console.log('** Need to specify URL and/or IP address **');
+    console.log('**                                       **');
+    console.log('*******************************************');
+    console.log(usage);
+  } else {
+    const CF = new Cloudflare({ ...defaultConfig,
+      args
+    });
+
+    try {
+      await CF.createDNSRecord();
+      console.log('Successfully created a new DNS record');
+      console.log('It may take a few minutes for DNS to propagate');
+    } catch (ex) {
+      console.error(ex.message);
+    }
+  }
+}
+
+main();

package/lib/server/dockreate

@@ -0,0 +1,338 @@
+#!/bin/bash
+if [ -z "$1" ]; then
+  echo "   Usage: create <version number>"
+  exit 1
+fi
+
+# cleanup trapper for gracefully killing, which doesn't do much right now
+cleanup() {
+  printf "\nCleaning up and exiting...\n\n"
+  rm -rf ./workspace $SSHDIR .npmrc
+  exit 0
+}
+trap cleanup INT
+
+# Usage: colorize <color> <string>
+# where: color  = [red|green|yellow]
+#        string = the thing to apply the color to
+colorize() {
+  local C_green='\e[92m'
+  local C_yellow='\e[93m'
+  local C_red='\e[91m'
+  local C_off='\e[0m'
+
+  case "$1" in
+    'red'   ) clr="$C_red" ;;
+    'green' ) clr="$C_green" ;;
+    'yellow') clr="$C_yellow" ;;
+           *) clr=$C_off;;
+  esac
+
+  printf "$clr$2$C_off"
+}
+
+strip_undefined() {
+  local result="$1"
+  [ "$1" == "undefined" ] && result=""
+  printf "$result"
+}
+
+# Useful links with information regarding k8s/docker/nodejs and PID 1
+#   No PID 1 for NodeJS     => https://bit.ly/2Txi9Jq
+#   What tini is all about  => https://bit.ly/2HsSxqP
+#   Graceful kills with k8s => https://bit.ly/2NONEJG
+#
+# Params: $1 = version from dockerize invocation
+#         $2 = node image to dockerize, default: carbon-alpine (node 8)
+#         $3 = additional packages to install (htop redis-cli etc)
+create_Dockerfile() {
+  local regvers="${1}"
+  local nodeimg="${2:-carbon-alpine}"
+  local apkadds="${3}"
+  echo "Creating the Dockerfile for node ${nodeimg}"
+  cat<<EODOCKER > Dockerfile
+# Version ${regvers} @ `date`
+#
+# The FROM directive sets the Base Image for subsequent instructions
+FROM node:${nodeimg} as intermediate
+ 
+RUN mkdir -p /usr/src/app
+WORKDIR /usr/src/app
+
+# Install app dependencies
+COPY ./workspace/ /usr/src/app/
+ 
+# --------------------------------------------------------------
+# copy the ssh keys into place, npm install, and remove them
+# --------------------------------------------------------------
+  
+# Install packages to install private repos with ssh keys
+COPY ./.npmrc /usr/src/app/.npmrc
+RUN apk --no-cache add curl git openssh-client && \
+    apk --update add --no-cache --virtual build-dep g++ gcc libgcc \\
+      libstdc++ linux-headers make python && \
+    npm install --production --silent && \
+    rm -f /usr/src/app/.npmrc /root/.ssh/*
+ 
+# --------------------------------------------------------------
+# On to the real build now, the thing before was just an intermediate container
+# --------------------------------------------------------------
+ 
+FROM node:${nodeimg}
+ 
+# Install tint for PID 1 and replace shell with bash so we can source files
+RUN apk update && \
+    apk add --no-cache tini bash vim ${apkadds} && \
+    rm /bin/sh && ln -s /bin/bash /bin/sh && \
+    mkdir -p /usr/src/app /tmp/levlog
+ENTRYPOINT [ "/sbin/tini", "--" ]
+WORKDIR /usr/src/app
+ 
+COPY --from=intermediate /usr/src/app /usr/src/app
+
+USER node
+COPY ./bashrc /home/node/.bashrc
+CMD [ "/bin/bash", "-c", "node index.js" ]
+EODOCKER
+} # end of create_Dockerfile
+
+# Params: $1 = version from dockerize invocation
+create_bashrc() {
+  cat<<EOBASHRC > bashrc
+#!/bin/bash
+#
+# Version $1 @ `date`
+
+alias golog='cd /var/log/levlog;ls -l'
+alias h=history
+
+alias ls='ls -CF --color=auto'
+alias ll='ls -lh'
+alias lla='ls -lha'
+alias ltr='ls -CF --color=auto -lthr'
+alias genv='env | grep -i'
+alias glep='grep -l -s'
+alias golog='cd /var/log/levlog'
+alias m=less
+alias menv='env | sort | less'
+
+alias whatsmyip='wget -qO- ifconfig.co'
+
+alias rcli='redis-cli -h \${DATABASES_REDIS_SERVICE_HOST}'
+
+alias buny='/usr/src/app/node_modules/bunyan/bin/bunyan'
+alias bunlog='golog;cat *-1.log | buny | m'
+alias dbg='wget -q -O- localhost:5111/logLevel/debug'
+alias inf='wget -q -O- localhost:5111/logLevel/info'
+
+loglev()
+{
+  local wget='wget -q -O- localhost:5111'
+  local logl=''
+
+  if [ "\$1" != "" ];
+  then
+    logl="logLevel/\$1"
+  fi
+
+  printf "Running=> \$wget/\$logl\n"
+  printf "\n\`\$wget/\$logl\`\n\n"
+}
+EOBASHRC
+} # end of create_bashrc
+
+NPMRC="$HOME/.npmrc.ro"
+if [ ! -f "$NPMRC" ];
+then
+  cat<<ROTOKEN
+
+  $(colorize 'red' '***ERROR: expecting to see a readonly npmjs token')
+
+  For security purposes, we deploy images with read-only npmjs tokens.
+  These may be acquired from another developer, or can be created with the
+  npmjs leverege account.
+  
+  Obtain the token and drop it here => $(colorize 'green' "$NPMRC")
+
+
+ROTOKEN
+  exit 1
+fi
+
+# Look for leverege specifics, but only require the project name.
+project=$(strip_undefined "`node -p \"require('../package.json').leverege.project\"`")
+if [ "$project" == "" ];
+then
+  cat<<NOPROJ
+
+  $(colorize 'red' '***ERROR: package.json missing a leverege project statement')
+
+  The package.json file must contain a project setting in the leverege
+  namespace stating which GCP project the docker images are written to. It
+  should look something like:
+
+  "leverege": {
+    "project": "leverege-docker-images"
+  },
+
+NOPROJ
+  exit 1
+fi
+
+nodeimg=$(strip_undefined "`node -p \"require('../package.json').leverege.nodeimg\"`")
+nodeimg="${nodeimg:-carbon-alpine}"
+apkadds=$(strip_undefined "`node -p \"require('../package.json').leverege.apkadds\"`")
+
+container="`node -p \"require('../package.json').leverege.container\"`"
+if [ "$container" == "undefined" ];
+then
+  container=$(basename `git config --get remote.origin.url` .git)
+fi
+gcimage=gcr.io/$project/$container
+
+version=$1
+previous=`cat .previous`
+pckgver="v`node -p \"require('../package.json').version\"`"
+pckgdts="`date +\"%Y%m%d-%H%M\"`"
+tagging=`echo $version | egrep -e "^v\d+\.\d+\.\d+$"`
+
+if [ $tagging ];
+then
+  if [[ `git status --porcelain` ]]; then
+    cat<<DIRTAG
+
+  $(colorize 'red' '***ERROR: attempting to tag a non-beta dirty git repository')
+
+  You are attempting to create a tagged release image for pushing to the
+  container registry, but there are locally modified files. This is not
+  allowed since the applied tag will not be relevant to the image version
+  due to the pending commits.
+
+  Available options for proceeding:
+
+    $(colorize 'green' '1) cleanly commit all local mods assuming relevance')
+    $(colorize 'yellow' '2) eliminate unwanted local modifications')
+    $(colorize 'red' '3) stash anything that is irrelevant to this release')
+
+
+DIRTAG
+    exit 1
+  fi
+
+  # since we're tagging, the current branch must have an upstream
+  branch=`git rev-parse --abbrev-ref HEAD`
+  git rev-parse --abbrec-ref ${branch}@{u} &> /dev/null
+
+  if [ $? -ne 0 ];
+  then
+    cat<<NOUPSTR
+
+  $(colorize 'red' '***ERROR: the current branch must have an upstream')
+
+  You are attempting to create a tagged release image for pushing to the
+  container registry, but the current branch does not have an upstream to
+  push to. This is not allowed since the applied tag will be stranded here
+  in your local repository, which is what we are attempting to avoid.
+
+  Available options for proceeding:
+
+    $(colorize 'green' '1) set an upstream for this branch via:')
+    $(colorize 'green' "       git push --set-upstream origin ${branch}")
+
+    $(colorize 'yellow' '2) rebase, squash and merge onto a branch with an upstream')
+
+NOUPSTR
+    exit 1
+  fi
+
+  tagstat=$(colorize 'yellow' 'will be tagged')
+else
+  tagstat=$(colorize 'red' 'BETA RELEASE WILL NOT BE TAGGED')
+fi
+
+cat<<IMGINFO
+
+  Project:   $(colorize 'green' "$project")
+  Container: $(colorize 'green' "$container")
+  NodeImage: $(colorize 'green' "$nodeimg")
+  AddedPkgs: $(colorize 'green' "$apkadds")
+  Version:   $(colorize 'green' "$version")  $tagstat
+  Previous:  $(colorize 'yellow' "$previous")
+  DateStamp: $(colorize 'green' "$pckgdts")
+  GCImage:   $(colorize 'green' "$gcimage:$version")
+
+IMGINFO
+
+if [ "$pckgver" != "$version" ];
+then
+  cat<<EOPKG
+  $(colorize 'yellow' '***WARNING: specified version does not match package.json version' )
+                   package.json => $(colorize 'green' "$pckgver")
+                   specified    => $(colorize 'red'   "$version")
+
+EOPKG
+  if [ $tagging ];
+  then
+    cat<<EONOPE
+
+  $(colorize 'red' '... and you are attempting to release so NOPE!' )
+
+EONOPE
+    exit 1
+  fi
+fi
+
+create_Dockerfile "$version" "$nodeimg" "$apkadds"
+create_bashrc "$version" "$nodeimg"
+
+[ -d ./workspace ] && rm -rf ./workspace
+mkdir -p ./workspace
+cp -rfp ../package*json ../dist/* ./workspace
+ 
+# grab the read only npmrc token for the image
+cp -f $NPMRC .npmrc
+
+[ "$CIRCLECI" == "true" ] && exit 0
+
+printf "Hit return to continue or ^C to exit\n\n"; read ANS
+
+echo $version > .previous
+
+echo "Changing Google Project to $project"
+gcloud config set project $project
+
+echo "Creating Docker Image for $gcimage:$version"
+echo "   Building the workspace"
+
+# submit the build request to gcloud
+gcloud builds submit --tag $gcimage:$version .
+ 
+if [ $? -ne 0 ];
+then
+  bldErr=$?
+  cat<<BUILDERR
+
+  $(colorize 'red' '***ERROR: build failed! Aborting without tagging.')
+
+  The gcloud build process seems to have run into a problem. Please fix the
+  issue and rerun the dockerize process. This build will not be tagged, nor
+  will it be pushed.
+
+BUILDERR
+  exit $bldErr
+fi
+
+# Tag the container with the node detailsand the culprit.
+gcloud beta container images add-tag --quiet $gcimage:$version $gcimage:$pckgdts-$nodeimg-$USER
+
+if [ $tagging ];
+then
+  printf "\n$(colorize 'green' "Tagging and Pushing $version")\n"
+  git tag -af $1 -m "Docker version $1"
+  git push --follow-tags
+  gcloud beta container images add-tag --quiet $gcimage:$version $gcimage:latest
+else
+  printf "\n$(colorize 'yellow' '*** Skipped git tagging - beta release')\n\n"
+fi
+
+cleanup

package/lib/server/encrypt-secrets

@@ -0,0 +1,31 @@
+#!/bin/bash
+display_usage() { 
+  echo "This script encrypts files using Google KMS." 
+  echo -e "\nInputs: .env and secrets directory (if it exists) \n" 
+} 
+
+if [ "$1" == "-h" ]; then
+  display_usage
+  exit 1
+fi
+
+if [ -d "secrets" ]; then
+  # tar up secrets directory
+  tar -zcvf secrets.tar.gz secrets
+  # encrypt secrets file
+  gcloud kms encrypt \
+    --project leverege-docker-images \
+    --key circle-ci \
+    --keyring build-tools \
+    --location us-east4 \
+    --plaintext-file secrets.tar.gz \
+    --ciphertext-file secrets.tar.gz.enc
+fi
+
+# encrypt .env file
+gcloud kms encrypt --project leverege-docker-images \
+  --key circle-ci \
+  --keyring build-tools \
+  --location us-east4 \
+  --plaintext-file .env \
+  --ciphertext-file .env.enc

package/lib/server/getfbcfg

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+/**
+ * This script parses a firebase config into something useful.
+ */
+let stdbuf = []
+
+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]}": "${kv[1]}"${(i < lastLine ? ',' : '')}` )
+    }
+    console.log( "}" )
+
+  } )
+  .setEncoding( 'utf8' )

package/lib/server/getjson

@@ -0,0 +1,48 @@
+#!/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.
+ */
+const fs = require( 'fs' )
+const opts = require( 'commander' )
+
+opts
+  .version( '0.0.1' )
+  .option( '-f, --file <file name>', 'file to parse JSON from' )
+  .option( '-k, --key <key>', 'JSON key whose value to grab' )
+  .option( '-r, --regex <reg>', 'regular expression to apply to the value' )
+  .parse( process.argv )
+
+if( !opts.key ) { return }
+
+if( !opts.file ) {
+  console.error( `\n***ERROR: Missing a --file param\n` )
+  opts.outputHelp()
+  process.exit( 1 )
+}
+
+try {
+  const json  = JSON.parse( fs.readFileSync( opts.file, 'utf8' ))
+  const value = json[opts.key]
+  const match = new RegExp( opts.regex || ".*" ).exec( value )
+
+  console.log( match ? match[match.length-1] : '' )
+}
+catch( e ) {
+  console.log( e )
+}