bash_backup

#!/usr/bin/env bash
################################################################################
#: Title       : bash_backup
#: Date        : 2017-Nov-30
#: Author      : Anthony Tilelli
#: Version     : 1
#: Description : Runs backups defined in configuration file
################################################################################

# strict mode (http://redsymbol.net/articles/unofficial-bash-strict-mode/)
set -euo pipefail

# CONSTANTS
readonly GL_BACKUP_CONFIG="example_config/backup.config"
readonly GL_PRMG_CONFIG="example_config/prgm.config"

# FUNCTIONS
function fail() {
  # Outputs error-message and force-quits script

  local -r ERRORCODE="${1:-1}"
  local -r ERROR_MESSAGE="${2:-"fail called but \"ERROR_MESSAGE\" not set"}"
  printf "ERROR %d: %s\\n" "$ERRORCODE" "$ERROR_MESSAGE" >&2
  exit "$ERRORCODE"
}

function validate_config_file() {
  # Evaluates config files:
  # - Readable/exist
  # - ASCII text
  # - Owned by script user or root
  # - Writable by owner only.

  # Return:
  # Returns 0 or exits with failure

  local -r USERID="$1" #UID of the user calling script
  local -r CONFIG="$2" #File to evaluate
  local config_user="" #config user owner

  #Validates config files is readable by script user
  if [[ -r "$CONFIG" ]]; then
    #Is file ASCII text?
    if [[ "$(file "$CONFIG")" =~ "ASCII" ]] ; then
      #If file owned by root or USERID
      config_user=$(stat -c %u "$CONFIG")
      if (( config_user == 0 )) || (( config_user == "$USERID" )) ; then
        #writable by owner only??
        if [[ "$(stat -c %A "$CONFIG")" != -r???--?-- ]]; then
          fail 10 \
          "Wrong permissions on file: $CONFIG.(Is file write/executable by group/other?)"
        fi
      else
        fail 9 \
        "\"$CONFIG\" is not owned by root or $USERID (File owner: $config_user)"
      fi
    else
      fail 8 "File \"$CONFIG\" is not ASCII text type"
    fi
  else
    fail 7 \
    "Unable to use file: \"$CONFIG\". (Does files exist and is it readable?)"
  fi
  return 0
}

