MuranoCLI 3.0.7 → 3.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 42ba380e8b5ca16f20f06bee796bff578db09bcd
-  data.tar.gz: e7d33d39b2814804f583cc7e5a8a70762f229be2
+  metadata.gz: 3724b5391071776bfe44190b14ad244788ff94b7
+  data.tar.gz: f7a7825838b2143194871519fd109b00701ac361
 SHA512:
-  metadata.gz: b8c9c36f36761f164fcf748e66af4684f7da5fe881967aee2244cae28aadff565937148476cedc8f88e1b0cb5f47e4ce442e5b1b684d83277d5fff19c4ae571f
-  data.tar.gz: def44224a4a21c19e0f0961580291d4b5990dc0a37c5d8f347aaab0a09cd79365958ab4b3942e569032ec720f412baf10bb0f114e2ca365efe0a1c49ab6d8ca9
+  metadata.gz: e92ac9179d3a3444d9a8a283ab94f85e576d88e5bcae6f7b947d2401b588bb8fd4ca67cd7d31817a7cdadec1488aefc6ae0b966afe45aaba944a611571f8b8d2
+  data.tar.gz: 9fba7a0956161da7105417580bd9aa79c0372b61e3883318a184dd8a17ea01aeafc4e9c2f89e299cc4cf1f68b9c92ca89c1fd8013380a458a9e9c45dd1ee92bd

data/.gitignore

@@ -45,5 +45,5 @@ Gemfile.lock
 .rake_tasks~
 
 # Output from .trustme.vim and .trustme.sh
-.rake_build.out
+.trustme.log
 

data/.ignore

@@ -11,7 +11,7 @@ tags
 
 # 2017-05-12: Testing!
 *.out
-.rake_build.out
+.trustme.log
 curldebug.out
 
 rspec-*.html

data/.rubocop.yml

@@ -1,7 +1,8 @@
-# Last Modified: 2017.09.12 /coding: utf-8
-# Copyright © 2016-2017 Exosite LLC.
-# License: MIT. See LICENSE.txt.
-#  vim:tw=0:ts=2:sw=2:et:ai
+# Copyright © 2016-2017 Exosite LLC. All Rights Reserved
+# License: PROPRIETARY. See LICENSE.txt.
+# Unauthorized copying of this file is strictly prohibited.
+# frozen_string_literal: true
+# vim:tw=0:ts=2:sw=2:et:ai
 
 # USAGE:
 #
@@ -110,7 +111,7 @@ Style/EmptyMethod:
   Enabled: false
 
 # "The name of this source file (Xxxxxxx.rb) should use snake_case."
-Style/FileName:
+Naming/FileName:
   Exclude:
     - 'Gemfile'
     - 'MuranoCLI.gemspec'
@@ -127,11 +128,13 @@ Style/FileName:
     - 'lib/MrMurano/Exchange-Element.rb'
     - 'lib/MrMurano/Gateway.rb'
     - 'lib/MrMurano/Keystore.rb'
+    - 'lib/MrMurano/Logs.rb'
     - 'lib/MrMurano/Mock.rb'
     - 'lib/MrMurano/Passwords.rb'
     - 'lib/MrMurano/ProjectFile.rb'
     - 'lib/MrMurano/ReCommander.rb'
     - 'lib/MrMurano/Setting.rb'
+    - 'lib/MrMurano/Settings-HttpService.rb'
     - 'lib/MrMurano/Solution-ServiceConfig.rb'
     - 'lib/MrMurano/Solution-Services.rb'
     - 'lib/MrMurano/Solution-Users.rb'
@@ -141,6 +144,8 @@ Style/FileName:
     - 'lib/MrMurano/SyncAllowed.rb'
     - 'lib/MrMurano/SyncRoot.rb'
     - 'lib/MrMurano/SyncUpDown.rb'
+    - 'lib/MrMurano/SyncUpDown-Core.rb'
+    - 'lib/MrMurano/SyncUpDown-Item.rb'
     - 'lib/MrMurano/Webservice-Cors.rb'
     - 'lib/MrMurano/Webservice-Endpoint.rb'
     - 'lib/MrMurano/Webservice-File.rb'

data/.trustme.sh

@@ -1,5 +1,4 @@
 #!/bin/bash
