dogfood

#!/bin/bash

nproc=$(nproc)

unset windows

terminal=
if [[ "${OS}" =~ "Windows" ]]
then
  windows=1
  configs=( Release Debug )
  buildopt="-m"
  launch=( start )
  launchdir="Release"
  if [[ -x $( type -p dos2unix ) ]]
  then
    dos2unix="dos2unix -O"
  else
    dos2unix="cat -v"
  fi
else
  configs=( "" )
  buildopt="-j${nproc}"
  launch=()
  launchdir=""
  dos2unix="cat -v"
fi

builddir="$(dirname $(pwd))/build/$(basename $(pwd))"
logfile="${builddir}/dogfood.out"
tmpfile="${builddir}/dogfood.tmp"
rm -fv "${logfile}"

_run()
{
  # Usage: _run: command
  echo -en "\nRun: ${@} " 2>&1 | tee -a "${logfile}"
  date 2>&1 | tee -a "${logfile}"
  if [[ "$1" == "--direct" ]]
  then
    shift
    "${@}"
  else
    ( time ${@} )  2>&1 | tee "${tmpfile}"
    set -x
    ${dos2unix} "${tmpfile}" >> "${logfile}"
    set +x
    rm "${tmpfile}"
  fi
}

tmuxopts="-d"
if [[ -n "${DISPLAY}" ]] && type -t gnome-terminal >& /dev/null
then
  terminal="gnome-terminal --"
  tmuxopts=""
fi
if [[ -z "${TMUX}" ]] && type -t tmux >& /dev/null
then
  # set -x
  cmd=( ${terminal} tmux new-session ${tmuxopts} -s rippled -x 80 -y 30 \
    sleep 600 )
  _run "${cmd[@]}" || true
  cmd=( tmux new-window -d -a -t rippled:$ -n dogfood \
    "${0}" "${@}" wait )
  _run "${cmd[@]}" || true
  cmd=( tmux select-window -t rippled:dogfood )
  _run "${cmd[@]}" || true
  cmd=( tmux kill-window -t rippled:sleep )
  _run "${cmd[@]}" || true
  # tmux set-option -w -t rippled:dogfood remain-on-exit on
  echo 'Running in tmux session. Use "tmux attach -t rippled" to join it'
  exit
fi

# Exit if anything fails
set -e
# Output commands before executing them
# set -x

cmake_prefix="${builddir}/cmake/"
cmake_dirs=$(\ls -r ${cmake_prefix})
echo Dirs: ${cmake_dirs}
cmake_targets="rippled"
echo Targets: ${cmake_targets}
echo "Configs: ${configs[@]}"
rundir=$(\ls -r ${cmake_prefix} | head -1)
echo rundir: ${rundir}

