factorio

#!/bin/bash

### BEGIN INIT INFO
# Provides: Factorio
# Required-Start: $local_fs $network $remote_fs
# Required-Stop: $local_fs $network $remote_fs
# Default-Start:  2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: start and stop Factorio server
# Description: A init script for Factorio, try the help command
### END INIT INFO

debug(){
  if [ ${DEBUG} -gt 0 ]; then
    echo "DEBUG: $@" >&2
  fi
}

# Load config file
if [ -L $0 ]; then
  source `readlink -e $0 | sed "s:[^/]*$:config:"`
else
  source `echo $0 | sed "s:[^/]*$:config:"`
fi

if [ -z "${SERVICE_NAME}" ]; then
  echo "Couldn't load config file, please edit config.example and rename it to config"
  exit 1
fi

# Check/load defaults for backwards compatible config options
if [ -z "${PACKAGE_DIR_NAME}" ]; then
  PACKAGE_DIR_NAME=factorio
fi
if [ -z "${USERGROUP}" ]; then
  USERGROUP=${USERNAME}
fi
if [ -z "${HEADLESS}" ]; then
  # This is a server init script, assume headless default
  HEADLESS=1
fi

if [ -z "${NONCMDPATTERN}" ]; then
  # This is a server init script, assume headless default
  NONCMDPATTERN='(^\s*(\s*[0-9]+\.[0-9]+|\)|\())|(Players:$)'
fi


if ! [ "$1" == "install" ]; then
  if [ -z ${BINARY} ]; then
    # Factorio headless only comes in x64 flavour - if you run anything else, override it in the config
    BINARY="${FACTORIO_PATH}/bin/x64/factorio"
  fi

  if ! [ -e ${BINARY} ]; then
    echo "Could not find factorio binary! ${BINARY}"
    echo "(if you store your binary some place else, override BINARY='/your/path' in the config)"
    exit 1
  fi

  if [ -z ${FCONF} ]; then
    FCONF="${FACTORIO_PATH}/config/config.ini"
  fi

  if ! [ -e "${SERVER_SETTINGS}" ]; then
    echo "Could not find factorio server settings file: ${SERVER_SETTINGS}"
    echo "Update your config and point SERVER_SETTINGS to a modified version of data/server-settings.example.json"
    exit 1
  fi

  if ! [ -e ${FCONF} ]; then
    echo "Could not find factorio config file: ${FCONF}"
    echo "If this is the first time you run this script you need to generate the config.ini by starting the server manually."
    echo "(also make sure you have a save to run or the server will not start)"
    echo
    echo "Create save: sudo -u ${USERNAME} ${BINARY} --create ${FACTORIO_PATH}/saves/my_savegame"
    echo "Start server: sudo -u ${USERNAME} ${BINARY} --start-server-load-latest"
    echo
    echo "(If you rather store the config.ini in another location, set FCONF='/your/path' in this scripts config file)"
    exit 1
  fi
  if [ -z "${WRITE_DIR}" ]; then
    # figure out the write-data path (where factorio looks for saves and mods)
    # Note - this is a hefty little operation, possible cause of head ache down the road
    # as it relies on the factorio write dir to live ../../ up from the binary if __PATH__executable__
    # is used in the config file.. for now, that's the default so cross your fingers it will not change ;)
    debug "Determining WRITE_DIR based on ${FCONF}, IF you edited write-data from the default, this probably fails"
    WRITE_DIR=$(dirname "$(echo `grep "^write-data=" "$FCONF"` |cut -d'=' -f2 |sed -e 's#__PATH__executable__#'$(dirname "$BINARY")/..'#g')")
  fi
  debug "write path: $WRITE_DIR"

  PIDFILE="${WRITE_DIR}/server.pid"

  if [ -z "${FIFO}" ];then
    FIFO="${WRITE_DIR}/server.fifo"
  fi

  if [ -z "${CMDOUT}" ];then
    CMDOUT="${WRITE_DIR}/server.out"
  fi

  if [ -z "${SAVELOG}" ]; then
    SAVELOG=0
  fi

  # Finally, set up the invocation
  INVOCATION="${BINARY} --config ${FCONF} --port ${PORT} --start-server-load-latest --server-settings ${SERVER_SETTINGS} --autosave-interval ${AUTOSAVE_INTERVAL} --autosave-slots ${AUTOSAVE_SLOTS} ${RCON} ${EXTRA_BINARGS}"