-# Last Modified: 2017.09.20
 # vim:tw=0:ts=2:sw=2:et:norl:spell
 
 # WHAT: A Continuous Integration (CI) script for kicking the build
@@ -40,159 +39,326 @@
 #
 # MONITOR: All script output gets writ to a file. Use a terminal to tail it:
 #
-#            tail -F .rake_build.out
+#            tail -F .trustme.log
 
 # MEH: Need to enable errexit?
 #set +x
 
-OUT_FILE=".rake_build.out"
+OUT_FILE=".trustme.log"
 
 #local DONE_FILE=".trustme.done"
 LOCK_DIR=".trustme.lock"
-PID_FILE="${LOCK_DIR}/.build.pid"
-LOCK_KILL=".trustme.kill"
+KILL_DIR=".trustme.kill"
+PID_FILE=".trustme.pid"
+# Hrm. The bang might not work without
+KILL_BIN=".trustme.kill!"
 
-if [[ -f ${HOME}/.fries/lib/ruby_util.sh ]]; then
-  source ${HOME}/.fries/lib/ruby_util.sh
-else
-  echo 'Missing ruby_util.sh and chruby' >> ${OUT_FILE}
-  exit 1
-fi
-chruby 2.3.3
+# 2017-10-03: Don't build immediately after every save. If you like to
+# code a little, save, code a little save, repeat, then always running
+# the builder (a) gets annoying to see constantly churning, if you keep
+# a terminal on it; and (b) runs the CPU hot, because eslint. So avoid
+# building too frequently.
+# LATER/2017-10-03: CLI options for this script? It keeps growing!
+# For now, hardcode.
+#BUILD_DELAY_SECS=300
+#BUILD_DELAY_SECS=90
+#BUILD_DELAY_SECS=13
+#BUILD_DELAY_SECS=5
+#BUILD_DELAY_SECS=1
+BUILD_DELAY_SECS=0
+
+# This script is run relative to Vim's working directory, so be deliberate about paths.
+# ${BASH_SOURCE[0]} should be the absolute path to this script.
+TRUSTME_DIR=$(dirname -- "${BASH_SOURCE[0]}")
+OUT_FILE="${TRUSTME_DIR}/${OUT_FILE}"
 
-trap death SIGINT
+say() {
+  echo "$1" >> "${OUT_FILE}"
+}
 
