@leverege/build-tools 1.8.4

package/src/dnsify/CloudflareAPI.js

@@ -0,0 +1,99 @@
+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/src/dnsify/index.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+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/src/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/src/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/src/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/src/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 )
+}