fi

usage(){
  echo "Usage: $0 COMMAND"
  echo
  echo "Available commands:"
  echo -e "   start \t\t Starts the server"
  echo -e "   stop \t\t Stops the server"
  echo -e "   restart \t\t Restarts the server"
  echo -e "   status \t\t Displays server status"
  echo -e "   players-online \t Shows online players"
  echo -e "   players \t\t Shows all players"
  echo -e "   cmd [command/message] Open interactive commandline or send a single command to the server"
  echo -e "   chatlog [--tail|-t]   Print the current chatlog, optionally tail the log to follow in real time"
  echo -e "   new-game name\t Stops the server and creates a new game with the specified name"
  echo -e "   save-game name \t Stops the server and saves game to specified save"
  echo -e "   load-save name \t Stops the server and loads the specified save"
  echo -e "   install tarball \t Installs the server with specified tarball"
  echo -e "   update [--dry-run] \t Updates the server"
  echo -e "   invocation \t\t Outputs the invocation for debugging purpose"
  echo -e "   listcommands \t List all init-commands"
  echo -e "   listsaves \t\t List all saves"
  echo -e "   version \t\t Prints the binary version"
  echo -e "   help \t\t Shows this help message"
}

ME=`whoami`
as_user() {
  if [ $ME == $USERNAME ]; then
    bash -c "$1"
  else
    su $USERNAME -s /bin/bash -c "$1"
  fi
}

is_running() {
  if [ -e ${PIDFILE} ]; then
    if kill -0 $(cat ${PIDFILE}) 2> /dev/null; then
      debug "${SERVICE_NAME} is running with pid $(cat ${PIDFILE})"
      return 0
    else
      debug "Found ${PIDFILE}, but the server is not running. It's possible that your server has crashed"
      debug "Check the log for details"
      rm ${PIDFILE} 2> /dev/null
      return 2
    fi
  fi
  return 1
}

start_service() {
  if [ -e ${PIDFILE} ]; then
    ps -p $(cat ${PIDFILE}) > /dev/null 2>&1
    if [ "$?" -eq "0" ]; then
      echo "${SERVICE_NAME} is already running!"
      return 1
    fi
    debug "Found rogue pid file, server might have crashed"
    rm ${PIDFILE} 2> /dev/null
  fi

  if ! check_permissions; then
    echo "Error! Incorrect permissions, unable to write to ${WRITE_DIR}"
    return 1
  fi

  if [ "${SAVELOG}" ==  "0" ]; then
    debug "Erasing log ${CMDOUT}"
    echo "" > ${CMDOUT}
  fi

  as_user "tail -f ${FIFO} |${INVOCATION} >> ${CMDOUT} 2>&1 & echo \$! > ${PIDFILE}"

  ps -p $(cat ${PIDFILE}) > /dev/null 2>&1
  if [ "$?" -ne "0" ]; then
    echo "Unable to start ${SERVICE_NAME}"
    return 1
  else
    echo "Started ${SERVICE_NAME}, please see log for details"
  fi
}

stop_service() {
  if [ -e ${PIDFILE} ]; then
    echo -n "Stopping ${SERVICE_NAME}: "
    if kill -TERM $(cat ${PIDFILE}) 2> /dev/null; then
      sec=1
      while [ "$sec" -le 15 ]; do
        if [ -e ${PIDFILE} ]; then
          if kill -0 $(cat ${PIDFILE}) 2> /dev/null; then
            echo -n ". "
            sleep 1
          else
            break
          fi
        else
          break
        fi
        sec=$(($sec+1))
      done
    fi

    if kill -0 $(cat ${PIDFILE}) 2> /dev/null; then
      echo "Unable to shut down nicely, killing the process!"
      kill -KILL $(cat ${PIDFILE}) 2> /dev/null
    else
      echo "complete!"
    fi

    # Write a newline to the pipe, this triggers a SIGPIPE and causes tail to exit
    echo "" > ${FIFO}
    rm ${PIDFILE} 2> /dev/null
    return 0 # we've either shut down gracefully or killed the process
  else
    echo "${SERVICE_NAME} is not running (${PIDFILE} does not exist)"
    return 1
  fi
}