gdb=()
gdbextra=()
clean=0
fast=0
build=yes
test=0
while [[ ${#@} > 0 ]]
do
  if [[ "$1" == "fast" || "$1" == "notest" ]]
  then
    shift
    fast=1
  elif [[ "$1" == "nobuild" ]]
  then
    shift
    build=no
  elif [[ "$1" == "onlyrun" || "$1" == "runonly" || "$1" == "one" ]]
  then
    shift
    build=run
  elif [[ "$1" == "debug" && -n "${launchdir}" ]]
  then
    shift
    launchdir="Debug"
  elif [[ "$1" == "debug" ]] && type -t gdb >& /dev/null
  then
    shift
    gdb=( gdb -q )
    gdbextra=( --fg )
  elif [[ "$1" == "debug" ]] && type -t lldb >& /dev/null
  then
    shift
    gdb=( lldb )
    gdbextra=( )
  elif [[ "$1" == "test" ]]
  then
    shift
    test=1
  elif [[ "$1" == "clean" ]]
  then
    shift
    clean=1
  elif [[ "$1" == "wait" ]]
  then
    shift
    wait=1
  elif [[ "$1" == "--config" ]]
  then
    shift
    configs=( $1 )
    shift
  elif [[ "$1" == "--exe" ]]
  then
    shift
    cmake_targets="$1"
    shift
  elif [[ ${#gdb[@]} > 0 && "$1" == "--" ]]
  then
    shift
    if [[ "${#@}" ]]
    then
      gdb+=( "${@}" )
      shift "${#@}"
    fi
  elif [[ -d "${cmake_prefix}$1" ]]
  then
    rundir="$1"
    echo rundir changed to: ${rundir}
    shift
  else
    echo "Unknown option: $1" 2>&1
    exit 127
  fi
done

if [[ "$build" == "run" ]]
then
  cmake_dirs="${rundir}"
fi

datestamp=$( date +%s )

time (
  set -o pipefail
  if [[ ${clean} != 0 ]]
  then
    for dir in ${cmake_dirs}
    do
      dir=${cmake_prefix}${dir}
      cmd=( cmake --build $dir --target clean )
      _run "${cmd[@]}" || exit 1
    done
  fi

  # set -x
  if [[ "${build}" != "no" ]]
  then
    # Parallel unit tests have been enabled since 2017

    if type -t SimpleTestLoop >& /dev/null
    then
      for target in ${cmake_targets}
      do
        if [[ "$target" == "rippled" ]] && \
          type -t SimpleRippledTestLoop >& /dev/null
        then
          cmd=( SimpleRippledTestLoop ${cmake_dirs} )
          if [[ -n "${configs[@]}" ]]
          then
            cmd+=( "${configs[@]}" )
          fi
          if [[ ${fast} != 0 ]]
          then
            cmd+=( "--version" )
          fi
        elif [[ "$target" == "xrpld" ]] && \
          type -t SimpleXrpldTestLoop >& /dev/null
        then
          cmd=( SimpleXrpldTestLoop ${cmake_dirs} )
          if [[ -n "${configs[@]}" ]]
          then
            cmd+=( "${configs[@]}" )
          fi
          if [[ ${fast} != 0 ]]
          then
            cmd+=( "--version" )
          fi
        else
          cmd=( SimpleTestLoop "${target}" ${cmake_dirs} )
          if [[ -n "${configs[@]}" ]]
          then
            cmd+=( "${configs[@]}" )
          fi
          if [[ ${fast} != 0 ]]
          then
            cmd+=( "--version" )
          else
            cmd+=( "--unittest --unittest-jobs=$( nproc )" )
          fi
        fi
        _run --direct "${cmd[@]}" || exit 1
        cmd=( echo "No failures found in SimpleTestLoop output" )
        _run "${cmd[@]}"
      done || exit 1
    else
      for dir in ${cmake_dirs}
      do
        dir=${cmake_prefix}${dir}
        src=$(pwd)
        if pushd $dir
        then
          cmd=( cmake "${src}" )
          echo "Run: (from $(basename $(pwd)))" 2>&1 | tee -a "${logfile}"
          _run "${cmd[@]}" || exit 1
          popd
        fi
        for target in ${cmake_targets}
        do
          for config in "${configs[@]}"
          do
            echo Building $target in $dir 2>&1 | tee -a "${logfile}"
            if [[ -n "$config" ]]
            then
              echo "With configuration $config" 2>&1 | tee -a "${logfile}"
              testdir="$config"
              config="--config $config"
            fi
            cmd=( cmake --build $dir --target $target $config -- ${buildopt} )
            _run "${cmd[@]}" || exit 1
            if [[ ${fast} == 0 ]]
            then
              if [[ -n "$testdir" ]]
              then
                rd="${dir}/${testdir}/${target}"
              else
                rd="${dir}/${target}"
              fi
              cmd=( "${rd}" "--unittest" "--unittest-jobs=$( nproc )" )
              _run "${cmd[@]}" || exit 1
            fi
          done
        done
      done || exit 1
    fi
  fi

) || exit 1

if [[ ${test} != 0 ]]
then
  exit 0
fi

# set -x

ulimit -c unlimited
if type -t tmux >& /dev/null
then
  launch=( tmux new-window -a -t rippled:$ -n rippled )
  switch=( tmux last-window )
  cmd=( ${terminal} tmux new-session ${tmuxopts} -s rippled -x 80 -y 30
    sleep 600 )
  _run "${cmd[@]}" || true
  # Give the terminal a few seconds to create
  sleep 2
fi
for network in rippled # rippled-altnet
do
  cfgfile="${HOME}/.config/ripple/${network}.cfg"
  if [ -e "${cfgfile}" ]
  then
    runpath="${cmake_prefix}${rundir}/${launchdir}"
    for target in ${cmake_targets}
    do
      for runfile in ${target}{.exe,}
      do
        if [[ -f "${runpath}/${runfile}" ]]
        then
          exe="${runpath}/${runfile}"
          break
        fi
      done
      if [[ ! -f "${exe}" ]]
      then
        echo "Error: Expected executable not found: ${target}"
        break
      fi

      # Clean up old files
      for file in "${builddir}/${target}".* "${builddir}/gdb".*
      do
        if [[ ! -e "${file}" ]]
        then
          continue
        fi

        echo $file
        parts=( $( echo "${file}" | sed 's/\./ /g' ) )
        echo "${parts[@]}"
        ls -ltr "${builddir}"/*.${parts[1]}*
        if [[ -e "${builddir}/core.${parts[1]}" ]]
        then
          continue
        fi
        rm -fv "${builddir}"/*.${parts[1]}*
      done

      if [[ ${#gdb[@]} > 0 ]] && type -t gdb >& /dev/null
      then
        temp=(
          'set pagination off'
          "set logging file ${builddir}/gdb.${datestamp}.txt"
          "run"
          'tui enable'
          'winheight src -8'
          "generate-core-file ${builddir}/core.${datestamp}"
          # "set logging overwrite on"
          "set logging enabled on"
          "thread apply all bt full"
          # "set logging enabled off"
          "quit"
          # "info break"
          # "delete 2"
          # "fg"
          # "thread apply all bt full"
          # "set logging enabled off"
        )
        gdbcommands=()
        for c in "${temp[@]}"
        do
          gdbcommands+=( -ex "${c}" )
        done
        gdbcommands+=( "--args" )
      elif [[ ${#gdb[@]} > 0 ]] && type -t lldb >& /dev/null
      then
        : "TODO: Figure out how to do fancy startup stuff in lldb"
        temp=(
          # 'set pagination off'
          # "set logging file ${builddir}/gdb.${datestamp}.txt"
          "run"
          # 'tui enable'
          # 'winheight src -8'
          # "generate-core-file ${builddir}/core.${datestamp}"
          # "set logging enabled on"
          # "thread apply all bt full"
          "quit"
        )
        gdbcommands=()
        for c in "${temp[@]}"
        do
          gdbcommands+=( -o "${c}" )
        done
        gdbcommands+=( "--" )
      fi

      # Stop the currently running rippled, if any
      cmd=( "${exe}" --conf "${cfgfile}" stop )
      _run "${cmd[@]}" || true
      # Save the executable
      cmd=( cp -v "${exe}" "${builddir}/${runfile}.${datestamp}" )
      _run "${cmd[@]}" || true
      # Start the new rippled
      cmd=( "${launch[@]}" "${gdb[@]}" "${gdbcommands[@]}"
        "${exe}" --conf ${cfgfile} --net "${gdbextra[@]}" )
      _run --direct "${cmd[@]}" || true
        : 'https://sourceware.org/gdb/onlinedocs/gdb/TUI-Commands.html'
        : 'C-x a'
      if [[ "${#switch}" -gt 0 ]]
      then
        _run --direct "${switch[@]}"
      fi

      # Rotate the logfile(s)
      if [[ -f $HOME/.logrotate.conf ]] && \
        grep -q rippled $HOME/.logrotate.conf && \
        crontab -l | grep -q logrotate
      then
        cmd=(
          eval "$(
            crontab -l | grep logrotate | \
            awk '(index($6, "logrotate") != 0) \
              {l=$6; $1=$2=$3=$4=$5=$6=""; print l " --force --verbose " $0 }'
          )"
        )
        _run "${cmd[@]}" || true
      else
        for file in debug.log logs/debug.log log/debug.log \
            perf.log logs/perf.log log/perf.log
        do
          if [ -e "${HOME}/${network}/${file}" ]
          then
            mv -vi "${HOME}/${network}/${file}"{,.${datestamp}} || true
          fi
        done
      fi
    done
  else
    echo "Error: config file not found: ${cfgfile}"
  fi
done

cmd=( grep failures "${logfile}" )
_run "${cmd[@]}"

if [[ -n "${wait}" ]]
then
  read -n 1 -p "Press any key to continue..." -s
fi