function find_config() {
  #Finds and processes config from given backup config file

  local -r BID="$1" #assumes there are no #
  local -r ACTION="$2"
  local -r BCKP_CONFIG="$3" #assumed validated

  #Return Variables (expected set)
  # - cfg_Program
  # - cfg_Arguments
  # - cfg_Source
  # - cfg_Backup
  # - cfg_cd
  # - cfg_UMASK

  #checking if variable exists (prevent non-local variable creation in function)
  local assert
  assert=${cfg_Program?"cfg_Program is not set"}
  assert=${cfg_Arguments?"cfg_Arguments is not set"}
  assert=${cfg_Source?"cfg_Source is not set"}
  assert=${cfg_Backup?"cfg_Backup is not set"}
  assert=${cfg_cd? "cfg_cd is not set"}
  assert=${cfg_UMASK? "cfg_UMASK is not set"}

  local -r CONFIG_LINE=$(grep "^$BID:.*$ACTION" "$BCKP_CONFIG" | sed 's/\s*#.*//g')
  #sed - removes comments from end of lines
  local IFS=:
  set -- $CONFIG_LINE
  if (( ${#} == 7 )) || (( ${#} == 8 )) ; then
    cfg_Program=$3
    cfg_Arguments=$4
    cfg_Source=$5
    cfg_Backup=$6
    cfg_cd=$7
    cfg_UMASK=${8-""} #$8 may be unset, defaults to empty
  elif ((${#} == 0)) ; then
    fail 3 "No entries found for \"${BID}:${ACTION}\""
  else
    fail 4 \
    "Entry \"${CONFIG_LINE}\" is incorrect or more then one line was found"
  fi
  return 0
}

function find_prgm(){
  #Finds and processes config from given prgm config file
  local -r PROGRAM="$1"
  local -ru ACTION="$2"
  local -r ARGUMENTS="$3"
  local -r SOURCE="$4"
  local -r BACKUP="$5"
  local -r PRMG_CONFIG_FILE="$6"

  #Return Variables (expected set)
  # - backup_command

  #checking if variable exists (prevent non-local variable creation in function)
  local assert=${backup_command?"backup_command is not set"}

  local -r CONFIG_LINE=$(grep "^$PROGRAM:.*$ACTION" "$PRMG_CONFIG_FILE" | sed 's/\s*#.*//g')
  #sed - removes comments from end of lines
  local -r NUM_OF_ENTRIES=$(grep -c "^$PROGRAM:.*$ACTION" "$PRMG_CONFIG_FILE")

  if (( NUM_OF_ENTRIES == 1 )); then
    local IFS=:
    # word splitting intended
    set -- $CONFIG_LINE
    shift 2 #removing program and Action

    backup_command="${PROGRAM} "
    while (( $# > 0  )) ; do
      case "${1}" in
        "arguments")  backup_command+="${ARGUMENTS} " ;;
        "source")     backup_command+="${SOURCE} "    ;;
        "backup")     backup_command+="${BACKUP} "    ;;
        *)            fail 6 "${1} is unknown"        ;;
      esac
      shift
    done
    #remove end space
    backup_command=${backup_command% }
  else
    fail 5 \
    "${NUM_OF_ENTRIES} entries found in ${PRMG_CONFIG_FILE} for \"${PROGRAM}:${ACTION}\""
  fi
}

function run_backup () {
  # Change directory and umask, if needed,  and runs backup

  local -r BACKUP_COMMAND="$1" #Command to run backup (required)
  local -r WORKING_DIR="${2:-/}"
  #Directory to change to before running backup (default /)
  local -r SET_UMASK="${3:-SKIP}"
  #umask to set before running backup (default SKIP)

  cd "$WORKING_DIR" || fail 20 "Could not cd to directory ${WORKING_DIR}"
  case "$SET_UMASK" in #ensuring is a valid umask
    SKIP) ;; #DO-NOTHING
    [0-7] | [0-7][0-7] | [0-7][0-7][0-7] | [0-7][0-7][0-7][0-7] )
      umask "${SET_UMASK}"
      ;;
    *) fail 11  "umask is invalid (${SET_UMASK})" ;;
  esac

  $BACKUP_COMMAND
  #script will terminate on program failure
}

function usage_short() {
  #outputs usage
  printf "%s -[ioRs]-[B <BID>]\\n" "${0##*/}"
}

function usage() {
  #OUTPUT
  #help information

  usage_short
  printf "\\nAction Parameters (choose one)\\n"
  printf "  -i  Run INITIAL Action\\n"
  printf "  -o  Run ONGOING Action\\n"
  printf "  -R  Run RESTORE Action\\n"
  printf "  -s  Run SHOW    Action\\n"
  printf "  -h  Prints help message and exits\\n"
  printf "Backup ID\\n"
  printf "  -B  sets backup ID\\n"
}

function user_input() {
  #Processes user command line input
  local bid=""
  local action=""

  #Return Variables (expected set)
  # - cfg_BID
  # - cfg_action

  #checking if variable exists (prevent nonlocal variable creation in function)
  local assert
  assert=${cfg_BID?"cfg_BID is not set"}
  assert=${cfg_action?"cfg_action is not set"}

  local -i action_count=0
  while getopts ":ioRshB:" opt; do
    case $opt in
      "i")  action="INITIAL" && action_count+=1 ;;
      "o")  action="ONGOING" && action_count+=1 ;;
      "R")  action="RESTORE" && action_count+=1 ;;
      "s")  action="SHOW"    && action_count+=1 ;;
      "h")  usage ; exit 0 ;;
      "B")
        if [[ -z "$cfg_BID" ]]; then
            bid="${OPTARG}"
        else
          fail 16  "-B already set as ${bid}"
        fi
        ;;
      \?)  fail 13 "Invalid argument entered -${OPTARG}" ;;
      ":") fail 14 "-${OPTARG} requires an argument"     ;;
    esac
  done

  shift $((OPTIND-1)) #remove process commad line options
  if (( ${#} != 0 )) ; then
     action="$*"
    fail 15 "Unknown remaining command line argument (args: ${action} )"
  fi

  if (( action_count == 1 )) ; then
    if [[ -z $bid  ]] ; then
      fail 17 "BID was never set"
    elif [[ $bid =~ ^# ]] ; then
      fail 18 "BID has # in it (${bid})"
    fi
  else
    fail 12 "More or less then one action set (count: ${action_count})"
  fi

  cfg_BID="$bid"
  cfg_action="$action"
  return 0
}

function main() {
  # Reads Global variables
  # - GL_BACKUP_CONFIG
  # - GL_PRMG_CONFIG

  local cfg_BID=""
  local -u cfg_action=""
  local cfg_Program=""
  local cfg_Arguments=""
  local cfg_Source=""
  local cfg_Backup=""
  local cfg_cd=""
  local cfg_UMASK=""
  local backup_command=""

  if (( $# == 0 )) ; then
    usage_short
    fail 19 "Command Line argument Missing"
  else
    user_input "$@"
  fi

  find_config "$cfg_BID" "$cfg_action" "$GL_BACKUP_CONFIG"
  find_prgm "$cfg_Program" "$cfg_action" "$cfg_Arguments" "$cfg_Source" "$cfg_Backup" "$GL_PRMG_CONFIG"
  run_backup "$backup_command" "$cfg_cd" "$cfg_UMASK"
}

if ((BASH_VERSINFO[0] > 4))
then
  fail 21 "Bash-4.0+ is required to run this script"
fi

validate_config_file "$UID" "$GL_BACKUP_CONFIG"
validate_config_file "$UID" "$GL_PRMG_CONFIG"
main "$@"
exit 0