send_cmd(){
  if is_running; then
    if [ -p ${FIFO} ]; then
      # Grab a random 16 character id for our command
      cmdid=$(cat /dev/urandom |tr -dc 'a-zA-Z0-9' |fold -w 16 |head -n 1)
      # Whisper that unknown player named after our random id
      echo "/w ${cmdid}" > ${FIFO}
      # Wait for factorio to read stdin
      sleep 1
      # Run the actual command
      echo $@ > ${FIFO}
      # Wait again, this might need more sleep for larger command output - time will tell (sorry future self for any head aches)
      sleep 1
      # Read the output file backwards - capture everything between the end of file until
      # factorio tells us our random command id player does not exist.
      # This also attempts to filter all non chat/command lines from the output
      response=$(sed "/Player ${cmdid} doesn't exist./q" <(tac ${CMDOUT}) |egrep -v "(${cmdid})|${NONCMDPATTERN}")
      echo "${response}"
    else
      echo "${FIFO} is not a pipe!"
      return 1
    fi
  else
    echo "Unable to send cmd to a stopped server!"
    return 1
  fi
}

cmd_players(){
  players=$(send_cmd "/p")
  if [ -z "${players}" ]; then
    echo "No players found!"
    return 1
  fi

  if [ "$1" == "online" ]; then
    echo "${players}" |egrep '.+ \(online\)$' |sed -e 's/ (online)//g'
  else
    echo "${players}"
  fi
}

check_permissions(){
  if [ ! -e "${BINARY}" ]; then
    echo "Can't find ${BINARY}. Please check your config!"
    exit 1
  fi

  if ! as_user "test -w ${WRITE_DIR}" ; then
    echo "Check Permissions. Cannot write to ${WRITE_DIR}"
    exit 1
  fi

  if ! as_user "touch ${PIDFILE}" ; then
    echo "Check Permissions. Cannot touch pidfile ${PIDFILE}"
    exit 1
  fi

  if ! [ -p ${FIFO} ]; then
    if ! as_user "mkfifo ${FIFO}"; then
      echo "Failed to create pipe for stdin, if applicable, remove ${FIFO} and try again"
      exit 1
    fi
  fi

  if ! as_user "touch ${CMDOUT}" ; then
    echo "Check Permissions. Cannot touch cmd output file ${CMDOUT}"
    exit 1
  fi
}

test_deps(){
  return 0 # TODO: Implement ldd check on $BINARY
}

install(){
  # Factorio comes packaged in a directory named "factorio"
  # Unless overriden in the config we will presume this is also the
  # name used in FACTORIO_PATH
  expected_path="`dirname ${FACTORIO_PATH}`/${PACKAGE_DIR_NAME}"
  if ! [ "${FACTORIO_PATH}" == "${expected_path}" ]; then
    echo "Aborting install! FACTORIO_PATH does not match expected path: ${expected_path}"
    echo "See config option PACKAGE_DIR_NAME for more details"
    exit 1
  fi

  # Prevent accitential overwrites
  if [ -e "${expected_path}" ]; then
    echo "Aborting install, ${FACTORIO_PATH} already exists"
    exit 1
  fi

  tarball=$1
  if ! [ -f "${tarball}" ]; then
    echo "Install package does not exist! ${tarball}"
    exit 1
  fi

  target="`dirname ${FACTORIO_PATH}`"
  if ! test -w "${target}"; then
    echo "Failed to write, aborting install!"
    echo "Install needs to be run as a user with write permissions to ${target}"
    exit 1
  fi

  echo "Installing ${tarball} ..."
  if ! tar -xzvf "${tarball}" --directory "${target}"; then
    echo "Install failed!"
    exit 1
  fi

  echo "Applying file ownership ..."
  if ! chown -R ${USERNAME}:${USERGROUP} ${FACTORIO_PATH}; then
    echo "Failed to apply ownership ${USERNAME}:${USERGROUP} for ${FACTORIO_PATH}"
    exit 1
  fi

  echo "Installation complete, edit the config and start your server"
}

get_bin_version(){
  echo `as_user "$BINARY --version |egrep '^Version: [0-9\.]+' |egrep -o '[0-9\.]+' |head -n 1"`
}