-function annoucement() {
-  echo >> ${OUT_FILE}
-  echo "###################################################################" >> ${OUT_FILE}
-  echo $1 >> ${OUT_FILE}
-  echo "###################################################################" >> ${OUT_FILE}
-  echo >> ${OUT_FILE}
+announcement() {
+  say
+  say "###################################################################"
+  say "$1"
+  say "###################################################################"
+  [[ "$2" != '' ]] && say "$2"
+  say
 }
 
-function death() {
-  echo "death!" >> ${OUT_FILE}
-  annoucement "DEATH! ☠☠☠"
+death() {
+  if [[ -n ${WAIT_PID} ]]; then
+    say "Sub-killing ‘${WAIT_PID}’"
+    kill -s 9 ${WAIT_PID}
+  fi
+  # The other script waits for us to cleanup the PID file.
+  remove_pid_files
+  # Note that output gets interleaved with the killing process,
+  # so keep this to one line (don't use `announcement`).
+  say "☠☠☠ DEATH! ☠☠☠ ‘$$’ is now dead"
   exit 1
 }
 
-function lock_kill_or_die() {
+# FIXME/2017-09-28: Move this and other common fcns. to home-fries?
+lock_kill_die() {
+  say "Desperately Seeking Lock on $(date)..."
+  [[ "$1" == true ]] && local AFTER_WAIT=true || local AFTER_WAIT=false
   local build_it=false
   # mkdir is atomic. Isn't that nice.
-  if $(mkdir ${LOCK_DIR} 2> /dev/null); then
-    # The first, or only instance to be running. Run the build.
-    echo "first one here!" >> ${OUT_FILE}
-  elif [[ -d ${LOCK_DIR} ]]; then
-    # There's a build going on. Should we kill it?
-    if $(mkdir ${LOCK_KILL} 2> /dev/null); then
-      if [[ -f ${PID_FILE} ]]; then
-        local build_pid=$(cat ${PID_FILE})
-        if [[ ${build_pid} != '' ]]; then
-          echo "build locked, but not the kill! time for mischiefs" >> ${OUT_FILE}
-          # Yeah! We get to kill a process!
-          annoucement "Killing it!"
-          kill -s SIGINT ${build_pid} &>> ${OUT_FILE}
-          if [[ $? -ne 0 ]]; then
-            echo "Kill failed! on pid ‘${build_pid}’" >> ${OUT_FILE}
-            # So, what happened? Did the build complete?
-            # Should we just move along? Probably...
-            # Get the name of the process. If it still exists, die.
-            if [[ $(ps -p ${build_pid} -o comm=) != '' ]]; then
-              echo "WARNING: but process still exists!"
-              exit
-            fi
+  if $(mkdir "${LOCK_DIR}" 2> /dev/null); then
+    say "Scored the lock!"
+    kill_other ${AFTER_WAIT} true
+  elif [[ -d "${LOCK_DIR}" ]]; then
+    if ! ${AFTER_WAIT}; then
+      # There's another script waiting to build, or a build going on.
+      # Kill it if you can.
+      say "Could not lock, but can still kill!"
+      kill_other ${AFTER_WAIT} false
+    else
+      # This script got the lock earlier, released it, and slept, and now
+      # it cannot get the lock...
+      say "i waited for you but you locked me out"
+      exit
+    fi
+  else
+    announcement "WARNING: could not mkdir ‘${LOCK_DIR}’ and it does not exist, later!"
+    exit
+  fi
+}
+
+kill_other() {
+  [[ "$1" == true ]] && local AFTER_WAIT=true || local AFTER_WAIT=false
+  [[ "$2" == true ]] && local OUR_LOCK=true || local OUR_LOCK=false
+  if $(mkdir "${KILL_DIR}" 2> /dev/null); then
+    if [[ -f "${PID_FILE}" ]]; then
+      local build_pid=$(cat "${PID_FILE}")
+      if ${AFTER_WAIT}; then
+        if [[ "$$" != "${build_pid}" ]]; then
+          echo "Panic, jerks! The build_pid is not our PID! ${build_pid} != $$"
+          exit
+        fi
+      elif [[ "${build_pid}" != '' ]]; then
+        #say "Locked the kill directory! time for mischiefs"
+        say "Killing ‘${build_pid}’"
+        # Process, your time has come.
+        kill -s SIGUSR1 "${build_pid}" &>> "${OUT_FILE}"
+        if [[ $? -ne 0 ]]; then
+          say "Kill failed! On PID ‘${build_pid}’"
+          # So, what happened? Did the build complete?
+          # Should we just move along? Probably...
+          # Get the name of the process. If it still exists, die.
+          if [[ $(ps -p "${build_pid}" -o comm=) != '' ]]; then
+            say "Said process still exists!"
+            exit
           fi
+          # The process is a ghost.
+          remove_pid_files
         else
-          echo "build locked, but not kill. but no pid? whatever, we'll take it!"
+          # Wait for the other trustme to clean up.
+          WAIT_PATIENCE=10
+          sleep 0.1
+          while [[ -f "${PID_FILE}" ]]; do
+            say "Waiting on PID ${build_pid} to cleanup..."
+            sleep 0.5
+            WAIT_PATIENCE=$((WAIT_PATIENCE - 1))
+            [[ ${WAIT_PATIENCE} -eq 0 ]] && echo "Done waiting!" && exit
+          done
         fi
       else
-        echo "build locked, but not kill. but builder has not started, bye" >> ${OUT_FILE}
-        exit
+        say "WARNING: Empty PID file? Whatever, we'll take it!"
       fi
-    else
-      echo "all locked, party over, man!" >> ${OUT_FILE}
+    elif ! ${OUR_LOCK}; then
+      # This is after waiting, which seems weird, eh.
+      say "Kill okay without build lock, but no PID file. Is someone tinkering?"
       exit
+    else
+      say "Got the build lock and kill lock, and there's no PID. Fresh powder!"
     fi
   else
-    echo "WARNING: could not mkdir ‘${LOCK_DIR}’ and it does not exist, later!" >> ${OUT_FILE}
+    say "Someone else has the kill lock. We're boned!"
     exit
   fi
 }
-lock_kill_or_die
 
-function prepare_to_build() {
-  echo "$$" > ${PID_FILE}
-  [[ -d ${LOCK_KILL} ]] && rmdir ${LOCK_KILL}
+lock_or_die() {
+  lock_kill_die false
+}
+
+lock_kill_or_die() {
+  lock_kill_die true
+}
+
+prepare_to_build() {
+  rmdir "${KILL_DIR}"
+  say
+  say "See you on the other side!"
+  touch "${OUT_FILE}"
+  truncate -s 0 "${OUT_FILE}"
+}
+
+init_it() {
+  if [[ -f ${HOME}/.fries/lib/ruby_util.sh ]]; then
+    source ${HOME}/.fries/lib/ruby_util.sh
+  else
+    echo 'Missing ruby_util.sh and chruby' >> ${OUT_FILE}
+    exit 1
+  fi
+  chruby 2.3.3
+}
 
-  #/bin/rm ${DONE_FILE}
-  #/bin/rm ${OUT_FILE}
-  touch ${OUT_FILE}
-  truncate -s 0 ${OUT_FILE}
+lang_it() {
+  announcement "LANG IT"
 }
-prepare_to_build
 
-time_0=$(date +%s.%N)
-#echo >> ${OUT_FILE} # Put newline after "tail: .rake_build.out: file truncated"
-annoucement "WARMING UP"
-echo "Build started at $(date '+%Y-%m-%d_%H-%M-%S')" >> ${OUT_FILE}
-echo "cwd: $(pwd)" >> ${OUT_FILE}
-echo "- ruby -v: $(ruby -v)" >> ${OUT_FILE}
-echo "- rubocop -v: $(rubocop -v)" >> ${OUT_FILE}
-#echo "- cmd rubocop: $(command -v rubocop)" >> ${OUT_FILE}
+build_it() {
+  announcement "BUILD IT"
+
+  echo "cwd: $(pwd)" >> ${OUT_FILE}
+  echo "- ruby -v: $(ruby -v)" >> ${OUT_FILE}
+  echo "- rubocop -v: $(rubocop -v)" >> ${OUT_FILE}
+  #echo "- cmd rubocop: $(command -v rubocop)" >> ${OUT_FILE}
 
-function build_it() {
-  annoucement "BUILD IT"
   rake build &>> ${OUT_FILE} && \
       gem install -i $(ruby -rubygems -e 'puts Gem.dir') \
           pkg/MuranoCLI-$(ruby -e 'require "/exo/clients/exosite/MuranoCLI/lib/MrMurano/version.rb"; puts MrMurano::VERSION').gem \
       &>> ${OUT_FILE}
 }
-build_it
 
-function test_concurrency() {
-  for i in $(seq 1 5); do build_it; done
-}
-# DEVs: Wanna test CTRL-C more easily by keeping the script alive longer?
-#       Then uncomment this.
-#test_concurrency
-
-function lint_it() {
-  annoucement "LINT IT"
+lint_it() {
+  announcement "LINT IT"
   rubocop -D -c .rubocop.yml &>> ${OUT_FILE}
 }
-lint_it
 
-function rspec_it() {
-  annoucement "RSPEC IT"
+rspec_it() {
+  announcement "RSPEC IT"
   rake rspec &>> ${OUT_FILE}
 }
-# This is probably not the best idea,
-# especially if your tests use the same
-# business as you do when developing.
-#rspec_it
-
-function ctags_it() {
-  annoucement "CTAGS IT"
-  ctags -R \
-    --exclude=coverage \
-    --exclude=docs \
-    --exclude=pkg \
-    --exclude=report \
-    --exclude=spec \
-    --verbose=yes
+
+ctags_it() {
+  announcement "CTAGS IT"
+  local ctags_out=$( { \
+    ctags -R \
+      --exclude=coverage \
+      --exclude=docs \
+      --exclude=pkg \
+      --exclude=report \
+      --verbose=yes \
+    ; \
+  } 2>&1 )
+  if [[ $? -ne 0 ]]; then
+    say
+    say 'ctags FAILED!'
+    say '                                      '
+    say
+    say "${ctags_out}"
+    say
+    say '                                      '
+    say
+  fi
   /bin/ls -la tags >> ${OUT_FILE}
 }
-ctags_it
 
-time_n=$(date +%s.%N)
-time_elapsed=$(echo "$time_n - $time_0" | bc -l)
-annoucement "DONE!"
-echo "Build finished at $(date '+%H:%M:%S') on $(date '+%Y-%m-%d') in $time_elapsed secs." >> ${OUT_FILE}
+drop_locks() {
+  rmdir "${LOCK_DIR}" "${KILL_DIR}"
+}
+
+remove_pid_files() {
+  /bin/rm "${PID_FILE}"
+  /bin/rm "${KILL_BIN}"
+}
+
+main() {
+  # We're called on both save, and on simple buffer enter.
+  if [[ ${DUBS_TRUST_ME_ON_SAVE} != 1 ]]; then
+    # We've got nothing to do on simple buffer enter...
+    announcement "DUBS_TRUST_ME_ON_FILE: ${DUBS_TRUST_ME_ON_FILE}"
+    say "Nothing to do on open"
+    exit 1
+  fi
+
+  trap death SIGUSR1
+
+  say
+  say "              󷎟  󲁹  󲁭  󲁨  🚷  🐧  🐨  🐫  🐬  🐰  🐳  🐎 "
+  announcement "  ❎ ❎ ❎ ❎ ❎ ❎ ❎ ❎ ❎ ❎ ❎ ❎ ❎ ❎ ❎   ❎ ❎ ❎ ❎ ❎ ❎ ❎ ❎ ❎ ❎ ❎ ❎ ❎ ❎ ❎ ❎"
+
+  init_it
+
+  # Get the lock.
+  lock_or_die
+
+  say "‘$$’ has the lock"
+  echo "$$" > "${PID_FILE}"
+  echo "kill -s SIGUSR1 $$" > "${KILL_BIN}"
+  chmod 755 "${KILL_BIN}"
+
+  # Always build tags.
+  ctags_it
+
+  announcement "WAITING ON BUILD" "Countdown: ${BUILD_DELAY_SECS} secs..."
+
+  # Defer the build!
+  # FIXME/2017-10-03: Riddle me this: is a two-fer rmdir atomic?
+  drop_locks
+  # The trap on SIGUSR1 only fires when this script is active and
+  # not blocked on a subshell. And sleep is it's own command, so we
+  # background it.
+  sleep ${BUILD_DELAY_SECS} &
+  # Fortunately, we can use the Bash wait command, which does not
+  # block signals.
+  # Get the process ID of the last command.
+  #   LPID=$!
+  #   wait ${LPID}
+  # Or just wait.
+  wait
 
-#touch ${DONE_FILE}
+  say "Ready to build..."
+  say
 
-trap - SIGINT
+  # Get the lock.
+  lock_kill_or_die
+
+  if ${TESTING:-false}; then
+    drop_locks
+    remove_pid_files
+    say "DONE! (ONLY TESTING)"
+    exit
+  fi
+
+  prepare_to_build
+
+  time_0=$(date +%s.%N)
+  #say # Put newline after "tail: .rake_build.out: file truncated"
+  announcement "WARMING UP"
+  say "Build started at $(date '+%Y-%m-%d_%H-%M-%S')"
+  say "cwd: $(pwd)"
+
+  #lang_it
+
+  build_it
+  function test_concurrency() {
+    for i in $(seq 1 5); do build_it; done
+  }
+  # DEVs: Wanna test CTRL-C more easily by keeping the script alive longer?
+  #       Then uncomment this.
+  #test_concurrency
+
+  lint_it
+
+  # MEH/2017-12-06: The tests take a number of seconds to run, so skipping.
+  #test_it
+
+  time_n=$(date +%s.%N)
+  time_elapsed=$(echo "$time_n - $time_0" | bc -l)
+  announcement "DONE!"
+  say "Build finished at $(date '+%H:%M:%S') on $(date '+%Y-%m-%d') in ${time_elapsed} secs."
+
+  #touch "${DONE_FILE}"
+
+  trap - SIGUSR1
+
+  remove_pid_files
+  rmdir "${LOCK_DIR}"
+}
 
-/bin/rm ${PID_FILE}
-rmdir ${LOCK_DIR}
+main "$@"