get_bin_arch(){
  echo `as_user "$BINARY --version |egrep '^Binary version: ' |egrep -o '[0-9]{2}'"`
}

update(){
  if ! [ -e "${UPDATE_SCRIPT}" ]; then
    echo "Failed to find update script, blatantly refusing to continue!"
    echo "Try cloning into git@github.com:narc0tiq/factorio-updater.git and set the UPDATE_SCRIPT config before you try again."
    exit 1
  fi

  # Assume the user wants a dry run? (our only argument to this function)
  if ! [ -z "$1" ]; then
    echo "Running updater in --dry-run mode, no patches will be applied"
    dryrun=1
  else
    dryrun=0
  fi

  if [ ${HEADLESS} -gt 0 ]; then
    package="core-linux_headless`get_bin_arch`"
  else
    package="core-linux`get_bin_arch`"
  fi

  version=`get_bin_version`
  if [ -z "${UPDATE_TMPDIR}" ]; then
    UPDATE_TMPDIR=/tmp
  fi

  tmpdir="${UPDATE_TMPDIR}/factorio-update"
  invocation="python ${UPDATE_SCRIPT} --for-version ${version} --package ${package} --output-path ${tmpdir}"
  if [ ${UPDATE_EXPERIMENTAL} -gt 0 ]; then
    invocation="${invocation} --experimental"
  fi

  if [ ${HEADLESS} -eq 0 ]; then
    #GoodGuy Wube Software allows you to download the headless for free - yay! but you still have to
    #buy the game if you want to download the sound/gfx client
    invocation="${invocation} --user ${UPDATE_USERNAME} --token ${UPDATE_TOKEN}"
  fi

  echo "Checking for updates..."
  result=`as_user "${invocation} --dry-run"`
  exitcode=$?
  if [ ${exitcode} -gt 0 ]; then
    echo "Update check failed!"
    exit 1
  else
    newversion=`echo ${result} |egrep '^Dry run: ' |egrep -o '[0-9\.]+' |tail -n 1`
  fi

  if [ -z "${newversion}" ]; then
    echo "No new updates for ${package} ${version}"
    exit 0
  else
    echo "New version ${package} ${newversion}"
  fi

  # Go or no Go?
  if [ ${dryrun} -gt 0 ]; then
    echo "Dry run, not taking further actions!"
    # allow scripts to read return code 0 for no updates and 2 if there are updates to apply
    if ! [ -z "${newversion}" ]; then
      exit 2
    fi
    exit 0
  fi

  if [ -e ${tmpdir} ]; then
    echo "Aborting update! Temporary directory already exists ${tmpdir}"
    echo "Remnants from a previously failed update?"
    exit 1
  fi

  if ! as_user "mkdir -p ${tmpdir}"; then
    echo "Aborting update! Unable to create tmpdir: ${tmpdir}"
    exit 1
  fi

  # Time to download the updates
  if ! as_user "${invocation}"; then
    echo "Aborting update!"
    rm -rf ${tmpdir}
    exit 1
  fi

  # Stop the server if it is running.
  if is_running; then
    send_cmd "Updating to new Factorio version, be right back"
    stop_service
  fi

  for patch in $(find ${tmpdir} -type f -name "*.zip" | sort -V); do
    echo "Applying ${patch} ..."
    result=`as_user "$BINARY --apply-update ${patch}"`
    exitcode=$?
    if [ $exitcode -gt 0 ]; then
      echo "${result}"
      echo
      echo "Error! Failed to apply update"
      echo "You can try to apply it manually with:"
      echo "su ${USERNAME} -c \"${BINARY} --apply-update ${patch}\""
      exit 1
    fi
  done

  echo "Successfully updated factorio"
  rm -rf ${tmpdir}
}

case "$1" in
  start)
    # Starts the server
    if is_running; then
      echo "Server already running."
      exit 0
    else
       if ! start_service; then
         echo "Could not start $SERVICE_NAME"
         exit 1
       fi
    fi
    ;;

  stop)
    # Stops the server
    if is_running; then
      send_cmd "Server is being shut down on request"
      if ! stop_service; then
        echo "Could not stop $SERVICE_NAME"
        exit 1
      fi
    else
      echo "No running server."
      exit 0
    fi
    ;;

  restart)
    # Restarts the server
    if is_running; then
      send_cmd "Server is being restarted on request, be right back!"
      if stop_service; then
        if ! start_service; then
          echo "Could not start $SERVICE_NAME after restart!"
          exit 1
        fi
      else
        echo "Failed to stop $SERVICE_NAME, aborting restart!"
        exit 1
      fi
    else
      echo "No running server to restart, starting it..."
      if ! start_service; then
        echo "Could not start $SERVICE_NAME"
        exit 1
      fi
    fi
    ;;

  status)
    # Shows server status
    if is_running; then
      echo "$SERVICE_NAME is running."
    else
      echo "$SERVICE_NAME is not running."
      exit 1
    fi
    ;;
  cmd)
    if [ -z "$2" ]; then
      trap 'clear' SIGTERM EXIT

      clear
      echo "Type any command or send chat messages"
      echo "This interactive commandline adds additional commands:"
      echo ""
      echo -e "\texit\t\texit the commandline"
      echo -e "\tclear\t\tclear the commandline screen"
      echo ""

      while true; do
        read -e -p "server@${SERVICE_NAME}> " cmd
        [ "${cmd}" == "exit" ] && exit 0
        [ "${cmd}" == "clear" ] && clear && continue
        echo ${cmd} > ${FIFO}
        sleep 1
      done
    else
      send_cmd "${@:2}"
    fi
    ;;
  chatlog)
    case $2 in
      --tail|-t)
        tail -F -n +0 ${CMDOUT} |egrep -v "${NONCMDPATTERN}"
        ;;
      *)
        cat ${CMDOUT} |egrep -v "${NONCMDPATTERN}"
        ;;
    esac
    ;;
  players)
    cmd_players
    ;;
  players-online|online)
    cmd_players online
    ;;
  new-game)
    if [ -z $2 ]; then
      echo "You must specify a save name for your new game"
      exit 1
    fi
    savename="${WRITE_DIR}/saves/$2"

    # Stop Service
    if is_running; then
      send_cmd "Generating new save, please stand by"
      if ! stop_service; then
        echo "Failed to stop server, unable to create new save"
        exit 1
      fi
    fi

    if ! as_user "$BINARY --create ${savename}"; then
      echo "Failed to create new game"
      exit 1
    else
      echo "New game created: ${savename}.zip"
    fi
    ;;

  save-game)
    savename="${WRITE_DIR}/saves/$2.zip"

    # Stop Service
    if is_running; then
      send_cmd "Stopping server to save game"
      if ! stop_service; then
        echo "Failed to stop server, unable to save as \"$2\""
        exit 1
      fi
    fi

    lastsave=$(find "${WRITE_DIR}/saves" -type f -printf '%T@ %p\n' | sort -n | tail -1 | cut -f2- -d" ")
    if ! as_user "cp ${lastsave} ${savename}"; then
      echo "Error! Failed to save game"
      exit 1
    fi
    ;;

  load-save)
    # Ensure we get a new save file name
    newsave=${WRITE_DIR}/saves/$2.zip
    if [ ! -f "${newsave}" ]; then
      echo "Save \"${newsave}\" does not exist, aborting action!"
      exit 1
    fi

    # Since stopping the server causes a save we have to stop the server to do this
    if is_running; then
      send_cmd "Stopping server to load a saved game"
      if ! stop_service; then
        echo "Aborting, unable to stop $SERVICE_NAME"
        exit 1
      fi
    fi

    # Touch the new save file
    as_user "touch ${newsave}"
    ;;
  install)
    install "$2"
    ;;
  update)
    update "$2"
    ;;
  inv|invocation)
    echo ${INVOCATION}
    ;;
  help|--help|-h)
    usage
    ;;
  listcommands)
    echo `$0 help 2> /dev/null |egrep '^   ' |awk '{ print $1 }'`
    ;;
  listsaves)
    echo `find ${WRITE_DIR} -type f |egrep -o '\w+\.zip$' |sed -e 's/.zip//'`
    ;;
  version)
    echo `get_bin_version`
    ;;
  *)
    echo "No such command!"
    echo
    usage
    exit 1
    ;;
esac

exit 0